LcioMcpMaps.cc

Go to the documentation of this file.

// $Header: /cvs/lcd/slic/src/LcioMcpMaps.cc,v 1.5 2007/04/27 01:54:35 jeremy Exp $
#include "LcioMcpMaps.hh"

// slic
#include "LcioMcpManager.hh"
#include "Module.hh"
#include "Trajectory.hh"

using EVENT::MCParticle;
using IMPL::MCParticleImpl;

namespace slic
{

  LcioMcpMaps::LcioMcpMaps(LcioMcpManager* manager)
    : Module( "LcioMcpMaps" )
  {
    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 ) const
  {
    MCParticleImpl* mcp = 0;
    for ( TrackToMcpMap::const_iterator iter = m_trackToMcp.begin();
          iter != m_trackToMcp.end();
          iter++ ) {
      if ( iter->first == trkID ) {
        mcp = iter->second;
        break;
      }
    }
    return mcp;
  }

  /* Find the trackID for the final MCParticle. */
  G4int LcioMcpMaps::findTrackIDFromFinalMcp( MCParticle* mcp) const
  {
    G4int trkID = -1;
    for ( TrackToMcpMap::const_iterator iter = m_trackToMcp.begin();
          iter != m_trackToMcp.end();
          iter++ ) {
      if ( iter->second == mcp ) {
        trkID = iter->first;
        break;
      }
    }
    return trkID;
  }

  MCParticle* LcioMcpMaps::findPrimaryInitialMcpFromTrajectory(Trajectory* trj) const
  {
    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) const
  {
    // 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) const
  {
    MCParticleImpl* mcpFinal = 0;
    for ( InitMcpToMcpMap::const_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) const
  {
    G4PrimaryParticle *pp = 0;
    for ( McpToPrimaryMap::const_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::clear()
  {
    m_trackToMcp.clear();
    m_McpToPrimary.clear();
    m_initMcpToMcp.clear();
  }

  void LcioMcpMaps::printMaps()
  {
    log() << LOG::debug << "Printing maps..." << LOG::done;

    printTrackToMcpMap();
    printMcpToPrimaryMap();
    printInitMcpToMcpMap();
    //    TrajectoryManager::instance()->printTrackIDToTrajectoryMap();
  }

  void LcioMcpMaps::printTrackToMcpMap()
  {
    log() << LOG::debug << "Printing track to Mcp map..." << LOG::done;

    log() << LOG::debug << "*** TrackToMcpMap ***" << LOG::done;
    log() << LOG::debug << "trkID | McpPtr" << LOG::done;
    for ( TrackToMcpMap::iterator iter = m_trackToMcp.begin();
          iter != m_trackToMcp.end();
          iter++ ) {
      log() << LOG::debug << iter->first << " " << iter->second << LOG::done;
    }
    log() << LOG::debug << LOG::done;
  }

  void LcioMcpMaps::printMcpToPrimaryMap()
  {
    log() << LOG::debug << "Printing Mcp to primary map..." << LOG::done;

    log() << LOG::debug << LOG::done;
    log() << LOG::debug << "*** McpToPrimaryMap ***" << LOG::done;
    log() << LOG::debug << "McpPtr | PrimaryPtr" << LOG::done;

    for ( McpToPrimaryMap::iterator iter = m_McpToPrimary.begin();
          iter != m_McpToPrimary.end();
          iter++ ) {
      log() << LOG::debug << iter->first << " " << iter->second << LOG::done;
    }
    log() << LOG::debug << LOG::done;
  }

  void LcioMcpMaps::printInitMcpToMcpMap()
  {
    log() << LOG::debug << "Printing InitMcp to Mcp map..." << LOG::done;

    log() << LOG::debug << LOG::done;
    log() << LOG::debug << "*** McpToMcpMap ***" << LOG::done;
    log() << LOG::debug << "McpPtrInit | McpPtrFinal" << LOG::done;

    for ( InitMcpToMcpMap::iterator iter = m_initMcpToMcp.begin();
          iter != m_initMcpToMcp.end();
          iter++ ) {
      log() << LOG::debug << iter->first << " " << iter->second << LOG::done;
    }
    log() << LOG::debug << LOG::done;
  }
}

---