#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)

Protected Member Functions
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 Generator/GeneratorModule/GeneratorModule-00-01-05/GeneratorModule/GenModule.h.

Constructor & Destructor Documentation

◆ GenModule() [1/2]

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

Definition at line 38 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);
 
}

◆ ~GenModule() [1/2]

GenModule::~GenModule ( )

virtual

Definition at line 53 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/2]

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

◆ ~GenModule() [2/2]

virtual GenModule::~GenModule ( )

virtual

Member Function Documentation

◆ callGenerator() [1/2]

StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

Definition at line 218 of file GenModule.cxx.

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

Referenced by execute().

◆ callGenerator() [2/2]

virtual StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

◆ execute() [1/2]

StatusCode GenModule::execute ( )

Definition at line 125 of file GenModule.cxx.

                              {
  //---------------------------------------------------------------------------
    
  int numToGenerate;
  StatusCode status;
 
  MsgStream log(messageService(), name());
 
  log << MSG::DEBUG << "GenModule::execute()" << endreq;
 
  // 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(messageService(), name());
      log << MSG::INFO << "Add McGenEvent to existing collection" << endreq;
      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(messageService(), name());
    log << MSG::ERROR << "Could not register McGenEvent" << endreq;
    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/2]

StatusCode GenModule::execute ( )

◆ fillEvt() [1/2]

StatusCode GenModule::fillEvt ( GenEvent * evt )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

Definition at line 230 of file GenModule.cxx.

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

Referenced by execute().

◆ fillEvt() [2/2]

virtual StatusCode GenModule::fillEvt ( GenEvent * evt )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

◆ finalize() [1/2]

StatusCode GenModule::finalize ( )

Definition at line 197 of file GenModule.cxx.

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

◆ finalize() [2/2]

StatusCode GenModule::finalize ( )

◆ genFinalize() [1/2]

StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

Definition at line 224 of file GenModule.cxx.

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

Referenced by finalize().

◆ genFinalize() [2/2]

virtual StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

◆ genInitialize() [1/2]

StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

Definition at line 206 of file GenModule.cxx.

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

Referenced by initialize().

◆ genInitialize() [2/2]

virtual StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in BesGenModule, SingleParticleGun, BesGenModule, and SingleParticleGun.

◆ genuserInitialize() [1/2]

StatusCode GenModule::genuserInitialize ( )

virtual

Definition at line 212 of file GenModule.cxx.

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

Referenced by initialize().

◆ genuserInitialize() [2/2]

virtual StatusCode GenModule::genuserInitialize ( )

virtual

◆ initialize() [1/2]

StatusCode GenModule::initialize ( )

Definition at line 63 of file GenModule.cxx.

                                {
  //---------------------------------------------------------------------------
 
  // Inform the user what the mode and conditions are:
  MsgStream log(messageService(), 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" << endreq;
    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 "
      << endreq;
    }
    else {
      log << MSG::INFO << "Fixed Number of Interactions per Event is: "
      << m_meanInteractions << endreq;
    }
  }
  else {
    m_pPoissonGenerator = new CLHEP::RandPoisson(*m_pRandomEngine, 
                      m_meanInteractions);
 
    log << MSG::INFO << 
      "Poisson Distribution of Interactions per Event with Mean: "
        << m_meanInteractions << endreq;
  }
  // Initialize the generator itself
  StatusCode status = this->genInitialize();
  if (status.isFailure()) {
    log << MSG::ERROR << "Could not initialize Generator properly" << endreq;
    return status;
  }  
  StatusCode  status1 = this->genuserInitialize();
  if (status1.isFailure()) {
    log << MSG::ERROR << "Could not initialize user part properly" << endreq;
    return status1;
  } 
  return status;
}

◆ initialize() [2/2]

StatusCode GenModule::initialize ( )

◆ StripPartons() [1/2]

void GenModule::StripPartons ( GenEvent * evt )

protected

Definition at line 274 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/2]

void GenModule::StripPartons ( GenEvent * evt )

protected

◆ StripPartonsInit() [1/2]

void GenModule::StripPartonsInit ( void )

protected

Definition at line 236 of file GenModule.cxx.

{
  MsgStream log(messageService(), 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 "
    << endreq;
    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 "
      << endreq;
      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 << endreq;
  
}