Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►N081_module
CMinModule
►N083_module
CMinModule
►N085_module
CAccessingDataStoreModule
►N087_module
CAccessingDataStoreModule
►NB2A714-DeepContinuumSuppression_MVAModel
Cbatch_generator
►Nb2pandas_utils
CVariablesToHDF5
CVariablesToTable
►Nb2parser
CB2Lexer
CB2ParameterLexer
►Nb2test_utils
►Nclassversion
CClassVersionError
CErrorWithExtraVariables
►Ndatastoreprinter
CDataStorePrinter
CPrintObjectsModule
►Nlogfilter
CLogReplacementFilter
►Nb2test_utils_analysis
CExamplesTest
►NB2Tools
►Nb2latex
CDefineColourList
CGraphics
CItemize
CLatexFile
CLatexObject
CListing
CLongTable
CSection
CString
CSubSection
CSubSubSection
CTitlePage
►Nb2root
►CRawRootFile
CKey
►Nformat
CAttrDict
CDefaultValueFormatter
►Nbasf2
►N_constwrapper
CConstructorNotFoundError
►Nbasf2_mva_python_interface
►Nhep_ml
CState
►Nkeras
CState
►Nlightgbm
CState
►Nsklearn
CState
►Ntensorflow
CState
►Ntest
CState
►Ntorch
CmyModel
►CPickleModule
CUnpickler
CState
►Nxgboost
CState
►Nbasf2_mva_util
CMethod
►NBelle2	Abstract base class for different kinds of events
►Nanalysis
CFourCFitKFit	FourCFitKFit is a derived class from KFitBase to perform 4 momentum-constraint kinematical fit
CKFitBase	KFitBase is a base class for kinematical fitters
CKFitConst	KFitConst is a container of constant names
CKFitError	KFitError is a container of error codes and a macro function
►CKFitTrack	KFitTrack is a container of the track information (Lorentz vector, position, and error matrix), and a set of macro functions to set/get the contents
CKFitPXE	KFitPXE is a container of the track information (Lorentz vector, position, and error matrix)
CMakeMotherKFit	MakeMotherKFit is a class to build mother particle from kinematically fitted daughters
CMassFitKFit	MassFitKFit is a derived class from KFitBase to perform mass-constraint kinematical fit
CMassFourCFitKFit	MassFourCFitKFit is a derived class from KFitBase to perform mass and 4 momentum-constraint kinematical fit
CMassPointingVertexFitKFit	MassPointingVertexFitKFit is a derived class from KFitBase It performs a kinematical fit with three constraints: the invariant mass is constrained to its PDG value, the tracks are forced to a common vertex, and the momentum vector is forced to point to an externally provided space point
CMassVertexFitKFit	MassVertexFitKFit is a derived class from KFitBase to perform mass-vertex-constraint kinematical fit
CRaveKinematicVertexFitter	Part of the RaveInterface together with RaveSetup
CRaveSetup	Part of the RaveInterface together with RaveVertexFitter It holds all global options for the RaveVertexFitter and also takes care that stuff like the magnetic field is correctly set up in way Rave can access it
CRaveVertexFitter	Part of the RaveInterface together with RaveSetup
CRecoilMassKFit	RecoilMassKFit is a derived class from KFitBase to perform a kinematical fit with a recoil mass constraint
CVertexFitKFit	VertexFitKFit is a derived class from KFitBase to perform vertex-constraint kinematical fit
►NAWESOME
CAWESOMEBasicModule	The AWESOME basic module
CAWESOMEGeometryCreator	The creator for the AWESOME detector geometry
CAWESOMESensitiveDetector	Sensitive Detector implementation of the AWESOME detector
►NConditions
CCentralMetadataProvider	Class to obtain payload metadata from the central database server via REST requests
CConfiguration	Class to enable configuration of the conditions database access in C++ and python
CCppOrPyList	Wrapper class for a list of strings to either be held in a std::vector or in a python list
CCurlSession	Struct encapsulating all the state information needed by curl
CDownloader	Simple class to encapsulate libcurl as used by the ConditionsDatabase
CHSFCentralMetadataProvider	Class to obtain payload metadata from the HSF central server via REST requests
CLocalMetadataProvider	Class to obtain metadata of all valid payloads from a local SQLite file instead of the central server
►CMetadataProvider	Base class for a payload metadata provider
►CPayloadMetadataCache	Simple caching structure to keep the payload information for this and the last exp/run
CCacheEntry	Each cache entry
CNullMetadataProvider	Fallback provider if no providers are given: Will raise an error if used but allows processing if no payloads are requested or all are taken locally from testing payload storage
CPayloadMetadata	Simple struct to group all information necessary for a single payload
►CPayloadProvider	Class to find payload files in a list of locations
CPayloadLocation	Simple struct to represent a lookup location
CTestingPayloadStorage	Class to store and retrieve temporary payloads
►NCurlTagger
CBundle	Class to contain particles identified to come from the same actual/mc particle
CSelector	Abstract base class for curl track selectors
CSelectorCut	Simple cut based selector for curl tracks taken from Belle note 1079
CSelectorMVA	MVA based selector for tagging curl tracks in Belle and Belle II
►Ngearbox
CFileContext	InputContext which serves the content of a plain file
CFileHandler	InputHandler which will read XML from plain files, optionally gzip compressed
CInputContext	Class representing a resource context for gearbox
CInputHandler	Class to provide an InputContext for a given XML resource name
CInterface	Exception to be thrown in case of an empty result
CStringContext	InputContext which just returns the value of a string previously assigned
CStringHandler	InputHandler which just takes the uri as XML data
►Ngeometry	Common code concerning the geometry representation of the detector
CCreatorBase	Pure virtual base class for all geometry creators
CCreatorFactory	Very simple class to provide an easy way to register creators with the CreatorManager
CCreatorManager	Class to manage all creators and provide factory access
CGeometryManager	Class to manage the creation and conversion of the geometry
CMaterials	Thin wrapper around the Geant4 Material system
►NIOIntercept	Encapsulate all classes needed to intercept stdout and stderr
CCaptureStream	Class to capture anything written to stream into a string
CCaptureStreamAbortHandler	Small class to handle std::abort() calls by external libraries
CDiscardStream	Simple class to just discard anything written to stream by redirecting it to /dev/null
CInterceptorScopeGuard	Simple RAII guard for output interceptor
CInterceptOutput	Class to intercept stdout and stderr and either capture, discard or keep them unmodified depending on the template arguments
CKeepStream	Dummy class which keeps the stream unmodified
COutputToLogMessages	Capture stdout and stderr and convert into log messages
CStreamInterceptor	Base class with all necessary features to intercept output to a file descriptor
►NMVA
►NONNX
CBaseTensor	Interface class for Tensor template instantiations
CSession	A wrapper around Ort::Session providing model execution
CTensor	Represents an input or output tensor for an ONNX model
CAbstractInterface	Abstract Interface to third-party MVA libraries
CBinning	Binning of a data distribution Provides PDF and CDF values of the distribution per bin
CCombinationExpert	Expert for the Combination MVA method
CCombinationOptions	Options for the Combination MVA method
CCombinationTeacher	Teacher for the Combination MVA method
CCombinedDataset	Wraps two other Datasets, one containing signal, the other background events Used by the reweighting method to train mc files against data files
CDataset	Abstract base class of all Datasets given to the MVA interface The current event can always be accessed via the public members of this class
CExpert	Abstract base class of all Expert Each MVA library has its own implementation of this class, so all libraries can be accessed via this common interface
CFANNExpert	Expert for the FANN MVA method
CFANNOptions	Options for the FANN MVA method
CFANNTeacher	Teacher for the FANN MVA method
CFastBDTExpert	Expert for the FastBDT MVA method
CFastBDTOptions	Options for the FANN MVA method
CFastBDTTeacher	Teacher for the FastBDT MVA method
CGeneralOptions	General options which are shared by all MVA trainings
CInterface	Template class to easily construct a interface for an MVA library using a library-specific Options, Teacher and Expert class
CMetaOptions	Meta Options which modify the underlying training by doing sPlot, Multiclass and HyperparameterSearch
CMultiDataset	Wraps the data of a multiple event into a Dataset
CONNXExpert	Expert for the ONNX MVA method
CONNXOptions	Options for the ONNX MVA method
CONNXTeacher	Teacher for the ONNX MVA method
COptions	Abstract base class of all Options given to the MVA interface
CPDFExpert	Expert for the PDF MVA method
CPDFOptions	Options for the PDF MVA method
CPDFTeacher	Teacher for the PDF MVA method
CPythonExpert	Expert for the Python MVA method
CPythonInitializerSingleton	Singleton class which handles the initialization and finalization of Python and numpy
CPythonOptions	Options for the Python MVA method
CPythonTeacher	Teacher for the Python MVA method
CRegressionDataSet	Dataset needed during the training of a regression method
CRegressionExpert	Generic expert for the regression applications
CRegressionFastBDTOptions	Explicit template specification for FastBDTs for regression options
CRegressionOptions	Generic options of the Regression MVA methods hosting the number of bins (and the base classifier options)
CRegressionTeacher	Core class for the training of regression methods based on binary classifiers
CReweighterExpert	Expert for the Reweighter MVA method
CReweighterOptions	Options for the Reweighter MVA method
CReweighterTeacher	Teacher for the Reweighter MVA method
CReweightingDataset	Dataset for Reweighting Wraps a dataset and provides each data-point with a new weight
CROOTDataset	Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods
CSidebandDataset	Dataset for Sideband Subtraction Wraps a dataset and provides each data-point with a new weight
CSingleDataset	Wraps the data of a single event into a Dataset
CSpecificOptions	Specific Options, all method Options have to inherit from this class
CSPlotDataset	Dataset for sPlot Wraps a dataset and provides each data-point twice, once as signal and once as background
CSubDataset	Wraps another Dataset and provides a view to a subset of its features and events
CTeacher	Abstract base class of all Teachers Each MVA library has its own implementation of this class, so all libraries can be accessed via this common interface
CTMVAExpert	Expert for the TMVA MVA method
CTMVAExpertClassification	Expert for the TMVA Classification MVA method
CTMVAExpertMulticlass	Expert for the TMVA Multiclass MVA method
CTMVAExpertRegression	Expert for the TMVA Regression MVA method
CTMVAOptions	Options for the TMVA MVA method
CTMVAOptionsClassification	Options for the TMVA Classification MVA method
CTMVAOptionsMulticlass	Options for the TMVA Multiclass MVA method
CTMVAOptionsRegression	Options for the TMVA Regression MVA method
CTMVATeacher	Teacher for the TMVA MVA method
CTMVATeacherClassification	Teacher for the TMVA Classification MVA method
CTMVATeacherMulticlass	Teacher for the TMVA Multiclass MVA method
CTMVATeacherRegression	Teacher for the TMVA Regression MVA method
CTrivialExpert	Expert for the Trivial MVA method
CTrivialOptions	Options for the Trivial MVA method
CTrivialTeacher	Teacher for the Trivial MVA method
CUtility	Wrapper class for some utility functions
CWeightfile	Serializes all information about a training into an xml tree
►NOrcaKinFit
CBaseConstraint	Abstract base class for constraints of kinematic fits
CBaseDefs
CBaseEvent
CBaseFitObject
CBaseFitter	Abstract base class for fitting engines of kinematic fits
CBaseHardConstraint	Abstract base class for constraints of kinematic fits
CBaseJetPairing	Abstract base class for jet pairings
CBaseSoftConstraint	Abstract base class for soft constraints of kinematic fits
CBaseTracer	Abstract base class for trace objects of kinematic fits
CFourVector	Yet another four vector class, with metric +—
CISRPhotonFitObject
CJetFitObject	Class for jets with (E, eta, phi) in kinematic fits
CMassConstraint	Implements constraint 0 = mass1 - mass2 - m
CMomentumConstraint	Implements a constraint of the form efact*sum(E)+pxfact*sum(px)+pyfact*sum(py)+pzfact*sum(pz)=value
CNeutrinoFitObject
CNewFitterGSL	A kinematic fitter using the Newton-Raphson method to solve the equations
CNewtonFitterGSL
COPALFitterGSL	Description of the fit algorithm and interface:
CParticleConstraint	Abstract base class for constraints of kinematic fits
CParticleFitObject
CParticleKinematicFitterModule	Kinematic fitter module
CPxPyPzMFitObject
CRecoilMassConstraint
CSoftGaussMassConstraint	Implements constraint 0 = mass1 - mass2 - m
CSoftGaussMomentumConstraint	Implements a soft constraint with chi^2=((efact*sum(E_i) + pxfact*sum(p_x,i)+pyfact*sum(p_y,i)+pzfact*sum(p_z,i)-value)/sigma)^2
CSoftGaussParticleConstraint	Abstract base class for constraints of kinematic fits
CTextTracer
CThreeVector
CTrackConstraint	Abstract base class for constraints of kinematic fits
CTwoVector
►NPyObjConvUtils	Python object converter utilities namespace
CconvertToPythonObjectVisitor	Helper function object to unpack a value from a variant to a python object
CSizeT	Helper construct for TMP that provides an index at compile time to recurse through type lists
CType	Converts a template argument into a string for corresponding Python type
CType< bool >	Converts a template argument into a string for corresponding Python type
CType< boost::variant< Types... > >	Converts a template argument into a string for corresponding Python type
CType< double >	Converts a template argument into a string for corresponding Python type
CType< float >	Converts a template argument into a string for corresponding Python type
CType< int >	Converts a template argument into a string for corresponding Python type
CType< std::map< A, B > >	Converts a template argument into a string for corresponding Python type
CType< std::optional< T > >	Converts a template argument into a string for corresponding Python type
CType< std::set< T > >	Convert a templeate argument into a string for corresponding Python type
CType< std::shared_ptr< Path > >	Some modules take a path as argument so let's add this as well
CType< std::string >	Converts a template argument into a string for corresponding Python type
CType< std::tuple< Types... > >	Converts a template argument into a string for corresponding Python type
CType< std::vector< T > >	Converts a template argument into a string for corresponding Python type
CType< unsigned int >	Converts a template argument into a string for corresponding Python type
CType< unsigned long int >	Converts a template argument into a string for corresponding Python type
CVariadicType	Recursively convert multiple types to type names (used for tuples)
CVariadicType< T >	Recursively convert multiple types to type names (used for tuples)
►NRootIOUtilities	Some constants and helpers common to the RootInput and RootOutput modules
CRootFileInfo	Helper class to factorize some necessary tasks when working with Belle2 output files
►NTestHelpers	Some utilities to help with writing unit tests
CLogMessageTest	Test fixture to be able to check the contents and types of emitted log messages in detail
CTempDirCreator	Changes working directory into a newly created directory, and removes it (and contents) on destruction
CTestWithGearbox	This class provides a test fixture managing the opening and closing of the Gearbox with the default geometry file
►NUtils	General utility functions
CTimer	Small helper class that prints its lifetime when destroyed
CVisitOverload	Helper struct for the C++17 std::visit overload pattern to allow simple use of variants
►NVariable
CDeprecateProxy	Internal class that registers a variable as deprecated
CGroupProxy	Internal class that registers a variable group with Manager when constructed
►CManager	Global list of available variables
CMetaVar	A variable taking string arguments returning a variable
CParameterVar	A variable taking additional floating-point arguments to influence the behaviour
CVar	A variable returning a floating-point value for a given Particle
CVarBase	Base class for information common to all types of variables
CProxy	Internal class that registers a variable with Manager when constructed
CAbstractBooleanNode	A parsed cut-string naturally has a tree shape which incorporates the information of operator precedence and evaluation order of the statements
CAbstractExpressionNode	AbstractExpressionNode Superclass for all nodes which host expressions
CAllParticleCombinerModule	This module combines all particles of the provided list to one mother particle
CAnalysisConfiguration	Singleton class keeping configurables of analysis components
CAnalysisConfigurationModule	Class to hold general basf2 configuration Used to initiate and configure CreateAnalysis object
CArrayIterator	Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc
CAsyncWrapper	Wraps a given Module to execute it asynchronously
CAWESOMESimHit	A Geant4 simulated hit for the AWESOME detector
CB2BIIConvertBeamParamsModule	Convert the IpProfile and Benergy to BeamParameters, BeamSpot, CollisionInvariantMass and CollisionBoostVector
CB2BIIConvertMdstModule	Module converts Belle MDST objects (Panther records) to Belle II MDST objects
CB2BIIFixMdstModule	Declaration of class B2BIIFixMdst
CB2BIIMCParticlesMonitorModule	Declaration of class B2BIIMCParticlesMonitor
CB2BIIMdstInputModule	Module reads Belle MDST files and converts Belle_event record to Belle II EventMetaData StoreObjectPointer
CB2Vector3	A fast and root compatible alternative to TVector3
►CBackgroundInfo	This class stores the information about what background was mixed or overlaid
CBackgroundDescr	Structure for background description
CBackgroundMetaData	Metadata information about the beam background file
CBaseAngle	Class to compare if two angles are compatible within a given error range
CBeamlineFieldMapInterpolation	The BeamlineFieldMapInterpolation class
CBeamParameters	This class contains the nominal beam parameters and the parameters used for smearing of the primary vertex and the beam energy and momentum
CBeamSpot	This class contains the beam spot position and size modeled as a gaussian distribution in space
CBelleBremRecoveryModule	Brem recovery module (used in past belle analyses) This module add four vector of all the brem photon to the four vector associated to the charged particle
CBelleMCOutputModule	KLM digitization module
CBelleNbarMVAModule	Apply nbarMVA for Belle I
CBellePi0EtaProbParameters	Class for handling the payloads with lookup tables for Belle pi0 and eta probabilities
CBelleTrkExtra	Class stores mdst_trk_fit information for each track
CBestCandidateSelectionModule	Ranks particles by the values of a variable
CBFieldComponent3d	The BFieldComponent3d class
CBFieldComponentAbs	The BFieldComponentAbs class
CBFieldComponentBeamline	The BFieldComponentBeamline class
CBFieldComponentConstant	The BFieldComponentConstant class
►CBFieldComponentKlm1	The Bfieldcomponentklm1 class
CBFieldPoint	Trivial struct representing rz coordinate
►CBFieldComponentQuad	The BFieldComponentQuad class
CApertPoint	Aperture data structure
Cirange_t	Start and stop indices to narrow search in array
CParamPoint3	Quadrupole lense data structure
Crange_t	Range data structure
►CBFieldComponentRadial	The BFieldComponentRadial class
CBFieldPoint	Magnetic field data structure
CBFieldFrameworkInterface	Simple BFieldComponent to just wrap the existing BFieldMap with the new BFieldManager
CBFieldManager	Bfield manager to obtain the magnetic field at any point
CBFieldMap	This class represents the magnetic field of the Belle II detector
CBinaryBooleanNode	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
CBinaryExpressionNode	BinaryExpressionNode Node which connects two expression nodes with an arithmetic operation
CBinaryRelationalNode	BooleanNode which has two AbstractExpressionNodes nodes and a ComparisonOperator
CBinnedEventT0	Database object for storing a binned EventT0 coming from the trigger
CBremsFinderModule	Bremsstrahlung finder correction module For each lepton in the input particle list, this module copies it to the output particle list and uses the results of the eclTrackBremFinder module to look for a possible bremsstrahlung photon; if this photon exists, adds its four momentum to the leptons in the output list
CBtube	For each MCParticle with hits in the CDC, this class stores some summarising information on those hits
CBtubeCreatorModule	Create a B particle from a Bbar particle
CBunchStructure	Class to store the fill pattern of colliding bunches
Ccal_scale_error_func_set_t	Structure type cal_scale_error_func_set_t
CCalcMeanCov	Class to calculate mean and and covariance between a number of parameters on running data without storing the actual values, also for weighted entries
CCharBuffer	Dynamic character buffer that knows its size
CChargedPidMVAModule	This module evaluates the response of an MVA trained for binary charged particle identification between two hypotheses, S and B
CChargedPidMVAMulticlassModule	This module evaluates the response of a multi-class MVA trained for global charged particle identification
CChargedPidMVAWeights	Class to contain the payload of MVA weightfiles needed for charged particle identification
CCleoCones	Class to calculate the Cleo clone variables
CCluster	Class to collect log likelihoods from Clusters from ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability
CClusterUtils	Class to provide momentum-related information from ECLClusters
CCMSFrame	CMS frame
CCMSRotationFrame	Stack frame for cms and Rotation frame
CCollisionAxisCMS	This class contains the measured values of the orientation of the collision axis in the CM system obtained by pure Lorentz boost angleXZ = atan(pHERcms.X / pHERcms.Z) angleYZ = atan(pHERcms.Y / pHERcms.Z) where pHERcms is HER momentum in CM system obtained by boost
CCollisionBoostVector	This class contains the measured average boost vector vec(beta) = (beta_x, beta_y, beta_z) = vec(p_e+e-)/E_e+e- of the center-of-mass system in the lab frame and its uncertainty
CCollisionInvariantMass	This class contains the measured average center-of-mass energy, which is equal to the invariant mass of the colliding beams, and its uncertainty
CConditionalGaussGenerator	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
►CConst	This class provides a set of constants for the framework
CChargedStable	Provides a type-safe way to pass members of the chargedStableSet set
CCluster	Provides a type-safe way to pass members of the clusterSet set
CClusterDetectors	A class that defines the valid set of Cluster detectors
►CDetectorSet	For sets of detector IDs in the form of EDetector values
CIterator	Iterator
CParticleSet	A set of ParticleType objects, with defined order
CParticleType	For identifying different particle types
CPIDDetectors	A class that defines the valid set of PID detectors
CRestrictedDetectorSet	A class for sets of detector IDs whose content is limited to restricted set of valid detector IDs
CTrackingDetectors	A class that defines the valid set of tracking detectors
CVXDDetectors	A class that defines the valid set of VXD detectors
CContinuumSuppression	This is a class for collecting variables used in continuum suppression
CContinuumSuppressionBuilderModule	Creates for each Particle in given ParticleList an ContinuumSuppression dataobject and makes basf2 relation between them
CCreateConsistencyInfoModule	If you want to merge two events with the 'MergeDataStoreModule', it might be necessary to make sure that this combination of events make sense
CCreateFieldMapModule	Create Field maps of the Belle II magnetic field used in the simulation
CCurlTaggerModule	This module is designed to tag curl tracks
►CDatabase	Singleton base class for the low-level interface to the database
CDBImportQuery	Struct for bulk write queries
CDatabaseRepresentationOfWeightfile	Database representation of a Weightfile object
CDataFlowVisualization	Class to visualize data flow between modules
CDataNode	Template class for storing the Constants (int, double, bool) of the Cutstring
►CDataStore	In the store you can park objects that have to be accessed by various modules
CSwitchableDataStoreContents	Encapsulates DataStoreContents, but allows transparently switching between different versions ('DataStore IDs')
CDataStoreStreamer	Stream/restore DataStore objects to/from EvtMessage
CDBAccessorBase	Base class for DBObjPtr and DBArray for easier common treatment
CDBArray	Class for accessing arrays of objects in the database
CDBImportArray	Class for importing array of objects to the database
CDBImportBase	Base class for importing objects to the database
CDBImportObjPtr	Class for importing a single object to the database
CDBObjPtr	Class for accessing objects in the database
CDBObjPtr< PayloadFile >	Specialization of DBObjPtr in case of PayloadFiles
CDBPointer	Class for pointing to an element in an array stored in the database
CDBRepresentationOfSoftwareTriggerCut	Class to handle storing SoftwareTriggerCuts in the database
CDBStore	Singleton class to cache database objects
CDBStoreEntry	Class to hold one entry from the ConditionsDB in the DBStore
CDecayDescriptor	The DecayDescriptor stores information about a decay tree or parts of a decay tree
CDecayDescriptorParticle	Represents a particle in the DecayDescriptor
CDecayForest	Contains several DecayTree objects, which belong all to the same candidate
CDecayNode	DecayNode describes the decay of a particle identified by its pdg code, into list of daughters
CDecayStringDecay	Holds the information of a decay
CDecayStringGrammar	This class describes the grammar and the syntax elements of decay strings
CDecayStringParticle	Holds the information of a particle in the decay string
CDecayTree	This is a helper class for the MCDecayFinderModule
CdEdxPDFs	Base class for holding the dE/dx PDFs
CDensityScalerModule	Scale density of simulation/reconstruction geometry
►CDependencyMap	Collect information about the dependencies between modules
CModuleInfo	Stores information on inputs/outputs of a module, as obtained by requireInput()/optionalInput()/registerEntry();
CDetectorSurface	Detector surfaces information
CDetSurfCylBoundaries	Simple class to encapsulate a detector surface's boundaries in cylindrical coordinates
CDigitBase	A common base for subdetector Digits
►CDisplayData	Add custom information to the display
CArrow	Stores data associated with an arrow
CDistanceCalculatorModule	Calculates distance between two vertices, distance of closest approach between a vertex and a track, distance of closest approach between a vertex and Btube
CDuplicateVertexMarkerModule	Identify duplicate vertices (distinct particles, but built from the same daughters) and mark the one with best chi2
CECLCluster	ECL cluster data
CECLEnergyCloseToTrack	Class to store energy information for ECL hits closest to a track
CECLPhotonEnergyResolution	Class to hold the information ECL energy resolution derived from PERC
CECLTimingNormalization	DB object for parameters to create variable clusterTimeNorm90
CECLTRGInformation	Class to store information about ECL trigger cells (TCs)
CECLTriggerCell	ECL Trigger cells
CEnergyBiasCorrectionModule	Energy bias correction
CEnvironment	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
CEnvironmentVariables	Utility functions related to environment variables
CEqualVisitor	Separate Visitor struct for equal_to comparison of variant<double, int bool>
CEventDependency	Class for handling changing conditions as a function of event number
CEventErrorFlagModule	Module to check or add error flags of the EventMetaData
CEventExtraInfo	Class to stores ExtraInfo of the whole event
CEventInfoPrinterModule	The event meta data info module
CEventInfoSetterModule	Module to set event, run, experiment numbers
CEventKinematics	Class for collecting variables related to the global kinematics of the event
CEventKinematicsModule	Module to compute global quantities related to the event kinematics, like total missing energy and mass2, visible energy, etc
CEventLevelClusteringInfo	ECL/KLM clustering event level information:
CEventLevelTrackingInfo	Tracking-related info on event-level, for example number of unassigned measurements
CEventLevelTriggerTimeInfo	Storage element for information from the Trigger Timing Distribution (TTD) and EventT0-related information
CEventLimit	This dataobject is used by EventLimiter module to set event limit based on the value from the database
CEventLimiterModule	The EventLimiter module
CEventMetaData	Store event, run, and experiment numbers
CEventMetaDataSerialization	Helper class for (de)serializing the event meta data used for the event backup transferral
►CEventProcessor	Core event processing loop
CStoppedBySignalException	Exception thrown when execution is stopped by a signal
CEventShapeCalculatorModule	Module to compute event shape variables starting from three lists of particle objects (tracks, gammas, Klongs)
CEventShapeContainer	Class for collecting the basic objects related to the event shape
►CEventT0	Storage element for the eventwise T0 estimation
CEventT0Component	Structure for storing the extracted event t0s together with its detector and its uncertainty
CEvtGenDatabasePDG	Replacement for TDatabasePDG that is filled from EvtGen's evt.pdl
CEvtGenParticlePDG	Helper class for setting additional TParticlePDG members and storing the ones it doesn't have yet
CEvtHeader	Header structure of streamed object list
CEvtMessage	Class to manage streamed object
CExportGeometryModule	The ExportGeometry module
CExtraInfoPrinterModule	Prints the names of the ExtraInfos for a ParticleList or for the Event
CExtraInfoRemoverModule	This module deletes the extrainfo of each particle in the given ParticleLists
CFBXWriterModule	The FBX-writer module
CFileCatalog	This class provides an interface to the file (metadata) catalog
CFileMetaData	Metadata information about a file
►CFileSystem	Utility functions related to filename validation and filesystem access
CLock	Helper class for locking a file
CTemporaryFile	Helper file to create a temporary file and ensure deletion if object goes out of scope
CFixMergedObjectsModule	If the content of two DataStores are merged using the 'MergeDataStoreModule', then Relations of the objects are corrected
CFlavorTaggerInfo	This class stores the relevant information for the TagV vertex fit, extracted mainly from the Flavor Tagging Module
CFlavorTaggerInfoBuilderModule	Creates for each Particle and RestOfEvent object in the DataStore a FlavorTaggerInfo dataobject and makes basf2 relation between them
CFlavorTaggerInfoFillerModule	Creates a new flavorTaggerInfoMap DataObject for the specific methods
CFlavorTaggerInfoMap	This class stores the Flavor Tagger information for a specific method and particle filled in the Flavor Tagger Module
CFormulaParser	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
CFormulaParserBase	Base class with the non-templated part of the formula parser
CFoxWolfram	Class to calculate the Fox-Wolfram moments up to order 8
CFramework	This class combines all subsystems of the framework, and exports the main interface to Python
CFunctionNode	FunctionNode Node class for handling MetaVariables in cuts
►CGearbox	Singleton class responsible for loading detector parameters from an XML file
CPathOverride	Struct to override a path in the XML file with a custom value
CPathValue	Struct for caching results from the xml file
CGearboxModule	The Gearbox module
CGearDir	GearDir is the basic class used for accessing the parameter store
CGenB0Tag	Class to determine generated decay mode of B0 and B0bar
CGenBplusTag	Class to determine generated decay modes of B+ and B-
CGenBsTag	Class to determine generated decay mode of Bs0 and Bs0bar
CGenDTag	Class to determine generated decay mode of D*, Ds, D0, D+, and their anti-particles
CGeneralCut	This class implements a common way to implement cut/selection functionality for arbitrary objects
CGenTauTag	Class to determine generated decay mode of tau+ and tau-
CGeoComponent	Describe one component of the Geometry
CGeoConfiguration	Configuration of the geometry
CGeoMagneticField	The GeoMagneticField class
CGeoMaterial	Class to represent a material information in the Database
CGeoMaterialComponent	Component of a material
CGeoMaterialProperty	Property of a material
CGeometryModule	Module to facilitate Geometry creation
CGeoOpticalSurface	Represent an optical finish of a surface
CGlobalProcHandler	A class to manage processes for parallel processing
CHardwareClockSettings	Database object containing the nominal accelerator RF value and the prescales to derive the clock frequencies of the sub-detectors
CHarmonicMoments	Class to calculate the Harmonic moments up to order 8 with respect to a given axis
CHelix	This class represents an ideal helix in perigee parameterization
CHelixErrorScalerModule	Scale the error of helix parameters
CHistoManagerModule	Class definition of HistoManager module
CHistoModule	HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions to be managed by HistoManager
CHitPatternCDC	Hit pattern of CDC hits within a track
CHitPatternVXD	Hit pattern of the VXD within a track
CIdentifierNode	Class which stores the name of a variable
CInclusiveBtagReconstructionModule	Inclusively reconstructs anti-B:tag from input ParticleLists for given B:sig
CInclusiveDstarReconstructionModule	Inclusive D* reconstruction module
CInMessage	Reusable Message class derived from TMessage (for reading only)
CInputController	A static class to control supported input modules
CInputHandlerFactory	Helper class to easily register new input handlers
CInteractiveModule	Start an interactive python shell in each call of event()
CIntervalOfValidity	A class that describes the interval of experiments/runs for which an object in the database is valid
CIntraRunDependency	Base class for handling changing conditions during a run
CIoVDependentConditionModule	Module which sets its return value based on the fact, if the event is in the given run/exp interval or not
CKeyValuePrinter	Create human-readable or JSON output for key value pairs
CKink	Object holding information for Kinks
CKlId	Klong identification (KlId) datastore object to store results from KlId calculations
CKLMCluster	KLM cluster data
CKlongCalculatorUtils	Utility class to calculate the Klong kinematics
CKlongDecayReconstructorExpertModule	Reco missing module
CKlongMomentumCalculatorExpertModule	Reco missing module
CKlongMomentumUpdaterExpertModule	Calculate and update the two body B decay kinematics
CKsfwMoments	Moment-calculation of the k_sfw improved Super-Fox-Wolfram moments
CLabFrame	Lab frame
CLabToCms	Class implementing general Lorentz Transformation between LAB and CMS system
CListIndexGenerator	ListIndexGenerator is a generator for all the combinations of the sublists (FlavorSpecificParticle = 0, SelfConjugatedParticle = 1) of a set of particle lists
CLogConfig	The LogConfig class
CLogConnectionBase	Abstract base class for the different types of log connections
CLogConnectionConsole	Implements a log connection to an IO Stream
CLogConnectionFilter	Implements a log connection that filters repeated messages
CLogConnectionJSON	Implements a log connection to stdout but with messages formatted as json objects to allow easy parsing by other tools, say jupyter notebooks
CLogConnectionTxtFile	Implements a log connection to a text file
CLogConnectionUDP	Log Connection to send the log message as JSON to a UDP server
►CLogMessage	The LogMessage class
CTextHasher	Helper struct to hash and compare messages only by log level and message content
CLogMethod	The LogMethod class
CLogPythonInterface	Thin wrapper to expose a usable interface to the logging framework in python
CLogSystem	Class for logging debug, info and error messages
CLowEnergyPi0IdentificationExpertModule	Calculation of low-energy pi0 identification value
CLowEnergyPi0VetoExpertModule	Calculation of low-energy pi0 veto value
CMagneticField	Magnetic field map
CMagneticFieldComponent	Abstract base class for BField components
CMagneticFieldComponent3D	Describe one component of the Geometry
CMagneticFieldComponentConstant	Describe one component of the Geometry
CMakeROOTCompatible	Helper class for converting strings into a ROOT-friendly format (e.g.: removing special characters in branch names, etc.)
CMap2Vector	Helper class to make a vector of all possible combinations of int numbers contained in the input vectors (passed as values in a map)
CMapMergeable	Wrap an STL map to make it mergeable
CMCDecayFinderModule	Find decays in MCParticle list matching a given DecayString
CMCInitialParticles	This class contains the initial state for the given event
CMCMatcherParticlesModule	MC matching module: module performs MC matching (sets the relation Particle -> MCParticle) for all particles and its (grand)^N-daughter particles in the user-specified ParticleList
CMCMatching	Functions to perform Monte Carlo matching for reconstructed Particles
CMCParticle	A Class to store the Monte Carlo particle information
►CMCParticleGraph	Class to build, validate and sort a particle decay chain
CGraphParticle	Class to represent Particle data in graph
CParticleSorter	Class to go over all the particles in the Graph an sort them in a sensible way
CMemoryPool	Class to provide a constant access time memory pool for one kind of objects
CMergeable	Abstract base class for objects that can be merged
CMergeDataStoreModule	Internal module used by Path.add_independent_merge_path()
CMergedEventConsistency	Mark if we want to merge the DataStore of a combination of events or not
CMetadataService	This class provides a service for writing metadata about the basf2 execution and about output files to a json file
CModule	Base class for Modules
CModuleCondition	Wraps a condition set on a Module instance
CModuleManager	The ModuleManager Class
CModuleParam	A single parameter of the module
CModuleParamBase	Base class for module parameter
CModuleParamInfoPython	Class to store basic information about a parameter
CModuleParamList	The Module parameter list class
CModuleProxyBase	The base module proxy class is used to create new instances of a module
CModuleStatistics	Keep track of time and memory consumption during processing
CMRUCache	Class implementing a generic Most Recently Used cache
CMsgHandler	A class to encode/decode an EvtMessage
CMuidProb	Class computes probability density for Muid calculation
CMultivariateNormalGenerator	Class to generate normal distributed, correlated random numbers given the mean values and the covariance matrix of all dimensions
CMVAExpertModule	This module adds an ExtraInfo to the Particle objects in a given ParticleList
CMVAMultipleExpertsModule	This module adds an ExtraInfo to the Particle objects in a given ParticleList
CMVAPrototypeModule	This module can be used as a prototype for your own module which uses MVA weightfiles
CMyDBCreator	Very simple Creator class which actually does not do anything but shows how creators should implement loading the geometry from database
CMyDBPayloadClass	Class containing all the parameters needed to create the geometry and suitable to save into a ROOT file to be used from the Database
CNeutralHadron4MomentumCalculatorModule	Calculates 4-momentum of a neutral hadron in a given decay chain e.g
CNeutralHadronMatcherModule	Module to geometrically match neutral hadrons (KL, neutrons) to ECL clusters
CNodeFactory	Wrapper class for static node compile functions
CObjArrayIterator	Optimizes class to iterate over TObjArray and classes inheriting from it
COnlyWriteOutParticleListsModule	Marks all objects in DataStore except those of type ParticleList as WrtieOut=False
COptionalDBArray	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
COptionalDBObjPtr	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
COverlapCheckerModule	The geometry overlap check module
CPartialSelectModule	The PartialSelect module
CParticle	Class to store reconstructed particles
CParticleAndWeight	This struct is used to store and sort the tag tracks
CParticleCombinerFromMCModule	Particle combiner module
CParticleCombinerModule	Particle combiner module
CParticleCopierModule	Module for creating copies of Particles
CParticleExtractorFromROEModule	Extract particles from ROE and fill them in ParticleList
CParticleExtraInfoMap	Internal class to store string -> index maps for extra info stored in Particle
CParticleGenerator	ParticleGenerator is a generator for all the particles combined from the given ParticleLists
CParticleIndexGenerator	ParticleIndexGenerator is a generator for all the combinations of the particle indices stored in the particle lists
CParticleList	ParticleList is a container class that stores a collection of Particle objects
CParticleListHelper	Class to help managing creation and adding to ParticleLists
CParticleListManipulatorModule	Module for copying Particles (actually their indices) from two or more ParticleLists(s) to another ParticleList
CParticleLoaderModule	Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList
CParticleMassHypothesesUpdaterModule	This module creates a new particle list with the desired pdg code using tracks from an input particle list (basically updates the mass hypotheses of the input list)
CParticleMassUpdaterModule	This module replaces the mass of the particles inside the given particleLists with the invariant mass of the particle corresponding to the given pdgCode
CParticleMCDecayStringModule	Adds the Monte Carlo decay string to a Particle
CParticleMomentumUpdaterModule	This module replaces the momentum of the Particle in the target particle list by p(beam) - p(selected daughters)
CParticlePrinterModule	Prints particle list to screen
CParticleSelectorModule	Loops over all Particles in the ParticleList and removes those Particles from the ParticleList that do not pass given selection criteria
CParticleStatsModule	This module summarises the ParticleLists in the event
CParticleSubset	Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists
CParticleVertexFitterModule	Vertex fitter module
CParticleWeightingAxis	Class for handling LookUp tables
CParticleWeightingBinLimits	Just pair of numbers - min and max values of bin border
CParticleWeightingKeyMap	Class for handling KeyMap
CParticleWeightingLookUpCreatorModule	Module that creates LookUpTable and upload it to the DB
CParticleWeightingLookUpTable	Class for handling LookUp tables
CParticleWeightingModule	Module to append weights from the database into the extraInfo of Particles
CPath	Implements a path consisting of Module and/or Path objects
CPathElement	Base for classes that can be elements of a Path
CPathIterator	Iterator over a Path (returning Module pointers)
CPathUtils	Helper utils for path arithmetic needed in the pEventProcessor
CPayloadFile	A wrapper class for payload files used by the Database and DBStore classes
CPCmsLabTransform	Class to hold Lorentz transformations from/to CMS and boost vector
CpEventProcessor	This class provides the core event processing loop for parallel processing
CPhiAngle
CPhotonEfficiencySystematicsModule	Adds Photon Detection Efficiency Data/MC ratios To Particle List
CPi0VetoEfficiencySystematicsModule	Adds Pi0Veto Efficiency Data/MC ratios To Particle List
CPIDCalibrationWeight	Class for handling the PID calibration weight matrix
CPIDCalibrationWeightCreatorModule	Module that creates WeightMatrix and uploads it to the DB
CPIDCalibrationWeightUtil	Class to call calibration weight matrix
►CPIDDetectorWeights	Class for handling the PID weights per detector, used to calculate the track helix isolation score per particle
CWeightsTable	Nested class acting as a container the per-detector weights
CPIDLikelihood	Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability
CPIDNeuralNetwork	Class to call PID neural network
CPIDNeuralNetworkParameters	Class for handling the parameters for the neural-network PID
CPIDNeuralNetworkParametersCreatorModule	Module that creates PID neural network parameters and uploads them to the DB
CPIDPriors	A database class to hold the prior probability for the particle identification
CPIDPriorsTable	This class holds the prior distribution for a single particle species
CPostMergeUpdaterModule	If the content of two DataStores are merged using the 'MergeDataStoreModule', several kinematic properties might need fix
CPostProcessingParticleWeighting	Post-processing particle weighting
CPrescaleModule	The Prescale module
CPrintBeamParametersModule	Print the BeamParameters every time they change
CPrintCollectionsModule	Prints the contents of DataStore in each event, listing all objects and arrays (including size)
CPrintMCParticlesModule	The PrintMCParticles module
CProcessedEventBackup	Storage item for the event backup storing the event message, the time stamp and the event meta data
CProcessedEventsBackupList	List-like structure for storing and retaining event backups
CProcessMonitor	Class to monitor all started framework processes (input, workers, output), kill them if requested and handle the signals from the OS
CProcessStatistics	Class to collect call statistics for all modules
CProcessStatisticsPython	Python interface for ProcessStatistics
CProcHandler	A class to manage processes for parallel processing
CProfileInfo	Store execution time and memory usage
►CProfileModule	A module that measures the execution time and memory usage per event
CMemTime	An internal struct to store pairs of memory usage and time
CProgressBarModule	Display a progress bar and an estimate of remaining time when number of events is known (e.g
CProgressModule	Periodically writes the number of processed events/runs to the logging system to give a progress indication
CPruneDataStoreModule	Clears the content of the DataStore while it keeps entries matching the regex expression in the matchEntries option
CPseudoVertexFitterModule	Pseudo Vertex fitter module
CPyDBArray	Class to access a DB Array from Python
CPyDBObj	Class to access a DBObjPtr from Python
CPyModule	Python wrapper for Belle2::Module
CPyStoreArray	A (simplified) python wrapper for StoreArray
CPyStoreObj	(simplified) python wrapper for StoreObjPtr
CRandomBarrierModule	Sets gRandom to an independent generator for the following modules
CRandomGenerator	Fast Random number Generator using on xorshift1024* [arXiv:1402.6246]
CRandomNumbers	The class for handling the random number generation
CRbTupleManager	Class to manage histograms defined in registered modules
CReferenceFrame	Abstract base class of all reference frames
►CRelationArray	Low-level class to create/modify relations between StoreArrays
CIdentity	Struct for identity transformation on indices
CReplaceMap	Struct to replace indices based on a map-like container
CReplaceVec	Struct to replace indices based on a sequential container
CRelationContainer	Class to store relations between StoreArrays in the DataStore
CRelationElement	Class to store a single element of a relation
CRelationEntry	Struct for relations
CRelationIndex	Provides access to fast ( O(log n) ) bi-directional lookups on a specified relation
CRelationIndexBase	Baseclass for all RelationIndexContainers
►CRelationIndexContainer	Class to store a bidirectional index between two StoreArrays
CElement	Element type for the index
CRelationIndexManager	Manager to keep a cache of existing RelationIndexContainers
CRelationsInterface	Defines interface for accessing relations of objects in StoreArray
CRelationVector	Class for type safe access to objects that are referred to in relations
CRelationVectorBase	Base class for RelationVector<T>
CRemoveParticlesNotInListsModule	Removes all Particles that are not in a given list of ParticleLists (or daughters of those)
CRestFrame	Rest frame of a particle
►CRestOfEvent	This is a general purpose class for collecting reconstructed MDST data objects that are not used in reconstruction of given Particle – referred also as Rest Of the Event
CMask	Structure of Rest of Event mask
CRestOfEventBuilderModule	Creates for each Particle in given ParticleList an RestOfEvent (ROE) dataobject and makes basf2 relation between them
CRestOfEventInterpreterModule	Creates a mask (vector of boolean values) for tracks and clusters in RestOfEvent regarding their usage
CRestOfEventPrinterModule	Prints ROE information and masks to screen
CRestOfEventUpdaterModule	Updates an existing mask (map of boolean values) for tracks or eclClusters in RestOfEvent with an available property (e.g
CRingBuffer	Class to manage a Ring Buffer placed in an IPC shared memory
CRingBufInfo	Internal metadata structure for RingBuffer
CRootFileCreationManager	This single instance class takes track of all open ROOT files open in "create" mode, usually meant for all the ntuple output modules
►CRootInputModule	Module to read TTree data from file into the data store
CReadStats	For collecting statistics over multiple files
CRootMergeable	Wrap a root histogram or TNtuple to make it mergeable
CRootOutputModule	Write objects from DataStore into a ROOT file
CRotationFrame	Rotation frame around vector
CRxModule	Module to decode data store contents from RingBuffer
CScopeGuard	Simple ScopeGuard to execute a function at the end of the object lifetime
CSelectDaughtersModule	Redefine (select) the daughters of a particle
CSelectSubset	Class to create a subset of a given StoreArray together with the relations with other StoreArrays
CSelectSubsetBase	Type-independent implementation details of SelectSubset
CSemaphoreLocker	Handles creation, locking and unlocking of System V semaphores
CSeqFile	A class to manage I/O for a chain of blocked files
CSeqRootInputModule	Module to read files produced by SeqRootOutputModule
CSeqRootOutputModule	Output module for sequential ROOT I/O
CSetMergeable	Wrap an STL set to make it mergeable
CSignalSideParticleFilterModule	The module returns true if the current RestOfEvent object is related to any of the Particles in the input ParticleLists
CSignalSideParticleListCreatorModule	The module creates a ParticleList and fills it with one of the daughter Particles
CSignalSideVariablesToDaughterExtraInfoModule	The module writes properties (values of specified variables) of the particle related to the current ROE as an ExtraInfo to the single particle in the input ParticleList
CSignalSideVariablesToExtraInfoModule	The module writes property of single particle found in the input ParticleList as an ExtraInfo to the Particle related to the current ROE
CSkimFilterModule	This module filters events based on presence of candidates in a list of ParticleLists
CSoftwareTriggerCutBase	Base class for the SoftwareTriggerCut and its DBRepresentation
CSoftwareTriggerMenu	Class to handle storing the trigger menu in the database
CSoftwareTriggerResult	Dataobject to store the results of the cut calculations performed by the SoftwareTriggerModule
CSphericityEigenvalues	Class to calculate the Sphericity tensor eigenvalues and eigenvectors starting from an array of 3-momenta The tensor itself is not stored, only its eigenvalues and eigenvectors are
CStatisticsSummaryModule	A module that displays the sum of multiple modules in the module statistics
CSteerRootInputModule	Internal module used by Path.add_independent_merge_path()
CStoreAccessorBase	Base class for StoreObjPtr and StoreArray for easier common treatment
CStoreArray	Accessor to arrays stored in the data store
CStoreEntry	Wraps a stored array/object, stored under unique (name, durability) key
CStoreObjPtr	Type-safe access to single objects in the data store
CStreamHelper	Helper class for data store serialization
CStringFormulaConstructor	Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging
CStringWrapper	This class is a wrapper for strings, such as MCDecayStrings, to allow them to be associated with particles via a relation
CSubEventModule	Framework-internal module that implements the functionality of Path::forEach() as well as Path::doWhile()
CSwitchDataStoreModule	Internal module used by Path.add_independent_path()
CTagUniqueSignalModule	Loops through the particle list finds a unique signal candidate for each event
CTagVertex	TagVertex data object: contains Btag Vertex and DeltaT
CTagVertexModule	Tag side Vertex Fitter module for modular analysis
CTauDecayMarkerModule	Module to identify generated tau pair decays, using MCParticle information
CTauDecayModeModule	Module to classify tau decay events according to a mapping given by the user or with a default mapping based on the TauolaBelle2 decay list
CTauPairDecay	Class for collecting variables related to tau-taubar MC decay process
CTernaryRelationalNode	BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator
CTestChunkData	Storable object which can be filled with random chunk data of a certain size
CTheKillerModule	This Modules kills basf2 as horribly as possible (or selected)
CThetaAngle
CThrust	Class to calculate the thrust axis
CTrack	Class that bundles various TrackFitResults
CTrackFitResult	Values of the result of a track fit with a given particle hypothesis
CTrackFitResultEstimatorModule	Create a TrackFitResult from the momentum of a Particle and make a relation between them
CTrackingEfficiencyModule	Tracking efficiency systematics module: removes tracks from the lists at random for efficiency studies
CTrackingEnergyLossCorrectionModule	Tracking energy systematics module: allows for the application of an additive energy correction which is read from a ParticleWeightingLookUpTable payload
CTrackingMomentumScaleFactorsModule	Tracking momentum systematics module: allows for the application of a corrective momentum scale factor which is read from a ParticleWeightingLookUpTable payload
CTrackIsoCalculatorModule	Calculate track isolation variables on the input ParticleList
CTRandomWrapper	Wrap TRandom to be usable as a uniform random number generator with STL algorithms like std::shuffle
CTreeFitterModule	Module to fit an entire decay tree
CTRGGDLDBBadrun	The payload class for GDL badrun
CTRGGDLDBFTDLBits	The payload class for FTDL output bit
CTRGGDLDBInputBits	The payload class for GDL input bit
CTRGGDLDBPrescales	The payload class for GDL psnm
CTRGSummary	Trigger Summary Information input bits input bits from subdetectors ftdl (Final Trigger Decision Logic) bits output bits of trigger logic psnm (Prescale and Mask) bits prescaled ftdl bits timType types of trigger timing source defined in b2tt firmware
Ctriangle_t	Triangle structure
CTriangularInterpolation	The TriangularInterpolation class
CTTDOffsets	This class contains information to correct the information obtained from the TTD (simple offsets)
CTwoBodyISRPhotonCorrectorModule	This module corrects the energy and momentum of high-energy ISR photons in single ISR events based on the beam energy, photon direction, and the mass of the recoil particle
CTxModule	Module for encoding data store contents into a RingBuffer
CUdstListFilterModule	Module to filter udst content based on a particle list
CUnaryBooleanNode	Nodeclass with a single AbstractBooleanNode as child
CUnaryExpressionNode	UnaryExpressionNode Node class with a single expression node as child
CUnaryRelationalNode	Nodeclass with a single AbstractExpressioNode as child
CUncertainHelix	This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters
CUnit	The Unit class
CUseReferenceFrame	A template class to apply the reference frame
CV0	Object holding information for V0s
CV0DaughterMassUpdaterModule	This module replaces the mass of two daughters of the selected V0 particles inside the given particleLists with masses of given pdgCode
CVariableFormulaConstructor	Struct to construct new variable function objects from a name or a double value or to apply operations on these variable function objects
CVariablesToEventBasedTreeModule	Module to calculate variables specified by the user for a given ParticleList and save them into a TTree
CVariablesToEventExtraInfoModule	For each particle in the input list the selected variables are saved in an event-extra-info field with the given name, Can be used to save MC truth information, for example, in a ntuple of reconstructed particles
CVariablesToExtraInfoModule	For each particle in the input list the selected variables are saved in an extra-info field with the given name, Can be used when wanting to save variables before modifying them, e.g
CVariablesToHistogramModule	Module to calculate variables specified by the user for a given ParticleList and save them into an Histogram
CVariablesToNtupleModule	Module to calculate variables specified by the user for a given ParticleList and save them into a ROOT TTree
CVariableToReturnValueModule	Module to calculate variable specified by the user and set return value accordingly
CVisitor	This is a class template which takes a template class operation as template argument
CVRMLWriterModule	The VRML-writer module
Cxy_t	A simple 2d vector structure
CZMQAddressUtils	Summary of some address helpers
CZMQClient	A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket
CZMQConfirmedInput	Input part of a confirmed connection
CZMQConfirmedOutput	Output part of a confirmed connection
CZMQConnection	Base class for every connection with virtual functions to be implemented:
CZMQConnectionOverSocket	Specialized connection over a ZMQ socket
CZMQEventProcessor	This class provides the core event processing loop for parallel processing with ZMQ
CZMQIdMessage	A message with the socket ID. Needed in input<->worker communication
CZMQLoadBalancedInput	Input part of a load-balanced connection
CZMQLoadBalancedOutput	Output part of a load-balanced connection
►CZMQLogger	Base class for the ZMQ connection to help monitor and log certain values
CDecrementor	Visitor Helper for decrementing a numerical value
CIncrementor	Visitor Helper for incrementing a numerical value
CtoJSON	Visitor Helper for converting a variant value into a JSON string
CZMQMessageFactory	Helper class for creating new ID/No-ID messages
CZMQMessageHelper	Internal helper for creating ZMQ messages (should not be used otherwise)
CZMQModuleMessage	A general message with as many parts as given as template argument
CZMQNoIdMessage	A message without an associated socket ID. Is used in most cases
CZMQNullConnection	Connection doing just nothing: without the capability to pull, send or receive. Useful for template interfaces
CZMQParent	A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed
CZMQRawInput	Input connection allowing to speak with non-zmq sockets via a ZMQ_STREAM socket
CZMQRawOutput	Output connection to speak to non-zmq sockets via a ZMQ_STREAM socket
CZMQRxOutputModule	Module connecting the worker path with the output path on the output side
CZMQRxWorkerModule	Module connecting the input path with the worker path on the worker side
CZMQSimpleConnection	Connection type to be used for answering simple requests, e.g
CZMQTxInputModule	Module connecting the input path with the worker path on the input side
CZMQTxWorkerModule	Module connecting the worker path with the output path on the worker side
►Ncdcplotmodule
CCDCPlotModule
►Nconditions_db
►Ncli_main
CFullHelpAction
►Ncli_management
CCommandIoVsHelper
►Ncli_utils
CItemFilter
►Niov
CIntervalOfValidity
CIoVSet
►Nlocal_metadata
CLocalMetadataProvider
►Nrunningupdate
CRunningTagUpdateMode
CRunningTagUpdater
CRunningTagUpdaterError
►Ntesting_payloads
CTestingPayloadEntry
CBearerAuth
►CConditionsDB
CRequestError
CPayloadInformation
►Ncreate_trainer
CGraFEIIgniteTrainer
►NdecayHash
CDecayHashMap
►Ndft
►Ntensorflow_dnn_model
CDefaultModel
CLayer
CMultilayerPerceptron
CTrainer
►NTfData
CTfDataBasf2
CTfDataBasf2Stub
►Ndplot
CPrior
►NevalPriors
CPriors
►Nfei
►Nconfig
CParticle
►Ncore
CFSPLoader
CPostReconstruction
CPreReconstruction
CTeacher
CTrainingData
CTrainingDataInformation
►Nmonitoring
CMonitoringBranchingFractions
CMonitoringHist
CMonitoringModuleStatistics
CMonitoringNTuple
CMonitoringParticle
CStatistic
►Nfill_array_example
CInjectPXDDigits
►Nfitter
Cbatch_generator
►Ngeometric_datasets
CGraphDataSet
►Ngeometric_layers
CEdgeLayer
CGlobalLayer
CNodeLayer
►Ngeometric_network
CGraFEIModel
►NGraFEIModule
CGraFEIModule
►Nhep_ipython_tools
►Ncalculation
CCalculation
►Ncalculation_process
CCalculationProcess
►Ncalculation_queue
CCalculationQueue
CCalculationQueueItem
►Nentities
CStatistics
CStatisticsColumn
CStoreContent	Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders
CStoreContentList
►Ninformation
CEnvironmentInformation
►Nipython_handler
CIPythonHandler
►Nipython_handler_basf2
►Ncalculation
CBasf2Calculation
►Ncalculation_process
CBasf2CalculationProcess
►Nentities
CBasf2CalculationQueueStatistics
CModuleStatistics
►Ninformation
CBasf2EnvironmentInformation
CBasf2ModulesInformation
►Nipython_handler
CBasf2IPythonHandler
►Npython_modules
CPrintCollections
CProgressPython
►Nviewer
CDependencyViewer
CModuleViewer
CPathViewer
CStylingWidget
►Nviewer
CCollectionsViewer
CIPythonWidget
CLogViewer
CProcessViewer
CProgressBarViewer
CStatisticsViewer
CStylingWidget
►Nhistogram
CHistograms
►Nhow_to_use_arbitrary_methods
CMyFancyClassifier
►Ninteractive
CBasf2IPythonPrompt
►Ninteractive_python
CMinModule
►Nkeras_relational
CEnhancedRelations
CRelations
►Nlca_to_adjacency
CInvalidLCAMatrix
CNode
►NLCASaverModule
CLCASaverModule
►Nmetrics
CPerfectEvent
CPerfectLCA
CPerfectMasses
►NmultiTrain
CMultiTrainLoss
►Nonline_book_statistics
CStatistics
CStatisticsVisitor
►Nper_event_statistics
CPerEventStatisticsGetterModule
►Npickable_basf2
CBASF2StateRecorder
►NpidTrainWeights
CWeightNet
►Nplotting
CBox
CCorrelation
CCorrelationMatrix
CDiagonal
CDifference
CDistribution
CImportance
CMultiplot
COvertraining
CPlotter
CPrecisionRecallCurve
CPurityAndEfficiencyOverCut
CPurityOverEfficiency
CRejectionOverEfficiency
CSignalToNoiseOverCut
CTrueVsFalsePositiveRate
CTSNE
CVerboseDistribution
►Npreprocessing
Cfast_equal_frequency_binning
►NprintPIDLikelihoods
CprintPIDLikelihoods
►NpriorDataLoaderAndModel
CPriorDataLoader
CPriorModel
►Nread_array_example
CPXDReader
►Nregister_pystorearray
CParticleStatisticsModule
CSillyGeneratorModule
►Nrelations
Cearly_stopping
►Nrundb
CRunDB
►Nsimple
CModel
CmyModel
►Nsqlite	C++ wrapper around the sqlite C Api for convenient use of SQLite statements in C++
►Ndetail
CColumnFiller	Struct to fill the different columns in a sqlite result row into a std::tuple
CParameterBinder	Bind the given parameter to the sqlite statement
CConnection	Simple wrapper for a SQLite database connection
►CObjectStatement	SQLite prepared statement wrapper
Citerator	Iterator class to allow iterating over the rows
CSQLiteError	Simple error class to be thrown if there is any sqlite error on any of the operations
►Nstd	STL namespace
Chash< std::set< int > >	Hash function used by unordered_set
►Nsysvar
CReweighter
CReweighterParticle
►Nterminal_utils
CANSIColors
CInputEditor
CPager
►Ntest6_CPVFlavorTaggerEfficiency
CQuiet
►Ntflat
►Nmodel
CMyConcatenate
►Ntorch_tcce
CTCCE
►NTreeFitter
CComposite	A class for composite particles, where the daughters must be ignored by the fitter
CConstraint	Class to manage the order of constraints and their filtering
CConstraintConfiguration	Constraint configuration class
CDecayChain	This class does a lot of stuff: Build decaytree structure allowing to index particles and handle the filtering of constraints across the tree
CErrCode	Abstract errorocode be aware that the default is success
CFitManager	This class
CFitParameterDimensionException	Exception template, runtime_error implements what()
CFitParams	Class to store and manage fitparams (statevector)
CHelixUtils	Utility for helix<->x,p conversions
CInternalParticle	Another unnecessary layer of abstraction
CKalmanCalculator	Does the calculation of the gain matrix, updates the cov and fitpars
CMergedConstraint	Merge multiple constraints that we want to project simultaneously
COrigin	Representation of the beamspot as a particle
CParticleBase	Base class for all particles
CProjection	Class to store the projected residuals and the corresponding jacobian as well as the covariance matrix in the system of residuals
CRecoNeutral	Representation of the neutral particle constraint
CRecoParticle	Base for RecoNeutral RecoTrack
CRecoResonance	A class for resonances
CRecoTrack	Representation of all charged final states FIXME rename since this name is taken in tracking
CResonance	Class for resonances as internal particles
►Nvariables
►Nutils
CDecayParticleNode
CPythonVariableManager
►Nwrite_test_files
CModel
CTrivialModel
Ccycle_detector	Simple struct to check boost graph for cyclic references
CLogModRealm	Class to modify the log level dependent on the execution realm
CLogVar	Class to store variables with their name which were sent to the logging service
CLogVariableStream	Specialized implementation of an ostream-like class where the << operator can be used to insert values
►Cstring	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
►Cvector	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class