GenModule Class Reference

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

Protected Member Functions
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 GenModule.h.

Constructor & Destructor Documentation

GenModule()

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

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;
 
} 

Member Function Documentation

callGenerator()

StatusCode GenModule::callGenerator ( )

virtual

Reimplemented in BesGenModule, and SingleParticleGun.

Definition at line 218 of file GenModule.cxx.

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

Referenced by execute().

execute()

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;
}

fillEvt()

StatusCode GenModule::fillEvt ( GenEvent *  evt )

virtual

Reimplemented in BesGenModule, and SingleParticleGun.

Definition at line 230 of file GenModule.cxx.

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

Referenced by execute().

finalize()

StatusCode GenModule::finalize

(

)

Definition at line 197 of file GenModule.cxx.

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

genFinalize()

StatusCode GenModule::genFinalize ( )

virtual

Reimplemented in BesGenModule, and SingleParticleGun.

Definition at line 224 of file GenModule.cxx.

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

Referenced by finalize().

genInitialize()

StatusCode GenModule::genInitialize ( )

virtual

Reimplemented in BesGenModule, and SingleParticleGun.

Definition at line 206 of file GenModule.cxx.

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

Referenced by initialize().

genuserInitialize()

StatusCode GenModule::genuserInitialize ( )

virtual

Definition at line 212 of file GenModule.cxx.

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

Referenced by initialize().

initialize()

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;
}

StripPartons()

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().

StripPartonsInit()

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;
  
}

Referenced by initialize().

Member Data Documentation

m_AllPartons

std::vector<int> GenModule::m_AllPartons

protected

Definition at line 60 of file GenModule.h.

Referenced by StripPartonsInit().

m_fixedMode

bool GenModule::m_fixedMode

protected

Definition at line 57 of file GenModule.h.

Referenced by execute(), and initialize().

m_meanInteractions

double GenModule::m_meanInteractions

protected

Definition at line 58 of file GenModule.h.

Referenced by execute(), and initialize().

m_particleTable

HepPDT::ParticleDataTable* GenModule::m_particleTable

protected

Definition at line 73 of file GenModule.h.

Referenced by SingleParticleGun::genInitialize(), and initialize().

m_pPoissonGenerator

CLHEP::RandPoisson* GenModule::m_pPoissonGenerator

protected

Definition at line 68 of file GenModule.h.

Referenced by execute(), initialize(), and ~GenModule().

m_pRandomEngine

CLHEP::HepRandomEngine* GenModule::m_pRandomEngine

protected

Definition at line 67 of file GenModule.h.

Referenced by initialize(), and ~GenModule().

m_randomSeed

int GenModule::m_randomSeed

protected

Definition at line 59 of file GenModule.h.

Referenced by initialize().

m_StripPartonSwitch

bool GenModule::m_StripPartonSwitch

protected

Definition at line 62 of file GenModule.h.

Referenced by execute(), initialize(), and StripPartonsInit().

m_StripVector

std::vector<int> GenModule::m_StripVector

protected

Definition at line 61 of file GenModule.h.

Referenced by initialize(), StripPartons(), and StripPartonsInit().

---

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

• GenModule.h
• GenModule.cxx