#include <PhysicsConfigurationHelper.h>

Collaboration diagram for PhysicsConfigurationHelper:

Public Member Functions
bool	Resonant () const

bool	ReggeModel () const

double	ResonanceEnergy () const

double	XsecMultiplier () const

double	Gamma () const

double	Amplitude () const

double	SuppressionFactor () const

double	Lifetime () const

double	Mixing () const

int	DoDecays () const

Static Public Member Functions
static const PhysicsConfigurationHelper *	Instance ()

Protected Member Functions
	PhysicsConfigurationHelper ()

	PhysicsConfigurationHelper (const PhysicsConfigurationHelper &)

PhysicsConfigurationHelper &	operator= (const PhysicsConfigurationHelper &)

Private Member Functions
void	ReadAndParse (const G4String &str, std::vector< G4String > &tokens, const G4String &delimiters=" ") const

void	ReadInPhysicsParameters (std::map< G4String, G4double > &parameters) const

Private Attributes
bool	m_resonant {false}

bool	m_reggemodel {false}

double	m_ek_0 {0.}

double	m_gamma {0.}

double	m_amplitude {0.}

double	m_xsecmultiplier {1.}

double	m_suppressionfactor {0.}

double	m_hadronlifetime {0.}

double	m_mixing {0.}

int	m_doDecays {0}

Detailed Description

Definition at line 14 of file PhysicsConfigurationHelper.h.

Constructor & Destructor Documentation

◆ PhysicsConfigurationHelper() [1/2]

PhysicsConfigurationHelper::PhysicsConfigurationHelper ( )

protected

Definition at line 12 of file PhysicsConfigurationHelper.cxx.

 {
   G4cout << "PhysicsConfigurationHelper constructor: start" << G4endl;
  
   std::map<G4String,G4double> parameters;
   ReadInPhysicsParameters(parameters);
   if (parameters["Resonant"]!=0.) m_resonant=true;
   m_ek_0 = parameters["ResonanceEnergy"]*CLHEP::GeV;
   m_gamma = parameters["Gamma"]*CLHEP::GeV;
   m_amplitude = parameters["Amplitude"]*CLHEP::millibarn;
   m_xsecmultiplier = parameters["XsecMultiplier"];
   m_suppressionfactor = parameters["ReggeSuppression"];
   m_hadronlifetime = parameters["HadronLifeTime"];
   m_mixing = parameters["Mixing"];
   if (parameters["ReggeModel"]!=0.) m_reggemodel=true;
   m_doDecays=parameters["DoDecays"];
  
   G4cout<<"Read in physics parameters:"<<G4endl;
   G4cout<<"Resonant = "<< m_resonant <<G4endl;
   G4cout<<"ResonanceEnergy = "<<m_ek_0/CLHEP::GeV<<" GeV"<<G4endl;
   G4cout<<"XsecMultiplier = "<<m_xsecmultiplier<<G4endl;
   G4cout<<"Gamma = "<<m_gamma/CLHEP::GeV<<" GeV"<<G4endl;
   G4cout<<"Amplitude = "<<m_amplitude/CLHEP::millibarn<<" millibarn"<<G4endl;
   G4cout<<"ReggeSuppression = "<<100*m_suppressionfactor<<" %"<<G4endl;
   G4cout<<"HadronLifeTime = "<<m_hadronlifetime;
   if (m_doDecays) G4cout<<" ns"<<G4endl;
   else G4cout<<" s"<<G4endl;
   G4cout<<"ReggeModel = "<< m_reggemodel <<G4endl;
   G4cout<<"Mixing = "<< m_mixing*100 <<" %"<<G4endl;
   G4cout<<"DoDecays = "<< m_doDecays << G4endl;
  
   if ((!m_doDecays && m_hadronlifetime>0.) ||
       (m_doDecays && m_hadronlifetime<=0.) ){
     G4cout << "WARNING: Inconsistent treatment of R-Hadron properties! Lifetime of " << m_hadronlifetime
            << " and doDecays= " << m_doDecays << G4endl;
   }
  
   return;
 }

◆ PhysicsConfigurationHelper() [2/2]

PhysicsConfigurationHelper::PhysicsConfigurationHelper ( const PhysicsConfigurationHelper & )

protected

Member Function Documentation

◆ Amplitude()

double PhysicsConfigurationHelper::Amplitude ( ) const

inline

Definition at line 24 of file PhysicsConfigurationHelper.h.

24 { return m_amplitude; }

◆ DoDecays()

int PhysicsConfigurationHelper::DoDecays ( ) const

inline

Definition at line 28 of file PhysicsConfigurationHelper.h.

28 { return m_doDecays; }

◆ Gamma()

double PhysicsConfigurationHelper::Gamma ( ) const

inline

Definition at line 23 of file PhysicsConfigurationHelper.h.

23 { return m_gamma; }

◆ Instance()

const PhysicsConfigurationHelper * PhysicsConfigurationHelper::Instance ( )

static

Definition at line 53 of file PhysicsConfigurationHelper.cxx.

 {
   static const PhysicsConfigurationHelper instance;
   return &instance;
 }

◆ Lifetime()

double PhysicsConfigurationHelper::Lifetime ( ) const

inline

Definition at line 26 of file PhysicsConfigurationHelper.h.

26 { return (m_doDecays == 1) ? m_hadronlifetime * CLHEP::ns : m_hadronlifetime * CLHEP::s; }

◆ Mixing()

double PhysicsConfigurationHelper::Mixing ( ) const

inline

Definition at line 27 of file PhysicsConfigurationHelper.h.

27 { return m_mixing; }

◆ operator=()

PhysicsConfigurationHelper& PhysicsConfigurationHelper::operator= ( const PhysicsConfigurationHelper & )

protected

◆ ReadAndParse()

void PhysicsConfigurationHelper::ReadAndParse	(	const G4String &	str,
		std::vector< G4String > &	tokens,
		const G4String &	delimiters = `" "`
	)		const

private

Definition at line 88 of file PhysicsConfigurationHelper.cxx.

 {
   // Skip delimiters at beginning.
   G4String::size_type lastPos = str.find_first_not_of(delimiters, 0);
   if (lastPos==G4String::npos) return;
  
   // Find first "non-delimiter".
   G4String::size_type pos     = str.find_first_of(delimiters, lastPos);
  
   while (G4String::npos != pos || G4String::npos != lastPos)
     {
       //Skipping leading / trailing whitespaces
       G4String temp = str.substr(lastPos, pos - lastPos);
       while(temp.c_str()[0] == ' ') temp.erase(0,1);
       while(temp[temp.size()-1] == ' ') temp.erase(temp.size()-1,1);
  
       // Found a token, add it to the vector.
       tokens.push_back(std::move(temp));
  
       // Skip delimiters.  Note the "not_of"
       lastPos = str.find_first_not_of(delimiters, pos);
       if (lastPos==G4String::npos) continue;
  
       // Find next "non-delimiter"
       pos = str.find_first_of(delimiters, lastPos);
     }
 }

◆ ReadInPhysicsParameters()

void PhysicsConfigurationHelper::ReadInPhysicsParameters ( std::map< G4String, G4double > & parameters ) const

private

Definition at line 60 of file PhysicsConfigurationHelper.cxx.

   {
     parameters["Resonant"]=0.;
     parameters["ResonanceEnergy"]=0.;
     parameters["XsecMultiplier"]=1.;
     parameters["Gamma"]=0.;
     parameters["Amplitude"]=0.;
     parameters["ReggeSuppression"]=0.;
     parameters["HadronLifeTime"]=0.;
     parameters["ReggeModel"]=0.;
     parameters["Mixing"]=0.;
     parameters["DoDecays"]=0;
  
     std::ifstream physics_stream ("PhysicsConfiguration.txt");
     G4String line;
     char** endptr=0;
     while (getline(physics_stream,line)) {
       std::vector<G4String> tokens;
       //Getting a line
       ReadAndParse(line,tokens,"=");
       G4String key = tokens[0];
       G4double val = strtod(tokens[1],endptr);
       parameters[key]=val;
     }
     physics_stream.close();
   }