FBaseSimEvent.h

Go to the documentation of this file.

#ifndef FastSimulation_Event_FBaseSimEvent_H
#define FastSimulation_Event_FBaseSimEvent_H

// Data Formats
#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
#include "DataFormats/Math/interface/Point3D.h"

// HepPDT Headers
#include "SimGeneral/HepPDTRecord/interface/ParticleDataTable.h"

// Famos Headers
#include "FastSimulation/Particle/interface/RawParticle.h"
#include "FastSimDataFormats/NuclearInteractions/interface/FSimVertexType.h"
#include "FastSimDataFormats/NuclearInteractions/interface/FSimVertexTypeFwd.h"

#include <vector>

//class FSimEvent;
class FSimTrack;
class FSimVertex;
class KineParticleFilter;

class SimTrack;
class SimVertex;
class PrimaryVertexGenerator;
class RandomEngine;
//class Histos;

namespace edm {
  class ParameterSet;
}

namespace HepMC {
  class GenEvent;
  class GenParticle;
  class GenVertex;
}

class FBaseSimEvent  
{

public:

  FBaseSimEvent(const edm::ParameterSet& kine);

  FBaseSimEvent(const edm::ParameterSet& vtx,
        const edm::ParameterSet& kine,
        const RandomEngine* engine);

  ~FBaseSimEvent();

  void initializePdt(const HepPDT::ParticleDataTable* aPdt);

  inline const HepPDT::ParticleDataTable* theTable() const { 
    return pdt;
  }

  void fill(const HepMC::GenEvent& hev);

  void fill(const reco::GenParticleCollection& hev);

  void fill(const std::vector<SimTrack>&, const std::vector<SimVertex>&);
  
  void printMCTruth(const HepMC::GenEvent& hev);

  void addParticles(const HepMC::GenEvent& hev);
  void addParticles(const reco::GenParticleCollection& myGenParticles);

  void print() const;

  void clear();


  void addChargedTrack(int id);

  inline unsigned int nTracks() const {
    return nSimTracks;
  }

  inline unsigned int nVertices() const { 
    return nSimVertices;
  }

  inline unsigned int nGenParts() const {
    return nGenParticles;
  }

  inline unsigned int nChargedTracks() const {
    return nChargedParticleTracks;
  }

  inline FSimTrack& track(int id) const;

  inline FSimVertex& vertex(int id) const;

  inline FSimVertexType& vertexType(int id) const;

  int chargedTrack(int id) const;

  inline const SimTrack & embdTrack(int i) const;

  inline const SimVertex & embdVertex(int i) const;

  inline const FSimVertexType & embdVertexType(int i) const;

  const HepMC::GenParticle* embdGenpart(int i) const;

  int addSimTrack(const RawParticle* p, int iv, int ig=-1, 
          const HepMC::GenVertex* ev=0);

  int addSimVertex(const XYZTLorentzVector& decayVertex, int im=-1,
           FSimVertexType::VertexType type = FSimVertexType::ANY);

  const KineParticleFilter& filter() const { return *myFilter; } 

  PrimaryVertexGenerator* thePrimaryVertexGenerator() const { return theVertexGenerator; }

  inline void setBeamSpot(const math::XYZPoint& aBeamSpot) { 
    theBeamSpot = aBeamSpot;
  }

 protected:

  inline std::vector<FSimTrack>* tracks() const { 
    return theSimTracks; 
  }

  inline std::vector<FSimVertex>* vertices() const { 
    return theSimVertices; 
  }

  inline std::vector<HepMC::GenParticle*>* genparts() const { 
    return theGenParticles; 
  }

 private:

  std::vector<FSimTrack>* theSimTracks;
  std::vector<FSimVertex>* theSimVertices;
  FSimVertexTypeCollection* theFSimVerticesType;
  std::vector<HepMC::GenParticle*>* theGenParticles;

  std::vector<unsigned>* theChargedTracks;

  unsigned int nSimTracks;
  unsigned int nSimVertices;
  unsigned int nGenParticles;
  unsigned int nChargedParticleTracks;

  unsigned int theTrackSize;
  unsigned int theVertexSize;
  unsigned int theGenSize;
  unsigned int theChargedSize;
  unsigned int initialSize;

  KineParticleFilter* myFilter;

  double sigmaVerteX;
  double sigmaVerteY;
  double sigmaVerteZ;

  const ParticleDataTable * pdt;

  PrimaryVertexGenerator* theVertexGenerator;
  math::XYZPoint theBeamSpot;
  double lateVertexPosition;

  const RandomEngine* random;

  //  Histos* myHistos;

};

#include "FastSimulation/Event/interface/FBaseSimEvent.icc"

#endif // FBaseSimEvent_H