2 added + 2 modified, total 4 files
slic/include
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
slic/include
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;
};
};
slic/src
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;
+ }
+};
slic/src
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;
CVSspam 0.2.8