diff -N LcioMcpMaps.hh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ LcioMcpMaps.hh	14 Sep 2005 23:59:44 -0000	1.1
@@ -0,0 +1,95 @@

+// $Header: /cvs/lcd/slic/include/LcioMcpMaps.hh,v 1.1 2005/09/14 23:59:44 jeremy Exp $
+#ifndef LcioMcpMaps_hh
+#define LcioMcpMaps_hh 1
+
+// lcdd
+#include "Verbose.hh"
+
+// lcio
+#include "IMPL/MCParticleImpl.h"
+#include "EVENT/MCParticle.h"
+
+// geant4
+#include "globals.hh"
+
+//std
+#include <map>
+
+class G4PrimaryParticle;
+
+namespace slic
+{
+
+  class Trajectory;
+  class LcioMcpManager;
+
+  class LcioMcpMaps : public Verbose
+  {
+
+  public:
+    LcioMcpMaps(LcioMcpManager*);
+    virtual ~LcioMcpMaps();
+
+  public:
+
+    // track to Mcp
+    typedef std::map<G4int, IMPL::MCParticleImpl*> TrackToMcpMap;
+
+    // Mcp to primary particle
+    typedef std::map<EVENT::MCParticle*, G4PrimaryParticle*> McpToPrimaryMap;
+
+    // initial Mcp from StdHep to final Mcp
+    typedef std::map<EVENT::MCParticle*, IMPL::MCParticleImpl*> InitMcpToMcpMap;
+
+  public:
+
+    // connect an initial Mcp to a primary
+    void addMcpToPrimaryLink(EVENT::MCParticle* mcp, G4PrimaryParticle* primary);
+
+    // connect track to MCParticle via track ID
+    void addTrackIDToMcpLink(G4int trkID, IMPL::MCParticleImpl* mcp);
+
+    // connect initial Mcp to final Mcp
+    void addInitialMcpToFinalMcpLink( EVENT::MCParticle* mcpInit, IMPL::MCParticleImpl* mcpFinal);
+
+    // find an MCParticle from the trackID
+    IMPL::MCParticleImpl* findMcpFromTrackID( G4int trkID );
+
+    // find matching primary particle given an MCP ptr
+    G4PrimaryParticle* findPrimaryFromMcp(EVENT::MCParticle* mcp);
+
+    // loop over input collection to find matching Mcp primary for this trajectory
+    EVENT::MCParticle* findPrimaryInitialMcpFromTrajectory(Trajectory* trj);
+
+    // find a dau Mcp given a G4PrimaryParticle dau
+    EVENT::MCParticle* findDaughterMcpFromPrimary(EVENT::MCParticle* mcpInit,
+						  G4PrimaryParticle* primary);
+
+    // given an input particle from stdhep, find the proper output particle
+    IMPL::MCParticleImpl* findFinalParticleFromInitial( EVENT::MCParticle* mcpInit);
+
+    // print maps
+    void printMaps();
+    void printTrackToMcpMap();
+    void printMcpToPrimaryMap();
+    void printInitMcpToMcpMap();
+
+    void clearMaps();
+
+  private:
+
+    // trackID -> MCP
+    TrackToMcpMap m_trackToMcp;
+
+    // MCP -> G4PrimaryParticle
+    McpToPrimaryMap m_McpToPrimary;
+
+    // initial Mcp -> final Mcp
+    InitMcpToMcpMap m_initMcpToMcp;
+
+    // back pointer to LcioMcpManager
+    LcioMcpManager* m_manager;
+  };
+}
+
+#endif

diff -u -r1.37 -r1.38
--- LcioMcpManager.hh	14 Sep 2005 23:10:37 -0000	1.37
+++ LcioMcpManager.hh	14 Sep 2005 23:59:44 -0000	1.38
@@ -1,17 +1,18 @@

 #ifndef slic_LcioMcpManager_hh
 #define slic_LcioMcpManager_hh 1
 

-// SLIC

+// slic

 #include "LcioMcpPrinter.hh"

+#include "LcioMcpMaps.hh"

 #include "LcioPrimaryGenerator.hh"
 

-// LCIO

+// lcio

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

-// G4

+// geant4

 #include "globals.hh"
 #include "G4PrimaryParticle.hh"
 

@@ -130,6 +131,9 @@

     // get the Mcp printer
     LcioMcpPrinter* getMcpPrinter();
 

+    /* Get the MCParticle data maps. */
+    LcioMcpMaps* getMaps();
+

   private:
 
     // clear the maps

@@ -170,6 +174,9 @@

 
     /* Factory for creating MCParticles from Geant4 runtime data. */
     LcioMcpFactory* m_factory;

+
+    /* Collection of maps with MCParticle information. */
+    LcioMcpMaps* m_maps;

   };
 };
 

diff -N LcioMcpMaps.cc
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ LcioMcpMaps.cc	14 Sep 2005 23:59:45 -0000	1.1
@@ -0,0 +1,202 @@

+// $Header: /cvs/lcd/slic/src/LcioMcpMaps.cc,v 1.1 2005/09/14 23:59:45 jeremy Exp $
+#include "LcioMcpMaps.hh"
+
+// slic
+#include "LcioMcpManager.hh"
+#include "Trajectory.hh"
+
+using EVENT::MCParticle;
+using IMPL::MCParticleImpl;
+
+namespace slic
+{
+
+  LcioMcpMaps::LcioMcpMaps(LcioMcpManager* manager)
+  {
+    m_manager = manager;
+  }
+
+  LcioMcpMaps::~LcioMcpMaps()
+  {}
+
+  void LcioMcpMaps::addTrackIDToMcpLink(G4int trkID,
+					   MCParticleImpl* mcp)
+  {
+    assert( mcp );
+    assert(trkID > 0);
+
+    m_trackToMcp[ trkID ] = mcp;
+  }
+
+  MCParticleImpl* LcioMcpMaps::findMcpFromTrackID( G4int trkID ) {
+    MCParticleImpl* mcp = 0;
+    for ( TrackToMcpMap::iterator iter = m_trackToMcp.begin();
+	  iter != m_trackToMcp.end();
+	  iter++ ) {
+      if ( iter->first == trkID ) {
+	mcp = iter->second;
+	break;
+      }
+    }
+    return mcp;
+  }
+
+  MCParticle* LcioMcpMaps::findPrimaryInitialMcpFromTrajectory(Trajectory* trj)
+  {
+    MCParticle* mcpPrim = 0;
+
+    G4int trjTrkID = trj->GetTrackID();
+
+    /* Get initial collection. */
+    EVENT::LCCollection* initMcpColl = m_manager->getInitialMcpCollection();
+
+    // loop over input collection
+    int numPrePart = initMcpColl->getNumberOfElements();
+    for( int k=0; k < numPrePart; k++ ) {
+
+      // current MCP
+      MCParticle* mcpPre = static_cast<MCParticle*> ( initMcpColl->getElementAt( k ) );
+
+      // do we have matching primary for this Mcp?
+      G4PrimaryParticle* primaryMatch = findPrimaryFromMcp( mcpPre );
+      if ( primaryMatch ) {
+
+	// found matching primary to this input trajectory
+	if ( primaryMatch->GetTrackID() == trjTrkID ) {
+	  mcpPrim = mcpPre;
+	  break;
+	}
+
+      }
+    }
+
+    return mcpPrim;
+  }
+
+  MCParticle* LcioMcpMaps::findDaughterMcpFromPrimary(MCParticle* mcpInit,
+								G4PrimaryParticle* primDau)
+  {
+    // loop over Mcp input particle's daughters
+    MCParticle* mcpDau = 0;
+    int numMcpDau = mcpInit->getDaughters().size();
+    for ( int i=0; i < numMcpDau; i++ ) {
+
+      // does ith Mcp dau match this primary?
+      if ( findPrimaryFromMcp( mcpInit->getDaughters()[i] ) == primDau ) {
+
+	// found it
+	mcpDau = mcpInit->getDaughters()[i];
+	break;
+      }
+    }
+
+    // return dau
+    return mcpDau;
+  }
+
+  MCParticleImpl* LcioMcpMaps::findFinalParticleFromInitial( MCParticle* mcpInit)
+  {
+    MCParticleImpl* mcpFinal = 0;
+    for ( InitMcpToMcpMap::iterator iter = m_initMcpToMcp.begin();
+	  iter != m_initMcpToMcp.end();
+	  iter++ ) {
+      if ( iter->first == mcpInit ) {
+	mcpFinal = iter->second;
+	break;
+      }
+    }
+
+    return mcpFinal;
+  }
+
+  G4PrimaryParticle* LcioMcpMaps::findPrimaryFromMcp(MCParticle* mcp)
+  {
+    G4PrimaryParticle *pp = 0;
+    for ( McpToPrimaryMap::iterator iter = m_McpToPrimary.begin();
+	  iter != m_McpToPrimary.end();
+	  iter++ ){
+      if ( iter->first == mcp ) {
+	pp = iter->second;
+	break;
+      }
+    }
+
+    return pp;
+  }
+
+  void LcioMcpMaps::addMcpToPrimaryLink(MCParticle* mcp,
+					   G4PrimaryParticle* primary)
+  {
+    m_McpToPrimary[ mcp ] = primary;
+  }
+
+  void LcioMcpMaps::addInitialMcpToFinalMcpLink(MCParticle* mcpInit,
+						   MCParticleImpl* mcpFinal)
+  {
+    m_initMcpToMcp[ mcpInit ] = mcpFinal;
+  }
+
+  void LcioMcpMaps::clearMaps()
+  {
+    m_trackToMcp.clear();
+    m_McpToPrimary.clear();
+    m_initMcpToMcp.clear();
+    //    m_mcpColls.clear();
+  }
+
+  void LcioMcpMaps::printMaps()
+  {
+    std::cout << "Printing maps..." << std::endl;
+
+    printTrackToMcpMap();
+    printMcpToPrimaryMap();
+    printInitMcpToMcpMap();
+    //    TrajectoryManager::instance()->printTrackIDToTrajectoryMap();
+  }
+
+  void LcioMcpMaps::printTrackToMcpMap()
+  {
+    std::cout << "Printing track to Mcp map..." << std::endl;
+
+    std::cout << "*** TrackToMcpMap ***" << std::endl;
+    std::cout << "trkID | McpPtr" << std::endl;
+    for ( TrackToMcpMap::iterator iter = m_trackToMcp.begin();
+	  iter != m_trackToMcp.end();
+	  iter++ ) {
+      std::cout << iter->first << " " << iter->second << std::endl;
+    }
+    std::cout << std::endl;
+  }
+
+  void LcioMcpMaps::printMcpToPrimaryMap()
+  {
+    std::cout << "Printing Mcp to primary map..." << std::endl;
+
+    std::cout << std::endl;
+    std::cout << "*** McpToPrimaryMap ***" << std::endl;
+    std::cout << "McpPtr | PrimaryPtr" << std::endl;
+
+    for ( McpToPrimaryMap::iterator iter = m_McpToPrimary.begin();
+	  iter != m_McpToPrimary.end();
+	  iter++ ) {
+      std::cout << iter->first << " " << iter->second << std::endl;
+    }
+    std::cout << std::endl;
+  }
+
+  void LcioMcpMaps::printInitMcpToMcpMap()
+  {
+    std::cout << "Printing InitMcp to Mcp map..." << std::endl;
+
+    std::cout << std::endl;
+    std::cout << "*** McpToMcpMap ***" << std::endl;
+    std::cout << "McpPtrInit | McpPtrFinal" << std::endl;
+
+    for ( InitMcpToMcpMap::iterator iter = m_initMcpToMcp.begin();
+	  iter != m_initMcpToMcp.end();
+	  iter++ ) {
+      std::cout << iter->first << " " << iter->second << std::endl;
+    }
+    std::cout << std::endl;
+  }
+};

diff -u -r1.50 -r1.51
--- LcioMcpManager.cc	14 Sep 2005 23:10:37 -0000	1.50
+++ LcioMcpManager.cc	14 Sep 2005 23:59:44 -0000	1.51
@@ -1,4 +1,4 @@

-// $Header: /cvs/lcd/slic/src/LcioMcpManager.cc,v 1.50 2005/09/14 23:10:37 jeremy Exp $

+// $Header: /cvs/lcd/slic/src/LcioMcpManager.cc,v 1.51 2005/09/14 23:59:44 jeremy Exp $

 #include "LcioMcpManager.hh"
 
 // SLIC

@@ -54,6 +54,9 @@

 
     /* Setup the MCParticle factory. */
     m_factory = new LcioMcpFactory(this);

+
+    /* Create the MCParticle data maps object. */
+    m_maps = new LcioMcpMaps(this);

   }
 
   void LcioMcpManager::endEvent(const G4Event*)

@@ -342,6 +345,11 @@

     return m_mcpPrinter;
   }
 

+  LcioMcpMaps* LcioMcpManager::getMaps()
+  {
+    return m_maps;
+  }
+

   void LcioMcpManager::printMaps()
   {
     std::cout << "Printing maps..." << std::endl;