__longlong | |
__Longs< I > | |
_Accessor< TYP > | |
NTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry |
NTuple::_Accessor< _Array< TYP > > | |
NTuple::Array< TYP > | Class acting as a smart pointer holding a N tuple _Item |
NTuple::_Accessor< _Item< bool > > | |
NTuple::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item |
NTuple::_Accessor< _Item< IOpaqueAddress * > > | |
NTuple::Item< IOpaqueAddress * > | |
NTuple::_Accessor< _Item< TYP > > | |
NTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item |
NTuple::_Accessor< _Matrix< TYP > > | |
NTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item |
_Array< TYP > | |
_ArrayImp< TYP > | |
_CallbackStreamBufBase | |
GaudiPython.Bindings.CallbackStreamBuf | |
_Data< TYP > | |
_DataImp< TYP > | |
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function | |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function | |
_GaudiAlgorithm | |
GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm |
_GaudiHistoAlg | |
GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming |
_GaudiTupleAlg | |
GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples |
Gaudi::Utils::_GetType< TYPE > | Helper structure to define the proper return type for "get"-functions |
Gaudi::Utils::_GetType< Gaudi::NamedRange_< CONTAINER > > | Template specialization for "named ranges" |
Gaudi::Utils::_GetType< Gaudi::Range_< CONTAINER > > | Template specialization for "ranges" |
Gaudi::Utils::_GetType< TYPE & > | Template specialization for references |
Gaudi::Utils::_GetType< TYPE * > | Template specialization for pointers |
KeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects |
_Item< TYP > | |
_ItemImp< TYP > | |
_Matrix< TYP > | |
_MatrixImp< TYP > | |
_PyAlgorithm | |
GaudiPython.Bindings.PyAlgorithm | |
KeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects |
GaudiKernel.ProcessJobOptions._TempSysPath | |
std::_Vector_base< _Tp, _Alloc > [external] | |
std::vector< DataObject * > [external] | |
IDataSelector | This is only a placeholder to allow me compiling
until the responsible guy does his work! M.Frank |
std::vector< SmartRef< TYPE > > [external] | |
SmartRefVector< TYPE > | Kernel objects: SmartRefVector |
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace | |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace | |
AbsFunction | |
Genfun::GaudiMathImplementation::Adapter2DoubleFunction | Constructor from the trivial function with two argument |
Genfun::GaudiMathImplementation::Adapter3DoubleFunction | Constructor from the trivial function with two argument |
Genfun::GaudiMathImplementation::AdapterIFunction | Constructor from the IFunction ( see AIDA/IFunction.h) |
Genfun::GaudiMathImplementation::Constant | Fixed constant function |
Genfun::GaudiMathImplementation::GSLFunctionWithError | |
Genfun::GaudiMathImplementation::GSLFunctionWithMode | |
Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError | |
Genfun::GaudiMathImplementation::GSLSpline | |
Genfun::GaudiMathImplementation::GSLSplineDeriv | |
Genfun::GaudiMathImplementation::GSLSplineDeriv2 | |
Genfun::GaudiMathImplementation::GSLSplineInteg | |
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral | This class allows the numerical evaluation of the following functions: |
Genfun::GaudiMathImplementation::NumericalDerivative | Numerical derivative (using GSL adaptive numerical differentiation) |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral | The simple class for numerical integrations |
Genfun::GaudiMathImplementation::SimpleFunction | |
Gaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project |
AlgContexSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service |
Gaudi::Utils::AlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context |
GaudiPython::AlgDecorator | |
AlgFactory< T > | |
ALGORITHM | |
GaudiPython::PyAlg< ALGORITHM > | General class to embed the existing algorithm/base class into the python |
GaudiSequencer::AlgorithmEntry | |
AlgorithmManager::AlgorithmItem | |
Gaudi::Utils::AlgSelector | Simple interface class for selection of algorithms |
Gaudi::Utils::AlgNameSelector | The trivial selector of algorithm by type |
Gaudi::Utils::AlgTypeSelector< TYPE > | The trivial selector of algorithm by type |
Gaudi::Utils::AlgTypeSelector< const TYPE & > | |
Gaudi::Utils::AlgTypeSelector< const TYPE * > | |
Gaudi::Utils::AlgTypeSelector< const TYPE > | |
Gaudi::Utils::AlgTypeSelector< TYPE & > | |
Gaudi::Utils::AlgTypeSelector< TYPE * > | |
GaudiUtils::Allocator< Type > | Allocator |
GaudiUtils::AllocatorPool | Allocator pool |
AIDA::Annotation::AnnotationItem | Internal private annotation item class |
AppendInterfaceName | Helper class for the cast used in the MPL for_each algorithm in the implementation of query_interface |
Containers::array | |
Array< TYP > | |
NTuple::Array< IOpaqueAddress * > | |
Gaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way |
BaseObjectMemberFunction | Base class of ObjectMemberFunction |
ObjectMemberFunction< CallerClass > | This class is used by IUpdateManagerSvc to keep pairs made of a member function and a pointer to the object for which that member function has to be called |
BasePtrSetter | Base class to set the pointer to an object of a class derived from DataObject in a generic way |
PtrSetter< ActualType > | Templated specialization of BasePtrSetter |
std::basic_streambuf< _CharT, _Traits > [external] | |
std::basic_stringbuf< _CharT, _Traits, _Alloc > [external] | |
GaudiPython::CallbackStreamBuf | |
GaudiTest.BasicOutputValidator | Output Validation Classes |
std::binary_function< const std::pair< ChronoEntity *, const IChronoStatSvc::ChronoTag * >, const std::pair< ChronoEntity *, const IChronoStatSvc::ChronoTag * >, bool > [external] | |
ComparePairOfChronoEntityAndChronoTag | |
std::binary_function< const std::pair< const StatEntity *, const IChronoStatSvc::StatTag * >, const std::pair< const StatEntity *, const IChronoStatSvc::StatTag * >, bool > [external] | |
ComparePairOfStatEntityAndStatTag | |
std::binary_function< double, double, bool > [external] | |
Gaudi::Math::Lomont< double > | Specialization for double numbers |
std::binary_function< float, float, bool > [external] | |
Gaudi::Math::Lomont< float > | Specialization for float numbers |
std::binary_function< Property, Property, bool > [external] | |
Gaudi::Parsers::Property::LessThen | |
FileInfo::CacheItem | |
FileInfo::CacheItemComparator | |
Cartesian3D< T > | |
Gaudi::Parsers::Catalog | |
Gaudi::Utils::CheckData< TYPE > | Helper structure for implementation of "exists"-functions for GaudiCommon<BASE> |
Gaudi::Utils::CheckData< const TYPE > | Template specialization for 'const'-type |
Gaudi::Utils::CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for ranges |
Gaudi::Utils::CheckData< TYPE & > | Template specialization for reference types |
Gaudi::Utils::CheckData< TYPE * > | Template specialization for pointer types |
Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | |
Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges |
Chrono | A small utility class for chronometry of user codes |
ChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer |
CLASS | |
RootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > | |
ProcStats::cleanup | |
CLibSymbolInfo | |
closure | |
Gaudi::Parsers::AttributesClosureGrammar< T1, T2 > | Grammar or grammar rule which derive from this struct will have two attributes: type T1 and name val , type T2 and name attrs |
Gaudi::Parsers::ClosureGrammar< T > | Grammar or grammar rule which derive from this struct will have attribute of type T and name val |
GaudiTest.CMT | |
CnvFactory< T > | |
configGenerator | |
NTupleSvc::Connection | |
StreamBuffer::ContainedLink | Definition of the contained link set |
ContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g |
KeyedObject< KEY > | Definition of the templated KeyedObject class |
Gaudi::RootDataConnection::ContainerSection | Internal helper class, which described a TBranch section in a ROOT file |
IEvtSelector::Context | |
EventCollectionContext | |
EventCollectionSelector::MyContextType | |
EvtSelectorContext | Definition of class EventIterator |
Gaudi::RootEvtSelectorContext | ROOT specific event selector context |
ConverterID | |
IgHookTrace::Counter | Nearly dummy object type to identify a counter |
GaudiToolLocal::Counter | Simple local counter |
Tuples::Local::Counter | |
IgHookTrace::CounterValue | Value for a counter chained from a trace |
DataHistory::DataHistoryOrder | |
DataIncident | Data service incident class |
StreamBuffer::DataIO | A small base class to handle generic data streaming |
StreamBuffer::Istream | Reader for standard input streams |
StreamBuffer::Ostream | Writer for standard output streams |
DataItem< TYP > | |
DataObject | A DataObject is the base class of any identifiable object on any data store |
Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2 |
Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
HistoryObj | Base class for History Objects |
AlgorithmHistory | AlgorithmHistory class definition |
AlgToolHistory | AlgToolHistory class definition |
DataHistory | DataHistory class definition |
JobHistory | JobHistory class definition |
ServiceHistory | ServiceHistory class definition |
NTuple::Directory | Small class representing an N tuple directory in the transient store |
NTuple::File | Small class representing an N tuple file in the transient store |
NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation |
NTuple::TupleImp | |
NTuple::ColumnWiseTuple | |
NTuple::RowWiseTuple | |
ObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes |
KeyedContainer< DATATYPE, MAPPING > | Template class KeyedContainer, KeyedContainer.h |
ObjectList< TYPE > | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores |
ObjectVector< TYPE > | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores |
SharedObjectsContainer< TYPE > | Very simple class to represent the container of objects which are not ownered by the container |
RefTableBase< FROM, MAPENTRY > | Template <class FROM, class TO, class MAPENTRY> class RefTable |
RefTableBase< FROM, SmartRef< TO > > | |
RefTable1to1< FROM, TO > | |
RefTableBase< FROM, SmartRefVector< TO > > | |
RefTable1toN< FROM, TO > | |
DataStoreItem | Description of the DataStoreItem class |
DataTypeInfo | Small class which allows access to internal type IDs |
AlgTool::declareInterface< I > | |
Decorator | Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm |
Containers::array::decrement | |
GaudiKernel.Configurable.Configurable.DefaultName | For detecting the default name |
Gaudi::Parsers::BoolGrammar< Iterator, Skipper >::definition | |
Gaudi::Parsers::CharGrammar< RT >::definition< ScannerT > | |
Gaudi::Parsers::IntGrammar< RT >::definition< ScannerT > | |
Gaudi::Parsers::RealGrammar< Iterator, Skipper >::definition< ScannerT > | |
Gaudi::Parsers::StringGrammar< Iterator, Skipper >::definition | |
Gaudi::Parsers::SkipperGrammar< Iterator >::definition | |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > | |
Gaudi::Parsers::VectorGrammar< GrammarT >::definition< ScannerT > | |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > | |
DHH | |
dict | |
GaudiKernel.ConfigurableDb._CfgDb | |
GaudiMP.FdsRegistry.FdsDict | |
GaudiProfiling.GenerateGaudiOpts.XmlDictObject | |
DirSearchPath | Search for files in a list of directories |
DisplacementVector3D< CoordSystem, Tag > | |
Gaudi::IODataManager::Entry | |
EnvConfig.Control.Environment | |
EqSolver::EqSolverMisc | |
Tuples::detail::ErrorHandler< OBJECT, FUNCTION > | Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g |
EventIterator< TYPE > | |
ExcelPlotter.Excel | |
std::exception [external] | STL class |
GaudiException | Define general base for Gaudi exception |
TimeException | Exception thrown by Gaudi::Time |
UpdateManagerException | Exception thrown by the UpdateManagerSvc when something goes wrong |
std::runtime_error [external] | STL class |
Gaudi::Parsers::PositionalPropertyValueException | |
Gaudi::Parsers::PropertyValueException | |
std::runtime_error [external] | STL class |
Exception | |
EnvConfig.Variable.EnvError | |
pyparsing.ParseBaseException | |
pyparsing.ParseException | |
pyparsing.ParseFatalException | |
pyparsing.ParseSyntaxException | |
pyparsing.RecursiveGrammarException | |
Gaudi::Guards::ExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc |
Factory< P, S > | |
Factory< P, S > | |
Factory< P, S > | |
Factory< P, S > | |
FileInfo | |
GaudiTest.FilePreprocessor | |
GaudiTest.BlockSkipper | |
GaudiTest.FilePreprocessorSequence | |
GaudiTest.LineSkipper | |
GaudiTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line |
GaudiTest.RegexpReplacer | |
GaudiMP.pTools.FileRecordsAgent | |
Filter | |
GaudiKernel.ProcessJobOptions.LogFilter | |
Filter | |
GaudiTest.GaudiFilterExecutable | |
Containers::find< CONT > | |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::first | |
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first | |
ana.FirstSummary | |
Formatter | |
GaudiKernel.ProcessJobOptions.LogFormatter | |
FuncMinimum::FuncMinimumMisc | |
Gaudi | This is a number of static methods for bootstrapping the Gaudi framework |
GaudiDll | |
GaudiGSL | Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it |
GaudiHandleInfo | |
GaudiHandleArrayBase | Base class of array's of various gaudihandles |
GaudiHandleArray< T > | T is the concrete handle type, e.g |
GaudiHandleArray< ServiceHandle< T > > | |
ServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
GaudiHandleArray< ToolHandle< T > > | |
ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
GaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components |
GaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis |
ServiceHandle< T > | Handle to be used in lieu of naked pointers to services |
ToolHandle< T > | Handle to be used in lieu of naked pointers to tools |
GaudiHandle< IToolSvc > | |
ServiceHandle< IToolSvc > | |
Generator< TYPE > | |
GetData< TYPE > | |
Gaudi::Utils::GetData< TYPE > | Helper structure for implementation of "get"-functions for GaudiCommon<BASE> |
Gaudi::Utils::GetData< const TYPE > | Template specialization for const types |
Gaudi::Utils::GetData< TYPE & > | Template specialization for reference types |
Gaudi::Utils::GetData< TYPE * > | Template specialization for pointer types |
Gaudi::Utils::GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for named ranges |
Gaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > > | |
Gaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges |
Gaudi::Utils::GetData< Range > | |
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 > | Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE> |
Gaudi::Utils::GetOrCreateData< const TYPE, const TYPE2 > | |
Gaudi::Utils::GetOrCreateData< const TYPE, TYPE2 > | |
Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 & > | |
Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 > | |
Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 * > | |
Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 > | |
Gaudi::Utils::GetOrCreateData< TYPE, const TYPE2 > | |
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 & > | |
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 * > | |
Gaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 > | |
Gaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 > | |
Gaudi::Utils::GetOrCreateData< Range_, TYPE2 > | |
THistSvc::GlobalDirectoryRestore | |
GlobalDirectoryRestore | |
grammar | |
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are: |
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are: |
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are: |
Gaudi::Parsers::CharGrammar< RT > | The valid represenation of char values are: |
Gaudi::Parsers::CharGrammar< RT > | The valid represenation of char values are: |
Gaudi::Parsers::EdgeGrammar< Iterator, Skipper > | |
Gaudi::Parsers::FileGrammar< Iterator, Skipper > | |
Gaudi::Parsers::H1Grammar< Iterator, Skipper > | |
Gaudi::Parsers::H2Grammar< Iterator, Skipper > | |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper > | |
Gaudi::Parsers::IdentifierGrammar< Iterator, Skipper > | |
Gaudi::Parsers::IntGrammar< RT > | The valid representation of integers values are: |
Gaudi::Parsers::IntGrammar< RT > | The valid representation of integers values are: |
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper > | |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of map are: |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of map are: |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of pairs are: ("abc",123) or ("abc","def") Inner types of pair depends on KeyGrammarT and ValueGrammarT grammars |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of pairs are: ("abc",123) or ("abc","def") Inner types of pair depends on KeyGrammarT and ValueGrammarT grammars |
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper > | |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper > | |
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are: |
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are: |
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are: |
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments |
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments |
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments |
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are: |
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are: |
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are: |
Gaudi::Parsers::UnitsGrammar< Iterator, Skipper > | |
Gaudi::Parsers::VectorGrammar< GrammarT > | The valid represenation of vector are: |
Gaudi::Parsers::VectorGrammar< GrammarT > | The valid represenation of vector are: |
Gaudi::Parsers::IdentifierGrammar< Iterator, double > | |
Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > | |
Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > | |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > | |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > | |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > | |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > | |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > | |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > | |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable > | |
Gaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, Scalar, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, ScalarT, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type > | |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type > | |
Gaudi::Parsers::Grammar_< Iterator, typename MapT::key_type, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, typename MapT::mapped_type, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, typename PairT::first_type, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, typename PairT::second_type, Skipper > | |
Gaudi::Parsers::Grammar_< Iterator, typename VectorT::value_type, Skipper > | |
Genfun::GaudiMathImplementation::GSL_Helper | Simple structure to be used for adaption interface Genfun::AbsFunction to gsl_function structure |
GslError | Helper class to represent GSL errors |
Containers::hashmap | |
GaudiPython::Helper | |
HistogramSvc::Helper | |
Gaudi::Histo1DDef | Simple helper class for description of 1D-histogram The class is targeted to act as the primary "histogram property", but clearly have significantly wider application range |
GaudiMP.pTools.HistoAgent | |
GaudiPython::HistoDecorator | Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin |
GaudiPython.HistoUtils.HistoFile | |
Gaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc |
Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2 |
Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
Gaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
Gaudi::Generic2D< IHistogram2D, TH2D > | |
Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
Gaudi::Utils::HistoStats | The collection of trivial functions to access the statistical information for the histograms |
Gaudi::Utils::Histos::HistoStrings | Helepr class to produce "good" Reflex dictionries |
IAxis | |
Gaudi::Axis | An IAxis represents a binned histogram axis |
ibs_param_t | |
ibsfetchctl_t | |
ibsopctl_t | |
ibsopdata2_t | |
ibsopdata3_t | |
ibsopdata_t | |
IClassInfo | Data base class allowing to store persistent type information |
GaudiAlg::ID | ID class for Histogram and Ntuples |
Gaudi::IDataConnection | ABC describing basic data connection |
Gaudi::RootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files |
IDataStoreAgent | Generic data agent interface |
DataSelectionAgent | DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria |
GaudiMP::TESSerializer | |
HistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria |
OutputStreamAgent | |
StreamBuffer::IdentifiedLink | Definition of the contained link set |
IFileCatalog | |
extend_interfaces1< IFileCatalog > | |
implements1< IFileCatalog > | |
Gaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API for POOL |
extend_interfaces2< IFileCatalog, IFileCatalogMgr > | |
IFileCatalogMgr | |
extend_interfaces2< IFileCatalog, IFileCatalogMgr > | |
IgHookTrace | |
IgHookTraceAlloc | |
IgnoreError | |
IHistogram1D | |
Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
IHistogram3D | |
Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
IHistogramFactory | |
HistogramSvc | HistogramSvc class definition |
IInspectable | Interface definition of an inspectable object |
IInterface | Definition of the basic interface |
extend_interfaces1< IInterface > | |
implements1< IInterface > | |
EventSelectorDataStream | Definition of class EventSelectorDataStream |
Gaudi::IFileCatalog | File catalog interface |
Gaudi::IFileCatalogMgr | File catalog manager |
Gaudi::IIODataManager | |
Gaudi::ISignalMonitor | Interface for the service that monitors the occurrences of system signals |
extend_interfaces1< Gaudi::ISignalMonitor > | |
extends1< Service, Gaudi::ISignalMonitor > | |
Gaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor |
IAddressCreator | IAddressCreator interface definition |
extend_interfaces2< IConversionSvc, IAddressCreator > | |
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > | |
IAlgContextSvc | An abstract interface for Algorithm Context Service |
extend_interfaces2< IAlgContextSvc, IIncidentListener > | |
IAppMgrUI | Application Manager User Interface |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > | |
IChronoSvc | "Chrono"-related part of interface IChronoStatSvc |
extend_interfaces3< IService, IChronoSvc, IStatSvc > | |
IChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService |
extend_interfaces1< IChronoStatSvc > | |
extends1< Service, IChronoStatSvc > | |
ChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications |
IClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions |
extend_interfaces1< IClassManager > | |
implements1< IClassManager > | |
DLLClassManager | |
IConverter | The data converters are responsible to translate data from one representation into another |
extend_interfaces1< IConverter > | |
implements1< IConverter > | |
Converter | Converter base class |
Gaudi::RootConverter | Description: Definition of the ROOT data converter |
Gaudi::RootStatCnv | Description: Base class converter for N-tuples and related classes |
Gaudi::RootDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples |
Gaudi::RootDatabaseCnv | Statistics file converter class definition |
Gaudi::RootNTupleCnv | NTuple converter class definition for NTuples writted/read using ROOT |
RootHistCnv::RConverter | Root Converter |
RootHistCnv::DirectoryCnv | |
RootHistCnv::RDirectoryCnv | Create persistent and transient representations of data store directories |
RootHistCnv::RFileCnv | NTuple converter class definition |
RootHistCnv::RHistogramCnv< T, S, Q > | Generic converter to save/read AIDA_ROOT histograms using ROOT |
RootHistCnv::RNTupleCnv | NTuple converter class definition |
RootHistCnv::RCWNTupleCnv | Converter of Column-wise NTuple into ROOT format |
RootHistCnv::RRWNTupleCnv | Row wise NTuple converter class definition |
IConversionSvc | |
extend_interfaces2< IConversionSvc, IAddressCreator > | |
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > | |
ICounterSvc | Create / access multi purpose counters |
extend_interfaces1< ICounterSvc > | |
extends1< Service, ICounterSvc > | |
CounterSvc | Simple implementation of the abstract interface ICounterSvc |
IDataManagerSvc | |
extend_interfaces2< IDataProviderSvc, IDataManagerSvc > | |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
IDataProviderSvc | Data provider interface definition |
extend_interfaces2< IDataProviderSvc, IDataManagerSvc > | |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
IAIDATupleSvc | Definition of the IAIDATupleSvc interface class |
IHistogramSvc | Definition of the IHistogramSvc interface class |
extend_interfaces1< IHistogramSvc > | |
extends1< DataSvc, IHistogramSvc > | |
HistogramSvc | HistogramSvc class definition |
INTupleSvc | |
extend_interfaces2< INTupleSvc, IDataSourceMgr > | |
IDataSourceMgr | IDataSourceMgr interface definition |
extend_interfaces2< INTupleSvc, IDataSourceMgr > | |
IDetDataSvc |
|
extend_interfaces2< IDetDataSvc, IIncidentListener > | |
IEventProcessor | The IEventProcessor is the interface to process events |
extend_interfaces1< IEventProcessor > | |
extends1< Service, IEventProcessor > | |
MinimalEventLoopMgr | This is the default processing manager of the application manager |
EventLoopMgr | Class definition of EventLoopMgr |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > | |
IEvtSelector | The Event Selector Interface |
extend_interfaces1< IEvtSelector > | |
extends1< Service, IEvtSelector > | |
EventCollectionSelector | Definition of class EventCollectionSelector |
EventSelector | Definition of class EventSelector |
Gaudi::RootEvtSelector | Concrete event selector implementation to access ROOT files |
IExceptionSvc | The abstract interface for exception handling service |
extend_interfaces1< IExceptionSvc > | |
extends1< Service, IExceptionSvc > | |
ExceptionSvc | Simple implementation of IExceptionSvc abstract interface |
IFactory | The IFactory is the interface used to create contrete instances of Objectes |
IFileAccess | Abstract interface for a service or tool implementing a read access to files |
extend_interfaces1< IFileAccess > | |
extends1< AlgTool, IFileAccess > | |
FileReadTool | Basic implementation of the IFileAccess interface |
extends1< Service, IFileAccess > | |
VFSSvc | Simple service that allows to read files independently from the storage |
IInactiveMessageCounter | |
extend_interfaces2< IMessageSvc, IInactiveMessageCounter > | |
IIncidentListener | The interface implemented by any class wanting to listen to Incidents |
extend_interfaces1< IIncidentListener > | |
extends1< Auditor, IIncidentListener > | |
Google::AuditorBase | Base for Google Auditors |
Google::CPUProfiler | Auditor using the Google CPU Profiler |
Google::HeapChecker | Auditor using the Google Heap Checker |
Google::HeapProfiler | Auditor based on the Google Heap Profiler |
TimingAuditor | Simple auditor which uses SequencerTimerTool for ALL algorithms, including the algorithm from main Gaudi "TopAlg" list and algorithms managed by Data-On-Demand Service |
extends1< DataSvc, IIncidentListener > | |
RecordDataSvc | A RecordDataSvc is the base class for event services |
FileRecordDataSvc | A FileRecordDataSvc is the base class for event services |
RunRecordDataSvc | A RunRecordDataSvc is the base class for event services |
extends1< Service, IIncidentListener > | |
DataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName" |
Gaudi::Utils::StopSignalHandler | Service that stop the processing if a signal is received |
StalledEventMonitor | Service that monitor the time taken by processing of single events using a separate thread |
extend_interfaces2< IAlgContextSvc, IIncidentListener > | |
extend_interfaces2< IDataStoreLeaves, IIncidentListener > | |
extend_interfaces2< IDetDataSvc, IIncidentListener > | |
extend_interfaces2< IHistorySvc, IIncidentListener > | |
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > | |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > | |
Gaudi::RootPerfMonSvc | Description: |
IntelProfilerAuditor | |
IIncidentSvc | The interface implemented by the IncidentSvc service |
extend_interfaces1< IIncidentSvc > | |
extends1< Service, IIncidentSvc > | |
IncidentSvc | Default implementation of the IIncidentSvc interface |
IInspector | Inspector base class |
IJobOptionsSvc | Main interface for the JobOptions service |
extend_interfaces2< IProperty, IJobOptionsSvc > | |
IMessageSvc | The IMessage is the interface implemented by the message service |
extend_interfaces2< IMessageSvc, IInactiveMessageCounter > | |
IMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes |
INamedInterface | IInterface compliant class extending IInterface with the name() method |
IAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class |
extend_interfaces3< IAlgorithm, IProperty, IStateful > | |
IAlgTool | The interface implemented by the AlgTool base class |
extend_interfaces3< IAlgTool, IProperty, IStateful > | |
IDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store |
extend_interfaces2< IDataStoreLeaves, IIncidentListener > | |
IDataStreamTool | |
extend_interfaces1< IDataStreamTool > | |
extends1< AlgTool, IDataStreamTool > | |
DataStreamTool | |
IDODAlgMapper | Interface of tools used by the DataOnDemandSvc to choose the algorithm to be run to produce the data at a path |
extend_interfaces2< IDODAlgMapper, IDODNodeMapper > | |
IDODNodeMapper | Interface of tools used by the DataOnDemandSvc to choose the type of node to be created at a path |
extend_interfaces2< IDODAlgMapper, IDODNodeMapper > | |
IEqSolver | Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns) |
extend_interfaces1< IEqSolver > | |
extends1< GaudiTool, IEqSolver > | |
EqSolver | The simplest concrete implementation of IEqSolver interface |
IErrorTool | |
ErrorTool | |
IEventTimeDecoder | Interface that a Tool that decodes the event time has to implement |
IFuncMinimum | Interface file to find minimum of the function and compute covariance matrix (matrix of error) |
extend_interfaces1< IFuncMinimum > | |
extends1< GaudiTool, IFuncMinimum > | |
FuncMinimum | The simplest concrete implementation of IFuncMinimum interface |
IGenericTool | General purpose interface class for tools that "do something" |
IGslErrorHandler | The abstract interface for arbitrary GSL error handler |
extend_interfaces1< IGslErrorHandler > | |
extends1< AlgTool, IGslErrorHandler > | |
GslErrorCount | Concrete GSL error handler It is just counts number of GSL errors |
GslErrorException | Concrete GSL eror handler It is just thrown the exception |
GslErrorPrint | Concrete GSL eror handler It is just prints the GSL errors |
IHistoTool | An abstract interface for "histogramming tool" |
HistoTool | Simple tool for histogramming (component) |
ISequencerTimerTool | Implements the time measurement inside a sequencer |
SequencerTimerTool | Implements the time measurement inside a sequencer |
ITupleTool | |
TupleTool | |
IAuditor | The IAuditor is the interface implmented by the AlgAuditor base class |
extend_interfaces2< IAuditor, IProperty > | |
extend_interfaces2< IService, IAuditor > | |
IAuditorSvc | The interface implemented by the IAuditorSvc base class |
extend_interfaces1< IAuditorSvc > | |
extends1< Service, IAuditorSvc > | |
AuditorSvc | |
IIoComponent | |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > | |
IIoComponentMgr | |
extend_interfaces1< IIoComponentMgr > | |
extends1< Service, IIoComponentMgr > | |
IoComponentMgr | |
IService | General service interface definition |
extend_interfaces2< IService, IAuditor > | |
extend_interfaces3< IService, IChronoSvc, IStatSvc > | |
extend_interfaces3< IService, IProperty, IStateful > | |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > | |
ICounterSummarySvc | Simple service interface to collect counters to persist in a summary file |
IGslSvc | The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling |
extend_interfaces1< IGslSvc > | |
extends1< Service, IGslSvc > | |
GslSvc | The implementation of IGslSvc interface |
IHistorySvc | Definition of the IHistorySvc interface class |
extend_interfaces2< IHistorySvc, IIncidentListener > | |
IIssueLogger | |
extend_interfaces1< IIssueLogger > | |
extends1< Service, IIssueLogger > | |
IssueLogger | |
IMagneticFieldSvc | The interface to the MagneticFieldSvc |
IParticlePropertySvc | This class is an interface to the ParticlePropertySvc |
extend_interfaces1< IParticlePropertySvc > | |
extends1< Service, IParticlePropertySvc > | |
Gaudi::ParticlePropertySvc | This service provides access to particle properties |
IPartPropSvc | |
extend_interfaces1< IPartPropSvc > | |
extends1< Service, IPartPropSvc > | |
PartPropSvc | |
IRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions: |
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > | |
IStatusCodeSvc | |
extend_interfaces1< IStatusCodeSvc > | |
extends1< Service, IStatusCodeSvc > | |
StatusCodeSvc | |
ITHistSvc | |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > | |
IPartitionControl | Create / access partitions |
extend_interfaces1< IPartitionControl > | |
extends1< Algorithm, IPartitionControl > | |
PartitionSwitchAlg | Small algorith, which switches the partition of a configurable multi-service |
extends1< AlgTool, IPartitionControl > | |
PartitionSwitchTool | |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
IPersistencySvc | Data persistency service interface |
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > | |
IProperty | The IProperty is the basic interface for all components which have properties that can be set or get |
extend_interfaces1< IProperty > | |
implements1< IProperty > | |
PropertyMgr | Property manager helper class |
extend_interfaces2< IAuditor, IProperty > | |
extend_interfaces2< IProperty, IJobOptionsSvc > | |
extend_interfaces3< IAlgorithm, IProperty, IStateful > | |
extend_interfaces3< IAlgTool, IProperty, IStateful > | |
extend_interfaces3< IService, IProperty, IStateful > | |
IRndmEngine | Definition of a interface for a generic random number generator giving randomly distributed numbers in the range [0...1] number generators |
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > | |
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > | |
IRndmGen | Definition of a interface for a generic random number generators |
extend_interfaces1< IRndmGen > | |
implements1< IRndmGen > | |
RndmGen | Random Generator definition |
HepRndm::Generator< TYPE > | |
HepRndm::Generator< Rndm::DefinedPdf > | |
IRunable | Runable interface definition |
extend_interfaces1< IRunable > | |
extends1< Service, IRunable > | |
AppMgrRunable | Class definition of AppMgrRunable |
PythonScriptingSvc | This service handles scripting implemented using Python |
ISelectStatement | A select statement can either contain |
extend_interfaces1< ISelectStatement > | |
implements1< ISelectStatement > | |
SelectStatement | Class of a selection statement |
NTuple::Selector | NTuple Selector class |
ISerialize | Object serialization interface definition |
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > | |
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > | |
IStagerSvc | |
IStateful | Interface for classes that implement the Gaudi State Machine |
extend_interfaces3< IAlgorithm, IProperty, IStateful > | |
extend_interfaces3< IAlgTool, IProperty, IStateful > | |
extend_interfaces3< IService, IProperty, IStateful > | |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > | |
IComponentManager | |
extend_interfaces1< IComponentManager > | |
implements1< IComponentManager > | |
CommonMessaging< implements1< IComponentManager > > | |
ComponentManager | Base class for a component manager |
extends1< ComponentManager, IAlgManager > | |
AlgorithmManager | In charge of the creation of concrete instances of Algorithms |
extends2< ComponentManager, ISvcManager, ISvcLocator > | |
ServiceManager | In charge of the creation of concrete instances of Services |
IAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions |
extend_interfaces1< IAlgManager > | |
extends1< ComponentManager, IAlgManager > | |
ISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions |
extend_interfaces2< ISvcManager, ISvcLocator > | |
IStatSvc | "Stat"-related part of interface IChronoStatSvc |
extend_interfaces3< IService, IChronoSvc, IStatSvc > | |
ISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework |
extend_interfaces1< ISvcLocator > | |
implements1< ISvcLocator > | |
Gaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr |
extend_interfaces2< ISvcManager, ISvcLocator > | |
IToolSvc | The interface implemented by the IToolSvc base class |
extend_interfaces1< IToolSvc > | |
extends1< Service, IToolSvc > | |
ToolSvc | This service manages tools |
IUpdateableIF | |
IUpdateManagerSvc | Interface class to the Update Manager service |
IIODataManager | |
extend_interfaces1< IIODataManager > | |
extends1< Service, IIODataManager > | |
Gaudi::IODataManager | |
Incident | Base class for all Incidents (computing events) |
ContextIncident< T > | |
FileIncident | This class is the FileIncident |
ModuleIncident | Base class for Module-related incident |
ModuleLoadedIncident | Fired when a module (DLL) is loaded |
Gaudi::Parsers::IncludedFiles | |
IndefiniteIntegral | |
Integration | Collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral |
GaudiPython::Interface< TYPE > | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python |
InterfaceID | Interface ID class |
Gaudi::InterfaceId< INTERFACE, majVers, minVers > | Class to handle automatically the versioning of the interfaces when they are inheriting from other interfaces |
interfaceMatch< T > | Helper class for the cast used in the MPL for_each algorithm in the implementation of queryInterface |
INTuple | NTuple interface class definition |
NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation |
INTupleItem | NTuple interface class definition |
NTuple::_Data< bool > | |
NTuple::_Item< bool > | |
NTuple::_Data< IOpaqueAddress * > | |
NTuple::_Item< IOpaqueAddress * > | |
NTuple::_Data< TYP > | Abstract class describing basic data in an Ntuple |
NTuple::_Array< TYP > | Abstract class describing a column-array in a N tuple |
NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple |
NTuple::_DataImp< TYP > | Concrete class discribing basic data items in an N tuple |
NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple |
NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple |
NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple |
NTuple::_Item< TYP > | Abstract class describing a column in a N tuple |
NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple |
NTuple::_Matrix< TYP > | Abstract class describing a matrix column in a N tuple |
NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple |
System::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters |
IIoComponentMgr::IoMode | |
IOpaqueAddress | Opaque address interface definition |
GenericAddress | Generic Transient Address |
Gaudi::RootAddress | Description: |
RootHistCnv::RootObjAddress | |
IProfile1D | |
Gaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
IProfile2D | |
Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
IRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded |
DataSvcHelpers::RegistryEntry | Definition of an entry in the transient data store |
IssueSeverity | |
Item< TYP > | |
Tuples::ItemStore< VALUE > | Simple class, which represents the local storage of N-tuple items of the given type |
IUpdateable | Object update interface definition |
IUpdateableIF | |
IUpdateableInterface | Component interface counterpart to the above ABC |
IValidity | Interface for objects with a validity |
IInspector::IValue | |
IInspector::_V< T > | |
IVersHistoryObj | Interface for Versioned History Objects |
AlgorithmHistory | AlgorithmHistory class definition |
AlgToolHistory | AlgToolHistory class definition |
JobHistory | JobHistory class definition |
ServiceHistory | ServiceHistory class definition |
GaudiKernel.ProcessJobOptions.JobOptsParser | |
System::KERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes |
key_compare | |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type | The actual structure used to compare the elements Only "key" is important for comparison |
key_traits< KEY > | Key traits class |
Containers::key_traits< KEY > | Definition of the key traits class |
Containers::key_traits< DATATYPE::key_type > | |
Containers::traits< CONTAINER, DATATYPE > | Definition of the container traits class |
KeyedContainerDict< T > | |
KeyedObjectDict< T > | |
Containers::KeyedObjectManager< SETUP > | KeyedObjectManager Class to manage keyed objects |
DataOnDemandSvc::Leaf | |
StoreSnifferAlg::LeafInfo | |
LinkManager::Link | Embedded class defining a symbolic link Note: No copy constructor; bitwise copy (done by the compiler) is just fine |
LinkManager | A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links |
linux_proc | |
list | |
GaudiKernel.GaudiHandles.GaudiHandleArray | |
GaudiKernel.GaudiHandles.PrivateToolHandleArray | |
GaudiKernel.GaudiHandles.PublicToolHandleArray | |
GaudiKernel.GaudiHandles.ServiceHandleArray | |
IncidentSvc::Listener | |
Gaudi::Utils::LockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g |
install.LogFile | |
Lomont< TYPE > | |
Lomont | The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP) |
GaudiMP.pTools.LumiFSR | |
Containers::map | |
Gaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi |
GaudiUtils::Map< K, T, M > | Extension of the STL map |
GaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map |
GaudiUtils::HashMap< const void *, EntryType > | |
GaudiUtils::HashMap< Gaudi::StringKey, Leaf > | |
GaudiUtils::HashMap< Gaudi::StringKey, ListenerList * > | |
GaudiUtils::HashMap< Gaudi::StringKey, Node > | |
GaudiUtils::HashMap< long, void * > | |
GaudiUtils::HashMap< std::string, Address * > | |
GaudiUtils::HashMap< std::string, Bool * > | |
GaudiUtils::HashMap< std::string, Char * > | |
GaudiUtils::HashMap< std::string, Double * > | |
GaudiUtils::HashMap< std::string, FArray * > | |
GaudiUtils::HashMap< std::string, Float * > | |
GaudiUtils::HashMap< std::string, FMatrix * > | |
GaudiUtils::HashMap< std::string, Gaudi::Utils::TypeNameString > | |
GaudiUtils::HashMap< std::string, IFileAccess * > | |
GaudiUtils::HashMap< std::string, Int * > | |
GaudiUtils::HashMap< std::string, int > | |
GaudiUtils::HashMap< std::string, LongLong * > | |
GaudiUtils::HashMap< std::string, NameMap > | |
GaudiUtils::HashMap< std::string, NTuple::Item< VALUE > * > | |
GaudiUtils::HashMap< std::string, Short * > | |
GaudiUtils::HashMap< std::string, SmartIF< IService > > | |
GaudiUtils::HashMap< std::string, std::string > | |
GaudiUtils::HashMap< std::string, UChar * > | |
GaudiUtils::HashMap< std::string, UInt * > | |
GaudiUtils::HashMap< std::string, ULongLong * > | |
GaudiUtils::HashMap< std::string, UShort * > | |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu |
GaudiUtils::Map< const void *, EntryType, __gnu_cxx::hash_map< const void *, EntryType, Hash< const void * > > > | |
GaudiUtils::Map< Gaudi::StringKey, Leaf, __gnu_cxx::hash_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > > | |
GaudiUtils::Map< Gaudi::StringKey, ListenerList *, __gnu_cxx::hash_map< Gaudi::StringKey, ListenerList *, Hash< Gaudi::StringKey > > > | |
GaudiUtils::Map< Gaudi::StringKey, Node, __gnu_cxx::hash_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > > | |
GaudiUtils::Map< InterfaceID, SmartIF< IInterface > > | |
GaudiUtils::Map< long, void *, __gnu_cxx::hash_map< long, void *, Hash< long > > > | |
GaudiUtils::Map< std::string, Address *, __gnu_cxx::hash_map< std::string, Address *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Bool *, __gnu_cxx::hash_map< std::string, Bool *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Char *, __gnu_cxx::hash_map< std::string, Char *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Double *, __gnu_cxx::hash_map< std::string, Double *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, FArray *, __gnu_cxx::hash_map< std::string, FArray *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Float *, __gnu_cxx::hash_map< std::string, Float *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, FMatrix *, __gnu_cxx::hash_map< std::string, FMatrix *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Gaudi::Utils::TypeNameString, __gnu_cxx::hash_map< std::string, Gaudi::Utils::TypeNameString, Hash< std::string > > > | |
GaudiUtils::Map< std::string, IFileAccess *, __gnu_cxx::hash_map< std::string, IFileAccess *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Int *, __gnu_cxx::hash_map< std::string, Int *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, int, __gnu_cxx::hash_map< std::string, int, Hash< std::string > > > | |
GaudiUtils::Map< std::string, LongLong *, __gnu_cxx::hash_map< std::string, LongLong *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, NameMap, __gnu_cxx::hash_map< std::string, NameMap, Hash< std::string > > > | |
GaudiUtils::Map< std::string, NTuple::Item< VALUE > *, __gnu_cxx::hash_map< std::string, NTuple::Item< VALUE > *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, Short *, __gnu_cxx::hash_map< std::string, Short *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, SmartIF< IService >, __gnu_cxx::hash_map< std::string, SmartIF< IService >, Hash< std::string > > > | |
GaudiUtils::Map< std::string, std::string > | |
GaudiUtils::Map< std::string, std::string, __gnu_cxx::hash_map< std::string, std::string, Hash< std::string > > > | |
GaudiUtils::Map< std::string, UChar *, __gnu_cxx::hash_map< std::string, UChar *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, UInt *, __gnu_cxx::hash_map< std::string, UInt *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, ULongLong *, __gnu_cxx::hash_map< std::string, ULongLong *, Hash< std::string > > > | |
GaudiUtils::Map< std::string, UShort *, __gnu_cxx::hash_map< std::string, UShort *, Hash< std::string > > > | |
GaudiUtils::VectorMap< const INamedInterface *, int > | |
Matrix< TYP > | |
NTuple::Matrix< IOpaqueAddress * > | |
MEMORY_MAPPED_FILE | |
Message | The Message class |
Gaudi::Parsers::Messages | |
MessageSvc::MsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL) |
MsgStream | Definition of the MsgStream class used to transmit messages |
NamedRange | New concept of "named" range : range with name |
DataOnDemandSvc::Node | Helper class of the DataOnDemandSvc |
Gaudi::Parsers::Node | |
Gaudi::Parsers::NodeOperations | |
NTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! It's only used for the ntuple service |
Rndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator |
object | |
cmt2cmake.Package | |
test_cmt2cmake.PackWrap | |
cmt2cmake.Project | |
test_cmt2cmake.ProjWrap | |
EnvConfig.TestEnvOps.TempDir | |
EnvConfig.Variable.VariableBase | |
EnvConfig.Variable.List | |
EnvConfig.Variable.Scalar | |
EnvConfig.Variable.VariableProcessor | |
EnvConfig.Variable.EnvExpander | |
EnvConfig.Variable.ListProcessor | |
EnvConfig.Variable.DuplicatesRemover | |
EnvConfig.Variable.EmptyDirsRemover | |
EnvConfig.Variable.UsePythonZip | |
EnvConfig.Variable.PathNormalizer | |
EnvConfig.Variable.ScalarProcessor | |
Gaudi._ConfigurablesModule | Small class that allows to access all the configurables as attributes of the instance |
Gaudi.Main.gaudimain | |
GaudiKernel.Configurable.Configurable | |
GaudiKernel.Configurable.ConfigurableAlgorithm | |
GaudiKernel.Configurable.ConfigurableAlgTool | |
GaudiKernel.Configurable.ConfigurableAuditor | |
GaudiKernel.Configurable.ConfigurableGeneric | |
GaudiKernel.Configurable.ConfigurableService | |
GaudiKernel.Configurable.ConfigurableUser | |
Gaudi.Configuration.GaudiPersistency | |
GaudiKernel.Configurable.DummyDescriptor | If isinstance(v,Configurable) and not v.isPublic(): rep += v.__str__( indent + 1 ) + os.linesep elif isinstance(v,GaudiHandleArray): for vi in v: if isinstance(vi,Configurable) and not vi.isPublic(): rep += vi.__str__( indent + 1 ) + os.linesep |
GaudiKernel.Configurable.PropertyReference | Allow references to options as in old style |
GaudiKernel.ConfigurableDb._Singleton | |
GaudiKernel.GaudiHandles.GaudiHandle | |
GaudiKernel.GaudiHandles.PrivateToolHandle | |
GaudiKernel.GaudiHandles.PublicToolHandle | |
GaudiKernel.GaudiHandles.ServiceHandle | |
GaudiKernel.PropertyProxy.PropertyProxy | |
GaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase | |
GaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy | |
GaudiKernel.PropertyProxy.GaudiHandlePropertyProxy | |
GaudiMP.GMPBase.Coord | |
GaudiMP.GMPBase.EventCommunicator | |
GaudiMP.GMPBase.GMPComponent | |
GaudiMP.GMPBase.Reader | |
GaudiMP.GMPBase.Worker | |
GaudiMP.GMPBase.Writer | |
GaudiMP.GMPBase.MiniWriter | |
GaudiMP.GMPBase.TESSerializer | |
GaudiMP.IoRegistry.IoRegistry | |
GaudiMP.Parallel.SshSession | |
GaudiMP.Parallel.Statistics | |
GaudiMP.Parallel.Task | |
GaudiMP.Parallel.WorkManager | |
GaudiMP.pTools.Syncer | |
GaudiMP.pTools.SyncMini | |
GaudiPython.Bindings.InterfaceCast | |
GaudiPython.Bindings.Interface | |
GaudiPython.Bindings.iProperty | |
GaudiPython.Bindings.iAlgorithm | |
GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm |
GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming |
GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples |
GaudiPython.Bindings.iAlgTool | |
GaudiPython.Bindings.iService | |
GaudiPython.Bindings.AppMgr | |
GaudiPython.Bindings.iDataSvc | |
GaudiPython.Bindings.iHistogramSvc | |
GaudiPython.Bindings.iNTupleSvc | |
GaudiPython.Bindings.iEventSelector | |
GaudiPython.Bindings.iJobOptSvc | |
GaudiPython.Bindings.iToolSvc | |
GaudiPython.Bindings.PropertyEntry | |
GaudiPython.GaudiAlgs.objectmethod | |
GaudiPython.Persistency.FileDescription | |
GaudiPython.Persistency.PersistencyHelper | |
GaudiPython.Persistency.RootPersistency | |
gaudirun.FakeModule | |
locker.LockFile | Lock a file |
make_heptools.HepToolsGenerator | |
pyparsing._Constants | |
pyparsing._NullToken | |
pyparsing._ParseResultsWithOffset | |
pyparsing.OnlyOnce | |
pyparsing.ParserElement | |
pyparsing.ParseElementEnhance | |
pyparsing.FollowedBy | |
pyparsing.Forward | |
pyparsing._ForwardNoRecurse | |
pyparsing.NotAny | |
pyparsing.OneOrMore | |
pyparsing.Optional | |
pyparsing.SkipTo | |
pyparsing.TokenConverter | |
pyparsing.Combine | |
pyparsing.Dict | |
pyparsing.Group | |
pyparsing.Suppress | |
pyparsing.Upcase | |
pyparsing.ZeroOrMore | |
pyparsing.ParseExpression | |
pyparsing.And | |
pyparsing.Each | |
pyparsing.MatchFirst | |
pyparsing.Or | |
pyparsing.Token | |
pyparsing._PositionToken | |
pyparsing.GoToColumn | |
pyparsing.LineEnd | |
pyparsing.LineStart | |
pyparsing.StringEnd | |
pyparsing.StringStart | |
pyparsing.WordEnd | |
pyparsing.WordStart | |
pyparsing.CharsNotIn | |
pyparsing.Empty | |
pyparsing.And._ErrorStop | |
pyparsing.Keyword | |
pyparsing.CaselessKeyword | |
pyparsing.Literal | |
pyparsing.CaselessLiteral | |
pyparsing.NoMatch | |
pyparsing.QuotedString | |
pyparsing.Regex | |
pyparsing.White | |
pyparsing.Word | |
pyparsing.ParseResults | |
run_qmtest.Options | |
validate_patch.PatchData | |
validate_patch.TempDir | |
SmartDataObjectPtr::ObjectFinder | Helper class to configure smart pointer functionality |
SmartDataObjectPtr::ObjectLoader | Helper class to configure smart pointer functionality |
IToolSvc::Observer | Allow call-backs when a tool is a created or retrieved |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations | |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations | |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations | |
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations | |
GaudiMP.pTools.PackedCaloHypo | |
IRndmGen::Param | |
Rndm::Binomial | Parameters for the Binomial distributed random number generation |
Rndm::Bit | Parameters for the bit value generation: returns values 0 and 1 |
Rndm::BreitWigner | Parameters for the BreitWigner distributed random number generation |
Rndm::BreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off; |
Rndm::Chi2 | Parameters for the Chi2 distributed random number generation |
Rndm::DefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function |
Rndm::Exponential | Parameters for the Gauss random number generation |
Rndm::Flat | Parameters for the flat random number generation within boundaries [minimum, maximum] |
Rndm::Gamma | Parameters for the Gamma distributed random number generation |
Rndm::Gauss | Parameters for the Gauss random number generation |
Rndm::GaussianTail | Parameters for the Gaussian tail number generation |
Rndm::Landau | Parameters for the Landau distributed random number generation |
Rndm::Poisson | Parameters for the Poisson distributed random number generation with a given mean |
Rndm::StudentT | Parameters for the StudentT distributed random number generation |
ParticleProperty | A trivial class to hold information about a single particle properties |
System::PathResolver | |
pentium4_cccr_value_t | Pentium4_cccr_value_t |
pentium4_escr_value_t | |
pfarg_ctx_t | |
pfarg_load_t | |
pfarg_msg_t | |
pfarg_ovfl_msg_t | |
pfarg_pmc_t | |
pfarg_pmd_attr_t | |
pfarg_pmd_t | |
pfarg_pmr_t | |
pfarg_set_desc_t | |
pfarg_set_info_t | |
pfarg_setdesc_t | |
pfarg_setinfo_t | |
pfarg_sinfo_t | |
pfarg_start_t | |
pfm_amd64_ctr_reg_t | |
pfm_amd64_sel_reg_t | |
pfm_core_sel_reg_t | |
pfm_coreduo_counter_t | |
pfm_coreduo_sel_reg_t | |
pfm_dfl_smpl_arg_t | |
pfm_dfl_smpl_entry_t | |
pfm_dfl_smpl_hdr_t | |
pfm_ds_area_core_t | |
pfm_ds_area_p4_t | |
pfm_gen_ia32_sel_reg_t | |
pfm_i386_p6_ctr_reg_t | |
pfm_i386_p6_sel_reg_t | |
pfm_intel_atom_sel_reg_t | |
pfm_nhm_sel_reg_t | |
pfm_pebs_core_smpl_arg_t | |
pfm_pebs_core_smpl_entry_t | |
pfm_pebs_core_smpl_hdr_t | |
pfm_pebs_nhm_smpl_entry_t | |
pfm_pebs_p4_smpl_arg_t | |
pfm_pebs_p4_smpl_entry_t | |
pfm_pebs_p4_smpl_hdr_t | |
pfm_pebs_smpl_arg_t | |
pfm_pebs_smpl_hdr_t | |
PfmCodeAnalyser | |
pfmlib_amd64_counter_t | |
pfmlib_amd64_input_param_t | |
pfmlib_amd64_output_param_t | |
pfmlib_core_counter_t | |
pfmlib_core_input_param_t | |
pfmlib_core_output_param_t | |
pfmlib_core_pebs_t | |
pfmlib_coreduo_input_param_t | |
pfmlib_event_t | |
pfmlib_gen_ia32_counter_t | |
pfmlib_gen_ia32_input_param_t | |
pfmlib_gen_ia32_output_param_t | |
pfmlib_i386_p6_counter_t | |
pfmlib_i386_p6_input_param_t | |
pfmlib_i386_p6_output_param_t | |
pfmlib_input_param_t | |
pfmlib_intel_atom_counter_t | |
pfmlib_intel_atom_input_param_t | |
pfmlib_nhm_counter_t | |
pfmlib_nhm_input_param_t | |
pfmlib_nhm_lbr_t | |
pfmlib_nhm_pebs_t | |
pfmlib_options_t | |
pfmlib_output_param_t | |
pfmlib_reg_t | |
pfmlib_regmask_t | |
PipeReader | |
GaudiUtils::AllocatorPool::PoolChunk | |
PoolDbLinkManager | Description: PoolDbLinkManager class implementation definition |
PoolDbTokenWrap | Description: |
System::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits |
GaudiUtils::AllocatorPool::PoolLink | |
Gaudi::Parsers::Position | |
PositionVector3D< CoordSystem, Tag > | |
Gaudi::Parsers::PragmaOptions | |
GaudiAlg::Print | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiAlg::Print1D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiAlg::Print1DProf | Collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiAlg::Print2D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiAlg::Print2DProf | Collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiAlg::Print3D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
GaudiPython::Printer< TYPE > | |
GaudiPython::Printer< ContainedObject > | |
GaudiPython::Printer< DataObject > | |
ICounterSvc::Printout | Print counters for each element in the range [first, last) e.g |
GaudiAlg::PrintStat | Collection of useful utilities to print StatEntity (currently used for implementation of class GaudiAlgorithm and class GaudiTool) |
GaudiAlg::PrintTuple | Collection of useful utilities to print INTuple object (currently used for implementation of class GaudiTupleAlg and class GaudiTupleTool) |
System::PROCESS_BASIC_INFORMATION | |
System::ProcessDescriptor | Provides access to process information |
System::ProcessDescriptor::ProcessHandle | |
System::ProcessTime | Simple class to hold the time information of a process |
procInfo | |
ProcStats | |
Property | Property base class allowing Property* collections to be "homogeneous" |
GaudiHandleArrayProperty | |
GaudiHandleProperty | |
PropertyList | List of properties |
PropertyWithValue< TYPE > | Helper intermediate class which represent partly implemented property with value of concrete type |
PropertyWithVerifier< TYPE, VERIFIER > | Helper intermediate class which represent partly implemented property with value of concrete type and concrete verifier |
SimpleProperty< TYPE, VERIFIER > | SimpleProperty concrete class which implements the full Property interface |
SimpleProperty< bool > | |
SimpleProperty< double > | |
SimpleProperty< int > | |
SimpleProperty< std::string > | |
CommandProperty | Command property base class (abstract) |
SimpleProperty< std::vector< std::string > > | |
SimpleProperty< unsigned int > | |
SimplePropertyRef< TYPE, VERIFIER > | SimplePropertyRef templated class |
PropertyWithValue< bool > | |
PropertyWithVerifier< bool, VERIFIER > | |
PropertyWithValue< double > | |
PropertyWithVerifier< double, VERIFIER > | |
PropertyWithValue< int > | |
PropertyWithVerifier< int, VERIFIER > | |
PropertyWithValue< std::string > | |
PropertyWithVerifier< std::string, VERIFIER > | |
PropertyWithValue< std::vector< std::string > > | |
PropertyWithVerifier< std::vector< std::string >, VERIFIER > | |
PropertyWithValue< unsigned int > | |
PropertyWithVerifier< unsigned int, VERIFIER > | |
Gaudi::Parsers::Property | |
PropertyCallbackFunctor | |
PropertyCallbackMemberFunctor< T > | |
PropertyCallbackPointerFunctor | |
Gaudi::Parsers::PropertyName | |
Gaudi::Utils::PropertyTypeTraits< TYPE > | Helper structure to define the types for properties |
Gaudi::Utils::PropertyTypeTraits< T[N]> | Specialization for arrays |
Gaudi::Utils::PropertyTypeTraits< boost::array< T, N > > | Specialization of property-traits for class boost::array to take care the non-trivial assignements and constructors for this class |
Gaudi::Utils::PropertyTypeTraits< char(&)[N]> | Specialisation for C-strings |
Gaudi::Utils::PropertyTypeTraits< const T(&)[N]> | Specialiation for const-arrays |
Gaudi::Utils::PropertyTypeTraits< T(&)[N]> | |
Gaudi::Utils::PropertyTypeTraits< T(&)[N]> | |
Gaudi::Parsers::PropertyValue | |
PropertyVerifier< T > | Templated Verifier base class |
BoundedVerifier< TYPE > | |
NullVerifier< TYPE > | Default, always true verifier |
PropertyVerifier< T[N]> | |
BoundedVerifier< T[N]> | Specialization of Bounded verifier for for C-arrays |
DataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc |
PyAlgorithm | |
Test.PhysAnalAlg | |
PyAlgorithm | |
AnalysisInit.PhysAnalAlg | |
GaudiMP::PyROOTPickle | |
IUpdateManagerSvc::PythonHelper | Helper class implemented in the python dictionary to allow access from python to template member functions |
System::QUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits |
NTuple::Range< TYP > | Class defining a range |
Range< TYP > | |
NTuple::Range< bool > | |
Gaudi::RangeBase_ | Helper class to simplify the dealing with ranges in Python |
Gaudi::Range_< CONTAINER > | Useful class for representation of "sequence" of the objects through the range of valid iterators |
Gaudi::NamedRange_< TYPE > | |
Gaudi::Range_< TYPE > | |
GaudiUtils::Allocator< Type >::rebind< U > | |
GaudiRoot::RefAccessor | |
GaudiTest.ReferenceFileValidator | |
EnvConfig.xmlModule.Report | |
Gaudi::Parsers::NodeOperations::result< A, B, C, D > | |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations::result< A, B, C, D > | |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > | |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations::result< A, B, C, D > | |
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > | |
RootConnectionSet | Class describing the setup parameters of a ROOT data connection |
Gaudi::RootConnectionSetup | |
Gaudi::RootNTupleDescriptor | Description: |
Gaudi::RootObjectRefs | Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject |
Gaudi::RootRef | Persistent reference object |
RuntimeError | |
env.EnvError | |
GaudiKernel.Configurable.Error | |
GaudiKernel.ProcessJobOptions.ParserError | |
GaudiPython.Persistency.PersistencyError | |
GaudiPython.Persistency.UnknownPersistency | |
ZipPythonDir.ZipdirError | Class for generic exception coming from the zipdir() function |
S_module | |
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second | |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::second | |
PersistencySvc::ServiceEntry | |
ServiceManager::ServiceItem | |
ServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes $Id: |
SmartDataObjectPtr | A small class used to access easily (and efficiently) data items residing in data stores |
SmartDataStorePtr< TYPE, LOADER > | A small class used to access easily (and efficiently) data items residing in data stores |
SmartDataStorePtr< TYPE, SmartDataObjectPtr::ObjectLoader > | |
SmartDataLocator< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores |
SmartDataPtr< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores |
SmartIF< T > | Small smart pointer class with automatic reference counting for IInterface |
SmartIF< Gaudi::ISignalMonitor > | |
SmartIF< IAddressCreator > | |
SmartIF< IAlgContextSvc > | |
SmartIF< IAlgManager > | |
SmartIF< IAlgorithm > | |
SmartIF< IAppMgrUI > | |
SmartIF< IAuditorSvc > | |
SmartIF< IChronoStatSvc > | |
SmartIF< IConversionSvc > | |
SmartIF< IDataManagerSvc > | |
SmartIF< IDataProviderSvc > | |
SmartIF< IEventProcessor > | |
SmartIF< IEvtSelector > | |
SmartIF< IExceptionSvc > | |
SmartIF< IFileCatalog > | |
SmartIF< IHistogramSvc > | |
SmartIF< IIncidentListener > | |
SmartIF< IIncidentSvc > | |
SmartIF< IInterface > | |
SmartIF< IJobOptionsSvc > | |
SmartIF< IMessageSvc > | |
SmartIF< IMonitorSvc > | |
SmartIF< INTupleSvc > | |
SmartIF< IPartitionControl > | |
SmartIF< IProperty > | |
SmartIF< IRndmGenSvc > | |
SmartIF< IRunable > | |
SmartIF< IService > | |
SmartIF< IStateful > | |
SmartIF< ISvcLocator > | |
SmartIF< ISvcManager > | |
SmartIF< IToolSvc > | |
SmartRef< TYPE > | Kernel objects: SmartRef |
SmartRef< ContainedObject > | |
SmartRef< DataObject > | |
SmartRef< KeyType > | |
SmartRefArray< TYPE > | |
SmartRefBase | User example objects: SmartRefBase |
SmartRefList< TYPE > | |
SmartRefMap< TYPE > | |
Genfun::GaudiMathImplementation::SplineBase | |
IntelProfilerAuditor::stack_entity | |
Stat | Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface |
StatusCodeSvc::StatCodeDat | |
StatEntity | The basic counter used for Monitoring purposes |
StatusCode | This class is used for returning status codes from appropriate routines |
ana.Step | |
StreamBuffer | The stream buffer is a small object collecting object data |
StreamHandler | |
GaudiKernel.ProcessJobOptions.ConsoleHandler | |
StreamLogger | |
Gaudi::StringKey | The helper class to represent the efficient "key" for access |
ana.Summary | |
SvcCatalog | |
SvcFactory< TYPE > | |
Gaudi::SysProcStat | |
Gaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables |
IInspector::Tag | |
IInspector::_TT< T > | |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_key | |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_mapped | |
MultiStoreSvc::tagROOT | |
TClassStreamer | |
GaudiRoot::IOHandler< T > | |
GaudiTest.TempDir | |
GaudiTest.TempFile | |
GaudiTest.TemporaryEnvironment | Utility Classes |
TestCase | |
EnvConfig.TestEnvOps.Test | |
EnvConfig.TestXMLOps.Test | |
THistSvc::THistID | |
ThreadGaudi | Singleton mapping the pthread ID to the Gaudi thread ID |
Gaudi::Time | Based on seal::Time |
TimerForSequencer | Auxilliary class |
Gaudi::TimeSpan | Based on seal::TimeSpan |
pool::Token | Shadow class to mimik POOL tokens |
Tokenizer::Token | Definition of the sub-class Token |
Tokenizer | STL Include files |
Gaudi::RootDataConnection::Tool | Helper class to facilitate an abstraction layer for reading POOL style files with this package |
Gaudi::PoolTool | |
Gaudi::RootTool | Description: |
ToolFactory< TOOL > | Forward declaration |
ToolHandleInfo | General info and helper functions for toolhandles and arrays |
ToolHandle< T > | Handle to be used in lieu of naked pointers to tools |
ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
traits< CONTAINER, DATATYPE > | Container traits class |
Tuples::Tuple | A simple wrapper class over standard Gaudi NTuple::Tuple facility |
GaudiPython::TupleAlgDecorator | Simple class to perform the "decoration" of Tuples in Python/Reflex |
Tuples::TupleColumn< ITEM > | Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects |
GaudiPython::TupleDecorator | Simple class which performs the decoration of the standard N-Tuple |
TupleItem< ITEM > | |
Tuples::TupleObj | A simple wrapper class over standard Gaudi NTuple::Tuple facility |
Tuples::detail::TupleObjImp< HANDLER1, HANDLER2 > | The simplest concrete implementation of class TupleObj with 3 arbitrary error handlers Any types (classes, functions, etc.) which supports the semantics |
GaudiPython::TupleToolDecorator | Simple class to perform the "decoration" of Tuples in Python/Reflex |
type | |
GaudiKernel.ConfigurableMeta.ConfigurableMeta | This metaclass installs PropertyProxy descriptors for Gaudi properties |
Gaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name" |
UCharDbArray | Shadow class to mimik POOL blobs |
std::unary_function< _Arg, _Result > [external] | |
FindByMassRange | The function object must be derived from std::unary_function< IParticlePropertySvc::value_type ,bool > IParticlePropertySvc::value_type is a typedef that defines the internal service storage type that is returned when an iterator is dereferenced |
std::unary_function< ARGUMENT, RESULT > [external] | |
Tuples::_TupAdapter< OBJECT, ARGUMENT, RESULT > | Trivial adapter to avoid the GCC problem (pointer to the function is never evaluated as "const TYPE&" ) |
std::unary_function< const IInterface *, IInterface * > [external] | |
GaudiPython::Interface< IInterface > | |
std::unary_function< const path &, bool > [external] | |
DirSearchPath::eqPath | Name |
std::unary_function< const T *, std::size_t > [external] | |
GaudiUtils::Hash< T * > | Partial specialization for pointers |
GaudiUtils::Hash< const T * > | Remove extra qualifiers: |
std::unary_function< const T(&)[N], std::size_t > [external] | |
GaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays |
std::unary_function< Property, bool > [external] | |
Gaudi::Parsers::Property::Equal | |
std::unary_function< T(&)[N], std::size_t > [external] | |
GaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays |
std::unary_function< T, std::size_t > [external] | |
GaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class) |
GaudiUtils::Hash< T > | Simple hash function |
GaudiUtils::Hash< const T & > | Remove extra qualifiers: |
GaudiUtils::Hash< const T > | Remove extra qualifiers: |
GaudiUtils::Hash< T & > | Remove extra qualifiers: |
std::unary_function< TYPE, TYPE > [external] | |
GaudiPython::_identity< TYPE > | It is here due to 'missing'(?) std::identity |
std::unary_function< WorkerEntry, bool > [external] | |
ConversionSvc::CnvTest | |
Gaudi::Parsers::Units | |
Gaudi::Parsers::NodeOperations::value | |
Containers::vector | |
Containers::vector< void * > | |
System::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters |
WatchdogThread | Simple class for asynchronous check of time-out |
ConversionSvc::WorkerEntry | |
EnvConfig.xmlModule.XMLFile | |
EnvConfig.xmlModule.XMLOperations | |
BASE | |
CommonMessaging< BASE > | Templated class to add the standard messaging functionalities |
extends1< BASE, I1 > | Base class used to extend a class implementing other interfaces |
extends2< BASE, I1, I2 > | Base class used to extend a class implementing other interfaces |
extends3< BASE, I1, I2, I3 > | Base class used to extend a class implementing other interfaces |
ExecTestBase | |
GaudiTest.GaudiExeTest | |
HTMLParser | |
validate_patch.SavannahParser | Parse the |
I1 | |
extend_interfaces1< I1 > | Base class to be used to extend an interface |
extends1< BASE, I1 > | Base class used to extend a class implementing other interfaces |
implements1< I1 > | Base class used to implement the interfaces |
extend_interfaces2< I1, I2 > | Base class to be used to extend an interface |
extends2< BASE, I1, I2 > | Base class used to extend a class implementing other interfaces |
extends2< AlgTool, IDataStoreLeaves, IIncidentListener > | |
DataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file) |
extends2< AlgTool, IDODAlgMapper, IDODNodeMapper > | |
DODBasicMapper | Default implementation of a DataOnDemand mapper |
extends2< ComponentManager, ISvcManager, ISvcLocator > | |
extends2< DataSvc, IDetDataSvc, IIncidentListener > | |
DetDataSvc |
|
extends2< DataSvc, INTupleSvc, IDataSourceMgr > | |
NTupleSvc | NTuple service |
TagCollectionSvc | Gaudi tag collection service definition |
extends2< Service, IAlgContextSvc, IIncidentListener > | |
AlgContextSvc | |
extends2< Service, IConversionSvc, IAddressCreator > | |
ConversionSvc | Base class for all conversion services |
Gaudi::RootCnvSvc | Description: |
RootHistCnv::PersSvc | Persistency service - to store histograms in ROOT format |
extends2< Service, IDataProviderSvc, IDataManagerSvc > | |
DataSvc | Data service base class |
EvtDataSvc | A EvtDataSvc is the base class for event services |
extends1< DataSvc, IHistogramSvc > | |
extends1< DataSvc, IIncidentListener > | |
extends2< DataSvc, IDetDataSvc, IIncidentListener > | |
extends2< DataSvc, INTupleSvc, IDataSourceMgr > | |
extends2< Service, IFileCatalog, IFileCatalogMgr > | |
Gaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi |
extends2< Service, IHistorySvc, IIncidentListener > | |
HistorySvc | HistorySvc class definition |
extends2< Service, IMessageSvc, IInactiveMessageCounter > | |
MessageSvc | |
extends2< Service, IProperty, IJobOptionsSvc > | |
JobOptionsSvc | |
implements2< I1, I2 > | Base class used to implement the interfaces |
implements2< IAuditor, IProperty > | |
Auditor | Base class from which all concrete auditor classes should be derived |
AlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it |
AlgErrorAuditor | Monitors the cpu time usage of each algorithm |
CommonAuditor | Base class with common functionalities shared by few auditor implementations |
ChronoAuditor | Monitors the cpu time usage of each algorithm |
MemoryAuditor | Monitors the memory use of each algorithm |
MemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed |
NameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it |
extends1< Auditor, IIncidentListener > | |
IntelProfilerAuditor | |
PerfMonAuditor | Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms |
extend_interfaces3< I1, I2, I3 > | Base class to be used to extend an interface |
extends3< BASE, I1, I2, I3 > | Base class used to extend a class implementing other interfaces |
extends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
PersistencySvc | PersistencySvc class implementation definition |
DetPersistencySvc | |
EvtPersistencySvc | EvtPersistencySvc class implementation definition |
HistogramPersistencySvc | HistogramPersistencySvc class implementation definition |
extends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
MultiStoreSvc | Data service base class |
extends3< Service, IRndmEngine, ISerialize, IIncidentListener > | |
RndmEngine | Random Generator engine definition |
HepRndm::BaseEngine | |
HepRndm::Engine< TYPE > | |
extends3< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
RndmGenSvc | Random Generator service definition |
extends3< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
THistSvc | |
implements3< I1, I2, I3 > | Base class used to implement the interfaces |
implements3< IAlgorithm, IProperty, IStateful > | |
Algorithm | Base class from which all concrete algorithm classes should be derived |
CollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way |
EventCounter | |
EvtCollectionStream | A small to stream Data I/O |
extends1< Algorithm, IPartitionControl > | |
GaudiCommon< Algorithm > | |
GaudiAlgorithm | The useful base class for data processing algorithms |
EventNodeKiller | Algorithm to kill nodes in the event data store |
GaudiHistos< GaudiAlgorithm > | |
GaudiHistoAlg | Simple class to extend the functionality of class GaudiAlgorithm |
GaudiTuples< GaudiHistoAlg > | |
GaudiTupleAlg | Simple class to extend the functionality of class GaudiHistoAlg |
GaudiSequencer | Sequencer for executing several algorithms, stopping when one is faulty |
Prescaler | |
GaudiPython::PyAlgorithm | Python Algorithm base class |
GaudiMP.GMPBase.CollectHistograms | |
OutputStream | A small to stream Data I/O |
InputCopyStream | Extension of OutputStream to copy the content of the main input file |
RecordStream | Extension of OutputStream to write run records after last event |
RunRecordStream | Extension of OutputStream to write run records after last event |
SequentialOutputStream | Extension of OutputStream to write run records after last event |
TagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself |
Sequencer | ClassName: Sequencer |
StoreExplorerAlg | Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed |
StoreSnifferAlg | Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run |
implements3< IAlgTool, IProperty, IStateful > | |
AlgTool | Base class from which all the concrete tool classes should be derived |
extends1< AlgTool, IDataStreamTool > | |
extends1< AlgTool, IFileAccess > | |
extends1< AlgTool, IGslErrorHandler > | |
extends1< AlgTool, IPartitionControl > | |
extends2< AlgTool, IDataStoreLeaves, IIncidentListener > | |
extends2< AlgTool, IDODAlgMapper, IDODNodeMapper > | |
GaudiCommon< AlgTool > | |
GaudiTool | The useful base class for tools |
ErrorTool | |
extends1< GaudiTool, IEqSolver > | |
extends1< GaudiTool, IFuncMinimum > | |
GaudiHistos< GaudiTool > | |
GaudiHistoTool | Simple class to extend the functionality of class GaudiTool |
GaudiTuples< GaudiHistoTool > | |
GaudiTupleTool | Simple class to extend the functionality of class GaudiHistoTool |
TupleTool | |
HistoTool | Simple tool for histogramming (component) |
SequencerTimerTool | Implements the time measurement inside a sequencer |
implements3< IService, IProperty, IStateful > | |
CommonMessaging< implements3< IService, IProperty, IStateful > > | |
Service | Base class for all services |
extends1< Service, Gaudi::ISignalMonitor > | |
extends1< Service, IAuditorSvc > | |
extends1< Service, IChronoStatSvc > | |
extends1< Service, ICounterSvc > | |
extends1< Service, IEventProcessor > | |
extends1< Service, IEvtSelector > | |
extends1< Service, IExceptionSvc > | |
extends1< Service, IFileAccess > | |
extends1< Service, IGslSvc > | |
extends1< Service, IIncidentListener > | |
extends1< Service, IIncidentSvc > | |
extends1< Service, IIoComponentMgr > | |
extends1< Service, IIODataManager > | |
extends1< Service, IIssueLogger > | |
extends1< Service, IParticlePropertySvc > | |
extends1< Service, IPartPropSvc > | |
extends1< Service, IRunable > | |
extends1< Service, IStatusCodeSvc > | |
extends1< Service, IToolSvc > | |
extends2< Service, IAlgContextSvc, IIncidentListener > | |
extends2< Service, IConversionSvc, IAddressCreator > | |
extends2< Service, IDataProviderSvc, IDataManagerSvc > | |
extends2< Service, IFileCatalog, IFileCatalogMgr > | |
extends2< Service, IHistorySvc, IIncidentListener > | |
extends2< Service, IMessageSvc, IInactiveMessageCounter > | |
extends2< Service, IProperty, IJobOptionsSvc > | |
extends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
extends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
extends3< Service, IRndmEngine, ISerialize, IIncidentListener > | |
extends3< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
extends3< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
Gaudi::RootPerfMonSvc | Description: |
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface |
implements4< I1, I2, I3, I4 > | Base class used to implement the interfaces |
implements4< IAppMgrUI, IEventProcessor, IService, IStateful > | |
CommonMessaging< implements4< IAppMgrUI, IEventProcessor, IService, IStateful > > | |
ApplicationMgr | The Application Manager class |
I2 | |
extend_interfaces2< I1, I2 > | Base class to be used to extend an interface |
extend_interfaces3< I1, I2, I3 > | Base class to be used to extend an interface |
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface |
I3 | |
extend_interfaces3< I1, I2, I3 > | Base class to be used to extend an interface |
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface |
I4 | |
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface |
IAnnotation | |
AIDA::Annotation | Implementation of the AIDA IAnnotation interface class |
IHistogram2D | |
Gaudi::Generic2D< IHistogram2D, TH2D > | |
INTERFACE | |
Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
PBASE | |
GaudiCommon< PBASE > | Implements the common functionality between GaudiTools and GaudiAlgorithms |
GaudiHistos< PBASE > | Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes |
GaudiTuples< PBASE > | Templated base class providing common 'ntupling' methods |
ResultStream | |
GaudiTest.HTMLResultStream | |