X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliRunDigitizer.cxx;h=14e9fc001b1fb19963cc66e91bab3318ec3bde0d;hb=2e184671bb7399c0214568b4bdacd247145c6437;hp=8daa524d8ea6ab4e4280ae17dd0f357cd84c2ba3;hpb=7e68127fd5c3b7a644b6fff3dde38e20de6024e5;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliRunDigitizer.cxx b/STEER/AliRunDigitizer.cxx
index 8daa524d8ea..14e9fc001b1 100644
--- a/STEER/AliRunDigitizer.cxx
+++ b/STEER/AliRunDigitizer.cxx
@@ -13,38 +13,9 @@
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
 
-/*
-$Log$
-Revision 1.11  2001/12/03 07:10:13  jchudoba
-Default ctor cannot create new objects, create dummy default ctor which leaves object in not well defined state - to be used only by root for I/O
+/* $Id$ */
 
-Revision 1.10  2001/11/15 11:07:25  jchudoba
-Set to zero new pointers to TPC and TRD special trees in the default ctor. Add const to all Get functions. Remove unused constant, rename constant according coding rules.
-
-Revision 1.9  2001/11/15 09:00:11  jchudoba
-Add special treatment for TPC and TRD, they use different trees than other detectors
-
-Revision 1.8  2001/10/21 18:38:43  hristov
-Several pointers were set to zero in the default constructors to avoid memory management problems
-
-Revision 1.7  2001/10/04 15:56:07  jchudoba
-TTask inheritance
-
-Revision 1.4  2001/09/19 06:23:50  jchudoba
-Move some tasks to AliStream and AliMergeCombi classes
-
-Revision 1.3  2001/07/30 14:04:18  jchudoba
-correct bug in the initialization
-
-Revision 1.2  2001/07/28 10:44:32  hristov
-Loop variable declared once; typos corrected
-
-Revision 1.1  2001/07/27 12:59:00  jchudoba
-Manager class for merging/digitization
-
-*/
-
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 //
 // AliRunDigitizer.cxx
 //
@@ -115,316 +86,397 @@ Manager class for merging/digitization
 //  manager->SetNrOfEventsToWrite(1);
 //  manager->Exec("");
 //
-//////////////////////////////////////////////////////////////////////// 
+//_______________________________________________________________________ 
 
 // system includes
 
-#include <iostream.h>
+#include <Riostream.h>
 
 // ROOT includes
 
 #include "TFile.h"
-#include "TTree.h"
 #include "TList.h"
+#include "TTree.h"
 
 // AliROOT includes
 
-#include "AliRunDigitizer.h"
 #include "AliDigitizer.h"
+#include "AliMergeCombi.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
 #include "AliRun.h"
-#include "AliHeader.h"
-#include "TParticle.h"
+#include "AliRunDigitizer.h"
 #include "AliStream.h"
-#include "AliMergeCombi.h"
+#include "AliHeader.h"
 
 ClassImp(AliRunDigitizer)
 
-////////////////////////////////////////////////////////////////////////
-AliRunDigitizer::AliRunDigitizer()
+const TString AliRunDigitizer::fgkDefOutFolderName("Output");
+const TString AliRunDigitizer::fgkBaseInFolderName("Input");
+
+
+//_______________________________________________________________________
+AliRunDigitizer::AliRunDigitizer():
+ fkMASKSTEP(0),
+ fOutputFileName(0),
+ fOutputDirName(0),
+ fEvent(0),
+ fNrOfEventsToWrite(0),
+ fNrOfEventsWritten(0),
+ fCopyTreesFromInput(0),
+ fNinputs(0),
+ fNinputsGiven(0),
+ fInputStreams(0x0),
+ fOutRunLoader(0x0),
+ fOutputInitialized(kFALSE),
+ fCombi(0),
+ fCombination(0),
+ fCombinationFileName(0),
+ fDebug(0)
 {
 // root requires default ctor, where no new objects can be created
 // do not use this ctor, it is supplied only for root needs
-  
-// just set all pointers - data members to 0
-  fOutput = 0;
-  fTreeD = 0;
-  fTreeDTPC = 0;
-  fTreeDTRD = 0;
-  fInputStreams = 0;
-  for (Int_t i=0;i<kMaxStreamsToMerge;i++) {
-    fArrayTreeS[i]=fArrayTreeH[i]=fArrayTreeTPCS[i]=fArrayTreeTRDS[i]=NULL;
-    fInputFiles[i]=0;
-  }
-  fCombi = 0;
 
+//  fOutputStream = 0x0;
 }
 
-////////////////////////////////////////////////////////////////////////
-AliRunDigitizer::AliRunDigitizer(Int_t nInputStreams, Int_t sperb) : TTask("AliRunDigitizer","The manager for Merging")
+//_______________________________________________________________________
+AliRunDigitizer::AliRunDigitizer(Int_t nInputStreams, Int_t sperb):
+ TTask("AliRunDigitizer","The manager for Merging"),
+ fkMASKSTEP(10000000),
+ fOutputFileName(""),
+ fOutputDirName("."),
+ fEvent(0),
+ fNrOfEventsToWrite(-1),
+ fNrOfEventsWritten(0),
+ fCopyTreesFromInput(-1),
+ fNinputs(nInputStreams),
+ fNinputsGiven(0),
+ fInputStreams(new TClonesArray("AliStream",nInputStreams)),
+ fOutRunLoader(0x0),
+ fOutputInitialized(kFALSE),
+ fCombi(new AliMergeCombi(nInputStreams,sperb)),
+ fCombination(kMaxStreamsToMerge),
+ fCombinationFileName(0),
+ fDebug(0)
+
 {
 // ctor which should be used to create a manager for merging/digitization
-  if (nInputStreams == 0) {
-    Error("AliRunDigitizer","Specify nr of input streams");
+  if (nInputStreams == 0) 
+   {//kidding
+    Fatal("AliRunDigitizer","Specify nr of input streams");
     return;
-  }
+   }
   Int_t i;
-  fNinputs = nInputStreams;
-  fOutputFileName = "";
-  fOutputDirName = ".";
-  fCombination.Set(kMaxStreamsToMerge);
-  for (i=0;i<kMaxStreamsToMerge;i++) {
-    fArrayTreeS[i]=fArrayTreeH[i]=fArrayTreeTPCS[i]=fArrayTreeTRDS[i]=NULL;
-    fCombination[i]=-1;
-  }
-  fkMASKSTEP = 10000000;
+  
   fkMASK[0] = 0;
-  for (i=1;i<kMaxStreamsToMerge;i++) {
+  
+  for (i=1;i<kMaxStreamsToMerge;i++) 
+   {
     fkMASK[i] = fkMASK[i-1] + fkMASKSTEP;
-  }
-  fInputStreams = new TClonesArray("AliStream",nInputStreams);
+   }
+  
   TClonesArray &lInputStreams = *fInputStreams;
-// the first Input is open RW to be output as well
-  new(lInputStreams[0]) AliStream("UPDATE");
+  
+  new(lInputStreams[0]) AliStream(fgkBaseInFolderName+(Long_t)0,"UPDATE");
   for (i=1;i<nInputStreams;i++) {
-    new(lInputStreams[i]) AliStream("READ");
+    new(lInputStreams[i]) AliStream(fgkBaseInFolderName+(Long_t)i,"READ");
   }
-  fOutput = 0;
-  fEvent = 0;
-  fNrOfEventsToWrite = -1;
-  fNrOfEventsWritten = 0;
-  fCopyTreesFromInput = -1;
-  fCombi = new AliMergeCombi(nInputStreams,sperb);
-  fDebug = 0;
-  fTreeD = 0;
-  fTreeDTPC = 0;
-  fTreeDTRD = 0;
-  
-  for (i=0; i<kMaxStreamsToMerge; i++) fInputFiles[i]=0;
+}
+//_______________________________________________________________________
+
+AliRunDigitizer::AliRunDigitizer(const AliRunDigitizer& dig):
+ TTask(dig),
+ fkMASKSTEP(0),
+ fOutputFileName(0),
+ fOutputDirName(0),
+ fEvent(0),
+ fNrOfEventsToWrite(0),
+ fNrOfEventsWritten(0),
+ fCopyTreesFromInput(0),
+ fNinputs(0),
+ fNinputsGiven(0),
+ fInputStreams(0x0),
+ fOutRunLoader(0x0),
+ fOutputInitialized(kFALSE),
+ fCombi(0),
+ fCombination(0),
+ fCombinationFileName(0),
+ fDebug(0)
+{
+  //
+  // Copy ctor
+  //
+  dig.Copy(*this);
+}
+//_______________________________________________________________________
+
+void AliRunDigitizer::Copy(TObject&) const
+{
+  Fatal("Copy","Not installed\n");
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 
 AliRunDigitizer::~AliRunDigitizer() {
 // dtor
-
-  if (fInputStreams) {
-    delete fInputStreams;
-    fInputStreams = 0;
-  }
-  if (fCombi) {
-    delete fCombi;
-    fCombi = 0;
-  }
-
+  delete fInputStreams;
+  delete fCombi;
+  delete fOutRunLoader;
 }
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 void AliRunDigitizer::AddDigitizer(AliDigitizer *digitizer)
 {
 // add digitizer to the list of active digitizers
   this->Add(digitizer);
 }
-////////////////////////////////////////////////////////////////////////
-void AliRunDigitizer::SetInputStream(Int_t i, char *inputFile)
+//_______________________________________________________________________
+void AliRunDigitizer::SetInputStream(Int_t i, const char *inputFile, TString foldername)
 {
+//
+// Sets the name of the input file
+//
   if (i > fInputStreams->GetLast()) {
     Error("SetInputStream","Input stream number too high");
     return;
   }
-  static_cast<AliStream*>(fInputStreams->At(i))->AddFile(inputFile);
+  AliStream * stream = static_cast<AliStream*>(fInputStreams->At(i)) ; 
+  if ( !foldername.IsNull() ) {
+    if ( i > 0 ) 
+      foldername += i ; // foldername should stay unchanged for the default output 
+    stream->SetFolderName(foldername) ;
+  } 
+  stream->AddFile(inputFile);
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 void AliRunDigitizer::Digitize(Option_t* option)
 {
-// get a new combination of inputs, connect input trees and loop 
-// over all digitizers
+// get a new combination of inputs, loads events to folders
 
 // take gAlice from the first input file. It is needed to access
 //  geometry data
-  if (!static_cast<AliStream*>(fInputStreams->At(0))->ImportgAlice()) {
-    cerr<<"gAlice object not found in the first file of "
-	<<"the 1st stream"<<endl;
-    return;
-  }
-  if (!InitGlobal()) {
-    cerr<<"False from InitGlobal"<<endl;
-    return;
-  }
+// If gAlice is already in memory, use it
+  SetDebug(10);
+  
+  if (!static_cast<AliStream*>(fInputStreams->At(0))->ImportgAlice()) 
+   {
+     Error("Digitize","Error occured while getting gAlice from Input 0");
+     return;
+   }
+    
+  if (!InitGlobal()) //calls Init() for all (sub)digitizers
+   {
+     Error("Digitize","InitGlobal returned error");
+     return;
+   }
+   
   Int_t eventsCreated = 0;
 // loop until there is anything on the input in case fNrOfEventsToWrite < 0
-  while ((eventsCreated++ < fNrOfEventsToWrite) || (fNrOfEventsToWrite < 0)) {
-    if (!ConnectInputTrees()) break;
-    InitEvent();
-// loop over all registered digitizers and let them do the work
-    ExecuteTasks("");
-    CleanTasks();
-    FinishEvent();
-  }
+  while ((eventsCreated++ < fNrOfEventsToWrite) || (fNrOfEventsToWrite < 0)) 
+   {
+      if (!ConnectInputTrees()) break;
+      InitEvent();//this must be after call of Connect Input tress.
+      if (fOutRunLoader)
+       {
+         fOutRunLoader->SetEventNumber(eventsCreated-1);
+       }
+      static_cast<AliStream*>(fInputStreams->At(0))->ImportgAlice(); // use gAlice of the first input stream
+      ExecuteTasks(option);// loop over all registered digitizers and let them do the work
+      FinishEvent();
+      CleanTasks();
+   }
   FinishGlobal();
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 Bool_t AliRunDigitizer::ConnectInputTrees()
 {
-// fill arrays fArrayTreeS, fArrayTreeH and fArrayTreeTPCS with 
-// pointers to the correct events according fCombination values
-// null pointers can be in the output, AliDigitizer has to check it
-
-  TTree *tree;
-  char treeName[50];
-  Int_t serialNr;
+//loads events 
   Int_t eventNr[kMaxStreamsToMerge], delta[kMaxStreamsToMerge];
   fCombi->Combination(eventNr, delta);
-  for (Int_t i=0;i<fNinputs;i++) {
-    if (delta[i] == 1) {
-      AliStream *iStream = static_cast<AliStream*>(fInputStreams->At(i));
-      if (!iStream->NextEventInStream(serialNr)) return kFALSE;
-      fInputFiles[i]=iStream->CurrentFile();
-      sprintf(treeName,"TreeS%d",serialNr);
-      tree = static_cast<TTree*>(iStream->CurrentFile()->Get(treeName));
-      fArrayTreeS[i] = tree;
-      sprintf(treeName,"TreeH%d",serialNr);
-      tree = static_cast<TTree*>(iStream->CurrentFile()->Get(treeName));
-      fArrayTreeH[i] = tree;
-      sprintf(treeName,"TreeS_75x40_100x60_%d",serialNr);
-      tree = static_cast<TTree*>(iStream->CurrentFile()->Get(treeName));
-      fArrayTreeTPCS[i] = tree;
-      sprintf(treeName,"TreeS%d_TRD",serialNr);
-      tree = static_cast<TTree*>(iStream->CurrentFile()->Get(treeName));
-      fArrayTreeTRDS[i] = tree;
-    } else if (delta[i] != 0) {
+  for (Int_t i=0;i<fNinputs;i++) 
+   {
+    if (delta[i] == 1)
+     {
+      AliStream *iStream = static_cast<AliStream*>(fInputStreams->At(i));//gets the "i" defined  in combination
+      if (!iStream->NextEventInStream()) return kFALSE; //sets serial number
+     } 
+    else if (delta[i] != 0) 
+     {
       Error("ConnectInputTrees","Only delta 0 or 1 is implemented");
       return kFALSE;
-    }
-  }
+     }
+   }
+
   return kTRUE;
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 Bool_t AliRunDigitizer::InitGlobal()
 {
 // called once before Digitize() is called, initialize digitizers and output
-
+  fOutputInitialized = kFALSE;
   TList* subTasks = this->GetListOfTasks();
   if (subTasks) {
-    subTasks->ForEach(AliDigitizer,Init)();
-  }  
+    TIter next(subTasks);
+    while (AliDigitizer * dig = (AliDigitizer *) next())
+     dig->Init();
+  }
   return kTRUE;
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 
 void AliRunDigitizer::SetOutputFile(TString fn)
-// the output will be to separate file, not to the signal file
 {
+// the output will be to separate file, not to the signal file
+ //here should be protection to avoid setting the same file as any input 
+  Info("SetOutputFile","Setting Output File Name %s ",fn.Data());
   fOutputFileName = fn;
-  (static_cast<AliStream*>(fInputStreams->At(0)))->ChangeMode("READ");
-  InitOutputGlobal();
+//  InitOutputGlobal();
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 Bool_t AliRunDigitizer::InitOutputGlobal()
 {
 // Creates the output file, called by InitEvent()
-
-  TString fn;
-  fn = fOutputDirName + '/' + fOutputFileName;
-  fOutput = new TFile(fn,"recreate");
-  if (GetDebug()>2) {
-    cerr<<"AliRunDigitizer::InitOutputGlobal(): file "<<fn.Data()<<" was opened"<<endl;
-  }
-  if (fOutput) return kTRUE;
-  Error("InitOutputGlobal","Could not create output file.");
-  return kFALSE;
+//Needs to be called after all inputs are opened  
+  if (fOutputInitialized) return kTRUE;
+  
+  if ( !fOutputFileName.IsNull())
+   {
+    fOutRunLoader = AliRunLoader::Open(fOutputFileName,fgkDefOutFolderName,"recreate");
+    
+    if (fOutRunLoader == 0x0)
+     {
+       Error("InitOutputGlobal","Can not open ooutput");
+       return kFALSE;
+     }
+    Info("InitOutputGlobal", " 1 %s = ", GetInputFolderName(0).Data()) ; 
+    AliRunLoader* inrl = AliRunLoader::GetRunLoader(GetInputFolderName(0));
+    if (inrl == 0x0)
+     {
+       Error("InitOutputGlobal","Can not get Run Loader Input 0. Maybe yet not initialized?");
+       return kFALSE;
+     }
+    Info("InitOutputGlobal", " 2 %#x = ", inrl) ; 
+
+    //Copy all detector loaders from input 0 to output
+    const TObjArray* inloaders = inrl->GetArrayOfLoaders();
+    TIter next(inloaders);
+    AliLoader *loader;
+    while((loader = (AliLoader*)next()))
+     {
+       AliLoader* cloneloader = (AliLoader*)loader->Clone();
+       cloneloader->Register(fOutRunLoader->GetEventFolder());//creates folders for this loader in Output Folder Structure
+       GetOutRunLoader()->AddLoader(cloneloader);//adds a loader for output
+     }
+
+    fOutRunLoader->MakeTree("E");
+    
+    if (GetDebug()>2)  Info("InitOutputGlobal","file %s was opened.",fOutputFileName.Data());
+   }
+  fOutputInitialized = kTRUE; 
+  return kTRUE;
 }
+//_______________________________________________________________________
 
-
-////////////////////////////////////////////////////////////////////////
 void AliRunDigitizer::InitEvent()
 {
-// Creates TreeDxx in the output file, called from Digitize() once for 
-//  each event. xx = fEvent
-
-  if (GetDebug()>2) 
-    cerr<<"AliRunDigitizer::InitEvent: fEvent = "<<fEvent<<endl;
-
-// if fOutputFileName was not given, write output to signal file
-  if (fOutputFileName == "") {
-    fOutput = (static_cast<AliStream*>(fInputStreams->At(0)))->CurrentFile();
-  }
-  fOutput->cd();
-  char treeName[30];
-  sprintf(treeName,"TreeD%d",fEvent);
-  fTreeD = static_cast<TTree*>(fOutput->Get(treeName));
-  if (!fTreeD) {
-    fTreeD = new TTree(treeName,"Digits");
-    fTreeD->Write(0,TObject::kOverwrite);
-  }
-
-// special tree for TPC
-  sprintf(treeName,"TreeD_75x40_100x60_%d",fEvent);
-  fTreeDTPC = static_cast<TTree*>(fOutput->Get(treeName));
-  if (!fTreeDTPC) {
-    fTreeDTPC = new TTree(treeName,"TPC_Digits");
-    fTreeDTPC->Write(0,TObject::kOverwrite);
-  }
-
-// special tree for TRD
-  sprintf(treeName,"TreeD%d_TRD",fEvent);
-  fTreeDTRD = static_cast<TTree*>(fOutput->Get(treeName));
-  if (!fTreeDTRD) {
-    fTreeDTRD = new TTree(treeName,"TRD_Digits");
-    fTreeDTRD->Write(0,TObject::kOverwrite);
-  }
-
+//redirects output properly
+  if (GetDebug()>2)
+   {
+    Info("InitEvent","fEvent = %d",fEvent);
+    Info("InitEvent","fOutputFileName \"%s\"",fOutputFileName.Data());
+   }
+  if (fOutputInitialized == kFALSE) InitOutputGlobal();
+  
+// if fOutputFileName was not given, write output to signal directory
 }
+//_______________________________________________________________________
 
-////////////////////////////////////////////////////////////////////////
 void AliRunDigitizer::FinishEvent()
 {
 // called at the end of loop over digitizers
 
-  fOutput->cd();
-  if (fCopyTreesFromInput > -1) {
-    char treeName[20];
-    Int_t i = fCopyTreesFromInput; 
-    sprintf(treeName,"TreeK%d",fCombination[i]);
-    fInputFiles[i]->Get(treeName)->Clone()->Write();
-    sprintf(treeName,"TreeH%d",fCombination[i]);
-    fInputFiles[i]->Get(treeName)->Clone()->Write();
-  }
+  
+  if (GetOutRunLoader() == 0x0)
+   {
+     Error("FinishEvent","fOutRunLoader is null");
+     return;
+   }
+  
   fEvent++;
   fNrOfEventsWritten++;
-  if (fTreeD) {
-    delete fTreeD;
-    fTreeD = 0;
-  }
-  if (fTreeDTPC) {
-    delete fTreeDTPC;
-    fTreeDTPC = 0;
-  }
-  if (fTreeDTRD) {
-    delete fTreeDTRD;
-    fTreeDTRD = 0;
-  }
+  
+  if (fOutRunLoader)
+  {
+     AliRunLoader* inrl = AliRunLoader::GetRunLoader(GetInputFolderName(0));
+     AliHeader* outheader = fOutRunLoader->GetHeader();
+     AliHeader* inheader = inrl->GetHeader();
+     if (inheader == 0x0)
+     {
+       inrl->LoadHeader();
+       inheader = inrl->GetHeader();
+       if (inheader == 0x0) Fatal("FinishEvent","Can not get header from input 0");
+     }
+     
+     outheader->SetNprimary(inheader->GetNprimary());
+     outheader->SetNtrack(inheader->GetNtrack());
+     outheader->SetEvent(inheader->GetEvent());
+     outheader->SetEventNrInRun(inheader->GetEventNrInRun());
+     outheader->SetNvertex(inheader->GetNvertex());
+     fOutRunLoader->TreeE()->Fill();
+  }
+      
+  if (fCopyTreesFromInput > -1) 
+   {
+    //this is sensless since no information would be coherent in case of merging
+    //
+    cout<<"Copy trees from input: Copy or link files manually"<<endl;
+    return;
+   }
 }
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
+
 void AliRunDigitizer::FinishGlobal()
 {
 // called at the end of Exec
 // save unique objects to the output file
 
-  fOutput->cd();
+  if (GetOutRunLoader() == 0x0)
+   {
+     Error("FinishGlobal","Can not get RunLoader from Output Stream folder");
+     return;
+   }
+  TFile* file = TFile::Open(fOutputDirName + "/digitizer.root", "recreate");
   this->Write();
-  if (fCopyTreesFromInput > -1) {
-    fInputFiles[fCopyTreesFromInput]->Get("TE")->Clone()->Write();
-    gAlice->Write();
-  }
-  fOutput->Close();
+  file->Close();
+  delete file;
+  if (fOutRunLoader)
+   {
+     fOutRunLoader->WriteHeader("OVERWRITE");
+     fOutRunLoader->WriteRunLoader("OVERWRITE");
+     TFolder* outfolder = fOutRunLoader->GetEventFolder();
+     if (outfolder == 0x0)
+     {
+       Error("FinishEvent","Can not get Event Folder");
+       return;
+     }    
+  
+     AliRunLoader* inRN = AliRunLoader::GetRunLoader(GetInputFolderName(0));
+     outfolder->Add(inRN->GetAliRun());
+     fOutRunLoader->WriteAliRun("OVERWRITE");
+   }
+   
+  if (fCopyTreesFromInput > -1) 
+   {
+     //copy files manually
+   }
 }
+//_______________________________________________________________________
 
-
-////////////////////////////////////////////////////////////////////////
 Int_t  AliRunDigitizer::GetNParticles(Int_t event) const
 {
 // return number of particles in all input files for a given
@@ -440,9 +492,9 @@ Int_t  AliRunDigitizer::GetNParticles(Int_t event) const
   }
   return sum;
 }
+//_______________________________________________________________________
 
-////////////////////////////////////////////////////////////////////////
-Int_t  AliRunDigitizer::GetNParticles(Int_t event, Int_t input) const
+Int_t  AliRunDigitizer::GetNParticles(Int_t /*event*/, Int_t /*input*/) const
 {
 // return number of particles in input file input for a given
 // event (as numbered in this input file)
@@ -452,35 +504,9 @@ Int_t  AliRunDigitizer::GetNParticles(Int_t event, Int_t input) const
 
   return -1;
 
-/*
-  TFile *file = ConnectInputFile(input);
-  if (!file) {
-    Error("GetNParticles","Cannot open input file");
-    return -1;
-  }
-
-// find the header and get Nprimaries and Nsecondaries
-  TTree* tE = (TTree *)file->Get("TE") ;
-  if (!tE) {
-    Error("GetNParticles","input file does not contain TE");
-    return -1;
-  }
-  AliHeader* header;
-  header = 0;
-  tE->SetBranchAddress("Header", &header);
-  if (!tE->GetEntry(event)) {
-    Error("GetNParticles","event %d not found",event);
-    return -1;
-  }
-  if (GetDebug()>2) {
-    cerr<<"Nprimary: "<< header->GetNprimary()<<endl;
-    cerr<<"Nsecondary: "<<header->GetNsecondary()<<endl;
-  }
-  return header->GetNprimary() + header->GetNsecondary();
-*/
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 Int_t* AliRunDigitizer::GetInputEventNumbers(Int_t event) const
 {
 // return pointer to an int array with input event numbers which were
@@ -493,8 +519,8 @@ Int_t* AliRunDigitizer::GetInputEventNumbers(Int_t event) const
   }
   return a;
 }
-////////////////////////////////////////////////////////////////////////
-Int_t AliRunDigitizer::GetInputEventNumber(Int_t event, Int_t input) const
+//_______________________________________________________________________
+Int_t AliRunDigitizer::GetInputEventNumber(Int_t event, Int_t /*input*/) const
 {
 // return an event number of an eventInput from input file input
 // which was merged to create output event event
@@ -502,7 +528,7 @@ Int_t AliRunDigitizer::GetInputEventNumber(Int_t event, Int_t input) const
 // simplified for now, implement later
   return event;
 }
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t event) const
 {
 // return pointer to particle with index i (index with mask)
@@ -512,8 +538,8 @@ TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t event) const
   return GetParticle(i,input,GetInputEventNumber(event,input));
 }
 
-////////////////////////////////////////////////////////////////////////
-TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t input, Int_t event) const
+//_______________________________________________________________________
+TParticle* AliRunDigitizer::GetParticle(Int_t /*i*/, Int_t /*input*/, Int_t /*event*/) const
 {
 // return pointer to particle with index i in the input file input
 // (index without mask)
@@ -523,56 +549,9 @@ TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t input, Int_t event) const
 // Must be revised in the version with AliStream
 
   return 0;
-/*
-  TFile *file = ConnectInputFile(input);
-  if (!file) {
-    Error("GetParticle","Cannot open input file");
-    return 0;
-  }
-
-// find the header and get Nprimaries and Nsecondaries
-  TTree* tE = (TTree *)file->Get("TE") ;
-  if (!tE) {
-    Error("GetParticle","input file does not contain TE");
-    return 0;
-  }
-  AliHeader* header;
-  header = 0;
-  tE->SetBranchAddress("Header", &header);
-  if (!tE->GetEntry(event)) {
-    Error("GetParticle","event %d not found",event);
-    return 0;
-  }
-  
-// connect TreeK  
-  char treeName[30];
-  sprintf(treeName,"TreeK%d",event);  
-  TTree* tK = static_cast<TTree*>(file->Get(treeName));
-  if (!tK) {
-    Error("GetParticle","input file does not contain TreeK%d",event);
-    return 0;
-  }
-  TParticle *particleBuffer;
-  particleBuffer = 0;
-  tK->SetBranchAddress("Particles", &particleBuffer);
-
-
-// algorithmic way of getting entry index
-// (primary particles are filled after secondaries)
-  Int_t entry;
-  if (i<header->GetNprimary())
-    entry = i+header->GetNsecondary();
-  else 
-    entry = i-header->GetNprimary();
-  Int_t bytesRead = tK->GetEntry(entry);
-//  new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
-  if (bytesRead)
-    return particleBuffer;
-  return  0;
-*/
 }
 
-////////////////////////////////////////////////////////////////////////
+//_______________________________________________________________________
 void AliRunDigitizer::ExecuteTask(Option_t* option)
 {
 // overwrite ExecuteTask to do Digitize only
@@ -582,3 +561,49 @@ void AliRunDigitizer::ExecuteTask(Option_t* option)
   fHasExecuted = kTRUE;
   return;
 }
+
+//_______________________________________________________________________
+const TString& AliRunDigitizer::GetInputFolderName(Int_t i) const
+{
+  AliStream* stream = dynamic_cast<AliStream*>(fInputStreams->At(i));
+  if (stream == 0x0)
+   {
+     Fatal("GetInputFolderName","Can not get the input stream. Index = %d. Exiting",i);
+   }
+  return stream->GetFolderName();
+}
+//_______________________________________________________________________
+
+const char* AliRunDigitizer::GetOutputFolderName()
+{
+  return GetOutRunLoader()->GetEventFolder()->GetName();
+}
+//_______________________________________________________________________
+
+AliRunLoader* AliRunDigitizer::GetOutRunLoader()
+{
+  if (fOutRunLoader) return fOutRunLoader;
+  
+  if ( fOutputFileName.IsNull() )
+   {//guard that sombody calls it without settting file name
+    cout<<"Output file name is empty. Using Input 0 for output\n";
+    return AliRunLoader::GetRunLoader(GetInputFolderName(0));
+   }
+//  InitOutputGlobal();
+  return fOutRunLoader;
+}
+//_______________________________________________________________________
+
+TString AliRunDigitizer::GetInputFileName(Int_t input, Int_t order) const 
+{
+// returns file name of the order-th file in the input stream input
+// returns empty string if such file does not exist
+// first input stream is 0
+// first file in the input stream is 0
+  TString fileName("");
+  if (input >= fNinputs) return fileName;
+  AliStream * stream = static_cast<AliStream*>(fInputStreams->At(input));
+  if (order > stream->GetNInputFiles()) return fileName;
+  fileName = stream->GetFileName(order);
+  return fileName;
+}