Removing the tasks from the digitization (Ruben)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 23 Oct 2011 15:46:57 +0000 (15:46 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 23 Oct 2011 15:46:57 +0000 (15:46 +0000)
122 files changed:
ACORDE/AliACORDE.cxx
ACORDE/AliACORDE.h
ACORDE/AliACORDEDigitizer.cxx
ACORDE/AliACORDEDigitizer.h
ACORDE/AliACORDERawReader.cxx
ACORDE/AliACORDERawReader.h
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALDigitizer.cxx
EMCAL/AliEMCALDigitizer.h
EMCAL/AliEMCALLoader.h
EMCAL/AliEMCALPID.h
EMCAL/AliEMCALPIDUtils.h
EMCAL/AliEMCALSDigitizer.cxx
EMCAL/AliEMCALSDigitizer.h
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDBaseDigitizer.cxx
FMD/AliFMDBaseDigitizer.h
FMD/AliFMDDigitizer.cxx
FMD/AliFMDDigitizer.h
FMD/AliFMDHitDigitizer.cxx
FMD/AliFMDHitDigitizer.h
HMPID/AliHMPIDDigitizer.cxx
HMPID/AliHMPIDDigitizer.h
HMPID/AliHMPIDPid.cxx
HMPID/AliHMPIDPid.h
HMPID/AliHMPIDRecon.cxx
HMPID/AliHMPIDRecon.h
HMPID/AliHMPIDReconHTA.cxx
HMPID/AliHMPIDReconHTA.h
HMPID/AliHMPIDv1.h
HMPID/AliHMPIDv2.h
HMPID/AliHMPIDv3.h
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSDigitizer.cxx
ITS/AliITSDigitizer.h
ITS/AliITSreconstruction.h
ITS/AliITSsDigitize.cxx
ITS/AliITSsDigitize.h
ITS/UPGRADE/AliITSUpg.cxx
ITS/UPGRADE/AliITSUpg.h
ITS/UPGRADE/AliITSupgrade.h
ITS/UPGRADE/AliITSupgradeDigitizer.cxx
ITS/UPGRADE/AliITSupgradeDigitizer.h
MFT/AliMFT.h
MFT/AliMFTDigitizer.cxx
MFT/AliMFTDigitizer.h
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONDigitizerV3.h
MUON/AliMUONSDigitizerV2.cxx
MUON/AliMUONSDigitizerV2.h
MUON/Doxymodules_STEER.h
PHOS/AliPHOS.cxx
PHOS/AliPHOS.h
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSDigitizer.h
PHOS/AliPHOSLoader.cxx
PHOS/AliPHOSLoader.h
PHOS/AliPHOSSDigitizer.cxx
PHOS/AliPHOSSDigitizer.h
PMD/AliPMD.cxx
PMD/AliPMD.h
PMD/AliPMDDigitizer.cxx
PMD/AliPMDDigitizer.h
PWG4/PartCorrBase/AliCaloPID.cxx
PWG4/PartCorrBase/AliCaloPID.h
STEER/AliHMPIDPIDResponse.cxx
STEER/AliHMPIDPIDResponse.h
STEER/CMakelibSTEER.pkg
STEER/STEER/AliConfig.cxx
STEER/STEER/AliConfig.h
STEER/STEER/AliDataLoader.cxx
STEER/STEER/AliDataLoader.h
STEER/STEER/AliDigitizationInput.cxx [moved from STEER/STEER/AliRunDigitizer.cxx with 79% similarity]
STEER/STEER/AliDigitizationInput.h [moved from STEER/STEER/AliRunDigitizer.h with 87% similarity]
STEER/STEER/AliDigitizer.cxx
STEER/STEER/AliDigitizer.h
STEER/STEER/AliLoader.cxx
STEER/STEER/AliLoader.h
STEER/STEER/AliModule.cxx
STEER/STEER/AliModule.h
STEER/STEER/AliRunLoader.cxx
STEER/STEER/AliRunLoader.h
STEER/STEER/AliSimulation.cxx
STEER/STEER/AliTaskLoader.cxx [deleted file]
STEER/STEER/AliTaskLoader.h [deleted file]
STEER/STEERLinkDef.h
T0/AliT0.cxx
T0/AliT0.h
T0/AliT0Digitizer.cxx
T0/AliT0Digitizer.h
T0/AliT0Loader.cxx
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFClusterFinder.cxx
TOF/AliTOFClusterFinder.h
TOF/AliTOFClusterFinderV1.cxx
TOF/AliTOFClusterFinderV1.h
TOF/AliTOFDigitizer.cxx
TOF/AliTOFDigitizer.h
TOF/AliTOFSDigitizer.cxx
TOF/AliTOFSDigitizer.h
TPC/AliTPC.cxx
TPC/AliTPC.h
TPC/AliTPCDigitizer.cxx
TPC/AliTPCDigitizer.h
TRD/AliTRD.cxx
TRD/AliTRD.h
TRD/AliTRDdigitizer.cxx
TRD/AliTRDdigitizer.h
VZERO/AliVZERO.cxx
VZERO/AliVZERO.h
VZERO/AliVZERODigitizer.cxx
VZERO/AliVZERODigitizer.h
ZDC/AliZDC.cxx
ZDC/AliZDC.h
ZDC/AliZDCDigitizer.cxx
ZDC/AliZDCDigitizer.h

index 1432368..1fcb976 100644 (file)
@@ -234,11 +234,11 @@ AliLoader* AliACORDE::MakeLoader(const char* topfoldername)
 }
 
 
-AliDigitizer* AliACORDE::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliACORDE::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   //
   //
-  return new AliACORDEDigitizer(manager);
+  return new AliACORDEDigitizer(digInput);
 }
 
 void AliACORDE::Digits2Raw()
index b77606a..7631e08 100644 (file)
@@ -33,7 +33,7 @@ public:
 
   virtual AliLoader* MakeLoader(const char* topfoldername);
 
-  AliDigitizer*  CreateDigitizer(AliRunDigitizer* manager) const;
+  AliDigitizer*  CreateDigitizer(AliDigitizationInput* digInput) const;
 
   virtual AliTriggerDetector* CreateTriggerDetector() const
   { return new AliACORDETrigger(); }
index 163c4b5..ec780d2 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliACORDEhit.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
@@ -56,8 +56,8 @@ AliACORDEDigitizer::AliACORDEDigitizer()
   // default constructor
 }
 
-AliACORDEDigitizer::AliACORDEDigitizer(AliRunDigitizer* manager)
-  :AliDigitizer(manager),
+AliACORDEDigitizer::AliACORDEDigitizer(AliDigitizationInput* digInput)
+  :AliDigitizer(digInput),
    fCalibData(GetCalibData()),
    fNdigits(0),
    fDigits(0)
@@ -89,7 +89,7 @@ Bool_t AliACORDEDigitizer::Init()
   return kTRUE;
 }
 
-void AliACORDEDigitizer::Exec(Option_t* /*option*/)
+void AliACORDEDigitizer::Digitize(Option_t* /*option*/)
 {
 
   // Creates digits from hits
@@ -128,7 +128,7 @@ void AliACORDEDigitizer::Exec(Option_t* /*option*/)
 
   // 2.- get loaders
   AliRunLoader* outRunLoader =
-    AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+    AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   if (!outRunLoader) {
     Error("Exec", "Can not get output Run Loader");
     return;}
@@ -146,9 +146,9 @@ void AliACORDEDigitizer::Exec(Option_t* /*option*/)
   treeD->Branch("ACORDEdigit", &fDigits, bufsize);
   
   // 3. loop over inputs
-  for (Int_t iInput = 0; iInput < fManager->GetNinputs(); iInput++) {
+  for (Int_t iInput = 0; iInput < fDigInput->GetNinputs(); iInput++) {
     AliRunLoader* runLoader =
-      AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
+      AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iInput));
     AliLoader* loader = runLoader->GetLoader("ACORDELoader");
     if (!loader) {
       Error("Exec", "Can not get ACORDE Loader for input %d", iInput);
index 8630a95..b510b09 100644 (file)
@@ -16,7 +16,7 @@
 #include "AliDigitizer.h"
 
 class TClonesArray;
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliCDBManager;
 class AliCDBStorage;
 class AliACORDECalibData;
@@ -26,11 +26,11 @@ class AliACORDEDigitizer: public AliDigitizer {
  public:
 
    AliACORDEDigitizer() ;                       // constructor
-   AliACORDEDigitizer(AliRunDigitizer *manager);// constructor
+   AliACORDEDigitizer(AliDigitizationInput* digInput);// constructor
    virtual ~AliACORDEDigitizer() ;              // destructor
   
    virtual Bool_t Init();
-   virtual void   Exec(Option_t* option=0);
+   virtual void   Digitize(Option_t* option=0);
 
    void AddDigit(Int_t* track, Int_t module, Float_t time);
    void AddDigit(Int_t* modul, Float_t time);  
index 8f0e274..c6900f3 100755 (executable)
@@ -34,7 +34,7 @@
 ClassImp(AliACORDERawReader)
   
 AliACORDERawReader::AliACORDERawReader (AliRawReader *rawReader, Bool_t isOnline):
-       TTask("ACORDERawReader","read raw ACORDE data"),
+       TNamed("ACORDERawReader","read raw ACORDE data"),
        fRawReader(rawReader),
        fData(NULL),
        fPosition(0),
index b92c6db..4cdd0f6 100755 (executable)
 //     Mario Rodriguez Cahuantzi <mrodrigu@mail.cern.ch>
 //     Arturo Fernandez Tellez   <afernan@mail.cern.ch>
  
-#include <TTask.h>
+#include <TNamed.h>
 #include "AliRawReader.h"
 
   
-class AliACORDERawReader : public TTask {
+class AliACORDERawReader : public TNamed {
   public :
 
   AliACORDERawReader(AliRawReader *rawReader,Bool_t isOnline = kFALSE) ;
 //AliACORDERawReader(AliRawReader *rawReader,Bool_t isOnline = kTRUE) ;
 
   virtual  ~AliACORDERawReader();
-  AliACORDERawReader(const AliACORDERawReader& o): TTask(o),fRawReader(0),fData(NULL),fPosition(0),fIsOnline(kFALSE),fDataSize(0)
+  AliACORDERawReader(const AliACORDERawReader& o): TNamed(o),fRawReader(0),fData(NULL),fPosition(0),fIsOnline(kFALSE),fDataSize(0)
 {
        fWord[0] = fWord[1] = fWord[2] = fWord[3] = 0;
 }
@@ -64,7 +64,7 @@ enum EACORDERawStreamError {
       kRawDataSizeErr = 1
   };
   
- ClassDef(AliACORDERawReader,2) //class for reading ACORDE Raw data
+ ClassDef(AliACORDERawReader,3) //class for reading ACORDE Raw data
 };
 
 typedef AliACORDERawReader AliSTARTRawReader; // for backward compatibility
index d9efcc1..fd35406 100644 (file)
@@ -100,12 +100,6 @@ AliEMCAL::~AliEMCAL()
   //dtor
   delete fgRawUtils;
   delete fTriggerData;
-    
-  AliLoader *emcalLoader=0;
-  if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
-    emcalLoader->CleanSDigitizer();
-  
-
 }
 
 //____________________________________________________________________________
@@ -196,10 +190,10 @@ void AliEMCAL::InitConstants()
 // }
 
 //____________________________________________________________________________
-AliDigitizer* AliEMCAL::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliEMCAL::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   //create and return the digitizer
-  return new AliEMCALDigitizer(manager);
+  return new AliEMCALDigitizer(digInput);
 }
 
 //____________________________________________________________________________
@@ -314,7 +308,7 @@ void AliEMCAL::Hits2SDigits()
   GetGeometry();
   AliEMCALSDigitizer emcalDigitizer(fLoader->GetRunLoader()->GetFileName().Data()) ;
   emcalDigitizer.SetEventRange(0, -1) ; // do all the events
-  emcalDigitizer.ExecuteTask() ;
+  emcalDigitizer.Digitize() ;
 }
 
 //______________________________________________________________________
index 4e2ea5a..4da1b44 100644 (file)
@@ -31,7 +31,6 @@
 // --- ROOT system ---
 
 class TString ;
-class TTask ;
 class TFolder ;
 class TRandom ; 
 class TGraph;
@@ -57,7 +56,7 @@ class AliEMCAL : public AliDetector {
   virtual void   AddHit(Int_t, Int_t*, Float_t *) {
     Fatal("AddHit(Int_t, Int_t*, Float_t *", "not to be used: use AddHit( Int_t shunt, Int_t primary, Int_t track,Int_t id, Float_t *hits )") ;  
   }
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
   virtual void  CreateMaterials() ;   
   virtual void  Init() ;   
   virtual void  Digits2Raw();
index 8a6bc31..40b4ce9 100644 (file)
@@ -54,7 +54,7 @@
 // --- AliRoot header files ---
 #include "AliLog.h"
 #include "AliRun.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRunLoader.h"
 #include "AliCDBManager.h"
 #include "AliCDBEntry.h"
@@ -133,16 +133,17 @@ AliEMCALDigitizer::AliEMCALDigitizer()
     fEventFolderName(""),
     fFirstEvent(0),
     fLastEvent(0),
-    fCalibData(0x0)
+    fCalibData(0x0),
+    fSDigitizer(0x0)
 {
   // ctor
   InitParameters() ; 
-  fManager = 0 ;                     // We work in the standalone mode
+  fDigInput = 0 ;                     // We work in the standalone mode
 }
 
 //____________________________________________________________________________ 
 AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName)
-  : AliDigitizer("EMCAL"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName),
+  : AliDigitizer("EMCALDigitizer", alirunFileName),
     fDefaultInit(kFALSE),
     fDigitsInRun(0),
     fInit(0),
@@ -165,12 +166,13 @@ AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolder
     fEventFolderName(eventFolderName),
     fFirstEvent(0),
     fLastEvent(0),
-    fCalibData(0x0)
+    fCalibData(0x0),
+    fSDigitizer(0x0)
 {
   // ctor
   InitParameters() ; 
   Init() ;
-  fManager = 0 ;                     // We work in the standalone mode
+  fDigInput = 0 ;                     // We work in the standalone mode
 }
 
 //____________________________________________________________________________ 
@@ -197,14 +199,15 @@ AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
     fEventFolderName(d.fEventFolderName),
     fFirstEvent(d.fFirstEvent),
     fLastEvent(d.fLastEvent),
-    fCalibData(d.fCalibData)
+    fCalibData(d.fCalibData),
+    fSDigitizer(d.fSDigitizer ? new AliEMCALSDigitizer(*d.fSDigitizer) : 0)
 {
   // copyy ctor 
 }
 
 //____________________________________________________________________________ 
-AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
-  : AliDigitizer(rd,"EMCAL"+AliConfig::Instance()->GetDigitizerTaskName()),
+AliEMCALDigitizer::AliEMCALDigitizer(AliDigitizationInput * rd)
+  : AliDigitizer(rd,"EMCALDigitizer"),
     fDefaultInit(kFALSE),
     fDigitsInRun(0),
     fInit(0),
@@ -227,12 +230,13 @@ AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
     fEventFolderName(0),
     fFirstEvent(0),
     fLastEvent(0),
-    fCalibData(0x0)
+    fCalibData(0x0),
+    fSDigitizer(0x0)
 {
   // ctor Init() is called by RunDigitizer
-  fManager = rd ; 
-  fEventFolderName = fManager->GetInputFolderName(0) ;
-  SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
+  fDigInput = rd ; 
+  fEventFolderName = fDigInput->GetInputFolderName(0) ;
+  SetTitle(dynamic_cast<AliStream*>(fDigInput->GetInputStream(0))->GetFileName(0));
   InitParameters() ; 
 }
 
@@ -240,17 +244,9 @@ AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
   AliEMCALDigitizer::~AliEMCALDigitizer()
 {
   //dtor
-  if (AliRunLoader::Instance()) {
-    AliLoader *emcalLoader=0;
-    if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
-      emcalLoader->CleanDigitizer();
-  }
-  else
-    AliDebug(1," no runloader present");
-  
   delete [] fInputFileNames ; 
   delete [] fEventNames ; 
-  
+  if (fSDigitizer) delete fSDigitizer;
 }
 
 //____________________________________________________________________________
@@ -274,9 +270,9 @@ void AliEMCALDigitizer::Digitize(Int_t event)
   
   if(emcalLoader){
     Int_t readEvent = event ; 
-    // fManager is data member from AliDigitizer
-    if (fManager) 
-      readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
+    // fDigInput is data member from AliDigitizer
+    if (fDigInput) 
+      readEvent = dynamic_cast<AliStream*>(fDigInput->GetInputStream(0))->GetCurrentEventNumber() ; 
     AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
                     readEvent, GetTitle(), fEventFolderName.Data())) ; 
     rl->GetEvent(readEvent);
@@ -301,39 +297,31 @@ void AliEMCALDigitizer::Digitize(Int_t event)
     
     digits->Expand(nEMC) ;
     
-    // get first the sdigitizer from the tasks list (must have same name as the digitizer)
-    if ( !emcalLoader->SDigitizer() ) 
-      emcalLoader->LoadSDigitizer();
-    AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer()); 
-    
-    if (!sDigitizer )
-    {
-      Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
-    }
-    else
-    {
-      
-      //take all the inputs to add together and load the SDigits
-      TObjArray * sdigArray = new TObjArray(fInput) ;
-      sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
-      Int_t i ;
-      Int_t embed = kFALSE;
-      for(i = 1 ; i < fInput ; i++){
-        TString tempo(fEventNames[i]) ; 
-        tempo += i ;
+    // RS create a digitizer on the fly
+    if (!fSDigitizer) fSDigitizer = new AliEMCALSDigitizer(rl->GetFileName().Data());
+    fSDigitizer->SetEventRange(0, -1) ;
+    //
+    //take all the inputs to add together and load the SDigits
+    TObjArray * sdigArray = new TObjArray(fInput) ;
+    sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
+    Int_t i ;
+    Int_t embed = kFALSE;
+    for(i = 1 ; i < fInput ; i++){
+      TString tempo(fEventNames[i]) ; 
+      tempo += i ;
         
-        AliRunLoader *  rl2 = AliRunLoader::GetRunLoader(tempo) ; 
+      AliRunLoader *  rl2 = AliRunLoader::GetRunLoader(tempo) ; 
         
-        if (rl2==0) 
-          rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
+      if (rl2==0) 
+       rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
         
-        if (fManager) 
-          readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
-        Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
-        rl2->LoadSDigits();
-        //     rl2->LoadDigits();
-        rl2->GetEvent(readEvent);
-        if(rl2->GetDetectorLoader("EMCAL"))
+      if (fDigInput) 
+       readEvent = dynamic_cast<AliStream*>(fDigInput->GetInputStream(i))->GetCurrentEventNumber() ; 
+      Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
+      rl2->LoadSDigits();
+      //     rl2->LoadDigits();
+      rl2->GetEvent(readEvent);
+      if(rl2->GetDetectorLoader("EMCAL"))
         {
           AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
  
@@ -345,11 +333,11 @@ void AliEMCALDigitizer::Digitize(Int_t event)
               // Check if first sdigit is of embedded type, if so, handle the sdigits differently:
               // do not smear energy of embedded, do not add noise to any sdigits
               if(sdigits2->GetEntriesFast()>0){
-                 //printf("Merged digit type: %d\n",dynamic_cast<AliEMCALDigit*> (sdigits2->At(0))->GetType());
-                 AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*> (sdigits2->At(0));
-                 if(digit2 && digit2->GetType()==AliEMCALDigit::kEmbedded){
-                   embed = kTRUE;
-                 }
+               //printf("Merged digit type: %d\n",dynamic_cast<AliEMCALDigit*> (sdigits2->At(0))->GetType());
+               AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*> (sdigits2->At(0));
+               if(digit2 && digit2->GetType()==AliEMCALDigit::kEmbedded){
+                 embed = kTRUE;
+               }
               }
             }
             
@@ -357,259 +345,258 @@ void AliEMCALDigitizer::Digitize(Int_t event)
           else  AliFatal("EMCAL Loader of second event not available!");
           
         }
-        else Fatal("Digitize", "Loader of second input not found");
-      }// input loop
+      else Fatal("Digitize", "Loader of second input not found");
+    }// input loop
       
-      //Find the first tower with signal
-      Int_t nextSig = nEMC + 1 ; 
-      TClonesArray * sdigits ;  
-      for(i = 0 ; i < fInput ; i++){
-        if(i > 0 && embed) continue;
-        sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
-        if(sdigits){
-          if (sdigits->GetEntriesFast() ){
-            AliEMCALDigit *sd = dynamic_cast<AliEMCALDigit *>(sdigits->At(0));
-            if(sd){
-              Int_t curNext = sd->GetId() ;
-              if(curNext < nextSig) 
-                nextSig = curNext ;
-              AliDebug(1,Form("input %i : #sdigits %i \n",
-                              i, sdigits->GetEntriesFast()));
+    //Find the first tower with signal
+    Int_t nextSig = nEMC + 1 ; 
+    TClonesArray * sdigits ;  
+    for(i = 0 ; i < fInput ; i++){
+      if(i > 0 && embed) continue;
+      sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
+      if(sdigits){
+       if (sdigits->GetEntriesFast() ){
+         AliEMCALDigit *sd = dynamic_cast<AliEMCALDigit *>(sdigits->At(0));
+         if(sd){
+           Int_t curNext = sd->GetId() ;
+           if(curNext < nextSig) 
+             nextSig = curNext ;
+           AliDebug(1,Form("input %i : #sdigits %i \n",
+                           i, sdigits->GetEntriesFast()));
               
-            }//First entry is not NULL
-            else {
-              Info("Digitize", "NULL sdigit pointer");
-              continue;
-            }
-          }//There is at least one entry
-          else {
-            Info("Digitize", "NULL sdigits array");
-            continue;
-          }
-        }// SDigits array exists
-        else {
-          Info("Digitizer","Null sdigit pointer");
-          continue;
-        }
-      }// input loop
-      AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
+         }//First entry is not NULL
+         else {
+           Info("Digitize", "NULL sdigit pointer");
+           continue;
+         }
+       }//There is at least one entry
+       else {
+         Info("Digitize", "NULL sdigits array");
+         continue;
+       }
+      }// SDigits array exists
+      else {
+       Info("Digitizer","Null sdigit pointer");
+       continue;
+      }
+    }// input loop
+    AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
       
-      TArrayI index(fInput) ;
-      index.Reset() ;  //Set all indexes to zero
+    TArrayI index(fInput) ;
+    index.Reset() ;  //Set all indexes to zero
       
-      AliEMCALDigit * digit ;
-      AliEMCALDigit * curSDigit ;
+    AliEMCALDigit * digit ;
+    AliEMCALDigit * curSDigit ;
       
-      //Put Noise contribution, smear time and energy     
-      Float_t timeResolution = 0;
-      for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
-        Float_t energy = 0 ;    
+    //Put Noise contribution, smear time and energy     
+    Float_t timeResolution = 0;
+    for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
+      Float_t energy = 0 ;    
         
-        // amplitude set to zero, noise will be added later
-        Float_t noiseTime = 0.;
-        if(!embed) noiseTime = TimeOfNoise(); //No need for embedded events?
-        new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., noiseTime,kFALSE); // absID-1->absID
-        //look if we have to add signal?
-        digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
+      // amplitude set to zero, noise will be added later
+      Float_t noiseTime = 0.;
+      if(!embed) noiseTime = TimeOfNoise(); //No need for embedded events?
+      new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., noiseTime,kFALSE); // absID-1->absID
+      //look if we have to add signal?
+      digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
         
-        if (digit) {
+      if (digit) {
           
-          if(absID==nextSig){
+       if(absID==nextSig){
 
-            // Calculate time as time of the largest digit
-            Float_t time = digit->GetTime() ;
-            Float_t aTime= digit->GetAmplitude() ;
+         // Calculate time as time of the largest digit
+         Float_t time = digit->GetTime() ;
+         Float_t aTime= digit->GetAmplitude() ;
             
-            // loop over input
-            Int_t nInputs = fInput;
-            if(embed) nInputs = 1; // In case of embedding, merge later real digits, do not smear energy and time of data
-            for(i = 0; i< nInputs ; i++){  //loop over (possible) merge sources
-              TClonesArray* sdtclarr = dynamic_cast<TClonesArray *>(sdigArray->At(i));
-              if(sdtclarr) {
-                Int_t sDigitEntries = sdtclarr->GetEntriesFast();
+         // loop over input
+         Int_t nInputs = fInput;
+         if(embed) nInputs = 1; // In case of embedding, merge later real digits, do not smear energy and time of data
+         for(i = 0; i< nInputs ; i++){  //loop over (possible) merge sources
+           TClonesArray* sdtclarr = dynamic_cast<TClonesArray *>(sdigArray->At(i));
+           if(sdtclarr) {
+             Int_t sDigitEntries = sdtclarr->GetEntriesFast();
                 
-                if(sDigitEntries > index[i] )
-                  curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;   
-                else
-                  curSDigit = 0 ;
+             if(sDigitEntries > index[i] )
+               curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;      
+             else
+               curSDigit = 0 ;
                 
-                //May be several digits will contribute from the same input
-                while(curSDigit && (curSDigit->GetId() == absID)){        
-                  //Shift primary to separate primaries belonging different inputs
-                  Int_t primaryoffset ;
-                  if(fManager)
-                    primaryoffset = fManager->GetMask(i) ; 
-                  else
-                    primaryoffset = i ;
-                  curSDigit->ShiftPrimary(primaryoffset) ;
+             //May be several digits will contribute from the same input
+             while(curSDigit && (curSDigit->GetId() == absID)){           
+               //Shift primary to separate primaries belonging different inputs
+               Int_t primaryoffset ;
+               if(fDigInput)
+                 primaryoffset = fDigInput->GetMask(i) ; 
+               else
+                 primaryoffset = i ;
+               curSDigit->ShiftPrimary(primaryoffset) ;
                   
-                  if(curSDigit->GetAmplitude()>aTime) {
-                    aTime = curSDigit->GetAmplitude();
-                    time  = curSDigit->GetTime();
-                  }
+               if(curSDigit->GetAmplitude()>aTime) {
+                 aTime = curSDigit->GetAmplitude();
+                 time  = curSDigit->GetTime();
+               }
                   
-                  *digit = *digit + *curSDigit ;  //adds amplitudes of each digit
+               *digit = *digit + *curSDigit ;  //adds amplitudes of each digit
                   
-                  index[i]++ ;
+               index[i]++ ;
                   
-                  if( sDigitEntries > index[i] )
-                    curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
-                  else
-                    curSDigit = 0 ;
-                }// while
-              }// source exists
-            }// loop over merging sources
+               if( sDigitEntries > index[i] )
+                 curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
+               else
+                 curSDigit = 0 ;
+             }// while
+           }// source exists
+         }// loop over merging sources
             
             
-            //Here we convert the summed amplitude to an energy in GeV only for simulation or mixing of simulations
-            energy = sDigitizer->Calibrate(digit->GetAmplitude()) ; // GeV
+         //Here we convert the summed amplitude to an energy in GeV only for simulation or mixing of simulations
+         energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ; // GeV
             
-            // add fluctuations for photo-electron creation
-            energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
+         // add fluctuations for photo-electron creation
+         energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
             
-            //calculate and set time
-            digit->SetTime(time) ;
+         //calculate and set time
+         digit->SetTime(time) ;
             
-            //Find next signal module
-            nextSig = nEMC + 1 ;
-            for(i = 0 ; i < nInputs ; i++){
-              sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
+         //Find next signal module
+         nextSig = nEMC + 1 ;
+         for(i = 0 ; i < nInputs ; i++){
+           sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
               
-              if(sdigits){
-                Int_t curNext = nextSig ;
-                if(sdigits->GetEntriesFast() > index[i])
+           if(sdigits){
+             Int_t curNext = nextSig ;
+             if(sdigits->GetEntriesFast() > index[i])
                 {
                   AliEMCALDigit * tmpdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]));
                   if(tmpdigit)
-                  {
-                    curNext = tmpdigit->GetId() ;        
-                  }
+                   {
+                     curNext = tmpdigit->GetId() ;       
+                   }
                 }
-                if(curNext < nextSig) nextSig = curNext ;
-              }// sdigits exist
-            } // input loop       
+             if(curNext < nextSig) nextSig = curNext ;
+           }// sdigits exist
+         } // input loop       
             
-          }//absID==nextSig
+       }//absID==nextSig
           
-          // add the noise now, no need for embedded events with real data
-          if(!embed)
-            energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
+       // add the noise now, no need for embedded events with real data
+       if(!embed)
+         energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
           
 
-          // JLK 26-June-2008
-          //Now digitize the energy according to the sDigitizer method,
-          //which merely converts the energy to an integer.  Later we will
-          //check that the stored value matches our allowed dynamic ranges
-          digit->SetAmplitude(sDigitizer->Digitize(energy)) ; 
+       // JLK 26-June-2008
+       //Now digitize the energy according to the fSDigitizer method,
+       //which merely converts the energy to an integer.  Later we will
+       //check that the stored value matches our allowed dynamic ranges
+       digit->SetAmplitude(fSDigitizer->Digitize(energy)) ; 
           
-          //Set time resolution with final energy
-          timeResolution = GetTimeResolution(energy);
-          digit->SetTime(gRandom->Gaus(digit->GetTime(),timeResolution) ) ;
-          AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
-                           absID, energy, nextSig));
-          //Add delay to time
-          digit->SetTime(digit->GetTime()+fTimeDelay) ;
+       //Set time resolution with final energy
+       timeResolution = GetTimeResolution(energy);
+       digit->SetTime(gRandom->Gaus(digit->GetTime(),timeResolution) ) ;
+       AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
+                        absID, energy, nextSig));
+       //Add delay to time
+       digit->SetTime(digit->GetTime()+fTimeDelay) ;
           
-        }// Digit pointer exists
-        else{
-          Info("Digitizer","Digit pointer is null");
-        }
-      } // for(absID = 0; absID < nEMC; absID++)
+      }// Digit pointer exists
+      else{
+       Info("Digitizer","Digit pointer is null");
+      }
+    } // for(absID = 0; absID < nEMC; absID++)
       
       //ticks->Delete() ;
       //delete ticks ;
 
       //Embed simulated amplitude (and time?) to real data digits
-      if(embed){
-        for(Int_t input = 1; input<fInput; input++){
-          TClonesArray *realDigits = dynamic_cast<TClonesArray*> (sdigArray->At(input));
-          if(!realDigits){
-            AliDebug(1,"No sdigits to merge\n");
-            continue;
-          }
-          for(Int_t i2 = 0 ; i2 < realDigits->GetEntriesFast() ; i2++){
-            AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*>( realDigits->At(i2) ) ;
-            if(digit2){
-              digit = dynamic_cast<AliEMCALDigit*>( digits->At(digit2->GetId()) ) ;
-              if(digit){
+    if(embed){
+      for(Int_t input = 1; input<fInput; input++){
+       TClonesArray *realDigits = dynamic_cast<TClonesArray*> (sdigArray->At(input));
+       if(!realDigits){
+         AliDebug(1,"No sdigits to merge\n");
+         continue;
+       }
+       for(Int_t i2 = 0 ; i2 < realDigits->GetEntriesFast() ; i2++){
+         AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*>( realDigits->At(i2) ) ;
+         if(digit2){
+           digit = dynamic_cast<AliEMCALDigit*>( digits->At(digit2->GetId()) ) ;
+           if(digit){
                 
-                // Put the embedded cell energy in same units as simulated sdigits -> transform to energy units
-                // and multiply to get a big int.
-                Float_t time2 = digit2->GetTime(); 
-                Float_t e2    = digit2->GetAmplitude();
-                CalibrateADCTime(e2,time2,digit2->GetId());
-                Float_t amp2 = sDigitizer->Digitize(e2);
+             // Put the embedded cell energy in same units as simulated sdigits -> transform to energy units
+             // and multiply to get a big int.
+             Float_t time2 = digit2->GetTime(); 
+             Float_t e2    = digit2->GetAmplitude();
+             CalibrateADCTime(e2,time2,digit2->GetId());
+             Float_t amp2 = fSDigitizer->Digitize(e2);
                 
-                Float_t e0    = digit ->GetAmplitude();
-                if(e0>0.01)
-                  AliDebug(1,Form("digit 1: Abs ID %d, amp %f, type %d, time %e; digit2: Abs ID %d, amp %f, type %d, time %e\n",
-                                  digit ->GetId(),digit ->GetAmplitude(), digit ->GetType(), digit->GetTime(),
-                                  digit2->GetId(),amp2,                   digit2->GetType(), time2           ));
+             Float_t e0    = digit ->GetAmplitude();
+             if(e0>0.01)
+               AliDebug(1,Form("digit 1: Abs ID %d, amp %f, type %d, time %e; digit2: Abs ID %d, amp %f, type %d, time %e\n",
+                               digit ->GetId(),digit ->GetAmplitude(), digit ->GetType(), digit->GetTime(),
+                               digit2->GetId(),amp2,                   digit2->GetType(), time2           ));
                 
-                // Sum amplitudes, change digit amplitude
-                digit->SetAmplitude( digit->GetAmplitude() + amp2);
-                // Rough assumption, assign time of the largest of the 2 digits, 
-                // data or signal to the final digit.
-                if(amp2 > digit->GetAmplitude())  digit->SetTime(time2);
-                //Mark the new digit as embedded
-                digit->SetType(AliEMCALDigit::kEmbedded);
+             // Sum amplitudes, change digit amplitude
+             digit->SetAmplitude( digit->GetAmplitude() + amp2);
+             // Rough assumption, assign time of the largest of the 2 digits, 
+             // data or signal to the final digit.
+             if(amp2 > digit->GetAmplitude())  digit->SetTime(time2);
+             //Mark the new digit as embedded
+             digit->SetType(AliEMCALDigit::kEmbedded);
                 
-                if(digit2->GetAmplitude()>0.01 && e0> 0.01 )
-                  AliDebug(1,Form("Embedded digit: Abs ID %d, amp %f, type %d\n",
-                                  digit->GetId(), digit->GetAmplitude(), digit->GetType()));
-              }//digit2 
-            }//digit2
-          }//loop digit 2
-        }//input loop
-      }//embed
+             if(digit2->GetAmplitude()>0.01 && e0> 0.01 )
+               AliDebug(1,Form("Embedded digit: Abs ID %d, amp %f, type %d\n",
+                               digit->GetId(), digit->GetAmplitude(), digit->GetType()));
+           }//digit2 
+         }//digit2
+       }//loop digit 2
+      }//input loop
+    }//embed
       
-      //JLK is it better to call Clear() here?
-      delete sdigArray ; //We should not delete its contents
+    //JLK is it better to call Clear() here?
+    delete sdigArray ; //We should not delete its contents
       
-      //remove digits below thresholds
-      // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
-      // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3,
-      // before merge in the same loop real data digits if available
-      Float_t energy = 0;
-      Float_t time   = 0;
-      for(i = 0 ; i < nEMC ; i++){
-        digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
-        if(digit){
+    //remove digits below thresholds
+    // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
+    // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3,
+    // before merge in the same loop real data digits if available
+    Float_t energy = 0;
+    Float_t time   = 0;
+    for(i = 0 ; i < nEMC ; i++){
+      digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
+      if(digit){
           
-          //Then get the energy in GeV units.
-          energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
-          //Then digitize using the calibration constants of the ocdb
-          Float_t ampADC = energy;
-          DigitizeEnergyTime(ampADC, time, digit->GetId())  ;    
-          if(ampADC < fDigitThreshold)
-            digits->RemoveAt(i) ;
+       //Then get the energy in GeV units.
+       energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ;
+       //Then digitize using the calibration constants of the ocdb
+       Float_t ampADC = energy;
+       DigitizeEnergyTime(ampADC, time, digit->GetId())  ;       
+       if(ampADC < fDigitThreshold)
+         digits->RemoveAt(i) ;
           
-        }// digit exists
-      } // digit loop
+      }// digit exists
+    } // digit loop
       
-      digits->Compress() ;  
+    digits->Compress() ;  
       
-      Int_t ndigits = digits->GetEntriesFast() ; 
+    Int_t ndigits = digits->GetEntriesFast() ; 
 
-      //JLK 26-June-2008
-      //After we have done the summing and digitizing to create the
-      //digits, now we want to calibrate the resulting amplitude to match
-      //the dynamic range of our real data.  
-      for (i = 0 ; i < ndigits ; i++) { 
-        digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ; 
-        if(digit){
-          digit->SetIndexInList(i) ; 
-          energy = sDigitizer->Calibrate(digit->GetAmplitude()) ;
-          time   = digit->GetTime();
-          Float_t ampADC = energy;
-          DigitizeEnergyTime(ampADC, time, digit->GetId());
-          digit->SetAmplitude(ampADC) ;
-          digit->SetTime(time);
-          // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
-        }// digit exists
-      }//Digit loop
+    //JLK 26-June-2008
+    //After we have done the summing and digitizing to create the
+    //digits, now we want to calibrate the resulting amplitude to match
+    //the dynamic range of our real data.  
+    for (i = 0 ; i < ndigits ; i++) { 
+      digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ; 
+      if(digit){
+       digit->SetIndexInList(i) ; 
+       energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ;
+       time   = digit->GetTime();
+       Float_t ampADC = energy;
+       DigitizeEnergyTime(ampADC, time, digit->GetId());
+       digit->SetAmplitude(ampADC) ;
+       digit->SetTime(time);
+       // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
+      }// digit exists
+    }//Digit loop
       
-    }//SDigitizer not null
   }
   else AliFatal("EMCALLoader is NULL!") ;
   
@@ -704,7 +691,7 @@ void AliEMCALDigitizer::CalibrateADCTime(Float_t & adc, Float_t & time, const In
 
 
 //____________________________________________________________________________
-void AliEMCALDigitizer::Exec(Option_t *option) 
+void AliEMCALDigitizer::Digitize(Option_t *option) 
 { 
   // Steering method to process digitization for events
   // in the range from fFirstEvent to fLastEvent.
@@ -713,7 +700,7 @@ void AliEMCALDigitizer::Exec(Option_t *option)
   // by default fLastEvent = fFirstEvent (process only one event)
 
   if (!fInit) { // to prevent overwrite existing file
-    Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
+    Error( "Digitize", "Give a version name different from %s", fEventFolderName.Data() ) ;
     return ;
   } 
 
@@ -733,13 +720,11 @@ void AliEMCALDigitizer::Exec(Option_t *option)
     AliFatal("Did not get the  Loader");
   }
   else{
-    // Post Digitizer to the white board
-    emcalLoader->PostDigitizer(this) ;
     
     if (fLastEvent == -1)  {
       fLastEvent = rl->GetNumberOfEvents() - 1 ;
     }
-    else if (fManager) 
+    else if (fDigInput) 
       fLastEvent = fFirstEvent ; // what is this ??
     
     nEvents = fLastEvent - fFirstEvent + 1;
@@ -768,7 +753,6 @@ void AliEMCALDigitizer::Exec(Option_t *option)
       (emcalLoader->TreeD())->Fill();
       
       emcalLoader->WriteDigits(   "OVERWRITE");
-      emcalLoader->WriteDigitizer("OVERWRITE");
       
       Unload();
       
@@ -784,14 +768,12 @@ void AliEMCALDigitizer::Exec(Option_t *option)
       //increment the total number of Digits per run 
       fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;  
     }//loop
-    
-    emcalLoader->CleanDigitizer() ;
-    
+       
   }//loader exists
   
   if(strstr(option,"tim")){
     gBenchmark->Stop("EMCALDigitizer");
-    AliInfo(Form("Exec: took %f seconds for Digitizing %f seconds per event", 
+    AliInfo(Form("Digitize: took %f seconds for Digitizing %f seconds per event", 
         gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nEvents )) ;
   } 
 }
@@ -946,8 +928,8 @@ Bool_t AliEMCALDigitizer::Init()
   fFirstEvent = 0 ; 
   fLastEvent = fFirstEvent ; 
   
-  if(fManager)
-    fInput = fManager->GetNinputs() ; 
+  if(fDigInput)
+    fInput = fDigInput->GetNinputs() ; 
   else 
     fInput           = 1 ;
 
@@ -957,14 +939,11 @@ Bool_t AliEMCALDigitizer::Init()
   fEventNames[0]     = fEventFolderName.Data() ; 
   Int_t index ; 
   for (index = 1 ; index < fInput ; index++) {
-    fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0); 
-    TString tempo = fManager->GetInputFolderName(index) ;
-    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager 
+    fInputFileNames[index] = dynamic_cast<AliStream*>(fDigInput->GetInputStream(index))->GetFileName(0); 
+    TString tempo = fDigInput->GetInputFolderName(index) ;
+    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fDigInput 
   }
-  
-  //to prevent cleaning of this object while GetEvent is called
-  emcalLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
-  
+    
   //Calibration instance
   fCalibData = emcalLoader->CalibData();
   return fInit ;    
@@ -1027,7 +1006,7 @@ void AliEMCALDigitizer::Print (Option_t * ) const
     printf(" Writing Digits to branch with title  %s\n", fEventFolderName.Data()) ;
     
     Int_t nStreams ; 
-    if (fManager) 
+    if (fDigInput) 
       nStreams =  GetNInputStreams() ;
     else 
       nStreams = fInput ; 
index 3284d0d..e4f6eb4 100644 (file)
@@ -36,7 +36,7 @@ class TBrowser;
 #include "AliConfig.h"
 class AliEMCALCalibData ;
 class AliEMCALSDigitizer ;
-class AliRunDigitizer ;
+class AliDigitizationInput ;
 
 class AliEMCALDigitizer: public AliDigitizer {
 
@@ -45,11 +45,11 @@ public:
   AliEMCALDigitizer(TString alirunFileNameFile, 
                     TString eventFolderName = AliConfig::GetDefaultEventFolderName()) ;  
   AliEMCALDigitizer(const AliEMCALDigitizer & dtizer) ;
-  AliEMCALDigitizer(AliRunDigitizer * manager) ;
+  AliEMCALDigitizer(AliDigitizationInput * manager) ;
   virtual ~AliEMCALDigitizer() ;       
 
   void     Digitize(Int_t event);   // Make Digits from SDigits stored in fSDigits
-  void     Exec(Option_t *option);  // Supervising method
+  void     Digitize(Option_t *option);  // Supervising method
 
   Int_t    GetDigitThreshold()     const { return fDigitThreshold     ; }
   Float_t  GetPinNoise()           const { return fPinNoise           ; }
@@ -124,8 +124,8 @@ private:
   Int_t    fLastEvent;            // last  event to process
        
   AliEMCALCalibData * fCalibData; //Calibration data pointer
-
-  ClassDef(AliEMCALDigitizer,11)  // description 
+  AliEMCALSDigitizer* fSDigitizer; // SDigitization object
+  ClassDef(AliEMCALDigitizer,12)  // description 
 };
 
 
index 2c98a04..0ed29b8 100644 (file)
@@ -23,7 +23,6 @@
 #include "TTree.h"
 class TString ;
 class TParticle ;
-class TTask ;
 
 // --- AliRoot header files ---
 #include "AliLoader.h"
index d984c4d..80455b3 100644 (file)
@@ -9,7 +9,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 //Root includes
-#include "TTask.h"
 class TArrayD ;
 
 //AliRoot includes
index c45ef71..d2b648c 100644 (file)
@@ -9,13 +9,13 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 //Root includes
-#include "TTask.h"
+#include "TNamed.h"
 class TArrayD ;
 
 //AliRoot includes
 #include "AliPID.h" 
 
-class AliEMCALPIDUtils : public TTask {
+class AliEMCALPIDUtils : public TNamed {
 
 public:
   
@@ -76,7 +76,7 @@ protected:
   Double_t fWeightGammaEnergy;           // Weight for a  Gamma to have a given energy  (for the moment =1.)
   Double_t fWeightPiZeroEnergy;                  // Weight for a Pi0 Hadron to have a given energy (for the moment =1.)
   
-  ClassDef(AliEMCALPIDUtils, 1)
+  ClassDef(AliEMCALPIDUtils, 2)
 
 };
 
index bb6757b..75aad40 100644 (file)
@@ -16,7 +16,7 @@
 /* $Id$ */
 
 //_________________________________________________________________________
-// This is a TTask that makes SDigits out of Hits
+// This is a Class that makes SDigits out of Hits
 // A Summable Digits is the sum of all hits originating 
 // from one in one tower of the EMCAL 
 // A threshold for assignment of the primary to SDigit is applied 
 // User case:
 // root [0] AliEMCALSDigitizer * s = new AliEMCALSDigitizer("galice.root")
 // Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-// root [1] s->ExecuteTask()
+// root [1] s->Digitize()
 //             // Makes SDigitis for all events stored in galice.root
 // root [2] s->SetPedestalParameter(0.001)
 //             // One can change parameters of digitization
 // root [3] s->SetSDigitsBranch("Redestal 0.001")
 //             // and write them into the new branch
-// root [4] s->ExeciteTask("deb all tim")
+// root [4] s->Digitize("deb all tim")
 //             // available parameters:
 //             deb - print # of produced SDigitis
 //             deb all  - print # and list of produced SDigits
@@ -77,7 +77,7 @@ ClassImp(AliEMCALSDigitizer)
            
 //____________________________________________________________________________ 
 AliEMCALSDigitizer::AliEMCALSDigitizer()
-  : TTask("",""),
+  : TNamed("",""),
     fA(0.),fB(0.),fECPrimThreshold(0.),
     fDefaultInit(kTRUE),
     fEventFolderName(0),
@@ -95,7 +95,7 @@ AliEMCALSDigitizer::AliEMCALSDigitizer()
 //____________________________________________________________________________ 
 AliEMCALSDigitizer::AliEMCALSDigitizer(const char * alirunFileName, 
                                       const char * eventFolderName)
-  : TTask("EMCAL"+AliConfig::Instance()->GetSDigitizerTaskName(), alirunFileName),
+  : TNamed("EMCALSDigitizer", alirunFileName),
     fA(0.),fB(0.),fECPrimThreshold(0.),
     fDefaultInit(kFALSE),
     fEventFolderName(eventFolderName),
@@ -115,7 +115,7 @@ AliEMCALSDigitizer::AliEMCALSDigitizer(const char * alirunFileName,
 
 //____________________________________________________________________________ 
 AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd) 
-  : TTask(sd.GetName(),sd.GetTitle()),
+  : TNamed(sd.GetName(),sd.GetTitle()),
     fA(sd.fA),
     fB(sd.fB),
     fECPrimThreshold(sd.fECPrimThreshold),
@@ -135,9 +135,6 @@ AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd)
 //____________________________________________________________________________ 
 AliEMCALSDigitizer::~AliEMCALSDigitizer() {
   //dtor
-  AliLoader *emcalLoader=0;
-  if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
-      emcalLoader->CleanSDigitizer();
        
   if(fHits){
          fHits->Clear();
@@ -147,8 +144,7 @@ AliEMCALSDigitizer::~AliEMCALSDigitizer() {
 
 //____________________________________________________________________________ 
 void AliEMCALSDigitizer::Init(){
-  // Initialization: open root-file, allocate arrays for hits and sdigits,
-  // attach task SDigitizer to the list of EMCAL tasks
+  // Initialization: open root-file, allocate arrays for hits and sdigits
   // 
   // Initialization can not be done in the default constructor
   //============================================================= YS
@@ -163,9 +159,6 @@ void AliEMCALSDigitizer::Init(){
     return ;
   } 
   
-  emcalLoader->PostSDigitizer(this);
-  emcalLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
-  
 }
 
 //____________________________________________________________________________ 
@@ -220,7 +213,7 @@ void AliEMCALSDigitizer::InitParameters()
 }
 
 //____________________________________________________________________________
-void AliEMCALSDigitizer::Exec(Option_t *option) 
+void AliEMCALSDigitizer::Digitize(Option_t *option) 
 { 
        // Collects all hit of the same tower into digits
        TString o(option); o.ToUpper();
@@ -247,11 +240,10 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
        AliRunLoader *rl = AliRunLoader::Instance();
        AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
        
-       //switch off reloading of this task while getting event
        if (!fInit) { // to prevent overwrite existing file
-               AliError( Form("Give a version name different from %s", fEventFolderName.Data()) ) ;
-               return ;
-  }
+         AliError( Form("Give a version name different from %s", fEventFolderName.Data()) ) ;
+         return ;
+       }
        
        if (fLastEvent == -1) 
                fLastEvent = rl->GetNumberOfEvents() - 1 ;
@@ -317,7 +309,7 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
                                                  Digitize(energy), hit->GetTime(),kFALSE,
                                                  -1, 0,0,energy ) ;
               } else {
-                Warning("Exec"," abs id %i is bad \n", hit->GetId());
+                Warning("Digitize"," abs id %i is bad \n", hit->GetId());
                 newsdigit = kFALSE;
                 curSDigit = 0;
               }
@@ -380,19 +372,17 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
                emcalLoader->WriteSDigits("OVERWRITE");
                
                //NEXT - SDigitizer
-               emcalLoader->WriteSDigitizer("OVERWRITE");  // why in event cycle ?
+               //emcalLoader->WriteSDigitizer("OVERWRITE");  // why in event cycle ?
                
                if(strstr(option,"deb"))
                        PrintSDigits(option) ;  
        }
        
        Unload();
-       
-       emcalLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
-       
+               
        if(strstr(option,"tim")){
                gBenchmark->Stop("EMCALSDigitizer"); 
-               printf("\n Exec: took %f seconds for SDigitizing %f seconds per event\n", 
+               printf("\n Digitize: took %f seconds for SDigitizing %f seconds per event\n", 
            gBenchmark->GetCpuTime("EMCALSDigitizer"), gBenchmark->GetCpuTime("EMCALSDigitizer")/nEvents ) ; 
        }
 }
@@ -533,5 +523,5 @@ void AliEMCALSDigitizer::Unload() const
 //____________________________________________________________________________ 
 void AliEMCALSDigitizer::Browse(TBrowser* b)
 {
-  TTask::Browse(b);
+  TNamed::Browse(b);
 }
index 9c88d82..a228f3e 100644 (file)
@@ -4,7 +4,7 @@
  * See cxx source for full Copyright notice                               */
 /* $Id$ */
 //_________________________________________________________________________
-// This is a TTask that makes SDigits out of Hits
+// This is a class that makes SDigits out of Hits
 // A Summable Digits is the sum of all hits originating 
 // from one in one tower of the EMCAL 
 // A threshold for assignment of the primary to SDigit is applied 
@@ -20,7 +20,7 @@
 //_________________________________________________________________________
  
 // --- ROOT system ---
-#include "TTask.h"
+#include "TNamed.h"
 class TBrowser;
 
 // --- Standard library ---
@@ -28,7 +28,7 @@ class TBrowser;
 // --- AliRoot header files ---
 #include "AliConfig.h"
 
-class AliEMCALSDigitizer: public TTask {
+class AliEMCALSDigitizer: public TNamed {
 
 public:
   AliEMCALSDigitizer() ;          // ctor
@@ -39,7 +39,7 @@ public:
   Float_t       Digitize(Float_t energy)const; //convert energy in GeV to int amplitude
   Float_t       Calibrate(Float_t amp)const;  //opposite of Digitize()
 
-  virtual void  Exec(Option_t *option); 
+  virtual void  Digitize(Option_t *option=""); 
   Int_t         GetSDigitsInRun() const {return fSDigitsInRun ;}  
   virtual void  Print(Option_t *option="") const;
   void          Print1(Option_t *option="all");  // *MENU*
@@ -61,7 +61,7 @@ private:
   Float_t fA ;                     // Pedestal parameter
   Float_t fB ;                     // Slope Digitizition parameters
   Float_t fECPrimThreshold ;       // To store primary if EC Shower Elos > threshold
-  Bool_t  fDefaultInit;            //! Says if the task was created by defaut ctor (only parameters are initialized)
+  Bool_t  fDefaultInit;            //! Says if the object was created by defaut ctor (only parameters are initialized)
   TString fEventFolderName;        // event folder name
   Bool_t  fInit ;                  //! tells if initialisation went OK, will revent exec if not
   Int_t   fSDigitsInRun ;          //! Total number of sdigits in one run
@@ -70,7 +70,7 @@ private:
   Float_t fSampling;               // See AliEMCALGeometry
   TClonesArray* fHits;             //-> Temporal array with hits
        
-  ClassDef(AliEMCALSDigitizer,7)  // description 
+  ClassDef(AliEMCALSDigitizer,8)  // description 
 };
 
 #endif // AliEMCALSDIGITIZER_H
index 0e35d5f..cd22e9b 100644 (file)
@@ -94,7 +94,7 @@
 #include <TVirtualMC.h>                // ROOT_TVirtualMC
 #include <cmath>                // __CMATH__
 
-#include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
+#include <AliDigitizationInput.h>      // ALIRUNDIGITIZER_H
 #include <AliLoader.h>         // ALILOADER_H
 #include <AliRun.h>            // ALIRUN_H
 #include <AliMC.h>             // ALIMC_H
@@ -943,7 +943,7 @@ AliFMD::Hits2Digits()
   // 
   AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kDigits);
   digitizer.Init();
-  digitizer.Exec("");
+  digitizer.Digitize("");
 }
 
 //____________________________________________________________________
@@ -955,13 +955,13 @@ AliFMD::Hits2SDigits()
   // 
   AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kSDigits);
   digitizer.Init();
-  digitizer.Exec("");
+  digitizer.Digitize("");
 }
 
   
 //____________________________________________________________________
 AliDigitizer* 
-AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
+AliFMD::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   // Create a digitizer object 
   
@@ -969,14 +969,14 @@ AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
   AliFMDBaseDigitizer* digitizer = 0;
   
 #ifdef USE_SSDIGITIZER
-  digitizer = new AliFMDSSDigitizer(manager);
+  digitizer = new AliFMDSSDigitizer(digInput);
 #else 
   /* This is what we actually do, and will work */
 #if 0
   AliInfo("SDigit->Digit conversion not really supported, "
          "doing Hit->Digit conversion instead");
 #endif
-  digitizer = new AliFMDDigitizer(manager);
+  digitizer = new AliFMDDigitizer(digInput);
 #endif
   return digitizer;
 }
index 9ba0853..5f4491b 100644 (file)
       hits, digits, reconstructed points and ESD data. 
 
     - AliFMDCalibFaker, AliFMDAlignFaker: Classes to write fake (or
-      dummy) calibration and alignment         data.  These derive from
-      TTask.  
+      dummy) calibration and alignment         data. 
+
 
     @section script Scripts 
     
@@ -542,7 +542,7 @@ public:
   /** Create a digitizer object
       @param manager Digitization manager
       @return a newly allocated AliFMDDigitizer */
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
   /** Create AliFMDDigit's from AliFMDHit's.  This is done by creating
       an AliFMDDigitizer object, and executing it.  */
   virtual        void   Hits2Digits();
index 9ae092c..a689e00 100644 (file)
 #include "AliFMDHit.h"         // ALIFMDHIT_H
 // #include "AliFMDDigit.h"    // ALIFMDDIGIT_H
 #include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
-// #include <AliRunDigitizer.h>        // ALIRUNDIGITIZER_H
+// #include <AliDigitizationInput.h>   // ALIRUNDIGITIZER_H
 //#include <AliRun.h>          // ALIRUN_H
 #include <AliLoader.h>         // ALILOADER_H
 #include <AliRun.h>            // ALILOADER_H
@@ -239,8 +239,8 @@ AliFMDBaseDigitizer::AliFMDBaseDigitizer()
 }
 
 //____________________________________________________________________
-AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager) 
-  : AliDigitizer(manager, "AliFMDBaseDigitizer", "FMD Digitizer base class"), 
+AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliDigitizationInput* digInput) 
+  : AliDigitizer(digInput, "AliFMDBaseDigitizer", "FMD Digitizer base class"), 
     fFMD(0),
     fRunLoader(0),
     fEdep(0),        // nDet==0 means 51200 slots
index bb135f4..0c9e85d 100644 (file)
@@ -32,7 +32,7 @@
 # include <AliDigitizer.h>
 #endif
 #ifndef ALIRUNDIGITIZER_H
-# include <AliRunDigitizer.h>
+# include <AliDigitizationInput.h>
 #endif
 #ifndef ALIFMDEdepMAP_H
 # include "AliFMDEdepMap.h"
@@ -160,7 +160,7 @@ public:
   AliFMDBaseDigitizer();
   /** Normal CTOR 
       @param manager Manager of digitization */
-  AliFMDBaseDigitizer(AliRunDigitizer * manager);
+  AliFMDBaseDigitizer(AliDigitizationInput * digInp);
   /** Normal ctor 
       @param name Name 
       @param title Title */
@@ -278,7 +278,7 @@ protected:
    */
   AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer& o);
 
-  ClassDef(AliFMDBaseDigitizer,4) // Base class for FMD digitizers
+  ClassDef(AliFMDBaseDigitizer,5) // Base class for FMD digitizers
 };
 
 
index 5eabe0b..69d42dc 100644 (file)
 #include "AliFMDSDigit.h"      // ALIFMDDIGIT_H
 #include "AliFMDDigit.h"       // ALIFMDDIGIT_H
 #include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
-#include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
+#include <AliDigitizationInput.h>      // ALIRUNDIGITIZER_H
 #include <AliRun.h>            // ALIRUN_H
 #include <AliLoader.h>         // ALILOADER_H
 #include <AliRunLoader.h>      // ALIRUNLOADER_H
@@ -256,18 +256,18 @@ AliFMDDigitizer::Init()
 
 //____________________________________________________________________
 void
-AliFMDDigitizer::Exec(Option_t*)
+AliFMDDigitizer::Digitize(Option_t*)
 {
   // 
   // Execute this digitizer.  
   // This member function will be called once per event by the passed
-  // AliRunDigitizer manager object. 
+  // AliDigitizationInput* digInput object. 
   // 
   // Parameters:
   //    options Not used 
   //
-  if (!fManager) { 
-    AliError("No digitisation manager defined");
+  if (!fDigInput) { 
+    AliError("No digitisation input defined");
     return;
   }
 
@@ -276,7 +276,7 @@ AliFMDDigitizer::Exec(Option_t*)
 
   AliRunLoader* runLoader = 0;
   if (!gAlice) { 
-    TString folderName(fManager->GetInputFolderName(0));
+    TString folderName(fDigInput->GetInputFolderName(0));
     runLoader = AliRunLoader::GetRunLoader(folderName.Data());
     if (!runLoader) { 
       AliError(Form("Failed at getting run loader from %s",
@@ -300,14 +300,14 @@ AliFMDDigitizer::Exec(Option_t*)
 
 
   // Loop over input files
-  Int_t nFiles= fManager->GetNinputs();
+  Int_t nFiles= fDigInput->GetNinputs();
   AliFMDDebug(1, (" Digitizing event number %d, got %d inputs",
-                 fManager->GetOutputEventNr(), nFiles));
+                 fDigInput->GetOutputEventNr(), nFiles));
   for (Int_t inputFile = 0; inputFile < nFiles; inputFile++) {
     AliFMDDebug(5, ("Now reading input # %d", inputFile));
     // Get the current loader 
     AliRunLoader* currentLoader = 
-      AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+      AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inputFile));
     if (!currentLoader) { 
       Error("Exec", "no run loader for input file # %d", inputFile);
       continue;
@@ -324,7 +324,7 @@ AliFMDDigitizer::Exec(Option_t*)
     // Get the tree of summable digits
     TTree* sdigitsTree = inFMD->TreeS();
     if (!sdigitsTree)  {
-      AliError("No sdigit tree from manager");
+      AliError("No sdigit tree from input");
       continue;
     }
     if (AliLog::GetDebugLevel("FMD","") >= 10) {
@@ -359,7 +359,7 @@ AliFMDDigitizer::Exec(Option_t*)
     inFMD->UnloadSDigits();
   }  
 
-  TString       outFolder(fManager->GetOutputFolderName());
+  TString       outFolder(fDigInput->GetOutputFolderName());
   AliRunLoader* out    = AliRunLoader::GetRunLoader(outFolder.Data());
   AliLoader*    outFMD = out->GetLoader("FMDLoader");
   if (!outFMD) { 
index b51d4f7..08e972f 100644 (file)
@@ -59,10 +59,10 @@ public:
   /** 
    * CTOR 
    *
-   * @param manager Manager of digitization 
+   * @param input Input of digitization 
    */
-  AliFMDDigitizer(AliRunDigitizer * manager)
-    : AliFMDBaseDigitizer(manager) {}
+  AliFMDDigitizer(AliDigitizationInput * digInput)
+    : AliFMDBaseDigitizer(digInput) {}
   /** 
    * DTOR 
    */
@@ -74,11 +74,11 @@ public:
   /** 
    * Execute this digitizer.  
    * This member function will be called once per event by the passed
-   * AliRunDigitizer manager object. 
+   * AliDigitizationInput* digInput object. 
    *
    * @param options Not used 
    */
-  virtual void Exec(Option_t* option="");
+  virtual void Digitize(Option_t* option="");
 protected:
   /** 
    * Sum contributions from SDigits 
index 3ccf75c..ad7d7f3 100644 (file)
@@ -240,7 +240,7 @@ AliFMDHitDigitizer::operator=(const AliFMDHitDigitizer& o)
 
 //____________________________________________________________________
 void
-AliFMDHitDigitizer::Exec(Option_t* /*option*/)
+AliFMDHitDigitizer::Digitize(Option_t* /*option*/)
 {
   // Run this digitizer 
   // Get an inititialize parameter manager
index 7038e13..828b307 100644 (file)
@@ -61,7 +61,7 @@ public:
   /** DTOR */
   virtual ~AliFMDHitDigitizer() {}
   /** Run over the input events (retrieved via run loader) */
-  void Exec(Option_t* option="");
+  void Digitize(Option_t* option="");
   /** 
    * Set the end of integration
    * 
index 91a6d30..15b9fe0 100644 (file)
@@ -19,7 +19,7 @@
 //.
 #include <AliRun.h>
 #include <AliRunLoader.h>
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include <AliLoader.h>
 #include "AliLog.h"
 #include <AliCDBEntry.h> 
@@ -38,18 +38,18 @@ ClassImp(AliHMPIDDigitizer)
 
 Bool_t AliHMPIDDigitizer::fgDoNoise=kTRUE;
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDDigitizer::Exec(Option_t*)
+void AliHMPIDDigitizer::Digitize(Option_t*)
 {
 // This methode is responsible for merging sdigits to a list of digits
 //Disintegration leeds to the fact that one hit affects several neighbouring pads, which means that the same pad might be affected by few hits.     
-  AliDebug(1,Form("Start with %i input(s) for event %i",fManager->GetNinputs(),fManager->GetOutputEventNr()));
+  AliDebug(1,Form("Start with %i input(s) for event %i",fDigInput->GetNinputs(),fDigInput->GetOutputEventNr()));
 //First we read all sdigits from all inputs  
   AliRunLoader *pInRunLoader=0;//in and out Run loaders
   AliLoader    *pInRichLoader=0;//in and out HMPID loaders  
   static TClonesArray sdigs("AliHMPIDDigit");//tmp storage for sdigits sum up from all input files
   Int_t total=0;
-  for(Int_t inFileN=0;inFileN<fManager->GetNinputs();inFileN++){//files loop
-    pInRunLoader  = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inFileN));          //get run loader from current input 
+  for(Int_t inFileN=0;inFileN<fDigInput->GetNinputs();inFileN++){//files loop
+    pInRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inFileN));          //get run loader from current input 
     pInRichLoader = pInRunLoader->GetLoader("HMPIDLoader"); if(pInRichLoader==0) continue;       //no HMPID in this input, check the next input
     if (!pInRunLoader->GetAliRun()) pInRunLoader->LoadgAlice();
     AliHMPID* pInRich=(AliHMPID*)pInRunLoader->GetAliRun()->GetDetector("HMPID");                  //take HMPID from current input
@@ -57,7 +57,7 @@ void AliHMPIDDigitizer::Exec(Option_t*)
     AliDebug(1,Form("input %i has %i sdigits",inFileN,pInRich->SdiLst()->GetEntries()));
     for(Int_t i=0;i<pInRich->SdiLst()->GetEntries();i++){                                        //collect sdigits from current input
       AliHMPIDDigit *pSDig=(AliHMPIDDigit*)pInRich->SdiLst()->At(i);
-      pSDig->AddTidOffset(fManager->GetMask(inFileN));                                          //apply TID shift since all inputs count tracks independently starting from 0
+      pSDig->AddTidOffset(fDigInput->GetMask(inFileN));                                          //apply TID shift since all inputs count tracks independently starting from 0
       new(sdigs[total++]) AliHMPIDDigit(*pSDig);       
     }
     pInRichLoader->UnloadSDigits();   pInRich->SdiReset(); //close current input and reset 
@@ -65,7 +65,7 @@ void AliHMPIDDigitizer::Exec(Option_t*)
 
   //PH  if(sdigs.GetEntries()==0) return;                                                              //no sdigits collected, nothing to convert  
   
-  AliRunLoader *pOutRunLoader  = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());    //open output stream (only 1 possible)
+  AliRunLoader *pOutRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());    //open output stream (only 1 possible)
   AliLoader    *pOutRichLoader = pOutRunLoader->GetLoader("HMPIDLoader");                         //take output HMPID loader
   AliRun *pArun = pOutRunLoader->GetAliRun();
   AliHMPID      *pOutRich       = (AliHMPID*)pArun->GetDetector("HMPID");      //take output HMPID
index 68d5451..e91bed9 100644 (file)
 class TClonesArray;
 class TObjArray;
 
-class AliHMPIDDigitizer : public AliDigitizer //TObject-TNamed-TTask-AliDigitizer-AliHMPIDDigitizer
+class AliHMPIDDigitizer : public AliDigitizer //TObject-TNamed-AliDigitizer-AliHMPIDDigitizer
 {
 public:
            AliHMPIDDigitizer()                                                {}
-           AliHMPIDDigitizer(AliRunDigitizer *pRunDig):AliDigitizer(pRunDig)  {}
+           AliHMPIDDigitizer(AliDigitizationInput *digInp):AliDigitizer(digInp)  {}
   virtual ~AliHMPIDDigitizer()                                                {}
-  void     Exec(Option_t* option=0);                //virtual
+  void     Digitize(Option_t* option=0);                //virtual
   void     DoNoise(Bool_t doNoise)                           {fgDoNoise=doNoise;} // Set noise or not
 //   
   static void    Sdi2Dig(TClonesArray *pSDigLst,TObjArray *pDigLst);
index bebe27e..e5d7a58 100644 (file)
@@ -28,7 +28,7 @@
 #include <TRandom.h>           //Resolution()
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDPid::AliHMPIDPid():TTask("HMPIDrec","HMPIDPid")
+AliHMPIDPid::AliHMPIDPid():TNamed("HMPIDrec","HMPIDPid")
 {
 //..
 //init of data members
index 1dd2942..6ec3d89 100644 (file)
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////
 
-
-#include <TTask.h>        //base class
+#include <TNamed.h>
 
 class AliESDtrack;
 
-class AliHMPIDPid : public TTask 
+class AliHMPIDPid : public TNamed 
 {
 public : 
              AliHMPIDPid();    //ctor
index 72336d9..c364377 100644 (file)
@@ -31,7 +31,7 @@
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 AliHMPIDRecon::AliHMPIDRecon():
-  TTask("RichRec","RichPat"),
+  TNamed("RichRec","RichPat"),
   fPhotCnt(-1),
   fPhotFlag(0x0),
   fPhotClusIndex(0x0),    
index f5dd89a..6a7b5ef 100644 (file)
 //////////////////////////////////////////////////////////////////////////
 
 
-#include <TTask.h>        //base class
+#include <TNamed.h>        //base class
 #include <TVector3.h>     //fields 
 
 class TClonesArray; //CkovAngle()
 class AliESDtrack;  //CkovAngle()
 class AliHMPIDParam;//general pourpose
 
-class AliHMPIDRecon : public TTask 
+class AliHMPIDRecon : public TNamed 
 {
 public : 
              AliHMPIDRecon();
@@ -83,7 +83,7 @@ private:
   AliHMPIDRecon(const AliHMPIDRecon& r);              //dummy copy constructor
   AliHMPIDRecon &operator=(const AliHMPIDRecon& r);   //dummy assignment operator
 //
-  ClassDef(AliHMPIDRecon,2)
+  ClassDef(AliHMPIDRecon,3)
 };
 
 #endif // #ifdef AliHMPIDRecon_cxx
index 0048322..6ba7dc1 100644 (file)
@@ -37,7 +37,7 @@
 Int_t AliHMPIDReconHTA::fgDB[500][150]={{75000*0}};
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 AliHMPIDReconHTA::AliHMPIDReconHTA():
-  TTask("RichRec","RichPat"),
+  TNamed("RichRec","RichPat"),
   fMipX(-999),
   fMipY(-999),
   fMipQ(-999),
index 4537fcd..a33af2e 100644 (file)
 //////////////////////////////////////////////////////////////////////////
 
 
-#include <TTask.h>        //base class
+#include <TNamed.h>        //base class
 
 class TClonesArray; //CkovAngle()
 class AliESDtrack;  //CkovAngle()
 class AliHMPIDParam;//General pourpose
 
-class AliHMPIDReconHTA : public TTask 
+class AliHMPIDReconHTA : public TNamed 
 {
 public : 
              AliHMPIDReconHTA();
@@ -103,7 +103,7 @@ private:
   AliHMPIDReconHTA(const AliHMPIDReconHTA& r);              //dummy copy constructor
   AliHMPIDReconHTA &operator=(const AliHMPIDReconHTA& r);   //dummy assignment operator
 //
-  ClassDef(AliHMPIDReconHTA,4)
+  ClassDef(AliHMPIDReconHTA,5)
 };
 
 #endif // #ifdef AliHMPIDReconHTA_cxx
index 018e9e4..8b46450 100644 (file)
@@ -21,7 +21,7 @@ public:
           void    AddAlignableVolumes(                               )const;                                   //from AliModule invoked from AliMC    
           void    CreateMaterials  (                                 );                                        //from AliModule invoked from AliMC
           void    CreateGeometry   (                                 );                                        //from AliModule invoked from AliMC
-  AliDigitizer*   CreateDigitizer  (AliRunDigitizer *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
+  AliDigitizer*   CreateDigitizer  (AliDigitizationInput *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
           void    Digits2Raw       (                                 );                                        //from AliModule invoked from AliSimulation::WriteRawFiles()
   virtual void    DefineOpticalProperties();                                                                   //from AliModule invoked from AliMC::ConstructOpGeometry() to set Cerenkov properties
           void    Hits2SDigits     (                                 );                                        //from AliModule invoked from AliSimulation::RunSDigitization()
index 7bc61c4..3b0968f 100644 (file)
@@ -23,7 +23,7 @@ public:
           void    CreateMaterials  (                                 );                                        //from AliModule invoked from AliMC
 static    void    IdealPosition(Int_t iCh,TGeoHMatrix *m);                                                     //ideal position of a given chamber 
           void    CreateGeometry   (                                 );                                        //from AliModule invoked from AliMC
-  AliDigitizer*   CreateDigitizer  (AliRunDigitizer *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
+  AliDigitizer*   CreateDigitizer  (AliDigitizationInput *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
           void    Digits2Raw       (                                 );                                        //from AliModule invoked from AliSimulation::WriteRawFiles()
   virtual void    DefineOpticalProperties(                           );                                        //from AliModule invoked from AliMC::ConstructOpGeometry() to set Cerenkov properties
           //void    InitProperties   (                                 );                                        //define the phys processes on/off (dray,eloss...)                                                 
index e1976a1..de3993d 100644 (file)
@@ -28,7 +28,7 @@ public:
 static    void    IdealPosition(Int_t iCh,TGeoHMatrix *m);                                                     //ideal position of a given chamber 
 static    void    IdealPositionCradle(Int_t iCh,TGeoHMatrix *m);                                               //ideal position of a module of the cradle 
           void    CreateGeometry   (                                 );                                        //from AliModule invoked from AliMC
-  AliDigitizer*   CreateDigitizer  (AliRunDigitizer *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
+  AliDigitizer*   CreateDigitizer  (AliDigitizationInput *m               )const{return new AliHMPIDDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
           void    Digits2Raw       (                                 );                                        //from AliModule invoked from AliSimulation::WriteRawFiles()
   virtual void    DefineOpticalProperties(                           );                                        //from AliModule invoked from AliMC::ConstructOpGeometry() to set Cerenkov properties
          // void    InitProperties   (                                 );                                        //define the phys processes on/off (dray,eloss...)                                                 
index 78407b1..48d1709 100644 (file)
@@ -257,18 +257,18 @@ AliITS::~AliITS(){
 }
 
 //______________________________________________________________________
-AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)const{
+AliDigitizer* AliITS::CreateDigitizer(AliDigitizationInput* digInput)const{
     // Creates the AliITSDigitizer in a standard way for use via AliModule.
     // This function can not be included in the .h file because of problems
     // with the order of inclusion (recursive).
     // Inputs:
-    //    AliRunDigitizer *manager  The Manger class for Digitization
+    //    AliDigitizationInput* digInput  The Manger class for Digitization
     // Output:
     //    none.
     // Return:
     //    A new AliITSRunDigitizer (cast as a AliDigitizer).
 
-     return new AliITSDigitizer(manager);
+     return new AliITSDigitizer(digInput);
 }
 //______________________________________________________________________
 void AliITS::Init(){
index 96990e4..410ad20 100644 (file)
@@ -27,7 +27,7 @@ class AliITShit;
 class AliITSgeom;
 class AliITSdigit;
 class AliITSmodule;
-class AliRunDigitizer;
+class AliDigitizationInput;
 class TArrayI;
 
 class AliITS : public AliDetector {
@@ -108,7 +108,7 @@ class AliITS : public AliDetector {
    // Trigger
     virtual AliTriggerDetector* CreateTriggerDetector() const;
 
-    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+    AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
     virtual void UpdateInternalGeometry();
     virtual void SDigitsToDigits(Option_t *opt="All");
     virtual void SDigits2Digits(){SDigitsToDigits("All");}
index 014f4a7..2b18026 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliLog.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliITSDigitizer.h"
 #include "AliITSgeom.h"
 #include "AliITSgeomTGeo.h"
@@ -63,7 +63,7 @@ fFlagFirstEv(kTRUE){
 
 }
 //______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr),
+AliITSDigitizer::AliITSDigitizer(AliDigitizationInput* digInp) : AliDigitizer(digInp),
 fITS(0),
 fModActive(0),
 fInit(kFALSE),
@@ -130,7 +130,7 @@ Bool_t AliITSDigitizer::Init(){
     return fInit;
 }
 //______________________________________________________________________
-void AliITSDigitizer::Exec(Option_t* opt){
+void AliITSDigitizer::Digitize(Option_t* opt){
     // Main digitization function. 
     // Inputs:
     //      Option_t * opt   list of sub detector to digitize. =0 all.
@@ -145,8 +145,8 @@ void AliITSDigitizer::Exec(Option_t* opt){
                           strstr(opt,"SSD")};
     if( !det[0] && !det[1] && !det[2] ) all = "All";
     else all = 0;
-    Int_t nfiles = GetManager()->GetNinputs();
-    Int_t event  = GetManager()->GetOutputEventNr();
+    Int_t nfiles = GetDigInput()->GetNinputs();
+    Int_t event  = GetDigInput()->GetOutputEventNr();
     AliITSsimulation *sim      = 0;
     if(fFlagFirstEv){
       fITS->SetDefaults();    
@@ -181,7 +181,7 @@ void AliITSDigitizer::Exec(Option_t* opt){
     AliRunLoader *inRL = 0x0, *outRL = 0x0;
     AliLoader *ingime = 0x0, *outgime = 0x0;    
     
-    outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());    
+    outRL = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());    
     if ( outRL == 0x0)
      {
        Error("Exec","Can not get Output Run Loader");
@@ -212,7 +212,7 @@ void AliITSDigitizer::Exec(Option_t* opt){
 
     for(ifiles=0; ifiles<nfiles; ifiles++ )
      {
-       inRL =  AliRunLoader::GetRunLoader(fManager->GetInputFolderName(fl[ifiles]));
+       inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
        ingime = inRL->GetLoader(loadname);
        if (ingime->TreeS() == 0x0) ingime->LoadSDigits();
      }
@@ -234,7 +234,7 @@ void AliITSDigitizer::Exec(Option_t* opt){
          {
            if(fRoif!=0) if(!fModActive[module]) continue;
             
-           inRL =  AliRunLoader::GetRunLoader(fManager->GetInputFolderName(fl[ifiles]));
+           inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
            ingime = inRL->GetLoader(loadname);
            
            TTree *treeS = ingime->TreeS();
@@ -252,11 +252,11 @@ void AliITSDigitizer::Exec(Option_t* opt){
                return;
             } // end if brchSDigits
             sdig->Clear();
-            mask = GetManager()->GetMask(ifiles);
+            mask = GetDigInput()->GetMask(ifiles);
             // add summable digits to module
             brchSDigits->GetEvent( module );
             lmod = sim->AddSDigitsToModule(sdig,mask);
-            if(fRegionOfInterest && (ifiles==0))
+            if(GetRegionOfInterest() && (ifiles==0))
              {
                fModActive[module] = lmod;
              } // end if
@@ -275,7 +275,7 @@ void AliITSDigitizer::Exec(Option_t* opt){
     outgime->UnloadDigits();
     for(ifiles=0; ifiles<nfiles; ifiles++ )
      {
-       inRL =  AliRunLoader::GetRunLoader(fManager->GetInputFolderName(fl[ifiles]));
+       inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
        ingime = inRL->GetLoader(loadname);
        ingime->UnloadSDigits();
      }
index 5bd87e6..b6c434d 100644 (file)
@@ -12,7 +12,7 @@
 class TObjArray;
 class TTree;
 
-class AliRunDigitizer;
+class AliDigitizationInput;
 
 #include "AliDigitizer.h" // Base class from which this one is derived
 #include "AliITS.h"   // ITS class functions used in inline functions.
@@ -21,14 +21,14 @@ class AliITSmodule;
 class AliITSDigitizer : public AliDigitizer{
  public:
     AliITSDigitizer();
-    AliITSDigitizer(AliRunDigitizer *manager);
+    AliITSDigitizer(AliDigitizationInput* digInput);
 
     virtual ~AliITSDigitizer();
     // Standard routines.
     virtual Bool_t Init();
     // Perform SDigits to Digits, with or without merging, depending on the
     // number of files.
-    virtual void Exec(Option_t* opt=0);
+    virtual void Digitize(Option_t* opt=0);
     // Sets a particular module active
     virtual void SetModuleActive(Int_t i){if(fModActive) fModActive[i] = kTRUE;}
     // Sets a particular module inactive
@@ -53,7 +53,7 @@ class AliITSDigitizer : public AliDigitizer{
     // Returns a pointer to a  specific module.
     AliITSmodule* GetModule(Int_t i){return fITS->GetModule(i);}
     // Returns a pointer to the manager
-    AliRunDigitizer* GetManager(){return fManager;}
+    AliDigitizationInput* GetDigInput(){return fDigInput;}
     // Sets the region of Interest based on which module have SDigits
     // Defined (non-noise SDigits).
     virtual void SetByRegionOfInterest(TTree *ts);
index e61e718..d1e5dcb 100644 (file)
 //                                                                     //
 ////////////////////////////////////////////////////////////////////////
 
-#include <TTask.h>
+#include <TNamed.h>
 
 class AliRunLoader;
 class AliITSLoader;
 class TString;
 
-class AliITSreconstruction : public TTask{
+class AliITSreconstruction : public TNamed{
  public:
     AliITSreconstruction(); // default constructor
     AliITSreconstruction(const char *filename); // standard constructor
@@ -44,7 +44,7 @@ class AliITSreconstruction : public TTask{
     AliITSLoader *fLoader; //! ITS loader
     AliRunLoader* fRunLoader;//!Run Loader
  
-    ClassDef(AliITSreconstruction,3) // Task to Reconstruct ITS from Digits.
+    ClassDef(AliITSreconstruction,4) // Class to Reconstruct ITS from Digits.
 
 };
 #endif
index 282b6aa..309eb86 100644 (file)
@@ -155,7 +155,7 @@ Bool_t AliITSsDigitize::InitSDig() const {
 }
  
 //______________________________________________________________________
-void AliITSsDigitize::Exec(const Option_t *opt){
+void AliITSsDigitize::Digitize(const Option_t *opt){
     // Main SDigitization function.
     // Inputs:
     //      Option_t * opt   list of subdetector to digitize. =0 all.
@@ -184,7 +184,7 @@ void AliITSsDigitize::Exec(const Option_t *opt){
     } // end if strstr(opt,...)
  
     if(!fInit){
-        cout << "Initilization Failed, Can't run Exec." << endl;
+        cout << "Initilization Failed, Can't run Digitize." << endl;
         return;
     } // end if !fInit
 
index 09f1a60..75d77ed 100644 (file)
 //                                                     //
 ///////////////////////////////////////////////////////// 
  
-#include <TTask.h>
+#include <TNamed.h>
  
 class TString;
 class AliITS;
  
-class AliITSsDigitize : public TTask{
+class AliITSsDigitize : public TNamed {
  public:
     AliITSsDigitize(); // default constructor
     AliITSsDigitize(const char *filename); // standard constructor
     virtual ~AliITSsDigitize();//Destructor
     virtual Bool_t Init();
-    virtual void Exec(const Option_t *opt="ALL");
+    virtual void Digitize(const Option_t *opt="ALL");
  private:
     Bool_t InitSDig() const;  // Standard SDigitization initilization.
  private:
@@ -39,7 +39,7 @@ class AliITSsDigitize : public TTask{
     Int_t   fEnt0;     //! first event to process, default 0.
     AliITS  *fITS;     //! Local pointer to ITS class.
     AliRunLoader* fRunLoader;//!Run Loader 
-    ClassDef(AliITSsDigitize,1) // Task to SDigitize ITS from Hits.
+    ClassDef(AliITSsDigitize,2) // Class to SDigitize ITS from Hits.
  
 };
 #endif
index 98a3394..1325c7d 100644 (file)
@@ -255,12 +255,12 @@ AliITSUpg::~AliITSUpg(){
 }
 
 //______________________________________________________________________
-AliDigitizer* AliITSUpg::CreateDigitizer(AliRunDigitizer* manager)const{
+AliDigitizer* AliITSUpg::CreateDigitizer(AliDigitizationInput* manager)const{
     // Creates the AliITSDigitizer in a standard way for use via AliModule.
     // This function can not be included in the .h file because of problems
     // with the order of inclusion (recursive).
     // Inputs:
-    //    AliRunDigitizer *manager  The Manger class for Digitization
+    //    AliDigitizationInput *manager  The Manger class for Digitization
     // Output:
     //    none.
     // Return:
index aed02f1..3e6dd39 100644 (file)
@@ -27,7 +27,7 @@ class AliITShit;
 class AliITSgeom;
 class AliITSdigit;
 class AliITSmodule;
-class AliRunDigitizer;
+class AliDigitizationInput;
 
 
 class AliITSUpg : public AliDetector {
@@ -107,7 +107,7 @@ class AliITSUpg : public AliDetector {
    // Trigger
     virtual AliTriggerDetector* CreateTriggerDetector() const;
 
-    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+    AliDigitizer* CreateDigitizer(AliDigitizationInput* manager) const;
     virtual void UpdateInternalGeometry();
     virtual void SDigitsToDigits(Option_t *opt="All");
     virtual void SDigits2Digits(){SDigitsToDigits("All");}
index 4235918..a9b3699 100644 (file)
@@ -72,7 +72,7 @@ class AliITSupgrade : public AliITS //TObject-TNamed-AliModule-AliDetector-AliIT
     for(Int_t i=0;i<fNlayers;i++)fDigitArray->AddAt(new TClonesArray("AliITSDigitUpgrade"),i);}//create digits list
   void          DigitsReset ()              {if(fDigitArray)for(int i=0;i<fNlayers;i++)fDigitArray->At(i)->Clear();                     }//clean digits list
 
-  AliDigitizer*   CreateDigitizer  (AliRunDigitizer *m) const {return new AliITSupgradeDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
+  AliDigitizer*   CreateDigitizer  (AliDigitizationInput *m) const {return new AliITSupgradeDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
            
   void Hit2SumDig(TClonesArray *hits,const TObjArray *pSDig, Int_t *nSdigit);
 
index 9bbd849..a32c540 100644 (file)
@@ -18,7 +18,7 @@
 
 #include <AliRun.h>
 #include <AliRunLoader.h>
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include <AliLoader.h>
 #include <AliLog.h>
 #include "AliITSupgradeDigitizer.h"
@@ -53,13 +53,13 @@ ClassImp(AliITSupgradeDigitizer)
   }  
 }   
 //______________________________________________________________________________      
-void AliITSupgradeDigitizer::Exec(Option_t*)
+void AliITSupgradeDigitizer::Digitize(Option_t*)
 {
   // This method is responsible for merging sdigits to a list of digits
   //  Disintegration leeds to the fact that one hit affects several neighbouring pads, 
   // which means that the same pad might be affected by few hits.     
   
-  AliDebug(1,Form("Start with %i input(s) for event %i",fManager->GetNinputs(),fManager->GetOutputEventNr()));
+  AliDebug(1,Form("Start with %i input(s) for event %i",fDigInput->GetNinputs(),fDigInput->GetOutputEventNr()));
   
   
   AliITSsegmentationUpgrade *s = new AliITSsegmentationUpgrade();
@@ -74,9 +74,9 @@ void AliITSupgradeDigitizer::Exec(Option_t*)
   
   
   Int_t total[10]={0,0,0,0,0,0,0,0,0,0};
-  for(Int_t inFileN=0;inFileN<fManager->GetNinputs();inFileN++){//files loop
+  for(Int_t inFileN=0;inFileN<fDigInput->GetNinputs();inFileN++){//files loop
     
-    pInRunLoader  = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inFileN));          //get run loader from current input 
+    pInRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inFileN));          //get run loader from current input 
     pITSLoader = pInRunLoader->GetLoader("ITSLoader"); 
     if(pITSLoader==0) {
       continue;       //no ITS in this input, check the next input
@@ -95,7 +95,7 @@ void AliITSupgradeDigitizer::Exec(Option_t*)
       //collect sdigits from current input
       for(Int_t ientr =0; ientr < ((TClonesArray*)pITS->SDigitsList()->At(is))->GetEntries(); ientr++){
        AliITSDigitUpgrade *pSDig=(AliITSDigitUpgrade*)((TClonesArray*)pITS->SDigitsList()->At(is))->At(ientr);
-       pSDig->AddTidOffset(fManager->GetMask(inFileN)); // -> To be introduced for merging (apply TID shift since all inputs count tracks independently starting from 0)
+       pSDig->AddTidOffset(fDigInput->GetMask(inFileN)); // -> To be introduced for merging (apply TID shift since all inputs count tracks independently starting from 0)
        new((sdigits[is])[total[is]++]) AliITSDigitUpgrade(*pSDig);  
       }
     }
@@ -104,7 +104,7 @@ void AliITSupgradeDigitizer::Exec(Option_t*)
     pITS->SDigitsReset(); //close current input and reset 
   }//files loop  
   
-  AliRunLoader *pOutRunLoader  = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());  //open output stream (only 1 possible)
+  AliRunLoader *pOutRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());  //open output stream (only 1 possible)
   AliLoader    *pOutITSLoader = pOutRunLoader->GetLoader("ITSLoader");                        
   AliRun *pArun = pOutRunLoader->GetAliRun();
   AliITSupgrade      *pOutITS       = (AliITSupgrade*)pArun->GetDetector("ITS");      
@@ -201,7 +201,7 @@ void AliITSupgradeDigitizer::Sdigits2Digits(TClonesArray *pSDigitList,TObjArray
 
        if(iNtrackPart>maxLab) {        
          AliWarning(Form(" Event %d: Number of summable digits for this pixel (lay=%d,mod=%d,pixId=%lu) is too large (%d<%d). Sum is ok but skipping track Id %d ... ",
-                         fManager->GetOutputEventNr(),ilay,module,pixId,maxLab,iNtrackPart,trackId));
+                         fDigInput->GetOutputEventNr(),ilay,module,pixId,maxLab,iNtrackPart,trackId));
        }
        eloss+=tmpdig->GetSignal();
        nele +=tmpdig->GetNelectrons();
index 92fffcc..3a315f4 100644 (file)
@@ -28,10 +28,10 @@ class AliITSupgradeDigitizer : public AliDigitizer //TObject-TNamed-TTask-AliDig
 {
  public:
   AliITSupgradeDigitizer():AliDigitizer(),fNxCells(0),fNzCells(0),fNlayers(0)              {;}
-    AliITSupgradeDigitizer(AliRunDigitizer *pRunDig):AliDigitizer(pRunDig),fNxCells(0),fNzCells(0),fNlayers(0){;}
+    AliITSupgradeDigitizer(AliDigitizationInput *pRunDig):AliDigitizer(pRunDig),fNxCells(0),fNzCells(0),fNlayers(0){;}
       virtual ~AliITSupgradeDigitizer()                                                {;}
       void   SetConfiguration(TArrayD xcell, TArrayD zcell);
-      void   Exec(Option_t* option=0);                //virtual
+      void   Digitize(Option_t* option=0);                //virtual
    
       void    Sdigits2Digits(TClonesArray *pSDigitList,TObjArray *pDigitLst);
  
index be506be..c8d1c3e 100644 (file)
@@ -77,7 +77,7 @@ public:
   void ResetDigits()    { if(fDigitsPerPlane)    for(int iPlane=0; iPlane<fNPlanes; iPlane++) ((TClonesArray*) fDigitsPerPlane   ->At(iPlane))->Clear(); }   // reset digits list
   void ResetRecPoints() { if(fRecPointsPerPlane) for(int iPlane=0; iPlane<fNPlanes; iPlane++) ((TClonesArray*) fRecPointsPerPlane->At(iPlane))->Clear(); }   // reset recPoints list
   
-  AliDigitizer* CreateDigitizer(AliRunDigitizer *manager) const { return new AliMFTDigitizer(manager); }   // from AliModule invoked from AliSimulation::RunDigitization()
+  AliDigitizer* CreateDigitizer(AliDigitizationInput *digInp) const { return new AliMFTDigitizer(digInp); }   // from AliModule invoked from AliSimulation::RunDigitization()
   
   AliMFTSegmentation* GetSegmentation() const { return fSegmentation; }
 
index bd4dc64..f6ba7c1 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "AliRun.h"
 #include "AliRunLoader.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliLoader.h"
 #include "AliLog.h"
 #include "AliMFTDigitizer.h"
@@ -50,8 +50,8 @@ AliMFTDigitizer::AliMFTDigitizer():
 
 //====================================================================================================================================================
 
-AliMFTDigitizer::AliMFTDigitizer(AliRunDigitizer *pRunDig):
-  AliDigitizer(pRunDig),
+AliMFTDigitizer::AliMFTDigitizer(AliDigitizationInput *digInp) :
+  AliDigitizer(digInp),
   fNPlanes(0),
   fSegmentation(0)
 {
@@ -60,7 +60,7 @@ AliMFTDigitizer::AliMFTDigitizer(AliRunDigitizer *pRunDig):
 
 //====================================================================================================================================================
 
-void AliMFTDigitizer::Exec(Option_t*) {
+void AliMFTDigitizer::Digitize(Option_t*) {
 
   // This method is responsible for merging sdigits to a list of digits
 
@@ -75,7 +75,7 @@ void AliMFTDigitizer::Exec(Option_t*) {
 
   AliDebug(1, Form("nPlanes = %d",fNPlanes));
 
-  AliDebug(1,Form("Start with %i input(s) for event %i", fManager->GetNinputs(), fManager->GetOutputEventNr()));
+  AliDebug(1,Form("Start with %i input(s) for event %i", fDigInput->GetNinputs(), fDigInput->GetOutputEventNr()));
     
   AliRunLoader *pInRunLoader=0;
   AliLoader    *pInMFTLoader=0;
@@ -85,9 +85,9 @@ void AliMFTDigitizer::Exec(Option_t*) {
   
   // filling the arrays of sdigits...
 
-  for (Int_t iFile=0; iFile<fManager->GetNinputs(); iFile++) {
+  for (Int_t iFile=0; iFile<fDigInput->GetNinputs(); iFile++) {
     
-    pInRunLoader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iFile));
+    pInRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iFile));
     pInMFTLoader = pInRunLoader->GetLoader("MFTLoader"); 
     if (!pInMFTLoader) {
       AliDebug(1,"no MFT lodader, checking in the other input \n"); 
@@ -109,7 +109,7 @@ void AliMFTDigitizer::Exec(Option_t*) {
        AliDebug(2, Form("Reading digit %03d of plane %02d (A)", iSDig, iPlane));
        AliMFTDigit *pSDig = (AliMFTDigit*) ((TClonesArray*)pInMFT->GetSDigitsList()->At(iPlane))->At(iSDig);
        AliDebug(2, Form("Reading digit %03d of plane %02d (B)", iSDig, iPlane));
-       pSDig->AddOffset2TrackID(fManager->GetMask(iFile));   // -> To be introduced for merging (since all inputs count tracks independently from 0)
+       pSDig->AddOffset2TrackID(fDigInput->GetMask(iFile));   // -> To be introduced for merging (since all inputs count tracks independently from 0)
        AliDebug(2, Form("Reading digit %03d of plane %02d (C)", iSDig, iPlane));
        new ((sDigits[iPlane])[sDigits[iPlane].GetEntries()]) AliMFTDigit(*pSDig);  
        AliDebug(2, Form("Reading digit %03d of plane %02d (D)", iSDig, iPlane));
@@ -121,7 +121,7 @@ void AliMFTDigitizer::Exec(Option_t*) {
 
   }
   
-  AliRunLoader *pOutRunLoader = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());  // open output stream (only 1 possible)
+  AliRunLoader *pOutRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());  // open output stream (only 1 possible)
   AliLoader    *pOutMFTLoader = pOutRunLoader->GetLoader("MFTLoader");                        
   AliRun       *pAliRun       = pOutRunLoader->GetAliRun();
   AliMFT       *pOutMFT       = (AliMFT*) pAliRun->GetDetector("MFT");      
index d002eaa..e1272b9 100644 (file)
@@ -14,7 +14,7 @@
 
 #include "AliRun.h"
 #include "AliRunLoader.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliLoader.h"
 #include "AliLog.h"
 #include "AliMFTDigit.h"
@@ -30,10 +30,10 @@ class AliMFTDigitizer : public AliDigitizer {
 public:
 
   AliMFTDigitizer();
-  AliMFTDigitizer(AliRunDigitizer *pRunDig);
+  AliMFTDigitizer(AliDigitizationInput *digInp);
   virtual ~AliMFTDigitizer() { }
 
-  void Exec(Option_t *option);
+  void Digitize(Option_t *option);
   void SDigits2Digits(TClonesArray *pSDigitList, TObjArray *pDigitLst);
 
   void MergeDigits(AliMFTDigit *mainDig, AliMFTDigit *digToSum);
index 31c0bb3..8509e36 100644 (file)
@@ -55,7 +55,7 @@
 
 #include "AliLoader.h"
 #include "AliCDBManager.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliMC.h"
 #include "AliRun.h"
 #include "AliRawDataHeaderSim.h"
@@ -439,11 +439,11 @@ void   AliMUON::SetResponseModel(Int_t id, const AliMUONResponse& response)
 }
 
 //____________________________________________________________________
-AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliMUON::CreateDigitizer(AliDigitizationInput* digInput) const
 {
 /// Return digitizer
   
-  AliMUONDigitizerV3* digitizer = new AliMUONDigitizerV3(manager, fDigitizerWithNoise);
+  AliMUONDigitizerV3* digitizer = new AliMUONDigitizerV3(digInput, fDigitizerWithNoise);
   AliMUONDigitizerV3::SetNSigmas(fDigitizerNSigmas);
   digitizer->SetCalibrationData(fCalibrationData,GetRecoParam());
   return digitizer;
@@ -466,7 +466,7 @@ void AliMUON::Hits2SDigits()
 /// Perform Hits2Digits using SDigitizerV2
   
   AliMUONSDigitizerV2 sdigitizer;
-  sdigitizer.ExecuteTask();
+  sdigitizer.Digitize();
 }
 
 //_____________________________________________________________________
index 99a6233..a9e21aa 100644 (file)
@@ -60,7 +60,7 @@ class AliMUON : public  AliDetector
     virtual void   SetSplitLevel(Int_t SplitLevel)     {fSplitLevel=SplitLevel;}
 
     // Digitisation 
-    virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+    virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
     virtual void   SDigits2Digits();      
     virtual void   Hits2SDigits();
     virtual void   Digits2Raw();
index be668a7..4daf311 100644 (file)
@@ -47,7 +47,7 @@
 #include "AliCodeTimer.h"
 #include "AliLog.h"
 #include "AliRun.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliLoader.h"
 #include "AliRunLoader.h"
 
@@ -110,9 +110,9 @@ ClassImp(AliMUONDigitizerV3)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMUONDigitizerV3::AliMUONDigitizerV3(AliRunDigitizer* manager, 
+AliMUONDigitizerV3::AliMUONDigitizerV3(AliDigitizationInput* digInput, 
                                        Int_t generateNoisyDigits)
-: AliDigitizer(manager),
+: AliDigitizer(digInput),
 fIsInitialized(kFALSE),
 fCalibrationData(0x0),
 fTriggerProcessor(0x0),
@@ -130,7 +130,7 @@ fEfficiencyResponse(2*AliMUONConstants::NTriggerCh()*AliMUONConstants::NTriggerC
 {
   /// Ctor.
 
-  AliDebug(1,Form("AliRunDigitizer=%p",fManager));
+  AliDebug(1,Form("AliDigitizationInput=%p",fDigInput));
 
 }
 
@@ -478,9 +478,9 @@ AliMUONDigitizerV3::CreateInputDigitStores()
   
   fInputDigitStores->SetOwner(kTRUE);
   
-  for ( Int_t iFile = 0; iFile < fManager->GetNinputs(); ++iFile )
+  for ( Int_t iFile = 0; iFile < fDigInput->GetNinputs(); ++iFile )
   {    
-    AliLoader* inputLoader = GetLoader(fManager->GetInputFolderName(iFile));
+    AliLoader* inputLoader = GetLoader(fDigInput->GetInputFolderName(iFile));
     
     inputLoader->LoadSDigits("READ");
     
@@ -496,7 +496,7 @@ AliMUONDigitizerV3::CreateInputDigitStores()
 
 //_____________________________________________________________________________
 void
-AliMUONDigitizerV3::Exec(Option_t*)
+AliMUONDigitizerV3::Digitize(Option_t*)
 {
   /// Main method.
   /// We first loop over input files, and merge the sdigits we found there.
@@ -506,7 +506,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
     
   AliCodeTimerAuto("",0)
   
-  if ( fManager->GetNinputs() == 0 )
+  if ( fDigInput->GetNinputs() == 0 )
   {
     AliWarning("No input set. Nothing to do.");
     return;
@@ -518,9 +518,9 @@ AliMUONDigitizerV3::Exec(Option_t*)
     return;
   }
   
-  Int_t nInputFiles = fManager->GetNinputs();
+  Int_t nInputFiles = fDigInput->GetNinputs();
   
-  AliLoader* outputLoader = GetLoader(fManager->GetOutputFolderName());
+  AliLoader* outputLoader = GetLoader(fDigInput->GetOutputFolderName());
   
   outputLoader->MakeDigitsContainer();
   
@@ -536,7 +536,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
   
   for ( Int_t iFile = 0; iFile < nInputFiles; ++iFile )
   {  
-    AliLoader* inputLoader = GetLoader(fManager->GetInputFolderName(iFile));
+    AliLoader* inputLoader = GetLoader(fDigInput->GetInputFolderName(iFile));
 
     inputLoader->LoadSDigits("READ");
 
@@ -557,7 +557,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
     
     iTreeS->GetEvent(0);
 
-    MergeWithSDigits(fDigitStore,*dstore,fManager->GetMask(iFile));
+    MergeWithSDigits(fDigitStore,*dstore,fDigInput->GetMask(iFile));
 
     inputLoader->UnloadSDigits();
     
@@ -845,7 +845,7 @@ AliMUONDigitizerV3::GetLoader(const TString& folderName)
 Bool_t
 AliMUONDigitizerV3::Init()
 {
-  /// Initialization of the TTask :
+  /// Initialization of the digitization :
   /// a) create the calibrationData, according to run number
   /// b) create the trigger processing task
 
@@ -857,9 +857,9 @@ AliMUONDigitizerV3::Init()
     return kFALSE;
   }
   
-  if (!fManager)
+  if (!fDigInput)
   {
-    AliError("fManager is null !");
+    AliError("fDigInput is null !");
     return kFALSE;
   }
   
index 7f3d082..30bb5b1 100644 (file)
@@ -36,12 +36,12 @@ class AliMUONTriggerUtilities;
 class AliMUONDigitizerV3 : public AliDigitizer
 {
 public:
-  AliMUONDigitizerV3(AliRunDigitizer* manager=0, 
+  AliMUONDigitizerV3(AliDigitizationInput* digInput=0, 
                      Int_t generateNoisyDigits=1);
   
   virtual ~AliMUONDigitizerV3();
 
-  virtual void Exec(Option_t* opt="");
+  virtual void Digitize(Option_t* opt="");
   
   virtual Bool_t Init();
 
index 3b00f87..4d80e98 100644 (file)
@@ -67,7 +67,7 @@ Float_t  AliMUONSDigitizerV2::fgkMinTimeDif = 25E-9;
 
 //_____________________________________________________________________________
 AliMUONSDigitizerV2::AliMUONSDigitizerV2() 
-: TTask("AliMUONSDigitizerV2","From Hits to SDigits for MUON")
+: TNamed("AliMUONSDigitizerV2","From Hits to SDigits for MUON")
 {
   ///
   /// ctor.
@@ -89,7 +89,7 @@ AliMUONSDigitizerV2::~AliMUONSDigitizerV2()
 
 //_____________________________________________________________________________
 void
-AliMUONSDigitizerV2::Exec(Option_t*)
+AliMUONSDigitizerV2::Digitize(Option_t*)
 {
   ///
   /// Go from hits to sdigits.
index 4a88675..f0123e2 100644 (file)
 #ifndef ALIMUONSDIGITIZERV2_H
 #define ALIMUONSDIGITIZERV2_H
 
-#ifndef ROOT_TTask
-#  include "TTask.h"
-#endif
+#include "TNamed.h"
 
-class AliMUONSDigitizerV2 : public TTask
+class AliMUONSDigitizerV2 : public TNamed
 {
 public:
   AliMUONSDigitizerV2();
   virtual ~AliMUONSDigitizerV2();
   
-  virtual void Exec(Option_t* opt="");
+  virtual void Digitize(Option_t* opt="");
   
 private:
   static Float_t  fgkMaxIntTime; ///< maximum time of interaction
@@ -36,7 +34,7 @@ private:
   static Float_t  fgkMaxNegTimeDif; ///< maximum event time before the triggered event for a hit to be digitized 
   static Float_t  fgkMinTimeDif; ///< minimum time difference for the reduction factor to be applied  
     
-  ClassDef(AliMUONSDigitizerV2,1) // MUON SDigitizer V2-1
+  ClassDef(AliMUONSDigitizerV2,2) // MUON SDigitizer V2-1
 };
 
 #endif
index 4d7d19c..10b7b6f 100644 (file)
     class  AliDebugVolume {};
     class  AliConfig {};
     class  AliDigitizer {};
-    class  AliRunDigitizer {};
+    class  AliDigitizationInput {};
     class  AliStream {};
     class  AliMergeCombi {};
     class  AliGausCorr {};
index d0d882a..8c0e9e8 100644 (file)
@@ -126,9 +126,9 @@ AliPHOS::~AliPHOS()
 }
 
 //____________________________________________________________________________
-AliDigitizer* AliPHOS::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliPHOS::CreateDigitizer(AliDigitizationInput* digInput) const
 {
-  return new AliPHOSDigitizer(manager);
+  return new AliPHOSDigitizer(digInput);
 }
 
 //____________________________________________________________________________
@@ -561,7 +561,7 @@ void AliPHOS::Hits2SDigits()
   AliPHOSSDigitizer phosDigitizer(fLoader->GetRunLoader()->GetFileName().Data()) ;
   phosDigitizer.SetEventRange(0, -1) ; // do all the events
  
-  phosDigitizer.ExecuteTask("all") ; 
+  phosDigitizer.Digitize("all") ; 
 }
 
 
index 079ed45..f1ce3c4 100644 (file)
@@ -57,7 +57,6 @@
 
 // --- ROOT system ---
 class TString ; 
-class TTask ;
 class TFolder ;
 class TTree ; 
 class TRandom ; 
@@ -83,7 +82,7 @@ public:
   }
   virtual void   AddHit( Int_t shunt, Int_t primary, Int_t track, 
                         Int_t id, Float_t *hits ) = 0 ;   
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
   virtual void  CreateMaterials() ;            
   virtual void  Digits2Raw();
   virtual Bool_t Raw2SDigits(AliRawReader* rawReader);
index 2f5c44f..f193db4 100644 (file)
 //_________________________________________________________________________
 //*-- Author :  Dmitri Peressounko (SUBATECH & Kurchatov Institute) 
 //////////////////////////////////////////////////////////////////////////////
-// This TTask performs digitization of Summable digits (in the PHOS case it is just
+// This class performs digitization of Summable digits (in the PHOS case it is just
 // the sum of contributions from all primary particles into a given cell). 
 // In addition it performs mixing of summable digits from different events.
-// The name of the TTask is also the title of the branch that will contain 
+// The name of the class is also the title of the branch that will contain 
 // the created SDigits
-// The title of the TTAsk is the name of the file that contains the hits from
+// The title of the class is the name of the file that contains the hits from
 // which the SDigits are created
 //
 // For each event two branches are created in TreeD:
 //
 // Use case:
 // root[0] AliPHOSDigitizer * d = new AliPHOSDigitizer() ;
-// root[1] d->ExecuteTask()             
+// root[1] d->Digitize()             
 // Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
 //                       //Digitizes SDigitis in all events found in file galice.root 
 //
 //                       // Reads another set of sdigits from galice2.root
 // root[3] d1->MixWith("galice3.root")       
 //                       // Reads another set of sdigits from galice3.root
-// root[4] d->ExecuteTask("deb timing")    
+// root[4] d->Digitize("deb timing")    
 //                       // Reads SDigits from files galice1.root, galice2.root ....
 //                       // mixes them and stores produced Digits in file galice1.root          
 //                       // deb - prints number of produced digits
 // --- AliRoot header files ---
 #include <TGeoManager.h>                                                                                                                   
 #include "AliLog.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliPHOSDigit.h"
 #include "AliPHOSDigitizer.h"
 #include "AliPHOSGeometry.h"
@@ -166,13 +166,13 @@ AliPHOSDigitizer::AliPHOSDigitizer() :
 {
   // ctor
   InitParameters() ; 
-  fManager = 0 ;                     // We work in the standalong mode
+  fDigInput = 0 ;                     // We work in the standalong mode
 }
 
 //____________________________________________________________________________ 
 AliPHOSDigitizer::AliPHOSDigitizer(TString alirunFileName, 
                                   TString eventFolderName):
-  AliDigitizer("PHOS"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName), 
+  AliDigitizer("PHOSDigitizer", alirunFileName), 
   fDefaultInit(kFALSE),
   fDigitsInRun(0),
   fInit(kFALSE),
@@ -193,7 +193,7 @@ AliPHOSDigitizer::AliPHOSDigitizer(TString alirunFileName,
   InitParameters() ; 
   Init() ;
   fDefaultInit = kFALSE ; 
-  fManager = 0 ;                     // We work in the standalone mode
+  fDigInput = 0 ;                     // We work in the standalone mode
   fcdb = new AliPHOSCalibData(-1);
 }
 
@@ -223,8 +223,8 @@ AliPHOSDigitizer::AliPHOSDigitizer(const AliPHOSDigitizer & d) :
 }
 
 //____________________________________________________________________________ 
-AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
-  AliDigitizer(rd,"PHOS"+AliConfig::Instance()->GetDigitizerTaskName()),
+AliPHOSDigitizer::AliPHOSDigitizer(AliDigitizationInput * rd) :
+  AliDigitizer(rd,"PHOSDigitizer"),
   fDefaultInit(kFALSE),
   fDigitsInRun(0),
   fInit(kFALSE),
@@ -232,7 +232,7 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
   fInputFileNames(0x0),
   fEventNames(0x0),
   fEmcCrystals(0),
-  fEventFolderName(fManager->GetInputFolderName(0)),
+  fEventFolderName(fDigInput->GetInputFolderName(0)),
   fFirstEvent(0),
   fLastEvent(0), 
   fcdb (0x0), 
@@ -243,8 +243,8 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
 
 {
   // ctor Init() is called by RunDigitizer
-  fManager = rd ; 
-  SetTitle(static_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
+  fDigInput = rd ; 
+  SetTitle(static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetFileName(0));
   InitParameters() ; 
   fDefaultInit = kFALSE ; 
   fcdb = new AliPHOSCalibData(-1);
@@ -253,15 +253,7 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd) :
 //____________________________________________________________________________ 
   AliPHOSDigitizer::~AliPHOSDigitizer()
 {
-  // dtor
-  AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
-  if(rl){                                                                                                                               
-    AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));    
-    
-    if(phosLoader)
-      phosLoader->CleanDigitizer() ;
-  }
-  
+  // dtor  
   delete [] fInputFileNames ; 
   delete [] fEventNames ; 
 
@@ -291,8 +283,8 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
 
   Int_t readEvent = event ; 
-  if (fManager) 
-    readEvent = static_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
+  if (fDigInput) 
+    readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetCurrentEventNumber() ; 
   AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
                  readEvent, GetTitle(), fEventFolderName.Data())) ; 
   rl->GetEvent(readEvent) ;
@@ -369,8 +361,8 @@ void AliPHOSDigitizer::Digitize(Int_t event)
     }
     AliPHOSLoader * phosLoader2 = static_cast<AliPHOSLoader*>(rl2->GetLoader("PHOSLoader"));
  
-    if(fManager){ 
-      readEvent = static_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
+    if(fDigInput){ 
+      readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(i))->GetCurrentEventNumber() ; 
     }
     TClonesArray * digs ;
     if(AliPHOSSimParam::GetInstance()->IsStreamDigits(i)){ //This is Digits Stream
@@ -464,8 +456,8 @@ void AliPHOSDigitizer::Digitize(Int_t event)
          while(curSDigit && curSDigit->GetId() == absID){         
            //Shift primary to separate primaries belonging different inputs
            Int_t primaryoffset ;
-           if(fManager)
-             primaryoffset = fManager->GetMask(i) ; 
+           if(fDigInput)
+             primaryoffset = fDigInput->GetMask(i) ; 
            else
              primaryoffset = 10000000*i ;
            curSDigit->ShiftPrimary(primaryoffset) ;
@@ -569,8 +561,8 @@ void AliPHOSDigitizer::Digitize(Int_t event)
             while(curSDigit && curSDigit->GetId() == absID){      
               //Shift primary to separate primaries belonging different inputs
               Int_t primaryoffset ;
-              if(fManager)
-                primaryoffset = fManager->GetMask(i) ; 
+              if(fDigInput)
+                primaryoffset = fDigInput->GetMask(i) ; 
               else
                 primaryoffset = 10000000*i ;
               curSDigit->ShiftPrimary(primaryoffset) ;
@@ -744,7 +736,7 @@ Int_t AliPHOSDigitizer::DigitizeCPV(Float_t charge, Int_t absId)
 }
 
 //____________________________________________________________________________
-void AliPHOSDigitizer::Exec(Option_t *option) 
+void AliPHOSDigitizer::Digitize(Option_t *option) 
 { 
   // Steering method to process digitization for events
   // in the range from fFirstEvent to fLastEvent.
@@ -768,13 +760,10 @@ void AliPHOSDigitizer::Exec(Option_t *option)
   
   AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
   AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
-
-  // Post Digitizer to the white board
-  phosLoader->PostDigitizer(this) ;
   
   if (fLastEvent == -1) 
     fLastEvent = rl->GetNumberOfEvents() - 1 ;
-  else if (fManager) 
+  else if (fDigInput) 
     fLastEvent = fFirstEvent ; 
  
   Int_t nEvents   = fLastEvent - fFirstEvent + 1;
@@ -795,8 +784,6 @@ void AliPHOSDigitizer::Exec(Option_t *option)
     fDigitsInRun += phosLoader->Digits()->GetEntriesFast() ;  
  }
  
-  phosLoader->CleanDigitizer();
-
   if(strstr(option,"tim")){
     gBenchmark->Stop("PHOSDigitizer");
     TString message ; 
@@ -851,8 +838,8 @@ Bool_t AliPHOSDigitizer::Init()
   
   fFirstEvent = 0 ; 
   fLastEvent = fFirstEvent ; 
-  if (fManager) 
-    fInput = fManager->GetNinputs() ; 
+  if (fDigInput) 
+    fInput = fDigInput->GetNinputs() ; 
   else 
     fInput           = 1 ;
   
@@ -862,9 +849,9 @@ Bool_t AliPHOSDigitizer::Init()
   fEventNames[0]     = fEventFolderName.Data() ; 
   Int_t index ; 
   for (index = 1 ; index < fInput ; index++) {
-    fInputFileNames[index] = static_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0); 
-    TString tempo = fManager->GetInputFolderName(index) ;
-    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added by fManager
+    fInputFileNames[index] = static_cast<AliStream*>(fDigInput->GetInputStream(index))->GetFileName(0); 
+    TString tempo = fDigInput->GetInputFolderName(index) ;
+    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added by fDigInput
   }
 
   //to prevent cleaning of this object while GetEvent is called
@@ -872,9 +859,6 @@ Bool_t AliPHOSDigitizer::Init()
   if(!rl){
     rl = AliRunLoader::Open(GetTitle(), fEventFolderName) ; 
   }
-  AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
-  phosLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
-
   return fInit ; 
 }
 
@@ -900,7 +884,7 @@ void AliPHOSDigitizer::Print(const Option_t *)const
     printf(" Writing Digits to branch with title  %s\n", fEventFolderName.Data()) ;
     
     Int_t nStreams ; 
-    if (fManager) 
+    if (fDigInput) 
       nStreams =  GetNInputStreams() ;
     else 
       nStreams = fInput ; 
@@ -1042,7 +1026,6 @@ void AliPHOSDigitizer::WriteDigits()
   digitsBranch->Fill() ;
   
   phosLoader->WriteDigits("OVERWRITE");
-  phosLoader->WriteDigitizer("OVERWRITE");
 
   Unload() ; 
 
index 58e92b1..bfe31b1 100644 (file)
@@ -45,7 +45,7 @@ class TClonesArray ;
 #include "AliDigitizer.h"
 #include "AliConfig.h"
 #include "AliPHOSPulseGenerator.h"
-class AliRunDigitizer ;
+class AliDigitizationInput ;
 class AliPHOSCalibData ; 
 
 class AliPHOSDigitizer: public AliDigitizer {
@@ -54,11 +54,11 @@ public:
   AliPHOSDigitizer() ;          // ctor
   AliPHOSDigitizer(TString alirunFileNameFile, TString eventFolderName = AliConfig::GetDefaultEventFolderName()) ; 
   AliPHOSDigitizer(const AliPHOSDigitizer & dtizer) ;
-  AliPHOSDigitizer(AliRunDigitizer * manager) ;
+  AliPHOSDigitizer(AliDigitizationInput * digInput) ;
   virtual ~AliPHOSDigitizer() ;       
 
   void    Digitize(Int_t event) ;            // Make Digits from SDigits 
-  void    Exec(Option_t *option);                  // Supervising method
+  void    Digitize(Option_t *option);                  // Supervising method
 
   void   SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
 
index ca11c1e..0a90d24 100644 (file)
@@ -137,7 +137,7 @@ void AliPHOSLoader::CleanFolders()
 Int_t AliPHOSLoader::SetEvent()
 {
 //Cleans loaded stuff and and sets Files and Directories
-// do not post any data to folder/tasks
+// do not post any data to folder
 
 
  Int_t retval = AliLoader::SetEvent();
index edf7b80..fec7377 100644 (file)
@@ -33,7 +33,6 @@
 // --- ROOT system ---
 class TString ;
 class TParticle ;
-class TTask ;
 #include <TClonesArray.h>
 #include <TTree.h>
 
@@ -93,11 +92,6 @@ public:
   void    CleanTracks()const;
   void    CleanRecParticles();
 
-//up to now it is only here -> no definition about global/incremental tracking/PID
-//   Int_t   WriteRecParticles(Option_t* opt="");//writes the reconstructed particles
-//   Int_t   WritePID(Option_t* opt="");//writes the task for PID to file
-//   Bool_t  PostPID  (AliPHOSPID * pid) const {return kTRUE;}
   
 /*******************************************************************/
 /*******************************************************************/
@@ -115,7 +109,7 @@ public:
 
   static AliPHOSLoader* GetPHOSLoader(const  char* eventfoldername);
 
-  //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
+  //Method to be used when digitizing under AliDigitizationInput, who opens all files etc.
   Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
   Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
 
@@ -153,23 +147,6 @@ public:
   TClonesArray * RecParticles() ;
   const AliPHOSRecParticle * RecParticle(Int_t index);
   void MakeRecParticlesArray();
-
-  /*********************************************/
-  /************    T A S K S      **************/
-  /*********************************************/
-  // 
-  //  AliPHOSSDigitizer*  PHOSSDigitizer(TString name = AliConfig::GetDefaultEventFolderName());
-  //AliPHOSDigitizer*   PHOSDigitizer()  { return  dynamic_cast<AliPHOSDigitizer*>(Digitizer()) ;}
-
-  AliPHOSPID * PID () const {return dynamic_cast<AliPHOSPID*>(PIDTask()) ;}
-  Int_t LoadPID(Option_t * opt="") const {return LoadPIDTask(opt);}
-  Int_t WritePID(Option_t * opt="") const {return WritePIDTask(opt);}
-
-
-  AliPHOSTrackSegmentMaker * TrackSegmentMaker () const { return dynamic_cast<AliPHOSTrackSegmentMaker *>(Tracker()) ;}
-  Int_t LoadTrackSegmentMaker(Option_t * opt="") const {return LoadTracker(opt);}
-  Int_t WriteTrackSegmentMaker(Option_t * opt="") const {return WriteTracker(opt);}
-
   
   void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
   void   SetBranchTitle(const TString& btitle);
index a74938a..7ef781f 100644 (file)
@@ -56,7 +56,7 @@
 // User case:
 //  root [0] AliPHOSSDigitizer * s = new AliPHOSSDigitizer("galice.root")
 //  Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-//  root [1] s->ExecuteTask()
+//  root [1] s->Digitize()
 //             // Makes SDigitis for all events stored in galice.root
 //  root [2] s->SetPedestalParameter(0.001)
 //             // One can change parameters of digitization
@@ -90,7 +90,7 @@ ClassImp(AliPHOSSDigitizer)
            
 //____________________________________________________________________________ 
 AliPHOSSDigitizer::AliPHOSSDigitizer() : 
-  TTask("",""),
+  TNamed("",""),
   fPrimThreshold(0.f),
   fDefaultInit(kTRUE),
   fEventFolderName(""),
@@ -106,7 +106,7 @@ AliPHOSSDigitizer::AliPHOSSDigitizer() :
 //____________________________________________________________________________ 
 AliPHOSSDigitizer::AliPHOSSDigitizer(const char * alirunFileName, 
                                     const char * eventFolderName):
-  TTask("PHOS"+AliConfig::Instance()->GetSDigitizerTaskName(), alirunFileName),
+  TNamed("PHOSSDigitizer", alirunFileName),
   fPrimThreshold(0.f),
   fDefaultInit(kFALSE),
   fEventFolderName(eventFolderName),
@@ -123,7 +123,7 @@ AliPHOSSDigitizer::AliPHOSSDigitizer(const char * alirunFileName,
 
 //____________________________________________________________________________
 AliPHOSSDigitizer::AliPHOSSDigitizer(const AliPHOSSDigitizer& sd) :
-  TTask(sd.GetName(), sd.GetTitle()),
+  TNamed(sd.GetName(), sd.GetTitle()),
   fPrimThreshold(sd.fPrimThreshold),
   fDefaultInit(kFALSE),
   fEventFolderName(sd.fEventFolderName),
@@ -146,15 +146,9 @@ AliPHOSSDigitizer& AliPHOSSDigitizer::operator = (const AliPHOSSDigitizer& qa)
 }
 
 //____________________________________________________________________________ 
-AliPHOSSDigitizer::~AliPHOSSDigitizer() {
+AliPHOSSDigitizer::~AliPHOSSDigitizer() 
+{
   //dtor
-  AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
-  if(rl){
-    AliPHOSLoader * phosLoader = 
-      static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
-    if(phosLoader)
-      phosLoader->CleanSDigitizer() ;
-  }
 }
 
 //____________________________________________________________________________ 
@@ -166,12 +160,7 @@ void AliPHOSSDigitizer::Init()
   
   //to prevent cleaning of this object while GetEvent is called
   AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
-  if (!rl)
-    rl = AliRunLoader::Open(GetTitle(), fEventFolderName) ; 
-
-  AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
-  phosLoader->PostSDigitizer(this);
-  phosLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+  if (!rl) rl = AliRunLoader::Open(GetTitle(), fEventFolderName) ; 
 }
 
 //____________________________________________________________________________ 
@@ -183,7 +172,7 @@ void AliPHOSSDigitizer::InitParameters()
 }
 
 //____________________________________________________________________________
-void AliPHOSSDigitizer::Exec(Option_t *option) 
+void AliPHOSSDigitizer::Digitize(Option_t *option) 
 { 
   // Steering method to produce summable digits for events
   // in the range from fFirstEvent to fLastEvent.
@@ -301,7 +290,6 @@ void AliPHOSSDigitizer::Exec(Option_t *option)
     sdigitsBranch->Fill() ;
 
     phosLoader->WriteSDigits("OVERWRITE");
-    phosLoader->WriteSDigitizer("OVERWRITE");
 
     if(strstr(option,"deb"))
       PrintSDigits(option) ;
index c7c1ddb..d3b734e 100644 (file)
@@ -30,7 +30,7 @@
  */
 
 //_________________________________________________________________________
-//  Task Class for making SDigits in PHOS      
+//  Class for making SDigits in PHOS      
 // A Summable Digits is the sum of all hits originating 
 // from one primary in one active cell
 //*--
@@ -38,7 +38,7 @@
 
 
 // --- ROOT system ---
-#include "TTask.h"
+#include "TNamed.h"
 #include "AliConfig.h"
 class TFile ;
 
@@ -48,7 +48,7 @@ class TFile ;
 // --- AliRoot header files ---
 //class AliPHOSQADataMaker ; 
 
-class AliPHOSSDigitizer: public TTask {
+class AliPHOSSDigitizer: public TNamed {
 
 public:
   AliPHOSSDigitizer() ;          // ctor
@@ -58,8 +58,8 @@ public:
 
   virtual ~AliPHOSSDigitizer(); // dtor
 
-  virtual void   Exec(Option_t *option); 
-  Int_t    GetSDigitsInRun() const {return fSDigitsInRun ;}  
+  virtual void   Digitize(Option_t *option); 
+  Int_t          GetSDigitsInRun() const {return fSDigitsInRun ;}  
   virtual void   Print(const Option_t * = "") const ;
   void           SetEventFolderName(TString name) { fEventFolderName = name ; }
   void           SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
@@ -84,7 +84,7 @@ private:
   Int_t   fFirstEvent;      // first event to process
   Int_t   fLastEvent;       // last  event to process
 
-  ClassDef(AliPHOSSDigitizer,5)  // description 
+  ClassDef(AliPHOSSDigitizer,6)  // description 
 
 };
 
index b4fc4ae..6d672ec 100644 (file)
@@ -316,9 +316,9 @@ void AliPMD::Hits2Digits()
 
 }
 // ---------------------------------------------------------------------------
-AliDigitizer* AliPMD::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliPMD::CreateDigitizer(AliDigitizationInput* digInput) const
 { 
-  return new AliPMDDigitizer(manager);
+  return new AliPMDDigitizer(digInput);
 }
 // ---------------------------------------------------------------------------
 void AliPMD::Digits2Raw()
index 700489a..c5363e4 100644 (file)
@@ -48,7 +48,7 @@ public:
   virtual void  SDigits2Digits();
   virtual void  Hits2Digits();
 
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
 
   virtual void  Digits2Raw();
   virtual Bool_t Raw2SDigits(AliRawReader *rawReader);
index 39171b4..d77c940 100644 (file)
@@ -40,7 +40,7 @@
 #include "AliLoader.h"
 #include "AliConfig.h"
 #include "AliMagF.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliDigitizer.h"
 #include "AliHeader.h"
 #include "AliCDBManager.h"
@@ -128,8 +128,8 @@ AliPMDDigitizer & AliPMDDigitizer::operator=(const AliPMDDigitizer& /*digitizer*
   return *this;
 }
 //____________________________________________________________________________
-AliPMDDigitizer::AliPMDDigitizer(AliRunDigitizer* manager):
-  AliDigitizer(manager),
+AliPMDDigitizer::AliPMDDigitizer(AliDigitizationInput* digInput):
+  AliDigitizer(digInput),
   fRunLoader(0),
   fPMDHit(0),
   fPMD(0),
@@ -863,7 +863,7 @@ void AliPMDDigitizer::SDigits2Digits(Int_t ievt)
 
 }
 //____________________________________________________________________________
-void AliPMDDigitizer::Exec(Option_t *option)
+void AliPMDDigitizer::Digitize(Option_t *option)
 {
   // Does the event merging and digitization
   const char *cdeb = strstr(option,"deb");
@@ -872,17 +872,17 @@ void AliPMDDigitizer::Exec(Option_t *option)
       AliDebug(100," *** PMD Exec is called ***");
     }
 
-  Int_t ninputs = fManager->GetNinputs();
+  Int_t ninputs = fDigInput->GetNinputs();
   AliDebug(1,Form("Number of files to be processed = %d",ninputs));
   ResetCellADC();
 
   for (Int_t i = 0; i < ninputs; i++)
     {
-      Int_t troffset = fManager->GetMask(i);
+      Int_t troffset = fDigInput->GetMask(i);
       MergeSDigits(i, troffset);
     }
 
-  fRunLoader = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  fRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   fPMD  = (AliPMD*)gAlice->GetDetector("PMD");
   fPMDLoader = fRunLoader->GetLoader("PMDLoader");
   if (fPMDLoader == 0x0)
@@ -1175,7 +1175,7 @@ void AliPMDDigitizer::TrackAssignment2CPVCell()
 void AliPMDDigitizer::MergeSDigits(Int_t filenumber, Int_t troffset)
 {
   // merging sdigits
-  fRunLoader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(filenumber));
+  fRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(filenumber));
   fPMDLoader = fRunLoader->GetLoader("PMDLoader");
   fPMDLoader->LoadSDigits("read");
   TTree* treeS = fPMDLoader->TreeS();
index 40d128f..004beb2 100644 (file)
@@ -28,7 +28,7 @@ class AliDetector;
 class AliPMDhit;
 class AliHit;
 class AliHeader;
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliCDBManager;
 class AliCDBStorage;
 
@@ -45,7 +45,7 @@ class AliPMDDigitizer:public AliDigitizer
   AliPMDDigitizer();
   AliPMDDigitizer(const AliPMDDigitizer &digitizer);  // copy constructor
   AliPMDDigitizer &operator=(const AliPMDDigitizer &digitizer); // assign op
-  AliPMDDigitizer(AliRunDigitizer *manager);
+  AliPMDDigitizer(AliDigitizationInput* digInput);
   virtual ~AliPMDDigitizer();
 
   void OpengAliceFile(const char *file, Option_t *option);
@@ -53,7 +53,7 @@ class AliPMDDigitizer:public AliDigitizer
   void Hits2SDigits(Int_t ievt);
   void Hits2Digits(Int_t ievt);
   void SDigits2Digits(Int_t ievt);
-  void Exec(Option_t *option);
+  void Digitize(Option_t *option);
   void MergeSDigits(Int_t filenumber, Int_t troffset);
   void TrackAssignment2CPVCell();
   void TrackAssignment2Cell();
index 4dfd254..3034e32 100755 (executable)
@@ -42,6 +42,7 @@
 // --- ROOT system ---
 #include <TMath.h>
 #include <TString.h>
+#include <TList.h>
 
 //---- ANALYSIS system ----
 #include "AliCaloPID.h"
@@ -101,7 +102,7 @@ fhTrackMatchedDEta(0x0),  fhTrackMatchedDPhi(0x0),     fhTrackMatchedDEtaDPhi(0x
 }
 
 //________________________________________________
-AliCaloPID::AliCaloPID(const TTask * emcalpid) : 
+AliCaloPID::AliCaloPID(const TNamed * emcalpid) : 
 TObject(), 
 fEMCALPhotonWeight(0.),   fEMCALPi0Weight(0.),  
 fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),      fEMCALNeutralWeight(0.),
index 1966449..0028f6a 100755 (executable)
@@ -32,7 +32,7 @@
 class TString ;
 class TLorentzVector ;
 #include <TFormula.h>
-class TTask;
+class TList;
 class TH2F ;
 
 //--- AliRoot system ---
@@ -47,7 +47,7 @@ class AliCaloPID : public TObject {
   
   AliCaloPID() ; // ctor
   AliCaloPID(const Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
-  AliCaloPID(const TTask * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
+  AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
   virtual ~AliCaloPID() ;//virtual dtor
   
 private:
index 3694de0..d0d2c22 100644 (file)
@@ -28,7 +28,7 @@
 #include <TRandom.h>           //Resolution()
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDPid::AliHMPIDPid():TTask("HMPIDrec","HMPIDPid")
+AliHMPIDPid::AliHMPIDPid():TNamed("HMPIDrec","HMPIDPid")
 {
 //..
 //init of data members
index b3bd0fb..8006365 100644 (file)
 //////////////////////////////////////////////////////////////////////////
 
 
-#include <TTask.h>        //base class
+#include <TNamed.h>        //base class
 
 class AliESDtrack;
 
-class AliHMPIDPIDResponse : public TTask 
+class AliHMPIDPIDResponse : public TNamed 
 {
 public : 
              AliHMPIDPIDResponse();    //ctor
index 045723e..0b9201d 100644 (file)
@@ -7,7 +7,6 @@ set ( SRCS
     STEER/AliObjectLoader.cxx 
     STEER/AliBaseLoader.cxx 
     STEER/AliTreeLoader.cxx 
-    STEER/AliTaskLoader.cxx 
     STEER/AliDetector.cxx 
     STEER/AliDigit.cxx 
     STEER/AliHit.cxx 
@@ -28,7 +27,7 @@ set ( SRCS
     STEER/AliRndm.cxx 
     STEER/AliDebugVolume.cxx 
     STEER/AliConfig.cxx 
-    STEER/AliRunDigitizer.cxx 
+    STEER/AliDigitizationInput.cxx 
     STEER/AliDigitizer.cxx 
     STEER/AliStream.cxx 
     STEER/AliMergeCombi.cxx 
index d022a8f..e18616d 100644 (file)
@@ -33,7 +33,6 @@
 #include <TROOT.h>
 #include <TString.h>
 #include <TSystem.h>
-#include <TTask.h>
 #include <TVirtualMC.h>
 
 #include "AliConfig.h"
 #include "AliLoader.h"
 #include "AliLog.h"
 
-enum 
- {
-  kDetTaskQA = 0,
-  kDetTaskSDigitizer,
-  kDetTaskDigitizer,
-  kDetTaskRecontructioner,
-  kDetTaskTracker,
-  kDetTaskPID,
-  kDetTaskLast
- };
-
 enum
  {
    kDetFolderData = 0,
    kDetFolderCalibration,
    kDetFolderAligmnet,
-   kDetFolderQA,
    kDetFolderLast
  };
 ClassImp(AliConfig)
@@ -69,7 +56,6 @@ AliConfig* AliConfig::fgInstance = 0;
 const TString AliConfig::fgkTopFolderName("Folders");
 
 //1st level folder
-const TString AliConfig::fgkTasksFolderName("Tasks"); //task folder, commn
 const TString AliConfig::fgkConstantsFolderName("Constants");
 const TString AliConfig::fgkDefaultEventFolderName("Event");  //default folder for event, always used except merging
 
@@ -81,19 +67,10 @@ const TString AliConfig::fgkConditionsFolderName("Conditions");//folder with con
 const TString AliConfig::fgkConfigurationFolderName("Configuration");//folder with configuration (setup) of the detector
 const TString AliConfig::fgkHeaderFolderName("Header");//folder with header and other MC information
 
-//Tasks names, goes into fgkTasksFolderName folder
-const TString AliConfig::fgkDigitizerTaskName("Digitizer");
-const TString AliConfig::fgkSDigitizerTaskName("SDigitizer");
-const TString AliConfig::fgkReconstructionerTaskName("Reconstructioner");
-const TString AliConfig::fgkTrackerTaskName("Tracker");
-const TString AliConfig::fgkPIDTaskName("PIDTask");//;=) PIDer???
-const TString AliConfig::fgkQATaskName("QAtask");
-
 //3rd level folder
 //fgkConditionsFolderName subfolders
 const TString AliConfig::fgkCalibrationFolderName("Calibration");
 const TString AliConfig::fgkAligmentFolderName("Aligment");
-const TString AliConfig::fgkQAFolderName("QAout");
   
 //3rd level folder
 //fgkConfigurationFolderName subfolders
@@ -123,9 +100,7 @@ AliConfig* AliConfig::Instance ()
 AliConfig::AliConfig(const char *name, const char *title): 
   TNamed(name,title), 
   fTopFolder(gROOT->GetRootFolder()->AddFolder(name,title)),
-  fTaskFolder(fTopFolder->AddFolder(fgkTasksFolderName, "ALICE Tasks")),
   fConstFolder(0x0),
-  fDetectorTask(0x0),
   fDetectorFolder(new TString[kDetFolderLast+1])
 {
 // Constructor
@@ -141,7 +116,6 @@ AliConfig::AliConfig(const char *name, const char *title):
   fDetectorFolder[kDetFolderData] = fgkDataFolderName;
   fDetectorFolder[kDetFolderCalibration] = fgkConditionsFolderName+"/"+fgkCalibrationFolderName;
   fDetectorFolder[kDetFolderAligmnet] = fgkConditionsFolderName+"/"+fgkAligmentFolderName;
-  fDetectorFolder[kDetFolderQA] = fgkConditionsFolderName+"/"+fgkQAFolderName;
   fDetectorFolder[kDetFolderLast] = "";
   
   gROOT->GetListOfBrowsables()->Add(fTopFolder, name);
@@ -150,30 +124,6 @@ AliConfig::AliConfig(const char *name, const char *title):
   fConstFolder = fTopFolder->AddFolder (fgkConstantsFolderName, "Constant parameters");
   fConstFolder->AddFolder("DatabasePDG", "PDG database");
   
-  // Add the tasks to //Folders
-  
-  TTask * qa = new TTask(fgkQATaskName, "Alice QA tasks");
-  fTaskFolder->Add(qa); 
-  TTask * sd = new TTask(fgkSDigitizerTaskName, "Alice SDigitizer") ;
-  fTaskFolder->Add(sd); 
-  TTask * di = new TTask(fgkDigitizerTaskName, "Alice Digitizer") ;
-  fTaskFolder->Add(di); 
-  TTask * re = new TTask(fgkReconstructionerTaskName, "Alice Reconstructioner") ;
-  fTaskFolder->Add(re); 
-  TTask * tr = new TTask(fgkTrackerTaskName,"Alice Tracker");
-  fTaskFolder->Add(tr);
-  TTask * pid = new TTask(fgkPIDTaskName,"Alice Particle Identification Task");
-  fTaskFolder->Add(pid);
-  fDetectorTask    =  new TString[kDetTaskLast+1];
-  
-  fDetectorTask[kDetTaskQA] = fgkQATaskName;
-  fDetectorTask[kDetTaskSDigitizer] = fgkSDigitizerTaskName;
-  fDetectorTask[kDetTaskDigitizer] =  fgkDigitizerTaskName;
-  fDetectorTask[kDetTaskRecontructioner] = fgkReconstructionerTaskName;
-  fDetectorTask[kDetTaskTracker] = fgkTrackerTaskName;
-  fDetectorTask[kDetTaskPID] = fgkPIDTaskName;
-  fDetectorTask[kDetTaskLast] = "";
-
   fgInstance=this;
 }
 
@@ -182,7 +132,6 @@ AliConfig::~AliConfig()
 { 
   // destructor
   delete [] fDetectorFolder ;  
-  delete [] fDetectorTask;
   if (fTopFolder)
    {
     fTopFolder->SetOwner();
@@ -198,37 +147,6 @@ void AliConfig::AddInFolder (const char *dir, TObject *obj)
   if (folder)
     folder->Add (static_cast<TObject *>(obj));
 }
-//____________________________________________________________________________
-
-Int_t AliConfig::AddSubTask(const char *taskname, const char* name,const char* title)
-{
-//Create new task named 'name' and titled 'title' 
-//as a subtask of the task named 'taskname'
-
-   AliDebug(1, Form("Try to get folder named %s",taskname));
-   TObject* obj = fTopFolder->FindObject(taskname);
-   TTask * task = (obj)?dynamic_cast<TTask*>(obj):0x0;
-   if (task)
-     {
-      AliDebug(1, "          Got");
-      TTask * subtask = static_cast<TTask*>(task->GetListOfTasks()->FindObject(name));
-      if (!subtask) 
-        {
-          subtask = new TTask(name,title);
-          task->Add(subtask);
-        }
-      else
-       {
-         AliWarning(Form("Task named \"%s\" already exists in Task %s",name,taskname));
-       }
-     }
-   else
-     {
-       AliError(Form("Can not find task %s to put a new task in.",taskname));
-       return 1;
-     }
-  return 0;
-}
 
 //____________________________________________________________________________
 TObject* AliConfig::FindInFolder (const char *dir, const char *name)
@@ -279,7 +197,7 @@ void AliConfig::Add(AliModule* obj,const char* eventfolder)
 
 Int_t AliConfig::AddDetector(TFolder* evntfolder, const char *name, const char* title)
 {
-//creates folders and tasks for the detector 'name'
+//creates folders for the detector 'name'
  Int_t retval;//returned value
  retval = CreateDetectorFolders(evntfolder,name,title);
  if (retval)
@@ -293,7 +211,7 @@ Int_t AliConfig::AddDetector(TFolder* evntfolder, const char *name, const char*
 
 Int_t AliConfig::AddDetector(const char* evntfoldername,const char *name, const char* title)
 {
-//creates folders and tasks for the detector 'name'
+//creates folders for the detector 'name'
  Int_t retval;//returned value
  retval = CreateDetectorFolders(evntfoldername,name,title);
  if (retval)
@@ -301,12 +219,6 @@ Int_t AliConfig::AddDetector(const char* evntfoldername,const char *name, const
     AliError(Form("CreateDetectorFolders returned error for detector %s",name));
     return retval;
   }
-// retval = CreateDetectorTasks(name,title);
-// if (retval)
-//  {
-//    Error("AddDetector","CreateDetectorTasks returned error for detector %s",name);
-//    return retval;
-//  }
  return 0; 
 }
 //____________________________________________________________________________
@@ -326,8 +238,6 @@ void  AliConfig::Add(AliDetector * obj,const char* eventfolder)
    } 
   CreateDetectorFolders(evfolder, obj->GetName(), obj->GetTitle());
   
-//  CreateDetectorTasks(obj->GetName(),obj->GetTitle());
-
 }
 //____________________________________________________________________________
 
@@ -369,26 +279,6 @@ Int_t  AliConfig::CreateDetectorFolders(TFolder* evntfolder,const char *name, co
   }
  return 0;
 }
-//____________________________________________________________________________
-Int_t AliConfig::CreateDetectorTasks(const char *name, const char* title)
-{
-  // Creates new detector's task "name"
-   Int_t i = 0;
-   Int_t tmp;
-   while (i < kDetTaskLast)
-    {
-      tmp = AddSubTask(fgkTasksFolderName+"/"+fDetectorTask[i],
-                       name+fDetectorTask[i],(fDetectorTask[i]+" for ")+title);
-      if (tmp)
-       {
-         AliError(Form("Error occured while creating task for %s in %s.",
-                      name,fDetectorTask[i-1].Data()));
-         return 1;
-       }
-      i++;
-    }
-   return 0;
-}
 
 /*****************************************************************************/
 
@@ -396,9 +286,7 @@ TFolder* AliConfig::BuildEventFolder(const char* name,const char* title)
 {
 /*
  creates the folder structure for one event
- TopFolder_
-         | \
-         |  Tasks
+ TopFolder
          |_
          | \
          |  Constants
@@ -510,7 +398,6 @@ TFolder* AliConfig::BuildEventFolder(const char* name,const char* title)
   TFolder *conditions = eventfolder->AddFolder(fgkConditionsFolderName, "Run conditions");
   conditions->AddFolder(fgkCalibrationFolderName,"Detector calibration data");
   conditions->AddFolder(fgkAligmentFolderName,"Detector aligment");
-  conditions->AddFolder(fgkQAFolderName,"Quality Asurance Output"); //Folder with output of the QA task(s)
   //Configuration
   TFolder *configuration = eventfolder->AddFolder(fgkConfigurationFolderName, "Run configuration");
   configuration->AddFolder(fgkFieldFolderName, "Magnetic field maps");
@@ -526,60 +413,12 @@ TFolder* AliConfig::BuildEventFolder(const char* name,const char* title)
 
 /*****************************************************************************/
 
-TString AliConfig::GetQATaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskQA];
- }
-/*****************************************************************************/
-TString AliConfig::GetDigitizerTaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskDigitizer];
- }
-/*****************************************************************************/
-TString AliConfig::GetSDigitizerTaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskSDigitizer];
- }
-/*****************************************************************************/
-
-TString AliConfig::GetReconstructionerTaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskRecontructioner];
- }
-/*****************************************************************************/
-
-TString AliConfig::GetTrackerTaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskTracker];
- }
-/*****************************************************************************/
-
-TString AliConfig::GetPIDTaskName() const
- {
- //returns task name
-  return fDetectorTask[kDetTaskPID];
- }
-/*****************************************************************************/
-
-const TString& AliConfig::GetQAFolderName() const
-{
-//returns pathname of folder with QA output relative to Top Alice Folder
-  return fDetectorFolder[kDetFolderQA];
-}
-/*****************************************************************************/
-
 const TString& AliConfig::GetDataFolderName() const
 {
 //returns name of data folder path relative to event folder
  return fgkDataFolderName;
 }
+
 /*****************************************************************************/
 
 Int_t AliConfig::AddSubFolder(TFolder* topfolder, const char* infoler, 
index 693916a..3a747d8 100644 (file)
@@ -27,7 +27,6 @@ class AliConfig;
 class AliDetector;
 class AliGenerator;
 class AliModule;
-class AliTasks;
 
 class AliConfig : public TNamed {
   
@@ -47,31 +46,18 @@ public:
   
   Int_t      CreateDetectorFolders(const char* evntfoldername,const char *name, const char* title);//Used by AliRunGetter
   Int_t      CreateDetectorFolders(TFolder* evntfolder,const char *name, const char* title);//Used by AliRunGetter
-  Int_t      CreateDetectorTasks(const char *name, const char* title);
   
   static     AliConfig* Instance();
   
   TFolder*              BuildEventFolder(const char* name,const char* tilte);
   
   TFolder*              GetTopFolder(){return fTopFolder;}
-  TFolder*              GetTaskFolder(){return fTaskFolder;}
   TFolder*              GetConstFolder(){return fConstFolder;}
 
   static const TString& GetModulesFolderName(){return fgkModuleFolderName;}
   static const TString& GetDefaultEventFolderName()
     {return fgkDefaultEventFolderName;}
-  static const TString& GetTasksFolderName() {return fgkTasksFolderName;}
-  
-  TString               GetQATaskName() const; //returns path to QA tasks
-  TString               GetDigitizerTaskName () const;
-  TString               GetSDigitizerTaskName () const;
-  TString               GetReconstructionerTaskName () const;
-  TString               GetTrackerTaskName () const;
-  TString               GetPIDTaskName () const;
-  
-  
-  const TString&        GetQAFolderName() const; //returns path to folder with QA output
-  
+    
   const TString&        GetDataFolderName() const;//returns name of data folder
 
 private:  
@@ -83,39 +69,27 @@ private:
   static const TString  fgkTopFolderName; //name of top AliRoot folder
  
   static const TString  fgkDefaultEventFolderName; //name of event folder
-  static const TString  fgkTasksFolderName;        //name of task folder
   static const TString  fgkConstantsFolderName;    //name of constants folder
   
   static const TString  fgkDataFolderName;         //name of data folde
   static const TString  fgkConditionsFolderName;   //name of conditions folder
   static const TString  fgkConfigurationFolderName;//name of configuration foolder
   static const TString  fgkHeaderFolderName;       //name of header folder
-  
-  static const TString  fgkDigitizerTaskName;      //name of digitizer task
-  static const TString  fgkSDigitizerTaskName;     //name of sdigitizer task
-  static const TString  fgkQATaskName;             //name of Q-A task
-  static const TString  fgkReconstructionerTaskName;//name of reconstructioner
-                                                    //task
-  static const TString  fgkTrackerTaskName;        //name of tracker task 
-  static const TString  fgkPIDTaskName;            //name of PID task
-  
+    
   static const TString  fgkCalibrationFolderName;  //name of calibration folder
   static const TString  fgkAligmentFolderName;     //name of alignment folder
-  static const TString  fgkQAFolderName;           //name of QA folder
   
   static const TString  fgkFieldFolderName;        //name of magn.field folder
   static const TString  fgkGeneratorsFolderName;   //name of generator folder
   static const TString  fgkVirtualMCFolderName;    //name of virtual MC folder
 
   void          AddInFolder (const char * dir, TObject *obj);
-  Int_t         AddSubTask(const char *taskname, const char* name, const char* title);
   Int_t         AddSubFolder(TFolder* topfolder, const char* infoler, //helper method
                      const char* newfoldname, const char* newfoldtitle);
   TObject*      FindInFolder (const char *dir, const char *name);
   
   // folders
   TFolder*              fTopFolder;    //pointer to top folder
-  TFolder*              fTaskFolder;   //pointer to task folder
   TFolder*              fConstFolder;  //pointer to constants folder
 
   static const TString  fgkPDGFolderName; //name of PDG folder
@@ -123,13 +97,12 @@ private:
   static const TString  fgkMCFolderName;        //name of MC folder
   static const TString  fgkModuleFolderName;    //name of module folder
   
-  TString              *fDetectorTask;//!array with names for detector tasks
   TString              *fDetectorFolder;//!array with names for detector folders (where detector is going to be put)
   
   static AliConfig*     fgInstance; //pointer to the AliConfig instance
   
   
-  ClassDef(AliConfig,2) //Configuration class for AliRun
+  ClassDef(AliConfig,3) //Configuration class for AliRun
 };                             // end class AliConfig
 
 #endif
index 9de8386..39c2230 100644 (file)
 //  Data managed by these standard base loaders has fixed naming convention                //
 //  e.g. - tree with hits is always named TreeH                                            //
 //                     (defined in AliLoader::fgkDefaultHitsContainerName)                 //
-//       - task DtectorName+Name defined                                                   //
 //                                                                                         //
 //  EStdBasicLoaders   idx     Object Type        Description                              //
 //      kData           0    TTree or TObject     main data itself (hits,digits,...)       //
-//      kTask           1        TTask            object producing main data               //
-//      kQA             2        TTree                quality assurance tree               //
-//      kQATask         3        TTask            task producing QA object                 //
 //                                                                                         //
 //                                                                                         //
 //  User can define and add more basic loaders even Run Time.                              //
@@ -33,7 +29,6 @@
 #include "AliLoader.h"
 #include "AliObjectLoader.h"
 #include "AliTreeLoader.h"
-#include "AliTaskLoader.h"
 #include "AliLog.h"
 
 #include <TFile.h>
@@ -52,9 +47,6 @@ AliDataLoader::AliDataLoader():
  fCompressionLevel(2),
  fNEventsPerFile(0),
  fBaseLoaders(0x0),
- fHasTask(kFALSE),
- fTaskName(),
- fParentalTask(0x0),
  fEventFolder(0x0),
  fFolder(0x0)
 {
@@ -72,9 +64,6 @@ AliDataLoader::AliDataLoader(const char* filename, const char* contname,
  fCompressionLevel(2),
  fNEventsPerFile(0),
  fBaseLoaders(new TObjArray(4)),
- fHasTask(kFALSE),
- fTaskName(),
- fParentalTask(0x0),
  fEventFolder(0x0),
  fFolder(0x0)
 {
@@ -275,7 +264,7 @@ void AliDataLoader::Unload()
 void AliDataLoader::UnloadAll()
 {
   //
-  // Unloads all data and tasks
+  // Unloads all data 
   //
   if ( fFile == 0x0 ) return; //nothing loaded
   
@@ -457,7 +446,7 @@ void AliDataLoader::Clean()
 void AliDataLoader::CleanAll()
 {
   //
-  // Cleans all folders and tasks
+  // Cleans all folders 
   //
   TIter next(fBaseLoaders);
   AliBaseLoader* bl;
@@ -595,10 +584,9 @@ Bool_t AliDataLoader::IsOptionContrary(const TString& option) const
 void AliDataLoader::AddBaseLoader(AliBaseLoader* bl)
 {
   //Adds a base loader to lits of base loaders managed by this data loader
-  //Managed data/task will be stored in proper root directory,
+  //Managed data will be stored in proper root directory,
   //and posted to 
   // - in case of tree/object - data folder connected with detector associated with this data loader
-  // - in case of task - parental task which defined in this AliTaskLoader 
   
   if (bl == 0x0)
     {
@@ -672,33 +660,6 @@ AliObjectLoader* AliDataLoader::GetBaseDataLoader()
 }
 
 //______________________________________________________________________________
-AliTaskLoader* AliDataLoader::GetBaseTaskLoader()
-{
-  //
-  // Gets the base task loader
-  //
-  return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kTask));
-}
-
-//______________________________________________________________________________
-AliBaseLoader* AliDataLoader::GetBaseQALoader()
-{
-  //
-  // Gets the base QA loader
-  //
-  return GetBaseLoader(kQA);
-}
-
-//______________________________________________________________________________
-AliTaskLoader* AliDataLoader::GetBaseQATaskLoader()
-{
-  //
-  // Returns pointer to QA base loader
-  //
-  return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kQATask));
-}
-
-//______________________________________________________________________________
 void AliDataLoader::SetBaseDataLoader(AliBaseLoader* bl)
 {
   //
@@ -714,51 +675,6 @@ void AliDataLoader::SetBaseDataLoader(AliBaseLoader* bl)
 }
 
 //______________________________________________________________________________
-void AliDataLoader::SetBaseTaskLoader(AliTaskLoader* bl)
-{
-  //
-  // Sets Task base loader
-  //
-  if (bl == 0x0)
-   {
-     AliError("Parameter is null");
-     return;
-   }
-  if (GetBaseTaskLoader()) delete GetBaseTaskLoader();
-  fBaseLoaders->AddAt(bl,kTask);
-}
-
-//______________________________________________________________________________
-void AliDataLoader::SetBaseQALoader(AliBaseLoader* bl)
-{
-  //
-  // Sets QA base loader
-  //
-  if (bl == 0x0)
-    {
-      AliError("Parameter is null");
-      return;
-    }
-  if (GetBaseQALoader()) delete GetBaseQALoader();
-  fBaseLoaders->AddAt(bl,kQA);
-}
-
-//______________________________________________________________________________
-void AliDataLoader::SetBaseQATaskLoader(AliTaskLoader* bl)
-{
-  //
-  // Sets QA Task base loader
-  //
-  if (bl == 0x0)
-    {
-      AliError("Parameter is null");
-      return;
-   }
-  if (GetBaseQATaskLoader()) delete GetBaseQATaskLoader();
-  fBaseLoaders->AddAt(bl,kQATask);
-}
-
-//______________________________________________________________________________
 void AliDataLoader::Synchronize()
 {
   //
index 03d7d7e..e589018 100644 (file)
 //  i.e. Hits, Kine, etc.                 //
 //  many objects type can be assciated    //
 //  with one data type: storing object    //
-//  (usually tree), task producing it,    //
-//  Quality Assurance(QA), QA Task, and   //
-//  others.                               //
-//                                        //
+//  (usually tree)                        //
 //                                        //
 ////////////////////////////////////////////
 
-class TTask;
 class TTree;
 class TFile;
 class TFolder;
@@ -29,7 +25,6 @@ class TFolder;
 class AliBaseLoader;
 class AliObjectLoader;
 class AliRunLoader;
-class AliTaskLoader;
 
 #include <TDirectory.h>
 #include <TNamed.h>
@@ -85,19 +80,13 @@ class AliDataLoader: public TNamed
    void               SetDirName(TString& dirname);
 
    void               AddBaseLoader(AliBaseLoader* bl);
-   enum EStdBasicLoaders {kData = 0,kTask,kQA,kQATask};//standard basic loaders identifiers
+   enum EStdBasicLoaders {kData = 0};//standard basic loaders identifiers
 
    AliBaseLoader*     GetBaseLoader(const TString& name) const;
    AliBaseLoader*     GetBaseLoader(Int_t n) const;
    AliObjectLoader*   GetBaseDataLoader();
-   AliTaskLoader*     GetBaseTaskLoader();
-   AliBaseLoader*     GetBaseQALoader();
-   AliTaskLoader*     GetBaseQATaskLoader();
    
    void               SetBaseDataLoader(AliBaseLoader* bl);
-   void               SetBaseTaskLoader(AliTaskLoader* bl);
-   void               SetBaseQALoader(AliBaseLoader* bl);
-   void               SetBaseQATaskLoader(AliTaskLoader* bl);
    
    Bool_t             CheckReload();//checks if we have to reload given file
    Bool_t             IsFileWritable() const;
@@ -121,14 +110,11 @@ class AliDataLoader: public TNamed
    Int_t        fNEventsPerFile;  //defines number of events stored per one file
    
    TObjArray*   fBaseLoaders;//base loaders
-   Bool_t       fHasTask;// flag if has a task
-   TString      fTaskName;// name of the task
-   TTask*       fParentalTask;//Parental task
 
    TFolder*     fEventFolder;//!event folder
    TFolder*     fFolder;//! folder with data
    
-   ClassDef(AliDataLoader,2)
+   ClassDef(AliDataLoader,3)
  };
 
 #endif
similarity index 79%
rename from STEER/STEER/AliRunDigitizer.cxx
rename to STEER/STEER/AliDigitizationInput.cxx
index 9f71574..ebf739b 100644 (file)
 
 //_______________________________________________________________________
 //
-// AliRunDigitizer.cxx
+// AliDigitizationInput.cxx
+// RS: Created from former AliDigitizationInput. It does not anymore manage digitization:
+// (now it is steared by the AliSimulation) but just provides input info for 
+// AliDetector::SDigits2Ditits.
 //
 // Manager object for merging/digitization
 //
@@ -25,8 +28,8 @@
 // Sdigits into Digits. 
 //
 // Only one instance of this class is created in the macro:
-//   AliRunDigitizer * manager = 
-//      new AliRunDigitizer(nInputStreams,SPERB);
+//   AliDigitizationInput * manager = 
+//      new AliDigitizationInput(nInputStreams,SPERB);
 // where nInputStreams is number of input streams and SPERB is
 // signals per background variable, which determines how combinations
 // of signal and background events are generated.
@@ -59,7 +62,7 @@
 //
 // Example with MUON digitizer, no merging, just digitization
 //
-//  AliRunDigitizer * manager = new AliRunDigitizer(1,1);
+//  AliDigitizationInput * manager = new AliDigitizationInput(1,1);
 //  manager->SetInputStream(0,"galice.root");
 //  AliMUONDigitizer *dMUON  = new AliMUONDigitizer(manager);
 //  manager->Exec("");
@@ -69,7 +72,7 @@
 //   (background) file. Number of merged events is
 //   min(number of events in galice.root, number of events in bgr.root)
 //
-//  AliRunDigitizer * manager = new AliRunDigitizer(2,1);
+//  AliDigitizationInput * manager = new AliDigitizationInput(2,1);
 //  manager->SetInputStream(0,"galice.root");
 //  manager->SetInputStream(1,"bgr.root");
 //  AliMUONDigitizer *dMUON  = new AliMUONDigitizer(manager);
@@ -78,7 +81,7 @@
 // Example with MUON digitizer, save digits in a new file digits.root,
 //   process only 1 event
 //
-//  AliRunDigitizer * manager = new AliRunDigitizer(2,1);
+//  AliDigitizationInput * manager = new AliDigitizationInput(2,1);
 //  manager->SetInputStream(0,"galice.root");
 //  manager->SetInputStream(1,"bgr.root");
 //  manager->SetOutputFile("digits.root");
@@ -104,17 +107,17 @@ class TList;
 #include "AliLoader.h"
 #include "AliMergeCombi.h"
 #include "AliRun.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRunLoader.h"
 
-ClassImp(AliRunDigitizer)
+ClassImp(AliDigitizationInput)
 
-const TString AliRunDigitizer::fgkDefOutFolderName("Output");
-const TString AliRunDigitizer::fgkBaseInFolderName("Input");
+const TString AliDigitizationInput::fgkDefOutFolderName("Output");
+const TString AliDigitizationInput::fgkBaseInFolderName("Input");
 
 
 //_______________________________________________________________________
-AliRunDigitizer::AliRunDigitizer(): TTask("AliRunDigitizer","The manager for Merging"),
+AliDigitizationInput::AliDigitizationInput(): TNamed("AliDigitizationInput","The manager for Merging"),
  fkMASKSTEP(0),
  fOutputFileName(0),
  fOutputDirName(0),
@@ -124,6 +127,7 @@ AliRunDigitizer::AliRunDigitizer(): TTask("AliRunDigitizer","The manager for Mer
  fCopyTreesFromInput(0),
  fNinputs(0),
  fNinputsGiven(0),
+ fRegionOfInterest(kFALSE),
  fInputStreams(0x0),
  fOutRunLoader(0x0),
  fOutputInitialized(kFALSE),
@@ -138,8 +142,8 @@ AliRunDigitizer::AliRunDigitizer(): TTask("AliRunDigitizer","The manager for Mer
 }
 
 //_______________________________________________________________________
-AliRunDigitizer::AliRunDigitizer(Int_t nInputStreams, Int_t sperb):
- TTask("AliRunDigitizer","The manager for Merging"),
+AliDigitizationInput::AliDigitizationInput(Int_t nInputStreams, Int_t sperb):
+ TNamed("AliDigitizationInput","The manager for Merging"),
  fkMASKSTEP(10000000),
  fOutputFileName(""),
  fOutputDirName("."),
@@ -149,6 +153,7 @@ AliRunDigitizer::AliRunDigitizer(Int_t nInputStreams, Int_t sperb):
  fCopyTreesFromInput(-1),
  fNinputs(nInputStreams),
  fNinputsGiven(0),
+ fRegionOfInterest(kFALSE),
  fInputStreams(new TClonesArray("AliStream",nInputStreams)),
  fOutRunLoader(0x0),
  fOutputInitialized(kFALSE),
@@ -184,7 +189,7 @@ AliRunDigitizer::AliRunDigitizer(Int_t nInputStreams, Int_t sperb):
 }
 //_______________________________________________________________________
 
-void AliRunDigitizer::Copy(TObject&) const
+void AliDigitizationInput::Copy(TObject&) const
 {
   //
   // Non implemented copy function
@@ -194,7 +199,7 @@ void AliRunDigitizer::Copy(TObject&) const
 
 //_______________________________________________________________________
 
-AliRunDigitizer::~AliRunDigitizer() 
+AliDigitizationInput::~AliDigitizationInput() 
 {
   //
   // dtor
@@ -203,16 +208,9 @@ AliRunDigitizer::~AliRunDigitizer()
   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, const char *inputFile, TString foldername)
+void AliDigitizationInput::SetInputStream(Int_t i, const char *inputFile, TString foldername)
 {
 //
 // Sets the name of the input file
@@ -231,46 +229,7 @@ void AliRunDigitizer::SetInputStream(Int_t i, const char *inputFile, TString fol
 }
 
 //_______________________________________________________________________
-void AliRunDigitizer::Digitize(Option_t* option)
-{
-// 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 gAlice is already in memory, use it
-  
-  if (!static_cast<AliStream*>(fInputStreams->At(0))->ImportgAlice()) 
-   {
-     AliError("Error occured while getting gAlice from Input 0");
-     return;
-   }
-    
-  if (!InitGlobal()) //calls Init() for all (sub)digitizers
-   {
-     AliError("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();//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()
+Bool_t AliDigitizationInput::ConnectInputTrees()
 {
   //
   // loads events 
@@ -294,26 +253,10 @@ Bool_t AliRunDigitizer::ConnectInputTrees()
   return kTRUE;
 }
 
-//_______________________________________________________________________
-Bool_t AliRunDigitizer::InitGlobal()
-{
-  //
-  // Method called once before Digitize() is called
-  // initialize digitizers and output
-  //
-  fOutputInitialized = kFALSE;
-  TList* subTasks = this->GetListOfTasks();
-  if (subTasks) {
-    TIter next(subTasks);
-    while (AliDigitizer * dig = (AliDigitizer *) next())
-     dig->Init();
-  }
-  return kTRUE;
-}
 
 //_______________________________________________________________________
 
-void AliRunDigitizer::SetOutputFile(TString fn)
+void AliDigitizationInput::SetOutputFile(TString fn)
 {
   //
   // The output will be to separate file, 
@@ -326,7 +269,7 @@ void AliRunDigitizer::SetOutputFile(TString fn)
 }
 
 //_______________________________________________________________________
-Bool_t AliRunDigitizer::InitOutputGlobal()
+Bool_t AliDigitizationInput::InitOutputGlobal()
 {
   //
   // Creates the output file, called by InitEvent()
@@ -372,7 +315,7 @@ Bool_t AliRunDigitizer::InitOutputGlobal()
 }
 //_______________________________________________________________________
 
-void AliRunDigitizer::InitEvent()
+void AliDigitizationInput::InitEvent()
 {
   //
   // redirects output properly
@@ -385,7 +328,7 @@ void AliRunDigitizer::InitEvent()
 }
 //_______________________________________________________________________
 
-void AliRunDigitizer::FinishEvent()
+void AliDigitizationInput::FinishEvent()
 {
   //
   // called at the end of loop over digitizers
@@ -430,7 +373,7 @@ void AliRunDigitizer::FinishEvent()
 }
 //_______________________________________________________________________
 
-void AliRunDigitizer::FinishGlobal()
+void AliDigitizationInput::FinishGlobal()
 {
   //
   // called at the end of Exec
@@ -466,7 +409,7 @@ void AliRunDigitizer::FinishGlobal()
 }
 //_______________________________________________________________________
 
-Int_t  AliRunDigitizer::GetNParticles(Int_t event) const
+Int_t  AliDigitizationInput::GetNParticles(Int_t event) const
 {
 // return number of particles in all input files for a given
 // event (as numbered in the output file)
@@ -483,7 +426,7 @@ Int_t  AliRunDigitizer::GetNParticles(Int_t event) const
 }
 //_______________________________________________________________________
 
-Int_t  AliRunDigitizer::GetNParticles(Int_t /*event*/, Int_t /*input*/) const
+Int_t  AliDigitizationInput::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)
@@ -496,7 +439,7 @@ Int_t  AliRunDigitizer::GetNParticles(Int_t /*event*/, Int_t /*input*/) const
 }
 
 //_______________________________________________________________________
-Int_t* AliRunDigitizer::GetInputEventNumbers(Int_t event) const
+Int_t* AliDigitizationInput::GetInputEventNumbers(Int_t event) const
 {
 // return pointer to an int array with input event numbers which were
 // merged in the output event event
@@ -509,7 +452,7 @@ Int_t* AliRunDigitizer::GetInputEventNumbers(Int_t event) const
   return a;
 }
 //_______________________________________________________________________
-Int_t AliRunDigitizer::GetInputEventNumber(Int_t event, Int_t /*input*/) const
+Int_t AliDigitizationInput::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
@@ -518,7 +461,7 @@ Int_t AliRunDigitizer::GetInputEventNumber(Int_t event, Int_t /*input*/) const
   return event;
 }
 //_______________________________________________________________________
-TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t event) const
+TParticle* AliDigitizationInput::GetParticle(Int_t i, Int_t event) const
 {
 // return pointer to particle with index i (index with mask)
 
@@ -528,7 +471,7 @@ TParticle* AliRunDigitizer::GetParticle(Int_t i, Int_t event) const
 }
 
 //_______________________________________________________________________
-TParticle* AliRunDigitizer::GetParticle(Int_t /*i*/, Int_t /*input*/, Int_t /*event*/) const
+TParticle* AliDigitizationInput::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)
@@ -541,19 +484,7 @@ TParticle* AliRunDigitizer::GetParticle(Int_t /*i*/, Int_t /*input*/, Int_t /*ev
 }
 
 //_______________________________________________________________________
-void AliRunDigitizer::ExecuteTask(Option_t* option)
-{
-  //
-  // overwrite ExecuteTask to do Digitize only
-  //
-  if (!IsActive()) return;
-  Digitize(option);
-  fHasExecuted = kTRUE;
-  return;
-}
-
-//_______________________________________________________________________
-const TString& AliRunDigitizer::GetInputFolderName(Int_t i) const
+const TString& AliDigitizationInput::GetInputFolderName(Int_t i) const
 {
   //
   // Get the input Folder Name
@@ -565,7 +496,7 @@ const TString& AliRunDigitizer::GetInputFolderName(Int_t i) const
 }
 //_______________________________________________________________________
 
-const char* AliRunDigitizer::GetOutputFolderName()
+const char* AliDigitizationInput::GetOutputFolderName()
 {
   //
   // Get output folder name
@@ -574,7 +505,7 @@ const char* AliRunDigitizer::GetOutputFolderName()
 }
 //_______________________________________________________________________
 
-AliRunLoader* AliRunDigitizer::GetOutRunLoader()
+AliRunLoader* AliDigitizationInput::GetOutRunLoader()
 {
   //
   // Returns Run Loader
@@ -591,7 +522,7 @@ AliRunLoader* AliRunDigitizer::GetOutRunLoader()
 }
 //_______________________________________________________________________
 
-TString AliRunDigitizer::GetInputFileName(Int_t input, Int_t order) const 
+TString AliDigitizationInput::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
similarity index 87%
rename from STEER/STEER/AliRunDigitizer.h
rename to STEER/STEER/AliDigitizationInput.h
index 9840912..0035c63 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIRUNDIGITIZER_H
-#define ALIRUNDIGITIZER_H
+#ifndef ALIDIGITIZATIONINPUT_H
+#define ALIDIGITIZATIONINPUT_H
 /* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -16,7 +16,7 @@
 // --- ROOT system ---
 
 #include "TArrayI.h"
-#include "TTask.h"
+#include "TNamed.h"
 #include "TClonesArray.h"
 class TFile;
 class TParticle;
@@ -31,18 +31,13 @@ class AliRunLoader;
 
 #define MAXSTREAMSTOMERGE 4
 
-class AliRunDigitizer: public TTask {
+class AliDigitizationInput: public TNamed {
 
 public:
-  AliRunDigitizer();
-  AliRunDigitizer(Int_t nInputStreams, Int_t sperb=1);
+  AliDigitizationInput();
+  AliDigitizationInput(Int_t nInputStreams, Int_t sperb=1);
 
-  virtual ~AliRunDigitizer();
-
-  void      ExecuteTask(Option_t* option = 0);
-  void      Exec(Option_t *option) {this->Digitize(option);}
-  void      Digitize(Option_t* option = 0);
-  void      AddDigitizer(AliDigitizer *digitizer);
+  virtual ~AliDigitizationInput();
 
   void      SetOutputFile(TString fn);
   TString   GetOutputFile() const {return fOutputFileName;}
@@ -60,8 +55,8 @@ public:
   void      SetCombinationFileName(TString fn) {fCombinationFileName = fn;} 
   TString   GetCombinationFileName() const {return fCombinationFileName;}
   Int_t     GetMask(Int_t i) const {return fkMASK[i];}
-
-
+  void      SetRegionOfInterest(Bool_t flag) {fRegionOfInterest = flag;};
+  Bool_t    GetRegionOfInterest() const {return fRegionOfInterest;};
   Int_t     GetNinputs() const {return fNinputs;}
   const TString& GetInputFolderName(Int_t i) const;
   const char* GetOutputFolderName();
@@ -94,17 +89,18 @@ public:
 
 // return TString with input file name  
   TString GetInputFileName(Int_t input, Int_t order) const;
-  
-private:
-  AliRunDigitizer(const AliRunDigitizer& dig); // not implemented
-  AliRunDigitizer& operator=(const AliRunDigitizer& dig); // not implemented
-  void Copy(TObject& dig) const;
+  AliRunLoader*     GetOutRunLoader();
+  //
   Bool_t            ConnectInputTrees();
-  Bool_t            InitGlobal();
   Bool_t            InitOutputGlobal();
   void              InitEvent();
   void              FinishEvent();
   void              FinishGlobal();
+  
+private:
+  AliDigitizationInput(const AliDigitizationInput& dig); // not implemented
+  AliDigitizationInput& operator=(const AliDigitizationInput& dig); // not implemented
+  void Copy(TObject& dig) const;
 
   Int_t             fkMASK[MAXSTREAMSTOMERGE];  //! masks for track ids from
                                               //  different source files
@@ -120,6 +116,7 @@ private:
                                           // should be copied, -1 for no copies
   Int_t             fNinputs;             // nr of input streams - can be taken from the TClonesArray dimension
   Int_t             fNinputsGiven;        // nr of input streams given by user
+  Bool_t            fRegionOfInterest;    // digitization in region of interest
   TClonesArray *    fInputStreams;        // input signal streams
 
 //  AliStream*        fOutputStream;
@@ -129,13 +126,10 @@ private:
   AliMergeCombi *   fCombi;               // pointer to the combination object
   TArrayI           fCombination;         //! combination of events from
   TString           fCombinationFileName; // fn with combinations (used
-                                          // with type 2 of comb.)
-
-  AliRunLoader*     GetOutRunLoader();
-  
+                                          // with type 2 of comb.)  
   static const TString fgkDefOutFolderName;//default name for output foler 
   static const TString fgkBaseInFolderName;//default name for input foler
-  ClassDef(AliRunDigitizer,6)
+  ClassDef(AliDigitizationInput,2)
 };
 
 #endif // ALIRUNDIGITIZER_H
index a32be6e..381422f 100644 (file)
@@ -17,7 +17,7 @@
 
 //----------------------------------------------------------------------
 //  Base Class for Detector specific Merging/Digitization   
-//  Collaborates with AliRunDigitizer class                
+//  Collaborates with AliDigitizationInput class                
 //  Author: Jiri Chudoba (CERN)
 //----------------------------------------------------------------------
 
 // AliROOT includes
 #include "AliLog.h"
 #include "AliDigitizer.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 
 ClassImp(AliDigitizer)
 
 //_______________________________________________________________________
 AliDigitizer::AliDigitizer(const Text_t* name, const Text_t* title):
-  TTask(name,title),
-  fManager(0),
-  fRegionOfInterest(kTRUE)
+  TNamed(name,title),
+  fDigInput(0)
 {
   //
   // Default ctor with name and title
@@ -46,9 +45,8 @@ AliDigitizer::AliDigitizer(const Text_t* name, const Text_t* title):
 
 //_______________________________________________________________________
 AliDigitizer::AliDigitizer(const AliDigitizer &dig):
-  TTask(dig.GetName(),dig.GetTitle()),
-  fManager(0),
-  fRegionOfInterest(kTRUE)
+  TNamed(dig.GetName(),dig.GetTitle()),
+  fDigInput(0)
 {
   //
   // Copy ctor with
@@ -63,16 +61,13 @@ void AliDigitizer::Copy(TObject &) const
 }
 
 //_______________________________________________________________________
-AliDigitizer::AliDigitizer(AliRunDigitizer *manager, 
+AliDigitizer::AliDigitizer(AliDigitizationInput *digInput, 
                            const Text_t* name, const Text_t* title):
-  TTask(name,title),
-  fManager(manager),
-  fRegionOfInterest(kFALSE)
+  TNamed(name,title),
+  fDigInput(digInput)
 {
   //
   // ctor with name and title
-  //
-  fManager->AddDigitizer(this);
 }
 
 //_______________________________________________________________________
@@ -87,7 +82,6 @@ Int_t AliDigitizer::GetNInputStreams() const
   // return number of input streams
   //
   Int_t nInputStreams = 0 ;
-  if (fManager)
-    nInputStreams = fManager->GetNinputs() ;
+  if (fDigInput) nInputStreams = fDigInput->GetNinputs() ;
   return nInputStreams ; 
 }
index 0eaadb3..4c9c9d7 100644 (file)
 //
 ////////////////////////////////////////////////////////////////////////
 
-#include "TTask.h"
+#include "TNamed.h"
+#include "AliDigitizationInput.h"
 
-class AliRunDigitizer;
-
-class AliDigitizer: public TTask {
+class AliDigitizer: public TNamed {
 
  public:
 // ctor with name and title
     AliDigitizer(const Text_t* name="AliDigitizer",
                 const Text_t* title="AliDigitizer");
 // ctor to be used with name and title
-    AliDigitizer(AliRunDigitizer *manager,
+    AliDigitizer(AliDigitizationInput *manager,
                  const Text_t* name="AliDigitizer",
                  const Text_t* title="AliDigitizer");
 // Copy ctor needed because there is a pointer
@@ -34,17 +33,16 @@ class AliDigitizer: public TTask {
       
     virtual ~AliDigitizer();
     virtual Bool_t Init() {return kTRUE;}
-    void SetRegionOfInterest(Bool_t flag) {fRegionOfInterest = flag;};
-//    virtual void Digitize() = 0;
+    virtual void Digitize(Option_t* option) = 0;
+    Bool_t GetRegionOfInterest() const {return fDigInput ? fDigInput->GetRegionOfInterest() : kFALSE;}
 
 protected:
     Int_t GetNInputStreams() const;
     void Copy(TObject &dig) const;
 
-    AliRunDigitizer *fManager;   //! Pointer to the Digitizer manager
-    Bool_t fRegionOfInterest;    // Flag for digitization only in region of interest
+    AliDigitizationInput *fDigInput;   //! Pointer to the Digitizer input
     
-    ClassDef(AliDigitizer,2) // Base class for detector digitizers
+    ClassDef(AliDigitizer,3) // Base class for detector digitizers
 };
 
 #endif // ALIDIGITIZER_H
index 0ced45a..a549fcc 100644 (file)
 #include <TFile.h>
 #include <TFolder.h>
 #include <TString.h>
-#include <TTask.h>
 
 //AliRoot includes
 #include "AliConfig.h"
 #include "AliDetector.h"
-#include "AliDigitizer.h"
 #include "AliLog.h"
 #include "AliRun.h"
 #include "AliRunLoader.h"
@@ -53,13 +51,11 @@ AliLoader::AliLoader():
  fEventFolder(0x0),
  fDataFolder(0x0),
  fDetectorDataFolder(0x0),
- fModuleFolder(0x0),
- fTasksFolder(0x0),
- fQAFolder(0x0)
+ fModuleFolder(0x0)
 {
-//default constructor
-
- }
+  //default constructor
+  
+}
 /******************************************************************/
 
 AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
@@ -68,9 +64,7 @@ AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
  fEventFolder(0x0),
  fDataFolder(0x0),
  fDetectorDataFolder(0x0),
- fModuleFolder(0x0),
- fTasksFolder(0x0),
- fQAFolder(0x0)
+ fModuleFolder(0x0)
 {
   //ctor
    AliDebug(1, Form("detname = %s eventfoldername = %s",detname,eventfoldername));
@@ -95,9 +89,7 @@ AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
  fEventFolder(0x0),
  fDataFolder(0x0),
  fDetectorDataFolder(0x0),
- fModuleFolder(0x0),
- fTasksFolder(0x0),
- fQAFolder(0x0)
+ fModuleFolder(0x0)
 {
 //constructor
    fDetectorName = detname;
@@ -126,37 +118,22 @@ void AliLoader::InitDefaults()
   
   // S U M M A B L E   D I G I T S
   dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
-  AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetSDigitizerTaskName(),
-                                        dl,AliRunLoader::GetRunSDigitizer(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kSDigits);
 
   // D I G I T S  
   dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
-  tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),
-                                        dl,AliRunLoader::GetRunDigitizer(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kDigits);
   
   // R E C O N S T R U C T E D   P O I N T S aka C L U S T E R S 
   dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
-  tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),
-                                        dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kRecPoints);
   
   // T R A C K S
   dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
-  tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetTrackerTaskName(),
-                                        dl,AliRunLoader::GetRunTracker(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kTracks);
   
   // R E C O N S T R U C T E D   P O I N T S aka C L U S T E R S 
   dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
-  tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetPIDTaskName(),
-                                        dl,AliRunLoader::GetRunPIDTask(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kRecParticles);
 
  }
@@ -275,24 +252,6 @@ TFolder* AliLoader::GetDataFolder()
 
 /*****************************************************************************/ 
 
-TFolder* AliLoader::GetTasksFolder()
-{
-//Returns pointer to Folder with Alice Tasks
- if (!fTasksFolder)
-  {
-   fTasksFolder =  dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::GetTasksFolderName()));
-   
-   if (!fTasksFolder)
-    {
-     AliFatal("Can not find tasks folder. Aborting");
-     return 0x0;
-    }
-  }
-  return fTasksFolder;
-   
-}
-/*****************************************************************************/ 
-
 TFolder* AliLoader::GetModulesFolder()
 {
   //returns pointer to the folder containing modules
@@ -309,98 +268,7 @@ TFolder* AliLoader::GetModulesFolder()
  return fModuleFolder;
    
 }
-/*****************************************************************************/ 
-
-TFolder* AliLoader::GetQAFolder()
-{ 
-  //returns folder with Quality assurance 
-  if (fQAFolder == 0x0)
-   {
-     TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
-     fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
 
-     if (fQAFolder == 0x0)
-      {
-       AliFatal("Can not find Quality Assurance folder. Aborting");
-       return 0x0;
-      }
-   }
-  return fQAFolder;
-  
-}
-/*****************************************************************************/ 
-TTask* AliLoader::SDigitizer() const
-{
-//returns SDigitizer task for this detector
-  return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
-
-}
-/*****************************************************************************/ 
-
-AliDigitizer* AliLoader::Digitizer() const
-{
-//returns Digitizer task for this detector
-  return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
-}
-/*****************************************************************************/ 
-
-TTask* AliLoader::Reconstructioner() const
-{
-//returns Recontructioner (Cluster Finder, Cluster Maker, 
-//or whatever you want to call it) task for this detector
-  return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
-}
-/*****************************************************************************/ 
-
-TTask* AliLoader::Tracker() const
-{
-//returns tracker
-  return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
-}
-
-/*****************************************************************************/ 
-TTask* AliLoader::PIDTask() const
-{
-//returns tracker
-  return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
-}
-
-/*****************************************************************************/ 
-
-TTask* AliLoader::QAtask(const char* name) const
-{
-  // Returns pointer to the quality assurance task
-  TTask* qat = AliRunLoader::GetRunQATask();
-  if ( qat == 0x0 ) 
-   {
-    AliError(Form("Can not get RunQATask. (Name:%s)",GetName()));
-    return 0x0;
-   }
-  
-  TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
-  TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
-  
-  if ( dqat == 0x0 ) 
-   {
-    AliError(Form("Can not find QATask in RunQATask for %s",GetDetectorName().Data()));
-    return 0x0;
-   }
-  
-  if (strlen(name) == 0) return dqat;
-  
-  TList* list = dqat->GetListOfTasks();
-  
-  TIter it(list) ;
-  TTask * task = 0 ; 
-  while((task = static_cast<TTask *>(it.Next()) ))
-   {
-    TString taskname(task->GetName()) ;
-    if(taskname.BeginsWith(name))
-      return task ;
-   }
-  AliError(Form("Can not find sub-task with name starting with %s in task %s",name,dqat->GetName()));
-  return 0x0;   
-}
 /*****************************************************************************/ 
 
 TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
@@ -519,41 +387,6 @@ Int_t AliLoader::WriteSDigits(Option_t* opt) const
  
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
-{
-  // Posts sdigitizer
-  return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
-}
-/*****************************************************************************/ 
-
-Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
- {
-   // Posts digitizer
-  return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
- }
-/*****************************************************************************/ 
-
-Int_t AliLoader::PostReconstructioner(TTask* task) const
- {
-   // Posts Reconstructioner
-  return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
- }
-/*****************************************************************************/ 
-
-Int_t AliLoader::PostTracker(TTask* task) const
- {
-   // Posts a tracker
-  return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
- }
-/*****************************************************************************/ 
-
-Int_t AliLoader::PostPIDTask(TTask* task) const
- {
-  // Posts particle identification task
-  return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
- }
-/*****************************************************************************/ 
-
 TObject** AliLoader::GetDetectorDataRef(TObject *obj)
 {
   // Returns pointer to an entry in the list of folders pointing to "obj"
@@ -563,66 +396,6 @@ TObject** AliLoader::GetDetectorDataRef(TObject *obj)
   }
  return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
 }
-/*****************************************************************************/ 
-
-TObject** AliLoader::SDigitizerRef()
-{
-  // Returns pointer to a Runloader's task-list entry pointing to SDigitizer
-  TTask* rsd = AliRunLoader::GetRunSDigitizer();
-  if (rsd == 0x0)
-   {
-     return 0x0;
-   }
-  return rsd->GetListOfTasks()->GetObjectRef(SDigitizer());
-}
-/*****************************************************************************/ 
-
-TObject** AliLoader::DigitizerRef()
-{
-  // Returns pointer to a Runloader's task-list entry pointing to Digitizer
- TTask* rd = AliRunLoader::GetRunDigitizer();
- if (rd == 0x0)
-  {
-    return 0x0;
-  }
- return rd->GetListOfTasks()->GetObjectRef(Digitizer()) ;
-}
-/*****************************************************************************/ 
-
-TObject** AliLoader::ReconstructionerRef()
-{
-  // Returns pointer to a Runloader's task-list entry pointing to Reconstructioner
-  TTask* rrec = AliRunLoader::GetRunReconstructioner();
-  if (rrec == 0x0)
-   {
-     return 0x0;
-   }
-  return rrec->GetListOfTasks()->GetObjectRef(Reconstructioner());
-}
-/*****************************************************************************/ 
-
-TObject** AliLoader::TrackerRef()
-{
-  // Returns pointer to a Runloader's task-list entry pointing to Tracker
-   TTask* rrec = AliRunLoader::GetRunTracker();
-   if (rrec == 0x0)
-    {
-      return 0x0;
-    }
-   return rrec->GetListOfTasks()->GetObjectRef(Tracker());
-}
-/*****************************************************************************/ 
-
-TObject** AliLoader::PIDTaskRef()
-{
-  // Returns pointer to a Runloader's task-list entry pointing to PIDTask
-  TTask* rrec = AliRunLoader::GetRunPIDTask();
-  if (rrec == 0x0)
-   {
-     return 0x0;
-   }
-  return rrec->GetListOfTasks()->GetObjectRef(PIDTask());
-}
 
 /*****************************************************************************/ 
 void AliLoader::CleanFolders()
@@ -636,69 +409,7 @@ void AliLoader::CleanFolders()
       dl->Clean();
     }
  }
-/*****************************************************************************/ 
-
-/*****************************************************************************/ 
-
-void AliLoader::CleanSDigitizer()
-{
-//removes and deletes detector task from Run Task
- if ( GetSDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
-  {
-    AliWarning("Task Loader for SDigits does not exist");
-    return;
-  }
- GetSDigitsDataLoader()->GetBaseTaskLoader()->Clean();
-}
-/*****************************************************************************/ 
-
-void AliLoader::CleanDigitizer()
-{
-//removes and deletes detector task from Run Task
- if ( GetDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
-  {
-    AliWarning("Task Loader for Digits does not exist");
-    return;
-  }
- GetDigitsDataLoader()->GetBaseTaskLoader()->Clean();
-}
-/*****************************************************************************/ 
-
-void AliLoader::CleanReconstructioner()
-{
-//removes and deletes detector Reconstructioner from Run Reconstructioner
- if ( GetRecPointsDataLoader()->GetBaseTaskLoader() == 0x0 )
-  {
-    AliWarning("Task Loader for SDigits does not exist");
-    return;
-  }
- GetRecPointsDataLoader()->GetBaseTaskLoader()->Clean();
-}
-/*****************************************************************************/ 
-
-void AliLoader::CleanTracker()
-{
-//removes and deletes detector task from Run Task
- if ( GetTracksDataLoader()->GetBaseTaskLoader() == 0x0 )
-  {
-    AliWarning("Task Loader for Tracks does not exist");
-    return;
-  }
- GetTracksDataLoader()->GetBaseTaskLoader()->Clean();
-}
-/*****************************************************************************/ 
 
-void AliLoader::CleanPIDTask()
-{
-//removes and deletes detector Reconstructioner from Run Reconstructioner
-
- if (  GetRecParticlesDataLoader()->GetBaseTaskLoader() == 0x0 )
-  {
-    AliWarning("Task Loader for Reconstructed Particles does not exist");
-    return;
-  }
-  GetRecParticlesDataLoader()->GetBaseTaskLoader()->Clean();
-}
 /*****************************************************************************/ 
 
 Int_t AliLoader::ReloadAll()
@@ -773,7 +484,7 @@ Int_t AliLoader::Register(TFolder* eventFolder)
  Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
  if(retval)
   {
-    AliError(Form("Can not create tasks and/or folders for %s. Event folder name is %s",
+    AliError(Form("Can not create folders for %s. Event folder name is %s",
                  fDetectorName.Data(),eventFolder->GetName()));
     return retval;
   }
@@ -884,7 +595,6 @@ void AliLoader::SetDebug(Int_t deb)
   AliLog::SetClassDebugLevel("AliBaseLoader", deb);
   AliLog::SetClassDebugLevel("AliObjectLoader", deb);
   AliLog::SetClassDebugLevel("AliTreeLoader", deb);
-  AliLog::SetClassDebugLevel("AliTaskLoader", deb);
   AliLog::SetClassDebugLevel("AliConfig", deb);
 }
 /*****************************************************************************/ 
index d967bee..bdc8d3e 100644 (file)
@@ -4,17 +4,15 @@
 class TDirectory;
 class TFile;
 class TString;
-class TTask;
 class TTree;
 
 #include <TFolder.h>
 #include <TObjArray.h>
 
-class AliDigitizer;
 class AliRunLoader;
 
 #include "AliDataLoader.h"
-#include "AliTaskLoader.h"
+#include "AliBaseLoader.h"
 
 
 //___________________________________________________________________
@@ -71,21 +69,6 @@ class AliLoader: public TNamed
     TFolder*       GetDetectorDataFolder();//returns the folder that hits, sdigits, etc 
                                      //are sitting for a given detector (subfolder of Data Folder)
     TFolder*       GetModulesFolder();
-    TFolder*       GetTasksFolder();
-    TFolder*       GetQAFolder();
-   
-    TTask*         SDigitizer() const;//return detector SDigitizer()
-    AliDigitizer*  Digitizer() const;
-    TTask*         Reconstructioner() const;
-    TTask*         Tracker() const;
-    TTask*         PIDTask() const;
-    TTask*         QAtask(const char* name = 0x0) const;
-
-    TObject**      SDigitizerRef();
-    TObject**      DigitizerRef();
-    TObject**      ReconstructionerRef();
-    TObject**      TrackerRef();
-    TObject**      PIDTaskRef();
     
     virtual void   MakeHitsContainer() const {GetHitsDataLoader()->MakeTree();}
     virtual void   MakeSDigitsContainer() const {GetSDigitsDataLoader()->MakeTree();}
@@ -97,23 +80,6 @@ class AliLoader: public TNamed
     virtual void   CleanFolders();
     virtual void   CloseFiles();
 
-    virtual Int_t  PostSDigitizer(TTask* sdzer) const;//adds it to Run SDigitizer
-    virtual Int_t  PostDigitizer(AliDigitizer* task) const;
-    virtual Int_t  PostReconstructioner(TTask* task) const;
-    virtual Int_t  PostTracker(TTask* task) const;
-    virtual Int_t  PostPIDTask(TTask* task) const;
-    
-    virtual Int_t  WriteSDigitizer(Option_t* opt="") const
-      {return GetSDigitsDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
-    virtual Int_t  WriteDigitizer(Option_t* opt="") const
-      {return GetDigitsDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
-    virtual Int_t  WriteReconstructioner(Option_t* opt="") const
-      {return GetRecPointsDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
-    virtual Int_t  WriteTracker(Option_t* opt="") const
-      {return GetTracksDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
-    virtual Int_t  WritePIDTask(Option_t* opt="") const
-      {return GetRecParticlesDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
-
     TTree*         TreeH() const
       {return GetHitsDataLoader()->Tree();}      //returns the tree from folder; shortcut method
     TTree*         TreeS() const
@@ -159,22 +125,6 @@ class AliLoader: public TNamed
       SetTAddrInDet();
       return status;
     }
-    
-    Int_t          LoadSDigitizer(Option_t* opt="") const {
-      return GetSDigitsDataLoader()->GetBaseTaskLoader()->Load(opt);
-    }
-    Int_t          LoadDigitizer(Option_t* opt="") const {
-      return GetDigitsDataLoader()->GetBaseTaskLoader()->Load(opt);
-    }
-    Int_t          LoadReconstructioner(Option_t* opt="") const {
-      return GetRecPointsDataLoader()->GetBaseTaskLoader()->Load(opt);
-    }
-    Int_t          LoadTracker(Option_t* opt="") const {
-      return GetTracksDataLoader()->GetBaseTaskLoader()->Load(opt);
-    }
-    Int_t          LoadPIDTask(Option_t* opt="") const {
-      return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Load(opt);
-    }
 
     void           UnloadHits() const {GetHitsDataLoader()->Unload();}
     void           UnloadSDigits() const {GetSDigitsDataLoader()->Unload();}
@@ -239,12 +189,6 @@ class AliLoader: public TNamed
       {GetRecPointsDataLoader()->Clean();}  //cleans rec. points from folder
     virtual void  CleanTracks() const
       {GetTracksDataLoader()->Clean();}     //cleans tracks from folder
-    
-    virtual void  CleanSDigitizer();                    //cleans SDigitizer from folder
-    virtual void  CleanDigitizer();                     //cleans Digitizer from folder
-    virtual void  CleanReconstructioner();              //cleans Reconstructions (clusterizer) from folder
-    virtual void  CleanTracker();                       //cleans tracker from folder
-    virtual void  CleanPIDTask();              //cleans Reconstructions (clusterizer) from folder
 
     virtual void  SetHitsFileOption(Option_t* newopt) const
       {GetHitsDataLoader()->SetFileOption(newopt);}          //Sets Hits File Option in open
@@ -351,9 +295,6 @@ class AliLoader: public TNamed
     TFolder*      fDetectorDataFolder;//!Folder that contains the detector data
     TFolder*      fModuleFolder;      //!Folder that contains the modules 
 
-    TFolder*      fTasksFolder;       //!Folder that contains the Tasks (sdigitizer, digitizer, reconstructioner)
-    TFolder*      fQAFolder;          //!Folder that contains the QA objects
-    
  // file option varible was introduced because if TFile is created with "recreate" 
  // stored option in TFile is "CREATE". We need to remeber "recreate" for
  // Max events per file functionality
@@ -372,7 +313,7 @@ class AliLoader: public TNamed
     AliLoader(const AliLoader&); //Not implemented
     AliLoader& operator=(const AliLoader&); //Not implemented
 
-    ClassDef(AliLoader,2)
+    ClassDef(AliLoader,3)
  };
 /******************************************************************/
 /************************ I N L I N E S ***************************/
index 5974f7a..b7dc2dc 100644 (file)
@@ -52,6 +52,7 @@
 #include "AliMC.h"
 #include "AliSimulation.h"
 #include "AliRawDataHeader.h"
+#include "AliDigitizationInput.h"
 
 #include "AliDAQ.h"
 
@@ -69,7 +70,8 @@ AliModule::AliModule():
   fEnable(1),
   fMaxIterTrackRef(0),
   fCurrentIterTrackRef(0),
-  fRunLoader(0)
+  fRunLoader(0),
+  fDigInput(0)
 {
   //
   // Default constructor for the AliModule class
@@ -87,7 +89,8 @@ AliModule::AliModule(const char* name,const char *title):
   fEnable(1),
   fMaxIterTrackRef(0),
   fCurrentIterTrackRef(0),
-  fRunLoader(0)
+  fRunLoader(0),
+  fDigInput(0)
 {
   //
   // Normal constructor invoked by all Modules.
index 5fced4f..adccc8c 100644 (file)
@@ -26,7 +26,7 @@ class TTree;
 class AliLoader;
 class AliTrackReference;
 class AliDigitizer;
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliVertexer;
 class AliTracker;
 class AliESD;
@@ -88,7 +88,7 @@ public:
   virtual void        AddHit(Int_t, Int_t*, Float_t *) {
   Error("AddDigit","Hits cannot be added to module %s\n",fName.Data());}
   virtual void        Hits2SDigits() {}
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* /*manager*/) const 
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* /*manager*/) const 
     {return NULL;}
   virtual AliTriggerDetector* CreateTriggerDetector() const
     { AliTriggerDetector* det = new AliTriggerDetector(); det->SetName(GetName()); return det;}
@@ -142,7 +142,8 @@ public:
   
 // Quality Assurance methods
   virtual void CheckQA()    { ; }
-  
+  AliDigitizationInput* GetDigitizationInput() const {return fDigInput;}
+  //  
   static void SetDensityFactor(Float_t density) { fgDensityFactor = density; }
   static Float_t GetDensityFactor() { return fgDensityFactor; }
   
@@ -161,13 +162,12 @@ protected:
   Int_t         fCurrentIterTrackRef; //!for track refernce iterator routines
 
   AliRunLoader* fRunLoader;   //!local pointer to run loader
-
+  AliDigitizationInput* fDigInput; //! input for sdigits -> digits
   static Float_t fgDensityFactor; //! factor that is multiplied to all material densities (ONLY for systematic studies)
-
  private:
   AliModule(const AliModule&);
   AliModule& operator=(const AliModule&);
 
-  ClassDef(AliModule, 9)  //Base class for ALICE Modules
+  ClassDef(AliModule, 10)  //Base class for ALICE Modules
 };
 #endif
index d04b9eb..7882179 100644 (file)
@@ -63,7 +63,6 @@
 #include <TFolder.h>
 #include <TObjArray.h>
 #include <TString.h>
-#include <TTask.h>
 
 ClassImp(AliRunLoader)
 
@@ -1870,68 +1869,6 @@ void AliRunLoader::Clean(const TString& name)
 
 /*****************************************************************************/ 
 
-TTask* AliRunLoader::GetRunDigitizer()
-{
-//returns Run Digitizer from folder
-
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetDigitizerTaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-/*****************************************************************************/ 
-
-TTask* AliRunLoader::GetRunSDigitizer()
-{
-//returns SDigitizer Task from folder
-
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetSDigitizerTaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-/*****************************************************************************/ 
-
-TTask* AliRunLoader::GetRunReconstructioner()
-{
-//returns Reconstructioner Task from folder
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetReconstructionerTaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-/*****************************************************************************/ 
-
-TTask* AliRunLoader::GetRunTracker()
-{
-//returns Tracker Task from folder
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetTrackerTaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-/*****************************************************************************/ 
-
-TTask* AliRunLoader::GetRunPIDTask()
-{
-//returns Tracker Task from folder
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetPIDTaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-/*****************************************************************************/ 
-
-TTask* AliRunLoader::GetRunQATask()
-{
-//returns Quality Assurance Task from folder
- TFolder* topf = AliConfig::Instance()->GetTaskFolder();
- if (topf == 0x0)
-  {
-    AliErrorClass("Can not get task folder from AliConfig");
-    return 0x0;
-  }
- TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetQATaskName());
- return (obj)?dynamic_cast<TTask*>(obj):0x0;
-}
-
-/*****************************************************************************/ 
-
 void AliRunLoader::SetCompressionLevel(Int_t cl)
 {
 //Sets Compression Level in all files
index 8db2fc8..07303fc 100644 (file)
@@ -27,7 +27,6 @@ class TString;
 class TFolder;
 class TObjArray;
 class TTree;
-class TTask;
 class TParticle;
 
 class AliRun;
@@ -183,14 +182,6 @@ class AliRunLoader: public TNamed
     static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
     static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
 
-//  Tasks are supposed to be singletons, that is why following methods are static
-    static TTask*           GetRunDigitizer();        //
-    static TTask*           GetRunSDigitizer();       //
-    static TTask*           GetRunReconstructioner(); //
-    static TTask*           GetRunTracker();          //
-    static TTask*           GetRunPIDTask();          // 
-    static TTask*           GetRunQATask();           //
-
     static TString GetRunLoaderName () {return fgkRunLoaderName;}
     static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
     static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
index bb493bd..9460d9a 100644 (file)
 #include "AliRawReaderFile.h"
 #include "AliRawReaderRoot.h"
 #include "AliRun.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRunLoader.h"
 #include "AliSimulation.h"
 #include "AliSysInfo.h"
@@ -1266,50 +1266,56 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
   Int_t nStreams = 1;
   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
-  AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
-  // manager->SetEmbeddingFlag(fEmbeddingFlag);
-  manager->SetInputStream(0, fGAliceFileName.Data());
+  AliDigitizationInput digInp(nStreams, signalPerBkgrd);
+  // digInp.SetEmbeddingFlag(fEmbeddingFlag);
+  digInp.SetRegionOfInterest(fRegionOfInterest);
+  digInp.SetInputStream(0, fGAliceFileName.Data());
   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
-    const char* fileName = ((TObjString*)
-                           (fBkgrdFileNames->At(iStream-1)))->GetName();
-    manager->SetInputStream(iStream, fileName);
+    const char* fileName = ((TObjString*)(fBkgrdFileNames->At(iStream-1)))->GetName();
+    digInp.SetInputStream(iStream, fileName);
   }
-
+  TObjArray detArr;
+  detArr.SetOwner(kTRUE);
   TString detStr = detectors;
   TString detExcl = excludeDetectors;
-  manager->GetInputStream(0)->ImportgAlice();
-  AliRunLoader* runLoader = 
-    AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
+  if (!static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice()) {
+    AliError("Error occured while getting gAlice from Input 0");
+    return kFALSE;
+  }
+  AliRunLoader* runLoader = AliRunLoader::GetRunLoader(digInp.GetInputStream(0)->GetFolderName());
   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
     AliModule* det = (AliModule*) detArray->At(iDet);
     if (!det || !det->IsActive()) continue;
-    if (IsSelected(det->GetName(), detStr) && 
-       !IsSelected(det->GetName(), detExcl)) {
-      AliDigitizer* digitizer = det->CreateDigitizer(manager);
-      
-      if (!digitizer) {
-       AliError(Form("no digitizer for %s", det->GetName()));
-       if (fStopOnError) return kFALSE;
-      } else {
-       digitizer->SetRegionOfInterest(fRegionOfInterest);
-      }
+    if (!IsSelected(det->GetName(), detStr) || IsSelected(det->GetName(), detExcl)) continue;
+    AliDigitizer* digitizer = det->CreateDigitizer(&digInp);
+    if (!digitizer || !digitizer->Init()) {
+      AliError(Form("no digitizer for %s", det->GetName()));
+      if (fStopOnError) return kFALSE;
+      else continue;
     }
+    detArr.AddLast(digitizer);    
+    AliInfo(Form("Created digitizer from SDigits -> Digits for %s", det->GetName()));    
   }
-
+  //
   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-    AliError(Form("the following detectors were not found: %s", 
-                  detStr.Data()));
+    AliError(Form("the following detectors were not found: %s", detStr.Data()));
     if (fStopOnError) return kFALSE;
   }
-
-  if (!manager->GetListOfTasks()->IsEmpty()) {
-    AliInfo("executing digitization");
-    manager->Exec("");
-  }
-
-  delete manager;
-
+  //
+  Int_t ndigs = detArr.GetEntriesFast();
+  Int_t eventsCreated = 0;
+  AliRunLoader* outRl =  digInp.GetOutRunLoader();
+  while ((eventsCreated++ < fNEvents) || (fNEvents < 0)) {
+    if (!digInp.ConnectInputTrees()) break;
+    digInp.InitEvent(); //this must be after call of Connect Input tress.
+    if (outRl) outRl->SetEventNumber(eventsCreated-1);
+    static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice(); // use gAlice of the first input stream
+    for (int id=0;id<ndigs;id++) ((AliDigitizer*)detArr[id])->Digitize("");
+    digInp.FinishEvent();
+  };
+  digInp.FinishGlobal();
+  //
   return kTRUE;
 }
 
diff --git a/STEER/STEER/AliTaskLoader.cxx b/STEER/STEER/AliTaskLoader.cxx
deleted file mode 100644 (file)
index c7b1a92..0000000
+++ /dev/null
@@ -1,110 +0,0 @@
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                         //
-//  class AliTaskLoader                                                                    //
-//                                                                                         //
-//  Container of all data needed for full                                                  //
-//  description of each data type                                                          //
-//  (Hits, Kine, ...)                                                                      //
-//                                                                                         //
-//  Each data loader has a basic standard setup of BaseLoaders                             //
-//  which can be identuified by indexes (defined by EStdBasicLoaders)                      //
-//  Data managed by these standard base loaders has fixed naming convention                //
-//  e.g. - tree with hits is always named TreeH                                            //
-//                     (defined in AliLoader::fgkDefaultHitsContainerName)                 //
-//       - task DtectorName+Name defined                                                   //
-//                                                                                         //
-//  EStdBasicLoaders   idx     Object Type        Description                              //
-//      kData           0    TTree or TObject     main data itself (hits,digits,...)       //
-//      kTask           1        TTask            object producing main data               //
-//      kQA             2        TTree                quality assurance tree               //
-//      kQATask         3        TTask            task producing QA object                 //
-//                                                                                         //
-//                                                                                         //
-//  User can define and add more basic loaders even Run Time.                              //
-//  Caution: in order to save information about added base loader                          //
-//  user must rewrite Run Loader to galice.file, overwriting old setup                     //
-//                                                                                         //
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-/* $Id$ */
-
-#include "AliTaskLoader.h"
-#include "AliDataLoader.h"
-#include "AliLog.h"
-
-ClassImp(AliTaskLoader)
-
-//______________________________________________________________________________
-AliTaskLoader::AliTaskLoader(const TString& name, AliDataLoader* dl, 
-                            TTask* parentaltask, Bool_t storeontop):
- AliBaseLoader(name,dl,storeontop),
- fParentalTask(parentaltask)
-{
-  //
-  // Constructor
-  //
-}
-
-//______________________________________________________________________________
-void AliTaskLoader::Clean()
-{
-  //
-  // Removes tasl from parental task
-  // DO NOT DELETE OBJECT contrary to BaseLoader
-  //
-  AliDebug(1, Form("Clean %s %s",GetName(),GetDataLoader()->GetName()));
-  TObject* obj = Get();
-  if(obj)
-    { 
-      AliDebug(1, Form("cleaning %s.",GetName()));
-      RemoveFromBoard(obj);
-    }
-}
-
-
-//______________________________________________________________________________
-void AliTaskLoader::RemoveFromBoard(TObject* obj)
-{
-  //
-  // Removes the task "obj" from the board
-  //
-  GetParentalTask()->GetListOfTasks()->Remove(obj);
-}
-
-//______________________________________________________________________________
-Int_t AliTaskLoader::AddToBoard(TObject* obj)
-{
-  //
-  // Adds task "obj" to the board
-  //
-  TTask* task = dynamic_cast<TTask*>(obj);
-  if (task == 0x0)
-    {
-      AliError("To TTask board can be added only tasks.");
-      return 1;
-    }
-  GetParentalTask()->Add(task);
-  return 0;
-}
-
-//______________________________________________________________________________
-TObject* AliTaskLoader::Get() const
-{
-  //
-  // Returns pointer to the current task
-  //
-  return (GetParentalTask()) ? GetParentalTask()->GetListOfTasks()->FindObject(GetName()) : 0x0;
-}
-
-//______________________________________________________________________________
-TTask* AliTaskLoader::GetParentalTask() const
-{
-  //
-  // Returns parental tasks for this task
-  //
-  return fParentalTask;
-}
-
-
-
diff --git a/STEER/STEER/AliTaskLoader.h b/STEER/STEER/AliTaskLoader.h
deleted file mode 100644 (file)
index bd86c4e..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef ALITASKLOADER_H
-#define ALITASKLOADER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-////////////////////////////////////////////
-//                                        //
-//  class AliTaskLoader                   //
-//                                        //
-//                                        //
-////////////////////////////////////////////
-
-/* $Id$ */
-
-class TObject;
-class AliDataLoader;
-
-#include "AliBaseLoader.h"
-#include <TTask.h>
-class AliTaskLoader: public AliBaseLoader
- {
-  public:
-    AliTaskLoader():fParentalTask(0x0){};
-    AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop = kFALSE);
-    virtual ~AliTaskLoader(){};
-    
-    TObject*           Get() const; 
-    virtual TTask*     Task() const {return dynamic_cast<TTask*>(Get());}
-    virtual void       Clean();
-
-  protected:
-    Int_t              AddToBoard(TObject* obj);
-    void               RemoveFromBoard(TObject* obj);
-    TTask*             GetParentalTask() const;
-
-  private:
-    AliTaskLoader(const AliTaskLoader&);            //Not implemented
-    AliTaskLoader& operator=(const AliTaskLoader&); //Not implemented
-
-    TTask*             fParentalTask; // Parental task
-
-  ClassDef(AliTaskLoader,1)    
- };
-
-#endif
-
-
index 85ad5cc..3912368 100644 (file)
@@ -35,7 +35,7 @@
 #pragma link C++ class  AliDebugVolume+;
 #pragma link C++ class  AliConfig+;
 #pragma link C++ class  AliDigitizer+;
-#pragma link C++ class  AliRunDigitizer+;
+#pragma link C++ class  AliDigitizationInput+;
 #pragma link C++ class  AliStream+;
 #pragma link C++ class  AliMergeCombi+;
 #pragma link C++ class  AliGausCorr+;
@@ -44,7 +44,6 @@
 #pragma link C++ class  AliBaseLoader+;
 #pragma link C++ class  AliObjectLoader+;
 #pragma link C++ class  AliTreeLoader+;
-#pragma link C++ class  AliTaskLoader+;
 #pragma link C++ class  AliRunLoader+;
 #pragma link C++ class  AliReconstructor+;
 #pragma link C++ class  AliMemoryWatcher+;
index d2c2c78..4675295 100644 (file)
@@ -292,9 +292,9 @@ void AliT0::MakeBranchInTreeD(TTree *treeD, const char *file)
 }
 
 //_____________________________________________________________________________
-AliDigitizer* AliT0::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliT0::CreateDigitizer(AliDigitizationInput* digInput) const
 {
-  return new AliT0Digitizer(manager);
+  return new AliT0Digitizer(digInput);
 }
 //____________________________________________________________________________
 void AliT0::Digits2Raw()
index d079a8c..778ac30 100644 (file)
@@ -46,7 +46,7 @@ public:
     virtual void   SetTreeAddress();
    virtual void   MakeBranchInTreeD(TTree *treeD, const char *file=0);
    // virtual AliLoader* MakeLoader(const char* topfoldername);
-   virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+   virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
    void  Digits2Raw ();
    void  Raw2Digits (AliRawReader *reader,TTree* digitsTree);
    virtual AliTriggerDetector* CreateTriggerDetector() const 
index 4fad34e..e113c62 100644 (file)
@@ -41,7 +41,7 @@
 #include "AliT0.h"
 #include "AliT0hit.h"
 #include "AliT0digit.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRun.h"
 #include <AliLoader.h>
 #include <AliRunLoader.h>
@@ -69,8 +69,8 @@ ClassImp(AliT0Digitizer)
 }
 
 //___________________________________________
-AliT0Digitizer::AliT0Digitizer(AliRunDigitizer* manager) 
-  :AliDigitizer(manager),
+AliT0Digitizer::AliT0Digitizer(AliDigitizationInput* digInput) 
+  :AliDigitizer(digInput),
    fT0(0),
    fHits(0),
    fdigits(0),
@@ -153,7 +153,7 @@ Bool_t AliT0Digitizer::Init()
 }
  
 //---------------------------------------------------------------------
-void AliT0Digitizer::Exec(Option_t* /*option*/)
+void AliT0Digitizer::Digitize(Option_t* /*option*/)
 {
 
   /*
@@ -167,7 +167,7 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
   */
 
   //output loader 
-  AliRunLoader *outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  AliRunLoader *outRL = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   AliLoader * pOutStartLoader = outRL->GetLoader("T0Loader");
 
   AliDebug(1,"start...");
@@ -202,7 +202,7 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
   AliT0hit  *startHit;
   TBranch *brHits=0;
   
-  Int_t nFiles=fManager->GetNinputs();
+  Int_t nFiles=fDigInput->GetNinputs();
   for (Int_t inputFile=0; inputFile<nFiles;  inputFile++) {
     if (inputFile < nFiles-1) {
       AliWarning(Form("ignoring input stream %d", inputFile));
@@ -227,7 +227,7 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
       {
        time[i0]=besttime[i0]=timeGaus[i0]=999999; countE[i0]=0;
       }
-    AliRunLoader * inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+    AliRunLoader * inRL = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inputFile));
     AliLoader * pInStartLoader = inRL->GetLoader("T0Loader");
     if (!inRL->GetAliRun()) inRL->LoadgAlice();
     fT0  = (AliT0*)inRL ->GetAliRun()->GetDetector("T0");
index 26b43ab..37c13c9 100644 (file)
@@ -10,7 +10,7 @@
 #include <AliDigitizer.h>
 #include "AliT0Parameters.h"
 
-#include <AliRunDigitizer.h>
+#include <AliDigitizationInput.h>
 class AliT0;
 class AliT0hit;
 class AliT0digit;
@@ -19,7 +19,7 @@ class AliT0Digitizer : public AliDigitizer {
  public:
   
   AliT0Digitizer();
-  AliT0Digitizer(AliRunDigitizer * manager);
+  AliT0Digitizer(AliDigitizationInput * digInput);
   virtual ~AliT0Digitizer();
   virtual Bool_t Init();
   TClonesArray *Hits() const {return fHits;}
@@ -29,7 +29,7 @@ class AliT0Digitizer : public AliDigitizer {
   TArrayI * ADC0() {return fADC0;} 
 
   // Do the main work
-  void Exec (Option_t* /*option=0*/) ;
+  void Digitize(Option_t* /*option=0*/) ;
   //  Bool_t RegisterPhotoE(Int_t impt, Double_t energy);
   enum {kBgTag = -1};
  
index 5852b09..9ea71d4 100644 (file)
@@ -24,8 +24,6 @@ void AliT0Loader::InitObjectLoaders()
     delete fDataLoaders->Remove(fDataLoaders->At(kDigits));
   }
   AliDataLoader* dl = new AliDataLoader(fDetectorName + ".Digits.root","T0_D", "Digits","O");//we want to have object data not tree
-  AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),dl,AliRunLoader::GetRunDigitizer(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kDigits);
 
   // R E C O N S T R U C T E D   P O I N T S, here: V E R T E X
@@ -33,7 +31,5 @@ void AliT0Loader::InitObjectLoaders()
     delete fDataLoaders->Remove(fDataLoaders->At(kRecPoints));
   }
   dl = new AliDataLoader(fDetectorName + ".RecPoints.root","T0_V", "Reconstructed Points","O");//we want to have object data not tree
-  tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
-  dl->SetBaseTaskLoader(tl);
   fDataLoaders->AddAt(dl,kRecPoints);  
 }
index 76168ac..8b8cf67 100644 (file)
@@ -42,7 +42,6 @@
 #include <TFile.h>
 #include <TFolder.h>
 #include <TROOT.h>
-#include <TTask.h>
 #include <TTree.h>
 #include <TVirtualMC.h>
 #include <TStopwatch.h>
@@ -79,8 +78,6 @@ ClassImp(AliTOF)
 //_____________________________________________________________________________
 AliTOF::AliTOF():
   fFGeom(0x0),
-  fDTask(0x0),
-  fReTask(0x0),
   fSDigits(0x0),
   fNSDigits(0),
   fReconParticles(0x0),
@@ -108,8 +105,6 @@ AliTOF::AliTOF(const char *name, const char *title, Option_t *option)
        : 
   AliDetector(name,title),
   fFGeom(0x0),
-  fDTask(0x0),
-  fReTask(0x0),
   fSDigits(0x0),
   fNSDigits(0),
   fReconParticles(0x0),
@@ -197,7 +192,6 @@ void AliTOF::GetTOFSectors(Int_t *sectors) const
 void AliTOF::CreateTOFFolders()
 {
   // create the ALICE TFolder
-  // create the ALICE TTasks
   // create the ALICE main TFolder
   // to be done by AliRun
 
@@ -210,31 +204,6 @@ void AliTOF::CreateTOFFolders()
   aliceF->SetOwner() ;
   // geometry folder
   TFolder * geomF = aliceF->AddFolder("Geometry", "Geometry objects") ;
-  TFolder * aliceT  = alice->AddFolder("tasks", "Alice tasks Folder") ;   
-  //  make it the owner of the objects that it contains
-  aliceT->SetOwner() ;
-
-  TTask * aliceDi = new TTask("(S)Digitizer", "Alice SDigitizer & Digitizer") ;
-  aliceT->Add(aliceDi);
-
-  TTask * aliceRe = new TTask("Reconstructioner", "Alice Reconstructioner") ;
-  aliceT->Add(aliceRe);
-
-  const Int_t kSize=80;
-  //char * tempo = new char[80] ;
-  char tempo[kSize];
-
-  // creates the TOF Digitizer and adds it to alice main (S)Digitizer task
-  snprintf(tempo,kSize, "%sDigitizers container",GetName() ) ;
-  fDTask = new TTask(GetName(), tempo);
-  aliceDi->Add(fDTask) ;
-
-  // creates the TOF reconstructioner and adds it to alice main Reconstructioner task
-  snprintf(tempo,kSize, "%sReconstructioner container",GetName() ) ;
-  fReTask = new TTask(GetName(), tempo);
-  aliceRe->Add(fReTask) ;
-
-  //delete [] tempo ;
  
   // creates the TOF geometry  folder
   geomF->AddFolder("TOF", "Geometry for TOF") ;
@@ -245,7 +214,6 @@ AliTOF::~AliTOF()
 {
   // dtor:
   // it remove also the alice folder 
-  // and task that TOF creates instead of AliRun
   /* PH Temporarily commented because of problems
   TFolder * alice = (TFolder*)gROOT->GetListOfBrowsables()->FindObject("FPAlice") ;
   delete alice;
@@ -552,8 +520,8 @@ void AliTOF::Hits2SDigits()
   //ToAliDebug(1, sd.Print(""));
   //AliInfo("ToAliDebug");
 
-  //sd.Exec("all") ;
-  sd.Exec("partial") ;
+  //sd.Digitize("all") ;
+  sd.Digitize("partial") ;
 
   AliDebug(2,"I am sorting from AliTOF class");
 
@@ -575,15 +543,15 @@ void AliTOF::Hits2SDigits(Int_t evNumber1, Int_t evNumber2)
   AliTOFSDigitizer sd((rl->GetFileName()).Data(),evNumber1,evNumber2) ;
   ToAliDebug(1, sd.Print(""));
 
-  sd.Exec("") ;
+  sd.Digitize("") ;
 
 }
 
 //___________________________________________________________________________
-AliDigitizer* AliTOF::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliTOF::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   AliDebug(2,"I am creating the TOF digitizer");
-  return new AliTOFDigitizer(manager);
+  return new AliTOFDigitizer(digInput);
 }
 
 //___________________________________________________________________________
index 5d08443..7eb64cb 100644 (file)
@@ -26,7 +26,6 @@ class TDirectory;
 class TFile;
 class TFolder ;
 class TString ;  
-class TTask ;
 
 class AliTOFGeometry;
 
@@ -65,7 +64,7 @@ public:
   //virtual void    Hits2Digits();   
   virtual void    Hits2SDigits();
   virtual void    Hits2SDigits(Int_t evNumber1, Int_t evNumber2);
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const; 
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const; 
   virtual void    Digits2Reco () {};
           void    Digits2Raw  ();
          void    Raw2Digits  () {};
@@ -90,8 +89,6 @@ public:
 
 protected:
   TFolder* fFGeom ;       //  Folder that holds the Geometry definition
-  TTask*   fDTask ;       //  TOF Digitizer container
-  TTask*   fReTask;       //  TOF Reconstructioner container
   TClonesArray* fSDigits; //! List of summable digits
   Int_t   fNSDigits;      //! Number of sdigits
   TClonesArray* fReconParticles; // List of reconstructed particles
@@ -115,7 +112,7 @@ private:
   AliTOF(const AliTOF &source); // copy constructor
   AliTOF& operator=(const AliTOF &source); // ass. op.
 
-  ClassDef(AliTOF,11)  // Time Of Flight base class
+  ClassDef(AliTOF,12)  // Time Of Flight base class
 };
  
 #endif /* ALITOF_H */
index 8de8eb7..e0286fb 100644 (file)
@@ -139,7 +139,7 @@ Revision 0.01  2005/07/25 A. De Caro
 ClassImp(AliTOFClusterFinder)
 
 AliTOFClusterFinder::AliTOFClusterFinder(AliTOFcalib *calib):
-  TTask("AliTOFClusterFinder",""),
+  TNamed("AliTOFClusterFinder",""),
   fRunLoader(0),
   fTOFLoader(0),
   fTreeD(0),
@@ -170,7 +170,7 @@ AliTOFClusterFinder::AliTOFClusterFinder(AliTOFcalib *calib):
 //______________________________________________________________________________
 
 AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader, AliTOFcalib *calib):
-  TTask("AliTOFClusterFinder",""),
+  TNamed("AliTOFClusterFinder",""),
   fRunLoader(runLoader),
   fTOFLoader(runLoader->GetLoader("TOFLoader")),
   fTreeD(0),
@@ -200,7 +200,7 @@ AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader, AliTOFcalib *c
 
 //------------------------------------------------------------------------
 AliTOFClusterFinder::AliTOFClusterFinder(const AliTOFClusterFinder &source) :
-  TTask(source),
+  TNamed(source),
   fRunLoader(0),
   fTOFLoader(0),
   fTreeD(0),
@@ -227,7 +227,7 @@ AliTOFClusterFinder& AliTOFClusterFinder::operator=(const AliTOFClusterFinder &s
   if (this == &source)
     return *this;
 
-  TTask::operator=(source);  
+  TNamed::operator=(source);  
   fDigits=source.fDigits;
   fRecPoints=source.fRecPoints;
   fVerbose=source.fVerbose;
index 3be1b71..59f81b9 100644 (file)
@@ -6,7 +6,7 @@
 // Task: Transform digits/raw data to TOF Clusters, to fill TOF RecPoints
 // and feed TOF tracking 
 
-#include "TTask.h"
+#include "TNamed.h"
 
 #include "AliTOFRawStream.h"
 
@@ -22,7 +22,7 @@ class AliTOFGeometry;
 class AliTOFcluster;
 class AliTOFcalib;
 
-class AliTOFClusterFinder : public TTask
+class AliTOFClusterFinder : public TNamed
 {
 
   enum {kTofMaxCluster=77777}; //maximal number of the TOF clusters
@@ -81,7 +81,7 @@ class AliTOFClusterFinder : public TTask
   AliTOFcalib *fTOFcalib;         // pointer to the TOF calibration info
   AliTOFRawStream fTOFRawStream; // AliTOFRawStream variable
 
-  ClassDef(AliTOFClusterFinder,6) // To run TOF clustering
+  ClassDef(AliTOFClusterFinder,7) // To run TOF clustering
 };
 #endif
 
index 78aff2c..2fc971f 100644 (file)
@@ -64,7 +64,7 @@ ClassImp(AliTOFClusterFinderV1)
 
 //_____________________________________________________________________________
 AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliTOFcalib *calib):
-  TTask("AliTOFClusterFinderV1",""),
+  TNamed("AliTOFClusterFinderV1",""),
   fRunLoader(0),
   fDigits(new TClonesArray("AliTOFdigit", 4000)),
   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
@@ -105,7 +105,7 @@ AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliTOFcalib *calib):
 
 //_____________________________________________________________________________
 AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliRunLoader* runLoader, AliTOFcalib *calib):
-  TTask("AliTOFClusterFinderV1",""),
+  TNamed("AliTOFClusterFinderV1",""),
   fRunLoader(runLoader),
   fDigits(new TClonesArray("AliTOFdigit", 4000)),
   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
@@ -146,7 +146,7 @@ AliTOFClusterFinderV1::AliTOFClusterFinderV1(AliRunLoader* runLoader, AliTOFcali
 //_____________________________________________________________________________
 
 AliTOFClusterFinderV1::AliTOFClusterFinderV1(const AliTOFClusterFinderV1 &source)
-  :TTask(source),
+  :TNamed(source),
    fRunLoader(0),
    fDigits(source.fDigits),
    fRecPoints(source.fRecPoints),
index 0112a85..6ddd971 100644 (file)
@@ -7,7 +7,7 @@
 // and feed TOF tracking 
 
 #include "TObject.h"
-#include "TTask.h"
+#include "TNamed.h"
 
 #include "AliTOFGeometry.h"
 #include "AliTOFRawStream.h"
@@ -72,7 +72,7 @@ class  AliTOFselectedDigit : public TObject {
 }; 
 
 
-class AliTOFClusterFinderV1 : public TTask
+class AliTOFClusterFinderV1 : public TNamed
 {
 
   enum {kTofMaxCluster=77777}; //maximal number of the TOF clusters
@@ -162,7 +162,7 @@ class AliTOFClusterFinderV1 : public TTask
 
   Bool_t fCalibrateTOFtimes;     // used for check
 
-  ClassDef(AliTOFClusterFinderV1,4) // To run TOF clustering
+  ClassDef(AliTOFClusterFinderV1,5) // To run TOF clustering
 };
 #endif
 
index 8f39f43..aa9eb3d 100644 (file)
@@ -36,7 +36,7 @@
 
 #include "AliLoader.h"
 #include "AliLog.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRunLoader.h"
 #include "AliRun.h"
 
@@ -71,8 +71,8 @@ ClassImp(AliTOFDigitizer)
 }
 
 //___________________________________________
-AliTOFDigitizer::AliTOFDigitizer(AliRunDigitizer* manager): 
-  AliDigitizer(manager), 
+AliTOFDigitizer::AliTOFDigitizer(AliDigitizationInput* digInput): 
+  AliDigitizer(digInput), 
   fDigits(new TClonesArray("AliTOFdigit",4000)),
   fSDigitsArray(new TClonesArray("AliTOFSDigit",1000)),
   fhitMap(0x0),
@@ -129,7 +129,7 @@ AliTOFDigitizer::~AliTOFDigitizer()
 
 //---------------------------------------------------------------------
 
-void AliTOFDigitizer::Exec(Option_t* /*option*/)
+void AliTOFDigitizer::Digitize(Option_t* /*option*/)
 {
   //
   // Perform digitization and merging.
@@ -153,7 +153,7 @@ void AliTOFDigitizer::Exec(Option_t* /*option*/)
   char branchname[kSize];
   snprintf(branchname,kSize,"%s", tof->GetName ());
  
-  AliRunLoader* outrl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  AliRunLoader* outrl = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   if (outrl == 0x0)
    {
      AliError("Can not find Run Loader in output folder.");
@@ -184,7 +184,7 @@ void AliTOFDigitizer::Exec(Option_t* /*option*/)
   
   // Loop over files to digitize
 
-  for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
+  for (Int_t inputFile=0; inputFile<fDigInput->GetNinputs();
        inputFile++) {
     ReadSDigit(inputFile);
    }
@@ -306,8 +306,8 @@ void AliTOFDigitizer::ReadSDigit(Int_t inputFile )
   static TClonesArray sdigitsClonesArray("AliTOFSDigit",  1000); 
   sdigitsClonesArray.Clear();
 
-  // get the treeS from manager
-  AliRunLoader* rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+  // get the treeS from digInput
+  AliRunLoader* rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inputFile));
   if (rl == 0x0)
    {
      AliError(Form("Can not find Run Loader in input %d folder.",inputFile));
index 59d4e53..613f745 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "AliDigitizer.h"
 
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliTOFHitMap;
 class AliTOFSDigit;
 class AliTOFcalib;
@@ -28,13 +28,13 @@ class AliTOFDigitizer : public AliDigitizer {
  public:
   
   AliTOFDigitizer();
-  AliTOFDigitizer(AliRunDigitizer * manager);
+  AliTOFDigitizer(AliDigitizationInput * digInput);
   virtual ~AliTOFDigitizer();
   AliTOFDigitizer(const AliTOFDigitizer &source); // copy constructor
   AliTOFDigitizer& operator=(const AliTOFDigitizer &source); // ass. op.
   
   // Do the main work
-  void Exec(Option_t* option=0) ;
+  void Digitize(Option_t* option=0) ;
   TClonesArray* SDigits() const {return fSDigitsArray;}
   void ReadSDigit(Int_t inputFile);
   void CreateDigits();
index d8f5520..6854b09 100644 (file)
@@ -17,7 +17,7 @@
 
 //__________________________________________________________//
 //                                                          //
-//   This is a TTask that constructs SDigits out of Hits    //
+//   This is a class that constructs SDigits out of Hits    //
 //   A Summable Digits is the "sum" of all hits in a pad    //
 //   Detector response has been simulated via the method    //
 //   SimulateDetectorResponse                               //
@@ -57,7 +57,7 @@ ClassImp(AliTOFSDigitizer)
 
 //____________________________________________________________________________ 
 AliTOFSDigitizer::AliTOFSDigitizer():
-  TTask("TOFSDigitizer",""),
+  TNamed("TOFSDigitizer",""),
   fEvent1(-1),
   fEvent2(-1),
   ftail(0x0),
@@ -104,7 +104,7 @@ AliTOFSDigitizer::AliTOFSDigitizer():
 
 //------------------------------------------------------------------------
 AliTOFSDigitizer::AliTOFSDigitizer(const AliTOFSDigitizer &source):
-  TTask(source),
+  TNamed(source),
   fEvent1(-1),
   fEvent2(-1),
   ftail(0x0),
@@ -160,7 +160,7 @@ AliTOFSDigitizer& AliTOFSDigitizer::operator=(const AliTOFSDigitizer &/*source*/
 
 //____________________________________________________________________________ 
 AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents):
-  TTask("TOFSDigitizer",""),
+  TNamed("TOFSDigitizer",""),
   fEvent1(-1),
   fEvent2(-1),
   ftail(0x0),
@@ -265,16 +265,12 @@ AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_
       AliFatal("Can not find TOF loader in event. Exiting.");
       return;
     }
-  fTOFLoader->PostSDigitizer(this);
-
 }
 
 //____________________________________________________________________________ 
 AliTOFSDigitizer::~AliTOFSDigitizer()
 {
   // dtor
-  fTOFLoader->CleanSDigitizer();
-
   if (fCalib) delete fCalib;
 
 }
@@ -350,7 +346,7 @@ Double_t TimeWithTail(const Double_t * const x, const Double_t * const par)
 }
 
 //____________________________________________________________________________
-void AliTOFSDigitizer::Exec(Option_t *verboseOption) { 
+void AliTOFSDigitizer::Digitize(Option_t *verboseOption) { 
   //execute TOF sdigitization
   if (strstr(verboseOption,"tim") || strstr(verboseOption,"all"))
     gBenchmark->Start("TOFSDigitizer");
index 9ab5f43..c0df7d4 100644 (file)
@@ -6,7 +6,7 @@
 
 //__________________________________________//
 //                                          //
-//  Task Class for making SDigits in TOF    // 
+//       Class for making SDigits in TOF    // 
 //                                          //
 //-- Authors: F. Pierella, A. De Caro       //
 //                                          //
@@ -14,7 +14,7 @@
 
 /* $Id$ */
 
-#include "TTask.h"
+#include "TNamed.h"
 
 class TF1;
 class TString;
@@ -24,7 +24,7 @@ class AliRunLoader;
 
 class AliTOFcalib;
 
-class AliTOFSDigitizer: public TTask {
+class AliTOFSDigitizer: public TNamed {
 
 public:
   AliTOFSDigitizer() ;          // ctor
@@ -38,7 +38,7 @@ public:
 
   //static Float_t WidthTdcBin() {return fgkTdcBin;};
 
-  virtual void  Exec(Option_t *verboseOption); 
+  virtual void  Digitize(Option_t *verboseOption); 
   void SetSDigitsFile(char * /*file*/ ) const {;}
   
   void InitParameters();
@@ -182,7 +182,7 @@ private:
 
   AliTOFcalib * fCalib; //! calibration object
 
-  ClassDef(AliTOFSDigitizer,4)  // creates TOF SDigits
+  ClassDef(AliTOFSDigitizer,5)  // creates TOF SDigits
 
 };
 
index 34487b6..16aaa94 100644 (file)
@@ -1095,9 +1095,9 @@ Bool_t AliTPC::Raw2SDigits(AliRawReader* rawReader){
 }
 
 //______________________________________________________________________
-AliDigitizer* AliTPC::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliTPC::CreateDigitizer(AliDigitizationInput* digInput) const
 {
-  return new AliTPCDigitizer(manager);
+  return new AliTPCDigitizer(digInput);
 }
 //__
 void AliTPC::SDigits2Digits2(Int_t /*eventnumber*/)  
index 9324b54..7e51922 100644 (file)
@@ -41,7 +41,7 @@ public:
   virtual void  CreateMaterials();
   virtual void  AddAlignableVolumes() const {}
   
-  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  virtual AliDigitizer* CreateDigitizer(AliDigitizationInput* digInput) const;
   virtual void  SDigits2Digits(){;} //MI change -cycling to production
   virtual void  SDigits2Digits2(Int_t eventnumber=0);
 
index fa2aef8..0bee1a6 100644 (file)
@@ -48,7 +48,7 @@
 #include "AliRun.h"
 #include "AliLoader.h"
 #include "AliPDG.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliSimDigits.h"
 #include "AliLog.h"
 
@@ -68,13 +68,13 @@ ClassImp(AliTPCDigitizer)
 }
 
 //___________________________________________
-AliTPCDigitizer::AliTPCDigitizer(AliRunDigitizer* manager) 
-  :AliDigitizer(manager),fDebug(0)
+AliTPCDigitizer::AliTPCDigitizer(AliDigitizationInput* digInput) 
+  :AliDigitizer(digInput),fDebug(0)
 {
   //
 // ctor which should be used
 //  
-  AliDebug(2,"(AliRunDigitizer* manager) was processed");
+  AliDebug(2,"(AliDigitizationInput* digInput) was processed");
 }
 
 //------------------------------------------------------------------------
@@ -95,12 +95,12 @@ Bool_t AliTPCDigitizer::Init()
 
 
 //------------------------------------------------------------------------
-void AliTPCDigitizer::Exec(Option_t* option)
+void AliTPCDigitizer::Digitize(Option_t* option)
 {
-  ExecFast(option);  
+  DigitizeFast(option);  
 }
 //------------------------------------------------------------------------
-void AliTPCDigitizer::ExecFast(Option_t* option)
+void AliTPCDigitizer::DigitizeFast(Option_t* option)
 {
   
   // merge input tree's with summable digits
@@ -109,7 +109,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
   char ss[100];
   TString optionString = option;
   if (!strcmp(optionString.Data(),"deb")) {
-    cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
+    cout<<"AliTPCDigitizer:::DigitizeFast called with option deb "<<endl;
     fDebug = 3;
   }
   //get detector and geometry
@@ -120,11 +120,11 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
   
   if (gAlice == 0x0)
    {
-     Warning("ExecFast","gAlice is NULL. Loading from input 0");
-     rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+     Warning("DigitizeFast","gAlice is NULL. Loading from input 0");
+     rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(0));
      if (rl == 0x0)
       {
-        Error("ExecFast","Can not find Run Loader for input 0. Can not proceed.");
+        Error("DigitizeFast","Can not find Run Loader for input 0. Can not proceed.");
         return;
       }
      rl->LoadgAlice();
@@ -134,7 +134,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
   AliTPCParam * param = pTPC->GetParam();
   
   //sprintf(s,param->GetTitle());
-  snprintf(s,100,param->GetTitle());
+  snprintf(s,100,"%s",param->GetTitle());
   //sprintf(ss,"75x40_100x60");
   snprintf(ss,100,"75x40_100x60");
   if(strcmp(s,ss)==0){
@@ -153,10 +153,10 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
   
   pTPC->GenerNoise(500000); //create table with noise
   //
-  Int_t nInputs = fManager->GetNinputs();
+  Int_t nInputs = fDigInput->GetNinputs();
   Int_t * masks = new Int_t[nInputs];
   for (Int_t i=0; i<nInputs;i++)
-    masks[i]= fManager->GetMask(i);
+    masks[i]= fDigInput->GetMask(i);
   Short_t **pdig= new Short_t*[nInputs];   //pointers to the expanded digits array
   Int_t **ptr=  new Int_t*[nInputs];       //pointers to the expanded tracks array
   Bool_t *active=  new Bool_t[nInputs];    //flag for active input segments
@@ -166,7 +166,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
   // make indexes
   //
   //create branch's in TPC treeD
-  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  orl = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   ogime = orl->GetLoader("TPCLoader");
   TTree * tree  = ogime->TreeD();
   AliSimDigits * digrow = new AliSimDigits;  
@@ -183,7 +183,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
     {
       digarr[i1]=0;
      //    intree[i1]
-      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
+      rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(i1));
       gime = rl->GetLoader("TPCLoader");
       gime->LoadSDigits("read");
       TTree * treear =  gime->TreeS();
@@ -260,7 +260,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
     for (Int_t i=0;i<nInputs; i++) 
      { 
 
-      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
+      rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(i));
       gime = rl->GetLoader("TPCLoader");
       
       if (gime->TreeS()->GetEntryWithIndex(segmentID,segmentID) >= 0) {
@@ -269,11 +269,11 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
         nrows = digarr[i]->GetNRows();
         ncols = digarr[i]->GetNCols();
        active[i] = kTRUE;
-       if (!fRegionOfInterest || (i == 0)) digitize = kTRUE;
+       if (!GetRegionOfInterest() || (i == 0)) digitize = kTRUE;
       } else {
        active[i] = kFALSE;
       }
-      if (fRegionOfInterest && !digitize) break;
+      if (GetRegionOfInterest() && !digitize) break;
      }   
     if (!digitize) continue;
 
@@ -358,11 +358,11 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
    } //for (Int_t n=0; n<param->GetNRowsTotal(); n++) 
   
 
-  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  orl = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   ogime = orl->GetLoader("TPCLoader");
   ogime->WriteDigits("OVERWRITE");
   
-  //fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
+  //fDigInput->GetTreeDTPC()->Write(0,TObject::kOverwrite);
   
   delete digrow;     
   for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
@@ -376,7 +376,7 @@ void AliTPCDigitizer::ExecFast(Option_t* option)
 
 
 //------------------------------------------------------------------------
-void AliTPCDigitizer::ExecSave(Option_t* option)
+void AliTPCDigitizer::DigitizeSave(Option_t* option)
 {
   
   // merge input tree's with summable digits
@@ -384,7 +384,7 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
 
   TString optionString = option;
   if (!strcmp(optionString.Data(),"deb")) {
-    cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
+    cout<<"AliTPCDigitizer::Digitize: called with option deb "<<endl;
     fDebug = 3;
   }
   //get detector and geometry 
@@ -392,10 +392,10 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
   AliLoader *gime, *ogime;
 
   
-  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  orl = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
   ogime = orl->GetLoader("TPCLoader");
   
-  rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+  rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(0));
   //gime = rl->GetLoader("TPCLoader");
   rl->GetLoader("TPCLoader");
   rl->LoadgAlice();
@@ -406,13 +406,13 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
   pTPC->GenerNoise(500000); //create teble with noise
   printf("noise %f \n",  param->GetNoise()*param->GetNoiseNormFac());
   //
-  Int_t nInputs = fManager->GetNinputs();
+  Int_t nInputs = fDigInput->GetNinputs();
   // stupid protection...
   if (nInputs <= 0) return;
   //
   Int_t * masks = new Int_t[nInputs];
   for (Int_t i=0; i<nInputs;i++)
-    masks[i]= fManager->GetMask(i);
+    masks[i]= fDigInput->GetMask(i);
 
   AliSimDigits ** digarr = new AliSimDigits*[nInputs]; 
   for(Int_t ii=0;ii<nInputs;ii++) digarr[ii]=0;
@@ -421,7 +421,7 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
    {
      //digarr[i1]=0;
     //    intree[i1]
-    rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
+    rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(i1));
     gime = rl->GetLoader("TPCLoader");
 
     TTree * treear =  gime->TreeS();
@@ -439,7 +439,7 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
     treear->GetBranch("Segment")->SetAddress(&digarr[i1]);
    }
   
-  rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+  rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(0));
   gime = rl->GetLoader("TPCLoader");
   Stat_t nentries = gime->TreeS()->GetEntries();
   
@@ -457,7 +457,7 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
   AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance()->GetDedxGainFactor();
   AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
   for (Int_t n=0; n<nentries; n++) {
-    rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+    rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(0));
     gime = rl->GetLoader("TPCLoader");
     gime->TreeS()->GetEvent(n);
 
@@ -466,8 +466,8 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
 
 
     for (Int_t i=1;i<nInputs; i++){ 
-//      fManager->GetInputTreeTPCS(i)->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());      
-      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
+//      fDigInput->GetInputTreeTPCS(i)->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());      
+      rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(i));
       gime = rl->GetLoader("TPCLoader");
       gime->TreeS()->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());  
       digarr[i]->ExpandBuffer();
@@ -554,13 +554,13 @@ void AliTPCDigitizer::ExecSave(Option_t* option)
     tree->Fill();
     if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";  
   } 
-//  printf("end TPC merging - end -Tree %s\t%p\n",fManager->GetInputTreeH(0)->GetName(),fManager->GetInputTreeH(0)->GetListOfBranches()->At(3));
-  //fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
+//  printf("end TPC merging - end -Tree %s\t%p\n",fDigInput->GetInputTreeH(0)->GetName(),fDigInput->GetInputTreeH(0)->GetListOfBranches()->At(3));
+  //fDigInput->GetTreeDTPC()->Write(0,TObject::kOverwrite);
     ogime->WriteDigits("OVERWRITE");
 
     for (Int_t i=1;i<nInputs; i++) 
      { 
-      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
+      rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(i));
       gime = rl->GetLoader("TPCLoader");
       gime->UnloadSDigits();
      }
index 7689fe8..ee73291 100644 (file)
@@ -7,22 +7,22 @@
 
 #include "AliDigitizer.h"
 
-class AliRunDigitizer;
+class AliDigitizationInput;
 
 class AliTPCDigitizer : public AliDigitizer {
  public:    
     AliTPCDigitizer();
-    AliTPCDigitizer(AliRunDigitizer * manager);
+    AliTPCDigitizer(AliDigitizationInput * digInput);
     virtual ~AliTPCDigitizer();
     // Initialize merging and digitization
     virtual Bool_t Init();
     // Do the main work
-    virtual void Exec(Option_t* option=0);    
+    virtual void Digitize(Option_t* option=0);    
     Int_t GetDebug() const {return fDebug;}       // get debug level
     void SetDebug(Int_t level){fDebug = level;}   // set debug level        
  private: 
-    void ExecFast(Option_t* option=0); //digitize - using row pointers
-    void ExecSave(Option_t* option=0); // digitize using controlled arrays   
+    void DigitizeFast(Option_t* option=0); //digitize - using row pointers
+    void DigitizeSave(Option_t* option=0); // digitize using controlled arrays   
     Int_t fDebug;
  private:
     ClassDef(AliTPCDigitizer,2)  // MUON merging/digitization
index da9c0a2..727e708 100644 (file)
@@ -179,13 +179,13 @@ void AliTRD::Hits2SDigits()
 }
 
 //_____________________________________________________________________________
-AliDigitizer *AliTRD::CreateDigitizer(AliRunDigitizer *manager) const
+AliDigitizer *AliTRD::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   //
   // Creates a new digitizer object
   //
 
-  return new AliTRDdigitizer(manager);
+  return new AliTRDdigitizer(digInput);
 
 }
 
index 32e9ca7..fee62a8 100644 (file)
@@ -56,7 +56,7 @@ class AliTRD : public AliDetector {
   virtual Bool_t   GetTR() const              = 0;
 
           AliTRDgeometry     *GetGeometry() const           { return fGeometry; };
-  virtual AliDigitizer       *CreateDigitizer(AliRunDigitizer *manager) const; 
+  virtual AliDigitizer       *CreateDigitizer(AliDigitizationInput* digInput) const; 
   virtual AliLoader          *MakeLoader(const char* topfoldername);
   virtual AliTriggerDetector *CreateTriggerDetector() const { return new AliTRDTrigger(); }
   void    SetPrimaryIonisation(Bool_t flag = kTRUE) {fPrimaryIonisation = flag;}  
index 502ae93..d2227fe 100644 (file)
@@ -47,7 +47,7 @@
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliConfig.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliLog.h"
@@ -119,9 +119,9 @@ AliTRDdigitizer::AliTRDdigitizer(const Text_t *name, const Text_t *title)
 }
 
 //_____________________________________________________________________________
-AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager
+AliTRDdigitizer::AliTRDdigitizer(AliDigitizationInput* digInput
                                , const Text_t *name, const Text_t *title)
-  :AliDigitizer(manager,name,title)
+  :AliDigitizer(digInput,name,title)
   ,fRunLoader(0)
   ,fDigitsManager(0)
   ,fSDigitsManager(0)
@@ -142,8 +142,8 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager
 }
 
 //_____________________________________________________________________________
-AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager)
-  :AliDigitizer(manager,"AliTRDdigitizer","TRD digitizer")
+AliTRDdigitizer::AliTRDdigitizer(AliDigitizationInput* digInput)
+  :AliDigitizer(digInput,"AliTRDdigitizer","TRD digitizer")
   ,fRunLoader(0)
   ,fDigitsManager(0)
   ,fSDigitsManager(0)
@@ -262,7 +262,7 @@ void AliTRDdigitizer::Copy(TObject &d) const
 }
 
 //_____________________________________________________________________________
-void AliTRDdigitizer::Exec(const Option_t * const option)
+void AliTRDdigitizer::Digitize(const Option_t* option)
 {
   //
   // Executes the merging
@@ -285,7 +285,7 @@ void AliTRDdigitizer::Exec(const Option_t * const option)
     AliDebug(1,"AliRun object found on file.");
   }
   else {
-    inrl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+    inrl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(0));
     inrl->LoadgAlice();
     gAlice = inrl->GetAliRun();
     if (!gAlice) {
@@ -294,17 +294,17 @@ void AliTRDdigitizer::Exec(const Option_t * const option)
     }
   }
                                                                            
-  Int_t nInput = fManager->GetNinputs();
+  Int_t nInput = fDigInput->GetNinputs();
   fMasks       = new Int_t[nInput];
   for (iInput = 0; iInput < nInput; iInput++) {
-    fMasks[iInput] = fManager->GetMask(iInput);
+    fMasks[iInput] = fDigInput->GetMask(iInput);
   }
 
   //
   // Initialization
   //
 
-  AliRunLoader *orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  AliRunLoader *orl = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
 
   if (InitDetector()) {
 
@@ -337,7 +337,7 @@ void AliTRDdigitizer::Exec(const Option_t * const option)
     AliDebug(1,Form("Add input stream %d",iInput));
 
     // Check if the input tree exists
-    inrl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
+    inrl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iInput));
     AliLoader *gime = inrl->GetLoader("TRDLoader");
 
     TTree *treees = gime->TreeS();
@@ -358,7 +358,7 @@ void AliTRDdigitizer::Exec(const Option_t * const option)
     sdigitsManager = new AliTRDdigitsManager();
     sdigitsManager->SetSDigits(kTRUE);
     
-    AliRunLoader *rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
+    AliRunLoader *rl = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iInput));
     AliLoader *gimme = rl->GetLoader("TRDLoader");
     if (!gimme->TreeS()) 
       {
index fbbefc2..9d4ce29 100644 (file)
@@ -16,7 +16,7 @@
 class TFile;
 class TF1;
 
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliRunLoader;
 
 class AliTRD;
@@ -32,8 +32,8 @@ class AliTRDdigitizer : public AliDigitizer {
 
   AliTRDdigitizer();
   AliTRDdigitizer(const Text_t *name, const Text_t *title);
-  AliTRDdigitizer(AliRunDigitizer *manager, const Text_t *name, const Text_t *title);
-  AliTRDdigitizer(AliRunDigitizer *manager);
+  AliTRDdigitizer(AliDigitizationInput* digInput, const Text_t *name, const Text_t *title);
+  AliTRDdigitizer(AliDigitizationInput* digInput);
   AliTRDdigitizer(const AliTRDdigitizer &d);
   virtual             ~AliTRDdigitizer();
   AliTRDdigitizer     &operator=(const AliTRDdigitizer &d);
@@ -41,7 +41,7 @@ class AliTRDdigitizer : public AliDigitizer {
   virtual void         Copy(TObject &d) const;
           Bool_t       InitDetector();
           void         InitOutput(Int_t iEvent);
-  virtual void         Exec(const Option_t * const option = 0);  
+  virtual void         Digitize(const Option_t * option = 0);  
 
   virtual Bool_t       Open(const Char_t *file, Int_t nEvent = 0);
   virtual Bool_t       Open(AliRunLoader * const runLoader, Int_t nEvent = 0);
index 356e494..0e69e9d 100755 (executable)
@@ -52,7 +52,7 @@
 #include "AliVZEROLoader.h"
 #include "AliVZERODigitizer.h"
 #include "AliVZEROBuffer.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliVZEROdigit.h"
 #include "AliVZEROSDigit.h"
 #include "AliDAQ.h"
@@ -247,12 +247,12 @@ void AliVZERO::SetTreeAddress()
 }
 
 //_____________________________________________________________________________
-AliDigitizer* AliVZERO::CreateDigitizer(AliRunDigitizer* manager) const
+AliDigitizer* AliVZERO::CreateDigitizer(AliDigitizationInput* digInput) const
 {
   //
   // Creates a digitizer for VZERO
   //
-  return new AliVZERODigitizer(manager);
+  return new AliVZERODigitizer(digInput);
 }
 
 //_____________________________________________________________________________
@@ -264,7 +264,7 @@ void AliVZERO::Hits2Digits(){
   AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2Digits);
 
   // Creates the digits
-  dig->Exec("");
+  dig->Digitize("");
 
   // deletes the digitizer
   delete dig;
@@ -279,7 +279,7 @@ void AliVZERO::Hits2SDigits(){
   AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2SDigits);
 
   // Creates the sdigits
-  dig->Exec("");
+  dig->Digitize("");
 
   // deletes the digitizer
   delete dig;
index ceb1dc4..c208764 100755 (executable)
@@ -63,7 +63,7 @@ public:
   virtual void   SetMaxDestepQua(Float_t p1);
   virtual void   SetMaxDestepAlu(Float_t p1);
 
-  AliDigitizer*  CreateDigitizer(AliRunDigitizer* manager) const;
+  AliDigitizer*  CreateDigitizer(AliDigitizationInput* digInput) const;
 
   void           GetCalibData();
   Float_t        CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const;
index 193206e..4abae07 100644 (file)
@@ -41,7 +41,7 @@
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliGRPObject.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
@@ -94,8