erhic/EventMC.h

Go to the documentation of this file.

 
#ifndef INCLUDE_EICSMEAR_ERHIC_EVENTMC_H_
#define INCLUDE_EICSMEAR_ERHIC_EVENTMC_H_
 
#include <string>
#include <vector>
 
#include <TClonesArray.h>
#include <TLorentzVector.h>
 
#include "eicsmear/erhic/EventDis.h"
#include "eicsmear/erhic/ParticleMC.h"
 
class TTree;
 
namespace erhic {
 
class EventMC : public EventDis {
 public:
  EventMC();
 
  virtual ~EventMC();
 
  virtual bool RequiresEaParticleFields() { return false; };
 
  virtual ULong64_t GetN() const;
 
  virtual Int_t GetProcess() const;
 
  virtual UInt_t GetNTracks() const;
 
  virtual const ParticleMC* GetTrack(UInt_t) const;
 
  virtual ParticleMC* GetTrack(UInt_t);
 
  virtual const ParticleMC* BeamLepton() const;
 
  virtual const ParticleMC* BeamHadron() const;
 
  virtual const ParticleMC* ExchangeBoson() const;
 
  virtual const ParticleMC* ScatteredLepton() const;
 
  virtual bool Parse(const std::string&) = 0;
 
  virtual void AddLast(ParticleMC* track);
 
  virtual void Reset();
 
  virtual void Clear(Option_t* = "");
 
  virtual void SetProcess(int code);
 
  virtual void SetN(int n);
 
  virtual void SetNTracks(int n);
 
  virtual void SetELeptonInNuclearFrame(double energy);
 
  virtual void SetEScatteredInNuclearFrame(double energy);
 
  void FinalState(ParticlePtrList& particles) const;
 
  void HadronicFinalState(ParticlePtrList&) const;
 
  TLorentzVector FinalStateMomentum() const;
 
  TLorentzVector HadronicFinalStateMomentum() const;
 
  Double_t FinalStateCharge() const;
 
  std::vector<const VirtualParticle*> GetTracks() const;
 
 protected:
  Int_t number;  
  Int_t process;  
  Int_t nTracks;  
  Double32_t ELeptonInNucl;  
  Double32_t ELeptonOutNucl;  
  TClonesArray particles;  
 
  ClassDef(erhic::EventMC, 2)
};
 
inline ULong64_t EventMC::GetN() const {
  return number;
}
 
inline Int_t EventMC::GetProcess() const {
  return process;
}
 
inline UInt_t EventMC::GetNTracks() const {
  return particles.GetEntries();
}
 
inline const ParticleMC* EventMC::GetTrack(UInt_t u) const {
  if (u < (UInt_t)particles.GetEntries()) {
    return static_cast<ParticleMC*>(particles.At(u));
  } else {
    return NULL;
  }  // if
}
 
inline ParticleMC* EventMC::GetTrack(UInt_t u) {
  if (u < (UInt_t)particles.GetEntries()) {
    return static_cast<ParticleMC*>(particles.At(u));
  } else {
    return NULL;
  }  // if
}
 
inline void EventMC::SetProcess(int code) {
  process = code;
}
 
inline void EventMC::SetN(int n) {
  number = n;
}
 
inline void EventMC::SetNTracks(int n) {
  nTracks = n;
}
 
inline void EventMC::SetELeptonInNuclearFrame(double e) {
  ELeptonInNucl = e;
}
 
inline void EventMC::SetEScatteredInNuclearFrame(double e) {
  ELeptonOutNucl = e;
}
 
class Reader {
 public:
  explicit Reader(const std::string& treeName = "EICTree");
 
  virtual ~Reader() { }
 
  EventMC* Read(Long64_t number);
 
  EventMC* operator()(Long64_t number);
 
  TTree* GetTree();
 
  EventMC* mEvent;  
  TTree* mTree;   
 
  ClassDef(erhic::Reader, 1)
};
 
inline EventMC* Reader::operator()(Long64_t i) {
  return Read(i);
}
 
inline TTree* Reader::GetTree() {
  return mTree;
}
 
}  // namespace erhic
 
#endif  // INCLUDE_EICSMEAR_ERHIC_EVENTMC_H_