BeamHaloGeneratorSettings Class Reference

A class to read a vector of strings defining particle filtering settings and provide a method for filtering particles based on type and kinematics. More...

#include <BeamHaloGeneratorSettings.h>

Collaboration diagram for BeamHaloGeneratorSettings:

Public Member Functions
	BeamHaloGeneratorSettings (const std::vector< std::string > &settings)
	Construct a class with a vector of string settings to filter particles. More...
int	parseSettings (void)
	A function to parse the settings using the vector of strings given to the constructor of this class. More...
bool	checkParticle (BeamHaloParticle *beamHaloParticle)
	Check if the supplied beam halo particle passes the generator settings. More...
void	printSettings (void)
	Print a summary of the current settings. More...

Private Types
enum	enumShapeRequirements { NONE, CYLINDER }
	An enum mapped to different shape requirements. More...
enum	enumLimits {   PX_LIMIT, PY_LIMIT, PZ_LIMIT, E_LIMIT,   X_LIMIT, Y_LIMIT, Z_LIMIT, PT_LIMIT,   PHI_LIMIT, ETA_LIMIT, R_LIMIT, W_LIMIT,   ENUM_LIMITS_SIZE }

Private Member Functions
int	parseLimitSetting (std::vector< std::string > *commandVector)
	A function to read the limit settings from the supplied vector of strings. More...
bool	checkCylinder (BeamHaloParticle *beamHaloParticle)
	A function to check if a particle is within a cylinder. More...
bool	checkSetting (int index, double value)
	A function to check if a particle is within a range. More...

Private Attributes
std::vector< std::string >	m_generatorSettings
	A vector of strings to configure the generator settings. More...
std::vector< long >	m_allowedPdgIds
	An allowed set of PDG ids where any empty vector implies all PDG ids are allowed. More...
std::vector< std::pair< float, float > >	m_limits
	Minimum and maximum limits. More...
std::vector< std::pair< bool, bool > >	m_limitsEnabled
	A vector of flags to signal if a limit should be used or not. More...
int	m_shapeRequirement
	A variable to store the volume shape requirement. More...
bool	m_settingsParsed
	A flag to check if the settings have been parsed or not. More...

Static Private Attributes
static const std::string	m_limitNames [ENUM_LIMITS_SIZE]
	The name of the limits. More...

Detailed Description

A class to read a vector of strings defining particle filtering settings and provide a method for filtering particles based on type and kinematics.

Author

W. H. Bell W.Bel.nosp@m.l@ce.nosp@m.rn.ch

Definition at line 25 of file BeamHaloGeneratorSettings.h.

Member Enumeration Documentation

enumLimits

enum BeamHaloGeneratorSettings::enumLimits

private

Enumerator
PX_LIMIT
PY_LIMIT
PZ_LIMIT
E_LIMIT
X_LIMIT
Y_LIMIT
Z_LIMIT
PT_LIMIT
PHI_LIMIT
ETA_LIMIT
R_LIMIT
W_LIMIT
ENUM_LIMITS_SIZE

Definition at line 51 of file BeamHaloGeneratorSettings.h.

                  {
    PX_LIMIT,
    PY_LIMIT,
    PZ_LIMIT,
    E_LIMIT,
    X_LIMIT,
    Y_LIMIT,
    Z_LIMIT,
    PT_LIMIT,
    PHI_LIMIT,
    ETA_LIMIT,
    R_LIMIT,
    W_LIMIT,
    ENUM_LIMITS_SIZE};

enumShapeRequirements

enum BeamHaloGeneratorSettings::enumShapeRequirements

private

An enum mapped to different shape requirements.

Enumerator
NONE
CYLINDER

Definition at line 47 of file BeamHaloGeneratorSettings.h.

                             {
    NONE,
    CYLINDER};

Constructor & Destructor Documentation

BeamHaloGeneratorSettings()

BeamHaloGeneratorSettings::BeamHaloGeneratorSettings

(

const std::vector< std::string > &

settings

)

Construct a class with a vector of string settings to filter particles.

Definition at line 26 of file BeamHaloGeneratorSettings.cxx.

                                                                                        : 
  m_generatorSettings(settings),
  m_allowedPdgIds(),
  m_limits(),
  m_limitsEnabled(),
  m_shapeRequirement(0),
  m_settingsParsed(false) {
 
  // Initialise the lower and upper limits as zero, and disabled.
  for(int i=0;i<ENUM_LIMITS_SIZE;i++) {
    m_limits.push_back(std::make_pair(0.,0.));
    m_limitsEnabled.push_back(std::make_pair(false,false));
  }
}

Member Function Documentation

checkCylinder()

bool BeamHaloGeneratorSettings::checkCylinder ( BeamHaloParticle *  beamHaloParticle )

private

A function to check if a particle is within a cylinder.

Definition at line 187 of file BeamHaloGeneratorSettings.cxx.

                                                                                {
  double rmin = m_limits[R_LIMIT].first;
  double rmax = m_limits[R_LIMIT].second;
  double zmin = m_limits[Z_LIMIT].first;
  double zmax = m_limits[Z_LIMIT].second;
 
  // Check if the particle radius at the scoring place is outside the
  // outer radius of the cylinder and the particle trajectory is away
  // from the cylinder reject the particle.
  if(beamHaloParticle->positionAtScoringPlane().perp() > rmax && 
     beamHaloParticle->fourVector().theta() > 0.) return false;
  
  // If the particle has no pT then check if it is inside the radius
  // of the cylinder.
  if(beamHaloParticle->fourVector().perp() == 0.) {
    if(beamHaloParticle->positionAtScoringPlane().perp() < rmin || 
       beamHaloParticle->positionAtScoringPlane().perp() > rmin) {
      return false;
    }
    else {
      return true;
    }
  }
 
  // r = sqrt(x^2 + y^2)
  //
  // tan(theta) = pT/pz
  // tan(theta) = r/z
  //
  // z = (r*pz)/pT
 
  // The z position where the particle crosses the inner radius.
  double innerZ = (rmin*beamHaloParticle->fourVector().z())/beamHaloParticle->fourVector().perp();
 
  // The z position where the particle crosses the outer radius.
  double outerZ = (rmax*beamHaloParticle->fourVector().z())/beamHaloParticle->fourVector().perp();
  
  // If the trajectory of the particle crosses either the inner or
  // outer surface within the length of the cylinder keep it.
  if((innerZ >= zmin && innerZ <= zmax) ||
     (outerZ >= zmin && outerZ <= zmax)) {
    return true;
  }
 
  return false;
}

checkParticle()

bool BeamHaloGeneratorSettings::checkParticle

(

BeamHaloParticle *

beamHaloParticle

)

Check if the supplied beam halo particle passes the generator settings.

Definition at line 139 of file BeamHaloGeneratorSettings.cxx.

                                                                                {
  if(!m_settingsParsed) {
    if(parseSettings() != 0) return false;  
  }
 
  // Search the allowed PDG id list if it has been defined.
  if(m_allowedPdgIds.size() != 0) {
    std::vector<long>::iterator itr = m_allowedPdgIds.begin();
    std::vector<long>::iterator itr_end = m_allowedPdgIds.end();
    while(itr!=itr_end) {
      if(beamHaloParticle->pdgId() == (*itr)) break;
      ++itr;
    }
    if(itr==itr_end) {
      return false;
    }
  }
 
  // First implement the cuts which are not related to the particle
  // trajectory.
  if(!checkSetting(W_LIMIT, std::abs(beamHaloParticle->weight()))) return false;
  if(!checkSetting(PX_LIMIT, std::abs(beamHaloParticle->fourVector().px()))) return false;
  if(!checkSetting(PY_LIMIT, std::abs(beamHaloParticle->fourVector().py()))) return false;
  if(!checkSetting(PZ_LIMIT, std::abs(beamHaloParticle->fourVector().pz()))) return false;
  if(!checkSetting(E_LIMIT, std::abs(beamHaloParticle->fourVector().e()))) return false;
  if(!checkSetting(PT_LIMIT, beamHaloParticle->fourVector().perp())) return false;
  if(!checkSetting(ETA_LIMIT, std::abs(beamHaloParticle->fourVector().pseudoRapidity()))) return false;
  if(!checkSetting(PHI_LIMIT, std::abs(beamHaloParticle->fourVector().phi()))) return false;
 
 
  // Require the selection at the scoring plane.
  if(m_shapeRequirement == NONE) {
    if(!checkSetting(X_LIMIT, std::abs(beamHaloParticle->positionAtScoringPlane().x()))) return false;
    if(!checkSetting(Y_LIMIT, std::abs(beamHaloParticle->positionAtScoringPlane().y()))) return false;
    if(!checkSetting(R_LIMIT, beamHaloParticle->positionAtScoringPlane().perp())) return false;
  }
  else if(m_shapeRequirement == CYLINDER) {
    if(!checkCylinder(beamHaloParticle)) return false;
  }
  else {
    std::cerr << "Warning: m_shapeRequirement = " << m_shapeRequirement << " is an unknown requirement." << std::endl;
  }
 
  return true;
}

checkSetting()

bool BeamHaloGeneratorSettings::checkSetting ( int  index, double  value  )

private

A function to check if a particle is within a range.

Definition at line 236 of file BeamHaloGeneratorSettings.cxx.

                                                                    {
  if(index >= ENUM_LIMITS_SIZE) {
    std::cerr << "Error: the index " << index << " is out of range." << std::endl;
    return false;
  }
 
  if(m_limitsEnabled[index].first && value < m_limits[index].first) return false;
  if(m_limitsEnabled[index].second && value >= m_limits[index].second) return false;
 
  return true;
}

parseLimitSetting()

int BeamHaloGeneratorSettings::parseLimitSetting ( std::vector< std::string > *  commandVector )

private

A function to read the limit settings from the supplied vector of strings.

Definition at line 98 of file BeamHaloGeneratorSettings.cxx.

                                                                                    {
  std::vector<std::string>::iterator itr = commandVector->begin();
  std::vector<std::string>::iterator itr_end = commandVector->end();
  
  int i = 0;
  while(i<ENUM_LIMITS_SIZE) {
    if((*itr) == m_limitNames[i]) break;
    i++;
  }
  
  if(i == ENUM_LIMITS_SIZE) {
    std::cerr << "Error: " << (*itr)  << " is an un-known generator setting." << std::endl;
    return 1;
  }
 
  // Look for the lower limit
  ++itr;
  if(itr==itr_end) {
    std::cerr << "Warning: " << m_limitNames[i] << " was not followed by a lower or upper limit." << std::endl;
    return 0;
  }
 
  // Enable the lower limit.
  m_limits[i] = std::make_pair(AsciiInput::strToDouble(*itr),0.);
  m_limitsEnabled[i] = std::make_pair(true,false);
 
  // Look for the upper limit
  ++itr;
  if(itr==itr_end) { // no upper limit.
    return 0;
  }
 
  // Enable the upper limit.   
  m_limits[i].second = AsciiInput::strToDouble(*itr);
  m_limitsEnabled[i].second = true;
  
  return 0;
}

parseSettings()

int BeamHaloGeneratorSettings::parseSettings

(

void

)

A function to parse the settings using the vector of strings given to the constructor of this class.

Returns

0 if successful and a status code otherwise

Definition at line 43 of file BeamHaloGeneratorSettings.cxx.

                                             {
  std::vector<std::string> strVector;
  std::vector<std::string>::iterator row_itr;
  std::vector<std::string>::iterator row_itr_end;
  std::vector<std::string>::iterator col_itr;
  std::vector<std::string>::iterator col_itr_end;
//  double  upperLimit, lowerLimit;
  
  // Loop over all settings.
  row_itr = m_generatorSettings.begin();
  row_itr_end = m_generatorSettings.end();
  for(;row_itr!=row_itr_end;++row_itr) {
    strVector.clear();
    strVector = AsciiInput::strToStrVec(*row_itr);
    
    if(strVector.size() == 0) continue;
    if(strVector.size() == 1) {
      std::cerr << "A generator setting must be followed by a value" << std::endl;
      continue;
    }
 
//    lowerLimit = -1.; upperLimit = -1.1; // Disable limits by default;
 
    col_itr = strVector.begin();
    col_itr_end = strVector.end();
    
    if((*col_itr) == "allowedPdgId") {
      ++col_itr;
      for(;col_itr!=col_itr_end;++col_itr) {
    m_allowedPdgIds.push_back(AsciiInput::strToLong(*col_itr));
      }
    }
    else if((*col_itr) == "shape") {
      ++col_itr;
      if((*col_itr) == "cylinder") {
        m_shapeRequirement = CYLINDER;
      }
      else {
        std::cerr << "Warning: unknown shape requirement \"" << (*col_itr) << "\" ignored." << std::endl;
      }
    }
    else {
      parseLimitSetting(&strVector);
    }
  }
 
  printSettings();
 
  m_settingsParsed = true;
 
  return 0;
}

printSettings()

void BeamHaloGeneratorSettings::printSettings

(

void

)

Print a summary of the current settings.

Definition at line 250 of file BeamHaloGeneratorSettings.cxx.

                                              {
  std::cout << "============== BeamHaloGeneratorSettings ==============" << std::endl;
  std::cout << " allowedPdfIds: ";
  if(m_allowedPdgIds.size() != 0) {
    std::vector<long>::iterator pdgId_itr = m_allowedPdgIds.begin();
    std::vector<long>::iterator pdgId_itr_end = m_allowedPdgIds.end();
    for(;pdgId_itr != pdgId_itr_end; ++pdgId_itr) {
      std::cout << (*pdgId_itr) << " ";
    }
    std::cout << std::endl;
  }
  else {
    std::cout << "All PDG IDs are allowed." << std::endl;
  }
 
  std::cout << " shapeRequirement: ";  
  switch (m_shapeRequirement) {
  case(NONE) : std::cout << "NONE"; break; 
  case(CYLINDER) : std::cout << "CYLINDER"; break;
  default : std::cout << "UNKNOWN"; break;
  }
  std::cout << std::endl;
 
  for(int i=0;i<ENUM_LIMITS_SIZE;i++) {
    std::cout << " " << m_limitNames[i] << ": {";
    if(!m_limitsEnabled[i].first) std::cout << "disabled, ";
    else std::cout << m_limits[i].first << ", ";
    if(!m_limitsEnabled[i].second) std::cout << "disabled}";
    else std::cout << m_limits[i].second << "}";
    std::cout << std::endl;
  }
  std::cout << "=======================================================" << std::endl;
}

Member Data Documentation

m_allowedPdgIds

std::vector<long> BeamHaloGeneratorSettings::m_allowedPdgIds

private

An allowed set of PDG ids where any empty vector implies all PDG ids are allowed.

Definition at line 84 of file BeamHaloGeneratorSettings.h.

m_generatorSettings

std::vector<std::string> BeamHaloGeneratorSettings::m_generatorSettings

private

A vector of strings to configure the generator settings.

Definition at line 80 of file BeamHaloGeneratorSettings.h.

m_limitNames

const std::string BeamHaloGeneratorSettings::m_limitNames

staticprivate

Initial value:

= {"pxLimits",
                                                                               "pyLimits",
                                                                               "pzLimits",
                                                                               "energyLimits",
                                                                               "xLimits",
                                                                               "yLimits",
                                                                               "zLimits",
                                                                               "ptLimits",
                                                                               "phiLimits",
                                                                               "etaLimits",
                                                                               "rLimits",
                                                                               "weightLimits"}

The name of the limits.

Definition at line 77 of file BeamHaloGeneratorSettings.h.

m_limits

std::vector<std::pair<float, float> > BeamHaloGeneratorSettings::m_limits

private

Minimum and maximum limits.

Definition at line 87 of file BeamHaloGeneratorSettings.h.

m_limitsEnabled

std::vector<std::pair<bool, bool> > BeamHaloGeneratorSettings::m_limitsEnabled

private

A vector of flags to signal if a limit should be used or not.

Definition at line 90 of file BeamHaloGeneratorSettings.h.

m_settingsParsed

bool BeamHaloGeneratorSettings::m_settingsParsed

private

A flag to check if the settings have been parsed or not.

Definition at line 96 of file BeamHaloGeneratorSettings.h.

m_shapeRequirement

int BeamHaloGeneratorSettings::m_shapeRequirement

private

A variable to store the volume shape requirement.

Definition at line 93 of file BeamHaloGeneratorSettings.h.

---

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

• BeamHaloGeneratorSettings.h
• BeamHaloGeneratorSettings.cxx