#include <GenModule.h>

Inheritance diagram for GenModule:

Public Member Functions
	GenModule (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~GenModule ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
virtual StatusCode	genInitialize ()
virtual StatusCode	genuserInitialize ()
virtual StatusCode	callGenerator ()
virtual StatusCode	genFinalize ()
virtual StatusCode	fillEvt (GenEvent *evt)
	GenModule (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~GenModule ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
virtual StatusCode	genInitialize ()
virtual StatusCode	genuserInitialize ()
virtual StatusCode	callGenerator ()
virtual StatusCode	genFinalize ()
virtual StatusCode	fillEvt (GenEvent *evt)
	GenModule (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~GenModule ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
virtual StatusCode	genInitialize ()
virtual StatusCode	genuserInitialize ()
virtual StatusCode	callGenerator ()
virtual StatusCode	genFinalize ()
virtual StatusCode	fillEvt (GenEvent *evt)

Protected Member Functions
void	StripPartonsInit (void)
void	StripPartons (GenEvent *evt)
void	StripPartonsInit (void)
void	StripPartons (GenEvent *evt)
void	StripPartonsInit (void)
void	StripPartons (GenEvent *evt)

Protected Attributes
bool	m_fixedMode
double	m_meanInteractions
int	m_randomSeed
std::vector< int >	m_AllPartons
std::vector< int >	m_StripVector
bool	m_StripPartonSwitch
CLHEP::HepRandomEngine *	m_pRandomEngine
CLHEP::RandPoisson *	m_pPoissonGenerator
HepPDT::ParticleDataTable *	m_particleTable

Detailed Description

Definition at line 41 of file GeneratorModule/include/GeneratorModule/GenModule.h.

Constructor & Destructor Documentation

◆ GenModule() [1/3]

GenModule::GenModule	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 37 of file GenModule.cxx.

    : Algorithm( name, pSvcLocator )
    , m_pRandomEngine( 0 )
    , m_pPoissonGenerator( 0 )
//---------------------------------------------------------------------------
{
  declareProperty( "FixedMode", m_fixedMode = true );
  declareProperty( "MeanInt", m_meanInteractions = 1.0 );
  declareProperty( "RandomSeed", m_randomSeed = 1234567 );
  declareProperty( "StripPartons", m_StripVector );
  m_StripVector.push_back( 0 );
}

Referenced by GenModule(), and SingleParticleGun::SingleParticleGun().

◆ ~GenModule() [1/3]

GenModule::~GenModule ( )

virtual

Definition at line 51 of file GenModule.cxx.

                      {
  // Delete random number objects if they were created
 
  if ( m_pPoissonGenerator ) delete m_pPoissonGenerator;
  if ( m_pRandomEngine ) delete m_pRandomEngine;
}

◆ GenModule() [2/3]

GenModule::GenModule	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

◆ ~GenModule() [2/3]

virtual GenModule::~GenModule ( )

virtual

◆ GenModule() [3/3]

GenModule::GenModule	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

◆ ~GenModule() [3/3]

virtual GenModule::~GenModule ( )

virtual

Member Function Documentation

◆ callGenerator() [1/3]

StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in SingleParticleGun.

Definition at line 217 of file GenModule.cxx.

                                    {
  //---------------------------------------------------------------------------
  return StatusCode::SUCCESS;
}

Referenced by execute().

◆ callGenerator() [2/3]

virtual StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in SingleParticleGun.

◆ callGenerator() [3/3]

virtual StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in SingleParticleGun.

◆ execute() [1/3]

StatusCode GenModule::execute ( )

Definition at line 124 of file GenModule.cxx.

                              {
  //---------------------------------------------------------------------------
 
  int        numToGenerate;
  StatusCode status;
 
  MsgStream log( msgSvc(), name() );
 
  log << MSG::DEBUG << "GenModule::execute()" << endmsg;
 
  // Decide how many interactions to generate
  if ( m_fixedMode ) { numToGenerate = (int)m_meanInteractions; }
  else { numToGenerate = m_pPoissonGenerator->fire(); }
 
  // Generate as many interactions as requested
  for ( int i = 0; i < numToGenerate; i++ )
  {
 
    // Call the code that generates an event
    status = this->callGenerator();
 
    // Create the MC event and send the GeneratorEvent stored in it to fillEvt
    GenEvent* evt = new GenEvent( 1, 1 );
    status        = this->fillEvt( evt );
 
    // Strip out the requested partons here.
    if ( m_StripPartonSwitch ) StripPartons( evt );
 
    // Check if the McCollection already exists
    SmartDataPtr<McGenEventCol> anMcCol( eventSvc(), "/Event/Gen" );
    if ( anMcCol != 0 )
    {
      // Add event to existing collection
      MsgStream log( msgSvc(), name() );
      log << MSG::INFO << "Add McGenEvent to existing collection" << endmsg;
      McGenEvent* mcEvent = new McGenEvent( evt );
      anMcCol->push_back( mcEvent );
    }
    else
    {
      // Create Collection and add  to the transient store
      McGenEventCol* mcColl  = new McGenEventCol;
      McGenEvent*    mcEvent = new McGenEvent( evt );
      mcColl->push_back( mcEvent );
 
      StatusCode sc = eventSvc()->registerObject( "/Event/Gen", mcColl );
 
      if ( sc != StatusCode::SUCCESS )
      {
        MsgStream log( msgSvc(), name() );
        log << MSG::ERROR << "Could not register McGenEvent" << endmsg;
        delete mcColl;
        delete evt;
        delete mcEvent;
        return StatusCode::FAILURE;
      }
      else
      {
        //        std::cout << " McGenEventCol made and stored" << std::endl;
      }
    }
  }
 
  // now call the incident service and set the signal.
  IIncidentSvc* incSvc;
  service( "IncidentSvc", incSvc );
  incSvc->fireIncident( Incident( name(), "McGenEvent Generated" ) );
 
  return status;
}

◆ execute() [2/3]

StatusCode GenModule::execute ( )

◆ execute() [3/3]

StatusCode GenModule::execute ( )

◆ fillEvt() [1/3]

StatusCode GenModule::fillEvt ( GenEvent * evt )

virtual

Reimplemented in SingleParticleGun.

Definition at line 229 of file GenModule.cxx.

                                           {
  //---------------------------------------------------------------------------
  return StatusCode::SUCCESS;
}

Referenced by execute().

◆ fillEvt() [2/3]

virtual StatusCode GenModule::fillEvt ( GenEvent * evt )

virtual

Reimplemented in SingleParticleGun.

◆ fillEvt() [3/3]

virtual StatusCode GenModule::fillEvt ( GenEvent * evt )

virtual

Reimplemented in SingleParticleGun.

◆ finalize() [1/3]

StatusCode GenModule::finalize ( )

Definition at line 196 of file GenModule.cxx.

                               {
  //---------------------------------------------------------------------------
 
  StatusCode status = this->genFinalize();
 
  return status;
}

◆ finalize() [2/3]

StatusCode GenModule::finalize ( )

◆ finalize() [3/3]

StatusCode GenModule::finalize ( )

◆ genFinalize() [1/3]

StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in SingleParticleGun.

Definition at line 223 of file GenModule.cxx.

                                  {
  //---------------------------------------------------------------------------
  return StatusCode::SUCCESS;
}

Referenced by finalize().

◆ genFinalize() [2/3]

virtual StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in SingleParticleGun.

◆ genFinalize() [3/3]

virtual StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in SingleParticleGun.

◆ genInitialize() [1/3]

StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in SingleParticleGun.

Definition at line 205 of file GenModule.cxx.

                                    {
  //---------------------------------------------------------------------------
  return StatusCode::SUCCESS;
}

Referenced by initialize().

◆ genInitialize() [2/3]

virtual StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in SingleParticleGun.

◆ genInitialize() [3/3]

virtual StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in SingleParticleGun.

◆ genuserInitialize() [1/3]

StatusCode GenModule::genuserInitialize ( )

virtual

Definition at line 211 of file GenModule.cxx.

                                        {
  //---------------------------------------------------------------------------
  return StatusCode::SUCCESS;
}

Referenced by initialize().

◆ genuserInitialize() [2/3]

virtual StatusCode GenModule::genuserInitialize ( )

virtual

◆ genuserInitialize() [3/3]

virtual StatusCode GenModule::genuserInitialize ( )

virtual

◆ initialize() [1/3]

StatusCode GenModule::initialize ( )

Definition at line 60 of file GenModule.cxx.

                                 {
  //---------------------------------------------------------------------------
 
  // Inform the user what the mode and conditions are:
  MsgStream log( msgSvc(), name() );
 
  // Initialize StripPartons variables
  if ( m_StripVector[0] > 0 ) { StripPartonsInit(); }
  else
  {
    m_StripPartonSwitch = false;
    m_StripVector.clear();
  }
 
  // Get the Particle Properties Service
  IPartPropSvc* p_PartPropSvc;
  // static const bool CREATEIFNOTTHERE(true);
  // StatusCode PartPropStatus = service("PartPropSvc", p_PartPropSvc, CREATEIFNOTTHERE);
  StatusCode PartPropStatus = service( "PartPropSvc", p_PartPropSvc );
  if ( !PartPropStatus.isSuccess() || 0 == p_PartPropSvc )
  {
    log << MSG::ERROR << " Could not initialize Particle Properties Service" << endmsg;
    return PartPropStatus;
  }
 
  m_particleTable = p_PartPropSvc->PDT();
 
  m_pRandomEngine = new CLHEP::Ranlux64Engine( m_randomSeed );
 
  if ( m_fixedMode )
  {
    if ( m_meanInteractions == 1.0 )
    { log << MSG::INFO << "Standard Initialization:  Single Interaction Mode " << endmsg; }
    else
    {
      log << MSG::INFO << "Fixed Number of Interactions per Event is: " << m_meanInteractions
          << endmsg;
    }
  }
  else
  {
    m_pPoissonGenerator = new CLHEP::RandPoisson( *m_pRandomEngine, m_meanInteractions );
 
    log << MSG::INFO
        << "Poisson Distribution of Interactions per Event with Mean: " << m_meanInteractions
        << endmsg;
  }
  // Initialize the generator itself
  StatusCode status = this->genInitialize();
  if ( status.isFailure() )
  {
    log << MSG::ERROR << "Could not initialize Generator properly" << endmsg;
    return status;
  }
  StatusCode status1 = this->genuserInitialize();
  if ( status1.isFailure() )
  {
    log << MSG::ERROR << "Could not initialize user part properly" << endmsg;
    return status1;
  }
  return status;
}

◆ initialize() [2/3]

StatusCode GenModule::initialize ( )

◆ initialize() [3/3]

StatusCode GenModule::initialize ( )

◆ StripPartons() [1/3]

void GenModule::StripPartons ( GenEvent * evt )

protected

Definition at line 277 of file GenModule.cxx.

                                            {
  //    for ( HepMC::GenEvent::particle_iterator p = evt->particles_begin();
  //          p != evt->particles_end(); ++p )
  //    {
  //  //        std::cout << " PDG, BAR " << (*p)->pdg_id() << " " << (*p)->barcode() <<
  //  std::endl;        if ( std::find(m_StripVector.begin(),              m_StripVector.end(),
  //               (*p)->pdg_id()) != m_StripVector.end() )
  //        {
  //  //        std::cout << " REMOVING " << (*p)->pdg_id() << " " << (*p)->barcode()
  //  << std::endl;         HepMC::GenVertex*   pvtx    =   (*p)->production_vertex();
  //        HepMC::GenVertex*   evtx    =   (*p)->end_vertex();
  //        if (pvtx) pvtx->remove_particle(*p);
  //        if (evtx) evtx->remove_particle(*p);
  //        delete  *p;
  //        }
 
  //    }
 
  // Loop on all vertices of the event and remove the particle from the vertex
  for ( HepMC::GenEvent::vertex_iterator vtx = evt->vertices_begin();
        vtx != evt->vertices_end(); ++vtx )
  {
    // Loop on all children particles and remove the ones that should be stripped out
    for ( HepMC::GenVertex::particle_iterator p = ( *vtx )->particles_begin( HepMC::children );
          p != ( *vtx )->particles_end( HepMC::children ); ++p )
    {
      if ( std::find( m_StripVector.begin(), m_StripVector.end(), ( *p )->pdg_id() ) !=
           m_StripVector.end() )
      {
        if ( ( *p )->end_vertex() ) ( *p )->end_vertex()->remove_particle( *p );
        if ( ( *p )->production_vertex() ) ( *p )->production_vertex()->remove_particle( *p );
        delete *p;
      }
    }
    // Loop on all parents particles and remove the ones that should be stripped out
    for ( HepMC::GenVertex::particle_iterator p = ( *vtx )->particles_begin( HepMC::parents );
          p != ( *vtx )->particles_end( HepMC::parents ); ++p )
    {
      if ( std::find( m_StripVector.begin(), m_StripVector.end(), ( *p )->pdg_id() ) !=
           m_StripVector.end() )
      {
        if ( ( *p )->end_vertex() ) ( *p )->end_vertex()->remove_particle( *p );
        if ( ( *p )->production_vertex() ) ( *p )->production_vertex()->remove_particle( *p );
        delete *p;
      }
    }
  }
}

Referenced by execute().

◆ StripPartons() [2/3]

void GenModule::StripPartons ( GenEvent * evt )

protected

◆ StripPartons() [3/3]

void GenModule::StripPartons ( GenEvent * evt )

protected

◆ StripPartonsInit() [1/3]

void GenModule::StripPartonsInit ( void )

protected

Definition at line 234 of file GenModule.cxx.

                                       {
  MsgStream log( msgSvc(), name() );
 
  for ( int i = 1; i < 9; ++i )
  {
    m_AllPartons.push_back( i );
    m_AllPartons.push_back( -i );
  }                             // Quarks
  m_AllPartons.push_back( 21 ); // gluon
 
  m_StripPartonSwitch = true;
  m_StripVector.erase( m_StripVector.begin(), m_StripVector.begin() + 1 );
  // When the user specifies only the StripPartonSwitch or gives a Particle Code
  // which is NOT a parton then strip ALL partons
  if ( m_StripVector.size() == 0 )
  {
    log << MSG::INFO << " !!!! NO SPECIFIC PARTON FOR STRIPOUT WAS REQUESTED => STRIPOUT ALL "
        << endmsg;
    m_StripVector = m_AllPartons;
  }
  else
  {
    bool                             value_ok = true;
    std::vector<int>::const_iterator i        = m_StripVector.begin();
    do {
      if ( std::find( m_AllPartons.begin(), m_AllPartons.end(), *i ) == m_AllPartons.end() )
        value_ok = false;
      ++i;
    } while ( i != m_StripVector.end() && value_ok );
    if ( !value_ok )
    {
      log << MSG::INFO << " !!!! ILEGAL PDG-ID FOR STRIPOUT WAS REQUESTED => STRIPOUT ALL "
          << endmsg;
      m_StripVector = m_AllPartons;
    }
  }
  log << MSG::INFO << " THE FOLLOWING PARTON(S) WILL BE STRIPED OUT ";
  for ( std::vector<int>::const_iterator ip = m_StripVector.begin(); ip != m_StripVector.end();
        ++ip )
    log << *ip << "  ";
  log << endmsg;
}