A task can now declare the list of input branches that are requested during analysis.
authoragheata <agheata@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 22 Nov 2010 10:59:27 +0000 (10:59 +0000)
committeragheata <agheata@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 22 Nov 2010 10:59:27 +0000 (10:59 +0000)
The way to do this is to add in the constructor where the output slots are defined:
fBranchNames = "ESD:bre1,bre2,...,breN AOD:bra1,bra2,...,braM";
The declared branches are currently not loaded automatically, the list being only used to make sure we don't combine in a train tasks that are using the branch loading feature with others that expect the full event.
A task using this should manually request loading of needed branches during UserExec - see example below.
This commit modifies the AliPhysicsSelectionTask to use this feature, gaining a factor of 2 in speed when run standalone.
//________________________________________________________________________
AliAnalysisTaskPt::AliAnalysisTaskPt(const char *name)
  : AliAnalysisTaskSE(name), fEvent(0), fOutputList(0), fHistPt(0)
{
  // Constructor

  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  // Output slot #0 id reserved by the base class for AOD
  // Output slot #1 writes into a TH1 container
  DefineOutput(1, TList::Class());
  fBranchNames = "ESD:AliESDRun.,AliESDHeader.,Tracks";
}
//________________________________________________________________________
void AliAnalysisTaskPt::UserExec(Option_t *)
{
  // Main loop
  // Called for each event

  // Post output data.
  fEvent = InputEvent();
  if (!fEvent) {
    printf("ERROR: Event not available\n");
    return;
  }

  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
  am->LoadBranch("AliESDHeader.");
  am->LoadBranch("AliESDRun.");

  // Track loop to fill a pT spectrum.
  am->LoadBranch("Tracks");
  Int_t ntracks = fEvent->GetNumberOfTracks();
  printf("There are %d tracks in this event\n", ntracks);
  for (Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
  ...
}

ANALYSIS/AliAnalysisAlien.cxx
ANALYSIS/AliAnalysisManager.cxx
ANALYSIS/AliAnalysisManager.h
ANALYSIS/AliAnalysisTask.cxx
ANALYSIS/AliAnalysisTask.h
ANALYSIS/AliPhysicsSelection.cxx
ANALYSIS/AliPhysicsSelectionTask.cxx
ANALYSIS/macros/AnalysisTrainNewFilterAOD.C

index 62d6bb0..79016fb 100644 (file)
@@ -1080,7 +1080,7 @@ Bool_t AliAnalysisAlien::CreateJDL()
          // Output archive for the merging jdl
          TString outputArchive;
          if (TestBit(AliAnalysisGrid::kDefaultOutputs)) {
-            outputArchive = "log_archive.zip:std*@disk=1 ";
+            outputArchive = "log_archive.zip:std*,*.stat@disk=1 ";
             // Add normal output files, extra files + terminate files
             TString files = GetListOfFiles("outextter");
             // Do not register merge excludes
@@ -1094,7 +1094,7 @@ Bool_t AliAnalysisAlien::CreateJDL()
                delete arr;
             }
             files.ReplaceAll(".root", "*.root");
-            outputArchive += Form("root_archive.zip:%s,*.stat@disk=%d",files.Data(),fNreplicas);
+            outputArchive += Form("root_archive.zip:%s@disk=%d",files.Data(),fNreplicas);
          } else {
             TString files = fOutputArchive;
             files.ReplaceAll(".root", "*.root"); // nreplicas etc should be already atttached by use
@@ -1745,7 +1745,7 @@ void AliAnalysisAlien::SetDefaults()
    fDataPattern                = "*AliESDs.root";  // Can be like: *AliESDs.root, */pass1/*AliESDs.root, ...
    fFriendChainName            = "";
    fGridOutputDir              = "output";
-   fOutputArchive              = "log_archive.zip:std*@disk=1 root_archive.zip:*.root@disk=2";
+   fOutputArchive              = "log_archive.zip:std*,*.stat@disk=1 root_archive.zip:*.root@disk=2";
    fOutputFiles                = "";  // Like "AliAODs.root histos.root"
    fInputFormat                = "xml-single";
    fJDLName                    = "analysis.jdl";
@@ -2482,7 +2482,7 @@ Bool_t AliAnalysisAlien::StartAnalysis(Long64_t /*nentries*/, Long64_t /*firstEn
          fOutputFiles += extra;
       }
       // Compose the output archive.
-      fOutputArchive = "log_archive.zip:std*@disk=1 ";
+      fOutputArchive = "log_archive.zip:std*,*.stat@disk=1 ";
       fOutputArchive += Form("root_archive.zip:%s@disk=%d",fOutputFiles.Data(),fNreplicas);
    }
 //   if (!fCloseSE.Length()) fCloseSE = gSystem->Getenv("alien_CLOSE_SE");
index ac553c7..b560de1 100644 (file)
@@ -86,7 +86,8 @@ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title)
                     fTable(),
                     fRunFromPath(0),
                     fNcalls(0),
-                    fStatisticsMsg()
+                    fStatisticsMsg(),
+                    fRequestedBranches()
 {
 // Default constructor.
    fgAnalysisManager = this;
@@ -133,7 +134,8 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
                     fTable(),
                     fRunFromPath(0),
                     fNcalls(other.fNcalls),
-                    fStatisticsMsg(other.fStatisticsMsg)
+                    fStatisticsMsg(other.fStatisticsMsg),
+                    fRequestedBranches(other.fRequestedBranches)
 {
 // Copy constructor.
    fTasks      = new TObjArray(*other.fTasks);
@@ -184,6 +186,7 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe
       fRunFromPath = other.fRunFromPath;
       fNcalls     = other. fNcalls;
       fStatisticsMsg = other.fStatisticsMsg;
+      fRequestedBranches = other.fRequestedBranches;
    }
    return *this;
 }
@@ -320,6 +323,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree)
       return kFALSE;
    }
    top->SetData(tree);
+   CheckBranches(kFALSE);
    if (fDebug > 1) {
       printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
    }
@@ -1348,11 +1352,73 @@ Bool_t AliAnalysisManager::InitAnalysis()
          Error("InitAnalysis", "Wrong container %s : a file name MUST be provided for special outputs", cont->GetName());
          return kFALSE;
       }
-   }      
+   }
+   // Initialize requested branch list if needed
+   if (!fAutoBranchHandling) {
+      next.Reset();
+      while ((task=(AliAnalysisTask*)next())) {
+         if (!task->HasBranches()) {
+            Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches.\nUse: fBranchNames = \"ESD:br1,br2,...,brN AOD:bra1,bra2,...,braM\"",
+                  task->GetName(), task->ClassName());
+            return kFALSE;
+         }
+         if (!fInputEventHandler || !strlen(fInputEventHandler->GetDataType())) {
+            Error("InitAnalysis", "Manual branch loading requested but no input handler defined or handler does not define data type.");
+            return kFALSE;
+         }
+         TString taskbranches;
+         task->GetBranches(fInputEventHandler->GetDataType(), taskbranches);
+         if (taskbranches.IsNull()) {
+            Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches of type %s:",
+                  task->GetName(), task->ClassName(), fInputEventHandler->GetDataType());
+            return kFALSE;      
+         }
+         AddBranches(taskbranches);
+      }         
+   }
    fInitOK = kTRUE;
    return kTRUE;
 }   
 
+//______________________________________________________________________________
+void AliAnalysisManager::AddBranches(const char *branches)
+{
+// Add branches to the existing fRequestedBranches.
+   TString br(branches);
+   TObjArray *arr = br.Tokenize(",");
+   TIter next(arr);
+   TObject *obj;
+   while ((obj=next())) {
+      if (!fRequestedBranches.Contains(obj->GetName())) {
+         if (!fRequestedBranches.IsNull()) fRequestedBranches += ",";
+         fRequestedBranches += obj->GetName();
+      }
+   }
+   if (arr) delete arr;
+}   
+
+//______________________________________________________________________________
+void AliAnalysisManager::CheckBranches(Bool_t load)
+{
+// The method checks the input branches to be loaded during the analysis.
+   if (fAutoBranchHandling || fRequestedBranches.IsNull() || !fTree) return;   
+   TObjArray *arr = fRequestedBranches.Tokenize(",");
+   TIter next(arr);
+   TObject *obj;
+   while ((obj=next())) {
+      TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(obj->GetName()));
+      if (!br) {
+         br = fTree->GetBranch(obj->GetName());
+         if (!br) {
+            Error("CheckBranches", "Could not find branch %s",obj->GetName());
+            continue;
+         }
+      }   
+      fTable.Add(br);
+      if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry());
+   }
+}
+
 //______________________________________________________________________________
 void AliAnalysisManager::PrintStatus(Option_t *option) const
 {
@@ -1368,6 +1434,8 @@ void AliAnalysisManager::PrintStatus(Option_t *option) const
    AliAnalysisTask *task;
    while ((task=(AliAnalysisTask*)next()))
       task->PrintTask(option);
+   if (!fAutoBranchHandling && !fRequestedBranches.IsNull()) 
+      printf("Requested input branches:\n%s\n", fRequestedBranches.Data());
 }
 
 //______________________________________________________________________________
@@ -2161,7 +2229,7 @@ void AliAnalysisManager::DoLoadBranch(const char *name)
 {
   // Get tree and load branch if needed.
 
-  if (!fTree)
+  if (fAutoBranchHandling || !fTree)
     return;
 
   TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(name));
@@ -2173,8 +2241,7 @@ void AliAnalysisManager::DoLoadBranch(const char *name)
     }
     fTable.Add(br);
   }
-  if (br->GetReadEntry()==GetCurrentEntry())
-    return;
+  if (br->GetReadEntry()==GetCurrentEntry()) return;
   br->GetEntry(GetCurrentEntry());
 }
 
index 468c90e..652251c 100644 (file)
@@ -109,6 +109,7 @@ enum EAliAnalysisFlags {
    TObjArray          *GetOutputs() const         {return fOutputs;}
    TObjArray          *GetParamOutputs() const    {return fParamCont;}
    Int_t               GetRunFromPath() const     {return fRunFromPath;}
+   const char         *GetRequestedBranches() const {return fRequestedBranches.Data();}
    TObjArray          *GetTasks() const           {return fTasks;}
    TObjArray          *GetTopTasks() const        {return fTopTasks;}
    TTree              *GetTree() const            {return fTree;}
@@ -156,6 +157,8 @@ enum EAliAnalysisFlags {
    void                 CleanContainers();
    
    // Analysis initialization and execution, status
+   void                 AddBranches(const char *branches);
+   void                 CheckBranches(Bool_t load=kFALSE);
    Bool_t               InitAnalysis();
    Bool_t               IsInitialized() const {return fInitOK;}
    Bool_t               IsExternalLoop() const {return TObject::TestBit(kExternalLoop);}
@@ -208,8 +211,9 @@ private:
    Int_t                   fRunFromPath;         // Run number retrieved from path to input data
    Int_t                   fNcalls;              // Total number of calls (events) of ExecAnalysis
    TString                 fStatisticsMsg;       // Statistics user message
+   TString                 fRequestedBranches;   // Requested branch names
    static TString          fgCommonFileName;     //! Common output file name (not streamed)
    static AliAnalysisManager *fgAnalysisManager; //! static pointer to object instance
-   ClassDef(AliAnalysisManager,10)  // Analysis manager class
+   ClassDef(AliAnalysisManager,11)  // Analysis manager class
 };   
 #endif
index 1d5b591..47edc46 100644 (file)
@@ -119,7 +119,8 @@ AliAnalysisTask::AliAnalysisTask()
                  fOutputReady(NULL),
                  fPublishedData(NULL),
                  fInputs(NULL),
-                 fOutputs(NULL)
+                 fOutputs(NULL),
+                 fBranchNames()
 {
 // Default constructor.
 }
@@ -134,7 +135,8 @@ AliAnalysisTask::AliAnalysisTask(const char *name, const char *title)
                  fOutputReady(NULL),
                  fPublishedData(NULL),
                  fInputs(NULL),
-                 fOutputs(NULL)                 
+                 fOutputs(NULL),
+                 fBranchNames()                 
 {
 // Constructor.
    fInputs      = new TObjArray(2);
@@ -151,7 +153,8 @@ AliAnalysisTask::AliAnalysisTask(const AliAnalysisTask &task)
                  fOutputReady(NULL),
                  fPublishedData(NULL),
                  fInputs(NULL),
-                 fOutputs(NULL)                 
+                 fOutputs(NULL),
+                 fBranchNames(task.fBranchNames)
 {
 // Copy ctor.
    fInputs      = new TObjArray((fNinputs)?fNinputs:2);
@@ -195,6 +198,7 @@ AliAnalysisTask& AliAnalysisTask::operator=(const AliAnalysisTask& task)
       fOutputReady[i] = IsOutputReady(i);
       fOutputs->AddAt(new AliAnalysisDataSlot(*task.GetOutputSlot(i)),i);
    }         
+   fBranchNames = task.fBranchNames;
    return *this;
 }
 
@@ -559,6 +563,7 @@ void AliAnalysisTask::PrintTask(Option_t *option, Int_t indent) const
    AliAnalysisDataContainer *cont;
    for (Int_t i=0; i<indent; i++) ind += " ";
    if (!dep || (dep && IsChecked())) {
+      printf("______________________________________________________________________________\n");
       printf("%s\n", Form("%stask: %s  ACTIVE=%i POST_LOOP=%i", ind.Data(), GetName(),IsActive(),IsPostEventLoop()));
       if (dep) thistask->SetChecked(kFALSE);
       else {
@@ -577,6 +582,7 @@ void AliAnalysisTask::PrintTask(Option_t *option, Int_t indent) const
       }
    }
    PrintContainers(option, indent+3);
+   if (!fBranchNames.IsNull()) printf("Requested branches:   %s\n", fBranchNames.Data());
 }      
 
 //______________________________________________________________________________
@@ -607,3 +613,18 @@ void AliAnalysisTask::SetPostEventLoop(Bool_t flag)
    }   
 }
    
+//______________________________________________________________________________
+void AliAnalysisTask::GetBranches(const char *type, TString &result) const
+{
+// Get the list of branches for a given type (ESD, AOD). The list of branches
+// requested by a task has to ve declared in the form:
+//   SetBranches("ESD:branch1,branch2,...,branchN AOD:branch1,branch2,...,branchM")
+   result = "";
+   if (fBranchNames.IsNull()) return;
+   Int_t index1 = fBranchNames.Index(type);
+   if (index1<0) return;
+   index1 += 1+strlen(type);
+   Int_t index2 = fBranchNames.Index(" ", index1);
+   if (index2<0) index2 = fBranchNames.Length();
+   result = fBranchNames(index1, index2-index1);
+}
index f0a320d..c478cf3 100644 (file)
@@ -43,6 +43,7 @@ class AliAnalysisTask : public TTask {
   TObject                  *fPublishedData; //! published data
   TObjArray                *fInputs;        // Array of input slots
   TObjArray                *fOutputs;       // Array of output slots
+  TString                   fBranchNames;   // List of input branches that need to be loaded for this task
 
   // Define the input/output slots (called by user in the ctor of the derived class)
   //=== CALL IN THE CONSTRUCTOR OF DERIVED CLASS TO DEFINE INPUTS/OUTPUTS ===
@@ -105,6 +106,7 @@ public:
   // Check if there are illegal circular dependencies
   Bool_t                    CheckCircularDeps();
   // Getters
+  void                      GetBranches(const char *type, TString &result) const;
   Int_t                     GetNinputs() const  {return fNinputs;}
   Int_t                     GetNoutputs() const {return fNoutputs;}
   TObject                  *GetPublishedData() const {return fPublishedData;}
@@ -122,8 +124,10 @@ public:
   Bool_t                    IsReady() const  {return fReady;}
   Bool_t                    IsUsed() const   {return TObject::TestBit(kTaskUsed);}
   Bool_t                    IsZombie() const {return TObject::TestBit(kTaskZombie);}
+  Bool_t                    HasBranches() const {return !fBranchNames.IsNull();}
   void                      PrintTask(Option_t *option="all", Int_t indent=0) const;
   void                      PrintContainers(Option_t *option="all", Int_t indent=0) const;
+  void                      SetBranches(const char *names) {fBranchNames = names;}
   void                      SetChecked(Bool_t flag=kTRUE) {TObject::SetBit(kTaskChecked,flag);}
   void                      SetPostEventLoop(Bool_t flag=kTRUE);
   void                      SetUsed(Bool_t flag=kTRUE);
@@ -138,6 +142,6 @@ public:
   virtual void              Terminate(Option_t *option="");
   //=====================================================================
     
-  ClassDef(AliAnalysisTask,1)  // Class describing an analysis task
+  ClassDef(AliAnalysisTask,2)  // Class describing an analysis task
 };
 #endif
index 53c5327..bea501f 100644 (file)
@@ -285,7 +285,19 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
   // checks if the given event is a collision candidate
   //
   // returns a bit word describing the fired offline triggers (see AliVEvent::EOfflineTriggerTypes)
-  
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  if (!mgr) {
+    AliError("Cannot get the analysis manager");
+    return 0;
+  } 
+  mgr->LoadBranch("AliESDHeader.");
+  mgr->LoadBranch("AliESDRun.");
+  mgr->LoadBranch("AliMultiplicity.");
+  mgr->LoadBranch("AliESDFMD.");
+  mgr->LoadBranch("AliESDVZERO.");
+  mgr->LoadBranch("AliESDZDC.");
+  mgr->LoadBranch("SPDVertex.");
+  mgr->LoadBranch("PrimaryVertex.");
   if (fCurrentRun != aEsd->GetRunNumber()) {
     if (!Initialize(aEsd))
       AliFatal(Form("Could not initialize for run %d", aEsd->GetRunNumber()));
@@ -336,13 +348,7 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
   
       Bool_t isBin0 = kFALSE;
       if (fBin0CallBack != "") {
-       AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-       if (!mgr) {
-         AliError("Cannot get the analysis manager");
-       }  
-       else {
          isBin0 = ((AliAnalysisTaskSE*)mgr->GetTask(fBin0CallBack.Data()))->IsEventInBinZero();
-       }
       } else if (fBin0CallBackPointer) {
          isBin0 = (*fBin0CallBackPointer)(aEsd);
       }
index 21ff1c1..5608b5e 100644 (file)
@@ -47,6 +47,7 @@ AliPhysicsSelectionTask::AliPhysicsSelectionTask(const char* opt) :
   }
   // Define input and output slots here
   DefineOutput(1, TList::Class());
+  fBranchNames = "ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.,AliESDFMD.,AliESDVZERO,AliESDZDC.,SPDVertex.,PrimaryVertex.";
   
   AliLog::SetClassDebugLevel("AliPhysicsSelectionTask", AliLog::kWarning);
 }
index f7bdcfb..94b2d52 100644 (file)
@@ -22,7 +22,7 @@ TString     train_tag          = "pass1";        // Train special tag appended t
                // Name in train page (DON'T CHANGE)
 TString     visible_name       = Form("FILTER%s$2_$3", train_tag.Data()); //# FIXED #
                // Add train composition and other comments
-TString     job_comment        = "PhysSel+Tender -> AODs: std(+jets)/(di)muon/vertexing/dielectrons";
+TString     job_comment        = "PhysSel -> AODs: std(+jets)/(di)muon/vertexing/dielectrons";
 TString     job_tag            = Form("%s: %s", visible_name.Data(), job_comment.Data());
 //==============================================================================
 
@@ -47,16 +47,16 @@ Bool_t      useProductionMode  = kTRUE;   // use the plugin in production mode
 // AliRoot.
 Bool_t      usePAR             = kFALSE;  // use par files for extra libs
 Bool_t      useCPAR            = kFALSE;  // use par files for common libs
-TString     root_version       = "v5-27-06a-1";  // *CHANGE ME IF MORE RECENT IN GRID*
-TString     aliroot_version    = "v4-21-02-AN";  // *CHANGE ME IF MORE RECENT IN GRID*                                          
+TString     root_version       = "v5-27-06b";  // *CHANGE ME IF MORE RECENT IN GRID*
+TString     aliroot_version    = "v4-21-05-AN";  // *CHANGE ME IF MORE RECENT IN GRID*                                          
 // Change production base directory here (test mode)
-TString     alien_datadir      = "/alice/data/2010/LHC10e";
+TString     alien_datadir      = "/alice/data/2010/LHC10h";
                // Work directory in GRID (DON'T CHANGE)
 TString     grid_workdir       = "/alice/cern.ch/user/a/alidaq/AOD/AOD$2";
                // Data pattern - change as needed for test mode
 TString     data_pattern       = "*ESDs/pass1/*ESDs.root";
 // Set the run range
-Int_t run_numbers[10] = {130848}; // **********************!!!!!!!
+Int_t run_numbers[10] = {137230}; // **********************!!!!!!!
 //Int_t       run_range[2]       =  {114786, 114949};  // LHC09a7   *CHANGE ME*
 // AliEn output directory. If blank will become output_<train_name>
                // Output directory (DON'T CHANGE)
@@ -69,7 +69,7 @@ TString     outputSingleFolder = "";
 // Number of files merged in a chunk
 Int_t       maxMergeFiles      = 20;
 // Files that should not be merged
-TString     mergeExclude       = "AliAOD.root AliAOD.VertexingHF.root AliAOD.Jets.root deltaAODPartCorr.root AliAOD.Muons.root AliAOD.Dimuons.root AliAOD.Dielectron.root";
+TString     mergeExclude       = "AliAOD.root AliAOD.VertexingHF.root AliAOD.Jets.root deltaAODPartCorr.root AliAOD.Muons.root AliAOD.Dimuons.root AliAOD.Dielectron.root AliAODCentrality.root";
 // Make replicas on the storages below
 TString     outputStorages      = "disk=4";
 // Number of runs per master job
@@ -85,8 +85,9 @@ TString     local_xmldataset   = "";
 // ### Other flags to steer the analysis
 //==============================================================================
 Bool_t      usePhysicsSelection = kTRUE; // use physics selection
+Bool_t      useBKrejection      = kFALSE; // use BK rejection
 Bool_t      useCentrality       = kTRUE; // centrality delta AOD
-Bool_t      useTender           = kTRUE; // use tender wagon
+Bool_t      useTender           = kFALSE; // use tender wagon
 Bool_t      useV0tender         = kTRUE;  // use V0 correction in tender
 Bool_t      useMergeViaJDL      = kTRUE;  // merge via JDL
 Bool_t      useFastReadOption   = kTRUE;  // use xrootd tweaks
@@ -366,12 +367,13 @@ void AddAnalysisTasks()
    // Physics selection task
       gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
       mgr->RegisterExtraFile("event_stat.root");
-      AliPhysicsSelectionTask *physSel = AddTaskPhysicsSelection(useMC);
+      AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC,useBKrejection);
    }
-
+   
    if (iESDfilter && !iAODanalysis) {
       //  ESD filter task configuration.
       gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
+      if (useCentrality) mgr->RegisterExtraFile("AliAODCentrality.root");
       if (iMUONcopyAOD) {
          printf("Registering delta AOD file\n");
          mgr->RegisterExtraFile("AliAOD.Muons.root");
@@ -1241,7 +1243,7 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
       plugin->SetOutputToRunNo();
    }   
    plugin->SetJobTag(job_tag);
-   plugin->SetNtestFiles(5);
+   plugin->SetNtestFiles(2);
    plugin->SetCheckCopy(kFALSE);
    plugin->SetOneStageMerging(kTRUE);
 // Set versions of used packages