LcioMcpFactory.hh

Go to the documentation of this file.

// $Header: /cvs/lcd/slic/include/LcioMcpFactory.hh,v 1.8 2007/04/27 01:54:32 jeremy Exp $

#ifndef SLIC_LCIOMCPFACTORY_HH
#define SLIC_LCIOMCPFACTORY_HH 1

// lcio
#include "EVENT/LCCollection.h"
#include "EVENT/LCEvent.h"
#include "EVENT/MCParticle.h"
#include "IMPL/MCParticleImpl.h"

// slic
#include "Module.hh"

class G4PrimaryParticle;
class G4TrajectoryContainer;
class G4Event;

namespace slic
{
  class LcioMcpManager;
  class Trajectory;

  class LcioMcpFactory : public Module
  {

  public:
    LcioMcpFactory(LcioMcpManager*);
    virtual ~LcioMcpFactory();

  public:

    // create new, blank Mcp coll
    EVENT::LCCollection* createEmptyMcpCollection(const std::string& collName, bool errorOnExist = true);

    // chooses to create from initial or traj cont
    void createFinalMcpCollection(const G4Event* event);

  private:

    // use StdHep-generated mcpVec to create final mcpVec for an event
    void createFinalMcpCollectionFromInitial(EVENT::LCCollection* mcpVecInitial);

    // These two functions create the Mcp coll from trajectories only in case of G4 GPS or gun
    void createFinalMcpCollectionFromTrajectoryContainer(G4TrajectoryContainer* trjCont);

    /* Create Mcp daughters of a trajectory with the given track ID. */
    void addMcpDaughtersFromTrajectoryContainer(IMPL::MCParticleImpl* parMcp, int parTrkID);

    // create an Mcp from a trajectory only
    IMPL::MCParticleImpl* createMcpFromTrajectory( Trajectory* );

    // create Mcps recursively given an initial Mcp
    IMPL::MCParticleImpl* createMcpFromInitialRecurse(EVENT::MCParticle* mcp);

    // create an Mcp from another, associated initial Mcp only
    IMPL::MCParticleImpl* createMcpFromInitialOnly(EVENT::MCParticle* mcpInit);

    // create an Mcp from a G4PrimaryParticle
    IMPL::MCParticleImpl* createMcpFromPrimary(G4PrimaryParticle*, EVENT::MCParticle* );

    // create an Mcp from primary and input Mcp
    IMPL::MCParticleImpl* createMcpFromInitialAndPrimary(G4PrimaryParticle* primary, EVENT::MCParticle* mcpInit);

    // create an Mcp from a trajectory and an input Mcp
    IMPL::MCParticleImpl* createMcpFromInitialAndTrajectory( Trajectory*, EVENT::MCParticle* mcpInit );

    // create an Mcp from a G4PrimaryParticle, shallow copy only
    IMPL::MCParticleImpl* createMcpFromPrimaryShallowCopy(G4PrimaryParticle*);

    // create new Mcp and shallow copy from input Mcp
    IMPL::MCParticleImpl* createMcpShallowCopy(EVENT::MCParticle* mcp);

    // create and add MCP daughters based on G4PrimaryParticle and associated MCP from StdHep
    void createDaughtersFromPrimary(G4PrimaryParticle* primary,
                                    EVENT::MCParticle* mcpInit,
                                    IMPL::MCParticleImpl* mcpPar);

    // add daughters to a MCP based on associated intial MCP from StdHep
    void addMcpDaughtersFromInitial( IMPL::MCParticleImpl* mcpNew, EVENT::MCParticle* mcpInit );

    void fillMcpEndPointEnergy(IMPL::LCCollectionVec* mcpColl);

  private:
    LcioMcpManager* m_manager;
    IMPL::LCCollectionVec* m_finalColl;
    G4TrajectoryContainer* m_currentTrajectoryContainer;
  };
}

#endif

---