ROOT logo
// @(#)root/eg:$Id$
// Author: Ola Nordmann   21/09/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// 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.    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TROOT.h"
#include "TGenerator.h"
#include "TDatabasePDG.h"
#include "TParticlePDG.h"
#include "TParticle.h"
#include "TObjArray.h"
#include "Hepevt.h"
#include "TVirtualPad.h"
#include "TView.h"
#include "TText.h"
#include "TPaveText.h"
#include "TClonesArray.h"
#include "Riostream.h"


ClassImp(TGenerator)

//______________________________________________________________________________
TGenerator::TGenerator(const char *name,const char *title): TNamed(name,title)
{
//  Event generator default constructor
//

   //  Initialize particles table
   TDatabasePDG::Instance();
   //TDatabasePDG *pdg = TDatabasePDG::Instance();
   //if (!pdg->ParticleList()) pdg->Init();

   fPtCut        = 0;
   fShowNeutrons = kTRUE;
   fParticles    =  new TObjArray(10000);
}

//______________________________________________________________________________
TGenerator::~TGenerator()
{
//  Event generator default destructor
//

   //do nothing
   if (fParticles) {
      fParticles->Delete();
      delete fParticles;
      fParticles = 0;
   }
}

//______________________________________________________________________________
void TGenerator::GenerateEvent()
{
  // must be implemented in concrete class (see eg TPythia6)
}

//______________________________________________________________________________
TObjArray* TGenerator::ImportParticles(Option_t *option)
{
//
//  It reads the /HEPEVT/ common block which has been filled by the
//  GenerateEvent method. If the event generator does not use the
//  HEPEVT common block, This routine has to be overloaded by the
//  subclasses.
//
//  The default action is to store only the stable particles (ISTHEP =
//  1) This can be demanded explicitly by setting the option = "Final"
//  If the option = "All", all the particles are stored.
//
   fParticles->Clear();
   Int_t numpart = HEPEVT.nhep;
   if (!strcmp(option,"") || !strcmp(option,"Final")) {
      for (Int_t i = 0; i<numpart; i++) {
         if (HEPEVT.isthep[i] == 1) {
//
//  Use the common block values for the TParticle constructor
//
            TParticle *p = new TParticle(
                                   HEPEVT.idhep[i],
                                   HEPEVT.isthep[i],
                                   HEPEVT.jmohep[i][0]-1,
                                   HEPEVT.jmohep[i][1]-1,
                                   HEPEVT.jdahep[i][0]-1,
                                   HEPEVT.jdahep[i][1]-1,
                                   HEPEVT.phep[i][0],
                                   HEPEVT.phep[i][1],
                                   HEPEVT.phep[i][2],
                                   HEPEVT.phep[i][3],
                                   HEPEVT.vhep[i][0],
                                   HEPEVT.vhep[i][1],
                                   HEPEVT.vhep[i][2],
                                   HEPEVT.vhep[i][3]);
            fParticles->Add(p);
         }
      }
   } else if (!strcmp(option,"All")) {
      for (Int_t i = 0; i<numpart; i++) {
         TParticle *p = new TParticle(
                                   HEPEVT.idhep[i],
                                   HEPEVT.isthep[i],
                                   HEPEVT.jmohep[i][0]-1,
                                   HEPEVT.jmohep[i][1]-1,
                                   HEPEVT.jdahep[i][0]-1,
                                   HEPEVT.jdahep[i][1]-1,
                                   HEPEVT.phep[i][0],
                                   HEPEVT.phep[i][1],
                                   HEPEVT.phep[i][2],
                                   HEPEVT.phep[i][3],
                                   HEPEVT.vhep[i][0],
                                   HEPEVT.vhep[i][1],
                                   HEPEVT.vhep[i][2],
                                   HEPEVT.vhep[i][3]);
         fParticles->Add(p);
      }
   }
   return fParticles;
}

//______________________________________________________________________________
Int_t TGenerator::ImportParticles(TClonesArray *particles, Option_t *option)
{
//
//  It reads the /HEPEVT/ common block which has been filled by the
//  GenerateEvent method. If the event generator does not use the
//  HEPEVT common block, This routine has to be overloaded by the
//  subclasses.
//
//  The function loops on the generated particles and store them in
//  the TClonesArray pointed by the argument particles.  The default
//  action is to store only the stable particles (ISTHEP = 1) This can
//  be demanded explicitly by setting the option = "Final" If the
//  option = "All", all the particles are stored.
//
   if (particles == 0) return 0;
   TClonesArray &clonesParticles = *particles;
   clonesParticles.Clear();
   Int_t numpart = HEPEVT.nhep;
   if (!strcmp(option,"") || !strcmp(option,"Final")) {
      for (Int_t i = 0; i<numpart; i++) {
         if (HEPEVT.isthep[i] == 1) {
//
//  Use the common block values for the TParticle constructor
//
            new(clonesParticles[i]) TParticle(
                                   HEPEVT.idhep[i],
                                   HEPEVT.isthep[i],
                                   HEPEVT.jmohep[i][0]-1,
                                   HEPEVT.jmohep[i][1]-1,
                                   HEPEVT.jdahep[i][0]-1,
                                   HEPEVT.jdahep[i][1]-1,
                                   HEPEVT.phep[i][0],
                                   HEPEVT.phep[i][1],
                                   HEPEVT.phep[i][2],
                                   HEPEVT.phep[i][3],
                                   HEPEVT.vhep[i][0],
                                   HEPEVT.vhep[i][1],
                                   HEPEVT.vhep[i][2],
                                   HEPEVT.vhep[i][3]);
         }
      }
   } else if (!strcmp(option,"All")) {
      for (Int_t i = 0; i<numpart; i++) {
         new(clonesParticles[i]) TParticle(
                                   HEPEVT.idhep[i],
                                   HEPEVT.isthep[i],
                                   HEPEVT.jmohep[i][0]-1,
                                   HEPEVT.jmohep[i][1]-1,
                                   HEPEVT.jdahep[i][0]-1,
                                   HEPEVT.jdahep[i][1]-1,
                                   HEPEVT.phep[i][0],
                                   HEPEVT.phep[i][1],
                                   HEPEVT.phep[i][2],
                                   HEPEVT.phep[i][3],
                                   HEPEVT.vhep[i][0],
                                   HEPEVT.vhep[i][1],
                                   HEPEVT.vhep[i][2],
                                   HEPEVT.vhep[i][3]);
      }
   }
   return numpart;
}

//______________________________________________________________________________
void TGenerator::Browse(TBrowser *)
{
   //browse generator
   Draw();
   gPad->Update();
}

//______________________________________________________________________________
Int_t TGenerator::DistancetoPrimitive(Int_t px, Int_t py)
{
//*-*-*-*-*-*-*-*Compute distance from point px,py to objects in event*-*-*-*
//*-*            =====================================================
//*-*

   const Int_t big = 9999;
   const Int_t inview = 0;
   Int_t dist = big;
   if (px > 50 && py > 50) dist = inview;
   return dist;
}

//______________________________________________________________________________
void TGenerator::Draw(Option_t *option)
{
//
//  Insert one event in the pad list
//

   // Create a default canvas if a canvas does not exist
   if (!gPad) {
      gROOT->MakeDefCanvas();
      if (gPad->GetVirtCanvas())
         gPad->GetVirtCanvas()->SetFillColor(13);
   }

   static Float_t rbox = 1000;
   Float_t rmin[3],rmax[3];
   TView *view = gPad->GetView();
   if (!strstr(option,"same")) {
      if (view) { view->GetRange(rmin,rmax); rbox = rmax[2];}
      gPad->Clear();
   }

   AppendPad(option);

   view = gPad->GetView();
   //    compute 3D view
   if (view) {
      view->GetRange(rmin,rmax);
      rbox = rmax[2];
   } else {
      view = TView::CreateView(1,0,0);
      if (view) view->SetRange(-rbox,-rbox,-rbox, rbox,rbox,rbox );
   }
   const Int_t kColorProton    = 4;
   const Int_t kColorNeutron   = 5;
   const Int_t kColorAntiProton= 3;
   const Int_t kColorPionPlus  = 6;
   const Int_t kColorPionMinus = 2;
   const Int_t kColorKaons     = 7;
   const Int_t kColorElectrons = 0;
   const Int_t kColorGamma     = 18;

   Int_t nProtons    = 0;
   Int_t nNeutrons   = 0;
   Int_t nAntiProtons= 0;
   Int_t nPionPlus   = 0;
   Int_t nPionMinus  = 0;
   Int_t nKaons      = 0;
   Int_t nElectrons  = 0;
   Int_t nGammas     = 0;

   Int_t ntracks = fParticles->GetEntriesFast();
   Int_t i,lwidth,color,lstyle;
   TParticlePDG *ap;
   TParticle *p;
   const char *name;
   Double_t etot,vx,vy,vz;
   Int_t ninvol = 0;
   for (i=0;i<ntracks;i++) {
      p = (TParticle*)fParticles->UncheckedAt(i);
      if(!p) continue;
      ap = (TParticlePDG*)p->GetPDG();
      vx = p->Vx();
      vy = p->Vy();
      vz = p->Vz();
      if  (vx*vx+vy*vy+vz*vz > rbox*rbox) continue;
      Float_t pt = p->Pt();
      if (pt < fPtCut) continue;
      etot = p->Energy();
      if (etot > 0.1) lwidth = Int_t(6*TMath::Log10(etot));
      else lwidth = 1;
      if (lwidth < 1) lwidth = 1;
      lstyle = 1;
      color = 0;
      name = ap->GetName();
      if (!strcmp(name,"n"))     { if (!fShowNeutrons) continue;
                                   color = kColorNeutron;    nNeutrons++;}
      if (!strcmp(name,"p"))     { color = kColorProton;     nProtons++;}
      if (!strcmp(name,"p bar")) { color = kColorAntiProton; nAntiProtons++;}
      if (!strcmp(name,"pi+"))   { color = kColorPionPlus;   nPionPlus++;}
      if (!strcmp(name,"pi-"))   { color = kColorPionMinus;  nPionMinus++;}
      if (!strcmp(name,"e+"))    { color = kColorElectrons;  nElectrons++;}
      if (!strcmp(name,"e-"))    { color = kColorElectrons;  nElectrons++;}
      if (!strcmp(name,"gamma")) { color = kColorGamma;      nGammas++; lstyle = 3; }
      if ( strstr(name,"K"))     { color = kColorKaons;      nKaons++;}
      p->SetLineColor(color);
      p->SetLineStyle(lstyle);
      p->SetLineWidth(lwidth);
      p->AppendPad();
      ninvol++;
   }

   // event title
   TPaveText *pt = new TPaveText(-0.94,0.85,-0.25,0.98,"br");
   pt->AddText((char*)GetName());
   pt->AddText((char*)GetTitle());
   pt->SetFillColor(42);
   pt->Draw();

   // Annotate color codes
   Int_t tcolor = 5;
   if (gPad->GetFillColor() == 10) tcolor = 4;
   TText *text = new TText(-0.95,-0.47,"Particles");
   text->SetTextAlign(12);
   text->SetTextSize(0.025);
   text->SetTextColor(tcolor);
   text->Draw();
   text->SetTextColor(kColorGamma);      text->DrawText(-0.95,-0.52,"(on screen)");
   text->SetTextColor(kColorGamma);      text->DrawText(-0.95,-0.57,"Gamma");
   text->SetTextColor(kColorProton);     text->DrawText(-0.95,-0.62,"Proton");
   text->SetTextColor(kColorNeutron);    text->DrawText(-0.95,-0.67,"Neutron");
   text->SetTextColor(kColorAntiProton); text->DrawText(-0.95,-0.72,"AntiProton");
   text->SetTextColor(kColorPionPlus);   text->DrawText(-0.95,-0.77,"Pion +");
   text->SetTextColor(kColorPionMinus);  text->DrawText(-0.95,-0.82,"Pion -");
   text->SetTextColor(kColorKaons);      text->DrawText(-0.95,-0.87,"Kaons");
   text->SetTextColor(kColorElectrons);  text->DrawText(-0.95,-0.92,"Electrons,etc.");

   text->SetTextColor(tcolor);
   text->SetTextAlign(32);
   char tcount[32];
   snprintf(tcount,12,"%d",ntracks);      text->DrawText(-0.55,-0.47,tcount);
   snprintf(tcount,12,"%d",ninvol);       text->DrawText(-0.55,-0.52,tcount);
   snprintf(tcount,12,"%d",nGammas);      text->DrawText(-0.55,-0.57,tcount);
   snprintf(tcount,12,"%d",nProtons);     text->DrawText(-0.55,-0.62,tcount);
   snprintf(tcount,12,"%d",nNeutrons);    text->DrawText(-0.55,-0.67,tcount);
   snprintf(tcount,12,"%d",nAntiProtons); text->DrawText(-0.55,-0.72,tcount);
   snprintf(tcount,12,"%d",nPionPlus);    text->DrawText(-0.55,-0.77,tcount);
   snprintf(tcount,12,"%d",nPionMinus);   text->DrawText(-0.55,-0.82,tcount);
   snprintf(tcount,12,"%d",nKaons);       text->DrawText(-0.55,-0.87,tcount);
   snprintf(tcount,12,"%d",nElectrons);   text->DrawText(-0.55,-0.92,tcount);

   text->SetTextAlign(12);
   if (nPionPlus+nPionMinus) {
      snprintf(tcount,31,"Protons/Pions= %4f",Float_t(nProtons)/Float_t(nPionPlus+nPionMinus));
   } else {
      strlcpy(tcount,"Protons/Pions= inf",31);
   }
   text->DrawText(-0.45,-0.92,tcount);

   if (nPionPlus+nPionMinus) {
      snprintf(tcount,12,"Kaons/Pions= %4f",Float_t(nKaons)/Float_t(nPionPlus+nPionMinus));
   } else {
      strlcpy(tcount,"Kaons/Pions= inf",31);
   }
   text->DrawText(0.30,-0.92,tcount);
}


//______________________________________________________________________________
void TGenerator::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
//*-*-*-*-*-*-*-*-*-*-*Execute action corresponding to one event*-*-*-*
//*-*                  =========================================

   if (gPad->GetView()) {
      gPad->GetView()->ExecuteRotateView(event, px, py);
      return;
   }
}

//______________________________________________________________________________
Int_t TGenerator::GetNumberOfParticles() const
{
   // Return the number of particles in the stack
   
   return fParticles->GetLast()+1;
}

//______________________________________________________________________________
TParticle *TGenerator::GetParticle(Int_t i) const
{
//  Returns pointer to primary number i;
//

   if (!fParticles) return 0;
   Int_t n = fParticles->GetLast();
   if (i < 0 || i > n) return 0;
   return (TParticle*)fParticles->UncheckedAt(i);
}

//______________________________________________________________________________
void TGenerator::Paint(Option_t *)
{
//
//  Paint one event
//

}

//______________________________________________________________________________
void TGenerator::SetPtCut(Float_t ptcut)
{
//
//  Set Pt threshold below which primaries are not drawn
//
   fPtCut = ptcut;
   Draw();
   gPad->Update();
}

//______________________________________________________________________________
void TGenerator::SetViewRadius(Float_t rbox)
{
//
//  Set lower and upper values of the view range
//
   SetViewRange(-rbox,-rbox,-rbox,rbox,rbox,rbox);
}

//______________________________________________________________________________
void TGenerator::SetViewRange(Float_t xmin, Float_t ymin, Float_t zmin, Float_t xmax, Float_t ymax, Float_t zmax)
{
//
//  Set lower and upper values of the view range
//
   TView *view = gPad->GetView();
   if (!view) return;
   view->SetRange(xmin,ymin,zmin,xmax,ymax,zmax);

   Draw();
   gPad->Update();
}

//______________________________________________________________________________
void TGenerator::ShowNeutrons(Bool_t show)
{
//
//  Set flag to display or not neutrons
//
   fShowNeutrons = show;
   Draw();
   gPad->Update();
}
 TGenerator.cxx:1
 TGenerator.cxx:2
 TGenerator.cxx:3
 TGenerator.cxx:4
 TGenerator.cxx:5
 TGenerator.cxx:6
 TGenerator.cxx:7
 TGenerator.cxx:8
 TGenerator.cxx:9
 TGenerator.cxx:10
 TGenerator.cxx:11
 TGenerator.cxx:12
 TGenerator.cxx:13
 TGenerator.cxx:14
 TGenerator.cxx:15
 TGenerator.cxx:16
 TGenerator.cxx:17
 TGenerator.cxx:18
 TGenerator.cxx:19
 TGenerator.cxx:20
 TGenerator.cxx:21
 TGenerator.cxx:22
 TGenerator.cxx:23
 TGenerator.cxx:24
 TGenerator.cxx:25
 TGenerator.cxx:26
 TGenerator.cxx:27
 TGenerator.cxx:28
 TGenerator.cxx:29
 TGenerator.cxx:30
 TGenerator.cxx:31
 TGenerator.cxx:32
 TGenerator.cxx:33
 TGenerator.cxx:34
 TGenerator.cxx:35
 TGenerator.cxx:36
 TGenerator.cxx:37
 TGenerator.cxx:38
 TGenerator.cxx:39
 TGenerator.cxx:40
 TGenerator.cxx:41
 TGenerator.cxx:42
 TGenerator.cxx:43
 TGenerator.cxx:44
 TGenerator.cxx:45
 TGenerator.cxx:46
 TGenerator.cxx:47
 TGenerator.cxx:48
 TGenerator.cxx:49
 TGenerator.cxx:50
 TGenerator.cxx:51
 TGenerator.cxx:52
 TGenerator.cxx:53
 TGenerator.cxx:54
 TGenerator.cxx:55
 TGenerator.cxx:56
 TGenerator.cxx:57
 TGenerator.cxx:58
 TGenerator.cxx:59
 TGenerator.cxx:60
 TGenerator.cxx:61
 TGenerator.cxx:62
 TGenerator.cxx:63
 TGenerator.cxx:64
 TGenerator.cxx:65
 TGenerator.cxx:66
 TGenerator.cxx:67
 TGenerator.cxx:68
 TGenerator.cxx:69
 TGenerator.cxx:70
 TGenerator.cxx:71
 TGenerator.cxx:72
 TGenerator.cxx:73
 TGenerator.cxx:74
 TGenerator.cxx:75
 TGenerator.cxx:76
 TGenerator.cxx:77
 TGenerator.cxx:78
 TGenerator.cxx:79
 TGenerator.cxx:80
 TGenerator.cxx:81
 TGenerator.cxx:82
 TGenerator.cxx:83
 TGenerator.cxx:84
 TGenerator.cxx:85
 TGenerator.cxx:86
 TGenerator.cxx:87
 TGenerator.cxx:88
 TGenerator.cxx:89
 TGenerator.cxx:90
 TGenerator.cxx:91
 TGenerator.cxx:92
 TGenerator.cxx:93
 TGenerator.cxx:94
 TGenerator.cxx:95
 TGenerator.cxx:96
 TGenerator.cxx:97
 TGenerator.cxx:98
 TGenerator.cxx:99
 TGenerator.cxx:100
 TGenerator.cxx:101
 TGenerator.cxx:102
 TGenerator.cxx:103
 TGenerator.cxx:104
 TGenerator.cxx:105
 TGenerator.cxx:106
 TGenerator.cxx:107
 TGenerator.cxx:108
 TGenerator.cxx:109
 TGenerator.cxx:110
 TGenerator.cxx:111
 TGenerator.cxx:112
 TGenerator.cxx:113
 TGenerator.cxx:114
 TGenerator.cxx:115
 TGenerator.cxx:116
 TGenerator.cxx:117
 TGenerator.cxx:118
 TGenerator.cxx:119
 TGenerator.cxx:120
 TGenerator.cxx:121
 TGenerator.cxx:122
 TGenerator.cxx:123
 TGenerator.cxx:124
 TGenerator.cxx:125
 TGenerator.cxx:126
 TGenerator.cxx:127
 TGenerator.cxx:128
 TGenerator.cxx:129
 TGenerator.cxx:130
 TGenerator.cxx:131
 TGenerator.cxx:132
 TGenerator.cxx:133
 TGenerator.cxx:134
 TGenerator.cxx:135
 TGenerator.cxx:136
 TGenerator.cxx:137
 TGenerator.cxx:138
 TGenerator.cxx:139
 TGenerator.cxx:140
 TGenerator.cxx:141
 TGenerator.cxx:142
 TGenerator.cxx:143
 TGenerator.cxx:144
 TGenerator.cxx:145
 TGenerator.cxx:146
 TGenerator.cxx:147
 TGenerator.cxx:148
 TGenerator.cxx:149
 TGenerator.cxx:150
 TGenerator.cxx:151
 TGenerator.cxx:152
 TGenerator.cxx:153
 TGenerator.cxx:154
 TGenerator.cxx:155
 TGenerator.cxx:156
 TGenerator.cxx:157
 TGenerator.cxx:158
 TGenerator.cxx:159
 TGenerator.cxx:160
 TGenerator.cxx:161
 TGenerator.cxx:162
 TGenerator.cxx:163
 TGenerator.cxx:164
 TGenerator.cxx:165
 TGenerator.cxx:166
 TGenerator.cxx:167
 TGenerator.cxx:168
 TGenerator.cxx:169
 TGenerator.cxx:170
 TGenerator.cxx:171
 TGenerator.cxx:172
 TGenerator.cxx:173
 TGenerator.cxx:174
 TGenerator.cxx:175
 TGenerator.cxx:176
 TGenerator.cxx:177
 TGenerator.cxx:178
 TGenerator.cxx:179
 TGenerator.cxx:180
 TGenerator.cxx:181
 TGenerator.cxx:182
 TGenerator.cxx:183
 TGenerator.cxx:184
 TGenerator.cxx:185
 TGenerator.cxx:186
 TGenerator.cxx:187
 TGenerator.cxx:188
 TGenerator.cxx:189
 TGenerator.cxx:190
 TGenerator.cxx:191
 TGenerator.cxx:192
 TGenerator.cxx:193
 TGenerator.cxx:194
 TGenerator.cxx:195
 TGenerator.cxx:196
 TGenerator.cxx:197
 TGenerator.cxx:198
 TGenerator.cxx:199
 TGenerator.cxx:200
 TGenerator.cxx:201
 TGenerator.cxx:202
 TGenerator.cxx:203
 TGenerator.cxx:204
 TGenerator.cxx:205
 TGenerator.cxx:206
 TGenerator.cxx:207
 TGenerator.cxx:208
 TGenerator.cxx:209
 TGenerator.cxx:210
 TGenerator.cxx:211
 TGenerator.cxx:212
 TGenerator.cxx:213
 TGenerator.cxx:214
 TGenerator.cxx:215
 TGenerator.cxx:216
 TGenerator.cxx:217
 TGenerator.cxx:218
 TGenerator.cxx:219
 TGenerator.cxx:220
 TGenerator.cxx:221
 TGenerator.cxx:222
 TGenerator.cxx:223
 TGenerator.cxx:224
 TGenerator.cxx:225
 TGenerator.cxx:226
 TGenerator.cxx:227
 TGenerator.cxx:228
 TGenerator.cxx:229
 TGenerator.cxx:230
 TGenerator.cxx:231
 TGenerator.cxx:232
 TGenerator.cxx:233
 TGenerator.cxx:234
 TGenerator.cxx:235
 TGenerator.cxx:236
 TGenerator.cxx:237
 TGenerator.cxx:238
 TGenerator.cxx:239
 TGenerator.cxx:240
 TGenerator.cxx:241
 TGenerator.cxx:242
 TGenerator.cxx:243
 TGenerator.cxx:244
 TGenerator.cxx:245
 TGenerator.cxx:246
 TGenerator.cxx:247
 TGenerator.cxx:248
 TGenerator.cxx:249
 TGenerator.cxx:250
 TGenerator.cxx:251
 TGenerator.cxx:252
 TGenerator.cxx:253
 TGenerator.cxx:254
 TGenerator.cxx:255
 TGenerator.cxx:256
 TGenerator.cxx:257
 TGenerator.cxx:258
 TGenerator.cxx:259
 TGenerator.cxx:260
 TGenerator.cxx:261
 TGenerator.cxx:262
 TGenerator.cxx:263
 TGenerator.cxx:264
 TGenerator.cxx:265
 TGenerator.cxx:266
 TGenerator.cxx:267
 TGenerator.cxx:268
 TGenerator.cxx:269
 TGenerator.cxx:270
 TGenerator.cxx:271
 TGenerator.cxx:272
 TGenerator.cxx:273
 TGenerator.cxx:274
 TGenerator.cxx:275
 TGenerator.cxx:276
 TGenerator.cxx:277
 TGenerator.cxx:278
 TGenerator.cxx:279
 TGenerator.cxx:280
 TGenerator.cxx:281
 TGenerator.cxx:282
 TGenerator.cxx:283
 TGenerator.cxx:284
 TGenerator.cxx:285
 TGenerator.cxx:286
 TGenerator.cxx:287
 TGenerator.cxx:288
 TGenerator.cxx:289
 TGenerator.cxx:290
 TGenerator.cxx:291
 TGenerator.cxx:292
 TGenerator.cxx:293
 TGenerator.cxx:294
 TGenerator.cxx:295
 TGenerator.cxx:296
 TGenerator.cxx:297
 TGenerator.cxx:298
 TGenerator.cxx:299
 TGenerator.cxx:300
 TGenerator.cxx:301
 TGenerator.cxx:302
 TGenerator.cxx:303
 TGenerator.cxx:304
 TGenerator.cxx:305
 TGenerator.cxx:306
 TGenerator.cxx:307
 TGenerator.cxx:308
 TGenerator.cxx:309
 TGenerator.cxx:310
 TGenerator.cxx:311
 TGenerator.cxx:312
 TGenerator.cxx:313
 TGenerator.cxx:314
 TGenerator.cxx:315
 TGenerator.cxx:316
 TGenerator.cxx:317
 TGenerator.cxx:318
 TGenerator.cxx:319
 TGenerator.cxx:320
 TGenerator.cxx:321
 TGenerator.cxx:322
 TGenerator.cxx:323
 TGenerator.cxx:324
 TGenerator.cxx:325
 TGenerator.cxx:326
 TGenerator.cxx:327
 TGenerator.cxx:328
 TGenerator.cxx:329
 TGenerator.cxx:330
 TGenerator.cxx:331
 TGenerator.cxx:332
 TGenerator.cxx:333
 TGenerator.cxx:334
 TGenerator.cxx:335
 TGenerator.cxx:336
 TGenerator.cxx:337
 TGenerator.cxx:338
 TGenerator.cxx:339
 TGenerator.cxx:340
 TGenerator.cxx:341
 TGenerator.cxx:342
 TGenerator.cxx:343
 TGenerator.cxx:344
 TGenerator.cxx:345
 TGenerator.cxx:346
 TGenerator.cxx:347
 TGenerator.cxx:348
 TGenerator.cxx:349
 TGenerator.cxx:350
 TGenerator.cxx:351
 TGenerator.cxx:352
 TGenerator.cxx:353
 TGenerator.cxx:354
 TGenerator.cxx:355
 TGenerator.cxx:356
 TGenerator.cxx:357
 TGenerator.cxx:358
 TGenerator.cxx:359
 TGenerator.cxx:360
 TGenerator.cxx:361
 TGenerator.cxx:362
 TGenerator.cxx:363
 TGenerator.cxx:364
 TGenerator.cxx:365
 TGenerator.cxx:366
 TGenerator.cxx:367
 TGenerator.cxx:368
 TGenerator.cxx:369
 TGenerator.cxx:370
 TGenerator.cxx:371
 TGenerator.cxx:372
 TGenerator.cxx:373
 TGenerator.cxx:374
 TGenerator.cxx:375
 TGenerator.cxx:376
 TGenerator.cxx:377
 TGenerator.cxx:378
 TGenerator.cxx:379
 TGenerator.cxx:380
 TGenerator.cxx:381
 TGenerator.cxx:382
 TGenerator.cxx:383
 TGenerator.cxx:384
 TGenerator.cxx:385
 TGenerator.cxx:386
 TGenerator.cxx:387
 TGenerator.cxx:388
 TGenerator.cxx:389
 TGenerator.cxx:390
 TGenerator.cxx:391
 TGenerator.cxx:392
 TGenerator.cxx:393
 TGenerator.cxx:394
 TGenerator.cxx:395
 TGenerator.cxx:396
 TGenerator.cxx:397
 TGenerator.cxx:398
 TGenerator.cxx:399
 TGenerator.cxx:400
 TGenerator.cxx:401
 TGenerator.cxx:402
 TGenerator.cxx:403
 TGenerator.cxx:404
 TGenerator.cxx:405
 TGenerator.cxx:406
 TGenerator.cxx:407
 TGenerator.cxx:408
 TGenerator.cxx:409
 TGenerator.cxx:410
 TGenerator.cxx:411
 TGenerator.cxx:412
 TGenerator.cxx:413
 TGenerator.cxx:414
 TGenerator.cxx:415
 TGenerator.cxx:416
 TGenerator.cxx:417
 TGenerator.cxx:418
 TGenerator.cxx:419
 TGenerator.cxx:420
 TGenerator.cxx:421
 TGenerator.cxx:422
 TGenerator.cxx:423
 TGenerator.cxx:424
 TGenerator.cxx:425
 TGenerator.cxx:426
 TGenerator.cxx:427
 TGenerator.cxx:428
 TGenerator.cxx:429
 TGenerator.cxx:430
 TGenerator.cxx:431
 TGenerator.cxx:432
 TGenerator.cxx:433
 TGenerator.cxx:434
 TGenerator.cxx:435
 TGenerator.cxx:436
 TGenerator.cxx:437
 TGenerator.cxx:438
 TGenerator.cxx:439
 TGenerator.cxx:440
 TGenerator.cxx:441
 TGenerator.cxx:442
 TGenerator.cxx:443
 TGenerator.cxx:444
 TGenerator.cxx:445
 TGenerator.cxx:446
 TGenerator.cxx:447
 TGenerator.cxx:448
 TGenerator.cxx:449
 TGenerator.cxx:450
 TGenerator.cxx:451
 TGenerator.cxx:452
 TGenerator.cxx:453
 TGenerator.cxx:454
 TGenerator.cxx:455
 TGenerator.cxx:456
 TGenerator.cxx:457
 TGenerator.cxx:458
 TGenerator.cxx:459
 TGenerator.cxx:460
 TGenerator.cxx:461
 TGenerator.cxx:462
 TGenerator.cxx:463
 TGenerator.cxx:464
 TGenerator.cxx:465
 TGenerator.cxx:466
 TGenerator.cxx:467
 TGenerator.cxx:468
 TGenerator.cxx:469
 TGenerator.cxx:470
 TGenerator.cxx:471
 TGenerator.cxx:472
 TGenerator.cxx:473
 TGenerator.cxx:474
 TGenerator.cxx:475
 TGenerator.cxx:476
 TGenerator.cxx:477
 TGenerator.cxx:478
 TGenerator.cxx:479
 TGenerator.cxx:480
 TGenerator.cxx:481
 TGenerator.cxx:482
 TGenerator.cxx:483
 TGenerator.cxx:484
 TGenerator.cxx:485
 TGenerator.cxx:486
 TGenerator.cxx:487
 TGenerator.cxx:488
 TGenerator.cxx:489
 TGenerator.cxx:490
 TGenerator.cxx:491
 TGenerator.cxx:492
 TGenerator.cxx:493
 TGenerator.cxx:494
 TGenerator.cxx:495
 TGenerator.cxx:496
 TGenerator.cxx:497
 TGenerator.cxx:498
 TGenerator.cxx:499
 TGenerator.cxx:500
 TGenerator.cxx:501
 TGenerator.cxx:502
 TGenerator.cxx:503
 TGenerator.cxx:504
 TGenerator.cxx:505
 TGenerator.cxx:506
 TGenerator.cxx:507
 TGenerator.cxx:508
 TGenerator.cxx:509
 TGenerator.cxx:510
 TGenerator.cxx:511
 TGenerator.cxx:512
 TGenerator.cxx:513
 TGenerator.cxx:514
 TGenerator.cxx:515
 TGenerator.cxx:516
 TGenerator.cxx:517
 TGenerator.cxx:518
 TGenerator.cxx:519
 TGenerator.cxx:520
 TGenerator.cxx:521
 TGenerator.cxx:522
 TGenerator.cxx:523
 TGenerator.cxx:524
 TGenerator.cxx:525
 TGenerator.cxx:526
 TGenerator.cxx:527
 TGenerator.cxx:528
 TGenerator.cxx:529
 TGenerator.cxx:530
 TGenerator.cxx:531
 TGenerator.cxx:532
 TGenerator.cxx:533
 TGenerator.cxx:534
 TGenerator.cxx:535
 TGenerator.cxx:536
 TGenerator.cxx:537
 TGenerator.cxx:538
 TGenerator.cxx:539
 TGenerator.cxx:540
 TGenerator.cxx:541
 TGenerator.cxx:542
 TGenerator.cxx:543
 TGenerator.cxx:544
 TGenerator.cxx:545
 TGenerator.cxx:546
 TGenerator.cxx:547
 TGenerator.cxx:548
 TGenerator.cxx:549
 TGenerator.cxx:550
 TGenerator.cxx:551
 TGenerator.cxx:552
 TGenerator.cxx:553
 TGenerator.cxx:554
 TGenerator.cxx:555
 TGenerator.cxx:556
 TGenerator.cxx:557
 TGenerator.cxx:558
 TGenerator.cxx:559
 TGenerator.cxx:560
 TGenerator.cxx:561
 TGenerator.cxx:562
 TGenerator.cxx:563
 TGenerator.cxx:564
 TGenerator.cxx:565
 TGenerator.cxx:566