Helper class to obtain the information about the valid symbols for particles, decay descriptors and Nodes. More...

#include </builds/gaudi/Gaudi/GaudiPartProp/include/Gaudi/Decays/Symbols.h>

Collaboration diagram for Gaudi::Decays::Symbols:

[legend]

Public Types
enum	{ InvalidService = 400 , InvalidSymbol , NoParticles , NoSymbols }

typedef std::vector< std::string >	Names
	the actual type for the list of names

typedef std::map< std::string, std::string >	CCMap

Public Member Functions
const CCMap &	cc () const
	get CC-map

bool	valid (std::string sym) const
	valid basic/primitive symbol?

const std::string &	symbol (std::string sym) const
	help for the basic primitive special symbol

StatusCode	symbol (std::string sym, Decays::Node &node) const
	get the node by symbol

size_t	symbols (Names &names) const
	get all known basic primitive special symbols

StatusCode	particles (const Gaudi::Interfaces::IParticlePropertySvc *svc, Names &parts) const
	get all known particle names

bool	addSymbol (std::string sym, const Decays::iNode &node, const std::string &help, const std::string &ccsym="")
	add new symbol to the internal structure

void	addCC (std::string sym, std::string ccsym="")
	add cc-pair to the internal map

Static Public Member Functions
static Symbols &	instance ()
	static accessor to teh singleton

Protected Member Functions
	Symbols ()
	the default constructor is protected:

virtual	~Symbols ()=default
	the destructor is protected

Private Types
typedef GaudiUtils::VectorMap< std::string, Decays::Nodes::_Node >	NodeMap

typedef std::map< std::string, std::string >	HelpMap

Private Member Functions
	Symbols (const Symbols &)
	copy constructor is private

Symbols &	operator= (const Symbols &)
	assignment operator is private

Private Attributes
NodeMap	m_nodes
	the actual map of symbols

HelpMap	m_help
	the actual help-map

CCMap	m_cc
	the map of cc-symbols

Detailed Description

Helper class to obtain the information about the valid symbols for particles, decay descriptors and Nodes.

Many thanks to Antonio PELLEGRINO for the kind help with regex expressions

See also: Decays::iNode; Decays::Nodes

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-05-07

Definition at line 45 of file Symbols.h.

Member Typedef Documentation

◆ CCMap

typedef std::map<std::string, std::string> Gaudi::Decays::Symbols::CCMap

Definition at line 51 of file Symbols.h.

◆ HelpMap

typedef std::map<std::string, std::string> Gaudi::Decays::Symbols::HelpMap

private

Definition at line 117 of file Symbols.h.

◆ Names

typedef std::vector<std::string> Gaudi::Decays::Symbols::Names

the actual type for the list of names

Definition at line 50 of file Symbols.h.

◆ NodeMap

typedef GaudiUtils::VectorMap<std::string, Decays::Nodes::_Node> Gaudi::Decays::Symbols::NodeMap

private

Definition at line 116 of file Symbols.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
InvalidService
InvalidSymbol
NoParticles
NoSymbols

Definition at line 47 of file Symbols.h.

47{ InvalidService = 400, InvalidSymbol, NoParticles, NoSymbols };

Gaudi::Decays::Symbols::InvalidService

@ InvalidService

Definition Symbols.h:47

Gaudi::Decays::Symbols::NoSymbols

@ NoSymbols

Definition Symbols.h:47

Gaudi::Decays::Symbols::InvalidSymbol

@ InvalidSymbol

Definition Symbols.h:47

Gaudi::Decays::Symbols::NoParticles

@ NoParticles

Definition Symbols.h:47

Constructor & Destructor Documentation

◆ Symbols() [1/2]

Gaudi::Decays::Symbols::Symbols ( )

protected

the default constructor is protected:

Definition at line 44 of file Symbols.cpp.

                       {
  addSymbol( "X", Decays::Nodes::Any(), "Any particle" );
  //
  addSymbol( "Hadron", Decays::Nodes::Hadron(), "Any hadron" );
  addSymbol( "Meson", Decays::Nodes::Meson(), "Any meson" );
  addSymbol( "Baryon", Decays::Nodes::Baryon(), "Any baryon" );
  addSymbol( "Nucleus", Decays::Nodes::Nucleus(), "Any nucleus" );
  addSymbol( "Lepton", Decays::Nodes::Lepton(), "Any lepton" );
  addSymbol( "l", Decays::Nodes::Ell(), "Any charged lepton" );
  addSymbol( "l+", Decays::Nodes::EllPlus(), "Any positive lepton", "l-" );
  addSymbol( "l-", Decays::Nodes::EllMinus(), "Any negative lepton", "l+" );
  addSymbol( "Nu", Decays::Nodes::Nu(), "Any neutral lepton" );
  addSymbol( "Neutrino", Decays::Nodes::Nu(), "Any neutral lepton" );
  //
  addSymbol( "X0", Decays::Nodes::Neutral(), "Any neutral particle" );
  addSymbol( "Xq", Decays::Nodes::Charged(), "Any charged particle" );
  addSymbol( "X+", Decays::Nodes::Positive(), "Any positive particle", "X-" );
  addSymbol( "X-", Decays::Nodes::Negative(), "Any negative particle", "X+" );
  //
  addSymbol( "ID+", Decays::Nodes::PosID(), "Any particle with positive ID", "ID-" );
  addSymbol( "ID-", Decays::Nodes::NegID(), "Any particle with negative ID", "ID+" );
  //
  addSymbol( "Xd", Decays::Nodes::HasQuark( Gaudi::ParticleID::down ), "Any particle with d-quark" );
  addSymbol( "Xu", Decays::Nodes::HasQuark( Gaudi::ParticleID::up ), "Any particle with u-quark" );
  addSymbol( "Xs", Decays::Nodes::HasQuark( Gaudi::ParticleID::strange ), "Any particle with s-quark" );
  addSymbol( "Xc", Decays::Nodes::HasQuark( Gaudi::ParticleID::charm ), "Any particle with c-quark" );
  addSymbol( "Xb", Decays::Nodes::HasQuark( Gaudi::ParticleID::bottom ), "Any particle with b-quark" );
  addSymbol( "Xt", Decays::Nodes::HasQuark( Gaudi::ParticleID::top ), "Any particle with t-quark" );
  //
  addSymbol( "Down", Decays::Nodes::HasQuark( Gaudi::ParticleID::down ), "Any particle with d-quark" );
  addSymbol( "Up", Decays::Nodes::HasQuark( Gaudi::ParticleID::up ), "Any particle with u-quark" );
  addSymbol( "Strange", Decays::Nodes::HasQuark( Gaudi::ParticleID::strange ), "Any particle with s-quark" );
  addSymbol( "Charm", Decays::Nodes::HasQuark( Gaudi::ParticleID::charm ), "Any particle with c-quark" );
  addSymbol( "Bottom", Decays::Nodes::HasQuark( Gaudi::ParticleID::bottom ), "Any particle with b-quark" );
  addSymbol( "Beauty", Decays::Nodes::HasQuark( Gaudi::ParticleID::bottom ), "Any particle with b-quark" );
  addSymbol( "Top", Decays::Nodes::HasQuark( Gaudi::ParticleID::top ), "Any particle with t-quark" );
  //
  addSymbol( "Scalar", Decays::Nodes::JSpin( 1 ), "Any scalar particle j=0" );
  addSymbol( "Spinor", Decays::Nodes::JSpin( 2 ), "Any spinor particle j=1/2" );
  addSymbol( "OneHalf", Decays::Nodes::JSpin( 2 ), "Any spinor particle j=1/2" );
  addSymbol( "Vector", Decays::Nodes::JSpin( 3 ), "Any vector particle j=1" );
  addSymbol( "ThreeHalf", Decays::Nodes::JSpin( 4 ), "Any particle with spin j=3/2" );
  addSymbol( "Tensor", Decays::Nodes::JSpin( 5 ), "Any tensor particle j=2" );
  addSymbol( "FiveHalf", Decays::Nodes::JSpin( 6 ), "Any particle with spin j=5/2" );
  //
  addSymbol( "ShortLived", Decays::Nodes::ShortLived_(), "Any short-ilved particle" );
  addSymbol( "LongLived", Decays::Nodes::LongLived_(), "Any long-lived particle" );
  addSymbol( "Stable", Decays::Nodes::Stable(), "Any 'stable' particle" );
  addSymbol( "StableCharged", Decays::Nodes::StableCharged(), "Any 'trackable' particle: stable & charged" );
  // special CC-symbols, protect them...
  addCC( "cc" );
  addCC( "CC" );
  addCC( "os" );
  addCC( "nos" );
  addCC( "HasQuark" );
  addCC( "JSpin" );
  addCC( "LSpin" );
  addCC( "SSpin" );
  addCC( "ShortLived" );
  addCC( "LongLived" );
  addCC( "ShortLived_" );
  addCC( "LongLived_" );
  addCC( "Stable" );
  addCC( "Light" );
  addCC( "Heavy" );
  addCC( "CTau" );
  addCC( "Mass" );
  addCC( "up" );
  addCC( "down" );
  addCC( "strange" );
  addCC( "charm" );
  addCC( "beauty" );
  addCC( "bottom" );
  addCC( "top" );
}

◆ ~Symbols()

virtual Gaudi::Decays::Symbols::~Symbols ( )

protectedvirtualdefault

the destructor is protected

◆ Symbols() [2/2]

Gaudi::Decays::Symbols::Symbols ( const Symbols & )

private

copy constructor is private

Member Function Documentation

◆ addCC()

void Gaudi::Decays::Symbols::addCC	(	std::string	sym,
		std::string	ccsym = "" )

add cc-pair to the internal map

Parameters

sym	the symbol
ccsym	the symbol for charge conjugation

Definition at line 148 of file Symbols.cpp.

                                                          {
  // trim the arguments
  boost::trim( sym );
  boost::trim( ccsym );
  if ( ccsym.empty() ) { ccsym = sym; }
  m_cc[sym] = ccsym;
  if ( ccsym != sym ) { m_cc[ccsym] = sym; }
}

◆ addSymbol()

bool Gaudi::Decays::Symbols::addSymbol	(	std::string	sym,
		const Decays::iNode &	node,
		const std::string &	help,
		const std::string &	ccsym = "" )

add new symbol to the internal structure

Parameters

sym	the symbol definition
node	the actual node
help	the help string
ccsym	the symbol for charge coonjugation

Returns: true if the symbol is added into the storage

Definition at line 129 of file Symbols.cpp.

                                                          {
  // trim the arguments
  boost::trim( sym );
  auto ifind = m_nodes.find( sym );
  if ( m_nodes.end() != ifind ) { return false; }
  // add the node into the map
  bool inserted = m_nodes.insert( sym, node ).second;
  if ( !inserted ) { return false; }
  // add the help-string
  m_help[sym] = help;
  // add cc-symbols
  addCC( sym, ccsym );
  return true;
}

◆ cc()

const Decays::Symbols::CCMap & Gaudi::Decays::Symbols::cc ( ) const

get CC-map

Definition at line 121 of file Symbols.cpp.

121{ return m_cc; }

◆ instance()

Decays::Symbols & Gaudi::Decays::Symbols::instance ( )

static

static accessor to teh singleton

Definition at line 39 of file Symbols.cpp.

                                       {
  static Decays::Symbols s_symbols;
  return s_symbols;
}

◆ operator=()

Symbols & Gaudi::Decays::Symbols::operator= ( const Symbols & )

private

assignment operator is private

◆ particles()

StatusCode Gaudi::Decays::Symbols::particles	(	const Gaudi::Interfaces::IParticlePropertySvc *	svc,
		Names &	parts ) const

get all known particle names

Parameters

svc	(INPUT) particle property service
parts	(OUTPUT) vector of particle names

Returns: status code

Definition at line 202 of file Symbols.cpp.

                                                                                                {
  // clear the output
  parts.clear();
  // check the service
  if ( 0 == service ) { return StatusCode( InvalidService ); }
 
  auto begin = service->begin();
  auto end   = service->end();
  for ( ; end != begin; ++begin ) {
    const Gaudi::ParticleProperty* pp = *begin;
    if ( !pp ) { continue; }
    parts.push_back( pp->particle() );
  }
  // sort it according to CC-criteria                                 ATTENTION!
  std::stable_sort( parts.begin(), parts.end(), Decays::CC::CmpCC() );
 
  return StatusCode::SUCCESS;
}

◆ symbol() [1/2]

const std::string & Gaudi::Decays::Symbols::symbol ( std::string sym ) const

help for the basic primitive special symbol

Parameters

sym	the symbol

Returns: the help string

Definition at line 163 of file Symbols.cpp.

                                                            {
  // trim the argument
  boost::trim( sym );
  NodeMap::const_iterator ifind = m_nodes.find( sym );
  if ( m_nodes.end() == ifind ) { return s_EMPTY; }
  HelpMap::const_iterator ihelp = m_help.find( sym );
  if ( m_help.end() == ihelp ) { return s_EMPTY; }
  return ihelp->second;
}

◆ symbol() [2/2]

StatusCode Gaudi::Decays::Symbols::symbol	(	std::string	sym,
		Decays::Node &	node ) const

get the node by symbol

Parameters

(INPUT)	sym the symbol name
(OUTPUT)	the symbol

Returns: status code

Definition at line 177 of file Symbols.cpp.

                                                                        {
  // trim the argument
  boost::trim( sym );
  auto ifind = m_nodes.find( sym );
  if ( m_nodes.end() != ifind ) {
    node = ifind->second;
    return StatusCode::SUCCESS;
  }
  node = Decays::Nodes::Invalid();
  return StatusCode( InvalidSymbol );
}

◆ symbols()

size_t Gaudi::Decays::Symbols::symbols ( Names & names ) const

get all known basic primitive special symbols

Parameters

names (OUTOUT) vector of all known special symbols

Returns: size of the vector

Definition at line 189 of file Symbols.cpp.

                                                               {
  // clear names ;
  names.clear();
  for ( auto inode = m_nodes.begin(); m_nodes.end() != inode; ++inode ) { names.push_back( inode->first ); }
  // sort it according to CC-criteria                               ATTENTION!
  std::stable_sort( names.begin(), names.end(), Decays::CC::CmpCC() );
  return names.size();
}

◆ valid()

bool Gaudi::Decays::Symbols::valid ( std::string sym ) const

valid basic/primitive symbol?

Parameters

sym	the symbol

Returns: true if it is vaild special symbol

Definition at line 157 of file Symbols.cpp.

                                               {
  // trim the argument
  boost::trim( sym );
  return m_nodes.end() != m_nodes.find( sym );
}

Member Data Documentation

◆ m_cc

CCMap Gaudi::Decays::Symbols::m_cc

private

the map of cc-symbols

Definition at line 124 of file Symbols.h.

◆ m_help

HelpMap Gaudi::Decays::Symbols::m_help

private

the actual help-map

Definition at line 122 of file Symbols.h.

◆ m_nodes

NodeMap Gaudi::Decays::Symbols::m_nodes

private

the actual map of symbols

Definition at line 120 of file Symbols.h.

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

GaudiPartProp/include/Gaudi/Decays/Symbols.h
GaudiPartProp/src/Symbols.cpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CCMap

◆ HelpMap

◆ Names

◆ NodeMap

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ Symbols() [1/2]

◆ ~Symbols()

◆ Symbols() [2/2]

Member Function Documentation

◆ addCC()

◆ addSymbol()

◆ cc()

◆ instance()

◆ operator=()

◆ particles()

◆ symbol() [1/2]

◆ symbol() [2/2]

◆ symbols()

◆ valid()

Member Data Documentation

◆ m_cc

◆ m_help

◆ m_nodes