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 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_