TGenerator

Class Description

                                                                      
 TGenerator                                                           
                                                                      
 Is an base class, that defines the interface of ROOT to various   	
 event generators. Every event generator should inherit from       	
 TGenerator or its subclasses.                                        
                                                                      
 Derived class can overload the member  function GenerateEvent        
 to do the actual event generation (e.g., call PYEVNT or similar).    
                                                                      
 The derived class should overload the member function                
 ImportParticles (both types) to read the internal storage of the     
 generated event into either the internal TObjArray or the passed     
 TClonesArray of TParticles.                                          
                                                                      
 If the generator code stores event data in the /HEPEVT/ common block 
 Then the default implementation of ImportParticles should suffice.   
 The common block /HEPEVT/ is structed like                           
                                                                      
   /* C */                                                            
   typedef struct {                                                   
      Int_t    nevhep;           // Event number                      
      Int_t    nhep;             // # of particles                    
      Int_t    isthep[4000];     // Status flag of i'th particle      
      Int_t    idhep[4000];      // PDG # of particle                 
      Int_t    jmohep[4000][2];  // 1st & 2nd mother particle #	      
      Int_t    jdahep[4000][2];  // 1st & 2nd daughter particle #     
      Double_t phep[4000][5];    // 4-momentum and 1 word             
      Double_t vhep[4000][4];    // 4-position of production          
   } HEPEVT_DEF;                                                      
                                                                      
                                                                      
   C Fortran                                                          
         COMMON/HEPEVT/NEVHEP,NHEP,ISTHEP(4000),IDHEP(4000),          
       +    JMOHEP(2,4000),JDAHEP(2,4000),PHEP(5,4000),VHEP(4,4000)   
         INTEGER NEVHEP,NHEP,ISTHEP,IDHEP,JMOHEP,JDAHEP               
         DOUBLE PRECISION PHEP,VHEP                                   
                                                                      
 The generic member functions SetParameter and GetParameter can be    
 overloaded to set and get parameters of the event generator.         
                                                                      
 Note, if the derived class interfaces a (set of) Fortran common      
 blocks (like TPythia, TVenus does), one better make the derived      
 class a singleton.  That is, something like                          
                                                                      
     class MyGenerator : public TGenerator                            
     {                                                                
     public:                                                          
       static MyGenerator* Instance()                                 
       {                                                              
         if (!fgInstance) fgInstance = new MyGenerator;               
         return fgInstance;                                           
       }                                                              
       void  GenerateEvent() { ... }                                  
       void  ImportParticles(TClonesArray* a, Option_t opt="") {...}  
       Int_t ImportParticles(Option_t opt="") { ... }                 
       Int_t    SetParameter(const char* name, Double_t val) { ... }  
       Double_t GetParameter(const char* name) { ... }                
       virtual ~MyGenerator() { ... }                                 
     protected:                                                       
       MyGenerator() { ... }                                          
       MyGenerator(const MyGenerator& o) { ... }                      
       MyGenerator& operator=(const MyGenerator& o) { ... }           
       static MyGenerator* fgInstance;                                
       ClassDef(MyGenerator,0);                                       
     };                                                               
                                                                      
 Having multiple objects accessing the same common blocks is not      
 safe.                                                                
                                                                      
 concrete TGenerator classes can be loaded in scripts and subseqent-  
 ly used in compiled code:                                            
                                                                      
     // MyRun.h                                                       
     class MyRun : public TObject                                     
     {                                                                
     public:                                                          
       static MyRun* Instance() { ... }                               
       void SetGenerator(TGenerator* g) { fGenerator = g; }           
       void Run(Int_t n, Option_t* option="")                         
       {                                                              
         TFile*        file = TFile::Open("file.root","RECREATE");    
         TTree*        tree = new TTree("T","T");                     
         TClonesArray* p    = new TClonesArray("TParticles");         
         tree->Branch("particles", &p);                               
         for (Int_t event = 0; event < n; event++) {                  
           fGenerator->GenerateEvent();                               
           fGenerator->ImportParticles(p,option);                     
           tree->Fill();                                              
         }                                                            
         file->Write();                                               
         file->Close();                                               
       }                                                              
       ...                                                            
     protected:                                                       
       TGenerator* fGenerator;                                        
       ClassDef(MyRun,0);                                             
     };                                                               
                                                                      
     // Config.C                                                      
     void Config()                                                    
     {                                                                
        MyRun* run = MyRun::Instance();                               
        run->SetGenerator(MyGenerator::Instance());                   
     }                                                                
                                                                      
     // main.cxx                                                      
     int                                                              
     main(int argc, char** argv)                                      
     {                                                                
       TApplication app("", 0, 0);                                    
       gSystem->ProcessLine(".x Config.C");                           
       MyRun::Instance()->Run(10);                                    
       return 0;                                                      
     }                                                                
                                                                      
 This is especially useful for example with TVirtualMC or similar.