StarGenEvent.h

#ifndef __StarGenEvent_h__
#define __StarGenEvent_h__
#include "TString.h"
#include <vector>
#include "TObjArray.h"
#include "TClonesArray.h"
#include "TCollection.h"
#include "TObject.h"

class TClonesArray;
class StarGenParticle;

class StarGenEvent : public TObject
{ 
 public:

  StarGenEvent( const Char_t *name="event", const Char_t *title="" );
  ~StarGenEvent();
  
  void SetGeneratorId( Int_t id ) { mGeneratorId = id; }
  Int_t GetGeneratorId(){ return mGeneratorId; }
  void SetProcessId( Int_t id ){ mProcessId = id; }
  Int_t GetProcessId(){ return mProcessId; }
  void SetOffset( Int_t o ){ mOffset = o; }
  Int_t GetOffset(){ return mOffset; }  

  Int_t operator++(){ return ++mEventNumber; }
  Int_t operator++(Int_t){ return mEventNumber++; }
  Int_t GetEventNumber(){ return mEventNumber; }

  void SetRunNumber( Int_t run ){ mRunNumber = run; }
  Int_t GetRunNumber(){ return mRunNumber; }
  void SetDaqRunNumber( Int_t run ){ mDaqRunNumber= run; }
  Int_t GetDaqRunNumber(){ return mDaqRunNumber; }
  void SetDaqFileNumber( Int_t fnum ){ mDaqFileNumber= fnum; }
  Int_t GetDaqFileNumber(){ return mDaqFileNumber; }

  void SetBlue( Int_t id ) { mBlueId = id; }
  Int_t GetBlue(){ return mBlueId; }
  void SetYell( Int_t id ){ mYellId = id; }
  Int_t GetYell(){ return mYellId; }
  void SetRootS( Double_t rs ){ mCmsEnergy = rs; }
  Double_t GetRootS(){ return mCmsEnergy; }
    
  StarGenParticle *AddParticle();

  StarGenParticle *AddParticle( Int_t status, Int_t pdg, Int_t m1, Int_t m2, Int_t d1, Int_t d2, 
                                Double_t px, Double_t py, Double_t pz, Double_t E, Double_t M,
                                Double_t vx, Double_t vy, Double_t vz, Double_t vt );


  StarGenParticle *AddParticle( StarGenParticle *particle );

  void Print( const Option_t *opts="head" ) const;

  TIter IterAll( Bool_t dir=kIterForward ){ 
    return TIter( mParticles, dir ); 
  }

  virtual void Clear( const Option_t *opts="part,data" );

  StarGenParticle *operator[]( Int_t idx ){ 
    return (StarGenParticle *)(*mParticles)[idx]; 
  }

  Int_t GetNumberOfParticles(){ return mNumParticles; }

  enum FilterResult 
    {
      kUnknown  = 0,      // Result not specified.
      kAccept   = 0x0001, // The event is accepted
      kReject   = 0x0002, // The event is rejected
      kFlag     = 0x0004  // The event will be simulated regardless of accept/reject decision
    };

  void SetFilterResult( UInt_t result ){ mFilterResult =result; }

  void AddFilterResult( UInt_t result ){ mFilterResult|=result; }

  UInt_t GetFilterResult(){ return mFilterResult; }

  void AddUserWeight( double w ){ mWeights.push_back(w); }

  const std::vector<double>& GetUserWeights()       { return mWeights; }
  const std::vector<double>& GetUserWeights() const { return mWeights; }

 private:
  StarGenEvent( const StarGenEvent &other );
  StarGenEvent &operator=( const StarGenEvent &other );

 protected:

  TString       mName;
  TString       mTitle;

  TClonesArray *mParticles;        

  Int_t    mGeneratorId;           
  Int_t    mProcessId;             
  Int_t    mOffset;                

  Int_t    mEventNumber;           
  Int_t    mRunNumber;             
  Int_t    mDaqRunNumber;          
  Int_t    mDaqFileNumber;         

  Int_t    mBlueId;                
  Int_t    mYellId;                
  
  Double_t mCmsEnergy;             

  Int_t    mNumRejected[3];        
  UInt_t   mFilterResult;          

  std::vector<Double_t> mWeights;  

  Int_t mNumParticles;             

  void InitArrays();
  
  ClassDef(StarGenEvent,1);
};



#endif