framework

Collaboration diagram for framework:

Modules
	framework data objects
	framework modules

Namespaces
namespace	Belle2::PyObjConvUtils
	Python object converter utilities namespace.
namespace	Belle2::_RelationsInterfaceImpl
	hide some implementation details.
namespace	Belle2::_StoreArrayImpl
	hide some implementation details.
namespace	Belle2::RootIOUtilities
	Some constants and helpers common to the RootInput and RootOutput modules.
namespace	Belle2::TangoPalette
	Implements a colour palette, see http://sobac.com/sobac/tangocolors.htm.
namespace	Belle2::HTML
	return information on objects in a nice format.
namespace	Belle2::IOIntercept
	Encapsulate all classes needed to intercept stdout and stderr.
namespace	Belle2::Stream
	Define (de)serialization methods for TObject.
namespace	Belle2::TestHelpers
	Some utilities to help with writing unit tests.
namespace	Belle2::Utils
	General utility functions.

Classes
class	CreateConsistencyInfoModule
	If you want to merge two events with the 'MergeDataStoreModule', it might be necessary to make sure that this combination of events make sense. More...
class	DataFlowVisualization
	class to visualize data flow between modules. More...
class	Environment
	This class stores all environment information required to run the framework, such as module or data filepaths, number of processes to be used in parallel processing etc. More...
class	EventProcessor
	provides the core event processing loop. More...
class	FileCatalog
	This class provides an interface to the file (metadata) catalog. More...
class	HistoModule
	HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions to be managed by HistoManager. More...
class	InputController
	A static class to control supported input modules. More...
class	MemoryPool< T, chunkSize >
	Class to provide a constant access time memory pool for one kind of objects. More...
class	MergeDataStoreModule
	Internal module used by Path.add_independent_merge_path(). More...
class	MetadataService
	This class provides a service for writing metadata about the basf2 execution and about output files to a json file. More...
class	Module
	Base class for Modules. More...
class	ModuleProxyBase
	The base module proxy class is used to create new instances of a module. More...
class	ModuleCondition
	Wraps a condition set on a Module instance. More...
class	ModuleManager
	The ModuleManager Class. More...
class	ModuleParam< T >
	A single parameter of the module. More...
class	ModuleParamBase
	Base class for module parameter. More...
class	ModuleParamInfoPython
	Class to store basic information about a parameter. More...
class	ModuleParamList
	The Module parameter list class. More...
class	ModuleStatistics
	Keep track of time and memory consumption during processing. More...
class	MRUCache< KEY, VALUE >
	Class implementing a generic Most Recently Used cache. More...
class	Path
	Implements a path consisting of Module and/or Path objects. More...
class	PathElement
	Base for classes that can be elements of a Path. More...
class	PathIterator
	Iterator over a Path (returning Module pointers). More...
class	ProcessStatistics
	Class to collect call statistics for all modules. More...
class	PyModule
	Python wrapper for Belle2::Module. More...
class	RandomGenerator
	Fast Random number Generator using on xorshift1024* [arXiv:1402.6246]. More...
class	RandomNumbers
	The class for handling the random number generation. More...
class	SteerRootInputModule
	Internal module used by Path.add_independent_merge_path(). More...
class	SubEventModule
	Framework-internal module that implements the functionality of Path::forEach() as well as Path::doWhile(). More...
class	SwitchDataStoreModule
	Internal module used by Path.add_independent_path(). More...
class	Database
	Singleton base class for the low-level interface to the database. More...
class	DBAccessorBase
	Base class for DBObjPtr and DBArray for easier common treatment. More...
class	DBArray< T >
	Class for accessing arrays of objects in the database. More...
class	OptionalDBArray< T >
	Optional DBArray: This class behaves the same as the DBArray except that it will not raise errors when an object could not be found in the database. More...
class	DBImportArray< T >
	Class for importing array of objects to the database. More...
class	DBImportBase
	Base class for importing objects to the database. More...
class	DBImportObjPtr< T >
	Class for importing a single object to the database. More...
class	DBObjPtr< T >
	Class for accessing objects in the database. More...
class	OptionalDBObjPtr< T >
	Optional DBObjPtr: This class behaves the same as the DBObjPtr except that it will not raise errors when an object could not be found in the database. More...
class	DBPointer< T, KEY, METHOD, NAME >
	Class for pointing to an element in an array stored in the database. More...
class	DBStore
	Singleton class to cache database objects. More...
class	DBStoreEntry
	Class to hold one entry from the ConditionsDB in the DBStore. More...
class	EventDependency
	Class for handling changing conditions as a function of event number. More...
class	IntervalOfValidity
	A class that describes the interval of experiments/runs for which an object in the database is valid. More...
class	IntraRunDependency
	Base class for handling changing conditions during a run. More...
class	PayloadFile
	A wrapper class for payload files used by the Database and DBStore classes. More...
class	DBObjPtr< PayloadFile >
	Specialization of DBObjPtr in case of PayloadFiles. More...
class	RelationVector< T >
	Class for type safe access to objects that are referred to in relations. More...
class	DataStore
	In the store you can park objects that have to be accessed by various modules. More...
class	DependencyMap
	Collect information about the dependencies between modules. More...
class	StoreArray< T >
	Accessor to arrays stored in the data store. More...
class	RelationArray
	Low-level class to create/modify relations between StoreArrays. More...
struct	RelationEntry
	Struct for relations. More...
class	RelationIndex< FROM, TO >
	Provides access to fast ( O(log n) ) bi-directional lookups on a specified relation. More...
class	RelationIndexBase
	Baseclass for all RelationIndexContainers. More...
class	RelationIndexContainer< FROM, TO >
	Class to store a bidirectional index between two StoreArrays. More...
class	RelationIndexManager
	Manager to keep a cache of existing RelationIndexContainers. More...
class	RelationsInterface< BASE >
	Defines interface for accessing relations of objects in StoreArray. More...
class	RelationVectorBase
	base class for RelationVector<T> More...
class	SelectSubsetBase
	Type-independent implementation details of SelectSubset. More...
class	SelectSubset< StoredClass >
	Class to create a subset of a given StoreArray together with the relations with other StoreArrays. More...
class	StoreAccessorBase
	Base class for StoreObjPtr and StoreArray for easier common treatment. More...
struct	StoreEntry
	Wraps a stored array/object, stored under unique (name, durability) key. More...
class	StoreObjPtr< T >
	Type-safe access to single objects in the data store. More...
class	BeamParameters
	This class contains the nominal beam parameters and the parameters used for smearing of the primary vertex and the beam energy and momentum. More...
class	BunchStructure
	Class to store the fill pattern of colliding bunches. More...
class	dEdxPDFs
	Base class for holding the dE/dx PDFs. More...
class	HardwareClockSettings
	Database object containing the nominal accelerator RF value and the prescales to derive the clock frequencies of the sub-detectors. More...
class	MagneticField
	Magnetic field map. More...
class	MagneticFieldComponent
	Abstract base class for BField components. More...
class	MagneticFieldComponentConstant
	Describe one component of the Geometry. More...
class	RunInfo
	Database object for Run Information. More...
class	Const
	This class provides a set of constants for the framework. More...
class	Gearbox
	Singleton class responsible for loading detector parameters from an XML file. More...
struct	InputHandlerFactory< T >
	Helper class to easily register new input handlers. More...
class	GearDir
	GearDir is the basic class used for accessing the parameter store. More...
class	Unit
	The Unit class. More...
class	B2Vector3< DataType >
	A fast and root compatible alternative to TVector3. More...
class	BFieldManager
	Bfield manager to obtain the magnetic field at any point. More...
class	LogConfig
	The LogConfig class. More...
class	LogConnectionBase
	Abstract base class for the different types of log connections. More...
class	LogConnectionConsole
	Implements a log connection to an IO Stream. More...
class	LogConnectionFilter
	Implements a log connection that filters repeated messages. More...
class	LogConnectionJSON
	Implements a log connection to stdout but with messages formatted as json objects to allow easy parsing by other tools, say jupyter notebooks. More...
class	LogConnectionTxtFile
	Implements a log connection to a text file. More...
class	LogConnectionUDP
	Log Connection to send the log message as JSON to a UDP server. More...
class	LogMessage
	The LogMessage class. More...
class	LogMethod
	The LogMethod class. More...
class	LogSystem
	Class for logging debug, info and error messages. More...
class	EvtGenDatabasePDG
	Replacement for TDatabasePDG that is filled from EvtGen's evt.pdl. More...
class	EvtGenParticlePDG
	Helper class for setting additional TParticlePDG members and storing the ones it doesn't have yet. More...
class	AsyncWrapper
	Wraps a given Module to execute it asynchronously. More...
class	DataStoreStreamer
	Stream/restore DataStore objects to/from EvtMessage. More...
struct	EvtHeader
	Header structure of streamed object list. More...
class	EvtMessage
	Class to manage streamed object. More...
class	GlobalProcHandler
	A class to manage processes for parallel processing. More...
class	MapMergeable< T >
	Wrap an STL map to make it mergeable. More...
class	Mergeable
	Abstract base class for objects that can be merged. More...
class	CharBuffer
	dynamic character buffer that knows its size. More...
class	InMessage
	Reusable Message class derived from TMessage (for reading only) More...
class	MsgHandler
	A class to encode/decode an EvtMessage. More...
class	PathUtils
	Helper utils for path arithmetics needed in the pEventProcessor. More...
class	pEventProcessor
	This class provides the core event processing loop for parallel processing. More...
class	ProcessMonitor
	Class to monitor all started framework processes (input, workers, output), kill them if requested and handle the signals from the OS. More...
class	ProcHandler
	A class to manage processes for parallel processing. More...
class	RbTupleManager
	Class to manage histograms defined in registered modules. More...
struct	RingBufInfo
	Internal metadata structure for RingBuffer. More...
class	RingBuffer
	Class to manage a Ring Buffer placed in an IPC shared memory. More...
class	RootMergeable< T >
	Wrap a root histogram or TNtuple to make it mergeable. More...
class	RxModule
	Module to decode data store contents from RingBuffer. More...
class	SemaphoreLocker
	Handles creation, locking and unlocking of System V semaphores. More...
class	SeqFile
	A class to manage I/O for a chain of blocked files. More...
class	SetMergeable< T >
	Wrap an STL set to make it mergeable. More...
class	TxModule
	Module for encoding data store contents into a RingBuffer. More...
class	ZMQEventProcessor
	This class provides the core event processing loop for parallel processing with ZMQ. More...
class	ZMQConfirmedInput
	Input part of a confirmed connection. More...
class	ZMQConfirmedOutput
	Output part of a confirmed connection. More...
class	ZMQConnection
	Base class for every connection with virtual functions to be implemented: More...
class	ZMQConnectionOverSocket
	Specialized connection over a ZMQ socket. More...
class	ZMQLoadBalancedInput
	Input part of a load-balanced connection. More...
class	ZMQLoadBalancedOutput
	Output part of a load-balanced connection. More...
class	ZMQNullConnection
	Connection doing just nothing: without the capability to pull, send or receive. Useful for template interfaces. More...
class	ZMQRawInput
	Input connection allowing to speak with non-zmq sockets via a ZMQ_STREAM socket. More...
class	ZMQRawOutput
	Output connection to speak to non-zmq sockets via a ZMQ_STREAM socket. More...
class	ZMQSimpleConnection
	Connection type to be used for answering simple requests, e.g. More...
class	ZMQIdMessage
	A message with the socket ID. Needed in input<->worker communication. More...
class	ZMQMessageFactory
	Helper class for creating new ID/No-ID messages. More...
class	ZMQMessageHelper
	Internal helper for creating ZMQ messages (should not be used otherwise). More...
class	ZMQModuleMessage< AMessageFrameNumber >
	A general message with as many parts as given as template argument. More...
class	ZMQNoIdMessage
	A message without an associated socket ID. Is used in most cases. More...
class	ProcessedEventBackup
	Storage item for the event backup storing the event message, the time stamp and the event meta data. More...
class	ProcessedEventsBackupList
	List-like structure for storing and retaining event backups. More...
class	ZMQRxOutputModule
	Module connecting the worker path with the output path on the output side. More...
class	ZMQRxWorkerModule
	Module connecting the input path with the worker path on the worker side. More...
class	ZMQTxInputModule
	Module connecting the input path with the worker path on the input side. More...
class	ZMQTxWorkerModule
	Module connecting the worker path with the output path on the worker side. More...
class	ZMQClient
	A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket. More...
class	EventMetaDataSerialization
	Helper class for (de)serializing the event meta data used for the event backup transferral. More...
class	StreamHelper
	Helper class for data store serialization. More...
class	ZMQAddressUtils
	Summary of some address helpers. More...
class	ZMQLogger
	Base class for the ZMQ connection to help monitor and log certain values. More...
class	ZMQParent
	A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed. More...
class	Framework
	This class combines all subsystems of the framework, and exports the main interface to Python. More...
class	LogPythonInterface
	Thin wrapper to expose a usable interface to the logging framework in python. More...
class	ProcessStatisticsPython
	Python interface for ProcessStatistics. More...
class	PyDBArray
	Class to access a DB Array from Python. More...
class	PyDBObj
	Class to access a DBObjPtr from Python. More...
class	PyStoreArray
	A (simplified) python wrapper for StoreArray. More...
class	PyStoreObj
	a (simplified) python wrapper for StoreObjPtr. More...
class	AbstractBooleanNode< AVariableManager >
	A parsed cut-string naturally has a tree shape which incorporates the infomation of operator precedence and evaluation order of the statements. More...
class	AbstractExpressionNode< AVariableManager >
	AbstractExpressionNode Superclass for all nodes which host expressions. More...
class	BaseAngle
	Class to compare if two angles are compatible withing a given error range. More...
class	ThetaAngle
class	PhiAngle
class	ObjArrayIterator< ArrayType, ValueType >
	Optimizes class to iterate over TObjArray and classes inheriting from it. More...
class	ArrayIterator< ArrayType, ValueType >
	Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc. More...
class	CalcMeanCov< N, RealType >
	Class to calculate mean and and covariance between a number of parameters on running data without storing the actual values, also for weighted entries. More...
class	ConditionalGaussGenerator
	Class implementing n-dimensional random number generator from Gaussian distribution where the first component of the vector is generated first (using some external source) and the remaining components are generated based on the value of the first component. More...
struct	Visitor< operation >
	This is a class template which takes a template class operation as template argument. More...
struct	EqualVisitor
	Seperate Visitor struct for equal_to comparison of variant<double, int bool>. More...
class	UnaryBooleanNode< AVariableManager >
	Nodeclass with a single AbstractBooleanNode as child. More...
class	BinaryBooleanNode< AVariableManager >
	Nodeclass with two AbstractBooleanNode as children and a Boolean Operator (AND, OR) Check() method evaluates the child nodes and returns the result of the boolean operation. More...
class	UnaryRelationalNode< AVariableManager >
	Nodeclass with a single AbstractExpressioNode as child. More...
class	BinaryRelationalNode< AVariableManager >
	BooleanNode which has two AbstractExpressionNodes nodes and a ComparisonOperator. More...
class	TernaryRelationalNode< AVariableManager >
	BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator. More...
class	UnaryExpressionNode< AVariableManager >
	UnaryExpressionNode Node class with a single expression node as child. More...
class	BinaryExpressionNode< AVariableManager >
	BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation. More...
class	DataNode< AVariableManager, T >
	Template class for storing the Constants (int, double, bool) of the Cutstring. More...
class	IdentifierNode< AVariableManager >
	Class which stores the name of a variable. More...
class	FunctionNode< AVariableManager >
	FunctionNode Node class for handling MetaVariables in cuts. More...
class	EnvironmentVariables
	Utility functions related to environment variables. More...
class	FileSystem
	Utility functions related to filename validation and filesystem access. More...
class	FormulaParserBase
	Base class with the non-templated part of the formula parser. More...
class	FormulaParser< VariableConstructor >
	FormulaParser to parse a text formula like "a + b * c ^ d" where the separate parts can be either variables (with and without arguments) or numbers. More...
struct	StringFormulaConstructor
	Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging. More...
class	GeneralCut< AVariableManager >
	This class implements a common way to implement cut/selection functionality for arbitrary objects. More...
class	KeyValuePrinter
	create human-readable or JSON output for key value pairs. More...
class	LabToCms
	Class implementing general Lorentz Transformation between LAB and CMS system. More...
class	MakeROOTCompatible
	Helper class for converting strings into a ROOT-friendly format (e.g.: removing special characters in branch names, etc.) More...
class	MultivariateNormalGenerator
	Class to generate normal distributed, correlated random numbers given the mean values and the covariance matrix of all dimensions. More...
class	NodeFactory
	Wrapper class for static node compile functions. More...
class	BoostPythonModuleProxy
	Proxy class to register python modules (the things you can 'import'). More...
class	RootFileCreationManager
	This single instance class takes track of all open ROOT files open in "create" mode, usually meant for all the ntuple output modules. More...
class	ScopeGuard
	Simple ScopeGuard to execute a function at the end of the object lifetime. More...
struct	TRandomWrapper
	Wrap TRandom to be useable as a uniform random number generator with STL algorithms like std::shuffle. More...

Macros
#define	BELLE2_DEFINE_EXCEPTION(ClassName, Message)
	Macro that defines an exception with the given message template.
#define	_PACKAGE_   ""
	make sure REG_MODULE works outside the normal build system
#define	REG_MODULE(moduleName)
	Register the given module (without 'Module' suffix) with the framework.
#define	B2_GEARBOX_REGISTER_INPUTHANDLER(classname, prefix)    InputHandlerFactory<classname> Gearbox_InputHandlerFactory_##classname(prefix)
	Helper macro to easily register new input handlers.
#define	DEFINE_UNIT_NAME(var, value, name)   const double Unit::var = Unit::registerConversion(name,value)
	Define a new Unit given a name for the conversion table.
#define	DEFINE_UNIT(var, value)   DEFINE_UNIT_NAME(var,value,#var)
	Define a new Unit and take the variable name as name for the conversion table.
#define	REGISTER_PYTHON_MODULE(moduleName)   Belle2::BoostPythonModuleProxy boostPythonModuleProxy##moduleName(#moduleName, PyInit_##moduleName);
	Register a python module to make available when loading the library.
#define	REGISTER_PYTHON_MODULE_AUTOIMPORT(moduleName)   Belle2::BoostPythonModuleProxy boostPythonModuleProxy##moduleName(#moduleName, PyInit_##moduleName, true);
	Identical to REGISTER_PYTHON_MODULE(), but will also import the module into the global namespace after loading it.
#define	B2INFO_MEASURE_TIME(txt, ...)
	Print an INFO message txt followed by the time it took to execute the statment given as second argument.
#define	branch_unlikely(x)   (x)
	A macro to tell the compiler that the argument x will be very likely be false.
#define	branch_likely(x)   (x)
	Usage:

Typedefs
typedef std::shared_ptr< Module >	ModulePtr
	Defines a pointer to a module object as a boost shared pointer.
typedef std::list< ModulePtr >	ModulePtrList
	Defines a std::list of shared module pointers.
using	ModuleParamPtr = std::shared_ptr< ModuleParamBase >
	Defines a pointer to a module parameter as a boost shared pointer. *‍/.
typedef std::shared_ptr< Path >	PathPtr
	Defines a pointer to a path object as a boost shared pointer.
typedef RelationsInterface< TObject >	RelationsObject
	Provides interface for getting/adding relations to objects in StoreArrays.
typedef std::pair< std::string, DataStore::EDurability >	AccessorParams
	Pair of parameters needed to find an object in the DataStore.
typedef B2Vector3< double >	B2Vector3D
	typedef for common usage with double
typedef B2Vector3< float >	B2Vector3F
	typedef for common usage with float

Enumerations
enum	ERecordType {   MSG_EVENT ,   MSG_BEGIN_RUN ,   MSG_END_RUN ,   MSG_TERMINATE ,   MSG_NORECORD ,   MSG_STREAMERINFO }
	What type of message is this? More...
enum class	ProcType {   c_Input = 'i' ,   c_Worker = 'w' ,   c_Output = 'o' ,   c_Proxy = 'p' ,   c_Monitor = 'm' ,   c_Init = '0' ,   c_Stopped = 's' }
	Type of the process used for storing and mapping the child processes in the process handler. More...
enum class	EMessageTypes {   c_confirmMessage = 'c' ,   c_helloMessage = 'h' ,   c_deleteWorkerMessage = 'd' ,   c_lastEventMessage = 'l' ,   c_readyMessage = 'r' ,   c_terminateMessage = 'x' ,   c_rawDataMessage = 'u' ,   c_compressedDataMessage = 'v' ,   c_eventMessage = 'w' ,   c_goodbyeMessage = 'g' ,   c_statisticMessage = 's' ,   c_killWorkerMessage = 'k' ,   c_monitoringMessage = 'm' ,   c_newRunMessage = 'n' }
	Type the messages can have. More...
enum	ZMQAddressType {   c_input ,   c_output ,   c_pub ,   c_sub ,   c_control }
	The type of a ZMQ socket address (which socket to use) More...
enum class	NodeType : int {   UnaryBooleanNode ,   BinaryBooleanNode ,   UnaryRelationalNode ,   BinaryRelationalNode ,   TernaryRelationalNode ,   UnaryExpressionNode ,   BinaryExpressionNode ,   FunctionNode ,   IdentifierNode ,   DoubleNode ,   IntegerNode ,   BooleanNode }
	Enum of possible Nodes in parsing tree. More...
enum class	BooleanOperator : int {   AND ,   OR }
	Enum for decoding the boolean operator type. More...
enum class	ComparisonOperator : int {   EQUALEQUAL ,   GREATEREQUAL ,   LESSEQUAL ,   GREATER ,   LESS ,   NOTEQUAL }
	Enum for decoding the comparison operator type. More...
enum class	ArithmeticOperation : int {   PLUS ,   MINUS ,   PRODUCT ,   DIVISION ,   POWER }
	Enum for decoding the comparison operator type. More...

Functions
template<class T >
boost::python::object	createROOTObjectPyCopy (const T &instance)
	Create a python wrapped copy from a class instance which has a ROOT dictionary.
std::istream &	operator>> (std::istream &input, IntervalOfValidity &iov)
std::ostream &	operator<< (std::ostream &output, const IntervalOfValidity &iov)
	ADD_BITMASK_OPERATORS (DataStore::EStoreFlags)
	Add bitmask operators to DataStore::EStoreFlags.
	DEFINE_UNIT (cm, 1.)
	Standard units with the value = 1.
	DEFINE_UNIT (ns, 1.)
	Standard of [time].
	DEFINE_UNIT (GHz, 1.)
	Standard of [frequency].
	DEFINE_UNIT (rad, 1.)
	Standard of [angle].
	DEFINE_UNIT (GeV, 1.)
	Standard of [energy, momentum, mass].
	DEFINE_UNIT (K, 1.)
	Standard of [temperature].
	DEFINE_UNIT (e, 1.)
	Standard of [electric charge].
	DEFINE_UNIT_NAME (g_cm3, 1., "g/cm3")
	Practical units with the value = 1.
	DEFINE_UNIT (km, Unit::cm *1e5)
	Derived units.
	DEFINE_UNIT (m, Unit::cm *1e2)
	[meters]
	DEFINE_UNIT (mm, Unit::m *1e-3)
	[millimeters]
	DEFINE_UNIT (um, Unit::m *1e-6)
	[micrometers]
	DEFINE_UNIT (nm, Unit::m *1e-9)
	[nanometers]
	DEFINE_UNIT (pm, Unit::m *1e-12)
	[picometers]
	DEFINE_UNIT (fm, Unit::m *1e-15)
	[femtometers]
	DEFINE_UNIT (m2, Unit::m *Unit::m)
	[square meters]
	DEFINE_UNIT (cm2, Unit::cm *Unit::cm)
	[square centimeters]
	DEFINE_UNIT (mm2, Unit::mm *Unit::mm)
	[square millimeters]
	DEFINE_UNIT (b, Unit::m2 *1e-28)
	[barn]
	DEFINE_UNIT (mb, Unit::b *1e-3)
	[millibarn]
	DEFINE_UNIT (ub, Unit::b *1e-6)
	[microbarn]
	DEFINE_UNIT (nb, Unit::b *1e-9)
	[nanobarn]
	DEFINE_UNIT (pb, Unit::b *1e-12)
	[picobarn]
	DEFINE_UNIT (fb, Unit::b *1e-15)
	[femtobarn]
	DEFINE_UNIT (ab, Unit::b *1e-18)
	[attobarn]
	DEFINE_UNIT (m3, Unit::m *Unit::m *Unit::m)
	[cubic meters]
	DEFINE_UNIT (cm3, Unit::cm *Unit::cm *Unit::cm)
	[cubic centimeters]
	DEFINE_UNIT (mm3, Unit::mm *Unit::mm *Unit::mm)
	[cubic millimeters]
	DEFINE_UNIT (s, Unit::ns *1e9)
	[second]
	DEFINE_UNIT (ms, Unit::s *1e-3)
	[millisecond]
	DEFINE_UNIT (us, Unit::s *1e-6)
	[microsecond]
	DEFINE_UNIT (ps, Unit::s *1e-12)
	[picosecond]
	DEFINE_UNIT (fs, Unit::s *1e-15)
	[femtosecond]
	DEFINE_UNIT (Hz, Unit::GHz *1e-9)
	[Hertz]
	DEFINE_UNIT (kHz, Unit::GHz *1e-6)
	[Kilohertz]
	DEFINE_UNIT (MHz, Unit::GHz *1e-3)
	[Megahertz]
	DEFINE_UNIT (mHz, Unit::GHz *1e-12)
	[Millihertz]
	DEFINE_UNIT (mrad, Unit::rad *1e-3)
	[millirad]
	DEFINE_UNIT (deg, TMath::DegToRad())
	degree to radians
	DEFINE_UNIT (eV, Unit::GeV *1e-9)
	[electronvolt]
	DEFINE_UNIT (keV, Unit::eV *1e3)
	[kiloelectronvolt]
	DEFINE_UNIT (MeV, Unit::eV *1e6)
	[megaelectronvolt]
	DEFINE_UNIT (TeV, Unit::eV *1e12)
	[teraelectronvolt]
	DEFINE_UNIT (J, 1.0/TMath::Qe() *Unit::eV)
	[joule]
	DEFINE_UNIT (V, Unit::eV/Unit::e)
	Standard of [voltage].
	DEFINE_UNIT (C, 1.0/TMath::Qe() *Unit::e)
	[Coulomb]
	DEFINE_UNIT (fC, Unit::C/1.0e15)
	[femtoCoulomb]
	DEFINE_UNIT (T, Unit::V *Unit::s/Unit::m2)
	[Tesla]
	DEFINE_UNIT (mT, Unit::T *1e-3)
	[millitesla]
	DEFINE_UNIT (Gauss, Unit::T *1e-4)
	[Gauss]
	DEFINE_UNIT (kGauss, Unit::Gauss *1e3)
	[kiloGauss]
	DEFINE_UNIT_NAME (mg_cm3, Unit::g_cm3 *1e-3, "mg/cm3")
	[mg/cm^3]
	DEFINE_UNIT_NAME (kg_cm3, Unit::g_cm3 *1e3, "kg/cm3")
	[kg/cm^3]
	DEFINE_UNIT_NAME (g_mm3, Unit::g_cm3/Unit::mm3, "g/mm3")
	[g/mm^3]
	DEFINE_UNIT_NAME (mg_mm3, Unit::mg_cm3/Unit::mm3, "mg/mm3")
	[mg/mm^3]
	DEFINE_UNIT_NAME (kg_mm3, Unit::kg_cm3/Unit::mm3, "kg/mm3")
	[kg/mm^3]
template<typename DataType >
Bool_t	operator== (const TVector3 &a, const B2Vector3< DataType > &b)
	non-memberfunction Comparison for equality with a TVector3
template<typename DataType >
Bool_t	operator!= (const TVector3 &a, const B2Vector3< DataType > &b)
	non-memberfunction Comparison for equality with a TVector3
template<typename DataType >
B2Vector3< DataType >	operator* (DataType a, const B2Vector3< DataType > &p)
	non-memberfunction Scaling of 3-vectors with a real number
template<typename DataType >
B2Vector3< DataType >	operator+ (const TVector3 &a, const B2Vector3< DataType > &b)
	non-memberfunction for adding a TVector3 to a B2Vector3
template<typename DataType >
B2Vector3< DataType >	operator- (const TVector3 &a, const B2Vector3< DataType > &b)
	non-memberfunction for substracting a TVector3 from a B2Vector3
template<typename DataType >
B2Vector3< DataType >	operator+ (const B2Vector3< DataType > &a, const TVector3 &b)
	non-memberfunction for adding a B2Vector3 to a TVector3
template<typename DataType >
B2Vector3< DataType >	operator- (const B2Vector3< DataType > &a, const TVector3 &b)
	non-memberfunction for substracting a B2Vector3 from a TVector3
template<typename DataType >
B2Vector3< DataType >	operator+ (const ROOT::Math::XYZVector &a, const B2Vector3< DataType > &b)
	non-memberfunction for adding a XYZVector to a B2Vector3
template<typename DataType >
B2Vector3< DataType >	operator- (const ROOT::Math::XYZVector &a, const B2Vector3< DataType > &b)
	non-memberfunction for substracting a XYZVector from a B2Vector3
template<typename DataType >
B2Vector3< DataType >	operator+ (const B2Vector3< DataType > &a, const ROOT::Math::XYZVector &b)
	non-memberfunction for adding a B2Vector3 to a XYZVector
template<typename DataType >
B2Vector3< DataType >	operator- (const B2Vector3< DataType > &a, const ROOT::Math::XYZVector &b)
	non-memberfunction for substracting a B2Vector3 from a XYZVector
void	injectBooleanOperatorToStream (std::ostream &stream, const BooleanOperator &boperator)
	Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the BooleanOperator given.
void	injectComparisonOperatorToStream (std::ostream &stream, const ComparisonOperator &coperator)
	Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the ComparisonOperator given.
void	injectArithmeticOperatorToStream (std::ostream &stream, const ArithmeticOperation &aoperation)
	Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the ComparisonOperator given.
template<typename T >
T	convertString (const std::string &str)
	Converts a string to type T (one of float, double, long double, int, long int, unsigned long int).
unsigned long int	findMatchedParenthesis (std::string str, char open='[', char close=']')
	Returns position of the matched closing parenthesis if the first character in the given string contains an opening parenthesis.
std::vector< std::string >	splitOnDelimiterAndConserveParenthesis (std::string str, char delimiter, char open, char close)
	Split into std::vector on delimiter ignoring delimiters between parenthesis.
unsigned long int	findIgnoringParenthesis (std::string str, std::string pattern, unsigned int begin=0)
	Returns the position of a pattern in a string ignoring everything that is in parenthesis.
bool	almostEqualFloat (const float &a, const float &b)
	Helper function to test if two floats are almost equal.
bool	almostEqualDouble (const double &a, const double &b)
	Helper function to test if two doubles are almost equal.
std::set< int64_t >	generate_number_sequence (const std::string &str)
	Generate a sequence of numbers defined by a string.
template<>
float	convertString (const std::string &str)
	Converts a string to float.
template<typename T >
void	addParam (const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
	Adds a new parameter to the module.
template<typename T >
void	addParam (const std::string &name, T &paramVariable, const std::string &description)
	Adds a new enforced parameter to the module.
template<typename T >
ModuleParam< T > &	getParam (const std::string &name) const
	Returns a reference to a parameter.
static std::string	TypeInfo ()
	Static function to generate a string description for the parameter type.
	ModuleParam (T &paramVariable, const std::string &description="", bool force=false)
	Constructor.
virtual	~ModuleParam ()
	Destructor.
void	setValue (const T &value)
	Sets the value of a parameter.
void	setDefaultValue (const T &defaultValue)
	Sets the default value of a parameter.
T &	getValue ()
	Returns the value of the parameter.
T &	getDefaultValue ()
	Returns the default value of the parameter.
virtual void	setValueFromPythonObject (const boost::python::object &pyObject) final
	Implements a method for setting boost::python objects.
virtual void	setValueToPythonObject (boost::python::object &pyObject, bool defaultValues=false) const final
	Returns a python object containing the value or the default value of the given parameter.
virtual void	setValueFromParam (const ModuleParamBase &param) final
	Set value from other ModuleParam of same type.
void	resetValue ()
	Resets the parameter value by assigning the default value to the parameter value.
template<typename T >
void	addParameter (const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
	Adds a new parameter to the module list.
template<typename T >
void	addParameter (const std::string &name, T &paramVariable, const std::string &description)
	Adds a new enforced parameter to the module list.
template<typename T >
void	setParameter (const std::string &name, const T &value)
	Sets the value of a parameter given by its name.
template<typename T >
ModuleParam< T > &	getParameter (const std::string &name) const
	Returns a reference to a parameter.
template<typename PythonObject >
void	setParamPython (const std::string &name, const PythonObject &pyObj)
	Implements a method for setting boost::python objects.
template<typename PythonObject >
void	getParamValuesPython (const std::string &name, PythonObject &pyOutput, bool defaultValues) const
	Returns a python object containing the value or default value of the given parameter.
uint64_t	random64 ()
	Generate one 64bit unsigned integer between 0 and UINT64_MAX (both inclusive).
void	RndmArray (Int_t n, Float_t *array)
	Fill an array of floats with random values in (0,1), both limits excluded.
void	RndmArray (Int_t n, Double_t *array)
	Fill an array of doubles with random values in (0,1), both limits excluded.
void	RndmArray (Int_t n, ULong64_t *array)
	Fill an array of unsigned 64bit integers with random values in [0, UINT64_MAX], both limits included.
void	RndmArray (Int_t n, UInt_t *array)
	Fill an array of unsigned integers with random values in [0, UINT32_MAX], both limits included.
double	random01 ()
	Generate a random double value between 0 and 1, both limits excluded.
static Database &	Instance ()
	Instance of a singleton Database.
	~Database ()
	Hidden destructor, as it is a singleton.
static void	reset (bool keepConfig=false)
	Reset the database instance.
ScopeGuard	createScopedUpdateSession ()
	Make sure we have efficient http pipelinging during initialize/beginRun but don't keep session alive for full processing time.
std::pair< TObject *, IntervalOfValidity >	getData (const EventMetaData &event, const std::string &name)
	Request an object from the database.
bool	getData (const EventMetaData &event, std::vector< DBQuery > &query)
	Request multiple objects from the database.
bool	storeData (std::list< DBImportQuery > &query)
	Store multiple objects in the database.
bool	storeData (const std::string &name, TObject *object, const IntervalOfValidity &iov)
	Store an object in the database.
std::string	getGlobalTags ()
	Return the global tags used by the database.
void	nextMetadataProvider ()
	Enable the next metadataprovider in the list.
void	initialize (const EDatabaseState target=c_Ready)
	Initialize the database connection settings on first use.
static void	exposePythonAPI ()
	Exposes setGlobalTag function of the Database class to Python.
	~DBStore ()
	Destructor.
static DBStore &	Instance ()
	Instance of a singleton DBStore.
DBStoreEntry *	getEntry (DBStoreEntry::EPayloadType payloadType, const std::string &name, const TClass *objClass, bool array, bool required=true)
	Returns the entry with the requested name in the DBStore.
void	update ()
	Updates all objects that are outside their interval of validity.
void	update (const EventMetaData &event)
	Updates all objects that are outside their interval of validity.
void	performUpdate (const EventMetaData &event)
	The main code that does an update, factored out so it can be used by both update and update(event).
void	updateEvent ()
	Updates all intra-run dependent objects.
void	updateEvent (const unsigned int eventNumber)
	Updates all intra-run dependent objects.
void	performUpdateEvent (const EventMetaData &event)
	The main code that does an updateEvent.
void	reset (bool keepEntries=false)
	Invalidate all payloads.
std::set< std::string >	getAllEntryNames ()
	Return the names of all the payloads stored in the database at the time of this function is called.
void	addConstantOverride (const std::string &name, TObject *obj, bool oneRun=false)
	Add constant override payload.
static DBStoreEntry	fromObject (const std::string &name, const TObject *obj, bool isRequired)
	Construct a new DBStoreEntry with a requested name and an object directly.
	~DBStoreEntry ()
	Clean up memory.
void	updateObject (const EventMetaData &event)
	update the payload object according to the new event information.
void	resetPayload ()
	reset the payload to nothing
void	updatePayload (unsigned int revision, const IntervalOfValidity &iov, const std::string &filename, const std::string &checksum, const std::string &globaltag, const EventMetaData &event)
	Update the payload information for this entry and if appropriate open the new file and extract the object as needed.
void	loadPayload (const EventMetaData &event)
	Actual load the payload from file after all info is set.
void	overrideObject (TObject *obj, const IntervalOfValidity &iov)
	Set an override object in case we want to use a different object then actually provided by the database.
void	notifyAccessors (bool onDestruction=false)
	Notify all the registered accessors.
bool	checkType (EPayloadType type, const TClass *objClass, bool array, bool inverse=false) const
	Check if a given TClass is compatible with the type of this entry.
bool	checkType (const TObject *object) const
	Check if a given TObject instance is compatible with the type of this entry.
template<class FunctionFrom , class FunctionTo >
void	consolidate (const FunctionFrom &replaceFrom=FunctionFrom(), const FunctionTo &replaceTo=FunctionTo(), EConsolidationAction action=c_doNothing)
	Consolidate RelationElements.
void	rebuild (bool force=false)
	Rebuild the index.
std::map< int, int >	copySetWithRelations (std::function< bool(const StoredClass *)> f)
	Selects the elements, fill the subset and copies all the relations in which the set is involved.
void	copyRelationsToSelf ()
	Copy any set -> set relations between selected objects.
void	select (const std::function< bool(const StoredClass *)> &f)
	This method is the actual worker.
ROOT::Math::XYZVector	getField (const ROOT::Math::XYZVector &pos) const
	Calculate the magnetic field at a given position.
void	setBucket (unsigned i)
	Sets the fill status of RF bucket to true.
bool	getBucket (int i) const
	Returns the fill status of RF bucket.
unsigned	getNumOfFilledBuckets () const
	Returns the number of filled buckets.
unsigned	generateBucketNumber () const
	Generates RF bucket number according to the fill pattern.
	Gearbox ()
	Singleton: private constructor.
	~Gearbox ()
	Free structures on destruction.
static Gearbox &	getInstance ()
	Return reference to the Gearbox instance.
gearbox::InputContext *	openXmlUri (const std::string &uri) const
	Function to be called when libxml requests a new input uri to be opened.
void	setBackends (const std::vector< std::string > &backends)
	Select the backends to use to find resources.
void	clearBackends ()
	Clear list of backends.
void	open (const std::string &name="Belle2.xml", size_t cacheSize=c_DefaultCacheSize)
	Open connection to backend and parse tree.
void	close ()
	Free internal structures of previously parsed tree and clear cache.
void	overridePathValue (const PathOverride &poverride)
	Change the value of a given path expression.
PathValue	getPathValue (const std::string &path) const
	Return the (cached) value of a given path.
virtual const TObject *	getTObject (const std::string &path) const noexcept(false) override
	Get the parameter path as a TObject.
GearDir	getDetectorComponent (const std::string &component)
	Return GearDir representing a given DetectorComponent.
static double	convertValue (double value, const std::string &unitString)
	Converts a floating point value to the standard framework unit.
static double	convertValueToUnit (double value, const std::string &unitString)
	Converts a floating point value from the standard framework unit to the given unit.
static double	registerConversion (const std::string &name, double value)
	registers the name and value of a conversion in s_conversionFactors.
B2Vector3< DataType > &	operator= (const B2Vector3< DataType > &b)
	Assignment via B2Vector3.
B2Vector3< DataType > &	operator= (const TVector3 &b)
	Assignment via TVector3.
B2Vector3< DataType > &	operator= (const ROOT::Math::XYZVector &b)
	Assignment via XYZVector.
B2Vector3< DataType > &	operator+= (const B2Vector3< DataType > &b)
	addition
B2Vector3< DataType > &	operator-= (const B2Vector3< DataType > &b)
	subtraction
B2Vector3< DataType > &	operator*= (DataType a)
	scaling with real numbers
void	SetXYZ (const TVector3 &tVec)
	set all coordinates using a reference to TVector3
void	SetXYZ (const TVector3 *tVec)
	set all coordinates using a pointer to TVector3
void	SetXYZ (const ROOT::Math::XYZVector &xyzVec)
	set all coordinates using a reference to XYZVector
void	SetXYZ (const ROOT::Math::XYZVector *xyzVec)
	set all coordinates using a pointer to XYZVector
void	GetXYZ (TVector3 *tVec) const
	directly copies coordinates to a TVector3
void	GetXYZ (ROOT::Math::XYZVector *xyzVec) const
	directly copies coordinates to a XYZVector
TVector3	GetTVector3 () const
	returns a TVector3 containing the same coordinates
ROOT::Math::XYZVector	GetXYZVector () const
	returns a XYZVector containing the same coordinates
DataType	at (unsigned i) const
	safe member access (with boundary check!)
static std::string	name ()
	Returns the name of the B2Vector.
ROOT::Math::XYZVector	calculate (const ROOT::Math::XYZVector &pos) const
	Calculate the field value at a given position and return it.
static void	getField (const double *pos, double *field)
	return the magnetic field at a given position.
const LogConfig &	getCurrentLogConfig (const char *package=nullptr) const
	Returns the current LogConfig object used by the logging system.
bool	isLevelEnabled (LogConfig::ELogLevel level, int debugLevel=0, const char *package=nullptr) const
	Returns true if the given log level is allowed by the log system (i.e.
	LogConnectionJSON (bool complete=false)
	The constructor.
bool	sendMessage (const LogMessage &message) override
	Sends a log message.
std::string	__repr__ () const
	Return a string repesentation of this particle to be used when printing the particle in python.
template<class AZMQClient >
void	sendToSocket (const AZMQClient &socket)
	Publish this event backup directly to the given client.
template<class AZMQClient >
void	sendWorkerBackupEvents (unsigned int worker, const AZMQClient &socket)
	Send all backups of a given worker directly to the multicast and delete them.
template<class AMulticastAnswer , class ASocketAnswer >
int	poll (unsigned int timeout, AMulticastAnswer multicastAnswer, ASocketAnswer socketAnswer) const
	Poll both the multicast and the data socket until, either:
template<class ASocketAnswer >
int	pollSocket (unsigned int timeout, ASocketAnswer socketAnswer) const
	Poll method to only the data socket.
template<class AMulticastAnswer >
int	pollMulticast (unsigned int timeout, AMulticastAnswer multicastAnswer) const
	Poll method to only the multicast socket.
template<class AClass >
void	log (const std::string &key, const AClass &value)
	Store a value under a certain key. Different types of values can be stored, namely long, double or string. Mixtures are not allowed for a given key.
template<size_t MAX_SIZE = 100>
void	average (const std::string &key, double value)
	Instead of storeing the double value directly under the given key, store the average of the last MAX_SIZE values.
template<size_t AVERAGE_SIZE = 2000>
void	timeit (const std::string &key)
	Measure the rate of calls with the same key every AVERAGE_SIZE calls (and also display the last time AVERAGE_SIZE was reached under <key>_last_measurement)
template<int AZMQType>
std::unique_ptr< zmq::socket_t >	createSocket (const std::string &socketAddress, bool bind)
	Create a socket of the given type with the given address and bind or not bind it.
template<int AZMQType>
std::unique_ptr< zmq::socket_t >	createSocket (const std::string &socketAddress)
	Create a socket of the given type while deciding on the bind behaviour via the address.
template<class AZMQMessage >
static void	send (std::unique_ptr< zmq::socket_t > &socket, AZMQMessage message)
	Send a given message over the given created socket. You need to move in the message for zero-copy.
template<class value_type >
bool	setMeanCov (const TVectorT< value_type > &mean, const TMatrixTBase< value_type > &cov)
	set mean and covariance matrix from ROOT vector/matrix objects, e.g.
template<class value_type >
bool	setMeanCov (const ROOT::Math::XYZVector &mean, const TMatrixTBase< value_type > &cov)
	set the mean and covariance for the distribution.
static bool	isSet (const std::string &name)
	Check if a value is set in the database.
static std::string	get (const std::string &name, const std::string &fallback="")
	Get the value of an environment variable or the given fallback value if the variable is not set.
static std::vector< std::string >	getList (const std::string &name, const std::vector< std::string > &fallback={}, const std::string &separators=" \t\n\r")
	Get a list of values from an environment variable or the given fallback list if the variable is not set.
static std::vector< std::string >	getOrCreateList (const std::string &name, const std::string &fallback, const std::string &separators=" \t\n\r")
	Get a list of values from an environment variable or the given fallback string if the variable is not set.
static std::string	expand (const std::string &text)
	Modify the given string and replace every occurence of $NAME or ${NAME} with the value of the environment variable NAME.
static char	operatorToChar (EOperator op) noexcept
	Convert operator code to character.
static double	applyOperator (EOperator op, double a, double b)
	Apply operator on two values.
static ENumberStatus	checkNumber (ENumberStatus current, char next)
	Check if a string literal with a given number status continues to be a valid number if next is appended to it.
static void	assertOperatorUsable (size_t stacksize)
	Make sure we have enough operands to use an operator.
void	addOperator (EOperator op)
	Add an operator to the internal state, convert them to reverse polish notation using the shunting yard algorithm and execute them as they become available.
void	flushPendingOperators ()
	Flush all pending operators at the end of processing.
void	flushCurrentVariable ()
	Flush the currently parsed variable name and add it to the state either as variable or number.
EOperator	checkForOperator (char next)
	Check if the next character is a operator.
void	processString (const std::string &formula)
	Process the given formula and store the final state.
void	raiseError (const std::runtime_error &e)
	Format the given runtime_error with context information and rethrow a new one.
std::shared_ptr< TFile >	getFile (std::string, bool ignoreErrors=false)
	Get a file with a specific name, if is does not exist it will be created.
static RootFileCreationManager &	getInstance ()
	Interface for the FileManager.

Variables
std::string	DBPointer_defaultName = ""
	Use default name for array in DBPointer.
static constexpr auto	XYZToTVector
	Helper function to convert XYZVector to TVector3.
static std::map< std::string, double >	s_conversionFactors
	Map to be able to convert between units using string representations of the unit name.

Detailed Description

Macro Definition Documentation

_PACKAGE_

#define _PACKAGE_   ""

make sure REG_MODULE works outside the normal build system

Definition at line 643 of file Module.h.

B2_GEARBOX_REGISTER_INPUTHANDLER

#define B2_GEARBOX_REGISTER_INPUTHANDLER	(		classname,
			prefix
	)		InputHandlerFactory<classname> Gearbox_InputHandlerFactory_##classname(prefix)

Helper macro to easily register new input handlers.

It will create a factory function for the InputHandler and register it with the Gearbox instance

Parameters

classname	Classname to create factory for
prefix	Prefix to register the handler for, e.g. "file" to register a handler responsible for uris starting with file:

Definition at line 256 of file Gearbox.h.

B2INFO_MEASURE_TIME

#define B2INFO_MEASURE_TIME	(		txt,
			...
	)

Value:

    {\
    std::stringstream __b2_timer_str__;\
    __b2_timer_str__ << txt;\
    ::Belle2::Utils::Timer __b2_timer__(__b2_timer_str__.str());\
    {__VA_ARGS__;}\
  }

Print an INFO message txt followed by the time it took to execute the statment given as second argument.

Care should be taken not to define variables in this call since they will be scoped and thus unavaiable after the macro

Definition at line 102 of file Utils.h.

BELLE2_DEFINE_EXCEPTION

#define BELLE2_DEFINE_EXCEPTION	(		ClassName,
			Message
	)

Value:

  class ClassName : public std::runtime_error { \
  public: \
    ClassName(): std::runtime_error(""), m_format(Message) { } \
    ~ClassName() noexcept {} \
    virtual const char * what() const noexcept override { \
      m_finalStr = m_format.str();\
      return m_finalStr.c_str();\
    }\
    template <class T> ClassName& operator<<(const T& param) {\
      m_format % param;\
      return *this;\
    }\
  private:\
    boost::format m_format;\
    mutable std::string m_finalStr;\
  };

Macro that defines an exception with the given message template.

Use the macro inside your class (header file) and specify a class name for your exception, plus a format string that contains a description of what went wrong:

BELLE2_DEFINE_EXCEPTION(ModuleNotCreatedError, "Could not create module: %1%")

When throwing, simply create an instance of this class, use operator<< to fill any placeholders (n%) specified, and pass this to the throw keyword:

throw (ModuleNotCreatedError() << moduleName);

Exceptions defined using this macro inherit from std::runtime_error, and can be queried using their what() member.

Definition at line 36 of file FrameworkExceptions.h.

branch_likely

#define branch_likely

(

x

)

(x)

Usage:

if (branch_unlikely(my_number > 10)) {
  // executed only rarely
} else {
  // executed very often
}

Definition at line 133 of file Utils.h.

branch_unlikely

#define branch_unlikely

(

x

)

(x)

A macro to tell the compiler that the argument x will be very likely be false.

This could result in optimized code as the compiler can reorder the code to reduce conditional jumps during execution. Due to the high efficiency of todays branch prediction systems the effect is probably small.

Warning

Use of this macro should be accompanied by a comment documenting the (significant) performance gains that justify its use. (Please make sure you compile in 'opt' mode.)

See also

Definition at line 134 of file Utils.h.

DEFINE_UNIT

#define DEFINE_UNIT	(		var,
			value
	)		DEFINE_UNIT_NAME(var,value,#var)

Define a new Unit and take the variable name as name for the conversion table.

Definition at line 35 of file UnitConst.cc.

DEFINE_UNIT_NAME

#define DEFINE_UNIT_NAME	(		var,
			value,
			name
	)		const double Unit::var = Unit::registerConversion(name,value)

Define a new Unit given a name for the conversion table.

Definition at line 33 of file UnitConst.cc.

REG_MODULE

#define REG_MODULE

(

moduleName

)

Value:

      namespace { struct ModuleProxy##moduleName: public ModuleProxyBase { \
      ModuleProxy##moduleName(): ModuleProxyBase(#moduleName, "" _PACKAGE_) {} \
      virtual ::Belle2::Module* createInstance() const override final { return new moduleName##Module(); } \
    } proxy##moduleName##Module; }

Register the given module (without 'Module' suffix) with the framework.

Definition at line 650 of file Module.h.

REGISTER_PYTHON_MODULE

#define REGISTER_PYTHON_MODULE

(

moduleName

)

Belle2::BoostPythonModuleProxy boostPythonModuleProxy##moduleName(#moduleName, PyInit_##moduleName);

Register a python module to make available when loading the library.

Use it by defining your module via BOOST_PYTHON_MODULE(name), then call REGISTER_PYTHON_MODULE(name) with the same name.

After the library has been loaded, you can use 'import name' to import the defined objects.

Definition at line 36 of file RegisterPythonModule.h.

REGISTER_PYTHON_MODULE_AUTOIMPORT

#define REGISTER_PYTHON_MODULE_AUTOIMPORT

(

moduleName

)

Belle2::BoostPythonModuleProxy boostPythonModuleProxy##moduleName(#moduleName, PyInit_##moduleName, true);

Identical to REGISTER_PYTHON_MODULE(), but will also import the module into the global namespace after loading it.

This might be useful to allow extra definitions for individual basf2 modules, consider for example:

//in MyTestModule.h (preferably as a member of your Module class):
enum class Shape {
  Sphere,
  Cube
};
 
//in MyTestModule.cc
#include <boost/python.hpp>
#include <framework/utilities/RegisterPythonModule.h>
//...
using namespace boost::python;
 
BOOST_PYTHON_MODULE(MyTest)
{
  //export enum to python, e.g. Shape::Sphere becomes Shape.Sphere
  enum_<Shape>("Shape")
    .value("Sphere", Shape::Sphere)
    .value("Cube", Shape::Cube)
    ;
}
REGISTER_PYTHON_MODULE_AUTOIMPORT(MyTest)

In a steering file, the type MyTest.Sphere is available immediately after register_module('MyTest').

Definition at line 74 of file RegisterPythonModule.h.

Typedef Documentation

AccessorParams

typedef std::pair<std::string, DataStore::EDurability> AccessorParams

Pair of parameters needed to find an object in the DataStore.

Definition at line 24 of file StoreAccessorBase.h.

B2Vector3D

typedef B2Vector3<double> B2Vector3D

typedef for common usage with double

Definition at line 516 of file B2Vector3.h.

B2Vector3F

typedef B2Vector3<float> B2Vector3F

typedef for common usage with float

Definition at line 519 of file B2Vector3.h.

ModuleParamPtr

using ModuleParamPtr = std::shared_ptr<ModuleParamBase>

Defines a pointer to a module parameter as a boost shared pointer. *‍/.

Definition at line 38 of file ModuleParamList.h.

ModulePtr

typedef std::shared_ptr<Module> ModulePtr

Defines a pointer to a module object as a boost shared pointer.

Definition at line 43 of file Module.h.

ModulePtrList

typedef std::list<ModulePtr> ModulePtrList

Defines a std::list of shared module pointers.

Definition at line 584 of file Module.h.

PathPtr

typedef std::shared_ptr<Path> PathPtr

Defines a pointer to a path object as a boost shared pointer.

Definition at line 35 of file Path.h.

RelationsObject

typedef RelationsInterface<TObject> RelationsObject

Provides interface for getting/adding relations to objects in StoreArrays.

See RelationsInterface for details.

Definition at line 441 of file RelationsObject.h.

Enumeration Type Documentation

ArithmeticOperation

enum class ArithmeticOperation : int

strong

Enum for decoding the comparison operator type.

For encoding scheme in python

See also

a_operator_types in yacc.py

Definition at line 141 of file AbstractNodes.h.

                                 : int {
    PLUS,
    MINUS,
    PRODUCT,
    DIVISION,
    POWER
  };

BooleanOperator

enum class BooleanOperator : int

strong

Enum for decoding the boolean operator type.

For encoding scheme in python

See also

b_operator_types in yacc.py

Definition at line 119 of file AbstractNodes.h.

                             : int {
    AND,
    OR
  };

ComparisonOperator

enum class ComparisonOperator : int

strong

Enum for decoding the comparison operator type.

For encoding scheme in python

See also

c_operator_types in yacc.py

Definition at line 128 of file AbstractNodes.h.

                                : int {
    EQUALEQUAL,
    GREATEREQUAL,
    LESSEQUAL,
    GREATER,
    LESS,
    NOTEQUAL
  };

EMessageTypes

enum class EMessageTypes

strong

Type the messages can have.

Definition at line 16 of file ZMQDefinitions.h.

                           {
    // Used by DAQ and Framework: general control messages
    c_confirmMessage = 'c',   // is sent when an event is confirmed to be at the output process
    c_helloMessage = 'h',     // registration
    c_deleteWorkerMessage = 'd', // Delete the events of a given worker
    c_lastEventMessage = 'l', // indicates the last event was processed by the process
    c_readyMessage = 'r',     // is sent from the worker to the input to show, that it can process an event
    c_terminateMessage = 'x', // Ask all processes to (gently) stop
 
    // Used by DAQ and Framework: event messages
    c_rawDataMessage = 'u',        // a normal message with event data but in raw format
    c_compressedDataMessage = 'v', // a normal message with event data but in compressed format
    c_eventMessage = 'w',          // a normal message with event data
 
    // Only needed by framework
    c_goodbyeMessage = 'g',      // un-registration
    c_statisticMessage = 's',    // the last statistics will be send from the output to the process monitor
    c_killWorkerMessage = 'k',   // is sent when a worker should be killed (because it needed too much time)
 
    // Only needed by DAQ
    c_monitoringMessage = 'm',   // sent in DAQ package to monitor from remote
    c_newRunMessage = 'n',              // sent in DAQ package on starting
  };

ERecordType

enum ERecordType

What type of message is this?

Note: for parallel processing, the only type that can work is MSG_EVENT. Other messages would need to be sent once to each process, which would result in all kinds of race conditions.

Definition at line 25 of file EvtMessage.h.

{ MSG_EVENT, MSG_BEGIN_RUN, MSG_END_RUN, MSG_TERMINATE, MSG_NORECORD, MSG_STREAMERINFO };

NodeType

enum class NodeType : int

strong

Enum of possible Nodes in parsing tree.

NodeTypes in python are encoded with the corresponding dict

See also

node_types in yacc.py

Definition at line 100 of file AbstractNodes.h.

                      : int {
    UnaryBooleanNode,
    BinaryBooleanNode,
    UnaryRelationalNode,
    BinaryRelationalNode,
    TernaryRelationalNode,
    UnaryExpressionNode,
    BinaryExpressionNode,
    FunctionNode,
    IdentifierNode,
    DoubleNode,
    IntegerNode,
    BooleanNode
  };

ProcType

enum class ProcType

strong

Type of the process used for storing and mapping the child processes in the process handler.

Enumerator
c_Input	Input Process.
c_Worker	Worker/Reconstruction Process.
c_Output	Output Process.
c_Proxy	Multicast Proxy Process.
c_Monitor	Monitoring Process.
c_Init	Before the forks, the process is in init state.
c_Stopped	The process is stopped/killed.

Definition at line 16 of file ProcHelper.h.

                      {
    c_Input = 'i', 
    c_Worker = 'w', 
    c_Output = 'o', 
    c_Proxy = 'p', 
    c_Monitor = 'm', 
    c_Init = '0', 
    c_Stopped = 's' 
  };

ZMQAddressType

enum ZMQAddressType

The type of a ZMQ socket address (which socket to use)

Enumerator
c_output	Input socket.
c_pub	Output socket.
c_sub	Multicast publish socket.
c_control	Multicast subscribe socket. Multicast control socket

Definition at line 18 of file ZMQAddressUtils.h.

                      {
    c_input, 
    c_output, 
    c_pub, 
    c_sub, 
    c_control 
  };

Function Documentation

__repr__()

std::string __repr__

(

)

const

Return a string repesentation of this particle to be used when printing the particle in python.

Definition at line 18 of file EvtGenParticlePDG.cc.

  {
    std::stringstream buf;
    buf << "<Particle " << std::quoted(GetName());
    buf << " mass=" << Mass() << " width=" << Width();
    buf << std::setprecision(2) << " charge=" << (Charge() / 3.);
    buf << " pdg=" << PdgCode() << ">";
    return buf.str();
  }

addConstantOverride()

void addConstantOverride	(	const std::string &	name,
		TObject *	obj,
		bool	oneRun = false
	)

Add constant override payload.

This payload will be valid for all possible iov and will be used instead of values from the database.

Parameters

name	Name under which the object will be accessible
obj	Pointer to the object to be used. Ownership will be transfered to the DBStore.
oneRun	if true the override will only be in effect for this one run, not for any other runs

Warning

don't use this if you do not know exactly what you are doing. This is meant mainly for beamparameters

Definition at line 204 of file DBStore.cc.

  {
    IntervalOfValidity iov = IntervalOfValidity::always();
    if (oneRun) {
      int exp, run;
      if (m_manualEvent) {
        exp = m_manualEvent->getExperiment();
        run = m_manualEvent->getRun();
      } else {
        exp = m_storeEvent->getExperiment();
        run = m_storeEvent->getRun();
      }
      iov = IntervalOfValidity(exp, run, exp, run);
    }
    // Add the DBStore entry
    auto iter = m_dbEntries.find(name);
    if (iter == end(m_dbEntries)) {
      iter = m_dbEntries.emplace(name, DBStoreEntry::fromObject(name, obj, true)).first;
    }
    DBStoreEntry& dbEntry = iter->second;
    dbEntry.overrideObject(obj, iov);
    // we need to remove this entry from the intraRunDependencies list now.
    // Otherwise it will reset the object on the next event call
    m_intraRunDependencies.erase(&dbEntry);
    B2WARNING("An override for DBEntry " << name << " was created.");
  }

addOperator()

void addOperator ( EOperator  op )

private

Add an operator to the internal state, convert them to reverse polish notation using the shunting yard algorithm and execute them as they become available.

Definition at line 111 of file FormulaParser.cc.

  {
    if (op == EOperator::c_squareBracketOpen or op == EOperator::c_roundBracketOpen) {
      //the last thing we added was a variable so a bracket doesn't make sense
      if (!m_lastTokenWasOperator) throw std::runtime_error("missing operator");
      // otherwise, ont the stack it goes
      m_operatorStack.push(op);
      return;
    }
    if (op == EOperator::c_squareBracketClose or op == EOperator::c_roundBracketClose) {
      // closing bracket. Look for a matching opening bracket and execute all
      // operators until then
      EOperator correct = EOperator::c_roundBracketOpen;
      EOperator wrong = EOperator::c_squareBracketOpen;
      if (op == EOperator::c_squareBracketClose) std::swap(correct, wrong);
      while (!m_operatorStack.empty()) {
        EOperator tok = m_operatorStack.top();
        m_operatorStack.pop();
        if (tok == wrong) throw std::runtime_error("wrong type of closing bracket");
        if (tok == correct) return;
        executeOperator(tok);
      }
      // stack is empty, still no bracket
      throw std::runtime_error("unmatched bracket");
    }
 
    // Ok, now normal operators: there shouldn't be two in a row
    if (m_lastTokenWasOperator) throw std::runtime_error("missing operand before operator");
    m_lastTokenWasOperator = true;
 
    // The operator precedence is in the upper 4 bits ... hrhr
    // TODO: make a function for this?
    int op_precedence = (int)op >> 4;
    while (!m_operatorStack.empty()) {
      EOperator tok = m_operatorStack.top();
      // Stop at brackets
      if (tok == EOperator::c_roundBracketOpen or tok == EOperator::c_squareBracketOpen) break;
      int tok_precedence = (int)tok >> 4;
      // Pow operator has right assiocativity, all others are left associative
      // TODO: make nicer?
      bool tok_right = op == EOperator::c_power;
      // If the token has lower precedence or equal precedence but is right associative stop taking tokens
      if (tok_precedence < op_precedence or (tok_precedence == op_precedence and tok_right)) break;
      // otherwise pop and execute
      executeOperator(tok);
      m_operatorStack.pop();
    }
    m_operatorStack.push(op);
  }

addParam() [1/2]

void addParam ( const std::string &  name, T &  paramVariable, const std::string &  description  )

protected

Adds a new enforced parameter to the module.

This method has to be called in the constructor of the module. The user has to set the value for this parameter in the steering file.

Parameters

name	The unique name of the parameter.
paramVariable	The member variable of the module to which the value from the steering file is written.
description	A description of the parameter.

Definition at line 567 of file Module.h.

  {
    m_moduleParamList.addParameter(name, paramVariable, description);
  }

addParam() [2/2]

void addParam ( const std::string &  name, T &  paramVariable, const std::string &  description, const T &  defaultValue  )

protected

Adds a new parameter to the module.

This method has to be called in the constructor of the module.

Parameters

name	The unique name of the parameter.
paramVariable	The member variable of the module to which the value from the steering file is written.
description	A description of the parameter.
defaultValue	The default value of the parameter which is used if there was no value given in the steering file.

Definition at line 560 of file Module.h.

  {
    m_moduleParamList.addParameter(name, paramVariable, description, defaultValue);
  }

addParameter() [1/2]

void addParameter	(	const std::string &	name,
		T &	paramVariable,
		const std::string &	description
	)

Adds a new enforced parameter to the module list.

A parameter consists of a reference pointing to a member variable in the module which stores and allows fast access to the parameter value. In addition the type of the parameter is saved and a description is given. This parameter has to be set by the user in the steering file.

Parameters

name	The unique name of the parameter.
paramVariable	Reference to the variable which stores the parameter value.
description	An description of the parameter.

Definition at line 50 of file ModuleParamList.templateDetails.h.

  {
    ModuleParamPtr newParam(new ModuleParam<T>(paramVariable, description, true));
 
    // Check if a parameter with the given name already exists
    std::map<std::string, ModuleParamPtr>::iterator mapIter;
    mapIter = m_paramMap.find(name);
 
    if (mapIter == m_paramMap.end()) {
      m_paramMap.insert(std::make_pair(name, newParam));
    } else {
      B2ERROR("A parameter with the name '" + name +
              "' already exists! The name of a module parameter must be unique within a module.");
    }
  }

addParameter() [2/2]

void addParameter	(	const std::string &	name,
		T &	paramVariable,
		const std::string &	description,
		const T &	defaultValue
	)

Adds a new parameter to the module list.

A parameter consists of a reference pointing to a member variable in the module which stores and allows fast access to the parameter value. In addition the type of the parameter is saved and a description is given.

Parameters

name	The unique name of the parameter.
paramVariable	Reference to the variable which stores the parameter value.
description	An description of the parameter.
defaultValue	The default value of the parameter.

Definition at line 28 of file ModuleParamList.templateDetails.h.

  {
    ModuleParamPtr newParam(new ModuleParam<T>(paramVariable, description, false));
 
    // Check if a parameter with the given name already exists
    std::map<std::string, ModuleParamPtr>::iterator mapIter;
    mapIter = m_paramMap.find(name);
 
    if (mapIter == m_paramMap.end()) {
      m_paramMap.insert(std::make_pair(name, newParam));
      ModuleParam<T>* explModParam = static_cast<ModuleParam<T>*>(newParam.get());
      explModParam->setDefaultValue(defaultValue);
    } else {
      B2ERROR("A parameter with the name '" + name +
              "' already exists! The name of a module parameter must be unique within a module.");
    }
  }

almostEqualDouble()

bool almostEqualDouble	(	const double &	a,
		const double &	b
	)

Helper function to test if two doubles are almost equal.

Forward declaration of function defined in framework/utilities/GeneralCut.cc.

Definition at line 26 of file CutHelpers.cc.

  {
    static_assert(sizeof(double) == sizeof(int64_t));
    // cppcheck-suppress invalidPointerCast
    return std::fabs(*(int64_t*)&a - * (int64_t*)&b) <= 2 or (a == b);
  }

almostEqualFloat()

bool almostEqualFloat	(	const float &	a,
		const float &	b
	)

Helper function to test if two floats are almost equal.

Definition at line 19 of file CutHelpers.cc.

  {
    static_assert(sizeof(float) == sizeof(int32_t));
    // cppcheck-suppress invalidPointerCast
    return std::fabs(*(int32_t*)&a - * (int32_t*)&b) <= 2 or (a == b);
  }

applyOperator()

double applyOperator ( EOperator  op, double  a, double  b  )

static

Apply operator on two values.

Definition at line 36 of file FormulaParser.cc.

  {
    switch (op) {
      case EOperator::c_plus: return a + b;
      case EOperator::c_minus: return a - b;
      case EOperator::c_multiply: return a * b;
      case EOperator::c_divide: return a / b;
      case EOperator::c_power: return std::pow(a, b);
      default: throw std::runtime_error(std::string("Cannot apply operator ") + operatorToChar(op));
    }
    return 0;
  }

assertOperatorUsable()

void assertOperatorUsable ( size_t  stacksize )

staticprotected

Make sure we have enough operands to use an operator.

Definition at line 102 of file FormulaParser.cc.

  {
    // we only have binary operators so we need two operands
    if (stacksize < 1)
      throw std::runtime_error("could not parse, stack of operands empty. Please report, this is most likely a bug");
    if (stacksize < 2)
      throw std::runtime_error("Missing operand");
  }

at()

DataType at

(

unsigned

i

)

const

safe member access (with boundary check!)

safe member access (with boundary check!) should always be used!

Definition at line 751 of file B2Vector3.h.

  {
    switch (i) {
      case 0:
        return B2Vector3<DataType>::m_coordinates[0];
      case 1:
        return B2Vector3<DataType>::m_coordinates[1];
      case 2:
        return B2Vector3<DataType>::m_coordinates[2];
    }
    B2FATAL(this->name() << "::access operator: given index (i=" << i << ") is out of bounds!");
    return 0.;
  }

average()

void average	(	const std::string &	key,
		double	value
	)

Instead of storeing the double value directly under the given key, store the average of the last MAX_SIZE values.

Definition at line 102 of file ZMQLogger.h.

  {
    auto& [averages, index] = m_averages[key];
 
    if (averages.size() == MAX_SIZE) {
      averages[index] = value;
      index = (index + 1) % MAX_SIZE;
    } else {
      averages.push_back(value);
    }
 
    log(key, std::accumulate(averages.begin(), averages.end(), 0.0) / averages.size());
  }

calculate()

ROOT::Math::XYZVector calculate ( const ROOT::Math::XYZVector &  pos ) const

inlineprivate

Calculate the field value at a given position and return it.

Parameters

pos	position where to evaluate the magnetic field

Returns

magnetic field value at position pos

Definition at line 85 of file BFieldManager.h.

  {
    if (!m_magfield) B2FATAL("Could not load magnetic field configuration from database");
    return m_magfield->getField(pos);
  };

checkForOperator()

auto checkForOperator ( char  next )

private

Check if the next character is a operator.

Definition at line 192 of file FormulaParser.cc.

  {
    if (next == '+' or next == '-') {
      // plus and minus are also part of literals so only treat it as operator
      // if, together with the next character, this is not a valid float literal
      auto isvalid = checkNumber(m_currentVariableNameNumberStatus, next);
      if (isvalid != ENumberStatus::c_Invalid and checkNumber(isvalid, m_buffer.peek()) != ENumberStatus::c_Invalid) {
        // this looks like a number don't interpret as operator
        return EOperator::c_noop;
      }
      if (next == '+') return EOperator::c_plus;
      if (next == '-') return EOperator::c_minus;
    }
    if (next == '/') return EOperator::c_divide;
    if (next == '^') return EOperator::c_power;
    if (next == '*') {
      // is it python style '**'? if yes, remove one char from stream and
      // assume pow
      if (m_buffer.peek() == '*') {
        m_buffer.get();
        return EOperator::c_power;
      }
      // otherwise multiply
      return EOperator::c_multiply;
    }
    if (next == '(') return EOperator::c_roundBracketOpen;
    if (next == ')') return EOperator::c_roundBracketClose;
    if (next == '[') return EOperator::c_squareBracketOpen;
    if (next == ']') return EOperator::c_squareBracketClose;
    // no operator, so let's return just that
    return EOperator::c_noop;
  }

checkNumber()

auto checkNumber ( ENumberStatus  current, char  next  )

static

Check if a string literal with a given number status continues to be a valid number if next is appended to it.

Definition at line 49 of file FormulaParser.cc.

  {
    switch (current) {
      case ENumberStatus::c_Invalid:
        // invalid stays invalid
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_Empty:
        // numbers are allowed to start with digits, a dot or a sign
        if (std::isdigit(next)) return ENumberStatus::c_Int;
        if (next == '.') return ENumberStatus::c_LeadingDot;
        if (next == '+' or next == '-') return ENumberStatus::c_Sign;
        // everything else we don't like
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_Sign:
        // if we started with a sign we can only go to digit and dots, no exponent
        if (std::isdigit(next)) return ENumberStatus::c_Int;
        if (next == '.') return ENumberStatus::c_Dot;
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_Int:
        // So far it's a valid int consisting only of [sign +] digits, next
        // stage is more digits, a . or an exponent
        if (std::isdigit(next)) return ENumberStatus::c_Int;
        if (next == '.') return ENumberStatus::c_Dot;
        if (next == 'E' or next == 'e') return ENumberStatus::c_Exponent;
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_Dot:
        // After the dot there can be more digits ... or a exponent
        if (std::isdigit(next)) return ENumberStatus::c_Float;
        if (next == 'E' or next == 'e') return ENumberStatus::c_Exponent;
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_LeadingDot:
        // But if the dot was in the beginning then no exponent
        if (std::isdigit(next)) return ENumberStatus::c_Float;
        return ENumberStatus::c_Invalid;
      // so, we saw some digits after the dot ... more digits or exponent it is
      case ENumberStatus::c_Float:
        if (std::isdigit(next)) return ENumberStatus::c_Float;
        if (next == 'E' or next == 'e') return ENumberStatus::c_Exponent;
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_Exponent:
        // and for the exponent we need either additional digits or a sign
        if (std::isdigit(next)) return ENumberStatus::c_Scientific;
        if (next == '+' or next == '-') return ENumberStatus::c_ExponentSign;
        return ENumberStatus::c_Invalid;
      case ENumberStatus::c_ExponentSign:
      case ENumberStatus::c_Scientific:
        // and after the exponent sign and any digit thereafter only digits are possible
        if (std::isdigit(next)) return ENumberStatus::c_Scientific;
        return ENumberStatus::c_Invalid;
    }
    return ENumberStatus::c_Invalid;
  }

checkType() [1/2]

bool checkType ( const TObject *  object ) const

private

Check if a given TObject instance is compatible with the type of this entry.

Definition at line 228 of file DBStoreEntry.cc.

  {
    // Get class information from object
    if (object->InheritsFrom(IntraRunDependency::Class())) {
      object = static_cast<const IntraRunDependency*>(object)->getAnyObject();
    }
    TClass* objClass = object->IsA();
    bool array = (objClass == TClonesArray::Class());
    if (array) {
      objClass = static_cast<const TClonesArray*>(object)->GetClass();
    }
 
    return checkType(c_Object, objClass, array, true);
  }

checkType() [2/2]

bool checkType ( EPayloadType  type, const TClass *  objClass, bool  array, bool  inverse = false  ) const

private

Check if a given TClass is compatible with the type of this entry.

Definition at line 198 of file DBStoreEntry.cc.

  {
    if (type != m_payloadType) {
      B2FATAL("Existing entry '" << m_name << "' is of a different type than requested");
    }
    // OK, all other checks only make sense for objects
    if (type != c_Object) return true;
    // Check whether the existing entry and the requested object are both arrays or both single objects
    if (m_isArray != array) {
      B2FATAL("Existing entry '" << m_name << "' is an " << ((m_isArray) ? "array" : "object") <<
              " and the requested one an " << ((array) ? "array" : "object"));
    }
 
    // Check whether the existing entry and the requested object have the same type
    if (!inverse) {
      if (!m_objClass->InheritsFrom(objClass)) {
        B2FATAL("Existing entry '" << m_name << "' of type " <<
                m_objClass->GetName() << " doesn't match requested type " <<
                objClass->GetName());
      }
    } else {
      if (!objClass->InheritsFrom(m_objClass)) {
        B2FATAL("Existing entry '" << m_name << "' of type " <<
                m_objClass->GetName() << " doesn't match actual type " <<
                objClass->GetName());
      }
    }
    return true;
  }

clearBackends()

void clearBackends

(

)

Clear list of backends.

Definition at line 127 of file Gearbox.cc.

  {
    for (gearbox::InputHandler* handler : m_handlers) delete handler;
    m_handlers.clear();
  }

close()

void close

(

)

Free internal structures of previously parsed tree and clear cache.

Definition at line 169 of file Gearbox.cc.

  {
    if (m_xpathContext) xmlXPathFreeContext(m_xpathContext);
    if (m_xmlDocument) xmlFreeDoc(m_xmlDocument);
    m_xpathContext = nullptr;
    m_xmlDocument = nullptr;
 
    for (auto& entry : m_ownedObjects) {
      delete entry.second;
    }
    m_ownedObjects.clear();
 
    m_parameterCache->clear();
  }

consolidate()

void consolidate	(	const FunctionFrom &	replaceFrom = FunctionFrom(),
		const FunctionTo &	replaceTo = FunctionTo(),
		EConsolidationAction	action = c_doNothing
	)

Consolidate RelationElements.

This function will loop over the relation and "compress" it by merging all elements with the same fromIndex.

The optional arguments can be used to replace indices in the relation, mainly useful in the simulation to replace the Geant4 TrackID with the index of the MCParticle at the end of the event

The Function objects should return a new (index,bool) pair for every index in the old relation. The returned index will be used as the new index in the relation and the bool pair indicates whether the original element got re-attributed or if it is just an index reordering. If it the original element got re-attributed the behaviour depends on the value of action, see EConsolidationAction

Warning: If action is set to c_negativeWeight and there is more than one element having the same from->to index pair after transformation the behaviour is undefined as the two elements get merged. It could happen that a negative and a positive weight get summed up, leaving the weight rather meaningless

See also

Identity, ReplaceMap, ReplaceVec, EConsolidationAction

Parameters

replaceFrom	Function object containing replacements for the from indices
replaceTo	Function object containing replacements for the to indices
action	Action to be performed when the old element got removed

Definition at line 466 of file RelationArray.h.

  {
    if (!isValid()) {
      B2ERROR("Cannot consolidate an invalid relation (" << m_name << ")");
      return;
    }
    typedef std::map<index_type, weight_type> element_t;
    typedef std::map<index_type, element_t > buffer_t;
    buffer_t buffer;
 
    //Fill all existing elements in a nested map, adding the weights of
    //duplicate elements
    index_type lastFromIndex(0);
    buffer_t::iterator lastFromIter = buffer.end();
    unsigned int nElements = (*m_relations)->getEntries();
    TClonesArray& elements = (*m_relations)->elements();
    for (unsigned int i = 0; i < nElements; ++i) {
      RelationElement& element = *static_cast<RelationElement*>(elements[i]);
      //Replace from index
      consolidation_type from = replaceFrom(element.getFromIndex());
 
      //Ignore whole element if original element got deleted
      if (action == c_deleteElement && from.second) continue;
 
      //Check if the fromIndex is the same as the last one and reuse
      //iterator if possible
      if (from.first != lastFromIndex || lastFromIter == buffer.end()) {
        lastFromIter = buffer.insert(make_pair(from.first, element_t())).first;
        lastFromIndex = from.first;
      }
      //Loop over all elements of this relationelement and add them to the map
      size_t size = element.getSize();
      for (size_t j = 0; j < size; ++j) {
        //Replace to Index
        consolidation_type to = replaceTo(element.getToIndex(j));
        //Ignore whole element if original element got deleted
        if (action == c_deleteElement && to.second) continue;
        double weight = element.getWeight(j);
        //Original from or to element got deleted. Do whatever is specified by action
        //Warning: if there is more than one element pointing to the same
        //from->to element after transformation the negative weight option is
        //not safe as we sum a positive and a negative weight when
        //consolidating.
        if (from.second || to.second) {
          if (action == c_zeroWeight) {
            weight = 0;
          } else if (action == c_negativeWeight && weight > 0) {
            weight = -weight;
          }
        }
        //add the weight to the new from->to index pair
        lastFromIter->second[to.first] += weight;
      }
    }
    //Clear the existing relation
    elements.Delete();
    //Fill the map into the relation
    for (buffer_t::iterator iter = buffer.begin(); iter != buffer.end(); ++iter) {
      add(iter->first, iter->second.begin(), iter->second.end());
    }
  }

convertString() [1/2]

T convertString

(

const std::string &

str

)

Converts a string to type T (one of float, double, long double, int, long int, unsigned long int).

Throws std::invalid_argument on conversion errors, out_of_range if T cannot hold the given value. You can catch both possible exception types of the function (invalid_argument and out_of_range) using the base class logic_error

convertString() [2/2]

float convertString

(

const std::string &

str

)

Converts a string to float.

Parameters

str	string which is converted to float

Returns

converted float

Definition at line 24 of file Conversion.cc.

  {
    std::string::size_type n;
    float number = std::stof(str, &n);
    if (n != str.size()) {
      throw std::invalid_argument("Could only parse a part of the given string " + str);
    }
    return number;
  }

convertValue()

double convertValue ( double  value, const std::string &  unitString  )

static

Converts a floating point value to the standard framework unit.

If the given unit is not found, the value is returned unchanged (and an error printed).

Parameters

value	The value which should be converted.
unitString	The string of the unit of the specified value.

Returns

The value converted to the standard unit.

Definition at line 129 of file UnitConst.cc.

  {
    auto it = s_conversionFactors.find(unitString);
    if (it == s_conversionFactors.end()) {
      B2ERROR("Could not find conversion factor for unit " << unitString << ", assuming 1.0");
      return value;
    }
    return it->second * value;
  }

convertValueToUnit()

double convertValueToUnit ( double  value, const std::string &  unitString  )

static

Converts a floating point value from the standard framework unit to the given unit.

If the given unit is not found, the value is returned unchanged (and an error printed).

Parameters

value	The value which should be converted.
unitString	The string of the unit of the specified value.

Returns

The value converted to the given unit.

Definition at line 139 of file UnitConst.cc.

  {
    auto it = s_conversionFactors.find(unitString);
    if (it == s_conversionFactors.end()) {
      B2ERROR("Could not find conversion factor for unit " << unitString << ", assuming 1.0");
      return value;
    }
    return value / it->second;
  }

copyRelationsToSelf()

void copyRelationsToSelf

protected

Copy any set -> set relations between selected objects.

Definition at line 390 of file SelectSubset.h.

  {
    for (const StoredClass& subsetObject1 : *m_subset) {
      //TODO: change relation direction to set -> subset?
      const StoredClass* setObject1 = subsetObject1.template getRelatedFrom<StoredClass>(m_set->getName());
 
      if (setObject1 != nullptr) {
        //get all objects in original set related to setObject1
        const RelationVector<StoredClass>& relations = setObject1->template getRelationsTo<StoredClass>(m_set->getName());
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          const StoredClass* setObject2 = relations.object(iRel);
          const double weight = relations.weight(iRel);
          //if setObject2 was selected into subset, inherit relation
          const StoredClass* subsetObject2 = setObject2->template getRelatedTo<StoredClass>(m_subset->getName());
          if (subsetObject2) {
            subsetObject1.addRelationTo(subsetObject2, weight);
          }
        }
      }
    }
  }

copySetWithRelations()

std::map< int, int > copySetWithRelations ( std::function< bool(const StoredClass *)>  f )

protected

Selects the elements, fill the subset and copies all the relations in which the set is involved.

Definition at line 351 of file SelectSubset.h.

  {
    std::map<int, int> oldToNew;
    for (const StoredClass& setObject : *m_set) {
      if (!f(&setObject))
        continue;
 
      oldToNew[setObject.getArrayIndex()] = m_subset->getEntries();
      const StoredClass* subsetObject = m_subset->appendNew(setObject);
      if (!m_reduceExistingSet)
        setObject.addRelationTo(subsetObject);
    }
 
 
    //TODO this is the slow bit, can probably be improved by directly dealing with indices
    for (const auto& oldToNewPair : oldToNew) {
      const StoredClass* setObject = (*m_set)[oldToNewPair.first];
      const StoredClass* subsetObject = (*m_subset)[oldToNewPair.second];
 
      for (std::string fromArray : m_inheritFromArrays) {
        const RelationVector<RelationsObject>& relations = setObject->template getRelationsFrom<RelationsObject>(fromArray);
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          relations.object(iRel)->addRelationTo(subsetObject, relations.weight(iRel));
        }
      }
      for (std::string toArray : m_inheritToArrays) {
        const RelationVector<RelationsObject>& relations = setObject->template getRelationsTo<RelationsObject>(toArray);
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          subsetObject->addRelationTo(relations.object(iRel), relations.weight(iRel));
        }
      }
    }
 
    return oldToNew;
  }

createROOTObjectPyCopy()

boost::python::object createROOTObjectPyCopy

(

const T &

instance

)

Create a python wrapped copy from a class instance which has a ROOT dictionary.

This piece of dark magic creates a python object referencing a ROOT object the same way as you would see it in the ROOT python module.

It will create a copy of the object using the copy constructor which is then owned by python.

Definition at line 26 of file PyObjROOTUtils.h.

  {
    const char* classname = instance.IsA()->GetName();
    void* addr = new T(instance);
    PyObject* obj = TPython::CPPInstance_FromVoidPtr(addr, classname, true);
    return boost::python::object(boost::python::handle<>(obj));
  }

createScopedUpdateSession()

ScopeGuard createScopedUpdateSession

(

)

Make sure we have efficient http pipelinging during initialize/beginRun but don't keep session alive for full processing time.

This will return an object which keeps the session open as long as it is alive.

Definition at line 62 of file Database.cc.

  {
    // make sure we reread testing text files in case they got updated
    for (auto& testing : m_testingPayloads) {
      testing.reset();
    }
    // and return a downloader session guard for the downloader we use
    return Conditions::Downloader::getDefaultInstance().ensureSession();
  }

createSocket() [1/2]

std::unique_ptr< zmq::socket_t > createSocket

(

const std::string &

socketAddress

)

Create a socket of the given type while deciding on the bind behaviour via the address.

An address in the form "tcp://ast:<port>" (with ast = *) means the socket is bound to a local interface. An address in the from "tcp://<host>:<port>" means it connects to the given host.

If you want to fore a given bind behaviour (and fail if the address is invalid), use the function above.

Definition at line 141 of file ZMQParent.h.

  {
    // We only check for "*" in the full address for now. This is fine, as neither a valid hostname nor a valid
    // port number can ever contain a "*".
    if (socketAddress.find("*") != std::string::npos) {
      return createSocket<AZMQType>(socketAddress, true);
    } else {
      return createSocket<AZMQType>(socketAddress, false);
    }
  }

createSocket() [2/2]

std::unique_ptr< zmq::socket_t > createSocket	(	const std::string &	socketAddress,
		bool	bind
	)

Create a socket of the given type with the given address and bind or not bind it.

Typical socket types are ZMQ_ROUTER, ZMQ_DEALER and ZMQ_STREAM.

The address needs to be in the form "tcp://ast:<port>" (with ast = *) if you want to bind to a local interface or "tcp://<host>:<port>" if you want to connect. Use the convenience function below if you want the program to decide based on your address and use this function if you want the program to force a specific bind behaviour (it will raise an exception if given an invalid address).

Definition at line 105 of file ZMQParent.h.

  {
    initialize();
 
    try {
      // TODO: options to test additionally in the future:
      // * ZMQ_IMMEDIATE
      // * ZMQ_PROBE_ROUTER
      // * ZMQ_ROUTER_MANDATORY
      // * ZMQ_ROUTER_NOTIFY
      auto socket = std::make_unique<zmq::socket_t>(*m_context, AZMQType);
 
      if (AZMQType == ZMQ_DEALER) {
        auto identity = createIdentity();
        socket->set(zmq::sockopt::routing_id, identity);
      }
 
      // Linger means: close the socket immediately if requested, do not wait until all messages have been sent.
      // This is needed because if we want to ABORT, we usually know what we are doing (and want to do it now).
      socket->set(zmq::sockopt::linger, 0);
      if (bind) {
        socket->bind(socketAddress.c_str());
      } else {
        socket->connect(socketAddress.c_str());
      }
 
      // Wait a bit to give the framework time to initialize the socket
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
      return socket;
    } catch (zmq::error_t& error) {
      B2FATAL("Creating the ZMQ socket for address " << socketAddress << " failed because of: " << error.what());
    }
  }

DEFINE_UNIT() [1/2]

DEFINE_UNIT	(	cm	,
		1.
	)

Standard units with the value = 1.

Standard of [length]

DEFINE_UNIT() [2/2]

DEFINE_UNIT	(	km	,
		Unit::cm *	1e5
	)

Derived units.

[kilometers]

DEFINE_UNIT_NAME()

DEFINE_UNIT_NAME	(	g_cm3	,
		1.	,
		"g/cm3"
	)

Practical units with the value = 1.

These units are NOT consistent with the other standard units. Please use them carefully. Standard of [density]

expand()

std::string expand ( const std::string &  text )

static

Modify the given string and replace every occurence of $NAME or ${NAME} with the value of the environment variable NAME.

Variables which are not found are returned unchanged

Definition at line 60 of file EnvironmentVariables.cc.

  {
    // we could implement this ourselves ... but that seems like a waste of
    // time since there's a perfectly good implementation available.
    namespace py = boost::python;
    py::object path = py::import("os.path");
    return py::extract<std::string>(path.attr("expandvars")(text));
  }

exposePythonAPI()

void exposePythonAPI ( )

static

Exposes setGlobalTag function of the Database class to Python.

Definition at line 272 of file Database.cc.

  {
    // To avoid confusion between std::arg and boost::python::arg we want a shorthand namespace as well
    namespace py = boost::python;
 
    // Make sure the default instance is created
    Database::Instance();
 
    // Don't show c++ signature in python doc to keep it simple
    py::docstring_options options(true, true, false);
 
    // Expose our shiny configuration object
    Conditions::Configuration::exposePythonAPI();
  }

findIgnoringParenthesis()

unsigned long int findIgnoringParenthesis	(	std::string	str,
		std::string	pattern,
		unsigned int	begin = 0
	)

Returns the position of a pattern in a string ignoring everything that is in parenthesis.

Definition at line 49 of file CutHelpers.cc.

  {
 
    if (str.size() < pattern.size())
      return std::string::npos;
 
    for (unsigned int i = begin; i < str.size() - pattern.size(); ++i) {
      if (str[i] == '[') {
        i += findMatchedParenthesis(str.substr(i), '[', ']');
        continue;
      }
      if (str[i] == '(') {
        i += findMatchedParenthesis(str.substr(i), '(', ')');
        continue;
      }
      if (str[i] == '{') {
        i += findMatchedParenthesis(str.substr(i), '{', '}');
        continue;
      }
 
      for (unsigned int j = 0; j < pattern.size(); ++j) {
        if (str[i + j] != pattern[j]) {
          break;
        }
        if (j == pattern.size() - 1) {
          return i;
        }
      }
    }
    return std::string::npos;
  }

findMatchedParenthesis()

unsigned long int findMatchedParenthesis	(	std::string	str,
		char	open = '[',
		char	close = ']'
	)

Returns position of the matched closing parenthesis if the first character in the given string contains an opening parenthesis.

Otherwise return 0.

Definition at line 33 of file CutHelpers.cc.

  {
    unsigned long int end = 1;
    if (str[0] == open) {
      unsigned int count = 1;
      for (end = 1; end < str.size() and count > 0; ++end) {
        if (str[end] == open) ++count;
        else if (str[end] == close) --count;
      }
 
      if (count > 0)
        throw std::runtime_error("Variable string has an invalid format: " + str);
    }
    return end - 1;
  }

flushCurrentVariable()

void flushCurrentVariable ( )

private

Flush the currently parsed variable name and add it to the state either as variable or number.

Definition at line 173 of file FormulaParser.cc.

  {
    if (!m_currentVariableName.empty()) {
      if (!m_lastTokenWasOperator) throw std::runtime_error("Missing operator before variable");
      m_lastTokenWasOperator = false;
      // looks like a number, so add a number
      if (m_currentVariableNameNumberStatus != ENumberStatus::c_Invalid) {
        char* ptr;
        double value;
        value = std::strtod(m_currentVariableName.c_str(), &ptr);
        addVariable(InputToken(value));
      } else {
        addVariable(InputToken(m_currentVariableName));
      }
    }
    m_currentVariableName.clear();
    m_currentVariableNameNumberStatus = ENumberStatus::c_Empty;
  }

flushPendingOperators()

void flushPendingOperators ( )

private

Flush all pending operators at the end of processing.

Definition at line 161 of file FormulaParser.cc.

  {
    while (!m_operatorStack.empty()) {
      EOperator op = m_operatorStack.top();
      m_operatorStack.pop();
      // found a bracket but no more closing brackets to come ... so error
      if (op == EOperator::c_squareBracketOpen or op == EOperator::c_roundBracketOpen)
        throw std::runtime_error("missing closing bracket");
      executeOperator(op);
    }
  }

fromObject()

DBStoreEntry fromObject ( const std::string &  name, const TObject *  obj, bool  isRequired  )

static

Construct a new DBStoreEntry with a requested name and an object directly.

The constructor arguments type, objClass and isArray will be filled correctly by looking at obj

Parameters

name	name of the payload, ususally the class name of the payload but can be any string identifying the payload in the database
obj	instance of an object representing the correct type
isRequired	if false don't emit errors if the payload cannot be found for any run

Returns

new DBStoreEntry instance with the correct name and types set

Definition at line 37 of file DBStoreEntry.cc.

  {
    assert(obj);
    bool isArray = dynamic_cast<const TClonesArray*>(obj) != nullptr;
    TClass* objClass = isArray ? (dynamic_cast<const TClonesArray*>(obj)->GetClass()) : (obj->IsA());
    return DBStoreEntry(c_Object, name, objClass, isArray, isRequired);
  }

Gearbox()

Gearbox ( )

private

Singleton: private constructor.

Definition at line 67 of file Gearbox.cc.

                  : m_xmlDocument(nullptr), m_xpathContext(nullptr),
    m_parameterCache(new MRUCache<std::string, PathValue>(c_DefaultCacheSize))
  {
    xmlInitParser();
    LIBXML_TEST_VERSION;
  }

generate_number_sequence()

std::set< int64_t > generate_number_sequence

(

const std::string &

str

)

Generate a sequence of numbers defined by a string.

The syntax looks like this: sequence = interval,interval,interval,... interval = begin:end number

For instance. 3,23:27,101 Would generate the following sequence of numbers 3,23,24,25,26,27,101

If intervals overlap the number is only returned once, so the following string 27,24:28,26:29 yields 24,25,26,27,28,29

Negative numbers and intervals are supported as well -3:3 yields -3,-2,-1,0,1,2,3

But reversed intervals are considered empty 5:3 yields an empty sequence

Returns a std::set, which contains the number sequence, each number (as stated above) occurs only once (obviously, since it's a set) and the numbers are ordered using the default Compare operator less<int> of std::set.

Definition at line 20 of file NumberSequence.cc.

  {
    // Tokenize input
    std::vector<std::string> tokens;
    unsigned int lastdelimiter = 0;
    for (unsigned int i = 0; i < str.size(); ++i) {
      if (str[i] == ',') {
        tokens.push_back(str.substr(lastdelimiter, i - lastdelimiter));
        lastdelimiter = i + 1;
      }
    }
    std::string last = str.substr(lastdelimiter);
    if (last.size() != 0) {
      tokens.push_back(last);
    }
 
    // Convert tokens into intervals
    std::vector<std::pair<int64_t, int64_t>> intervals;
    intervals.reserve(tokens.size());
    for (const auto& token : tokens) {
      size_t interval_marker_position = token.find(':');
      // Single number
      if (interval_marker_position == std::string::npos) {
        int64_t number = std::stol(token);
        intervals.emplace_back(number, number);
      } else {
        int64_t interval_begin = std::stol(token.substr(0, interval_marker_position));
        int64_t interval_end = std::stol(token.substr(interval_marker_position + 1));
        intervals.emplace_back(interval_begin, interval_end);
      }
    }
 
    // Convert tokens into number sequence
    std::set<int64_t> sequence;
    for (const auto& interval : intervals) {
      for (int64_t number = interval.first; number <= interval.second; ++number)
        sequence.insert(number);
    }
 
    return sequence;
  }

generateBucketNumber()

unsigned generateBucketNumber

(

)

const

Generates RF bucket number according to the fill pattern.

Returns

bucket number

Definition at line 47 of file BunchStructure.cc.

  {
    if (m_fillPattern.empty()) return (gRandom->Integer(c_RFBuckets / 2) * 2);
 
    if (m_filledBuckets.empty()) {
      for (unsigned i = 0; i < c_RFBuckets; ++i) {
        if (m_fillPattern[i]) m_filledBuckets.push_back(i);
      }
    }
 
    int index = gRandom->Integer(m_filledBuckets.size());
    return m_filledBuckets[index];
  }

get()

std::string get ( const std::string &  name, const std::string &  fallback = ""  )

static

Get the value of an environment variable or the given fallback value if the variable is not set.

Definition at line 25 of file EnvironmentVariables.cc.

  {
    char* envValue = std::getenv(name.c_str());
    if (envValue != nullptr) {
      std::string val(envValue);
      boost::trim(val);
      return envValue;
    }
    return fallback;
  }

getAllEntryNames()

std::set< std::string > getAllEntryNames

(

)

Return the names of all the payloads stored in the database at the time of this function is called.

This is equivalent to getting all the payloads' names used by the current basf2 process.

Definition at line 196 of file DBStore.cc.

  {
    std::set<std::string> s{};
    for (auto& [key, value] : m_dbEntries)
      s.emplace(key);
    return s;
  };

getBucket()

bool getBucket

(

int

i

)

const

Returns the fill status of RF bucket.

Parameters

i	bucket number (modulo c_RFBuckets applied internally)

Returns

true if bucket is filled

Definition at line 29 of file BunchStructure.cc.

  {
    if (m_fillPattern.empty()) return (i % 2 == 0);
 
    int k = i % c_RFBuckets;
    if (k < 0) k += c_RFBuckets;
    return m_fillPattern[k];
  }

getCurrentLogConfig()

const LogConfig & getCurrentLogConfig ( const char *  package = nullptr ) const

inline

Returns the current LogConfig object used by the logging system.

Will use the configuration of the current package, if available, or the current module, if available, or, otherwise, the global configuration.

The idea is that a module can call functions in a different package, and the log configuration for that package will be used.

Definition at line 258 of file LogSystem.h.

  {
    //module specific config?
    if (m_moduleLogConfig && (m_moduleLogConfig->getLogLevel() != LogConfig::c_Default)) {
      return *m_moduleLogConfig;
    }
    //package specific config?
    if (package && !m_packageLogConfigs.empty()) {
      // cppcheck-suppress stlIfFind ; cppcheck doesn't like scoped variables in if statements
      if (auto it = m_packageLogConfigs.find(package); it != m_packageLogConfigs.end()) {
        const LogConfig& logConfig = it->second;
        if (logConfig.getLogLevel() != LogConfig::c_Default)
          return logConfig;
      }
    }
    //global config
    return m_logConfig;
  }

getData() [1/2]

std::pair< TObject *, IntervalOfValidity > getData	(	const EventMetaData &	event,
		const std::string &	name
	)

Request an object from the database.

Parameters

event	The metadata of the event for which the object should be valid.
name	Name that identifies the object in the database.

Returns

A pair containing the object and the iov for which it is valid. Ownership will be given to the caller

Warning

The returned object has to be deleted by the caller

Definition at line 72 of file Database.cc.

  {
    DBStoreEntry entry(DBStoreEntry::c_Object, name, TObject::Class(), false, true);
    std::vector<DBQuery> query{DBQuery{name, true}};
    getData(event, query);
    entry.updatePayload(query[0].revision, query[0].iov, query[0].filename, query[0].checksum, query[0].globaltag, event);
    return std::make_pair(entry.releaseObject(), query[0].iov);
  }

getData() [2/2]

bool getData	(	const EventMetaData &	event,
		std::vector< DBQuery > &	query
	)

Request multiple objects from the database.

Parameters

event	The metadata of the event for which the objects should be valid.
query	A list of DBQuery entries that contains the names of the objects to be retrieved. On return the object and iov fields are filled.

Definition at line 81 of file Database.cc.

  {
    // initialize lazily ...
    if (!m_metadataProvider) initialize();
    // So first go over the requested payloads once, reset the info and check for any
    // testing payloads we might want to use
    const size_t testingPayloads = std::count_if(query.begin(), query.end(), [this, &event](auto & payload) {
      // make sure the queries are "reset" to invalid revision and no filename before we start looking
      payload.filename = "";
      payload.revision = 0;
      // and now look in all testing payload providers if any.
      for (auto& tmp : m_testingPayloads) {
        if (tmp.get(event, payload)) return true;
      }
      return false;
    });
    // if we already found all just return here
    if (testingPayloads == query.size()) return true;
    // nooow, lets look for proper payloads;
    try {
      m_metadataProvider->getPayloads(event.getExperiment(), event.getRun(), query);
    } catch (std::exception&) {
      // something went wrong with the metadata update ... so let's try next provider
      B2WARNING("Conditions data: Problem with payload metadata provider, trying to fall back to next provider..."
                << LogVar("provider", m_currentProvider));
      nextMetadataProvider();
      return getData(event, query);
    }
    // and if we could find the metadata lets also locate the payloads ...
    const size_t payloadsLocated = std::count_if(query.begin(), query.end(), [this](auto & payload) {
      // make sure we don't overwrite local payloads or otherwise already valid filenames;
      if (!payload.filename.empty()) return true;
      // but don't check for payloads we could not find. But this is only a
      // problem if they are required so report success for not required
      // payloads
      if (payload.revision == 0) return not payload.required;
      // and locate the payload.
      if (not m_payloadProvider->find(payload)) {
        // if that fails lets let the user know: Even for optional payloads, if
        // we know the metadata but cannot find the file something is fishy and
        // should be reported.
        auto loglevel = payload.required ? LogConfig::c_Error : LogConfig::c_Warning;
        B2LOG(loglevel, 0, "Conditions data: Could not find file for payload"
              << LogVar("name", payload.name) << LogVar("revision", payload.revision)
              << LogVar("checksum", payload.checksum) << LogVar("globaltag", payload.globaltag));
        return not payload.required;
      }
      return true;
    });
    // did we find all payloads?
    return payloadsLocated == query.size();
  }

getDefaultValue()

T & getDefaultValue

Returns the default value of the parameter.

Returns

The default value of the parameter.

Definition at line 56 of file ModuleParam.templateDetails.h.

  {
    return m_defaultValue;
  }

getDetectorComponent()

GearDir getDetectorComponent

(

const std::string &

component

)

Return GearDir representing a given DetectorComponent.

Parameters

component

Name of the DetectorComponent (e.g. IR, PXD)

Definition at line 314 of file Gearbox.cc.

  {
    return GearDir("/Detector/DetectorComponent[@name='" + component + "']/Content");
  }

getEntry()

DBStoreEntry * getEntry	(	DBStoreEntry::EPayloadType	payloadType,
		const std::string &	name,
		const TClass *	objClass,
		bool	array,
		bool	required = true
	)

Returns the entry with the requested name in the DBStore.

If the DBStore entry does not exist yet it is added to the map.

If the DBStore map already contains an object under the key with a DIFFERENT type than the given type one, an error will be reported.

Parameters

payloadType	Type of the payload. Usually c_Object.
name	Name under which the object is stored in the database (and in the DBStore).
objClass	The class of the object.
array	Whether it is a TClonesArray or not.
required	If true emit errors if the object cannot be found

Returns

DBEntry, or nullptr if the requested type does not match the one in the DBStore

Definition at line 34 of file DBStore.cc.

  {
    // Check whether the map entry already exists
    const auto& entry = m_dbEntries.find(name);
    if (entry != m_dbEntries.end()) {
      DBStoreEntry& dbEntry = entry->second;
 
      // Check whether the types match
      if (!dbEntry.checkType(type, objClass, array)) return nullptr;
 
      B2DEBUG(39, "DBEntry " << name << " was requested once more.");
      if (required && !dbEntry.isRequired()) {
        dbEntry.require();
        B2DEBUG(34, "DBEntry " << name << " is now required");
      }
      return &dbEntry;
    }
 
    // Add the DBStore entry
    const auto iter = m_dbEntries.emplace(name, DBStoreEntry{type, name, objClass, array, required});
    DBStoreEntry& dbEntry = iter.first->second;
    B2DEBUG(34, "DBEntry " << name << " was created (" << (required ? "required" : "optional") << ")");
 
    // If no object was obtained from the database yet, but it should be available, get it
 
    // Check if we have a non-DataStore event to use
    if (m_manualEvent) {
      Database::DBQuery query(name, required);
      if (Database::Instance().getData(*m_manualEvent, query)) {
        dbEntry.updatePayload(query.revision, query.iov, query.filename, query.checksum, query.globaltag, *m_manualEvent);
      }
      if (dbEntry.isIntraRunDependent()) m_intraRunDependencies.insert(&dbEntry);
    }
    // Otherwise use the DataStore if it is valid
    else if (m_storeEvent.isValid()) {
      Database::DBQuery query(name, required);
      if (Database::Instance().getData(*m_storeEvent, query)) {
        dbEntry.updatePayload(query.revision, query.iov, query.filename, query.checksum, query.globaltag, *m_storeEvent);
      }
      if (dbEntry.isIntraRunDependent()) m_intraRunDependencies.insert(&dbEntry);
    }
    return &dbEntry;
  }

getField() [1/2]

void getField ( const double *  pos, double *  field  )

inlinestatic

return the magnetic field at a given position.

Parameters

[in]	pos	position in framework units, needs to be of at least size 3
[out]	field	magnetic field field value at position pos in framework units

Definition at line 91 of file BFieldManager.h.

  {
    ROOT::Math::XYZVector fieldvec = getField(ROOT::Math::XYZVector(pos[0], pos[1], pos[2]));
    field[0] = fieldvec.X();
    field[1] = fieldvec.Y();
    field[2] = fieldvec.Z();
  }

getField() [2/2]

ROOT::Math::XYZVector getField ( const ROOT::Math::XYZVector &  pos ) const

inline

Calculate the magnetic field at a given position.

Parameters

pos	position where the field should be evaluated in framework units.

Returns

magnetic field at pos in framework units.

Warning

The returned field is in basf2 units which is NOT Tesla. If you need the field strength in a fixed unit please divide the returned value by Unit::T or similar.

Definition at line 67 of file MagneticField.h.

  {
    ROOT::Math::XYZVector field;
    for (auto c : m_components) {
      if (c->inside(pos)) {
        // is it an exclusive component? If so return the field
        if (c->isExclusive()) return c->getField(pos);
        // else add it to what we already have
        field += c->getField(pos);
      }
    }
    return field;
  }

getFile()

std::shared_ptr< TFile > getFile	(	std::string	fileName,
		bool	ignoreErrors = false
	)

Get a file with a specific name, if is does not exist it will be created.

If the file cannot be created and opened an error is emitted and you get an empty shared_ptr. If you don't want an error to be emitted you can provide ignoreErrors=true as second argument.

WARNING: When you get this file it is probably not set as current directory so before you use it you have to call file->cd();

Definition at line 33 of file RootFileCreationManager.cc.

  {
    std::shared_ptr<TFile> ptr = m_files[fileName].lock();
    if (!ptr) {
      // make sure stupid gDirectory is not modified ... that means that users
      // have to ptr->cd() but plays nice with other modules which might not
      // set their cd() correctly.
      TDirectory::TContext gDirectoryGuard;
      // Create shared ptr for the file which will correctly close it when the last user disconnects.
      ptr = std::shared_ptr<TFile>(TFile::Open(fileName.c_str(), "RECREATE"), TFile_Deleter);
      // Check if the file is actually open ... otherwise no use in returning it
      if (!ptr || !ptr->IsOpen()) {
        if (!ignoreErrors) B2ERROR("Could not create file " << std::quoted(fileName));
        return nullptr;
      }
      //remember this ...
      m_files[fileName] = ptr;
    }
    return ptr;
  }

getGlobalTags()

std::string getGlobalTags

(

)

Return the global tags used by the database.

If no conditions database is configured return an empty string. If more then one database is configured return all global tags concatenated by ','

Definition at line 154 of file Database.cc.

  {
    return boost::algorithm::join(m_globalTags, ",");
  }

getInstance() [1/2]

Gearbox & getInstance ( )

static

Return reference to the Gearbox instance.

Definition at line 81 of file Gearbox.cc.

  {
    static Gearbox instance;
    return instance;
  }

getInstance() [2/2]

RootFileCreationManager & getInstance ( )

static

Interface for the FileManager.

Definition at line 54 of file RootFileCreationManager.cc.

  {
    static RootFileCreationManager instance;
    return instance;
  }

getList()

std::vector< std::string > getList ( const std::string &  name, const std::vector< std::string > &  fallback = {}, const std::string &  separators = " \t\n\r"  )

static

Get a list of values from an environment variable or the given fallback list if the variable is not set.

By default the value of the environment variable is split by whitespace (" \t\n\r") but a different list of characters can be supplied, for example ":" for path lists or ", " for comma or space separated values

Definition at line 36 of file EnvironmentVariables.cc.

  {
    if (!isSet(name)) return fallback;
    std::string value = get(name);
    std::vector<std::string> items;
    //Treat empty string as empty list
    if (value.empty()) return items;
    boost::split(items, value, boost::is_any_of(separators));
    return items;
  }

getNumOfFilledBuckets()

unsigned getNumOfFilledBuckets

(

)

const

Returns the number of filled buckets.

Returns

the number of filled buckets

Definition at line 39 of file BunchStructure.cc.

  {
    if (m_fillPattern.empty()) return (c_RFBuckets / 2);
 
    return std::count(m_fillPattern.begin(), m_fillPattern.end(), true);
  }

getOrCreateList()

std::vector< std::string > getOrCreateList ( const std::string &  name, const std::string &  fallback, const std::string &  separators = " \t\n\r"  )

static

Get a list of values from an environment variable or the given fallback string if the variable is not set.

By default the value of the environment variable is split by whitespace (" \t\n\r") but a different list of characters can be supplied, for example ":" for path lists or ", " for comma or space separated values

In case the variable is not set this function will convert the fallback string to a list using the same rules as would apply for the envirnoment value itself.

Definition at line 48 of file EnvironmentVariables.cc.

  {
    //almost the same as above but we don't need to check if its set, we just parse the value or fallback into a list
    std::string value = get(name, fallback);
    std::vector<std::string> items;
    //Treat empty string as empty list
    if (value.empty()) return items;
    boost::split(items, value, boost::is_any_of(separators));
    return items;
  }

getParam()

ModuleParam< T > & getParam

(

const std::string &

name

)

const

Returns a reference to a parameter.

The returned parameter has already the correct type.

Throws an exception of type ModuleParameterNotFoundError if a parameter with the given name does not exist. Throws an exception of type ModuleParameterTypeError if the parameter type of does not match to the template parameter.

Parameters

name	The unique name of the parameter.

Returns

A reference to a module parameter having the correct type.

Definition at line 573 of file Module.h.

  {
    return m_moduleParamList.getParameter<T>(name);
  }

getParameter()

ModuleParam< T > & getParameter

(

const std::string &

name

)

const

Returns a reference to a parameter.

The returned parameter has already the correct type.

Throws an exception of type ModuleParameterNotFoundError if a parameter with the given name does not exist. Throws an exception of type ModuleParameterTypeError if the parameter type of does not match to the template parameter.

Parameters

name	The unique name of the parameter.

Returns

A reference to a module parameter having the correct type.

Definition at line 80 of file ModuleParamList.templateDetails.h.

  {
    // Check if a parameter with the given name exists
    std::map<std::string, ModuleParamPtr>::const_iterator mapIter;
    mapIter = m_paramMap.find(name);
 
    if (mapIter != m_paramMap.end()) {
      ModuleParamPtr moduleParam = mapIter->second;
 
      // Check the type of the stored parameter (currently done using the type identifier string)
      if (moduleParam->getTypeInfo() == ModuleParam<T>::TypeInfo()) {
        ModuleParam<T>* explModParam = static_cast<ModuleParam<T>*>(moduleParam.get());
        return *explModParam;
      } else
        throwTypeError(name, moduleParam->getTypeInfo(), ModuleParam<T>::TypeInfo());
    } else
      throwNotFoundError(name);
  }

getParamValuesPython()

void getParamValuesPython	(	const std::string &	name,
		PythonObject &	pyOutput,
		bool	defaultValues
	)		const

Returns a python object containing the value or default value of the given parameter.

Calls according to the parameter type a specialized converter in PyObjConvUtils.h

Parameters

name	The unique name of the parameter.
pyOutput	Reference to the output object containing the parameter value or default values.
defaultValues	If true returns a list of default values otherwise a list of the parameter values.

Definition at line 112 of file ModuleParamList.templateDetails.h.

  {
    try {
      ModuleParamPtr p = getParameterPtr(name);
      p->setValueToPythonObject(pyOutput, defaultValues);
    } catch (std::runtime_error& exc) {
      B2ERROR(exc.what());
    }
  }

getPathValue()

Gearbox::PathValue getPathValue ( const std::string &  path ) const

private

Return the (cached) value of a given path.

Definition at line 247 of file Gearbox.cc.

  {
    PathValue value;
    if (m_xpathContext == nullptr) B2FATAL("Gearbox is not connected");
    //Get from cache if possible
    if (m_parameterCache->retrieve(path, value)) {
      return value;
    }
    //Nothing in cache, query xml
    string query = ensureNode(path);
    B2DEBUG(1000, "Gearbox XPath query: " << query);
    xmlXPathObjectPtr result = xmlXPathEvalExpression((xmlChar*) query.c_str(), m_xpathContext);
    if (result != nullptr && result->type == XPATH_NODESET && !xmlXPathNodeSetIsEmpty(result->nodesetval)) {
      value.numNodes = xmlXPathNodeSetGetLength(result->nodesetval);
      xmlNodePtr node = result->nodesetval->nodeTab[0];
      //Example: <foo><bar/></foo>
      // - bar has no children, so node->children is 0
      // - foo has not text children, so node->children->content should be 0
      //   but xmlXPathOrderDocElems assigns them an index<0 to speed up XPath
      //   so we have to cast to a long integer and check if it is positive
      if (node->children && (long)node->children->content > 0) {
        xmlChar* valueString = xmlNodeListGetString(m_xmlDocument, node->children, 1);
        value.value = (char*)valueString;
        xmlFree(valueString);
      }
      //See if we have a unit attribute and add it
      xmlAttrPtr attribute = node->properties;
      while (attribute) {
        B2DEBUG(1001, "Checking attribute " << attribute->name);
        if (!strcmp((char*)attribute->name, "unit")) {
          B2DEBUG(1001, "found Unit " << attribute->children->content);
          value.unit = (char*)attribute->children->content;
          break;
        }
        attribute = attribute->next;
      }
      //Remove leading and trailing whitespaces
      boost::trim(value.value);
      boost::trim(value.unit);
    }
    //Add to cache, empty or not: results won't change
    m_parameterCache->insert(path, value);
    B2DEBUG(1000, "Gearbox XPath result: " << value.numNodes << ", " << value.value << ", " << value.unit);
 
    xmlXPathFreeObject(result);
    return value;
  }

getTObject()

const TObject * getTObject ( const std::string &  path ) const

overridevirtual

Get the parameter path as a TObject.

Exceptions

gearbox::PathEmptyError	if path is empty or does not exist
gearbox::TObjectConversionError	if the value could not be deserialized

Parameters

path	Path of the parameter to get

Returns

pointer to object, owned and managed by gearbox. Object will be deleted once it is no longer valid (e.g. after the current run if it belongs to this run)

Implements Interface.

Definition at line 295 of file Gearbox.cc.

  {
    //do we already have an object for this path?
    auto it = m_ownedObjects.find(path);
    if (it != m_ownedObjects.end())
      return it->second;
 
    const string& value = getString(path);
    //assume base64-encoded raw data.
    TObject* object = Stream::deserializeEncodedRawData(value);
    if (!object)
      throw gearbox::TObjectConversionError() << path;
 
    m_ownedObjects[path] = object;
 
    return object;
  }

GetTVector3()

TVector3 GetTVector3

returns a TVector3 containing the same coordinates

Definition at line 725 of file B2Vector3.h.

  {
    return
      TVector3(
        static_cast<Double_t>(X()),
        static_cast<Double_t>(Y()),
        static_cast<Double_t>(Z())
      );
  }

getValue()

T & getValue

Returns the value of the parameter.

Returns

The value of the parameter.

Definition at line 50 of file ModuleParam.templateDetails.h.

  {
    return m_paramVariable;
  }

GetXYZ() [1/2]

void GetXYZ

(

ROOT::Math::XYZVector *

xyzVec

)

const

directly copies coordinates to a XYZVector

Definition at line 715 of file B2Vector3.h.

  {
    xyzVec->SetXYZ(static_cast<Double_t>(X()),
                   static_cast<Double_t>(Y()),
                   static_cast<Double_t>(Z()));
  }

GetXYZ() [2/2]

void GetXYZ

(

TVector3 *

tVec

)

const

directly copies coordinates to a TVector3

Definition at line 706 of file B2Vector3.h.

  {
    tVec->SetXYZ(static_cast<Double_t>(X()),
                 static_cast<Double_t>(Y()),
                 static_cast<Double_t>(Z()));
  }

GetXYZVector()

ROOT::Math::XYZVector GetXYZVector

returns a XYZVector containing the same coordinates

returns a ROOT::Math::XYZVector containing the same coordinates

Definition at line 738 of file B2Vector3.h.

  {
    return
      ROOT::Math::XYZVector(
        static_cast<Double_t>(X()),
        static_cast<Double_t>(Y()),
        static_cast<Double_t>(Z())
      );
  }

initialize()

void initialize

(

const EDatabaseState

target = c_Ready

)

Initialize the database connection settings on first use.

Definition at line 197 of file Database.cc.

  {
    if (m_configState >= target) return;
    auto conf = Conditions::Configuration::getInstance();
 
    if (m_configState == c_PreInit) {
      // first step: freeze the configuration object and determine the list of globaltags
      // this calculates if tag replay is possible and will create an error otherwise but
      // it will not do anything else than setting the final list of globaltags
      conf.setInitialized(true);
      m_globalTags = conf.getFinalListOfTags();
      // trim the globaltag names for removing leading/trailing whitespaces, since they
      // are a potential source of FATAL errors
      std::transform(m_globalTags.begin(), m_globalTags.end(), m_globalTags.begin(),
      [](const auto & tag) {
        return boost::algorithm::trim_copy(tag);
      });
      // and remove duplicates, there's no need to look in the same gt multiple times
      std::set<std::string> seen;
      m_globalTags.erase(std::remove_if(m_globalTags.begin(), m_globalTags.end(),
      [&seen](const auto & tag) {
        return not seen.insert(tag).second;
      }), m_globalTags.end());
      // and also obtain usable tag states and metadata providers
      m_usableTagStates = conf.getUsableTagStates();
      m_metadataConfigurations = conf.getMetadataProviders();
      // reverse because we want to pop out elements when used
      std::reverse(m_metadataConfigurations.begin(), m_metadataConfigurations.end());
      m_currentProvider = "";
      m_configState = c_InitGlobaltagList;
    }
    // do we want to stop early?
    if (m_configState >= target) return;
    if (m_configState == c_InitGlobaltagList) {
      // setup the first working provider;
      if (m_metadataConfigurations.empty()) {
        m_metadataProvider = std::make_unique<Conditions::NullMetadataProvider>();
      } else {
        nextMetadataProvider();
      }
      // we will actually use the globaltags so print them now
      if (!m_globalTags.empty()) {
        // Globaltags are useable so print out the final list we're gonna use
        if (m_globalTags.size() == 1) {
          B2INFO("Conditions data: configured globaltag is " << m_globalTags[0]);
        } else {
          B2INFO("Conditions data: configured globaltags (highest priority first) are " << boost::algorithm::join(m_globalTags, ", "));
        }
      }
      // Configure payload location/download
      m_payloadProvider = std::make_unique<Conditions::PayloadProvider>(
                            conf.getPayloadLocations(),
                            conf.getDownloadCacheDirectory(),
                            conf.getDownloadLockTimeout()
                          );
      // Also we need to be able to create payloads ...
      m_payloadCreation = std::make_unique<Conditions::TestingPayloadStorage>(conf.getNewPayloadLocation());
      // And maaaybe we want to use testing payloads
      m_testingPayloads.clear();
      for (const auto& path : conf.getTestingPayloadLocations()) {
        B2INFO("Conditions data: configured to use testing payloads" << LogVar("location", path));
        m_testingPayloads.emplace_back(path);
      }
      // If so, warn again ... because
      if (not m_testingPayloads.empty()) {
        B2WARNING(R"(Conditions data: configured to look for temporary testing payloads from one or more local folders.
 
    This will lead to non-reproducible results and is strictly only for testing purposes.
    It is NOT ALLOWED for official productions or data analysis and any results obtained like this WILL NOT BE PUBLISHED.
  )");
      }
      m_configState = c_Ready;
    }
  }

injectArithmeticOperatorToStream()

void injectArithmeticOperatorToStream	(	std::ostream &	stream,
		const ArithmeticOperation &	aoperation
	)

Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the ComparisonOperator given.

For decompiling/printing we want the corresponding character of the operator e.g " + " for ArithmeticOperator::PLUS print() redirects to std::cout, decompile() should redirect to a std::stringstream Both streams subclass std::ostream. This allows the use of these functions in both cases.

Definition at line 57 of file AbstractNodes.cc.

  {
    switch (aoperation) {
      case ArithmeticOperation::PLUS:
        stream << " + ";
        break;
      case ArithmeticOperation::MINUS:
        stream << " - ";
        break;
      case ArithmeticOperation::PRODUCT:
        stream << " * ";
        break;
      case ArithmeticOperation::DIVISION:
        stream << " / ";
        break;
      case ArithmeticOperation::POWER:
        stream << " ** ";
        break;
      default:
        throw std::runtime_error("Invalid ArithmeticOperator provided to injectArithmeticOperatorToStream.");
    }
  }

injectBooleanOperatorToStream()

void injectBooleanOperatorToStream	(	std::ostream &	stream,
		const BooleanOperator &	boperator
	)

Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the BooleanOperator given.

For decompiling/printing we want the corresponding character of the operator e.g " and " for BooleanOperator::AND print() redirects to std::cout, decompile() should redirect to a std::stringstream Both streams subclass std::ostream. This allows the use of these functions in both cases.

Definition at line 17 of file AbstractNodes.cc.

  {
    switch (boperator) {
      case BooleanOperator::AND:
        stream << " and ";
        break;
      case BooleanOperator::OR:
        stream << " or ";
        break;
      default:
        throw std::runtime_error("Invalid BooleanOperator provided to injectBooleanOperatorToStream.");
    }
  }

injectComparisonOperatorToStream()

void injectComparisonOperatorToStream	(	std::ostream &	stream,
		const ComparisonOperator &	coperator
	)

Helper functions for AbstractBooleanNode and AbstractExpressionNode print() and decompile() members Shifts the correct characters into the ostream, depending on the ComparisonOperator given.

For decompiling/printing we want the corresponding character of the operator e.g " == " for ComparisonOperator::EQUALEQUAL print() redirects to std::cout, decompile() should redirect to a std::stringstream Both streams subclass std::ostream. This allows the use of these functions in both cases.

Definition at line 31 of file AbstractNodes.cc.

  {
    switch (coperator) {
      case ComparisonOperator::EQUALEQUAL:
        stream << " == ";
        break;
      case ComparisonOperator::GREATEREQUAL:
        stream << " >= ";
        break;
      case ComparisonOperator::LESSEQUAL:
        stream << " <= ";
        break;
      case ComparisonOperator::GREATER:
        stream << " > ";
        break;
      case ComparisonOperator::LESS:
        stream << " < ";
        break;
      case ComparisonOperator::NOTEQUAL:
        stream << " != ";
        break;
      default:
        throw std::runtime_error("Invalid ComparisonOperator provided to injectComparisonOperatorToStream.");
    }
  }

Instance() [1/2]

Database & Instance ( )

static

Instance of a singleton Database.

Definition at line 42 of file Database.cc.

  {
    static Database instance;
    return instance;
  }

Instance() [2/2]

DBStore & Instance ( )

static

Instance of a singleton DBStore.

This method is used to access the DBStore directly. It is used internally in the DBStore accessor classes.

Definition at line 28 of file DBStore.cc.

  {
    static DBStore instance;
    return instance;
  }

isLevelEnabled()

bool isLevelEnabled ( LogConfig::ELogLevel  level, int  debugLevel = 0, const char *  package = nullptr  ) const

inline

Returns true if the given log level is allowed by the log system (i.e.

>= the system level).

Parameters

level	The log level which should be compared with the log level of the log system
debugLevel	The level for debug messages. Only used for the debug level.
package	Current package (e.g. framework). NULL for package-independent config.

Definition at line 277 of file LogSystem.h.

  {
    const LogConfig& config = getCurrentLogConfig(package);
    const LogConfig::ELogLevel logLevelLimit = config.getLogLevel();
    const int debugLevelLimit = config.getDebugLevel();
    return logLevelLimit <= level && (level != LogConfig::c_Debug || debugLevelLimit >= debugLevel);
  }

isSet()

bool isSet ( const std::string &  name )

static

Check if a value is set in the database.

Definition at line 19 of file EnvironmentVariables.cc.

  {
    char* envValue = std::getenv(name.c_str());
    return envValue != nullptr;
  }

loadPayload()

void loadPayload ( const EventMetaData &  event )

private

Actual load the payload from file after all info is set.

Definition at line 115 of file DBStoreEntry.cc.

  {
    if (m_filename == "") {
      // invalid payload nothing else to do
      return;
    }
    if (m_payloadType != c_RawFile) {
      // Open the payload file but make sure to go back to the previous
      // directory to not disturb other code.
      TDirectory* oldDirectory = gDirectory;
      m_tfile = TFile::Open(m_filename.c_str());
      gDirectory = oldDirectory;
      // Check if the file is open
      if (!m_tfile || !m_tfile->IsOpen()) {
        B2ERROR("Cannot open " << std::quoted(m_filename) << " for reading");
        deleteAndSetNullptr(m_tfile);
        return;
      }
      m_tfile->SetBit(kCanDelete, false);
      // File is open and we are a normal object entry?
      if (m_payloadType == c_Object) {
        // get the object
        m_object = m_tfile->Get(m_name.c_str());
        if (!m_object) {
          B2ERROR("Failed to get " << std::quoted(m_name) << " from payload file "
                  << std::quoted(m_filename) << ".");
          return;
        }
        m_object->SetBit(kCanDelete, false);
        // check that it is compatible with what it should be
        checkType(m_object);
        // resolve run dependency
        if (m_object->InheritsFrom(IntraRunDependency::Class())) {
          m_intraRunDependency = static_cast<IntraRunDependency*>(m_object);
          m_object = m_intraRunDependency->getObject(event);
          B2DEBUG(34, "Found intra run dependency for " << m_name << ": " << m_intraRunDependency << ", " << m_object);
        }
        // TODO: depending on the object type we could now close the file. I
        // guess we cannot close the file in case of TTree but we have to find
        // out exactly which object types are safe before doing that?
      }
    }
  }

log()

void log	(	const std::string &	key,
		const AClass &	value
	)

Store a value under a certain key. Different types of values can be stored, namely long, double or string. Mixtures are not allowed for a given key.

Definition at line 96 of file ZMQLogger.h.

  {
    m_monitoring[key] = value;
  }

LogConnectionJSON()

LogConnectionJSON ( bool  complete = false )

explicit

The constructor.

Parameters

complete

if true ignore the LogInfo settings and output all parts of the message (like file, line, etc.)

Definition at line 19 of file LogConnectionJSON.cc.

                                                   : m_console{STDOUT_FILENO, false}, m_complete{complete}
  {
  }

ModuleParam()

ModuleParam ( T &  paramVariable, const std::string &  description = "", bool  force = false  )

explicit

Constructor.

A parameter consists of a reference pointing to a member variable in the module which stores and allows fast access to the parameter value. In addition the type of the parameter is saved and optionally a description can be given.

Parameters

paramVariable	Reference to the variable which stores the parameter value.
description	The optional description of the parameter.
force	If true the parameter has to be set by the user in the steering file.

Definition at line 28 of file ModuleParam.templateDetails.h.

                                                                                       :
    ModuleParamBase(TypeInfo(), description, force), m_paramVariable(paramVariable) {};

name()

std::string name

static

Returns the name of the B2Vector.

Returns a less readable (but more compatible) name of the B2Vector3.

Definition at line 767 of file B2Vector3.h.

  {
    return std::string("B2Vector3<") + typeid(DataType).name() + std::string(">");
  }

nextMetadataProvider()

void nextMetadataProvider ( )

protected

Enable the next metadataprovider in the list.

Definition at line 159 of file Database.cc.

  {
    if (m_metadataConfigurations.empty()) {
      B2FATAL("Conditions data: No more metadata providers available");
    }
    m_currentProvider = m_metadataConfigurations.back();
    m_metadataConfigurations.pop_back();
    bool remote{false};
    if (auto pos = m_currentProvider.find("://"); pos != std::string::npos) {
      // found a protocol: if file remove, otherwise keep as is and set as remote ...
      auto protocol = m_currentProvider.substr(0, pos);
      boost::algorithm::to_lower(protocol);
      if (protocol == "file") {
        m_currentProvider = m_currentProvider.substr(pos + 3);
      } else if (protocol == "http" or protocol == "https") {
        remote = true;
      } else {
        B2FATAL("Conditions data: Unknown metadata protocol, only supported protocols for payload metadata are file, http, https"
                << LogVar("protocol", protocol));
      }
    }
    try {
      if (remote) {
        m_metadataProvider = std::make_unique<Conditions::CentralMetadataProvider>(m_currentProvider, m_usableTagStates);
      } else {
        m_metadataProvider = std::make_unique<Conditions::LocalMetadataProvider>(m_currentProvider, m_usableTagStates);
      }
    } catch (std::exception& e) {
      B2WARNING("Conditions data: Metadata provider not usable, trying next one ..."
                << LogVar("provider", m_currentProvider) << LogVar("error", e.what()));
      return nextMetadataProvider();
    }
    // and check the tags are useable
    if (!m_metadataProvider->setTags(m_globalTags)) {
      B2FATAL("Conditions data: Problems with globaltag configuration, cannot continue");
    }
  }

notifyAccessors()

void notifyAccessors ( bool  onDestruction = false )

private

Notify all the registered accessors.

Definition at line 190 of file DBStoreEntry.cc.

  {
    // Just notify all registered accessors ...
    for (DBAccessorBase* object : m_accessors) object->storeEntryChanged(onDestruction);
    // on destruction we also should clear the list ... we will not call them again
    if (onDestruction) m_accessors.clear();
  }

open()

void open	(	const std::string &	name = "Belle2.xml",
		size_t	cacheSize = c_DefaultCacheSize
	)

Open connection to backend and parse tree.

Parameters

name	Name of the tree to parse
cacheSize	maximum cache size in entries

Definition at line 133 of file Gearbox.cc.

  {
    //Check if we have an open connection and close first if so
    if (m_xmlDocument) close();
    //Check if we have at least one backend
    if (m_handlers.empty())
      B2FATAL("No backends defined, please use Gearbox::setBackends() first to specify how to access XML files.");
 
    // register input callbacks for opening the files
    xmlRegisterInputCallbacks(gearbox::matchXmlUri, gearbox::openXmlUri,
                              gearbox::readXmlData, gearbox::closeXmlContext);
 
    //Open document
    m_xmlDocument = xmlParseFile(name.c_str());
    //libxml >= 2.7.0 introduced some limits on node size etc. which breaks reading VXDTF files
    xmlXIncludeProcessFlags(m_xmlDocument, XML_PARSE_HUGE);
 
    // reset input callbacks
    xmlPopInputCallbacks();
 
    if (!m_xmlDocument) B2FATAL("Could not connect gearbox to " << name);
    m_xpathContext = xmlXPathNewContext(m_xmlDocument);
    if (!m_xpathContext) B2FATAL("Could not create XPath context");
 
    //Apply overrides
    for (const auto& poverride : m_overrides) {
      overridePathValue(poverride);
    }
 
    //Speeds up XPath computation on static documents.
    xmlXPathOrderDocElems(m_xmlDocument);
 
    //Set cachesize
    m_parameterCache->setMaxSize(cacheSize);
  }

openXmlUri()

gearbox::InputContext * openXmlUri ( const std::string &  uri ) const

private

Function to be called when libxml requests a new input uri to be opened.

Definition at line 87 of file Gearbox.cc.

  {
    //Check input handlers one by one
    for (gearbox::InputHandler* handler : m_handlers) {
      //try to create context for uri, return if success
      gearbox::InputContext* context = handler->open(uri);
      if (context) return context;
    }
    B2ERROR("Could not find data for uri '" << uri << "'");
    return nullptr;
  }

operator!=()

Bool_t operator!=	(	const TVector3 &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction Comparison for equality with a TVector3

Definition at line 530 of file B2Vector3.h.

  {
    return !(a == b);
  }

operator*()

B2Vector3< DataType > operator*	(	DataType	a,
		const B2Vector3< DataType > &	p
	)

non-memberfunction Scaling of 3-vectors with a real number

Definition at line 537 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a * p.X(), a * p.Y(), a * p.Z());
  }

operator*=()

B2Vector3< DataType > & operator*=

(

DataType

a

)

scaling with real numbers

multiplication with a real number

Definition at line 652 of file B2Vector3.h.

  {
    m_coordinates[0] *= a;
    m_coordinates[1] *= a;
    m_coordinates[2] *= a;
    return *this;
  }

operator+() [1/4]

B2Vector3< DataType > operator+	(	const B2Vector3< DataType > &	a,
		const ROOT::Math::XYZVector &	b
	)

non-memberfunction for adding a B2Vector3 to a XYZVector

Definition at line 586 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
  }

operator+() [2/4]

B2Vector3< DataType > operator+	(	const B2Vector3< DataType > &	a,
		const TVector3 &	b
	)

non-memberfunction for adding a B2Vector3 to a TVector3

Definition at line 558 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
  }

operator+() [3/4]

B2Vector3< DataType > operator+	(	const ROOT::Math::XYZVector &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction for adding a XYZVector to a B2Vector3

Definition at line 572 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
  }

operator+() [4/4]

B2Vector3< DataType > operator+	(	const TVector3 &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction for adding a TVector3 to a B2Vector3

Definition at line 544 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
  }

operator+=()

B2Vector3< DataType > & operator+=

(

const B2Vector3< DataType > &

b

)

addition

Definition at line 631 of file B2Vector3.h.

  {
    m_coordinates[0] += b.X();
    m_coordinates[1] += b.Y();
    m_coordinates[2] += b.Z();
    return *this;
  }

operator-() [1/4]

B2Vector3< DataType > operator-	(	const B2Vector3< DataType > &	a,
		const ROOT::Math::XYZVector &	b
	)

non-memberfunction for substracting a B2Vector3 from a XYZVector

Definition at line 593 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
  }

operator-() [2/4]

B2Vector3< DataType > operator-	(	const B2Vector3< DataType > &	a,
		const TVector3 &	b
	)

non-memberfunction for substracting a B2Vector3 from a TVector3

Definition at line 565 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
  }

operator-() [3/4]

B2Vector3< DataType > operator-	(	const ROOT::Math::XYZVector &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction for substracting a XYZVector from a B2Vector3

Definition at line 579 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
  }

operator-() [4/4]

B2Vector3< DataType > operator-	(	const TVector3 &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction for substracting a TVector3 from a B2Vector3

Definition at line 551 of file B2Vector3.h.

  {
    return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
  }

operator-=()

B2Vector3< DataType > & operator-=

(

const B2Vector3< DataType > &

b

)

subtraction

Definition at line 642 of file B2Vector3.h.

  {
    m_coordinates[0] -= b.X();
    m_coordinates[1] -= b.Y();
    m_coordinates[2] -= b.Z();
    return *this;
  }

operator<<()

std::ostream & operator<<	(	std::ostream &	output,
		const IntervalOfValidity &	iov
	)

Parameters

output	The output stream.
iov	The IntervalOfValidity object.

Definition at line 194 of file IntervalOfValidity.cc.

  {
    output << iov.m_experimentLow << "," << iov.m_runLow << "," << iov.m_experimentHigh << "," << iov.m_runHigh;
 
    return output;
  }

operator=() [1/3]

B2Vector3< DataType > & operator=

(

const B2Vector3< DataType > &

b

)

Assignment via B2Vector3.

Definition at line 601 of file B2Vector3.h.

  {
    m_coordinates[0] = b.X();
    m_coordinates[1] = b.Y();
    m_coordinates[2] = b.Z();
    return *this;
  }

operator=() [2/3]

B2Vector3< DataType > & operator=

(

const ROOT::Math::XYZVector &

b

)

Assignment via XYZVector.

Definition at line 621 of file B2Vector3.h.

  {
    m_coordinates[0] = b.X();
    m_coordinates[1] = b.Y();
    m_coordinates[2] = b.Z();
    return *this;
  }

operator=() [3/3]

B2Vector3< DataType > & operator=

(

const TVector3 &

b

)

Assignment via TVector3.

Definition at line 611 of file B2Vector3.h.

  {
    m_coordinates[0] = b.X();
    m_coordinates[1] = b.Y();
    m_coordinates[2] = b.Z();
    return *this;
  }

operator==()

Bool_t operator==	(	const TVector3 &	a,
		const B2Vector3< DataType > &	b
	)

non-memberfunction Comparison for equality with a TVector3

Definition at line 523 of file B2Vector3.h.

  {
    return (a.X() == b.X() && a.Y() == b.Y() && a.Z() == b.Z());
  }

operator>>()

std::istream & operator>>	(	std::istream &	input,
		IntervalOfValidity &	iov
	)

Parameters

input	The input stream.
iov	The InervalOfValidity object.

Definition at line 150 of file IntervalOfValidity.cc.

  {
    iov = IntervalOfValidity();
    if (!input.good()) {
      throw std::runtime_error("cannot read from stream");
    }
 
    std::string str[4];
    int index = 0;
    while (input.good()) {
      auto c = input.peek();
      if (c == EOF) break;
      if (((c == ' ') || (c == '\n') || (c == '\t'))) {
        //ignore whitespace in the beginning
        if (index == 0 && str[0].empty()) {
          input.get();
          continue;
        }
        //and stop parsing otherwise
        break;
      }
      if (c == ',') {
        index++;
        if (index == 4) break;
      } else {
        str[index] += c;
      }
      input.get();
    }
    if (index != 3) {
      throw std::invalid_argument("IoV needs to be four values (firstExp,firstRun,finalExp,finalRun)");
    }
    try {
      iov.m_experimentLow = stoi(str[0]);
      iov.m_runLow = stoi(str[1]);
      iov.m_experimentHigh = stoi(str[2]);
      iov.m_runHigh = stoi(str[3]);
    } catch (std::invalid_argument& e) {
      throw std::invalid_argument("experiment and run numbers must be integers");
    }
 
    return input;
  }

operatorToChar()

char operatorToChar ( EOperator  op )

staticnoexcept

Convert operator code to character.

Definition at line 19 of file FormulaParser.cc.

  {
    switch (op) {
      case EOperator::c_noop: return ' ';
      case EOperator::c_plus: return '+';
      case EOperator::c_minus: return '-';
      case EOperator::c_multiply: return '*';
      case EOperator::c_divide: return '/';
      case EOperator::c_power: return '^';
      case EOperator::c_roundBracketOpen: return '(';
      case EOperator::c_roundBracketClose: return ')';
      case EOperator::c_squareBracketOpen: return '[';
      case EOperator::c_squareBracketClose: return ']';
    }
    return 0;
  }

overrideObject()

void overrideObject ( TObject *  obj, const IntervalOfValidity &  iov  )

private

Set an override object in case we want to use a different object then actually provided by the database.

Parameters

obj	Instance to use as payload, this entry will take over ownership.
iov	interval how long this object should be valid

Definition at line 159 of file DBStoreEntry.cc.

  {
    if (!checkType(obj)) return;
 
    m_globaltag = "";
    m_revision = 0;
    m_filename = "";
    m_iov = iov;
    m_keep = true;
    // object unchanged, nothing to do
    if (m_object == obj) {
      B2DEBUG(34, "DBEntry " << std::quoted(m_name) << " override unchanged");
      return;
    }
    // We need to clean up the object but if someone hands us the same object
    // we already own this would lead to invalid access later so make sure we
    // only delete it when appropriate
    if (!isIntraRunDependent()) {
      delete m_object;
    }
    // clean up the other memory
    deleteAndSetNullptr(m_intraRunDependency, m_tfile);
    // and set, ready go
    m_object = obj;
    B2DEBUG(34, "DBEntry " << this << " " << std::quoted(m_name) << " override created: " << std::endl
            << "    object = " << m_object << std::endl
            << "    validity = " << m_iov << std::endl
            << "  -> notiying accessors");
    notifyAccessors();
  }

overridePathValue()

void overridePathValue ( const PathOverride &  poverride )

private

Change the value of a given path expression.

Definition at line 184 of file Gearbox.cc.

  {
    if (m_xpathContext == nullptr) B2FATAL("Gearbox is not connected");
    //Make sure it ends with a slash
    string query = ensureNode(poverride.path);
    //Ok, lets search for the path
    B2INFO("Override '" << poverride.path << "' with '" << poverride.value
           << "' (unit: '" << poverride.unit << "')");
    xmlXPathObjectPtr result = xmlXPathEvalExpression((xmlChar*) query.c_str(), m_xpathContext);
    if (result != nullptr && result->type == XPATH_NODESET && !xmlXPathNodeSetIsEmpty(result->nodesetval)) {
      //Found it, so let's replace the content
      int numNodes = xmlXPathNodeSetGetLength(result->nodesetval);
      if (!poverride.multiple && numNodes > 1) {
        B2ERROR("Cannot override '" << poverride.path << "': more than one node found");
        return;
      } else {
        B2DEBUG(200, "Found " << numNodes << " nodes, overriding them all");
      }
      for (int i = numNodes - 1; i >= 0; --i) {
        xmlNodePtr node = result->nodesetval->nodeTab[i];
        //Check if children are only TEXT nodes
        bool textOnly(true);
        for (xmlNodePtr child = node->children; child; child = child->next) {
          textOnly &= child->type == XML_TEXT_NODE;
          if (!textOnly) break;
        }
        if (!textOnly) {
          B2ERROR("Cannot override '" << poverride.path << "': not just text content");
          continue;
        }
        xmlNodeSetContent(node, BAD_CAST poverride.value.c_str());
 
        //Is the path an element? if so replace the unit, otherwise warn
        if (node->type != XML_ELEMENT_NODE) {
          if (!poverride.unit.empty())
            B2WARNING("Cannot set unit '" << poverride.unit << "' on '"
                      << poverride.path << "': not an element");
        } else {
          xmlSetProp(node, BAD_CAST "unit", BAD_CAST poverride.unit.c_str());
        }
        //From libxml example xpath2.c:
        //All the elements returned by an XPath query are pointers to
        //elements from the tree *except* namespace nodes where the XPath
        //semantic is different from the implementation in libxml2 tree.
        //As a result when a returned node set is freed when
        //xmlXPathFreeObject() is called, that routine must check the
        //element type. But node from the returned set may have been removed
        //by xmlNodeSetContent() resulting in access to freed data.
        //There is 2 ways around it:
        //  - make a copy of the pointers to the nodes from the result set
        //    then call xmlXPathFreeObject() and then modify the nodes
        //or
        //  - remove the reference to the modified nodes from the node set
        //    as they are processed, if they are not namespace nodes.
        if (node->type != XML_NAMESPACE_DECL)
          result->nodesetval->nodeTab[i] = nullptr;
      }
    } else {
      B2ERROR("Cannot override '" << poverride.path << "': not found");
    }
    xmlXPathFreeObject(result);
  }

performUpdate()

void performUpdate ( const EventMetaData &  event )

private

The main code that does an update, factored out so it can be used by both update and update(event).

Definition at line 108 of file DBStore.cc.

  {
    // For the time being we will request updates for all payloads just to make
    // sure we never miss an update. This is done once per run so it should be
    // fine from performance.
    // TODO: once we are sure somehow to not have duplicate iovs we can relax
    // this requirement.
    std::vector<Database::DBQuery> entries;
    entries.reserve(m_dbEntries.size());
    for (auto& entry : m_dbEntries) {
      bool expired = !entry.second.getIoV().contains(event);
      if (expired) {
        B2DEBUG(34, "DBEntry " << entry.first << " out of date, will need update");
      }
      if (!entry.second.keepUntilExpired() || expired)
        entries.emplace_back(entry.first, entry.second.isRequired());
      // remove from intra run handling, will be added again after update if needed.
      m_intraRunDependencies.erase(&entry.second);
    }
 
    // nothing to update
    if (entries.empty()) return;
 
    // Request new objects and IoVs from database
    Database::Instance().getData(event, entries);
 
    // Update DBStore entries
    for (auto& query : entries) {
      auto& dbEntry = m_dbEntries.find(query.name)->second;
      dbEntry.updatePayload(query.revision, query.iov, query.filename, query.checksum, query.globaltag, event);
      if (dbEntry.isIntraRunDependent()) m_intraRunDependencies.insert(&dbEntry);
    }
  }

performUpdateEvent()

void performUpdateEvent ( const EventMetaData &  event )

private

The main code that does an updateEvent.

Factored out so it can be used by both updateEvent and updateEvent(eventNumber).

Definition at line 169 of file DBStore.cc.

  {
    // loop over intra-run dependent conditions and update the objects if needed
    for (auto& dbEntry : m_intraRunDependencies) {
      dbEntry->updateObject(event);
    }
  }

poll()

int poll	(	unsigned int	timeout,
		AMulticastAnswer	multicastAnswer,
		ASocketAnswer	socketAnswer
	)		const

Poll both the multicast and the data socket until, either:

• the timeout is raised. The method will return with 0.
• a message came to the multicast socket. Then, the multicastAnswer will be called with the socket as an argument. If this method returns true, the polling will go on like before. If it returns false, the polling will be stopped. The return value of this function is 1.
• a message came to the data socket. See above.

A note on the order: if there are messages on both the data socket and the multicast socket, first all messages to the multicast socket will be answered and then all messages to the data socket.

Definition at line 113 of file ZMQClient.h.

  {
    B2ASSERT("Can only run this on started clients", m_subSocket and m_socket);
    bool repeat = true;
    int pollResult;
    do {
      pollResult = pollSocketVector(m_pollSocketPtrList, timeout);
      if (pollResult & 1) {
        // The multicast is the first entry.
        // Get all entries if possible, but do not block anymore.
        std::vector<zmq::socket_t*> vector = {m_subSocket.get()};
        while (pollSocketVector(vector, 0) and repeat) {
          repeat = multicastAnswer(m_subSocket);
        }
      }
 
      if (pollResult & 2) {
        // Get all entries if possible, but do not block anymore.
        std::vector<zmq::socket_t*> vector = {m_socket.get()};
        while (pollSocketVector(vector, 0) and repeat) {
          repeat = socketAnswer(m_socket);
        }
      }
    } while (repeat and pollResult);
 
    return pollResult;
  }

pollMulticast()

int pollMulticast	(	unsigned int	timeout,
		AMulticastAnswer	multicastAnswer
	)		const

Poll method to only the multicast socket.

Basically the same as the poll function to both sockets, except: If the answer function returns false, the polling will stop as above, BUT: it will first answer all messages that are already in the socket!

Definition at line 162 of file ZMQClient.h.

  {
    B2ASSERT("Can only run this on started clients", m_subSocket);
    std::vector<zmq::socket_t*> vector = {m_subSocket.get()};
 
    bool repeat = true;
    int pollResult;
    do {
      pollResult = pollSocketVector(vector, timeout);
      if (pollResult) {
        while (pollSocketVector(vector, 0)) {
          repeat = multicastAnswer(m_subSocket);
        }
      }
    } while (repeat and pollResult);
 
    return pollResult;
  }

pollSocket()

int pollSocket	(	unsigned int	timeout,
		ASocketAnswer	socketAnswer
	)		const

Poll method to only the data socket.

Basically the same as the poll function to both sockets, except: If the answer function returns false, the polling will stop as above, BUT: it will first answer all messages that are already in the socket!

Definition at line 142 of file ZMQClient.h.

  {
    B2ASSERT("Can only run this on started clients", m_socket);
    std::vector<zmq::socket_t*> vector = {m_socket.get()};
 
    bool repeat = true;
    int pollResult;
    do {
      pollResult = pollSocketVector(vector, timeout);
      if (pollResult) {
        while (pollSocketVector(vector, 0)) {
          repeat = socketAnswer(m_socket);
        }
      }
    } while (repeat and pollResult);
 
    return pollResult;
  }

processString()

void processString ( const std::string &  formula )

protected

Process the given formula and store the final state.

Definition at line 225 of file FormulaParser.cc.

  {
    // initialize buffer
    m_buffer = std::istringstream(formula);
    // clear stacks
    std::stack<EOperator>().swap(m_operatorStack);
    // and an empty identifier name
    m_currentVariableName.clear();
    m_lastTokenWasOperator = true;
    // reset some other variable state
    flushCurrentVariable();
    // and if the variable has arguments remember the nesting level of the ()
    int nestlevel{0};
    // Now loop over the whole formula character by character
    for (char next; m_buffer.get(next);) {
      // If nestlevel>0 we are in a variable(...) parameters area so ignore
      // everything but keep track of how many open/closing brackets we saw
      // until we are back to nestlevel=0
      if (nestlevel > 0) {
        m_currentVariableName += next;
        if (next == '(') ++nestlevel;
        if (next == ')') --nestlevel;
        // finished variable arguments so variable is definitely done
        if (nestlevel == 0) flushCurrentVariable();
        // done with this character
        continue;
      }
 
      // check for opening parenthesis: could be variable arguments or operation binding
      if (next == '(' and not m_currentVariableName.empty()) {
        m_currentVariableName += next;
        ++nestlevel;
        // definitely not a number anymore
        m_currentVariableNameNumberStatus = ENumberStatus::c_Invalid;
        // done with this character
        continue;
      }
 
      // check for operator
      auto opcode = checkForOperator(next);
      if (opcode != EOperator::c_noop) {
        // found operator, flush variable, add operator
        flushCurrentVariable();
        addOperator(opcode);
        // done with this character
        continue;
      }
 
      // check for whitespace
      if (next == ' ' or next == '\n' or next == '\t' or next == '\r') {
        // variable is finished, just flush here.
        flushCurrentVariable();
        // otherwise nothing to do with whitespace ...
        continue;
      }
 
      // anything else is a identifier, most likely a variable name or a
      // float literal now lets build up the variable name, first lets check
      // if the variable name will still be a valid number
      m_currentVariableNameNumberStatus = checkNumber(m_currentVariableNameNumberStatus, next);
      // then just add it to the state
      m_currentVariableName += next;
    }
    if (nestlevel > 0) throw std::runtime_error("unterminated variable arguments");
    // done with parsing, lets make sure everything is flushed
    flushCurrentVariable();
    flushPendingOperators();
  }

raiseError()

void raiseError ( const std::runtime_error &  e )

protected

Format the given runtime_error with context information and rethrow a new one.

Definition at line 294 of file FormulaParser.cc.

  {
    // So lets some fun printing the error message :D
    std::ostringstream message;
    // check where we stopped parsing
    auto pos = m_buffer.tellg();
    // -1 -> after the end
    if (pos == -1) pos = m_buffer.str().size() + 1;
    // basic boring message + reason
    message << "Error parsing formula at character " << pos << ": " << e.what() << std::endl;
    // now lets go through the formula again, line by line. YES, multi line formula are a thing
    std::istringstream errbuff(m_buffer.str());
    long lastpos = 0;
    bool arrowShown{false};
    for (std::string line; std::getline(errbuff, line);) {
      // print each line
      message << "   " << line << std::endl;
      // and get the position after each line
      auto curpos = errbuff.tellg();
      // if it's the last line or if we are now beyond the error position then print an arrow
      if (!arrowShown && (curpos == -1 || curpos >= pos)) { // -1 = last line
        // from the beginning to the line to the position of the error
        for (long i = lastpos - 1; i < pos; ++i) message << "-";
        message << "^" << std::endl;
        // but only show it once
        arrowShown = true;
      }
      lastpos = curpos;
    }
    throw std::runtime_error(message.str());
  }

random01()

double random01 ( )

inline

Generate a random double value between 0 and 1, both limits excluded.

Returns

value in (0,1)

Definition at line 240 of file RandomGenerator.h.

  {
    // There are two possibilities to generate a uniform double between 0 and
    // 1: multiply the integer by a constant or exploit the double
    // representation and use some bit shift magic. We have both implementation
    // here and they seem to produce the exact same output so we stick with the
    // more readable one but leave the bitshift solution just in case
#ifdef RANDOM_IEEE754
    //Generate a double in (0,1) using magic bit hackery with doubles: The
    //memory layout of a IEEE754 double precision floating point variable
    //is [sign(1)|exponent(11)|fraction(52)] with values in parentheses
    //being the number of bits. The actual value is then
    //-1^{sign} * (1.fraction) * 2^{exponent-1023}. Setting sign to 0 the
    //exponent to 1023 will thus return a value between 1 (inclusive) and 2
    //(exclusive). So we shift the 64bit integer to the right by 12 bits
    //(which gives as zeros for sign and exponent) and logical or this with
    //the correct binary representation of the exponent
 
    //To do this we use a union to modify the binary representation using
    //an integer and then return the double value
    union { uint64_t i; double d; } x;
    x.i = random64() >> 12;
    //This is a bit academic but we want (0,1) so if we happen to get
    //exactly zero we try again. Chance is 1 in 2^52
    if (x.i == 0) return random01();
    x.i |= 0x3FF0000000000000ULL;
    return x.d - 1.0;
#else
    //Generate a double (0,1) the traditional way by multiplying it with a
    //constant. As doubles only have a precision of 52 bits we need to
    //remove the 12 leading bits from our random int value
    const uint64_t x = random64() >> 12;
    //This is a bit academic but we want (0,1) so if we happen to get
    //exactly zero we try again. Chance is 1 in 2^52
    if (!x) return random01();
    //return x / 2^{52};
    return x * 2.220446049250313080847263336181640625e-16;
#endif
  }

random64()

uint64_t random64 ( )

inline

Generate one 64bit unsigned integer between 0 and UINT64_MAX (both inclusive).

Returns

random value in [0, UINT64_MAX]

Definition at line 200 of file RandomGenerator.h.

  {
    //Generate random number using magic, taken from [arXiv:1402.6246] and only
    //changed to conform to naming scheme
    uint64_t s0 = m_state[ m_index ];
    uint64_t s1 = m_state[ m_index = (m_index + 1) & 15 ];
    s1 ^= s1 << 31;
    s1 ^= s1 >> 11;
    s0 ^= s0 >> 30;
    return (m_state[ m_index ] = s0 ^ s1) * 1181783497276652981LL;
  }

rebuild()

void rebuild ( bool  force = false )

protected

Rebuild the index.

Parameters

force

if force is true, the index will be rebuild even if the RelationArray says that it has not been modified

Definition at line 156 of file RelationIndexContainer.h.

  {
    m_valid = m_storeRel.isValid();
    if (!m_valid) {
      B2DEBUG(100, "Relation " << m_storeRel.getName() << " does not exist, cannot build index");
      m_index.clear();
      m_storeFrom = AccessorParams();
      m_storeTo = AccessorParams();
      return;
    }
 
    //Check if relation has been modified since we created the index
    //If not, keep old contents
    if (!force && !m_storeRel.getModified()) return;
 
    B2DEBUG(100, "Building index for " << m_storeRel.getName());
 
    //Reset modification flag
    m_storeRel.setModified(false);
 
    m_index.clear();
 
    //Get related StoreArrays
    m_storeFrom = m_storeRel.getFromAccessorParams();
    m_storeTo = m_storeRel.getToAccessorParams();
    const StoreArray<FROM> storeFrom(m_storeFrom.first, m_storeFrom.second);
    const StoreArray<TO>   storeTo(m_storeTo.first, m_storeTo.second);
 
    //Get number of entries in relation and stores (also checks template type versus DataStore contents)
    const RelationElement::index_type nFrom = storeFrom.getEntries();
    const RelationElement::index_type nTo = storeTo.getEntries();
    const unsigned int nRel = m_storeRel.getEntries();
 
    //Loop over all RelationElements and add them to index
    for (unsigned int i = 0; i < nRel; ++i) {
      const RelationElement& r = m_storeRel[i];
      RelationElement::index_type idxFrom = r.getFromIndex();
      if (idxFrom >= nFrom)
        B2FATAL("Relation " <<  m_storeRel.getName() << " is inconsistent: from-index (" << idxFrom << ") out of range");
      const FROM* from = storeFrom[idxFrom];
 
      //Loop over index and weight vector at once
      const auto& indices = r.getToIndices();
      const auto& weights = r.getWeights();
      auto itIdx = indices.begin();
      auto itWgt = weights.begin();
      const auto& idxEnd = indices.end();
      for (; itIdx != idxEnd; ++itIdx, ++itWgt) {
        const RelationElement::index_type idxTo = *itIdx;
        if (idxTo >= nTo)
          B2FATAL("Relation " <<  m_storeRel.getName() << " is inconsistent: to-index (" << idxTo << ") out of range");
        const TO* to = storeTo[idxTo];
        m_index.insert(Element(idxFrom, idxTo, from, to, *itWgt));
      }
    }
  }

registerConversion()

double registerConversion ( const std::string &  name, double  value  )

staticprotected

registers the name and value of a conversion in s_conversionFactors.

Definition at line 149 of file UnitConst.cc.

  {
    if (!s_conversionFactors.insert(make_pair(name, value)).second) {
      B2ERROR("Conversion factor for unit " << name << " already exists, ignoring");
    }
    return value;
  }

reset() [1/2]

void reset ( bool  keepConfig = false )

static

Reset the database instance.

Parameters

keepConfig

if true the configuration object itself is not resetted so that initializing the database again will result in the same configuration as before. This is useful when running process multiple times.

Definition at line 50 of file Database.cc.

  {
    auto& conf = Conditions::Configuration::getInstance();
    conf.setInitialized(false);
    DBStore::Instance().reset(true);
    Instance().m_configState = c_PreInit;
    Instance().m_metadataProvider.reset();
    Instance().m_payloadCreation.reset();
    if (not keepConfig)
      conf.reset();
  }

reset() [2/2]

void reset

(

bool

keepEntries = false

)

Invalidate all payloads.

Parameters

keepEntries

Keep the existing entries so that future calls to update the database will try to obtain the payloads which were registered so far.

Definition at line 177 of file DBStore.cc.

  {
    if (!m_dbEntries.empty())
      B2DEBUG(31, "DBStore::reset(): Cleaning all database information");
    m_intraRunDependencies.clear();
    if (!keepEntries) {
      m_dbEntries.clear();
    } else {
      for (auto& entry : m_dbEntries) {
        entry.second.resetPayload();
      }
    }
    // Make sure our EventMetaData pointer is reconnected on next access ...
    // because probably this is after resetting the DataStore (BII-1262)
    StoreObjPtr<EventMetaData> event;
    m_storeEvent = event;
    m_manualEvent = std::nullopt;
  }

resetPayload()

void resetPayload ( )

private

reset the payload to nothing

Definition at line 68 of file DBStoreEntry.cc.

  {
    m_globaltag = "";
    m_revision = 0;
    m_iov = IntervalOfValidity();
    m_keep = false;
    m_filename = "";
    m_checksum = "";
    // If the old object was intra run dependent then m_object is owned by the
    // intra run dependency object. So set the pointer to null to not delete the object.
    if (m_intraRunDependency) m_object = nullptr;
    // and delete the old intra run dependency if it exists
    deleteAndSetNullptr(m_object, m_intraRunDependency, m_tfile);
  }

resetValue()

void resetValue

Resets the parameter value by assigning the default value to the parameter value.

Definition at line 87 of file ModuleParam.templateDetails.h.

  {
    m_paramVariable = m_defaultValue;
    m_setInSteering = false;
  }

RndmArray() [1/4]

void RndmArray ( Int_t  n, Double_t *  array  )

inline

Fill an array of doubles with random values in (0,1), both limits excluded.

Parameters

n	number of doubles to generate
array	pointer to an array where the numbers should be stored

Definition at line 219 of file RandomGenerator.h.

  {
    //Fill the array, no optimization whatsoever necessary
    for (int i = 0; i < n; ++i) array[i] = random01();
  }

RndmArray() [2/4]

void RndmArray ( Int_t  n, Float_t *  array  )

inline

Fill an array of floats with random values in (0,1), both limits excluded.

Parameters

n	number of floats to generate
array	pointer to an array where the numbers should be stored

Definition at line 212 of file RandomGenerator.h.

  {
    //We could optimize this more thoroughly since one 64bit random int is
    //enough to generate two floats but this would probably be rather academic
    for (int i = 0; i < n; ++i) array[i] = random01();
  }

RndmArray() [3/4]

void RndmArray ( Int_t  n, UInt_t *  array  )

inline

Fill an array of unsigned integers with random values in [0, UINT32_MAX], both limits included.

Parameters

n	number of ints to generate
array	pointer to an array where the numbers should be stored

Definition at line 231 of file RandomGenerator.h.

  {
    //Fill the most part of the array using 64bit numbers
    RndmArray(n / 2, (ULong64_t*)array);
    //Only for uneven number of elements we need to fill the last one using a
    //32bit number
    if (n % 2) array[n - 1] = random32();
  }

RndmArray() [4/4]

void RndmArray ( Int_t  n, ULong64_t *  array  )

inline

Fill an array of unsigned 64bit integers with random values in [0, UINT64_MAX], both limits included.

Parameters

n	number of ints to generate
array	pointer to an array where the numbers should be stored

Definition at line 225 of file RandomGenerator.h.

  {
    //Fill the array, no optimization whatsoever necessary
    for (int i = 0; i < n; ++i) array[i] = random64();
  }

select()

void select

(

const std::function< bool(const StoredClass *)> &

f

)

This method is the actual worker.

It selects the elements, fill the subset and all the relations in which the subset is involved.

Parameters

f	the pointer to the function (or a nameless lambda expression) returning true for the elements to be selected and false for the others.

Definition at line 414 of file SelectSubset.h.

  {
    copySetWithRelations(f);
 
    if (m_inheritToSelf) {
      copyRelationsToSelf();
    }
 
    if (m_reduceExistingSet) {
      swapSetsAndDestroyOriginal();
    }
  }

send()

void send ( std::unique_ptr< zmq::socket_t > &  socket, AZMQMessage  message  )

static

Send a given message over the given created socket. You need to move in the message for zero-copy.

Definition at line 153 of file ZMQParent.h.

  {
    AZMQMessage::element_type::toSocket(std::move(message), socket);
  }

sendMessage()

bool sendMessage ( const LogMessage &  message )

overridevirtual

Sends a log message.

Parameters

message

The log message object.

Returns

Returns true if the message could be send.

Implements LogConnectionBase.

Definition at line 23 of file LogConnectionJSON.cc.

  {
    if (!isConnected()) return false;
    m_console.write(message.toJSON(m_complete));
    return true;
  }

sendToSocket()

void sendToSocket

(

const AZMQClient &

socket

)

Publish this event backup directly to the given client.

Definition at line 56 of file ProcessedEventBackup.h.

  {
    auto message = ZMQMessageFactory::createMessage(EMessageTypes::c_eventMessage, m_eventMessage);
    socket.publish(std::move(message));
    B2DEBUG(100, "sent backup evt: " << m_eventMetaData.getEvent());
  }

sendWorkerBackupEvents()

void sendWorkerBackupEvents	(	unsigned int	worker,
		const AZMQClient &	socket
	)

Send all backups of a given worker directly to the multicast and delete them.

Definition at line 51 of file ProcessedEventsBackupList.h.

  {
    for (auto it = m_evtBackupVector.begin(); it != m_evtBackupVector.end();) {
      if (it->getWorkerId() == worker) {
        B2DEBUG(100, "Delete event: " << it->getEventMetaData().getEvent());
        it->sendToSocket(socket);
        // TODO: better: delete backup on confirmation message
        m_evtBackupVector.erase(it);
        B2DEBUG(100, "new backup list size: " << m_evtBackupVector.size());
      } else {
        it++;
      }
    }
  }

setBackends()

void setBackends

(

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

backends

)

Select the backends to use to find resources.

Parameters

backends

list of URIs identifying the backends starting with the handler prefix followed by a colon, the rest is handler specific

Definition at line 99 of file Gearbox.cc.

  {
    clearBackends();
    for (const string& backend : backends) {
      B2DEBUG(300, "Adding InputHandler for '" << backend << "'");
      //Find correct InputHandler, assuming file backend by default if there is no colon in the
      //uri
      string prefix("file");
      string accessinfo(backend);
      size_t colon = backend.find(':');
      if (colon != string::npos) {
        prefix = backend.substr(0, colon);
        accessinfo = backend.substr(colon + 1);
      }
      auto it = m_registeredHandlers.find(prefix);
      if (it == m_registeredHandlers.end()) {
        B2ERROR("Could not find input handler to handle '" << backend << "', ignoring");
        continue;
      }
      gearbox::InputHandler* handler = it->second(accessinfo);
      if (handler) {
        m_handlers.push_back(handler);
      } else {
        B2ERROR("Problem creating input handler to handle '" << backend << "', ignoring");
      }
    }
  }

setBucket()

void setBucket

(

unsigned

i

)

Sets the fill status of RF bucket to true.

Parameters

i	bucket number (modulo c_RFBuckets applied internally)

Definition at line 20 of file BunchStructure.cc.

  {
    if (m_fillPattern.empty()) m_fillPattern.resize(c_RFBuckets, false);
 
    m_fillPattern[i % c_RFBuckets] = true;
    m_filledBuckets.clear();
  }

setDefaultValue()

void setDefaultValue

(

const T &

defaultValue

)

Sets the default value of a parameter.

Parameters

defaultValue

The parameter default value of the parameter.

Definition at line 42 of file ModuleParam.templateDetails.h.

  {
    m_defaultValue = defaultValue;
    m_paramVariable = defaultValue;
    m_setInSteering = false;
  }

setMeanCov() [1/2]

bool setMeanCov	(	const ROOT::Math::XYZVector &	mean,
		const TMatrixTBase< value_type > &	cov
	)

set the mean and covariance for the distribution.

Parameters

mean	Vector of mean values
cov	Matrix containing the covariance values

Returns

true if covariance could be decomposited, false otherwise

Definition at line 190 of file MultivariateNormalGenerator.h.

  {
    TVectorT<value_type> tmean(3);
    tmean[0] = mean.X();
    tmean[1] = mean.Y();
    tmean[2] = mean.Z();
    return setMeanCov(tmean, cov);
  }

setMeanCov() [2/2]

bool setMeanCov	(	const TVectorT< value_type > &	mean,
		const TMatrixTBase< value_type > &	cov
	)

set mean and covariance matrix from ROOT vector/matrix objects, e.g.

TMatrixD, TMatrixF, TMatrixDSym and so forth

Parameters

mean	Vector of mean values
cov	Matrix containing the covariance values

Returns

true if covariance could be decomposited, false otherwise

Definition at line 176 of file MultivariateNormalGenerator.h.

  {
    Eigen::VectorXd emean(mean.GetNrows());
    Eigen::MatrixXd ecov(cov.GetNrows(), cov.GetNcols());
    for (int i = 0; i < mean.GetNrows(); ++i) { emean(i) = mean(i); }
    for (int i = 0; i < cov.GetNrows(); ++i) {
      for (int j = 0; j < cov.GetNcols(); ++j) {
        ecov(i, j) = cov(i, j);
      }
    }
    return setMeanCov(emean, ecov);
  }

setParameter()

void setParameter	(	const std::string &	name,
		const T &	value
	)

Sets the value of a parameter given by its name.

A template based method which is invoked by the module.

Parameters

name	The unique name of the parameter.
value	The parameter value which should be assigned to the parameter given by its name.

Definition at line 69 of file ModuleParamList.templateDetails.h.

  {
    try {
      ModuleParam<T>& explModParam = getParameter<T>(name);
      explModParam.setValue(value);
    } catch (std::runtime_error& exc) {
      B2ERROR(exc.what());
    }
  }

setParamPython()

void setParamPython	(	const std::string &	name,
		const PythonObject &	pyObj
	)

Implements a method for setting boost::python objects.

The method supports the following types: dict, list, int, double, string, bool The conversion of the python object to the C++ type and the final storage of the parameter value is done by specialized converter in PyObjConvUtils.h

Parameters

name	The unique name of the parameter.
pyObj	The object which should be converted and stored as the parameter value.

Definition at line 104 of file ModuleParamList.templateDetails.h.

  {
 
    ModuleParamPtr p = getParameterPtr(name);
    p->setValueFromPythonObject(pyObj);
  }

setValue()

void setValue

(

const T &

value

)

Sets the value of a parameter.

Parameters

value

The parameter value which should be assigned to the parameter.

Definition at line 35 of file ModuleParam.templateDetails.h.

  {
    m_paramVariable = value;
    m_setInSteering = true;
  }

setValueFromParam()

void setValueFromParam ( const ModuleParamBase &  param )

finalvirtual

Set value from other ModuleParam of same type.

Implements ModuleParamBase.

Definition at line 76 of file ModuleParam.templateDetails.h.

  {
    const ModuleParam<T>* p = dynamic_cast<const ModuleParam<T>*>(&param);
    if (p) {
      m_defaultValue = p->m_defaultValue;
      m_paramVariable = p->m_paramVariable;
      m_setInSteering = p->m_setInSteering;
    }
  }

setValueFromPythonObject()

void setValueFromPythonObject ( const boost::python::object &  pyObject )

finalvirtual

Implements a method for setting boost::python objects.

The method supports the following types: list, dict, int, double, string, bool The conversion of the python object to the C++ type and the final storage of the parameter value is done by PyObjConvUtils::convertPythonObject.

Parameters

pyObject

The object which should be converted and stored as the parameter value.

Implements ModuleParamBase.

Definition at line 62 of file ModuleParam.templateDetails.h.

  {
    setValue(PyObjConvUtils::convertPythonObject(pyObject, getDefaultValue()));
  }

setValueToPythonObject()

void setValueToPythonObject ( boost::python::object &  pyObject, bool  defaultValues = false  ) const

finalvirtual

Returns a python object containing the value or the default value of the given parameter.

Parameters

pyObject	Reference to the python object which is set to the parameter value.
defaultValues	If true returns default value otherwise parameter value.

Implements ModuleParamBase.

Definition at line 68 of file ModuleParam.templateDetails.h.

  {
    pyObject =
      PyObjConvUtils::convertToPythonObject((defaultValues) ? m_defaultValue : m_paramVariable);
  }

SetXYZ() [1/4]

void SetXYZ

(

const ROOT::Math::XYZVector &

xyzVec

)

set all coordinates using a reference to XYZVector

Definition at line 680 of file B2Vector3.h.

  {
    m_coordinates[0] = static_cast<Double_t>(xyzVec.X());
    m_coordinates[1] = static_cast<Double_t>(xyzVec.Y());
    m_coordinates[2] = static_cast<Double_t>(xyzVec.Z());
  }

SetXYZ() [2/4]

void SetXYZ

(

const ROOT::Math::XYZVector *

xyzVec

)

set all coordinates using a pointer to XYZVector

Definition at line 689 of file B2Vector3.h.

  {
    m_coordinates[0] = static_cast<Double_t>(xyzVec->X());
    m_coordinates[1] = static_cast<Double_t>(xyzVec->Y());
    m_coordinates[2] = static_cast<Double_t>(xyzVec->Z());
  }

SetXYZ() [3/4]

void SetXYZ

(

const TVector3 &

tVec

)

set all coordinates using a reference to TVector3

Definition at line 662 of file B2Vector3.h.

  {
    m_coordinates[0] = static_cast<Double_t>(tVec.X());
    m_coordinates[1] = static_cast<Double_t>(tVec.Y());
    m_coordinates[2] = static_cast<Double_t>(tVec.Z());
  }

SetXYZ() [4/4]

void SetXYZ

(

const TVector3 *

tVec

)

set all coordinates using a pointer to TVector3

Definition at line 671 of file B2Vector3.h.

  {
    m_coordinates[0] = static_cast<Double_t>(tVec->X());
    m_coordinates[1] = static_cast<Double_t>(tVec->Y());
    m_coordinates[2] = static_cast<Double_t>(tVec->Z());
  }

splitOnDelimiterAndConserveParenthesis()

std::vector< std::string > splitOnDelimiterAndConserveParenthesis	(	std::string	str,
		char	delimiter,
		char	open,
		char	close
	)

Split into std::vector on delimiter ignoring delimiters between parenthesis.

Definition at line 81 of file CutHelpers.cc.

  {
 
    std::vector<std::string> result;
    unsigned int lastdelimiter = 0;
    for (unsigned int i = 0; i < str.size(); ++i) {
      if (str[i] == open) {
        i += findMatchedParenthesis(str.substr(i), open, close);
        continue;
      }
      if (str[i] == delimiter) {
        result.push_back(str.substr(lastdelimiter, i - lastdelimiter));
        lastdelimiter = i + 1;
      }
    }
    std::string last = str.substr(lastdelimiter);
    if (last.size() != 0) {
      result.push_back(last);
    }
    return result;
  }

storeData() [1/2]

bool storeData	(	const std::string &	name,
		TObject *	object,
		const IntervalOfValidity &	iov
	)

Store an object in the database.

Parameters

name	Name that identifies the object in the database.
object	The object that should be stored in the database.
iov	The interval of validity of the the object.

Returns

True if the storage of the object succeeded.

Definition at line 141 of file Database.cc.

  {
    if (!m_payloadCreation) initialize();
    auto result = m_payloadCreation->storeData(name, obj, iov);
    // we added payloads, make sure we reread testing files on next try
    if (result) {
      for (auto& testing : m_testingPayloads) {
        testing.reset();
      }
    }
    return result;
  }

storeData() [2/2]

bool storeData

(

std::list< DBImportQuery > &

query

)

Store multiple objects in the database.

Parameters

query

A list of DBImportQuery entries that contains the objects, their names, and their intervals of validity.

Returns

True if the storage of the object succeeded.

Definition at line 134 of file Database.cc.

  {
    return std::all_of(query.begin(), query.end(), [this](const auto & import) {
      return storeData(import.name, import.object, import.iov);
    });
  }

timeit()

void timeit

(

const std::string &

key

)

Measure the rate of calls with the same key every AVERAGE_SIZE calls (and also display the last time AVERAGE_SIZE was reached under <key>_last_measurement)

Definition at line 117 of file ZMQLogger.h.

  {
    auto& [calls, timestamp] = m_timeCounters[key];
    if (calls % AVERAGE_SIZE == 0) {
      auto current = std::chrono::high_resolution_clock::now();
      double elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(
                         current - timestamp).count();
 
      log(key, AVERAGE_SIZE / elapsed);
 
      timestamp = current;
      calls = 0;
 
      auto displayTime = std::chrono::system_clock::to_time_t(current);
      log(key + "_last_measurement", std::ctime(&displayTime));
    }
    calls++;
  }

TypeInfo()

std::string TypeInfo

static

Static function to generate a string description for the parameter type.

This string will be used to identify the contained type and guaranties some level of type safety in this type erasure.

Definition at line 22 of file ModuleParam.templateDetails.h.

  {
    return PyObjConvUtils::Type<T>::name();
  }

update() [1/2]

void update

(

)

Updates all objects that are outside their interval of validity.

This method is called by the framework for each new run.

Definition at line 79 of file DBStore.cc.

  {
    if (m_dbEntries.empty()) {
      // make sure we at least fix the list of globaltags on the first time
      Database::Instance().initialize(Database::c_InitGlobaltagList);
      return;
    }
 
    // Make sure our EventMetaData pointer is reconnected as it could get
    // disconnected if the DataStore is reset.
    // TODO: This can be removed once BII-1262 is fixed.
    StoreObjPtr<EventMetaData> event;
    m_storeEvent = event;
    // Clear the m_manualEvent to indicate that we now want to use the DataStore event numbers
    m_manualEvent = std::nullopt;
    performUpdate(*m_storeEvent);
  }

update() [2/2]

void update

(

const EventMetaData &

event

)

Updates all objects that are outside their interval of validity.

This method is for calling the DBStore manually using an EventMetaData object instead of relying on the DataStore containing one.

Definition at line 97 of file DBStore.cc.

  {
    if (m_dbEntries.empty()) {
      // make sure we at least fix the list of globaltags on the first time
      Database::Instance().initialize(Database::c_InitGlobaltagList);
      return;
    }
    m_manualEvent = event;
    performUpdate(*m_manualEvent);
  }

updateEvent() [1/2]

void updateEvent

(

)

Updates all intra-run dependent objects.

This method is called by the framework for each event.

Definition at line 142 of file DBStore.cc.

  {
    if (!m_manualEvent) {
      performUpdateEvent(*m_storeEvent);
    } else {
      B2WARNING("DBStore is currently using manual event information. But you are asking for the DataStore's EventMetaData "
                "to be used to update the Intra-run dependencies. Update could not proceed. "
                "Did you forget to call DBStore::Instance().update() before calling this function?");
    }
  }

updateEvent() [2/2]

void updateEvent

(

const unsigned int

eventNumber

)

Updates all intra-run dependent objects.

This method is for specifying the event number to update to manually. Updates the m_manualEvent to use the event number given in the argument, before performing the intra-run update. This doesn't alter/use the DataStore EventMetaData.

Definition at line 153 of file DBStore.cc.

  {
    // As m_manualEvent doesn't use the DataStore, it isn't automatically updated and we must manually update the event
    // number prior to updating the intra-run objects.
    // This also updates it ready for getData if a DBObject gets constructed later.
    if (m_manualEvent) {
      m_manualEvent->setEvent(eventNumber);
      performUpdateEvent(*m_manualEvent);
    } else {
      B2WARNING("DBStore is not currently using manual event information. But you are asking for the event number to be set "
                " to a custom value. Update of the Intra-run dependencies could not proceed. "
                "Did you forget to call DBStore::Instance().update(event), or accidentally call DBStore::Instance().update() "
                "prior to to this?");
    }
  }

updateObject()

void updateObject ( const EventMetaData &  event )

private

update the payload object according to the new event information.

If the payload has no intra run dependency this does nothing, otherwise it will load the appropirate object for the given event and call the update notifications on changes to the object.

Definition at line 55 of file DBStoreEntry.cc.

  {
    // if we don't have intra run dependency we don't care about event number
    if (!m_intraRunDependency) return;
    // otherwise update the object and call notify all accessors on change
    TObject* old = m_object;
    m_object = m_intraRunDependency->getObject(event);
    if (old != m_object) {
      B2DEBUG(35, "IntraRunDependency for " << m_name << ": new object (" << old << ", " << m_object << "), notifying accessors");
      notifyAccessors();
    }
  }

updatePayload()

void updatePayload ( unsigned int  revision, const IntervalOfValidity &  iov, const std::string &  filename, const std::string &  checksum, const std::string &  globaltag, const EventMetaData &  event  )

private

Update the payload information for this entry and if appropriate open the new file and extract the object as needed.

If another version is already loaded the object will be deleted and the file closed.

If neither revision or filename change we assume the payload is not modified and will not update anything and not call any update notifications.

Parameters

revision	new revision of the payload
iov	new interval of validity for the payload
filename	filename for the payload
checksum	checksum of the payload
globaltag	globaltag name (or testing payloads path) from which the payload is picked
event	EventMetaData object

Definition at line 83 of file DBStoreEntry.cc.

  {
    m_iov = iov;
    m_globaltag = globaltag;
    // File is the same as before, no need to update anything else. We could
    // check all identifiers like revision, filename and checksum
    // > if (revision == m_revision && filename == m_filename && m_checksum == checksum) return;
    // but this is a bit strict as we know we have some payloads with the same
    // checksum but multiple revisions and there's no need to actually update
    // the object. But at least lets make sure the revision number is reported the same as in the db
    m_revision = revision;
    if (m_checksum == checksum) return;
    m_keep = false;
    m_checksum = checksum;
    m_filename = filename;
    // If the old object was intra run dependent then m_object is owned by the
    // intra run dependency object. So set the pointer to null to not delete the object.
    if (m_intraRunDependency) m_object = nullptr;
    // and delete the old intra run dependency if it exists
    deleteAndSetNullptr(m_object, m_intraRunDependency, m_tfile);
    loadPayload(event);
    B2DEBUG(30, "DBEntry changed"
            << LogVar("name", m_name)
            << LogVar("globaltag", m_globaltag)
            << LogVar("revision", m_revision)
            << LogVar("checksum", m_checksum)
            << LogVar("filename", m_filename)
            << LogVar("validity", m_iov));
    notifyAccessors();
  }

~DBStore()

~DBStore

(

)

Destructor.

Definition at line 23 of file DBStore.cc.

  {
    reset();
  }

~DBStoreEntry()

~DBStoreEntry

(

)

Clean up memory.

Some of the members are raw pointers to limit the include burden on this class as it will be included by anyone using Conditions data

Definition at line 45 of file DBStoreEntry.cc.

  {
    // if intra run dependency: object owned by the IntraRunDependency object so don't delete the object itself.
    if (m_intraRunDependency) m_object = nullptr;
    // and free all memory
    deleteAndSetNullptr(m_object, m_intraRunDependency, m_tfile);
    if (!m_accessors.empty()) B2DEBUG(38, "DBEntry " << m_name << " destroyed, notifying accessors");
    notifyAccessors(true);
  }

~Gearbox()

~Gearbox

(

)

Free structures on destruction.

Definition at line 74 of file Gearbox.cc.

  {
    close();
    clearBackends();
    delete m_parameterCache;
  }

Variable Documentation

DBPointer_defaultName

std::string DBPointer_defaultName = ""

Use default name for array in DBPointer.

Definition at line 19 of file DBPointer.h.

s_conversionFactors

map< string, double > s_conversionFactors

staticprotected

Map to be able to convert between units using string representations of the unit name.

Definition at line 163 of file Unit.h.

XYZToTVector

constexpr auto XYZToTVector

staticconstexpr

Initial value:

= [](const ROOT::Math::XYZVector& a)
  {
    return TVector3(a.X(), a.Y(), a.Z());
  }

Helper function to convert XYZVector to TVector3.

Definition at line 24 of file VectorUtil.h.