Fix some problems with PAR file generation.
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 May 2012 09:01:03 +0000 (09:01 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 May 2012 09:01:03 +0000 (09:01 +0000)
Added new DebugGuard structure to AliForwardUtil, and
companion macro DGUARD to easily define debug traces.

15 files changed:
PWGLF/FORWARD/analysis2/AliBaseMCTrackDensity.cxx
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.h
PWGLF/FORWARD/analysis2/AliCentralMCCorrectionsTask.cxx
PWGLF/FORWARD/analysis2/AliCentraldNdetaTask.cxx
PWGLF/FORWARD/analysis2/AliFMDEventInspector.cxx
PWGLF/FORWARD/analysis2/AliFMDMCTrackDensity.cxx
PWGLF/FORWARD/analysis2/AliForwardMultiplicityBase.cxx
PWGLF/FORWARD/analysis2/AliForwardMultiplicityTask.cxx
PWGLF/FORWARD/analysis2/AliForwardUtil.cxx
PWGLF/FORWARD/analysis2/AliForwardUtil.h
PWGLF/FORWARD/analysis2/AliSPDMCTrackDensity.cxx
PWGLF/FORWARD/analysis2/AliSPDMCTrackDensity.h
PWGLF/FORWARD/analysis2/MakeAOD.C
PWGLF/FORWARD/analysis2/trains/TrainSetup.C

index 7a8ea55..42cf1ad 100644 (file)
@@ -11,6 +11,7 @@
 #include <iostream>
 #include "AliCollisionGeometry.h"
 #include "AliGenEventHeader.h"
+#include "AliForwardUtil.h"
 #include <TF1.h>
 #include <TGraph.h>
 
@@ -33,6 +34,7 @@ AliBaseMCTrackDensity::AliBaseMCTrackDensity()
     fDebug(false)
 {
   // Default constructor 
+  DGUARD(0,0,"MC track density default construction");
 }
 
 //____________________________________________________________________
@@ -54,6 +56,7 @@ AliBaseMCTrackDensity::AliBaseMCTrackDensity(const char* name)
     fDebug(false)
 {
   // Normal constructor constructor 
+  DGUARD(0,0,"MC track density named construction: %s", name);
 }
 
 //____________________________________________________________________
@@ -75,6 +78,7 @@ AliBaseMCTrackDensity::AliBaseMCTrackDensity(const AliBaseMCTrackDensity& o)
     fDebug(o.fDebug)
 {
   // Normal constructor constructor 
+  DGUARD(0,0,"MC track density copy construction");
 }
 
 //____________________________________________________________________
@@ -82,6 +86,7 @@ AliBaseMCTrackDensity&
 AliBaseMCTrackDensity::operator=(const AliBaseMCTrackDensity& o)
 {
   // Assignment operator 
+  DGUARD(fDebug,3,"MC track density assignmetn");
   if (&o == this) return *this; 
   TNamed::operator=(o);
   fUseOnlyPrimary       = o.fUseOnlyPrimary;
@@ -105,6 +110,7 @@ AliBaseMCTrackDensity::operator=(const AliBaseMCTrackDensity& o)
 void
 AliBaseMCTrackDensity::DefineOutput(TList* l)
 {
+  DGUARD(fDebug,1,"MC track defines output");
   TList* ll = new TList;
   ll->SetName(GetTitle());
   ll->SetOwner();
@@ -148,6 +154,7 @@ AliBaseMCTrackDensity::DefineOutput(TList* l)
 void 
 AliBaseMCTrackDensity::SetupWeights(TList* l)
 {
+  DGUARD(fDebug,2,"MC track setup phi weights");
   fV2Eta = new TF1("v2eta", "gaus", -6, 6);
   fV2Eta->SetParameters(20 * 0.1, 0, 9);
   l->Add(fV2Eta);
@@ -209,6 +216,7 @@ AliBaseMCTrackDensity::StoreParticle(AliMCParticle*       particle,
                                     const AliMCParticle* mother, 
                                     AliTrackReference*   ref) const
 {
+  DGUARD(fDebug,3,"MC track density store particle");
   // Store a particle. 
   if (!ref) return 0;
 
@@ -285,6 +293,7 @@ AliBaseMCTrackDensity::GetMother(Int_t     iTr,
 Bool_t
 AliBaseMCTrackDensity::GetCollisionParameters(const AliMCEvent& event)
 { 
+  DGUARD(fDebug,3,"MC track density get collision parameters");
   AliCollisionGeometry* hd = 
     dynamic_cast<AliCollisionGeometry*>(event.GenEventHeader());
   fPhiR = (hd ? hd->ReactionPlaneAngle() : 0.);
@@ -298,6 +307,7 @@ AliBaseMCTrackDensity::ProcessTrack(AliMCParticle* particle,
                                    const AliMCParticle* mother)
 {
   // Check the returned particle 
+  DGUARD(fDebug,3,"MC track density Process a track");
   if (!particle) return false;
     
   Int_t              nTrRef = particle->GetNumberOfTrackReferences();
@@ -355,6 +365,7 @@ AliBaseMCTrackDensity::ProcessTracks(const AliMCEvent& event,
   // Return:
   //    True on succes, false otherwise 
   //
+  DGUARD(fDebug,3,"MC track density Process a tracks");
   fVz = vz;
   GetCollisionParameters(event);
   
index eebc442..c700385 100644 (file)
@@ -44,6 +44,7 @@ AliBasedNdetaTask::AliBasedNdetaTask()
   // 
   // Constructor
   // 
+  DGUARD(0,0,"Default construction of AliBasedNdetaTask");
 }
 
 //____________________________________________________________________
@@ -75,6 +76,7 @@ AliBasedNdetaTask::AliBasedNdetaTask(const char* name)
   // 
   // Constructor
   // 
+  DGUARD(0,0,"Named construction of AliBasedNdetaTask: %s", name);
   fListOfCentralities = new TObjArray(1);
   
   // Set the normalisation scheme 
@@ -113,7 +115,9 @@ AliBasedNdetaTask::AliBasedNdetaTask(const AliBasedNdetaTask& o)
     fTriggerString(o.fTriggerString),
     fFinalMCCorrFile(o.fFinalMCCorrFile), 
     fIsESD(o.fIsESD)
-{}
+{
+  DGUARD(0,0,"Copy construction of AliBasedNdetaTask");
+}
 
 //____________________________________________________________________
 AliBasedNdetaTask::~AliBasedNdetaTask()
@@ -121,6 +125,7 @@ AliBasedNdetaTask::~AliBasedNdetaTask()
   // 
   // Destructor
   // 
+  DGUARD(fDebug,3,"Destruction of AliBasedNdetaTask");
   if (fSums) { 
     fSums->Delete();
     delete fSums;
@@ -135,8 +140,21 @@ AliBasedNdetaTask::~AliBasedNdetaTask()
 
 //________________________________________________________________________
 void 
+AliBasedNdetaTask::SetDebugLevel(Int_t lvl)
+{
+  AliAnalysisTaskSE::SetDebugLevel(lvl);
+  for (Int_t i = 0; i < fListOfCentralities->GetEntries(); i++) { 
+    CentralityBin* bin = 
+      static_cast<CentralityBin*>(fListOfCentralities->At(i));
+    bin->SetDebugLevel(lvl);
+  }
+}
+
+//________________________________________________________________________
+void 
 AliBasedNdetaTask::SetCentralityAxis(UShort_t n, Short_t* bins)
 {
+  DGUARD(fDebug,3,"Set centrality axis, %d bins", n);
   if (!fCentAxis) { 
     fCentAxis = new TAxis();
     fCentAxis->SetName("centAxis");
@@ -159,7 +177,9 @@ AliBasedNdetaTask::AddCentralityBin(UShort_t at, Short_t low, Short_t high)
   //    low  Low cut
   //    high High cut
   //
+  DGUARD(fDebug,3,"Add a centrality bin [%f,%f] @ %d", low, high, at);
   CentralityBin* bin = MakeCentralityBin(GetName(), low, high);
+  bin->SetDebugLevel(fDebug);
   fListOfCentralities->AddAtAndExpand(bin, at);
 }
 
@@ -179,6 +199,7 @@ AliBasedNdetaTask::MakeCentralityBin(const char* name,
   // Return:
   //    A newly created centrality bin 
   //
+  DGUARD(fDebug,3,"Make a centrality bin [%f,%f]: %s", low, high, name);
   return new CentralityBin(name, low, high);
 }
 //________________________________________________________________________
@@ -188,6 +209,7 @@ AliBasedNdetaTask::SetNormalizationScheme(const char* what)
   // 
   // Set normalisation scheme 
   // 
+  DGUARD(fDebug,3,"Set the normalization scheme: %s", what);
   UShort_t    scheme = 0;
   TString     twhat(what);
   twhat.ToUpper();
@@ -220,6 +242,7 @@ AliBasedNdetaTask::SetNormalizationScheme(const char* what)
 void 
 AliBasedNdetaTask::SetNormalizationScheme(UShort_t scheme) 
 {
+  DGUARD(fDebug,3,"Set the normalization scheme: 0x%x", scheme);
   fNormalizationScheme = scheme; 
   TString tit = "";
   if (scheme == kFull) tit = "FULL"; 
@@ -245,12 +268,14 @@ AliBasedNdetaTask::SetTriggerMask(const char* mask)
   // Parameters:
   //    mask Trigger mask
   //
+  DGUARD(fDebug,3,"Set the trigger mask: %s", mask);
   SetTriggerMask(AliAODForwardMult::MakeTriggerMask(mask));
 }
 //________________________________________________________________________
 void 
 AliBasedNdetaTask::SetTriggerMask(UShort_t mask) 
 { 
+  DGUARD(fDebug,3,"Set the trigger mask: 0x%0x", mask);
   fTriggerMask = mask; 
   TString tit(AliAODForwardMult::GetTriggerString(mask));
   tit = tit.Strip(TString::kBoth);
@@ -270,6 +295,7 @@ AliBasedNdetaTask::SetShapeCorrection(const TH1* c)
   // Parameters:
   //    h Correction
   //
+  DGUARD(fDebug,3,"Set the shape correction: %p", c);
   if (!c) return;
   fShapeCorr = static_cast<TH1*>(c->Clone());
   fShapeCorr->SetDirectory(0);
@@ -284,6 +310,7 @@ AliBasedNdetaTask::UserCreateOutputObjects()
   //
   // This is called once per slave process 
   //
+  DGUARD(fDebug,1,"Create user ouput object");
   fSums = new TList;
   fSums->SetName(Form("%s_sums", GetName()));
   fSums->SetOwner();
@@ -340,6 +367,7 @@ AliBasedNdetaTask::GetAODEvent(bool isESD)
   // 
   // Return: 
   //   Pointer to AOD event or null
+  DGUARD(fDebug,1,"Get the AOD event (%s analysis)", isESD ? "ESD" : "AOD");
   AliAODEvent* aod = 0;
 
   if (!isESD) aod = dynamic_cast<AliAODEvent*>(InputEvent());
@@ -360,6 +388,7 @@ AliBasedNdetaTask::UserExec(Option_t *)
   //    option Not used
   //
   // Main loop
+  DGUARD(fDebug,1,"Analyse the AOD event");
   AliAODEvent* aod = GetAODEvent(fIsESD);
   if (!aod) return;
 
@@ -583,6 +612,7 @@ AliBasedNdetaTask::Terminate(Option_t *)
   //
   // Draw result to screen, or perform fitting, normalizations Called
   // once at the end of the query
+  DGUARD(fDebug,1,"Process final merged results");
 
   fSums = dynamic_cast<TList*> (GetOutputData(1));
   if(!fSums) {
@@ -729,6 +759,8 @@ void
 AliBasedNdetaTask::LoadNormalizationData(UShort_t sys, UShort_t energy)
 {
   // Load the normalisation data for dN/deta for pp INEL, INEL>0, and NSD
+  DGUARD(fDebug,1,"Load the normalization data for sys=%d, energy=%d",
+        sys, energy);
   TString type("pp");
   TString snn("900");
   if(energy == 7000) snn.Form("7000");
@@ -1007,6 +1039,7 @@ AliBasedNdetaTask::FlipHollowStyle(Int_t style)
 void
 AliBasedNdetaTask::Sum::Init(TList* list, const TH2D* data, Int_t col)
 {
+  DGUARD(fDebug,1,"Initializing sums with %s", data->GetName());
   TString n(GetHistName(0));
   TString n0(GetHistName(1));
   const char* postfix = GetTitle();
@@ -1053,7 +1086,7 @@ AliBasedNdetaTask::Sum::GetHistName(Int_t what) const
 void
 AliBasedNdetaTask::Sum::Add(const TH2D* data, Bool_t isZero)
 {
-
+  DGUARD(fDebug,2,"Adding %s to sums", data->GetName());
   if (isZero) fSum0->Add(data);
   else        fSum->Add(data);
   fEvents->Fill(isZero ? 1 : 0);
@@ -1070,6 +1103,7 @@ AliBasedNdetaTask::Sum::GetSum(const TList* input,
                               Bool_t       rootProj, 
                               Bool_t       corrEmpty) const
 {
+  DGUARD(fDebug,2,"Get sums from input list %s", input->GetName());
   TH2D* sum      = static_cast<TH2D*>(input->FindObject(GetHistName(0)));
   TH2D* sum0     = static_cast<TH2D*>(input->FindObject(GetHistName(1)));
   TH1I* events   = static_cast<TH1I*>(input->FindObject(GetHistName(2)));
@@ -1179,11 +1213,13 @@ AliBasedNdetaTask::CentralityBin::CentralityBin()
     fTriggers(0), 
     fLow(0), 
     fHigh(0),
-    fDoFinalMCCorrection(false)
+    fDoFinalMCCorrection(false), 
+    fDebug(0)
 {
   // 
   // Constructor 
   //
+  DGUARD(0,0,"Centrality bin default construction");
 }
 //____________________________________________________________________
 AliBasedNdetaTask::CentralityBin::CentralityBin(const char* name, 
@@ -1196,7 +1232,8 @@ AliBasedNdetaTask::CentralityBin::CentralityBin(const char* name,
     fTriggers(0),
     fLow(low), 
     fHigh(high),
-    fDoFinalMCCorrection(false)
+    fDoFinalMCCorrection(false), 
+    fDebug(0)
 {
   // 
   // Constructor 
@@ -1206,6 +1243,7 @@ AliBasedNdetaTask::CentralityBin::CentralityBin(const char* name,
   //    low  Lower centrality cut in percent 
   //    high Upper centrality cut in percent 
   //
+  DGUARD(0,0,"Named Centrality bin construction: %s [%d,%d]", name);
   if (low <= 0 && high <= 0) { 
     fLow  = 0; 
     fHigh = 0;
@@ -1227,7 +1265,8 @@ AliBasedNdetaTask::CentralityBin::CentralityBin(const CentralityBin& o)
     fTriggers(o.fTriggers), 
     fLow(o.fLow), 
     fHigh(o.fHigh),
-    fDoFinalMCCorrection(o.fDoFinalMCCorrection)
+    fDoFinalMCCorrection(o.fDoFinalMCCorrection), 
+    fDebug(o.fDebug)
 {
   // 
   // Copy constructor 
@@ -1235,6 +1274,7 @@ AliBasedNdetaTask::CentralityBin::CentralityBin(const CentralityBin& o)
   // Parameters:
   //    other Object to copy from 
   //
+  DGUARD(0,0,"Copy Centrality bin construction");
 }
 //____________________________________________________________________
 AliBasedNdetaTask::CentralityBin::~CentralityBin()
@@ -1242,6 +1282,7 @@ AliBasedNdetaTask::CentralityBin::~CentralityBin()
   // 
   // Destructor 
   //
+  DGUARD(fDebug,3,"Centrality bin desctruction");
   if (fSums) fSums->Delete();
   if (fOutput) fOutput->Delete();
 }
@@ -1259,6 +1300,7 @@ AliBasedNdetaTask::CentralityBin::operator=(const CentralityBin& o)
   // Return:
   //    Reference to this 
   //
+  DGUARD(fDebug,3,"Centrality bin assignment");
   if (&o == this) return *this; 
   SetName(o.GetName());
   SetTitle(o.GetTitle());
@@ -1307,6 +1349,7 @@ AliBasedNdetaTask::CentralityBin::CreateOutputObjects(TList* dir)
   // Parameters:
   //    dir   Parent list
   //
+  DGUARD(fDebug,1,"Create centrality bin output objects");
   fSums = new TList;
   fSums->SetName(GetListName());
   fSums->SetOwner();
@@ -1318,6 +1361,15 @@ AliBasedNdetaTask::CentralityBin::CreateOutputObjects(TList* dir)
 }
 //____________________________________________________________________
 void
+AliBasedNdetaTask::CentralityBin::SetDebugLevel(Int_t lvl)
+{
+  fDebug = lvl;
+  if (fSum) fSum->fDebug = lvl;
+  if (fSumMC) fSumMC->fDebug = lvl;
+}
+
+//____________________________________________________________________
+void
 AliBasedNdetaTask::CentralityBin::CreateSums(const TH2D* data, const TH2D* mc)
 {
   // 
@@ -1327,9 +1379,11 @@ AliBasedNdetaTask::CentralityBin::CreateSums(const TH2D* data, const TH2D* mc)
   //    data  Data histogram to clone 
   //    mc    (optional) MC histogram to clone 
   //
+  DGUARD(fDebug,1,"Create centrality bin sums from %s", data->GetName());
   if (data) {
     fSum = new Sum(GetName(),"");
     fSum->Init(fSums, data, GetColor());
+    fSum->fDebug = fDebug;
   }
 
   // If no MC data is given, then do not create MC sum histogram 
@@ -1337,6 +1391,7 @@ AliBasedNdetaTask::CentralityBin::CreateSums(const TH2D* data, const TH2D* mc)
 
   fSumMC = new Sum(GetName(), "MC");
   fSumMC->Init(fSums, mc, GetColor());
+  fSumMC->fDebug = fDebug;
 }
 
 //____________________________________________________________________
@@ -1356,6 +1411,7 @@ AliBasedNdetaTask::CentralityBin::CheckEvent(const AliAODForwardMult* forward,
   //
   if (!forward) return false;
 
+  DGUARD(fDebug,2,"Check the event");
   // We do not check for centrality here - it's already done 
   return forward->CheckEvent(triggerMask, vzMin, vzMax, 0, 0, fTriggers);
 }
@@ -1379,6 +1435,8 @@ AliBasedNdetaTask::CentralityBin::ProcessEvent(const AliAODForwardMult* forward,
   //    data        Data histogram 
   //    mc          MC histogram
   //
+  DGUARD(fDebug,1,"Process one event for %s a given centrality bin", 
+        data->GetName());
   if (!CheckEvent(forward, triggerMask, vzMin, vzMax)) return;
   if (!data) return;
   if (!fSum) CreateSums(data, mc);
@@ -1403,6 +1461,7 @@ AliBasedNdetaTask::CentralityBin::Normalization(const TH1I& t,
   //    trigEff From MC
   //    ntotal  On return, contains the number of events. 
   //
+  DGUARD(fDebug,1,"Normalize centrality bin with %s", t.GetName());
   Double_t nAll        = t.GetBinContent(AliAODForwardMult::kBinAll);
   Double_t nB          = t.GetBinContent(AliAODForwardMult::kBinB);
   Double_t nA          = t.GetBinContent(AliAODForwardMult::kBinA);
@@ -1575,6 +1634,7 @@ AliBasedNdetaTask::CentralityBin::MakeResult(const TH2D* sum,
   //     rebin      Whether to rebin
   //     cutEdges   Whether to cut edges when rebinning 
   //
+  DGUARD(fDebug,1,"Make centrality bin result from %s", sum->GetName());
   TH2D* copy    = static_cast<TH2D*>(sum->Clone(Form("d2Ndetadphi%s%s", 
                                                     GetName(), postfix)));
   TH1D* accNorm = ProjectX(sum, Form("norm%s%s",GetName(), postfix), 0, 0, 
@@ -1676,6 +1736,7 @@ AliBasedNdetaTask::CentralityBin::End(TList*      sums,
   //    cutEdges    Whether to cut edges when rebinning
   //    triggerMask Trigger mask 
   //
+  DGUARD(fDebug,1,"End centrality bin procesing");
 
   fSums = dynamic_cast<TList*>(sums->FindObject(GetListName()));
   if(!fSums) {
index 2ec30a6..7f6ddc9 100644 (file)
@@ -99,6 +99,7 @@ public:
    * @{ 
    * @name Task configuration 
    */
+  virtual void SetDebugLevel(Int_t level);
   /** 
    * Set the vertex range to use 
    * 
@@ -388,10 +389,11 @@ protected:
     TH2D* fSum;     // Sum of non-zero events
     TH2D* fSum0;    // Sum of zero events 
     TH1I* fEvents;  // Distribution of events 
+    Int_t fDebug;   // Debug level
     /** 
      * I/O Constructor - do not use
      */    
-    Sum() : fSum(0), fSum0(0), fEvents(0) {}
+    Sum() : fSum(0), fSum0(0), fEvents(0), fDebug(0) {}
     /** 
      * Constructor 
      * 
@@ -402,7 +404,8 @@ protected:
       : TNamed(name,postfix), 
        fSum(0), 
        fSum0(0), 
-       fEvents(0) 
+       fEvents(0), 
+       fDebug(0) 
     {}
     /** 
      * Copy constructor
@@ -413,7 +416,8 @@ protected:
       : TNamed(o), 
        fSum(o.fSum), 
        fSum0(o.fSum0), 
-       fEvents(o.fEvents) 
+       fEvents(o.fEvents), 
+       fDebug(o.fDebug) 
     {}
     /** 
      * Assignment operator 
@@ -741,6 +745,7 @@ protected:
     TH1* GetResult(Int_t rebin, Bool_t sym, 
                   const char* postfix="") const;
 
+    void SetDebugLevel(Int_t lvl);
   protected:
     /** 
      * Create sum histogram 
@@ -771,8 +776,9 @@ protected:
     UShort_t fLow;       // Lower limit (inclusive)
     UShort_t fHigh;      // Upper limit (exclusive)
     Bool_t   fDoFinalMCCorrection; //Do final MC correction
-    
-    ClassDef(CentralityBin,1); // A centrality bin 
+    Int_t    fDebug;    // Debug level 
+
+    ClassDef(CentralityBin,2); // A centrality bin 
   };
   TList*          fSums;         // Container of sums 
   TList*          fOutput;       // Container of outputs 
index 493d99e..b1b7574 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliMCEvent.h"
 #include "AliAODForwardMult.h"
 #include "AliCentralCorrSecondaryMap.h"
+#include "AliForwardUtil.h"
 #include <TH1.h>
 #include <TH2D.h>
 #include <TDirectory.h>
@@ -76,6 +77,7 @@ AliCentralMCCorrectionsTask::AliCentralMCCorrectionsTask()
   // Parameters:
   //    name Name of task 
   //
+  DGUARD(fDebug,0,"Default construction of AliCentralMCCorrectionsTask");
 }
 
 //____________________________________________________________________
@@ -99,6 +101,7 @@ AliCentralMCCorrectionsTask::AliCentralMCCorrectionsTask(const char* name)
   // Parameters:
   //    name Name of task 
   //
+  DGUARD(fDebug,0,"Named construction of AliCentralMCCorrectionsTask: %s",name);
   DefineOutput(1, TList::Class());
   DefineOutput(2, TList::Class());
 }
@@ -124,6 +127,7 @@ AliCentralMCCorrectionsTask::AliCentralMCCorrectionsTask(const AliCentralMCCorre
   // Parameters:
   //    o Object to copy from 
   //
+  DGUARD(fDebug,0,"Copy construction of AliCentralMCCorrectionsTask");
 }
 
 //____________________________________________________________________
@@ -139,6 +143,7 @@ AliCentralMCCorrectionsTask::operator=(const AliCentralMCCorrectionsTask& o)
   // Return:
   //    Reference to this object 
   //
+  DGUARD(fDebug,3,"Assignment of AliCentralMCCorrectionsTask");
   if (&o == this) return *this; 
   fInspector         = o.fInspector;
   fTrackDensity      = o.fTrackDensity;
@@ -162,6 +167,7 @@ AliCentralMCCorrectionsTask::Init()
   // Initialize the task 
   // 
   //
+  DGUARD(fDebug,1,"Initialize AliCentralMCCorrectionsTask");
 }
 
 //____________________________________________________________________
@@ -177,6 +183,8 @@ AliCentralMCCorrectionsTask::SetVertexAxis(Int_t nBin, Double_t min,
   //    vzMin Least @f$z@f$ coordinate of interation point
   //    vzMax Largest @f$z@f$ coordinate of interation point
   //
+  DGUARD(fDebug,3,"Set vertex axis AliCentralMCCorrectionsTask [%d,%f,%f]",
+        nBin, min, max);
   if (max < min) { 
     Double_t tmp = min;
     min          = max;
@@ -213,6 +221,8 @@ AliCentralMCCorrectionsTask::SetEtaAxis(Int_t nBin, Double_t min, Double_t max)
   //    vzMin Least @f$\eta@f$ 
   //    vzMax Largest @f$\eta@f$ 
   //
+  DGUARD(fDebug,3,"Set eta axis AliCentralMCCorrectionsTask [%d,%f,%f]",
+        nBin, min, max);
   if (max < min) { 
     Double_t tmp = min;
     min          = max;
@@ -241,6 +251,7 @@ AliCentralMCCorrectionsTask::SetEtaAxis(const TAxis& axis)
 void
 AliCentralMCCorrectionsTask::DefineBins(TList* l)
 {
+  DGUARD(fDebug,1,"Define bins in AliCentralMCCorrectionsTask");
   if (!fVtxBins) fVtxBins = new TObjArray(fVtxAxis.GetNbins(), 1);
   if (fVtxBins->GetEntries() > 0) return;
 
@@ -262,6 +273,7 @@ AliCentralMCCorrectionsTask::UserCreateOutputObjects()
   // Create output objects 
   // 
   //
+  DGUARD(fDebug,1,"Create user output for AliCentralMCCorrectionsTask");
   fList = new TList;
   fList->SetOwner();
   fList->SetName(Form("%sSums", GetName()));
@@ -335,6 +347,7 @@ AliCentralMCCorrectionsTask::UserExec(Option_t*)
   //    option Not used
   //  
 
+  DGUARD(fDebug,1,"AliCentralMCCorrectionsTask process an event");
   // Get the input data - MC event
   AliMCEvent*  mcEvent = MCEvent();
   if (!mcEvent) { 
@@ -422,6 +435,7 @@ AliCentralMCCorrectionsTask::Terminate(Option_t*)
   // Parameters:
   //    option Not used 
   //
+  DGUARD(fDebug,1,"AliCentralMCCorrectionsTask analyse merged output");
 
   fList = dynamic_cast<TList*>(GetOutputData(1));
   if (!fList) {
index 3b201fe..7204b50 100644 (file)
@@ -22,6 +22,7 @@ ClassImp(AliCentraldNdetaTask)
 AliCentraldNdetaTask::AliCentraldNdetaTask(const char*)
   : AliBasedNdetaTask("Central") 
 { 
+  DGUARD(fDebug,0,"Named construction of AliCentraldNdetaTask");
   fSymmetrice = false; 
   fCorrEmpty  = false;
   SetTitle("Central");
@@ -32,6 +33,7 @@ TH2D*
 AliCentraldNdetaTask::GetHistogram(const AliAODEvent* aod, Bool_t mc) 
 {
   // Get objects from the event structure 
+  DGUARD(fDebug,2,"Get our histogram for AliCentraldNdetaTask");
   TObject* obj = 0;
   if (mc) obj = aod->FindListObject("CentralClustersMC");
   else    obj = aod->FindListObject("CentralClusters");
index 7b493af..2fb78fa 100644 (file)
@@ -247,6 +247,7 @@ AliFMDEventInspector::Init(const TAxis& vtxAxis)
   // Parameters:
   //   vtxAxis Vertex axis in use 
   //
+  AliInfo("Initialising the event inspector");
   
   // -1.5 -0.5 0.5 1.5 ... 89.5 ... 100.5
   // ----- 92 number --------- ---- 1 ---
@@ -691,6 +692,10 @@ AliFMDEventInspector::ReadTriggers(const AliESDEvent* esd, UInt_t& triggers,
   if (offline) {
     triggers |= AliAODForwardMult::kOffline;
     triggers |= AliAODForwardMult::kInel;
+    if (!fHTriggers) { 
+      AliWarning("Histogram of triggers not defined - has init been called");
+      return false;
+    }
     fHTriggers->Fill(kOffline+0.5);
 
     // If this is inel, see if we have a tracklet 
index 5bbe62c..a5cb9b5 100644 (file)
@@ -1,9 +1,9 @@
 #include "AliFMDMCTrackDensity.h"
-#include <AliESDFMD.h>
-#include <AliTrackReference.h>
+#include "AliESDFMD.h"
+#include "AliTrackReference.h"
 #include <TMath.h>
 #include "AliFMDStripIndex.h"
-#include <AliLog.h>
+#include "AliLog.h"
 #include <TH2D.h>
 #include <TH1D.h>
 #include <TList.h>
index 93bcf06..36cafe7 100644 (file)
@@ -39,6 +39,7 @@ AliForwardMultiplicityBase::AliForwardMultiplicityBase(const char* name)
     fFirstEvent(true),
     fCorrManager(0)
 {
+  DGUARD(0,0,"Named Construction of AliForwardMultiplicityBase %s",name);
   // Set our persistent pointer 
   fCorrManager = &AliForwardCorrectionManager::Instance();
   fBranchNames = 
@@ -50,6 +51,7 @@ AliForwardMultiplicityBase::AliForwardMultiplicityBase(const char* name)
 AliForwardMultiplicityBase& 
 AliForwardMultiplicityBase::operator=(const AliForwardMultiplicityBase& o)
 {
+  DGUARD(fDebug,2,"Assignment to AliForwardMultiplicityBase");
   if (&o == this) return *this;
   fEnableLowFlux = o.fEnableLowFlux;
   fFirstEvent    = o.fFirstEvent;
@@ -71,6 +73,7 @@ AliForwardMultiplicityBase::CheckCorrections(UInt_t what) const
   // Return:
   //    true if all present, false otherwise
   //  
+  DGUARD(fDebug,1,"Checking corrections 0x%x", what);
 
   AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
   // Check that we have the energy loss fits, needed by 
@@ -127,6 +130,7 @@ AliForwardMultiplicityBase::ReadCorrections(const TAxis*& pe,
   // Read corrections
   //
   //
+
   UInt_t what = AliForwardCorrectionManager::kAll;
   if (!fEnableLowFlux)
     what ^= AliForwardCorrectionManager::kDoubleHit;
@@ -136,6 +140,7 @@ AliForwardMultiplicityBase::ReadCorrections(const TAxis*& pe,
     what ^= AliForwardCorrectionManager::kAcceptance;
   if (!GetCorrections().IsUseMergingEfficiency())
     what ^= AliForwardCorrectionManager::kMergingEfficiency;
+  DGUARD(fDebug,1,"Read corrections 0x%x", what);
 
   AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
   if (!fcm.Init(GetEventInspector().GetCollisionSystem(),
@@ -168,6 +173,7 @@ AliForwardMultiplicityBase::GetESDEvent()
   //
   // Get the ESD event. IF this is the first event, initialise
   //
+  DGUARD(fDebug,1,"Get the ESD event");
   AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
   if (!esd) {
     AliWarning("No ESD event found for input event");
@@ -202,6 +208,7 @@ void
 AliForwardMultiplicityBase::MarkEventForStore() const
 {
   // Make sure the AOD tree is filled 
+  DGUARD(fDebug,3,"Mark AOD event for storage");
   AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
   AliAODHandler*      ah = 
     dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
@@ -225,6 +232,8 @@ AliForwardMultiplicityBase::MakeRingdNdeta(const TList* input,
   // 
   // Note, that the distributions are normalised to the number of
   // observed events only - they should be corrected for 
+  DGUARD(fDebug,3,"Make first-shot ring dN/deta");
+
   if (!input) return;
   TList* list = static_cast<TList*>(input->FindObject(inName));
   if (!list) { 
index cfe4c9b..e297db0 100644 (file)
@@ -47,6 +47,7 @@ AliForwardMultiplicityTask::AliForwardMultiplicityTask()
   // 
   // Constructor
   //
+  DGUARD(0,0,"Default construction of AliForwardMultiplicityTask");
 }
 
 //____________________________________________________________________
@@ -72,6 +73,7 @@ AliForwardMultiplicityTask::AliForwardMultiplicityTask(const char* name)
   // Parameters:
   //    name Name of task 
   //
+  DGUARD(0,0,"named construction of AliForwardMultiplicityTask: %s", name);
   DefineOutput(1, TList::Class());
 }
 
@@ -98,6 +100,7 @@ AliForwardMultiplicityTask::AliForwardMultiplicityTask(const AliForwardMultiplic
   // Parameters:
   //    o Object to copy from 
   //
+  DGUARD(0,0,"Copy construction of AliForwardMultiplicityTask");
   DefineOutput(1, TList::Class());
 }
 
@@ -114,6 +117,7 @@ AliForwardMultiplicityTask::operator=(const AliForwardMultiplicityTask& o)
   // Return:
   //    Reference to this object 
   //
+  DGUARD(fDebug,3,"Assignment to AliForwardMultiplicityTask");
   if (&o == this) return *this;
   AliForwardMultiplicityBase::operator=(o);
 
@@ -159,6 +163,7 @@ AliForwardMultiplicityTask::InitializeSubs()
   // Initialise the sub objects and stuff.  Called on first event 
   // 
   //
+  DGUARD(fDebug,1,"Initialize sub-algorithms");
   const TAxis* pe = 0;
   const TAxis* pv = 0;
 
@@ -208,6 +213,7 @@ AliForwardMultiplicityTask::UserCreateOutputObjects()
   // Create output objects 
   // 
   //
+  DGUARD(fDebug,1,"Create user ouput");
   fList = new TList;
   fList->SetOwner();
 
@@ -242,6 +248,7 @@ AliForwardMultiplicityTask::UserExec(Option_t*)
   //    option Not used
   //  
 
+  DGUARD(fDebug,1,"Process the input event");
   // static Int_t cnt = 0;
   // cnt++;
   // Get the input data 
@@ -334,6 +341,7 @@ AliForwardMultiplicityTask::Terminate(Option_t*)
   // Parameters:
   //    option Not used 
   //
+  DGUARD(fDebug,1,"Processing the merged results");
 
   TList* list = dynamic_cast<TList*>(GetOutputData(1));
   if (!list) {
index 07d5ca5..b8ef2d1 100644 (file)
@@ -17,6 +17,7 @@
 #include <TFitResult.h>
 #include <TMath.h>
 #include <TError.h>
+#include <TROOT.h>
 
 //====================================================================
 UShort_t
@@ -925,6 +926,41 @@ AliForwardUtil::RingHistos::GetOutputHist(const TList* d, const char* name) cons
   return static_cast<TH1*>(d->FindObject(name));
 }
 
+//====================================================================
+AliForwardUtil::DebugGuard::DebugGuard(Int_t lvl, Int_t msgLvl, 
+                                      const char* format, ...)
+  : fMsg("")
+{
+  if (lvl < msgLvl) return; 
+  va_list ap;
+  va_start(ap, format);
+  static char buf[512];
+  Int_t n = gROOT->GetDirLevel() + 1;
+  for (Int_t i = 0; i < n; i++) buf[i] = ' ';
+  vsnprintf(&(buf[n]), 511-n, format, ap);
+  buf[511] = '\0';
+  fMsg = buf;
+  va_end(ap);
+  Format(true);
+}
+//____________________________________________________________________
+AliForwardUtil::DebugGuard::~DebugGuard()
+{
+  if (fMsg.IsNull()) return;
+  Format(false);
+}
+//____________________________________________________________________
+void
+AliForwardUtil::DebugGuard::Format(bool in)
+{
+  fMsg[0] = in ? '>' : '<';
+  AliLog::Debug(0, fMsg, "PWGLF-forward", "", "", "", 0);
+  if (in) gROOT->IncreaseDirLevel();
+  else    gROOT->DecreaseDirLevel();
+}
+
+
+
 //
 // EOF
 //
index 0ede52d..0748a6a 100644 (file)
@@ -626,6 +626,16 @@ public:
     ClassDef(RingHistos,1) 
   };
   /* @} */
+
+  //__________________________________________________________________
+  struct DebugGuard 
+  {
+    DebugGuard(Int_t lvl, Int_t msgLvl, const char* format, ...);
+    ~DebugGuard();
+  private:
+    void Format(bool in);
+    TString fMsg;
+  };
 private:
   AliForwardUtil() {}
   AliForwardUtil(const AliForwardUtil& o) : TObject(o) {}
@@ -636,6 +646,12 @@ private:
   ClassDef(AliForwardUtil,1) // Utilities - do not make object
 };
 
+#ifdef LOG_NO_DEBUG
+# define DGUARD(L,N,F,...) do {} while(false) 
+#else
+# define DGUARD(L,N,F,...)                                     \
+  AliForwardUtil::DebugGuard _GUARD(L,N,F, ## __VA_ARGS__)
+#endif
 #endif
 // Local Variables:
 //  mode: C++
index c3b28df..ca98049 100644 (file)
@@ -1,6 +1,6 @@
 #include "AliSPDMCTrackDensity.h"
-#include <AliMCEvent.h>
-#include <AliTrackReference.h>
+#include "AliMCEvent.h"
+#include "AliTrackReference.h"
 #include <TMath.h>
 #include <AliLog.h>
 #include <TROOT.h>
index b3c2806..ae90529 100644 (file)
@@ -1,6 +1,6 @@
 #ifndef ALISPDMCTRACKDENSITY_MC
 #define ALISPDMCTRACKDENSITY_MC
-#include <AliBaseMCTrackDensity.h>
+#include "AliBaseMCTrackDensity.h"
 
 /**
  * A class to calculate the particle density from track references.
index 5aecf53..db980ab 100644 (file)
@@ -44,7 +44,8 @@ void MakeAOD(const char* esddir,
             Bool_t      mc         = false,
             Bool_t      centrality = true,
             const char* name       = 0,
-            bool        debug      = false)
+            bool        debug      = false, 
+            bool        local      = false)
 {
   // --- Possibly use plug-in for this -------------------------------
   if ((name && name[0] != '\0') && gSystem->Load("libRAliEn") >= 0) {
@@ -59,7 +60,8 @@ void MakeAOD(const char* esddir,
     t.SetDataSet("");
     t.SetProofServer(Form("workers=%d",proof));
     t.SetUseGDB(debug);
-    t.Run(proof > 0 ? "PROOF" : "LOCAL", "FULL", nEvents, mc, proof > 0);
+    t.Run(proof > 0 ? "PROOF" : 
+         local ? "LOCAL" : "GRID", "FULL", nEvents, mc, proof > 0);
     return;
   }
 
index 9ffacaa..dbf71c1 100644 (file)
@@ -172,6 +172,10 @@ struct TrainSetup
     kFull
   };
 
+
+  //__________________________________________________________________
+  virtual ~TrainSetup() {}
+
   //__________________________________________________________________
   /** 
    * Constructor 
@@ -345,6 +349,8 @@ struct TrainSetup
    * @param v Version string of AliROOT 
    */
   void SetAliROOTVersion(const char* v) { fAliRootVersion = v; }
+
+  void SetAliEnAPIVersion(const char* v) { fAliEnAPIVersion = v; }
   //__________________________________________________________________
   /** 
    * Set the PROOF server URL
@@ -504,7 +510,8 @@ struct TrainSetup
     char* templ  = new char[ltempl];
     snprintf(templ, ltempl, "%s/trainXXXXXX", tmpdir.Data());
     if (!mkdtemp(templ)) {
-      Error("MakeScriptPAR", "Failed to generate temporary directory from template %s", 
+      Error("MakeScriptPAR", 
+           "Failed to generate temporary directory from template %s", 
            templ);
       return false;
     }
@@ -544,52 +551,53 @@ struct TrainSetup
       }
       
       // Make our build file 
-      std::ofstream build(Form("%s/PROOF-INF/BUILD.sh", dir.Data()));
-      if (!build) 
-       throw TString::Format("Failed to open build shell script");
-      build << "#!/bin/sh\n"
-           << "echo BUILD.sh@`hostname`: Building " << base << "\n"
-           << "root.exe -l -b -q PROOF-INF/BUILD.C 2>&1 | tee " << base << ".log\n"
-           << "echo BUILD.sh@`hostname`: done: $?\n"
-           << std::endl;
-      build.close();
+      std::ofstream b(Form("%s/PROOF-INF/BUILD.sh", dir.Data()));
+      if (!b) 
+       throw TString::Format("Failed to open b shell script");
+      b << "#!/bin/sh\n"
+       << "echo BUILD.sh@`hostname`: Building " << base << "\n"
+       << "root.exe -l -b -q PROOF-INF/BUILD.C 2>&1 | tee " << base << ".log\n"
+       << "echo BUILD.sh@`hostname`: done: $?\n"
+       << std::endl;
+      b.close();
       if (gSystem->Chmod(Form("%s/PROOF-INF/BUILD.sh", dir.Data()), 0755) != 0)
        throw TString::Format("Failed to set exectuable flags on "
                              "%s/PROOF-INF/BUILD.sh", dir.Data());
       
-      std::ofstream util(Form("%s/PROOF-INF/UTIL.C", dir.Data()));
-      if (!util) 
+      std::ofstream u(Form("%s/PROOF-INF/UTIL.C", dir.Data()));
+      if (!u) 
        throw TString::Format("Failed to open utility script");
-      util << "void LoadROOTLibs() {\n"
-          << "  gSystem->Load(\"libVMC\");\n"
-          << "  gSystem->Load(\"libNet\");\n"
-          << "  gSystem->Load(\"libTree\");\n"
-          << "  gSystem->Load(\"libPhysics\");\n"
-          << "  gSystem->Load(\"libMinuit\");\n"
-          << "}\n\n"
-          << "void AddDep(const char* env) {\n"
-          << "  TString val(gSystem->Getenv(Form(\"%s_INCLUDE\",env)));\n"
-          << "  if (val.IsNull())\n"
-          << "    Warning(\"Add\",\"%s_INCLUDE not defined\", env);\n"
-          << "  else {\n"
-          << "    gSystem->AddIncludePath(Form(\"-I../%s\",val.Data()));\n"
-          << "  }\n"
-          << "}\n\n"
-          << "void LoadDep(const char* name) {\n"
-          << "  gSystem->AddDynamicPath(Form(\"../%s\",name));\n"
-          << "  char* full = gSystem->DynamicPathName(name,true);\n"
-          << "  if (!full) \n"
-          << "   full = gSystem->DynamicPathName(Form(\"lib%s\",name),true);\n"
-          << "  if (!full) \n"
-          << "   full = gSystem->DynamicPathName(Form(\"lib%s.so\",name),true);\n"
-          << "  if (!full) {\n"
-          << "    Warning(\"LoadDep\",\"Module %s not found\", name);\n"
-          << "    return;\n"
-          << "  }\n"
-          << "  gSystem->Load(full);\n"
-          << "}\n"
-          << std::endl;
-                 
+      u << "void LoadROOTLibs() {\n"
+       << "  gSystem->Load(\"libVMC\");\n"
+       << "  gSystem->Load(\"libNet\");\n"
+       << "  gSystem->Load(\"libTree\");\n"
+       << "  gSystem->Load(\"libPhysics\");\n"
+       << "  gSystem->Load(\"libMinuit\");\n"
+       << "}\n\n"
+       << "void AddDep(const char* env) {\n"
+       << "  TString val(gSystem->Getenv(Form(\"%s_INCLUDE\",env)));\n"
+       << "  if (val.IsNull())\n"
+       << "    Warning(\"Add\",\"%s_INCLUDE not defined\", env);\n"
+       << "  else {\n"
+       << "    gSystem->AddIncludePath(Form(\"-I../%s\",val.Data()));\n"
+       << "  }\n"
+       << "}\n\n"
+       << "void LoadDep(const char* name) {\n"
+       << "  gSystem->AddDynamicPath(Form(\"../%s\",name));\n"
+       << "  char* full = gSystem->DynamicPathName(name,true);\n"
+       << "  if (!full) \n"
+       << "   full = gSystem->DynamicPathName(Form(\"lib%s\",name),true);\n"
+       << "  if (!full) \n"
+       << "   full = gSystem->DynamicPathName(Form(\"lib%s.so\",name),true);\n"
+       << "  if (!full) {\n"
+       << "    Warning(\"LoadDep\",\"Module %s not found\", name);\n"
+       << "    return;\n"
+       << "  }\n"
+       << "  gSystem->Load(full);\n"
+       << "}\n"
+       << std::endl;
+      u.close();
+
       std::ofstream cbuild(Form("%s/PROOF-INF/BUILD.C", dir.Data()));
       if (!cbuild) 
        throw TString::Format("Failed to open build script");
@@ -615,7 +623,7 @@ struct TrainSetup
       
       // Make our set-up script 
       std::ofstream setup(Form("%s/PROOF-INF/SETUP.C", dir.Data()));
-      if (!build) 
+      if (!setup) 
        throw TString::Format("Failed to open setup script");
       setup << "void SETUP() {\n"
            << "  gROOT->LoadMacro(\"PROOF-INF/UTIL.C\");\n"
@@ -644,8 +652,9 @@ struct TrainSetup
       ret = gSystem->Exec(Form("mv -vf %s/%s.par %s.par", templ, base.Data(), 
                               base.Data()));
       if (ret != 0) 
-       throw TString::Format("Failed to rename %s/%s.par to %s.par: %s", templ, base.Data(),
-                             base.Data(), gSystem->GetError());
+       throw TString::Format("Failed to rename %s/%s.par to %s.par: %s", 
+                             templ, base.Data(), base.Data(), 
+                             gSystem->GetError());
     }
     catch (TString& e) { 
       Error("MakeScriptPAR", "%s", e.Data()); 
@@ -712,16 +721,29 @@ struct TrainSetup
     
   }
   //__________________________________________________________________
-  Bool_t Init(EType  type, 
-             EMode  mode, 
-             EOper  oper,
-             Bool_t mc=false, 
-             bool   usePar=false, 
-             Int_t  dbg=0)
+  /** 
+   * Initialize the job 
+   * 
+   * @param type   Type of job (ESD, AOD)
+   * @param mode   Where to do it (local, proof, grid)
+   * @param oper   What to do
+   * @param mc     If true, assume MC input
+   * @param usePar Whether to use PAR files 
+   * @param dbg    Debug flag 
+   * 
+   * @return true on success, false otherwise
+   */
+  Bool_t Init(EType   type, 
+             EMode   mode, 
+             EOper   oper,
+             Bool_t  mc=false, 
+             bool    usePar=false, 
+             Int_t   dbg=0)
   {
     Info("Init", "Connecting in mode=%d", mode);
     if (!Connect(mode)) return false;
 
+    // --- Get current directory and set-up sub-directory ------------
     TString cwd = gSystem->WorkingDirectory();
     TString nam = EscapedName();
     Info("Init", "Current directory=%s, escaped name=%s", 
@@ -751,6 +773,7 @@ struct TrainSetup
     }
     Info("Init", "Made subdirectory %s, and cd'ed there", nam.Data());
       
+    // --- Load the common libraries ---------------------------------
     if (!LoadCommonLibraries(mode, usePar)) return false;
     
     // --- Create analysis manager -----------------------------------
@@ -813,6 +836,18 @@ struct TrainSetup
     return true;
   }
   //__________________________________________________________________
+  /** 
+   * Initialize the job 
+   * 
+   * @param type   Type of analysis (ESD, AOD)
+   * @param mode   Where to do the analysis (LOCAL, GRID, PROOF)
+   * @param oper   What to do 
+   * @param mc     If true, assume MC input
+   * @param usePar Whether to use PARs or not. 
+   * @param dbg    Debug flag 
+   * 
+   * @return true on success, false otherwise 
+   */
   Bool_t Init(const char*  type="ESD", 
              const char*  mode="LOCAL", 
              const char*  oper="FULL",
@@ -958,12 +993,14 @@ protected:
       return;
     }
 
-    AliAnalysisManager *mgr  = new AliAnalysisManager(fName,"Analysis Train");
+    // --- Get manager and execute -----------------------------------
+    AliAnalysisManager *mgr  =AliAnalysisManager::GetAnalysisManager();
     Long64_t ret = StartAnalysis(mgr, mode, chain, nEvents);
 
     // Make sure we go back 
     gSystem->ChangeDirectory(cwd.Data());
 
+    // Return. 
     if (ret < 0) Error("Exec", "Analysis failed");
   }
   //__________________________________________________________________
@@ -1011,7 +1048,6 @@ protected:
   /** 
    * Return the escaped name 
    * 
-   * 
    * @return Escaped name 
    */
   const TString& EscapedName() const 
@@ -1052,15 +1088,18 @@ protected:
     plugin->SetNtestFiles(1);
     
     // Set required version of software 
-    plugin->SetAPIVersion(fAliEnAPIVersion);
-    plugin->SetROOTVersion(fRootVersion);
-    plugin->SetAliROOTVersion(fAliRootVersion);
+    if (!fAliEnAPIVersion.IsNull()) plugin->SetAPIVersion(fAliEnAPIVersion);
+    if (!fRootVersion.IsNull())     plugin->SetROOTVersion(fRootVersion);
+    if (!fAliRootVersion.IsNull())  plugin->SetAliROOTVersion(fAliRootVersion);
 
     // Keep log files 
     plugin->SetKeepLogs();
 
     // Declare root of input data directory 
-    plugin->SetGridDataDir(fDataDir);
+    TString dataDir(fDataDir);
+    if (dataDir.BeginsWith("alien://")) 
+      dataDir.ReplaceAll("alien://", "");
+    plugin->SetGridDataDir(dataDir);
 
     // Data search patterns 
     TString pat;
@@ -1357,7 +1396,7 @@ protected:
     }
 
     // --- Open a connection to the grid -----------------------------
-#if 0
+#if 1
     TGrid::Connect("alien://");
     if (!gGrid || !gGrid->IsConnected()) { 
       // This is only fatal in grid mode 
@@ -1418,20 +1457,6 @@ protected:
       
     }
 
-#if 0
-    // We need to activate the workers here in case 
-    // we have dynamic slaves - otherwise they won't get
-    // the packages 
-    if (mode == kProof) { 
-      Info("LoadCommonLibraries", "Starting slaves");
-      if (!gProof->StartSlaves()) { 
-       Error("LoadCommonLibraries", "Failed to start slaves");
-       return false;
-      }
-      Info("LoadCommonLibraries", "Slaves started");
-    }
-#endif       
-      
     Bool_t ret   = true;
     Bool_t basic = mode == kGrid ? false : par;
     
@@ -1832,34 +1857,6 @@ protected:
   Bool_t  fUseGDB;           // Wrap PROOF slaves in GDB 
 };
 
-
-void
-BuildTrainSetup()
-{
-  gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGLF/FORWARD/analysis2:"
-                          "$ALICE_ROOT/ANALYSIS/macros",
-                          gROOT->GetMacroPath()));
-  gSystem->AddIncludePath("-I${ALICE_ROOT}/include");
-  gSystem->Load("libRAliEn");
-  gSystem->Load("libANALYSIS");
-  gSystem->Load("libANALYSISalice");
-  TString path = gSystem->Which(gROOT->GetMacroPath(), "TrainSetup.C");
-  Info("BuildTrainSetup", "Path=%s", path.Data());
-  TString tmp("TrainSetup");
-  FILE* fp = gSystem->TempFileName(tmp, ".");
-  fclose(fp);
-  gSystem->Unlink(tmp);
-  tmp.Append(".C");
-  Info("BuildTrainSetup", "Copy %s -> %s", path.Data(), tmp.Data());
-  gSystem->CopyFile(path, tmp);
-  gROOT->LoadMacro(Form("%s+g", tmp.Data()));
-  gSystem->Unlink(tmp);
-  tmp.ReplaceAll(".C", "_C.so");
-  gSystem->Unlink(tmp);
-  tmp.ReplaceAll("_C.so", "_C.d");
-  gSystem->Unlink(tmp);
-}
-
   
 //____________________________________________________________________
 //