SingleParticleGun Class Reference

#include <SingleParticleGun.h>

Inheritance diagram for SingleParticleGun:

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

Additional Inherited Members
Protected Member Functions inherited from GenModule
void	StripPartonsInit (void)
void	StripPartons (GenEvent *evt)
Protected Attributes inherited from GenModule
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 42 of file SingleParticleGun.h.

Constructor & Destructor Documentation

SingleParticleGun()

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

Definition at line 34 of file SingleParticleGun.cxx.

  : GenModule(name,pSvcLocator)
{
//--------------------------------------------------------------------------  
  declareProperty("Mode",m_Emode =  SingleEnergyMode::PtMode);
  // in PtMode user specifies Pt theta and phi
  // in EMode user specifies E, theta and phi 
  // defaults are set so that something is always generated
 
  declareProperty("Pt",m_requestedPt = 5.0); 
  declareProperty("E",m_requestedE = 5.0); 
  declareProperty("Phi",m_requestedPhi = 0.0);  
  declareProperty("Theta",m_requestedTheta = 3.14/4.0);  
 
  declareProperty("VertexX",m_requestedX = 0.0); 
  declareProperty("VertexY",m_requestedY = 0.0); 
  declareProperty("VertexZ",m_requestedZ = 0.0); 
  declareProperty("Time",m_requestedT = 0.0); 
 
  declareProperty("MinPt",m_minPt = 1.); 
  declareProperty("MinE",m_minE = 1.); 
  declareProperty("MinTheta",m_minTheta = 0.); 
  declareProperty("MinPhi",m_minPhi = 0.); 
 
  declareProperty("MaxPt",m_maxPt = 100.); 
  declareProperty("MaxE",m_maxE = 100.); 
  declareProperty("MaxTheta",m_maxTheta=CLHEP::pi); 
  declareProperty("MaxPhi",m_maxPhi = CLHEP::twopi); 
 
  declareProperty("SigmaPt",m_sigmaPt = 0.1); 
  declareProperty("SigmaE",m_sigmaE = 0.1); 
 
  declareProperty("SigmaTheta",m_sigmaTheta= 0.1); 
  declareProperty("SigmaPhi",m_sigmaPhi = 0.1); 
 
  declareProperty("ModePt",m_PtGenMode = SingleParticleGunGenMode::FixedMode); 
  declareProperty("ModeE",m_EGenMode = SingleParticleGunGenMode::FixedMode); 
  declareProperty("ModeTheta",m_ThetaGenMode=SingleParticleGunGenMode::FixedMode); 
 
  declareProperty("ModePhi",m_PhiGenMode=SingleParticleGunGenMode::FixedMode);
  // specifies type of distribution
 
  declareProperty("PdgCode",m_pdgCode=211);
}

~SingleParticleGun()

SingleParticleGun::~SingleParticleGun ( )

virtual

Definition at line 80 of file SingleParticleGun.cxx.

                                      {
//--------------------------------------------------------------------------
//   if(m_pFlatGenerator)  delete m_pFlatGenerator;
//   if(m_pGaussGenerator) delete m_pGaussGenerator;
}

Member Function Documentation

callGenerator()

StatusCode SingleParticleGun::callGenerator ( )

virtual

Reimplemented from GenModule.

Definition at line 158 of file SingleParticleGun.cxx.

                                            {
//---------------------------------------------------------------------------
 
  ++m_events;
  // Save the random number seeds in the event
  CLHEP::HepRandomEngine*   engine  =   p_BesRndmGenSvc->GetEngine("SINGLE");
  const long*       s   =   engine->getSeeds();
  m_seeds.clear();
  m_seeds.push_back(s[0]);
  m_seeds.push_back(s[1]);
 
 // Generate values for pt, theta and phi
 //
  double pt,phi,theta,E,px,py,pz,p;
  switch(m_Emode){
 
  case SingleEnergyMode::PtMode:
 pt = generateValue(m_PtGenMode,m_requestedPt, m_sigmaPt, 
                           m_minPt, m_maxPt);
 theta = generateValue(m_ThetaGenMode,m_requestedTheta, m_sigmaTheta, 
                           m_minTheta, m_maxTheta);
 phi = generateValue(m_PhiGenMode,m_requestedPhi, m_sigmaPhi, 
                           m_minPhi, m_maxPhi);
 
 // Transform to x,y,z coordinates
 //
 px = pt*cos(phi);
 py = pt*sin(phi);
 pz = pt/tan(theta);
 m_fourMom.setVectM(CLHEP::Hep3Vector(px,py,pz),m_mass);
 m_fourPos.set(m_requestedX,m_requestedY,m_requestedZ,m_requestedT);
 return StatusCode::SUCCESS;
 
 case SingleEnergyMode::EMode:
 E = generateValue(m_EGenMode,m_requestedE, m_sigmaE, 
                           m_minE, m_maxE);
 theta = generateValue(m_ThetaGenMode,m_requestedTheta, m_sigmaTheta, 
                           m_minTheta, m_maxTheta);
 phi = generateValue(m_PhiGenMode,m_requestedPhi, m_sigmaPhi, 
                           m_minPhi, m_maxPhi);
 
 // Transform to x,y,z coordinates
 //
 if(E*E-m_mass*m_mass < 0.){
 MsgStream log(messageService(), name());
 log << MSG::ERROR  << "You have Generated a Tachyon!! Increase energy or change particle ID" << endreq;   
return StatusCode::FAILURE;
 }
 p=sqrt(E*E-m_mass*m_mass);
 px = p*sin(theta)*cos(phi);
 py = p*sin(theta)*sin(phi);
 pz = p*cos(theta);
 
 m_fourMom.setVectM(CLHEP::Hep3Vector(px,py,pz),m_mass);
 m_fourPos.set(m_requestedX,m_requestedY,m_requestedZ,m_requestedT);
 return StatusCode::SUCCESS;
}  
 return StatusCode::SUCCESS;
}

fillEvt()

StatusCode SingleParticleGun::fillEvt ( GenEvent * evt )

virtual

Reimplemented from GenModule.

Definition at line 225 of file SingleParticleGun.cxx.

                                                   {
//---------------------------------------------------------------------------
  // Note:  The vertex is owned by the event so the event is responsible
  // for deleting its memory
  evt->set_event_number(m_events); // Set the event number
  GenVertex* v1 = new GenVertex(m_fourPos);
 
  std::cout << " SingleParticleGun::fillEvt --> " <<std::endl;
  std::cout << " Event number:: " << m_events << std::endl; 
  std::cout << " vertex.x = " << m_fourPos.x() 
            << " vertex.y = " << m_fourPos.y() 
            << " vertex.z = " << m_fourPos.z() 
            << " vertex.t = " << m_fourPos.t() <<  std::endl;
 
  std::cout << " momentum.x = " << m_fourMom.x() 
            << " momentum.y = " << m_fourMom.y() 
            << " momentum.z = " << m_fourMom.z() 
            << " momentum.t = " << m_fourMom.t() <<  std::endl;
 
  evt->add_vertex( v1 );
 
 
  v1->add_particle_out( new GenParticle( m_fourMom, m_pdgCode,1) );
 
  std::cout << " particles_size = " << evt->particles_size() 
        << " vertices_size = " << evt->vertices_size()
        << std::endl;
 
  evt->set_signal_process_id(SINGLE);
  evt->set_random_states(m_seeds);
 
 return StatusCode::SUCCESS;
}

genFinalize()

StatusCode SingleParticleGun::genFinalize ( )

virtual

Reimplemented from GenModule.

Definition at line 219 of file SingleParticleGun.cxx.

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

genInitialize()

StatusCode SingleParticleGun::genInitialize ( )

virtual

Reimplemented from GenModule.

Definition at line 87 of file SingleParticleGun.cxx.

                                            {
//---------------------------------------------------------------------------
 
 // Create the flat and gaussian generators
 //
 
 MsgStream log(messageService(), name());
 
 static const bool CREATEIFNOTTHERE(true);
 StatusCode RndmStatus = service("BesRndmGenSvc", p_BesRndmGenSvc, CREATEIFNOTTHERE);
 if (!RndmStatus.isSuccess() || 0 == p_BesRndmGenSvc)
 {
   log << MSG::ERROR << " Could not initialize Random Number Service" << endreq;
   return RndmStatus;
 }  
 
 // Get the mass of the particle to be generated
 //
 const HepPDT::ParticleData* particle = m_particleTable->particle(HepPDT::ParticleID(abs(m_pdgCode)));
 // Some particle can't be found in HepPDT, such as geantino
 m_mass = particle?particle->mass().value():0;
 
 // 
 // Make sure the parameters are in a sensible range...
 //
 switch (m_Emode){
 case SingleEnergyMode::PtMode:
 if(!m_PtGenMode && (m_minPt > m_requestedPt || m_maxPt < m_requestedPt)
      || m_maxPt < m_minPt ) {
   log << MSG:: ERROR << " Pt min and max out of range.  \n" <<
       "     Will set Pt mode to Fixed!!!" << endreq;
   m_PtGenMode = SingleParticleGunGenMode::FixedMode;
 }
 if(!m_ThetaGenMode && (m_minTheta > m_requestedTheta || m_maxTheta < m_requestedTheta) 
      || m_maxTheta < m_minTheta ) {
   log << MSG:: ERROR << " Theta min and max out of range. \n" <<
       "     Will set Theta mode to Fixed!!!" << endreq;
   m_ThetaGenMode = SingleParticleGunGenMode::FixedMode;
 }
 if(!m_PhiGenMode && (m_minPhi > m_requestedPhi || m_maxPhi < m_requestedPhi)
      || m_maxPhi < m_minPhi ) {
   log << MSG:: ERROR << " Phi min and max out of range.  \n" <<
       "     Will set Phi mode to Fixed!!!" << endreq;
   m_PhiGenMode = SingleParticleGunGenMode::FixedMode;
 }
 break;
 case SingleEnergyMode::EMode:
 if(!m_EGenMode && (m_minE > m_requestedE || m_maxE < m_requestedE)
      || m_maxE < m_minE ) {
   log << MSG:: ERROR << " E min and max out of range.  \n" <<
       "     Will set E mode to Fixed!!!" << endreq;
   m_EGenMode = SingleParticleGunGenMode::FixedMode;
 }
 if(!m_ThetaGenMode && (m_minTheta > m_requestedTheta || m_maxTheta < m_requestedTheta) 
      || m_maxTheta < m_minTheta ) {
   log << MSG:: ERROR << " Theta min and max out of range. \n" <<
       "     Will set Theta mode to Fixed!!!" << endreq;
   m_ThetaGenMode = SingleParticleGunGenMode::FixedMode;
 }
 if(!m_PhiGenMode && (m_minPhi > m_requestedPhi || m_maxPhi < m_requestedPhi)
      || m_maxPhi < m_minPhi ) {
   log << MSG:: ERROR << " Phi min and max out of range.  \n" <<
       "     Will set Phi mode to Fixed!!!" << endreq;
   m_PhiGenMode = SingleParticleGunGenMode::FixedMode;
 }break;
 }
  m_events = 0;
 return StatusCode::SUCCESS;
}

---

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

• SingleParticleGun.h
• SingleParticleGun.cxx