G4HepMCInterface Class Reference

#include <G4HepMCInterface.h>

Inheritance diagram for G4HepMCInterface:

Public Member Functions
void	HepMC2G4 (HepMC::GenEvent *hepmcevt, G4Event *g4event)
void	Print (const HepMC::GenEvent *hepmcevt)
G4int	CheckType (const HepMC::GenEvent *hepmcevt)
void	Boost (HepMC::GenEvent *hepmcevt)
void	PrintHPlist ()
G4int	GetLogLevel ()
void	SetLogLevel (G4int level)
	G4HepMCInterface ()
virtual	~G4HepMCInterface ()
HepMC::GenEvent *	GetHepMCGenEvent () const
virtual void	GeneratePrimaryVertex (G4Event *anEvent)

Public Attributes
std::vector< G4HepMCParticle * >	HPlist

Protected Member Functions
virtual HepMC::GenEvent *	GenerateHepMCEvent ()

Protected Attributes
HepMC::GenEvent *	hepmcEvent
G4int	m_logLevel

Detailed Description

Definition at line 44 of file G4HepMCInterface.h.

Constructor & Destructor Documentation

G4HepMCInterface()

G4HepMCInterface::G4HepMCInterface

(

)

Definition at line 64 of file G4HepMCInterface.cpp.

    : hepmcEvent( 0 )
// , m_geantinoPdgId( 100 )
// , m_chargedgeantinoPdgId( 101 )
////////////////////////////////////
{
 
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  StatusCode   status     = svcLocator->service( "RealizationSvc", m_RealizationSvc );
  if ( !status.isSuccess() )
  {
    std::cout << " Could not initialize Realization Service in G4HepMCInterface" << std::endl;
  }
 
  //   int  pdlId1 = -1, pdlId2 = -1;
  //   auto algMan = svcLocator->as<IAlgManager>();
  //   if ( algMan )
  //   {
  //     if ( algMan->existsAlgorithm( "EvtDecay" ) )
  //     { // BesEvtGen used
  //       EvtId evtId1 = EvtPDL::getId( "geantino" );
  //       pdlId1       = evtId1.getId();
  //       if ( pdlId1 != -1 )
  //       { // denote geantino has been defined in pdt.table
  //         m_geantinoPdgId = EvtPDL::getStdHep( evtId1 );
  //       }
  //       EvtId evtId2 = EvtPDL::getId( "chargedgeantino" );
  //       pdlId2       = evtId2.getId();
  //       if ( pdlId2 != -1 )
  //       { // denote chargedgeantino has been defined in pdt.table
  //         m_chargedgeantinoPdgId = EvtPDL::getStdHep( evtId2 );
  //       }
  //     }
  //   }
 
  //   if ( pdlId1 == -1 || pdlId2 == -1 )
  //   { // generator is not BesEvtGen, defined in PDGTABLE.MeV; if not, will use default
  //     IPartPropSvc* p_PartPropSvc;
  //     StatusCode    PartPropStatus = svcLocator->service( "PartPropSvc", p_PartPropSvc );
  //     if ( !PartPropStatus.isSuccess() || 0 == p_PartPropSvc )
  //     {
  //       std::cout << " Could not initialize Particle Properties Service in G4HepMCInterface"
  //                 << std::endl;
  //     }
  //     else
  //     {
  //       HepPDT::ParticleDataTable* pdt = p_PartPropSvc->PDT();
  //       if ( pdlId1 == -1 )
  //       {
  //         const HepPDT::ParticleData* pd = pdt->particle( "geantino" );
  //         if ( pd ) m_geantinoPdgId = pd->pid();
  //       }
  //       if ( pdlId2 == -1 )
  //       {
  //         const HepPDT::ParticleData* pd = pdt->particle( "chargedgeantino" );
  //         if ( pd ) m_chargedgeantinoPdgId = pd->pid();
  //       }
  //     }
  //   }
}

~G4HepMCInterface()

G4HepMCInterface::~G4HepMCInterface ( )

virtual

Definition at line 126 of file G4HepMCInterface.cpp.

{
  delete hepmcEvent;
}

Member Function Documentation

Boost()

void G4HepMCInterface::Boost

(

HepMC::GenEvent *

hepmcevt

)

Definition at line 209 of file G4HepMCInterface.cpp.

{
  // suppose relavtive vectoy is v(vx,vy,vz),position are (x,y,z,t)in CMS and(X,Y,Z,T)in
  // Lab,the formulae for boost vertex position from Cms to Lab in natural units are following:
  //  v2 = vx*vx + vy*vy + vz*vz;
  //  gamma = 1.0 / sqrt(1.0 - v2);
  //  bp = vx*x + vy*y + vz*z;
  //  X=x + gamma2*bp*vx + gamma*vx*t;
  //  Y=y + gamma2*bp*vy + gamma*vy*t;
  //  Z=z + gamma2*bp*vz + gamma*vz*t;
  //  T=gamma*(t + bp);
  // the function of these formulae is the same as xvtx.boost(ThreeVector v)
  // For the E_cms,need to loop and splice the momentum of all the final state particles
  G4LorentzVector ptot( 0, 0, 0, 0 );
  double          E_cms, p_Mag, e_Mass2, M_cms, theta;
  for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
        vitr != hepmcevt->vertices_end(); ++vitr )
  { // loop for vertex ...
 
    for ( HepMC::GenVertex::particle_iterator vpitr =
              ( *vitr )->particles_begin( HepMC::children );
          vpitr != ( *vitr )->particles_end( HepMC::children ); ++vpitr )
    {
 
      if ( ( *vpitr )->status() != 1 ) continue; // Not final state particle
 
      G4LorentzVector p;
      p.setX( ( *vpitr )->momentum().x() );
      p.setY( ( *vpitr )->momentum().y() );
      p.setZ( ( *vpitr )->momentum().z() );
      p.setT( ( *vpitr )->momentum().t() );
      ptot = p + ptot;
    }
  }
  E_cms = ptot.e() * GeV;
 
  // get G4Svc, allow user to access the beam momentum shift in JobOptions
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  IG4Svc*      tmpSvc;
  G4Svc*       m_G4Svc;
  StatusCode   sc = svcLocator->service( "G4Svc", tmpSvc );
  m_G4Svc         = dynamic_cast<G4Svc*>( tmpSvc );
 
  G4ThreeVector v( 0, 0, 0 ); // velocity of cms as seen from lab
  // for cms velocity
  theta = 11 * mrad;
  // theta=(m_G4Svc->GetBeamAngle())*mrad;
  // theta is half of the angle between the two beams,namely,is the angle between the beam and
  // Z axis.
  M_cms   = E_cms;                               // for p_cms=0 in the CMS
  e_Mass2 = electron_mass_c2 * electron_mass_c2; // square of electron mass
  p_Mag   = sqrt( ( E_cms * E_cms - 4 * e_Mass2 ) / ( 2 * ( 1 - cos( pi - 2 * theta ) ) ) );
  G4ThreeVector p_Positron( p_Mag * sin( theta ), 0, p_Mag * cos( theta ) );
  G4ThreeVector p_Electron( p_Mag * sin( pi - theta ), 0, p_Mag * cos( pi - theta ) );
  G4ThreeVector vee = p_Positron + p_Electron;
  G4ThreeVector beamshift( m_G4Svc->GetBeamShiftPx(), m_G4Svc->GetBeamShiftPy(),
                           m_G4Svc->GetBeamShiftPz() );
  if ( m_G4Svc->GetSetBeamShift() == true && fabs( M_cms - 3686 ) < 50.0 ) { vee = beamshift; }
 
  double pee = vee.r();
  M_cms      = sqrt( M_cms * M_cms + pee * pee );
  v          = vee / M_cms;
 
  for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
        vitr != hepmcevt->vertices_end(); ++vitr )
  { // loop for vertex ...
 
    // Boost vertex position from cms to lab
    G4LorentzVector xvtx;
    xvtx.setX( ( *vitr )->position().x() );
    xvtx.setY( ( *vitr )->position().y() );
    xvtx.setZ( ( *vitr )->position().z() );
    xvtx.setT( ( *vitr )->position().t() );
    xvtx.boost( v );
    ( *vitr )->set_position( xvtx );
 
    // Boost the particles four momentum from cms to lab
    // the transform formulae are similary to the position boost
    for ( HepMC::GenVertex::particle_iterator vpitr =
              ( *vitr )->particles_begin( HepMC::children );
          vpitr != ( *vitr )->particles_end( HepMC::children ); ++vpitr )
    {
      G4LorentzVector p;
      p.setX( ( *vpitr )->momentum().x() );
      p.setY( ( *vpitr )->momentum().y() );
      p.setZ( ( *vpitr )->momentum().z() );
      p.setT( ( *vpitr )->momentum().t() );
      p = p.boost( v );
      ( *vpitr )->set_momentum( p );
    }
  }
}

Referenced by HepMC2G4().

CheckType()

G4int G4HepMCInterface::CheckType

(

const HepMC::GenEvent *

hepmcevt

)

Definition at line 182 of file G4HepMCInterface.cpp.

                                                                 {
  G4int flag = 0;
  for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
        vitr != hepmcevt->vertices_end(); ++vitr )
  { // loop for vertex ...
    for ( HepMC::GenVertex::particle_iterator pitr =
              ( *vitr )->particles_begin( HepMC::children );
          pitr != ( *vitr )->particles_end( HepMC::children ); ++pitr )
    {
      if ( ( *pitr )->end_vertex() )
      {
        flag = 1;
        break;
      }
    }
    if ( flag ) break;
  }
  if ( m_logLevel <= 4 )
  {
    if ( flag == 0 ) G4cout << G4endl << "generator is GENBES!" << G4endl;
    else G4cout << G4endl << "generator is not GENBES!" << G4endl;
  }
  return flag;
}

Referenced by HepMC2G4().

GenerateHepMCEvent()

HepMC::GenEvent * G4HepMCInterface::GenerateHepMCEvent ( )

protectedvirtual

Reimplemented in BesHepMCInterface.

Definition at line 576 of file G4HepMCInterface.cpp.

{
  HepMC::GenEvent* aevent = new HepMC::GenEvent();
  return aevent;
}

Referenced by GeneratePrimaryVertex().

GeneratePrimaryVertex()

void G4HepMCInterface::GeneratePrimaryVertex ( G4Event * anEvent )

virtual

Definition at line 584 of file G4HepMCInterface.cpp.

{
  // delete previous event object
  delete hepmcEvent;
 
  // generate next event
  hepmcEvent = GenerateHepMCEvent();
  if ( !hepmcEvent )
  {
    G4Exception( "G4HepMCInterface", "GeneratePrimaryVertex", RunMustBeAborted,
                 "HepMCInterface: no generated particles. run terminated..." );
    return;
  }
  HepMC2G4( hepmcEvent, anEvent );
}

GetHepMCGenEvent()

HepMC::GenEvent * G4HepMCInterface::GetHepMCGenEvent ( ) const

inline

Definition at line 96 of file G4HepMCInterface.h.

{ return hepmcEvent; }

GetLogLevel()

G4int G4HepMCInterface::GetLogLevel ( )

inline

Definition at line 53 of file G4HepMCInterface.h.

{ return m_logLevel; }

HepMC2G4()

void G4HepMCInterface::HepMC2G4	(	HepMC::GenEvent *	hepmcevt,
		G4Event *	g4event )

Definition at line 304 of file G4HepMCInterface.cpp.

{
  // Print HepMC Event before boost
  if ( m_logLevel <= 4 ) Print( hepmcevt );
 
  // get G4Svc
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  IG4Svc*      tmpSvc;
  G4Svc*       m_G4Svc;
  StatusCode   sc = svcLocator->service( "G4Svc", tmpSvc );
  m_G4Svc         = dynamic_cast<G4Svc*>( tmpSvc );
 
  // considering 22rmad beam clossing angle ,need to boost the Cms to Lab
  //  need to boost ?
  if ( m_G4Svc->GetBoostLab() == true ) Boost( hepmcevt );
 
  // Print HepMC Event after boost
  if ( m_logLevel <= 2 && m_G4Svc->GetBoostLab() == true ) Print( hepmcevt );
 
  //*********************send particles to HPlist*************************//
  G4int flag = CheckType( hepmcevt );
  if ( flag )
  {
    for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
          vitr != hepmcevt->vertices_end(); ++vitr )
    { // loop for vertex ...
      G4int                               vtxFlag = 0;
      G4int                               pOut    = ( *vitr )->particles_out_size();
      HepMC::GenVertex::particle_iterator pitr = ( *vitr )->particles_begin( HepMC::children );
      G4int                               pdgcode = ( *pitr )->pdg_id();
      if ( pOut == 1 && abs( pdgcode ) == 11 ) vtxFlag = 1;
      G4int barcodeVtx = ( *vitr )->barcode();
 
      for ( HepMC::GenVertex::particle_iterator pitr =
                ( *vitr )->particles_begin( HepMC::children );
            pitr != ( *vitr )->particles_end( HepMC::children ); ++pitr )
      { // loop for particle from this vertex
        G4int pdgcode = ( *pitr )->pdg_id();
        if ( vtxFlag == 0 )
        {
          if ( pdgcode == -22 ) pdgcode = 22;
          G4LorentzVector p;
          p.setX( ( *pitr )->momentum().x() );
          p.setY( ( *pitr )->momentum().y() );
          p.setZ( ( *pitr )->momentum().z() );
          p.setT( ( *pitr )->momentum().t() );
          G4PrimaryParticle* particle = 0;
          // geantino and chargedgeantino can't create through pdgcode;
          // their PdgID = 0 in Geant4.10.07.p02, and if particle->SetPDGcode(100), Geant4 will
          // not know. So reset PdgID of input HepMC::GenParticle to G4ParticleDefinition's; if
          // not, BesSensitiveManager::UpdatePrimaryTrack(const G4Track* track) will exit(1)
          // because MatchError.
          // if ( pdgcode == m_geantinoPdgId )
          // {
          //   G4ParticleDefinition* pd =
          //       G4ParticleTable::GetParticleTable()->FindParticle( "geantino" );
          //   particle = new G4PrimaryParticle( pd, p.x() * GeV, p.y() * GeV, p.z() * GeV );
          //   ( *pitr )->set_pdg_id( particle->GetPDGcode() );
          // }
          // else if ( pdgcode == m_chargedgeantinoPdgId )
          // {
          //   G4ParticleDefinition* pd =
          //       G4ParticleTable::GetParticleTable()->FindParticle( "chargedgeantino" );
          //   particle = new G4PrimaryParticle( pd, p.x() * GeV, p.y() * GeV, p.z() * GeV );
          //   ( *pitr )->set_pdg_id( particle->GetPDGcode() );
          // }
          // pdgcode==0 dot define both in Geant4 and pdt.table
          // else if(pdgcode==0){
          //}
          // else
          // {
          particle = new G4PrimaryParticle( pdgcode, p.x() * GeV, p.y() * GeV, p.z() * GeV );
          // }
          // if ( !particle )
          // { G4cout << "ERROR! Cannot create particle PDGCode=" << pdgcode << G4endl; }
          // G4PrimaryParticle* particle = new G4PrimaryParticle(pdgcode);
          // particle->Set4Momentum(p.x()*GeV,p.y()*GeV,p.z()*GeV,p.t()*GeV);
          G4int ISTHEP = ( *pitr )->status();
 
          G4int barcodeEndVtx = 0;
          if ( ( *pitr )->end_vertex() ) barcodeEndVtx = ( *pitr )->end_vertex()->barcode();
 
          G4HepMCParticle* hepmcParticle =
              new G4HepMCParticle( particle, ISTHEP, barcodeEndVtx );
          HPlist.push_back( hepmcParticle );
 
          for ( size_t ii = 0; ii < HPlist.size(); ii++ )
          {
            if ( barcodeVtx == HPlist[ii]->GetBarcodeEndVtx() )
            {
              HPlist[ii]->GetTheParticle()->SetDaughter( particle );
              hepmcParticle->Done();
              break;
            }
          }
        }
      }
    }
  }
  else
  {
    for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
          vitr != hepmcevt->vertices_end(); ++vitr )
    {
      for ( HepMC::GenVertex::particle_iterator pitr =
                ( *vitr )->particles_begin( HepMC::children );
            pitr != ( *vitr )->particles_end( HepMC::children ); ++pitr )
      {
        G4int           ISTHEP = ( *pitr )->status();
        G4LorentzVector p;
        p.setX( ( *pitr )->momentum().x() );
        p.setY( ( *pitr )->momentum().y() );
        p.setZ( ( *pitr )->momentum().z() );
        p.setT( ( *pitr )->momentum().t() );
 
        G4int pdgcode       = ( *pitr )->pdg_id();
        G4int barcodeEndVtx = 0;
        if ( ( *pitr )->end_vertex() ) barcodeEndVtx = ( *pitr )->end_vertex()->barcode();
        G4PrimaryParticle* particle = 0;
        // geantino and chargedgeantino can't create through pdgcode;
        // their PdgID = 0 in Geant4.10.07.p02, and if particle->SetPDGcode(100), Geant4 will
        // not know. So reset PdgID of input HepMC::GenParticle to G4ParticleDefinition's; if
        // not, BesSensitiveManager::UpdatePrimaryTrack(const G4Track* track) will exit(1)
        // because MatchError.
        // if ( pdgcode == m_geantinoPdgId )
        // {
        //   G4ParticleDefinition* pd =
        //       G4ParticleTable::GetParticleTable()->FindParticle( "geantino" );
        //   particle = new G4PrimaryParticle( pd, p.x() * GeV, p.y() * GeV, p.z() * GeV );
        //   ( *pitr )->set_pdg_id( particle->GetPDGcode() );
        // }
        // else if ( pdgcode == m_chargedgeantinoPdgId )
        // {
        //   G4ParticleDefinition* pd =
        //       G4ParticleTable::GetParticleTable()->FindParticle( "chargedgeantino" );
        //   particle = new G4PrimaryParticle( pd, p.x() * GeV, p.y() * GeV, p.z() * GeV );
        //   ( *pitr )->set_pdg_id( particle->GetPDGcode() );
        // }
        // pdgcode==0 dot define both in Geant4 and pdt.table
        // else if(pdgcode==0){
        //}
        // else
        // {
        particle = new G4PrimaryParticle( pdgcode, p.x() * GeV, p.y() * GeV, p.z() * GeV );
        //    }
        // if ( !particle )
        // { G4cout << "ERROR! Cannot create particle PDGCode=" << pdgcode << G4endl; }
        // G4PrimaryParticle* particle = new G4PrimaryParticle(pdgcode);
        // particle->Set4Momentum(p.x()*GeV,p.y()*GeV,p.z()*GeV,p.t()*GeV);
 
        G4HepMCParticle* hepmcParticle =
            new G4HepMCParticle( particle, ISTHEP, barcodeEndVtx );
        HPlist.push_back( hepmcParticle );
        if ( ISTHEP > 1 ) hepmcParticle->Done();
      }
    }
  }
 
  // print particles in HPlist
  if ( m_logLevel <= 4 ) PrintHPlist();
 
  // get time and position information from G4Svc
  G4double pmPosX, pmPosY, pmPosZ, pmTime;
  G4double tmpPosX, tmpPosY, tmpPosZ, tmpT;
  G4double beamPosX = 0, beamPosY = 0, beamPosZ = 0, beamSizeX = 0, beamSizeY = 0,
           beamSizeZ = 0;
 
  if ( m_RealizationSvc->UseDBFlag() == false )
  {
    beamPosX = m_G4Svc->GetBeamPosX();
    beamPosY = m_G4Svc->GetBeamPosY();
    beamPosZ = m_G4Svc->GetBeamPosZ();
 
    beamSizeX = m_G4Svc->GetBeamSizeX();
    beamSizeY = m_G4Svc->GetBeamSizeY();
    beamSizeZ = m_G4Svc->GetBeamSizeZ() / sqrt( 2 );
  }
  if ( m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadBunch() == true )
  {
    beamPosX = m_RealizationSvc->getBunchPosX();
    beamPosY = m_RealizationSvc->getBunchPosY();
    beamPosZ = m_RealizationSvc->getBunchPosZ();
 
    beamSizeX = m_RealizationSvc->getBunchSizeX();
    beamSizeY = m_RealizationSvc->getBunchSizeY();
    beamSizeZ = m_RealizationSvc->getBunchSizeZ();
  }
  if ( m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadBunch() == false )
  {
    beamPosX = m_G4Svc->GetBeamPosX();
    beamPosY = m_G4Svc->GetBeamPosY();
    beamPosZ = m_G4Svc->GetBeamPosZ();
 
    beamSizeX = m_G4Svc->GetBeamSizeX();
    beamSizeY = m_G4Svc->GetBeamSizeY();
    beamSizeZ = m_G4Svc->GetBeamSizeZ() / sqrt( 2 );
  }
 
  G4double gaussX = G4RandGauss::shoot();
  G4double gaussY = G4RandGauss::shoot();
  G4double gaussZ = G4RandGauss::shoot();
  G4double gaussT = G4RandGauss::shoot();
 
  G4double beamStartTime  = m_G4Svc->GetBeamStartTime() * ns;
  G4double beamDeltaTime  = m_G4Svc->GetBeamDeltaTime() * ns;
  G4double nBunch         = m_G4Svc->GetNBunch();
  G4double bunchTimeSigma = m_G4Svc->GetBunchTimeSigma() * ns;
 
  G4double ran      = G4UniformRand();
  G4double beamTime = bunchTimeSigma * G4RandGauss::shoot() + beamStartTime +
                      beamDeltaTime * int( ran * nBunch );
 
  tmpPosX = ( beamPosX + beamSizeX * gaussX ) * mm;
  tmpPosY = ( beamPosY + beamSizeY * gaussY ) * mm;
  tmpPosZ = ( beamPosZ + beamSizeZ * gaussZ ) * mm;
  tmpT    = ( beamSizeZ * gaussT ) * mm / c_light + beamTime;
 
  G4LorentzVector tmpv( tmpPosX, tmpPosY, tmpPosZ, tmpT * c_light / mm );
 
  HepMC::GenEvent::vertex_const_iterator vitr0 = hepmcevt->vertices_begin();
  G4LorentzVector                        xvtx0;
  xvtx0.setX( ( *vitr0 )->position().x() );
  xvtx0.setY( ( *vitr0 )->position().y() );
  xvtx0.setZ( ( *vitr0 )->position().z() );
  xvtx0.setT( ( *vitr0 )->position().t() );
  pmPosX = xvtx0.x() * mm + tmpPosX;
  pmPosY = xvtx0.y() * mm + tmpPosY;
  pmPosZ = xvtx0.z() * mm + tmpPosZ;
  pmTime = xvtx0.t() * mm / c_light + tmpT;
 
  if ( m_logLevel <= 4 )
  {
    G4cout << G4endl;
    G4cout << xvtx0.x() << " " << xvtx0.y() << " " << xvtx0.z() << " " << beamSizeX * gaussX
           << " " << beamSizeY * gaussY << " " << beamSizeZ * gaussZ << " " << G4endl;
    G4cout << xvtx0.t() * mm / c_light << " " << beamSizeZ * gaussT / sqrt( 2 ) * mm / c_light
           << " " << beamTime << G4endl;
  }
  for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
        vitr != hepmcevt->vertices_end(); ++vitr )
  {
    G4LorentzVector xvtx;
    xvtx.setX( ( *vitr )->position().x() );
    xvtx.setY( ( *vitr )->position().y() );
    xvtx.setZ( ( *vitr )->position().z() );
    xvtx.setT( ( *vitr )->position().t() );
    ( *vitr )->set_position( xvtx + tmpv );
  }
  m_G4Svc->SetBeamTime( pmTime );
 
  G4PrimaryVertex* g4vtx = new G4PrimaryVertex( pmPosX, pmPosY, pmPosZ, pmTime );
 
  // put initial particles to the vertex
  for ( size_t ii = 0; ii < HPlist.size(); ii++ )
  {
    if ( HPlist[ii]->GetISTHEP() > 0 ) // ISTHEP of daughters had been
                                       // set to negative
    {
      G4PrimaryParticle* initialParticle = HPlist[ii]->GetTheParticle();
      g4vtx->SetPrimary( initialParticle );
    }
  }
 
  // clear G4HepMCInterface
  for ( size_t iii = 0; iii < HPlist.size(); iii++ ) { delete HPlist[iii]; }
  HPlist.clear();
 
  g4event->AddPrimaryVertex( g4vtx );
}

Referenced by G4SvcRunManager::GenerateEvent(), and GeneratePrimaryVertex().

Print()

void G4HepMCInterface::Print

(

const HepMC::GenEvent *

hepmcevt

)

Definition at line 131 of file G4HepMCInterface.cpp.

                                                            {
  G4int i = 0;
  for ( HepMC::GenEvent::vertex_const_iterator vitr = hepmcevt->vertices_begin();
        vitr != hepmcevt->vertices_end(); ++vitr )
  { // loop for vertex ...
    G4cout << G4endl << "vertex:" << i << "  barcode:" << ( *vitr )->barcode() << " ";
    i++;
    // if((*vitr)->mother())
    //   G4cout<<"mother particle: "<<(*vitr)->mother()-> pdg_id()<<"  ";
    // if((*vitr)->secondMother())
    //   G4cout<<" second mother: "<<(*vitr)->secondMother()-> pdg_id()<<G4endl;
    G4LorentzVector xvtx;
    xvtx.setX( ( *vitr )->position().x() );
    xvtx.setY( ( *vitr )->position().y() );
    xvtx.setZ( ( *vitr )->position().z() );
    xvtx.setT( ( *vitr )->position().t() );
    G4cout << "x:" << xvtx.x() << " y:" << xvtx.y() << " z:" << xvtx.z()
           << " t:" << xvtx.t() * mm / c_light << G4endl;
 
    G4int j = 0;
    for ( HepMC::GenVertex::particle_iterator pitr =
              ( *vitr )->particles_begin( HepMC::children );
          pitr != ( *vitr )->particles_end( HepMC::children ); ++pitr )
    {
      G4int           pdgcode = ( *pitr )->pdg_id();
      G4LorentzVector p;
      p.setX( ( *pitr )->momentum().x() );
      p.setY( ( *pitr )->momentum().y() );
      p.setZ( ( *pitr )->momentum().z() );
      p.setT( ( *pitr )->momentum().t() );
      G4cout << "particle:" << j << " pdgcode:" << pdgcode << " ";
      G4cout << "p:" << p.x() << " " << p.y() << " " << p.z() << " ";
      if ( ( *pitr )->end_vertex() )
        G4cout << "endVtx:" << ( *pitr )->end_vertex()->barcode() << " ";
      G4cout << "status:" << ( *pitr )->status() << G4endl;
      j++;
    }
  }
}

Referenced by HepMC2G4().

PrintHPlist()

void G4HepMCInterface::PrintHPlist

(

)

Definition at line 171 of file G4HepMCInterface.cpp.

                                   {
  G4cout << G4endl;
  G4cout << "particles sent to Geant4: " << G4endl;
  for ( size_t ii = 0; ii < HPlist.size(); ii++ )
  {
    G4int pdgcode = HPlist[ii]->GetTheParticle()->GetPDGcode();
    G4cout << pdgcode << " ";
  }
  G4cout << G4endl;
}

Referenced by HepMC2G4().

SetLogLevel()

void G4HepMCInterface::SetLogLevel ( G4int level )

inline

Definition at line 54 of file G4HepMCInterface.h.

{ m_logLevel = level; }

Referenced by G4SvcRunManager::GenerateEvent().

Member Data Documentation

hepmcEvent

HepMC::GenEvent* G4HepMCInterface::hepmcEvent

protected

Definition at line 64 of file G4HepMCInterface.h.

Referenced by G4HepMCInterface(), GeneratePrimaryVertex(), GetHepMCGenEvent(), and ~G4HepMCInterface().

HPlist

std::vector<G4HepMCParticle*> G4HepMCInterface::HPlist

Definition at line 82 of file G4HepMCInterface.h.

Referenced by HepMC2G4(), and PrintHPlist().

m_logLevel

G4int G4HepMCInterface::m_logLevel

protected

Definition at line 69 of file G4HepMCInterface.h.

Referenced by CheckType(), GetLogLevel(), HepMC2G4(), and SetLogLevel().

---

The documentation for this class was generated from the following files:

• G4HepMCInterface.h
• G4HepMCInterface.cpp