Event

class Event : public TObject

    public:

                Event Event()
                Event Event(Event&)
         virtual void ~Event()
                 void AddTrack(Float_t random)
              TClass* Class()
         virtual void Clear(Option_t* option)
               UInt_t GetFlag()
         EventHeader* GetHeader()
                TH1F* GetHistogram()
                Int_t GetNseg()
                Int_t GetNtrack()
                Int_t GetNvertex()
              Float_t GetTemperature()
        TClonesArray* GetTracks()
      virtual TClass* IsA()
                 void Reset(Option_t* option)
                 void ResetHistogramPointer()
                 void SetFlag(UInt_t f)
                 void SetHeader(Int_t i, Int_t run, Int_t date, Float_t random)
                 void SetNseg(Int_t n)
                 void SetNtrack(Int_t n)
                 void SetNvertex(Int_t n)
                 void SetTemperature(Float_t t)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)

  Data Members
    private:

                     Int_t fNtrack       
                     Int_t fNseg         
                     Int_t fNvertex      
                    UInt_t fFlag         
                   Float_t fTemperature  
               EventHeader fEvtHdr       
             TClonesArray* fTracks       
                     TH1F* fH            
      static TClonesArray* fgTracks      
              static TH1F* fgHist        

Class Description

                       Event and Track classes
                       =======================

  The Event class is a naive/simple example of an event structure.
     public:
        Int_t          fNtrack;
        Int_t          fNseg;
        Int_t          fNvertex;
        UInt_t         fFlag;
        Float_t        fTemperature;
        EventHeader    fEvtHdr;
        TClonesArray  *fTracks;
        TH1F          *fH;

   The EventHeader class has 3 data members (integers):
     public:
        Int_t          fEvtNum;
        Int_t          fRun;
        Int_t          fDate;


   The Event data member fTracks is a pointer to a TClonesArray.
   It is an array of a variable number of tracks per event.
   Each element of the array is an object of class Track with the members:
     private:
        Float_t      fPx;           //X component of the momentum
        Float_t      fPy;           //Y component of the momentum
        Float_t      fPz;           //Z component of the momentum
        Float_t      fRandom;       //A random track quantity
        Float_t      fMass2;        //The mass square of this particle
        Float_t      fBx;           //X intercept at the vertex
        Float_t      fBy;           //Y intercept at the vertex
        Float_t      fMeanCharge;   //Mean charge deposition of all hits of this track
        Float_t      fXfirst;       //X coordinate of the first point
        Float_t      fXlast;        //X coordinate of the last point
        Float_t      fYfirst;       //Y coordinate of the first point
        Float_t      fYlast;        //Y coordinate of the last point
        Float_t      fZfirst;       //Z coordinate of the first point
        Float_t      fZlast;        //Z coordinate of the last point
        Float_t      fCharge;       //Charge of this track
        Int_t        fNpoint;       //Number of points for this track
        Short_t      fValid;        //Validity criterion

   An example of a batch program to use the Event/Track classes is given
   in this directory: MainEvent.
   Look also in the same directory at the following macros:
     - eventa.C  an example how to read the tree
     - eventb.C  how to read events conditionally

   During the processing of the event (optionally) also a large number
   of histograms can be filled. The creation and handling of the
   histograms is taken care of by the HistogramManager class.

 Create an Event object.
 When the constructor is invoked for the first time, the class static
 variable fgTracks is 0 and the TClonesArray fgTracks is created.

 Add a new track to the list of tracks for this event.
 To avoid calling the very time consuming operator new for each track,
 the standard but not well know C++ operator "new with placement"
 is called. If tracks[i] is 0, a new Track object will be created
 otherwise the previous Track[i] will be overwritten.

 Static function to reset all static objects for this event
   fgTracks->Delete(option);

Inline Functions

                 void ResetHistogramPointer()
                 void SetNseg(Int_t n)
                 void SetNtrack(Int_t n)
                 void SetNvertex(Int_t n)
                 void SetFlag(UInt_t f)
                 void SetTemperature(Float_t t)
                Int_t GetNtrack()
                Int_t GetNseg()
                Int_t GetNvertex()
               UInt_t GetFlag()
              Float_t GetTemperature()
         EventHeader* GetHeader()
        TClonesArray* GetTracks()
                TH1F* GetHistogram()
              TClass* Class()
              TClass* IsA()
                 void ShowMembers(TMemberInspector& insp, char* parent)
                 void Streamer(TBuffer& b)
                Event Event(Event&)