Code for simulation, sdigitization and digitization moved from macros to compiled...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Nov 2003 18:01:24 +0000 (18:01 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Nov 2003 18:01:24 +0000 (18:01 +0000)
37 files changed:
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDSDigitizer.cxx
FMD/AliFMDSDigitizer.h
ITS/AliITS.cxx
ITS/AliITS.h
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONDigitizerv1.cxx
PHOS/AliPHOS.cxx
PHOS/AliPHOS.h
PMD/AliPMD.cxx
PMD/AliPMD.h
PMD/AliPMDDigitizer.cxx
PMD/AliPMDDigitizer.h
RICH/AliRICH.cxx
RICH/AliRICH.h
START/AliSTART.cxx
START/AliSTART.h
STEER/AliModule.h
STEER/AliRunLoader.cxx
STEER/AliSimulation.cxx [new file with mode: 0644]
STEER/AliSimulation.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFSDigitizer.cxx
TOF/AliTOFSDigitizer.h
TPC/AliTPC.cxx
TPC/AliTPC.h
TRD/AliTRD.cxx
TRD/AliTRD.h
TRD/AliTRDdigitizer.cxx
ZDC/AliZDC.cxx

index 953f398..d34a7bc 100644 (file)
@@ -38,6 +38,9 @@ class TFile;
 #include "AliEMCAL.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALLoader.h"
+#include "AliRun.h"
+#include "AliEMCALSDigitizer.h"
+#include "AliEMCALDigitizer.h"
 
 ClassImp(AliEMCAL)
 //____________________________________________________________________________
@@ -240,3 +243,19 @@ AliLoader* AliEMCAL::MakeLoader(const char* topfoldername)
  fLoader = new AliEMCALLoader(GetName(),topfoldername);
  return fLoader;
 }
+
+//____________________________________________________________________________
+void AliEMCAL::Hits2SDigits()  
+{ 
+// create summable digits
+
+  AliEMCALSDigitizer* emcalDigitizer = 
+    new AliEMCALSDigitizer(fLoader->GetRunLoader()->GetFileName().Data());
+  emcalDigitizer->ExecuteTask();
+}
+
+//____________________________________________________________________________
+AliDigitizer* AliEMCAL::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliEMCALDigitizer(manager);
+}
index ea1c34e..a9b2438 100644 (file)
@@ -49,6 +49,9 @@ class AliEMCAL : public AliDetector {
  
   virtual AliLoader* MakeLoader(const char* topfoldername);
   
+  virtual void    Hits2SDigits();
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
+
 protected:
 
   //AliEMCALQAChecker * fQATask ; //! PHOS checkers container
index feb90fe..c66b68a 100644 (file)
@@ -64,6 +64,7 @@
 #include "AliMagF.h"
 #include "AliRun.h"
 #include "AliMC.h"
+#include "AliFMDDigitizer.h"
 
 ClassImp (AliFMD)
   //_____________________________________________________________________________
@@ -341,3 +342,8 @@ void AliFMD::MakeBranchInTreeD(TTree *treeD, const char *file)
      }
 }
 
+//____________________________________________________________________________
+AliDigitizer* AliFMD::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliFMDDigitizer(manager);
+}
index e507ceb..08a47e7 100644 (file)
@@ -39,6 +39,7 @@ public:
    // Digitisation
    TClonesArray *ReconParticles() const {return fReconParticles;}   
   virtual void SetHitsAddressBranch(TBranch *b){b->SetAddress(&fHits);}
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
 
  protected:
 //Granularity
index 97307a4..f3c6491 100644 (file)
@@ -62,7 +62,7 @@ ClassImp(AliFMDSDigitizer)
 }
            
 //____________________________________________________________________________ 
-AliFMDSDigitizer::AliFMDSDigitizer(char* HeaderFile,char *SdigitsFile ):TTask("AliFMDSDigitizer","") 
+AliFMDSDigitizer::AliFMDSDigitizer(const char* HeaderFile,char *SdigitsFile ):TTask("AliFMDSDigitizer","") 
 {
   fNevents = 0 ;     // Number of events to digitize, 0 means all evens in current file
   // add Task to //root/Tasks folder
index 5b6ed79..56c2f15 100644 (file)
@@ -27,7 +27,7 @@ class AliFMDSDigitizer: public TTask {
 
 public:
   AliFMDSDigitizer() ;          // ctor
-  AliFMDSDigitizer(char* HeaderFile,char *SdigitsFile = 0) ; 
+  AliFMDSDigitizer(const char* HeaderFile,char *SdigitsFile = 0) ; 
 
   virtual ~AliFMDSDigitizer() ; // dtor
   // Int_t    Digitize(Float_t Energy);
index 81ad690..7f1009c 100644 (file)
@@ -107,6 +107,7 @@ the AliITS class.
 #include "AliITSsimulationSPD.h"
 #include "AliITSsimulationSSD.h"
 #include "AliMC.h"
+#include "AliITSDigitizer.h"
 
 ClassImp(AliITS)
 
@@ -949,19 +950,23 @@ void AliITS::Hits2SDigits(){
     //      none.
 
 //    return; // Using Hits in place of the larger sDigits.
+    fLoader->LoadHits("read");
+    fLoader->LoadSDigits("recreate");
     AliRunLoader* rl = fLoader->GetRunLoader(); 
-    AliHeader *header=rl->GetHeader(); // Get event number from this file.
-    if (header == 0x0)
-     {
-       rl->LoadHeader();
-       header=rl->GetHeader();
-       if (header == 0x0) return;
-     }
+
+    for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
     // Do the Hits to Digits operation. Use Standard input values.
     // Event number from file, no background hit merging , use size from
     // AliITSgeom class, option="All", input from this file only.
-    HitsToSDigits(header->GetEvent(),0,-1," ",fOpt," ");
+      rl->GetEvent(iEvent);
+      if (!fLoader->TreeS()) fLoader->MakeTree("S");
+      MakeBranch("S");
+      SetTreeAddress();
+      HitsToSDigits(iEvent,0,-1," ",fOpt," ");
+    }
     
+    fLoader->UnloadHits();
+    fLoader->UnloadSDigits();
 }
 //______________________________________________________________________
 void AliITS::Hits2PreDigits(){
@@ -978,6 +983,11 @@ void AliITS::Hits2PreDigits(){
     HitsToPreDigits(header->GetEvent(),0,-1," ",fOpt," ");
 }
 //______________________________________________________________________
+AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliITSDigitizer(manager);
+}
+//______________________________________________________________________
 void AliITS::SDigitsToDigits(Option_t *opt){
     // Standard Summable digits to Digits function.
     // Inputs:
@@ -1049,11 +1059,23 @@ void AliITS::Hits2Digits(){
     // Outputs:
     //      none.
 
-    AliHeader *header=fLoader->GetRunLoader()->GetHeader(); // Get event number from this file.
+    fLoader->LoadHits("read");
+    fLoader->LoadDigits("recreate");
+    AliRunLoader* rl = fLoader->GetRunLoader(); 
+
+    for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
     // Do the Hits to Digits operation. Use Standard input values.
     // Event number from file, no background hit merging , use size from
     // AliITSgeom class, option="All", input from this file only.
-    HitsToDigits(header->GetEvent(),0,-1," ",fOpt," ");
+      rl->GetEvent(iEvent);
+      if (!fLoader->TreeD()) fLoader->MakeTree("D");
+      MakeBranch("D");
+      SetTreeAddress();   
+      HitsToDigits(iEvent,0,-1," ",fOpt," ");
+    }
+
+    fLoader->UnloadHits();
+    fLoader->UnloadDigits();
 }
 //______________________________________________________________________
 void AliITS::HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
index 4fb231a..111184b 100644 (file)
@@ -120,6 +120,7 @@ class AliITS : public AliDetector {
     void SetTreeAddressD(TTree *treeD);
     void Hits2SDigits(); // Turn hits into SDigits
     void Hits2PreDigits(); // Turn hits into SDigits
+    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
     void SDigits2Digits(){SDigitsToDigits("All");} // Turn SDigits to Digits
     void SDigitsToDigits(Option_t *opt="All"); // Turn SDigits to Digits
     void Hits2Digits(); // Turn hits straight into Digits.
index 7f8cd05..e63a35b 100644 (file)
@@ -67,6 +67,7 @@
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONTriggerDecision.h"
 #include "AliRun.h"    
+#include "AliMUONDigitizerv1.h"
 
 
 // Defaults parameters for Z positions of chambers
@@ -337,6 +338,11 @@ void   AliMUON::SetNsec(Int_t id, Int_t nsec)
 // Set number of segmented cathods for chamber id
     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
 }
+//____________________________________________________________________
+AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliMUONDigitizerv1(manager);
+}
 //_____________________________________________________________________
 void AliMUON::SDigits2Digits()
 {
index 859fb24..c9e4584 100644 (file)
@@ -61,6 +61,7 @@ class AliMUON : public  AliDetector {
     virtual void   Digits2Reco();
     virtual void   FindClusters();
     // Digitisation 
+    virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
     virtual void   SDigits2Digits();      
     // Configuration Methods (per station id)
     //
index 882c55b..f8d542c 100644 (file)
 ClassImp(AliMUONDigitizerv1)
 
 //___________________________________________
-AliMUONDigitizerv1::AliMUONDigitizerv1() :AliDigitizer()
+AliMUONDigitizerv1::AliMUONDigitizerv1() :
+  AliDigitizer(),
+  fHitMap(0),
+  fTDList(0),
+  fTDCounter(0),
+  fDebug(0),
+  fMask(0),
+  fSignal(0)
 {
 // Default ctor - don't use it
-  fHitMap = 0;
-  fTDList = 0;
   if (GetDebug()>2) 
     cerr<<"AliMUONDigitizerv1::AliMUONDigitizerv1"
        <<"(AliRunDigitizer* manager) was processed"<<endl;
 }
 
 //___________________________________________
-AliMUONDigitizerv1::AliMUONDigitizerv1(AliRunDigitizer* manager) 
-    :AliDigitizer(manager)
+AliMUONDigitizerv1::AliMUONDigitizerv1(AliRunDigitizer* manager):
+  AliDigitizer(manager),
+  fHitMap(0),
+  fTDList(0),
+  fTDCounter(0),
+  fDebug(0),
+  fMask(0),
+  fSignal(0)
 {
 // ctor which should be used
-  fHitMap  = 0;
-  fTDList  = 0;
-  fDebug   = 0; 
-  //  fHits = new TClonesArray("AliMUONHit",1000);
   if (GetDebug()>2) 
     cerr<<"AliMUONDigitizerv1::AliMUONDigitizerv1"
        <<"(AliRunDigitizer* manager) was processed"<<endl;
@@ -53,7 +60,6 @@ AliMUONDigitizerv1::AliMUONDigitizerv1(AliRunDigitizer* manager)
 AliMUONDigitizerv1::~AliMUONDigitizerv1()
 {
 // Destructor
-  //delete fHits;
 }
 
 //------------------------------------------------------------------------
index 0d3176b..bf73123 100644 (file)
@@ -38,7 +38,10 @@ class TFile;
 #include "AliPHOS.h"
 #include "AliPHOSGeometry.h"
 #include "AliPHOSLoader.h"
-
+#include "AliPHOSQAChecker.h"
+#include "AliRun.h"
+#include "AliPHOSDigitizer.h"
+#include "AliPHOSSDigitizer.h"
 
 ClassImp(AliPHOS)
 //____________________________________________________________________________
@@ -425,3 +428,20 @@ AliLoader* AliPHOS::MakeLoader(const char* topfoldername)
  fLoader = new AliPHOSLoader(GetName(),topfoldername);
  return fLoader;
 }
+
+
+//____________________________________________________________________________
+void AliPHOS::Hits2SDigits()  
+{ 
+// create summable digits
+
+  AliPHOSSDigitizer* phosDigitizer = 
+    new AliPHOSSDigitizer(fLoader->GetRunLoader()->GetFileName().Data());
+  phosDigitizer->ExecuteTask("all");
+}
+
+//____________________________________________________________________________
+AliDigitizer* AliPHOS::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliPHOSDigitizer(manager);
+}
index f612c8d..d28e5e5 100644 (file)
@@ -54,6 +54,9 @@ class AliPHOS : public AliDetector {
 
   virtual AliLoader* MakeLoader(const char* topfoldername);
  
+  virtual void    Hits2SDigits();
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
+
 protected:
   
   AliPHOSQAChecker * fQATask ; //! PHOS checkers container
index 938b197..de70e52 100644 (file)
@@ -52,6 +52,7 @@
 #include "AliPMDRecPoint.h"
 #include "AliRun.h"
 #include "AliMC.h"
+#include "AliPMDDigitizer.h"
   
 ClassImp(AliPMD)
  
@@ -350,3 +351,22 @@ AliPMDhit::AliPMDhit(Int_t shunt,Int_t track, Int_t *vol, Float_t *hits):
   fEnergy=hits[3];
 }
   
+
+//____________________________________________________________________________
+void AliPMD::Hits2SDigits()  
+{ 
+// create summable digits
+
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
+  AliPMDDigitizer* pmdDigitizer = new AliPMDDigitizer;
+  pmdDigitizer->OpengAliceFile(fLoader->GetRunLoader()->GetFileName().Data(),
+                              "HS");
+  pmdDigitizer->SetZPosition(365.0);
+
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    pmdDigitizer->Hits2SDigits(iEvent);
+  }
+  fLoader->UnloadHits();
+  fLoader->UnloadSDigits();
+  delete pmdDigitizer;
+}
index a41c524..1936632 100644 (file)
@@ -48,6 +48,8 @@ public:
   virtual void  SetTreeAddress();
   virtual void  ResetHits();
   
+  virtual void  Hits2SDigits();
+
  private:
   TClonesArray* fRecPoints;   //! List of reconstructed hits
   Int_t         fNRecPoints;  // Number of reconstructed hits
index 135e73f..03f6454 100644 (file)
@@ -87,13 +87,12 @@ AliPMDDigitizer::~AliPMDDigitizer()
 //
 // Member functions
 //
-void AliPMDDigitizer::OpengAliceFile(Char_t *file, Option_t *option)
+void AliPMDDigitizer::OpengAliceFile(const char *file, Option_t *option)
 {
   // Loads galice.root file and corresponding header, kinematics
   // hits and sdigits or digits depending on the option
   //
-  fRunLoader = AliRunLoader::Open(file,AliConfig::fgkDefaultEventFolderName,
-                                 "UPDATE");
+  fRunLoader = AliRunLoader::Open(file,AliConfig::fgkDefaultEventFolderName);
   
   if (!fRunLoader)
    {
index f2532cf..22d7d71 100644 (file)
@@ -38,7 +38,7 @@ class AliPMDDigitizer
   AliPMDDigitizer();
   virtual ~AliPMDDigitizer();
 
-  void OpengAliceFile(char *file, Option_t *option);
+  void OpengAliceFile(const char *file, Option_t *option);
 
   void Hits2SDigits(Int_t ievt);
   void Hits2Digits(Int_t ievt);
index 6fe76ff..1d2278b 100644 (file)
@@ -28,6 +28,7 @@
 #include <AliRunDigitizer.h>
 #include <AliMC.h>
 #include <TVirtualMC.h>
+#include "AliRICHDigitizer.h"
  
 ClassImp(AliRICHhit)
 //__________________________________________________________________________________________________
@@ -133,6 +134,11 @@ void AliRICH::Hits2SDigits()
   if(GetDebug()) Info("Hit2SDigits","Stop.");
 }//void AliRICH::Hits2SDigits()
 //__________________________________________________________________________________________________
+AliDigitizer* AliRICH::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliRICHDigitizer(manager);
+}
+//__________________________________________________________________________________________________
 void AliRICH::SDigits2Digits()
 {
 //Generate digits from sdigits.
index 5aa3fbc..ba92629 100644 (file)
@@ -267,6 +267,7 @@ public:
   AliRICH&  operator=(const AliRICH&)                 {return *this;}
   virtual Int_t   IsVersion()                                            const =0;            
           void    Hits2SDigits();                                                                                 //virtual
+  AliDigitizer*   CreateDigitizer(AliRunDigitizer* manager);                                                      //virtual
           void    SDigits2Digits();                                                                               //virtual
   
   inline  void    CreateHits();    
index bdf950a..402f8c8 100755 (executable)
@@ -56,6 +56,7 @@
 #include "AliSTARThitPhoton.h"
 #include "AliSTARTvertex.h"
 #include "AliMC.h"
+#include "AliSTARTDigitizer.h"
 
 ClassImp(AliSTART)
 
@@ -261,3 +262,8 @@ void AliSTART::Hit2digit(Int_t /*evnum*/)
 {
 }
 
+//_____________________________________________________________________________
+AliDigitizer* AliSTART::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliSTARTDigitizer(manager);
+}
index 004f4a1..939c0cc 100755 (executable)
@@ -44,6 +44,8 @@ public:
    virtual void   SetTreeAddress();
    TClonesArray   *Photons() {return fPhotons;}
    
+   virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
+
 protected:
    Int_t fIdSens;    // Sensetive Cherenkov radiator
    Int_t       fNPhotons;   // Number of photons plan to photokatod
index 92c233c..35db6d6 100644 (file)
@@ -20,6 +20,8 @@ class TFile;
 class TTree;
 class AliLoader;
 class AliTrackReference;
+class AliDigitizer;
+class AliRunDigitizer;
 
 
 class AliModule : public TNamed , public TAttLine, public TAttMarker,
@@ -80,7 +82,10 @@ 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*/) 
+    {return NULL;}
   virtual void        SDigits2Digits() {}
+  virtual void        Hits2Digits() {}
   virtual void        Digits2Reco() {}
   virtual void        Digits2Raw() {}
   virtual void        Raw2Digits() {}
index 7dacc52..8821997 100644 (file)
@@ -77,6 +77,7 @@ AliRunLoader::AliRunLoader():
  fUnixDirName(".")
 {
   AliConfig::Instance();//force to build the folder structure
+  if (!fgRunLoader) fgRunLoader = this;
 }
 /**************************************************************************/
 
@@ -95,6 +96,7 @@ AliRunLoader::AliRunLoader(const char* eventfoldername):
 {
 //ctor
   SetEventFolderName(eventfoldername);
+ if (!fgRunLoader) fgRunLoader = this;
 }
 /**************************************************************************/
 
@@ -124,15 +126,26 @@ AliRunLoader::~AliRunLoader()
 }
 /**************************************************************************/
 
-AliRunLoader::AliRunLoader(TFolder* topfolder):TNamed(fgkRunLoaderName,fgkRunLoaderName)
+AliRunLoader::AliRunLoader(TFolder* topfolder):
+ TNamed(fgkRunLoaderName,fgkRunLoaderName),
+ fLoaders(new TObjArray()),
+ fEventFolder(topfolder),
+ fCurrentEvent(0),
+ fGAFile(0x0),
+ fHeader(0x0),
+ fStack(0x0),
+ fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
+ fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
+ fNEventsPerFile(1),
+ fUnixDirName(".")
 {
 //ctor
+ if (!fgRunLoader) fgRunLoader = this;
  if(topfolder == 0x0)
   {
     Fatal("AliRunLoader(TFolder*)","Parameter is NULL");
     return;
   }
- fEventFolder = topfolder;
  
  TObject* obj = fEventFolder->FindObject(fgkRunLoaderName);
  if (obj)
@@ -143,7 +156,6 @@ AliRunLoader::AliRunLoader(TFolder* topfolder):TNamed(fgkRunLoaderName,fgkRunLoa
     return;//never reached
   }
    
- fLoaders = new TObjArray();
  fEventFolder->Add(this);//put myself to the folder to accessible for all
   
 }
@@ -421,7 +433,7 @@ AliRunLoader* AliRunLoader::Open
  
  result->SetDirName(dirname); 
  result->SetGAliceFile(gAliceFile);//set the pointer to gAliceFile
- fgRunLoader = result; //PH get access from any place
+ if (!fgRunLoader) fgRunLoader = result; //PH get access from any place
  return result;
 }
 /**************************************************************************/
diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
new file mode 100644 (file)
index 0000000..54440d3
--- /dev/null
@@ -0,0 +1,416 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// class for running generation, simulation and digitization                 //
+//                                                                           //
+// Hits, sdigits and digits are created for all detectors by typing:         //
+//                                                                           //
+//   AliSimulation sim;                                                      //
+//   sim.Run();                                                              //
+//                                                                           //
+// The Run method returns kTRUE in case of successful execution.             //
+// The number of events can be given as argument to the Run method or it     //
+// can be set by                                                             //
+//                                                                           //
+//   sim.SetNumberOfEvents(n);                                               //
+//                                                                           //
+// The name of the configuration file can be specified by                    //
+//                                                                           //
+//   sim.SetConfigFile("...");                                               //
+//                                                                           //
+// The generation of particles and the simulation of detector hits can be    //
+// switched on or off by                                                     //
+//                                                                           //
+//   sim.SetRunGeneration(kTRUE);   // generation of primary particles       //
+//   sim.SetRunSimulation(kFALSE);  // but no tracking                       //
+//                                                                           //
+// For which detectors sdigits and digits will be created, can be steered    //
+// by                                                                        //
+//                                                                           //
+//   sim.SetMakeSDigits("ALL");     // make sdigits for all detectors        //
+//   sim.SetMakeDigits("ITS TPC");  // make digits only for ITS and TPC      //
+//                                                                           //
+// The argument is a (case sensitive) string with the names of the           //
+// detectors separated by a space. An empty string ("") can be used to       //
+// disable the creation of sdigits or digits. The special string "ALL"       //
+// selects all available detectors. This is the default.                     //
+//                                                                           //
+// The creation of digits from hits instead of from sdigits can be selected  //
+// by                                                                        //
+//                                                                           //
+//   sim.SetMakeDigitsFromHits("TRD");                                       //
+//                                                                           //
+// The argument is again a string with the selected detectors. Be aware that //
+// this feature is not available for all detectors and that merging is not   //
+// possible, when digits are created directly from hits.                     //
+//                                                                           //
+// Backgound events can be merged by calling                                 //
+//                                                                           //
+//   sim.MergeWith("background/galice.root", 2);                             //
+//                                                                           //
+// The first argument is the file name of the background galice file. The    //
+// second argument is the number of signal events per background event.      //
+// The default value for this is 1. MergeWith can be called several times    //
+// to merge more than two event streams. It is assumed that the sdigits      //
+// were already produced for the background events.                          //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include "AliSimulation.h"
+#include "AliRunLoader.h"
+#include "AliRun.h"
+#include "AliModule.h"
+#include "AliGenerator.h"
+#include "AliRunDigitizer.h"
+#include <TObjString.h>
+
+
+ClassImp(AliSimulation)
+
+
+//_____________________________________________________________________________
+AliSimulation::AliSimulation(const char* name, const char* title) :
+  TNamed(name, title)
+{
+// create simulation object with default parameters
+
+  Init();
+}
+
+//_____________________________________________________________________________
+AliSimulation::AliSimulation(const AliSimulation& sim) :
+  TNamed(sim)
+{
+// copy constructor
+
+  fRunGeneration = sim.fRunGeneration;
+  fRunSimulation = sim.fRunSimulation;
+  fMakeSDigits = sim.fMakeSDigits;
+  fMakeDigits = sim.fMakeDigits;
+  fMakeDigitsFromHits = sim.fMakeDigitsFromHits;
+  fStopOnError = sim.fStopOnError;
+
+  fNEvents = sim.fNEvents;
+  fConfigFileName = sim.fConfigFileName;
+  fGAliceFileName = sim.fGAliceFileName;
+  fBkgrdFileNames = new TObjArray;
+  for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
+    if (!sim.fBkgrdFileNames->At(i)) continue;
+    fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
+  }
+
+  fRunLoader = NULL;
+}
+
+//_____________________________________________________________________________
+AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
+{
+// assignment operator
+
+  this->~AliSimulation();
+  new(this) AliSimulation(sim);
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliSimulation::~AliSimulation()
+{
+// clean up
+
+  fBkgrdFileNames->Delete();
+  delete fBkgrdFileNames;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::Init()
+{
+// set default parameters
+
+  fRunGeneration = kTRUE;
+  fRunSimulation = kTRUE;
+  fMakeSDigits = "ALL";
+  fMakeDigits = "ALL";
+  fMakeDigitsFromHits = "";
+  fStopOnError = kFALSE;
+
+  fNEvents = 1;
+  fConfigFileName = "Config.C";
+  fGAliceFileName = "galice.root";
+  fBkgrdFileNames = new TObjArray;
+
+  fRunLoader = NULL;
+}
+
+
+//_____________________________________________________________________________
+void AliSimulation::SetNumberOfEvents(Int_t nEvents)
+{
+// set the number of events for one run
+
+  fNEvents = nEvents;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetConfigFile(const char* fileName)
+{
+// set the name of the config file
+
+  fConfigFileName = fileName;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
+{
+// add a file with background events for merging
+
+  TObjString* fileNameStr = new TObjString(fileName);
+  fileNameStr->SetUniqueID(nSignalPerBkgrd);
+  fBkgrdFileNames->Add(fileNameStr);
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::Run(Int_t nEvents)
+{
+// run the generation, simulation and digitization
+
+  if (nEvents > 0) fNEvents = nEvents;
+
+  // generation and simulation -> hits
+  if (fRunGeneration) {
+    if (!gAlice) {
+      Error("Run", "no gAlice object. Restart aliroot and try again.");
+      return kFALSE;
+    }
+    if (gAlice->Modules()->GetEntries() > 0) {
+      Error("Run", "gAlice was already run. Restart aliroot and try again.");
+      return kFALSE;
+    }
+    if (!RunSimulation()) if (fStopOnError) return kFALSE;
+  }
+
+  // reopen the run loader
+  if (fRunLoader) delete fRunLoader;
+  fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
+  if (!fRunLoader) {
+    Error("Run", "no run loader found in file %s", 
+         fGAliceFileName.Data());
+    return kFALSE;
+  }
+  fRunLoader->LoadgAlice();
+  gAlice = fRunLoader->GetAliRun();
+  if (!gAlice) {
+    Error("GetLoadersAndDetectors", "no gAlice object found in file %s", 
+         fGAliceFileName.Data());
+    return kFALSE;
+  }
+
+  // hits -> summable digits
+  if (!fMakeSDigits.IsNull()) {
+    if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
+  }
+
+  // summable digits -> digits
+  if (!fMakeDigits.IsNull()) {
+    if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
+      if (fStopOnError) return kFALSE;
+    }
+  }
+
+  // hits -> digits
+  if (!fMakeDigitsFromHits.IsNull()) {
+    if (fBkgrdFileNames->GetEntriesFast() > 0) {
+      Warning("Run", "Merging and direct creation of digits from hits " 
+             "was selected for some detectors. "
+             "No merging will be done for the following detectors: %s",
+             fMakeDigitsFromHits.Data());
+    }
+    if (!RunHitsDigitization(fMakeDigitsFromHits)) {
+      if (fStopOnError) return kFALSE;
+    }
+  }
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunSimulation()
+{
+// run the generation and simulation
+
+  Info("RunSimulation", "initializing gAlice with config file %s",
+       fConfigFileName.Data());
+  gAlice->Init(fConfigFileName.Data());
+  fRunLoader = gAlice->GetRunLoader();
+  if (!fRunLoader) {
+    Error("RunSimulation", "gAlice has no run loader object. "
+         "Check your config file: %s", fConfigFileName.Data());
+    return kFALSE;
+  }
+  fGAliceFileName = fRunLoader->GetFileName();
+
+  if (!fRunSimulation) {
+    if (!gAlice->Generator()) {
+      Error("RunSimulation", "gAlice has no generator object. "
+           "Check your config file: %s", fConfigFileName.Data());
+      return kFALSE;
+    }
+    gAlice->Generator()->SetTrackingFlag(0);
+  }
+
+  Info("Run", "running gAlice");
+  gAlice->Run(fNEvents);
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunSDigitization(const TString& detectors)
+{
+// run the digitization and produce summable digits
+
+  TString detStr = detectors;
+  TObjArray* detArray = gAlice->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)) {
+      Info("RunSDigitization", "creating summable digits for %s", 
+          det->GetName());
+      det->Hits2SDigits();
+    }
+  }
+
+  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+    Error("RunSDigitization", "the following detectors were not found: %s", 
+         detStr.Data());
+    if (fStopOnError) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunDigitization(const TString& detectors, 
+                                     const TString& excludeDetectors)
+{
+// run the digitization and produce digits from sdigits
+
+  Int_t nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
+  Int_t signalPerBkgrd = 1;
+  if (nStreams > 1) signalPerBkgrd = fBkgrdFileNames->At(0)->GetUniqueID();
+  AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
+  manager->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);
+  }
+
+  TString detStr = detectors;
+  TString detExcl = excludeDetectors;
+  TObjArray* detArray = gAlice->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)) {
+      if (!det->CreateDigitizer(manager)) {
+       Error("RunDigitization", "no digitizer for %s", det->GetName());
+       if (fStopOnError) return kFALSE;
+      }
+    }
+  }
+
+  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+    Error("RunDigitization", "the following detectors were not found: %s", 
+         detStr.Data());
+    if (fStopOnError) return kFALSE;
+  }
+
+  if (!manager->GetListOfTasks()->IsEmpty()) {
+    Info("RunDigitization", "executing digitization");
+    manager->Exec("");
+  }
+  delete manager;
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunHitsDigitization(const TString& detectors)
+{
+// run the digitization and produce digits from hits
+
+  TString detStr = detectors;
+  TObjArray* detArray = gAlice->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)) {
+      Info("RunHitsDigitization", "creating digits from hits for %s", 
+          det->GetName());
+      det->Hits2Digits();
+    }
+  }
+
+  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+    Error("RunHitsDigitization", "the following detectors were not found: %s", 
+         detStr.Data());
+    if (fStopOnError) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
+{
+// check whether detName is contained in detectors
+// if yes, it is removed from detectors
+
+  // check if all detectors are selected
+  if ((detectors.CompareTo("ALL") == 0) ||
+      detectors.BeginsWith("ALL ") ||
+      detectors.EndsWith(" ALL") ||
+      detectors.Contains(" ALL ")) {
+    detectors = "ALL";
+    return kTRUE;
+  }
+
+  // search for the given detector
+  Bool_t result = kFALSE;
+  if ((detectors.CompareTo(detName) == 0) ||
+      detectors.BeginsWith(detName+" ") ||
+      detectors.EndsWith(" "+detName) ||
+      detectors.Contains(" "+detName+" ")) {
+    detectors.ReplaceAll(detName, "");
+    result = kTRUE;
+  }
+
+  // clean up the detectors string
+  while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
+  while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
+  while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
+
+  return result;
+}
diff --git a/STEER/AliSimulation.h b/STEER/AliSimulation.h
new file mode 100644 (file)
index 0000000..61b12be
--- /dev/null
@@ -0,0 +1,65 @@
+#ifndef ALISIMULATION_H
+#define ALISIMULATION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include <TNamed.h>
+#include <TString.h>
+
+class AliRunLoader;
+
+
+class AliSimulation: public TNamed {
+public:
+  AliSimulation(const char* name = "AliSimulation", 
+               const char* title = "generation, simulation and digitization");
+  AliSimulation(const AliSimulation& sim);
+  AliSimulation& operator = (const AliSimulation& sim);
+  virtual ~AliSimulation();
+
+  void           SetNumberOfEvents(Int_t nEvents);
+  void           SetConfigFile(const char* fileName);
+
+  void           SetRunGeneration(Bool_t run) {fRunGeneration = run;};
+  void           SetRunSimulation(Bool_t run) {fRunSimulation = run;};
+  void           SetMakeSDigits(const char* detectors) 
+                   {fMakeSDigits = detectors;};
+  void           MergeWith(const char* fileName, Int_t nSignalPerBkgrd = 1);
+  void           SetMakeDigits(const char* detectors)
+                   {fMakeDigits = detectors;};
+  void           SetMakeDigitsFromHits(const char* detectors)
+                   {fMakeDigitsFromHits = detectors;};
+
+  virtual Bool_t Run(Int_t nEvents = 0);
+
+private:
+  void           Init();
+
+  Bool_t         IsSelected(TString detName, TString& detectors) const;
+
+  Bool_t         RunSimulation();
+  Bool_t         RunSDigitization(const TString& detectors);
+  Bool_t         RunDigitization(const TString& detectors,
+                                const TString& excludeDetectors);
+  Bool_t         RunHitsDigitization(const TString& detectors);
+
+  Bool_t         fRunGeneration;      // generate prim. particles or not
+  Bool_t         fRunSimulation;      // simulate detectors (hits) or not
+  TString        fMakeSDigits;        // create sdigits for these detectors
+  TString        fMakeDigits;         // create digits for these detectors
+  TString        fMakeDigitsFromHits; // create digits from hits for these detectors
+  Bool_t         fStopOnError;        // stop or continue on errors
+
+  Int_t          fNEvents;            // number of events
+  TString        fConfigFileName;     // name of the config file
+  TString        fGAliceFileName;     // name of the galice file
+  TObjArray*     fBkgrdFileNames;     // names of background files for merging
+
+  AliRunLoader*  fRunLoader;          //! current run loader object
+
+  ClassDef(AliSimulation, 1)  // class for running generation, simulation and digitization
+};
+
+#endif
index bd6ad43..0ee5cb5 100644 (file)
@@ -10,6 +10,8 @@
  
 #pragma link C++ global gAlice;
 #pragma link C++ global gMC;
+#pragma link C++ global kAliDetMax;
+#pragma link C++ global kAliDetAll;
  
 #pragma link C++ enum VertexSmear_t;
 #pragma link C++ enum VertexSource_t;
@@ -75,6 +77,7 @@
 #pragma link C++ class  AliMemoryWatcher+;
 #pragma link C++ class  AliBarrelTrack+;
 #pragma link C++ class  AliMC+;
+#pragma link C++ class  AliSimulation+;
 #endif
 
 
index b5e5cc6..d5767b8 100644 (file)
@@ -17,7 +17,7 @@ AliGausCorr.cxx AliTrackReference.cxx AliESD.cxx \
 AliTrackMap.cxx AliTrackMapper.cxx AliCollisionGeometry.cxx \
 AliMemoryWatcher.cxx AliBarrelTrack.cxx \
 AliESDtrack.cxx AliESDv0.cxx AliESDcascade.cxx AliESDvertex.cxx AliESDpid.cxx \
-AliMC.cxx
+AliMC.cxx AliSimulation.cxx
 HDRS:= $(SRCS:.cxx=.h) 
 
 DHDR= STEERLinkDef.h
index 666d28e..497097f 100644 (file)
@@ -70,6 +70,7 @@
 #include "AliTOFhit.h"
 #include "AliTOFhitT0.h"
 #include "AliMC.h"
+#include "AliTOFDigitizer.h"
  
 ClassImp(AliTOF)
  
@@ -723,16 +724,22 @@ void AliTOF::Hits2SDigits()
   //#endif
   
   //char * fileSDigits = 0 ;
-  char * fileHeader = 0;
+  const char * fileHeader = fLoader->GetRunLoader()->GetFileName().Data();
   AliTOFSDigitizer * sd = new AliTOFSDigitizer(fileHeader) ;
 
   sd->Exec("") ;
   sd->Print("");
 
-  delete sd ;
+//  delete sd ;
   
 }
 //___________________________________________________________________________
+AliDigitizer* AliTOF::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliTOFDigitizer(manager);
+}
+
+//___________________________________________________________________________
 Bool_t AliTOF::CheckOverlap(Int_t* vol, Float_t* digit,Int_t Track)
 {
 //
index 3c8e739..19e8070 100644 (file)
@@ -76,6 +76,7 @@ public:
   virtual AliTOFMerger* Merger();
 //  virtual void    Hits2Digits();   
   virtual void    Hits2SDigits();
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager); 
   virtual void    Digits2Reco() {cout << "AliTOF::Digits2Reco()  dummy function called" << endl;}
           void    Digits2Raw (Int_t evNumber=0);
           void    Raw2Digits (Int_t evNumber=0);
index 0be6089..795ca7c 100644 (file)
@@ -74,7 +74,7 @@ ClassImp(AliTOFSDigitizer)
 }
            
 //____________________________________________________________________________ 
-  AliTOFSDigitizer::AliTOFSDigitizer(char* HeaderFile, Int_t evNumber1, Int_t nEvents):TTask("AliTOFSDigitizer","") 
+  AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents):TTask("AliTOFSDigitizer","") 
 {
   fEvent1=evNumber1;
   fEvent2=fEvent1+nEvents;
index 08f78ff..a47cbb3 100644 (file)
@@ -20,7 +20,7 @@ class AliTOFSDigitizer: public TTask {
 
 public:
   AliTOFSDigitizer() ;          // ctor
-  AliTOFSDigitizer(char* HeaderFile, Int_t evNumber1=0, Int_t nEvents=1) ; // par ctor
+  AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1=0, Int_t nEvents=1) ; // par ctor
 
   virtual ~AliTOFSDigitizer() ; // dtor
 
index 2b9cde3..97a4297 100644 (file)
@@ -75,6 +75,7 @@
 #include "AliTPCcluster.h"
 #include "AliTrackReference.h"
 #include "AliMC.h"
+#include "AliTPCDigitizer.h"
 
 
 ClassImp(AliTPC) 
@@ -1227,6 +1228,11 @@ void AliTPC::Hits2ExactClustersSector(Int_t isec)
 
 
 
+//______________________________________________________________________
+AliDigitizer* AliTPC::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliTPCDigitizer(manager);
+}
 //__
 void AliTPC::SDigits2Digits2(Int_t /*eventnumber*/)  
 {
@@ -1409,6 +1415,22 @@ void AliTPC::SetDefaults(){
 
 }
 //__________________________________________________________________  
+void AliTPC::Hits2Digits()  
+{
+  fLoader->LoadHits("read");
+  fLoader->LoadDigits("recreate");
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
+
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    runLoader->GetEvent(iEvent);
+    SetActiveSectors();   
+    Hits2Digits(iEvent);
+  }
+
+  fLoader->UnloadHits();
+  fLoader->UnloadDigits();
+} 
+//__________________________________________________________________  
 void AliTPC::Hits2Digits(Int_t eventnumber)  
 { 
  //----------------------------------------------------
@@ -1555,53 +1577,19 @@ void AliTPC::Hits2SDigits()
   //   summable digits - 16 bit "ADC", no noise, no saturation
   //-----------------------------------------------------------
 
- //----------------------------------------------------
- // Loop over all sectors for a single event
- //----------------------------------------------------
-  //MI change - for pp run
-//  Int_t eventnumber = gAlice->GetEvNumber();
-//  AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
-//  rl->GetEvent(eventnumber);
-// 12/05/2003 This method is obsolete and not used. It should be redesingned
-// M.Kowalski
-
-  if (fLoader->TreeH() == 0x0)
-   {
-     if(fLoader->LoadHits())
-      {
-        Error("Hits2Digits","Can not load hits.");
-      }
-   }
-  SetTreeAddress();
-
-  if(fDefaults == 0) SetDefaults();
-  GenerNoise(500000); //create table with noise
-
-  //setup TPCDigitsArray 
+  fLoader->LoadHits("read");
+  fLoader->LoadSDigits("recreate");
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
 
-  if(GetDigitsArray()) delete GetDigitsArray();
-
-  if (fLoader->TreeS() == 0x0 ) 
-   {
-     fLoader->MakeTree("S");
-   }
-  
-  AliTPCDigitsArray *arr = new AliTPCDigitsArray; 
-  arr->SetClass("AliSimDigits");
-  arr->Setup(fTPCParam);
-  arr->MakeTree(fLoader->TreeS());
-  SetDigitsArray(arr);
-
-  cerr<<"Digitizing TPC -- summable digits...\n"; 
-
-  //  fDigitsSwitch=1; // summable digits  -for the moment direct
-
-  for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    runLoader->GetEvent(iEvent);
+    SetTreeAddress();
+    SetActiveSectors();
+    Hits2SDigits2(iEvent);
+  }
 
-  // write results
-  //
-  cout<<"Why method TPC::Hits2SDigits writes digits and not sdigits? skowron\n";
-  fLoader->WriteDigits("OVERWRITE");
+  fLoader->UnloadHits();
+  fLoader->UnloadSDigits();
 }
 //_____________________________________________________________________________
 
@@ -3087,18 +3075,19 @@ AliTPCParam* AliTPC::LoadTPCParam(TFile *file) {
 
 }
 
-//_____________________________________________________________________________
+
+//____________________________________________________________________________
 Double_t SigmaY2(Double_t r, Double_t tgl, Double_t pt)
 {
   //
-  // Parametrised error of the cluster reconstruction (pad direction)   
+  // Parametrised error of the cluster reconstruction (pad direction)
   //
   // Sigma rphi
   const Float_t kArphi=0.41818e-2;
   const Float_t kBrphi=0.17460e-4;
   const Float_t kCrphi=0.30993e-2;
   const Float_t kDrphi=0.41061e-3;
-  
+
   pt=TMath::Abs(pt)*1000.;
   Double_t x=r/pt;
   tgl=TMath::Abs(tgl);
@@ -3109,8 +3098,9 @@ Double_t SigmaY2(Double_t r, Double_t tgl, Double_t pt)
   return s;
 }
 
-//_____________________________________________________________________________
-Double_t SigmaZ2(Double_t r, Double_t tgl) 
+
+//____________________________________________________________________________
+Double_t SigmaZ2(Double_t r, Double_t tgl)
 {
   //
   // Parametrised error of the cluster reconstruction (drift direction)
@@ -3119,7 +3109,7 @@ Double_t SigmaZ2(Double_t r, Double_t tgl)
   const Float_t kAz=0.39614e-2;
   const Float_t kBz=0.22443e-4;
   const Float_t kCz=0.51504e-1;
-  
+
 
   tgl=TMath::Abs(tgl);
   Double_t s=kAz - kBz*r*tgl + kCz*tgl*tgl;
@@ -3128,3 +3118,4 @@ Double_t SigmaZ2(Double_t r, Double_t tgl)
 
   return s;
 }
+
index 03f6e10..b30306e 100644 (file)
@@ -72,6 +72,7 @@ public:
   virtual void  Hits2Clusters(Int_t eventn=0);
   virtual void  Hits2ExactClustersSector(Int_t isec); // MI change calculate "exact" cluster position
   
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager);
   virtual void  SDigits2Digits(){;} //MI change -cycling to production
   virtual void  SDigits2Digits2(Int_t eventnumber=0);
 
@@ -79,7 +80,8 @@ public:
   virtual void  Hits2SDigits2(Int_t eventnumber=0);
 
   virtual void  Digits2Reco(Int_t firstevent=0,Int_t lastevent=0);
-  virtual void  Hits2Digits(Int_t eventnumber=0);   //MI change
+  virtual void  Hits2Digits();
+  virtual void  Hits2Digits(Int_t eventnumber);   //MI change
   virtual void  Hits2DigitsSector(Int_t isec);  //MI change
   virtual void  Init();
   virtual Int_t IsVersion() const =0;
index a8fa23b..0149069 100644 (file)
@@ -230,32 +230,25 @@ void AliTRD::Hits2Digits()
   //
   // Create digits
   //
-  if (!fLoader->TreeH()) fLoader->LoadHits("read");
-  SetTreeAddress();
-  
   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
                                                   ,"TRD digitizer class");
   digitizer->SetDebug(GetDebug());
-  digitizer->SetEvent(gAlice->GetEvNumber());
   
   // Initialization
   digitizer->InitDetector();
     
-  // Create the digits
-  digitizer->MakeDigits();
-  
-  // Write the digits into the input file
-
-  if (!fLoader->TreeD()) fLoader->MakeTree("D");
-  if (digitizer->MakeBranch(fLoader->TreeD())) {
+  if (!fLoader->TreeH()) fLoader->LoadHits("read");
+  fLoader->LoadDigits("recreate");
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
 
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    digitizer->Open(runLoader->GetFileName().Data(), iEvent);
+    digitizer->MakeDigits();
     digitizer->WriteDigits();
-
-    // Save the digitizer class in the AliROOT 
-    digitizer->Write();
-
   }
 
+  fLoader->UnloadHits();
+  fLoader->UnloadDigits();
 }
 
 //_____________________________________________________________________________
@@ -264,35 +257,33 @@ void AliTRD::Hits2SDigits()
   //
   // Create summable digits
   //
-  if (!fLoader->TreeH()) fLoader->LoadHits("read");
-  SetTreeAddress();
-
   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
                                                   ,"TRD digitizer class");
-  digitizer->SetDebug(GetDebug());
-
   // For the summable digits
   digitizer->SetSDigits(kTRUE);
-  digitizer->SetEvent(gAlice->GetEvNumber());
+  digitizer->SetDebug(GetDebug());
 
   // Initialization
   digitizer->InitDetector();
     
-  // Create the TRD s-digits branch
-  digitizer->MakeDigits();
-  
-  // Write the digits into the input file
-  if (!fLoader->TreeS()) fLoader->MakeTree("S");
-  
-  if (digitizer->MakeBranch(fLoader->TreeS())) {
+  if (!fLoader->TreeH()) fLoader->LoadHits("read");
+  fLoader->LoadSDigits("recreate");
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
 
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    digitizer->Open(runLoader->GetFileName().Data(), iEvent);
+    digitizer->MakeDigits();
     digitizer->WriteDigits();
+  }
 
-    // Save the digitizer class in the AliROOT 
-    digitizer->Write();
-
+  fLoader->UnloadHits();
+  fLoader->UnloadSDigits();
   }
 
+//_____________________________________________________________________________
+AliDigitizer* AliTRD::CreateDigitizer(AliRunDigitizer* manager)
+{
+  return new AliTRDdigitizer(manager);
 }
 
 //_____________________________________________________________________________
index d2c4b94..5ddbf32 100644 (file)
@@ -80,6 +80,7 @@ class AliTRD : public AliDetector {
  
   virtual void       Hits2Digits();
   virtual void       Hits2SDigits();
+  virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager); 
   virtual void       SDigits2Digits();
 
   virtual AliTRDsim *CreateTR()     = 0;
index 0df0e23..f440d9c 100644 (file)
@@ -81,14 +81,15 @@ AliTRDdigitizer::AliTRDdigitizer()
   // AliTRDdigitizer default constructor
   //
 
+  fRunLoader          = 0;
   fDigitsManager      = 0;
-  fSDigitsManagerList = 0;
   fSDigitsManager     = 0;
+  fSDigitsManagerList = 0;
   fTRD                = 0;
   fGeo                = 0;
   fPar                = 0;
-  fMasks              = 0;
   fEvent              = 0;
+  fMasks              = 0;
   fCompress           = kTRUE;
   fDebug              = 0;
   fSDigits            = kFALSE;
@@ -107,31 +108,26 @@ AliTRDdigitizer::AliTRDdigitizer(const Text_t *name, const Text_t *title)
   // AliTRDdigitizer constructor
   //
 
-  fDigitsManager      = NULL;
-  fSDigitsManager     = NULL;
-  fSDigitsManagerList = NULL;
-  fTRD                = NULL;
-  fGeo                = NULL;
+  fRunLoader          = 0;
 
   //NewIO: These data members probably are not needed anymore
   fDigitsManager      = 0;
-  fSDigitsManagerList = 0;
   fSDigitsManager     = 0;
+  fSDigitsManagerList = 0;
   fTRD                = 0;
   fGeo                = 0;
   fPar                = 0;
   //End NewIO comment
-  fMasks              = 0;
   fEvent              = 0;
+  fMasks              = 0;
   fCompress           = kTRUE;
   fDebug              = 0;
   fSDigits            = kFALSE;
+  fSDigitsScale       = 100.; // For the summable digits
   fMergeSignalOnly    = kFALSE;
   fSimpleSim          = kFALSE;
   fSimpleDet          = 0;
  
-  // For the summable digits
-  fSDigitsScale       = 100.;
 
 }
 
@@ -144,23 +140,23 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager
   // AliTRDdigitizer constructor
   //
 
+  fRunLoader          = 0;
   fDigitsManager      = 0;
-  fSDigitsManagerList = 0;
   fSDigitsManager     = 0;
+  fSDigitsManagerList = 0;
   fTRD                = 0;
   fGeo                = 0;
   fPar                = 0;
-  fMasks              = 0;
   fEvent              = 0;
+  fMasks              = 0;
   fCompress           = kTRUE;
   fDebug              = 0;
   fSDigits            = kFALSE;
+  fSDigitsScale       = 100.; // For the summable digits
   fMergeSignalOnly    = kFALSE;
   fSimpleSim          = kFALSE;
   fSimpleDet          = 0;
  
-  // For the summable digits
-  fSDigitsScale       = 100.;
 
 }
 
@@ -173,25 +169,23 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager)
   //
 
 
-
+  fRunLoader          = 0;
   fDigitsManager      = 0;
-  fSDigitsManagerList = 0;
   fSDigitsManager     = 0;
+  fSDigitsManagerList = 0;
   fTRD                = 0;
   fGeo                = 0;
   fPar                = 0;
-
-  fMasks              = 0;
   fEvent              = 0;
+  fMasks              = 0;
   fCompress           = kTRUE;
   fDebug              = 0;
   fSDigits            = kFALSE;
+  fSDigitsScale       = 100.;  // For the summable digits
   fMergeSignalOnly    = kFALSE;
   fSimpleSim          = kFALSE;
   fSimpleDet          = 0;
 
-  // For the summable digits
-  fSDigitsScale       = 100.;
 
 }
 
@@ -255,14 +249,15 @@ void AliTRDdigitizer::Copy(TObject &d)
   // Copy function
   //
 
-  ((AliTRDdigitizer &) d).fSDigitsManagerList = 0;
-  ((AliTRDdigitizer &) d).fSDigitsManager     = 0;
+  ((AliTRDdigitizer &) d).fRunLoader          = 0;
   ((AliTRDdigitizer &) d).fDigitsManager      = 0;
+  ((AliTRDdigitizer &) d).fSDigitsManager     = 0;
+  ((AliTRDdigitizer &) d).fSDigitsManagerList = 0;
   ((AliTRDdigitizer &) d).fTRD                = 0;
   ((AliTRDdigitizer &) d).fGeo                = 0;
-  ((AliTRDdigitizer &) d).fMasks              = 0;
-  ((AliTRDdigitizer &) d).fEvent              = 0;
   ((AliTRDdigitizer &) d).fPar                = 0;
+  ((AliTRDdigitizer &) d).fEvent              = 0;
+  ((AliTRDdigitizer &) d).fMasks              = 0;
   ((AliTRDdigitizer &) d).fCompress           = fCompress;
   ((AliTRDdigitizer &) d).fDebug              = fDebug  ;
   ((AliTRDdigitizer &) d).fSDigits            = fSDigits;
@@ -406,7 +401,7 @@ Bool_t AliTRDdigitizer::Open(const Char_t *file, Int_t nEvent)
 
   // Connect the AliRoot file containing Geometry, Kine, and Hits
   
-  fRunLoader = AliRunLoader::Open(file,AliConfig::fgkDefaultEventFolderName,"UPDATE");
+  fRunLoader = AliRunLoader::Open(file,AliConfig::fgkDefaultEventFolderName);
   
   if (!fRunLoader)
    {
index d5915bd..90c8c5c 100644 (file)
@@ -325,6 +325,15 @@ void AliZDC::Hits2SDigits()
 {
   printf("\n   Entering AliZDC::SDigits2Digits() ");
   
+  fLoader->LoadHits("read");
+  fLoader->LoadSDigits("recreate");
+  AliRunLoader* runLoader = fLoader->GetRunLoader(); 
+
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    runLoader->GetEvent(iEvent);
+    if (!fLoader->TreeS()) fLoader->MakeTree("S");
+    MakeBranch("S");
+
   //----------------------------------------------------------------
   if(!fMerger){ 
     printf("   ZDC digitization (without merging)\n");
@@ -361,9 +370,9 @@ void AliZDC::Hits2SDigits()
          fNMergedhits++;
          delete MHit;
     }
-    gAlice->TreeS()->Fill();
-    gAlice->TreeS()->AutoSave(); 
-    gAlice->TreeS()->Reset();  
+      fLoader->TreeS()->Fill();
+      fLoader->TreeS()->AutoSave(); 
+      fLoader->TreeS()->Reset();  
   }
   //----------------------------------------------------------------
   else if(fMerger){
@@ -415,6 +424,10 @@ void AliZDC::Hits2SDigits()
     treeS->AutoSave();
   }
   
+  }
+
+  fLoader->UnloadHits();
+  fLoader->UnloadSDigits();
 }
 
 //_____________________________________________________________________________