| ►C_HelpAction | |
| CFullHelpAction | |
| ►CAbstractBooleanNode< AVariableManager > | A parsed cut-string naturally has a tree shape which incorporates the infomation of operator precedence and evaluation order of the statements |
| CBinaryBooleanNode< AVariableManager > | Nodeclass with two AbstractBooleanNode as children and a Boolean Operator (AND, OR) Check() method evaluates the child nodes and returns the result of the boolean operation |
| CBinaryRelationalNode< AVariableManager > | BooleanNode which has two AbstractExpressionNodes nodes and a ComparisonOperator |
| CTernaryRelationalNode< AVariableManager > | BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator |
| CUnaryBooleanNode< AVariableManager > | Nodeclass with a single AbstractBooleanNode as child |
| CUnaryRelationalNode< AVariableManager > | Nodeclass with a single AbstractExpressioNode as child |
| ►CAbstractExpressionNode< AVariableManager > | AbstractExpressionNode Superclass for all nodes which host expressions |
| CBinaryExpressionNode< AVariableManager > | BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation |
| CDataNode< AVariableManager, T > | Template class for storing the Constants (int, double, bool) of the Cutstring |
| CFunctionNode< AVariableManager > | FunctionNode Node class for handling MetaVariables in cuts |
| CIdentifierNode< AVariableManager > | Class which stores the name of a variable |
| CUnaryExpressionNode< AVariableManager > | UnaryExpressionNode Node class with a single expression node as child |
| ►CAbstractInterface | Abstract Interface to third-party MVA libraries |
| CInterface< TemplateOptions, TemplateTeacher, TemplateExpert > | Template class to easily construct a interface for an MVA library using a library-specific Options, Teacher and Expert class |
| CAnalysisConfiguration | Singleton class keeping configurables of analysis components |
| CBFieldComponentQuad::ApertPoint | Aperture data structure |
| CArrayIterator< ArrayType, ValueType > | Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc |
| CDisplayData::Arrow | Stores data associated with an arrow |
| CAttrDict | |
| ►CAuthBase | |
| CBearerAuth | |
| CB2Vector3< DataType > | A fast and root compatible alternative to TVector3 |
| CB2Vector3< double > | |
| CB2Vector3< float > | |
| CBackgroundInfo::BackgroundDescr | Structure for background description |
| ►CBASE | |
| ►CRelationsInterface< BASE > | Defines interface for accessing relations of objects in StoreArray |
| CAWESOMESimHit | A Geant4 simulated hit for the AWESOME detector |
| CBelleTrkExtra | Class stores mdst_trk_fit information for each track |
| CBtube | For each MCParticle with hits in the CDC, this class stores some summarising information on those hits |
| CCluster | Class to collect log likelihoods from Clusters from ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability |
| CContinuumSuppression | This is a class for collecting variables used in continuum suppression |
| CDigitBase | A common base for subdetector Digits |
| CECLCluster | ECL cluster data |
| CECLEnergyCloseToTrack | Class to store energy information for ECL hits closest to a track |
| CECLTriggerCell | ECL Trigger cells |
| CEventKinematics | Class for collecting variables related to the global kinematics of the event |
| CEventShapeContainer | Class for collecting the basic objects related to the event shape |
| CFlavorTaggerInfo | This class stores the relevant information for the TagV vertex fit, extracted mainly from the Flavor Tagging Module |
| CFlavorTaggerInfoMap | This class stores the Flavor Tagger information for a specific method and particle filled in the Flavor Tagger Module |
| ►CHelix | This class represents an ideal helix in perigee parameterization |
| CUncertainHelix | This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters |
| CKLMCluster | KLM cluster data |
| CKink | Object holding information for Kinks |
| CKlId | Klong identifcation (KlId) datastore object to store results from KlId calculations |
| ►CMCParticle | A Class to store the Monte Carlo particle information |
| CMCParticleGraph::GraphParticle | Class to represent Particle data in graph |
| 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 |
| CParticle | Class to store reconstructed particles |
| 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 |
| CSoftwareTriggerResult | Dataobject to store the results of the cut calculations performed by the SoftwareTriggerModule |
| CStringWrapper | This class is a wrapper for strings, such as MCDecayStrings, to allow them to be associated with particles via a relation |
| 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 |
| CTagVertex | TagVertex data object: contains Btag Vertex and DeltaT |
| CTauPairDecay | Class for collecting variables related to tau-taubar MC decay process |
| CTrack | Class that bundles various TrackFitResults |
| CTrackFitResult | Values of the result of a track fit with a given particle hypothesis |
| CV0 | Object holding information for V0s |
| ►CBaseAngle | Class to compare if two angles are compatible withing a given error range |
| CPhiAngle | |
| CThetaAngle | |
| ►CBaseConstraint | Abstract base class for constraints of kinematic fits |
| ►CBaseHardConstraint | Abstract base class for constraints of kinematic fits |
| ►CParticleConstraint | Abstract base class for constraints of 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 |
| CRecoilMassConstraint | |
| ►CBaseSoftConstraint | Abstract base class for soft constraints of kinematic fits |
| ►CSoftGaussParticleConstraint | Abstract base class for constraints of kinematic fits |
| 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 |
| CTrackConstraint | Abstract base class for constraints of kinematic fits |
| CBaseDefs | |
| CBaseEvent | |
| ►CBaseFitObject | |
| ►CParticleFitObject | |
| CISRPhotonFitObject | |
| CJetFitObject | Class for jets with (E, eta, phi) in kinematic fits |
| CNeutrinoFitObject | |
| CPxPyPzMFitObject | |
| ►CBaseFitter | Abstract base class for fitting engines of kinematic fits |
| CNewFitterGSL | A kinematic fitter using the Newton-Raphson method to solve the equations |
| CNewtonFitterGSL | |
| COPALFitterGSL | Description of the fit algorithm and interface: |
| CBaseJetPairing | Abstract base class for jet pairings |
| ►CBaseTracer | Abstract base class for trace objects of kinematic fits |
| CTextTracer | |
| CBasf2ModulesInformation | |
| CBASF2StateRecorder | |
| Cbatch_generator | |
| Cbatch_generator | |
| CBeamlineFieldMapInterpolation | The BeamlineFieldMapInterpolation class |
| CBeamParametersFitter | Fitter calculating BeamParameters from CollisionBoostVector and CollisionInvariantMass |
| ►CBFieldComponentAbs | The BFieldComponentAbs class |
| CBFieldComponent3d | The BFieldComponent3d class |
| CBFieldComponentBeamline | The BFieldComponentBeamline class |
| CBFieldComponentConstant | The BFieldComponentConstant class |
| CBFieldComponentKlm1 | The Bfieldcomponentklm1 class |
| CBFieldComponentQuad | The BFieldComponentQuad class |
| CBFieldComponentRadial | The BFieldComponentRadial class |
| CBFieldManager | Bfield manager to obtain the magnetic field at any point |
| CBFieldMap | This class represents the magnetic field of the Belle II detector |
| CBFieldComponentKlm1::BFieldPoint | Trivial struct representing rz coordinate |
| CBFieldComponentRadial::BFieldPoint | Magnetic field data structure |
| CBinning | Binning of a data distribution Provides PDF and CDF values of the distribution per bin |
| CBoostPythonModuleProxy | Proxy class to register python modules (the things you can 'import') |
| CBundle | Class to contain particles identified to come from the same actual/mc particle |
| CMetadataProvider::PayloadMetadataCache::CacheEntry | Each cache entry |
| Ccal_scale_error_func_set_t | Structure type cal_scale_error_func_set_t |
| CCalcMeanCov< N, RealType > | Class to calculate mean and and covariance between a number of parameters on running data without storing the actual values, also for weighted entries |
| CCalcMeanCov< 2, value_type > | |
| ►CCalculation | |
| CBasf2Calculation | |
| CCalculationQueue | |
| CCalculationQueueItem | |
| CCaptureStreamAbortHandler | Small class to handle std::abort() calls by external libraries |
| CCharBuffer | Dynamic character buffer that knows its size |
| CCleoCones | Class to calculate the Cleo clone variables |
| CConst::ClusterDetectors | A class that defines the valid set of Cluster detectors |
| CClusterUtils | Class to provide momentum-related information from ECLClusters |
| CColumnFiller | Struct to fill the different columns in a sqlite result row into a std::tuple |
| CCommandIoVsHelper | |
| 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 |
| CConditionsDB | |
| CConfiguration | Class to enable configuration of the conditions database access in C++ and python |
| CConnection | Simple wrapper for a SQLite database connection |
| CConst | This class provides a set of constants for the framework |
| ►CConstraint | Class to manage the order of constraints and their filtering |
| CMergedConstraint | Merge multiple constraints that we want to project simultaneously |
| CConstraintConfiguration | Constraint configuration class |
| CCppOrPyList | Wrapper class for a list of strings to either be held in a std::vector or in a python list |
| ►CCreatorBase | Pure virtual base class for all geometry creators |
| CAWESOMEGeometryCreator | The creator for the AWESOME detector geometry |
| CGeoMagneticField | The GeoMagneticField class |
| CMyDBCreator | Very simple Creator class which actually does not do anything but shows how creators should implement loading the geometry from database |
| CCreatorFactory< T > | Very simple class to provide an easy way to register creators with the CreatorManager |
| CCreatorManager | Class to manage all creators and provide factory access |
| CCurlSession | Struct encapsulating all the state information needed by curl |
| CDatabase | Singleton base class for the low-level interface to the database |
| CDataFlowVisualization | Class to visualize data flow between modules |
| ►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 |
| CCombinedDataset | Wraps two other Datasets, one containing signal, the other background events Used by the reweighting method to train mc files against data files |
| CMultiDataset | Wraps the data of a multiple event into a Dataset |
| CROOTDataset | Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods |
| CRegressionDataSet | Dataset needed during the training of a regression method |
| CReweightingDataset | Dataset for Reweighting Wraps a dataset and provides each data-point with a new weight |
| CSPlotDataset | Dataset for sPlot Wraps a dataset and provides each data-point twice, once as signal and once as background |
| 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 |
| CSubDataset | Wraps another Dataset and provides a view to a subset of its features and events |
| CDataStore | In the store you can park objects that have to be accessed by various modules |
| CDataStorePrinter | |
| CDataStoreStreamer | Stream/restore DataStore objects to/from EvtMessage |
| ►CDBAccessorBase | Base class for DBObjPtr and DBArray for easier common treatment |
| CDBObjPtr< Belle2::BeamSpot > | |
| CDBObjPtr< Belle2::CollisionBoostVector > | |
| CDBObjPtr< Belle2::CollisionInvariantMass > | |
| CDBObjPtr< Belle2::CollisionAxisCMS > | |
| CDBObjPtr< Belle2::MagneticField > | |
| CDBObjPtr< Belle2::BeamParameters > | |
| CDBObjPtr< Belle2::ChargedPidMVAWeights > | |
| CDBObjPtr< Belle2::ECLPhotonEnergyResolution > | |
| CDBObjPtr< Belle2::DatabaseRepresentationOfWeightfile > | |
| CDBObjPtr< Belle2::ParticleWeightingLookUpTable > | |
| CDBObjPtr< Belle2::GeoConfiguration > | |
| CDBObjPtr< Belle2::PIDCalibrationWeight > | |
| CDBObjPtr< Belle2::PIDDetectorWeights > | |
| CDBObjPtr< Belle2::PIDNeuralNetworkParameters > | |
| ►CDBArray< T > | Class for accessing arrays of objects in the database |
| COptionalDBArray< T > | Optional DBArray: This class behaves the same as the DBArray except that it will not raise errors when an object could not be found in the database |
| ►CDBObjPtr< T > | Class for accessing objects in the database |
| COptionalDBObjPtr< Belle2::BeamSpot > | |
| COptionalDBObjPtr< Belle2::CollisionBoostVector > | |
| COptionalDBObjPtr< Belle2::CollisionInvariantMass > | |
| COptionalDBObjPtr< Belle2::CollisionAxisCMS > | |
| COptionalDBObjPtr< Belle2::ECLPhotonEnergyResolution > | |
| COptionalDBObjPtr< Belle2::ParticleWeightingLookUpTable > | |
| COptionalDBObjPtr< T > | Optional DBObjPtr: This class behaves the same as the DBObjPtr except that it will not raise errors when an object could not be found in the database |
| CDBObjPtr< PayloadFile > | Specialization of DBObjPtr in case of PayloadFiles |
| CPyDBArray | Class to access a DB Array from Python |
| CPyDBObj | Class to access a DBObjPtr from Python |
| ►CDBImportBase | Base class for importing objects to the database |
| CDBImportArray< T > | Class for importing array of objects to the database |
| CDBImportObjPtr< T > | Class for importing a single object to the database |
| CDatabase::DBImportQuery | Struct for bulk write queries |
| CDBPointer< T, KEY, METHOD, NAME > | Class for pointing to an element in an array stored in the database |
| CDBStore | Singleton class to cache database objects |
| CDBStoreEntry | Class to hold one entry from the ConditionsDB in the DBStore |
| CDecayChain | This class does a lot of stuff: Build decaytree structure allowing to index particles and handle the filtering of constraints across the tree |
| 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 |
| CDecayHashMap | |
| CDecayNode | DecayNode describes the decay of a particle identified by its pdg code, into list of daughters |
| CDecayParticleNode | |
| CDecayStringDecay | Holds the information of a decay |
| CDecayStringParticle | Holds the information of a particle in the decay string |
| CDecayTree< T > | This is a helper class for the MCDecayFinderModule |
| CZMQLogger::Decrementor | Visitor Helper for decrementing a numerical value |
| CDependencyMap | Collect information about the dependencies between modules |
| CDeprecateProxy | Internal class that registers a variable as deprecated |
| ►CConst::DetectorSet | For sets of detector IDs in the form of EDetector values |
| CConst::RestrictedDetectorSet< ASetType > | A class for sets of detector IDs whose content is limited to restricted set of valid detector IDs |
| CDetectorSurface | Detector surfaces information |
| CDetSurfCylBoundaries | Simple class to encapsulate a detector surface's boundaries in cylindrical coordinates |
| ►Cdfs_visitor | |
| Ccycle_detector | Simple struct to check boost graph for cyclic references |
| CDownloader | Simple class to encapsulate libcurl as used by the ConditionsDatabase |
| Cearly_stopping | |
| CRelationIndexContainer< FROM, TO >::Element | Element type for the index |
| 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 |
| ►CEnvironmentInformation | |
| CBasf2EnvironmentInformation | |
| CEnvironmentVariables | Utility functions related to environment variables |
| CEqualVisitor | Seperate Visitor struct for equal_to comparison of variant<double, int bool> |
| CErrCode | Abstract errorocode be aware that the default is success |
| CEventMetaDataSerialization | Helper class for (de)serializing the event meta data used for the event backup transferral |
| ►CEventProcessor | Core event processing loop |
| CSubEventModule | Framework-internal module that implements the functionality of Path::forEach() as well as Path::doWhile() |
| CZMQEventProcessor | This class provides the core event processing loop for parallel processing with ZMQ |
| CpEventProcessor | This class provides the core event processing loop for parallel processing |
| CEventT0::EventT0Component | Structure for storing the extracted event t0s together with its detector and its uncertainty |
| CEvtHeader | Header structure of streamed object list |
| CEvtMessage | Class to manage streamed object |
| ►CExamplesTest | |
| CExamplesTest | Extend the examples test class to actually run over the uncategorized examples: |
| CExamplesTest | Extend the examples test class to actually run over the FEI examples: |
| CExamplesTest | Extend the examples test class to actually run over the fitting examples: |
| CExamplesTest | Extend the examples test class to actually run over the GraFEI examples: |
| CExamplesTest | Extend the examples test class to actually run over the mva examples: |
| CExamplesTest | Extend the examples test class to actually run over the PID calibration examples: |
| CExamplesTest | Extend the examples test class to actually run over the post mdst identification examples: |
| CExamplesTest | Extend the examples test class to actually run over the reconstruction examples: |
| CExamplesTest | Extend the examples test class to actually run over the simulation examples: |
| CExamplesTest | Extend the examples test class to actually run over the tagging examples: |
| CExamplesTest | Extend the examples test class to actually run over the variable manager examples: |
| ►CException | |
| CClassVersionError | |
| CErrorWithExtraVariables | |
| CRunningTagUpdaterError | |
| CInvalidLCAMatrix | |
| ►Cexception | STL class |
| ►Cruntime_error | STL class |
| CEventProcessor::StoppedBySignalException | Exception thrown when execution is stopped by a signal |
| CFitParameterDimensionException | Exception template, runtime_error implements what() |
| CSQLiteError | Simple error class to be thrown if there is any sqlite error on any of the operations |
| ►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 |
| CCombinationExpert | Expert for the Combination MVA method |
| CFANNExpert | Expert for the FANN MVA method |
| CFastBDTExpert | Expert for the FastBDT MVA method |
| CPDFExpert | Expert for the PDF MVA method |
| CPythonExpert | Expert for the Python MVA method |
| CRegressionExpert< BaseClassifierExpert, RegressionClassifierOptions > | Generic expert for the regression applications |
| CReweighterExpert | Expert for the Reweighter MVA method |
| ►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 |
| CTrivialExpert | Expert for the Trivial MVA method |
| Cfast_equal_frequency_binning | |
| CFileCatalog | This class provides an interface to the file (metadata) catalog |
| CFileSystem | Utility functions related to filename validation and filesystem access |
| CFitManager | This class |
| CFitParams | Class to store and manage fitparams (statevector) |
| ►CFormulaParserBase | Base class with the non-templated part of the formula parser |
| CFormulaParser< VariableConstructor > | FormulaParser to parse a text formula like "a + b * c ^ d" where the separate parts can be either variables (with and without arguments) or numbers |
| CFourVector | Yet another four vector class, with metric +— |
| 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 |
| 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< AVariableManager > | 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- |
| CGeometryManager | Class to manage the creation and conversion of the geometry |
| CGlobalProcHandler | A class to manage processes for parallel processing |
| CGraFEIIgniteTrainer | |
| ►Cgrammar | |
| CDecayStringGrammar< Iterator > | This class describes the grammar and the syntax elements of decay strings |
| CGroupProxy | Internal class that registers a variable group with Manager when constructed |
| CHarmonicMoments | Class to calculate the Harmonic moments up to order 8 with respect to a given axis |
| Chash< std::set< int > > | Hash function used by unordered_set |
| CHelixUtils | Utility for helix<->x,p conversions |
| CHistograms | |
| CHitPatternCDC | Hit pattern of CDC hits within a track |
| CHitPatternVXD | Hit pattern of the VXD within a track |
| CRelationArray::Identity | Struct for identity transformation on indices |
| CZMQLogger::Incrementor | Visitor Helper for incrementing a numerical value |
| ►CInputContext | Class representing a resource context for gearbox |
| CFileContext | InputContext which serves the content of a plain file |
| CStringContext | InputContext which just returns the value of a string previously assigned |
| CInputController | A static class to control supported input modules |
| ►CInputHandler | Class to provide an InputContext for a given XML resource name |
| CFileHandler | InputHandler which will read XML from plain files, optionally gzip compressed |
| CStringHandler | InputHandler which just takes the uri as XML data |
| CInputHandlerFactory< T > | Helper class to easily register new input handlers |
| CInterceptorScopeGuard< T > | Simple RAII guard for output interceptor |
| ►CInterceptOutput< STDOUT, STDERR > | Class to intercept stdout and stderr and either capture, discard or keep them unmodified depending on the template arguments |
| COutputToLogMessages | Capture stdout and stderr and convert into log messages |
| ►CInterface | Exception to be thrown in case of an empty result |
| CGearDir | GearDir is the basic class used for accessing the parameter store |
| CGearbox | Singleton class responsible for loading detector parameters from an XML file |
| CIntervalOfValidity | A class that describes the interval of experiments/runs for which an object in the database is valid |
| CIntervalOfValidity | |
| ►Cios_base | STL class |
| ►Cbasic_ios< Char > | STL class |
| ►Cbasic_istream< Char > | STL class |
| ►Cbasic_iostream< Char > | STL class |
| ►Cbasic_fstream< Char > | STL class |
| ►Cfstream | STL class |
| CFileSystem::TemporaryFile | Helper file to create a temporary file and ensure deletion if object goes out of scope |
| ►Cbasic_ostream< Char > | STL class |
| Cbasic_iostream< Char > | STL class |
| CIoVSet | |
| ►CIPythonHandler | |
| CBasf2IPythonHandler | |
| ►CIPythonWidget | |
| CDependencyViewer | |
| CModuleViewer | |
| CPathViewer | |
| CCollectionsViewer | |
| CLogViewer | |
| CProgressBarViewer | |
| CStatisticsViewer | |
| ►CStylingWidget | |
| CStylingWidget | |
| CBFieldComponentQuad::irange_t | Start and stop indicies to narrow search in array |
| CItemFilter | |
| CConst::DetectorSet::Iterator | Iterator |
| ►Citerator | |
| CObjectStatement< ObjectType, Columns >::iterator | Iterator class to allow iterating over the rows |
| CKalmanCalculator | Does the calculation of the gain matrix, updates the cov and fitpars |
| CKeepStream | Dummy class which keeps the stream unmodified |
| CRawRootFile.Key | |
| CKeyValuePrinter | Create human-readable or JSON output for key value pairs |
| ►CKFitBase | KFitBase is a base class for kinematical fitters |
| CFourCFitKFit | FourCFitKFit is a derived class from KFitBase to perform 4 momentum-constraint kinematical fit |
| 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 |
| 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 |
| CKFitConst | KFitConst is a container of constant names |
| CKFitError | KFitError is a container of error codes and a macro function |
| CKFitTrack::KFitPXE | KFitPXE is a container of the track information (Lorentz vector, position, and error matrix) |
| 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 |
| CKlongCalculatorUtils | Utility class to calculate the Klong kinematics |
| CKsfwMoments | Moment-calculation of the k_sfw improved Super-Fox-Wolfram moments |
| CLabToCms | Class implementing general Lorentz Transformation between LAB and CMS system |
| ►CLatexObject | |
| CDefineColourList | |
| CGraphics | |
| CItemize | |
| CLatexFile | |
| CListing | |
| CLongTable | |
| CSection | |
| CString | |
| CSubSection | |
| CSubSubSection | |
| CTitlePage | |
| CListIndexGenerator | ListIndexGenerator is a generator for all the combinations of the sublists (FlavorSpecificParticle = 0, SelfConjugatedParticle = 1) of a set of particle lists |
| CLocalMetadataComparison | |
| CLocalMetadataProvider | |
| CFileSystem::Lock | Helper class for locking a file |
| 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 |
| CLogMethod | The LogMethod class |
| CLogModRealm | Class to modify the log level dependent on the execution realm |
| CLogPythonInterface | Thin wrapper to expose a usable interface to the logging framework in python |
| CLogReplacementFilter | |
| CLogSystem | Class for logging debug, info and error messages |
| 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 |
| ►CMagneticFieldComponent | Abstract base class for BField components |
| CBFieldFrameworkInterface | Simple BFieldComponent to just wrap the existing BFieldMap with the new BFieldManager |
| CMagneticFieldComponent3D | Describe one component of the Geometry |
| CMagneticFieldComponentConstant | Describe one component of the Geometry |
| CMakeMotherKFit | MakeMotherKFit is a class to build mother particle from kinematically fitted daughters |
| CMakeROOTCompatible | Helper class for converting strings into a ROOT-friendly format (e.g.: removing special characters in branch names, etc.) |
| CManager | Global list of available variables |
| 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) |
| CRestOfEvent::Mask | Structure of Rest of Event mask |
| CMaterials | Thin wrapper around the Geant4 Material system |
| CMCMatching | Functions to perform Monte Carlo matching for reconstructed Particles |
| CMCParticleGraph | Class to build, validate and sort a particle decay chain |
| CMemoryPool< T, chunkSize > | Class to provide a constant access time memory pool for one kind of objects |
| CMemoryPool< Belle2::MCParticleGraph::GraphParticle > | |
| CProfileModule::MemTime | An internal struct to store pairs of memory usage and time |
| ►CMetadataProvider | Base class for a payload metadata provider |
| CCentralMetadataProvider | Class to obtain payload metadata from the central database server via REST requests |
| CLocalMetadataProvider | Class to obtain metadata of all valid payloads from a local SQLite file instead of the central server |
| 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 |
| CMetadataService | This class provides a service for writing metadata about the basf2 execution and about output files to a json file |
| CMethod | |
| ►CModule | |
| CPrintCollections | |
| CProgressPython | |
| ►CModule | |
| CMinModule | |
| CMinModule | |
| CAccessingDataStoreModule | |
| CAccessingDataStoreModule | |
| CfitDeltaT | |
| CGraFEIModule | |
| CLCASaverModule | |
| CTestingModule | |
| CCheckPayloadMetadata | |
| CCheckPayloadNames | |
| CaddECLCalDigitsModule | |
| CcheckNumOutOfTimeDigitsModule | |
| CprintPIDLikelihoods | |
| ►CModule | |
| CVariablesToHDF5 | |
| CGenerator | |
| CNumBestChecker | |
| CRankChecker | |
| CNoopModule | |
| CTestModule | |
| CPrinterModule | |
| CCountEvents | |
| CEvtMetaDataTest | |
| CNoopModule | |
| CTestModule | |
| CDelayEvents | |
| CPrintName | |
| CReturnFalse | |
| CSelectOddEvents | |
| CCheckEventNumbers | |
| CCountEvents | |
| CPerEventStatisticsGetterModule | |
| CCountEvents | |
| CTestModule | |
| CParticleStatisticsModule | |
| CSillyGeneratorModule | |
| CBrokenEventsModule | |
| CNoopModule | |
| CTestingModule | |
| CTestModule | |
| CTestModule | |
| CErrorInEvent | |
| CErrorInInit | |
| CMVAExtraInfoChecker | |
| ►CModule | |
| CEdgeLayer | |
| CGlobalLayer | |
| CNodeLayer | |
| CMultiTrainLoss | |
| CWeightNet | |
| CTCCE | |
| ►CModule | |
| CDefaultModel | |
| CLayer | |
| CMultilayerPerceptron | |
| ►CModule | |
| CmyModel | |
| CGraFEIModel | |
| CPriorModel | |
| CmyModel | |
| CModuleCondition | Wraps a condition set on a Module instance |
| CDependencyMap::ModuleInfo | Stores information on inputs/outputs of a module, as obtained by requireInput()/optionalInput()/registerEntry(); |
| CModuleManager | The ModuleManager Class |
| ►CModuleParamBase | Base class for module parameter |
| CModuleParam< T > | A single parameter of the module |
| 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 |
| CModuleStatistics | |
| CMRUCache< KEY, VALUE > | Class implementing a generic Most Recently Used cache |
| CMRUCache< std::string, Belle2::Gearbox::PathValue > | |
| CMRUCache< std::string, G4Material * > | |
| 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 |
| CMyFancyClassifier | |
| CNode | |
| CNodeFactory | Wrapper class for static node compile functions |
| CObjArrayIterator< ArrayType, ValueType > | Optimizes class to iterate over TObjArray and classes inheriting from it |
| CObjectStatement< ObjectType, Columns > | SQLite prepared statement wrapper |
| CObjectStatement< Belle2::Conditions::PayloadMetadata, std::string, std::string, std::string, std::string, std::string, int, int, int, int, int > | |
| CObjectStatement< std::string > | |
| ►COptions | Abstract base class of all Options given to the MVA interface |
| CGeneralOptions | General options which are shared by all MVA trainings |
| CMetaOptions | Meta Options which modify the underlying training by doing sPlot, Multiclass and HyperparameterSearch |
| ►CSpecificOptions | Specific Options, all method Options have to inherit from this class |
| ►CRegressionOptions< FastBDTOptions > | |
| CRegressionFastBDTOptions | Explicit template specification for FastBDTs for regression options |
| CCombinationOptions | Options for the Combination MVA method |
| CFANNOptions | Options for the FANN MVA method |
| CFastBDTOptions | Options for the FANN MVA method |
| CPDFOptions | Options for the PDF MVA method |
| CPythonOptions | Options for the Python MVA method |
| CRegressionOptions< BaseClassifierOptions > | Generic options of the Regression MVA methods hosting the number of bins (and the base classifier options) |
| CReweighterOptions | Options for the Reweighter 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 |
| CTrivialOptions | Options for the Trivial MVA method |
| CParameterBinder | Bind the given parameter to the sqlite statement |
| CBFieldComponentQuad::ParamPoint3 | Quadrupole lense data structure |
| CParticleAndWeight | This struct is used to store and sort the tag tracks |
| ►CParticleBase | Base class for all particles |
| ►CComposite | A class for composite particles, where the daughters must be ignored by the fitter |
| CRecoResonance | A class for resonances |
| ►CInternalParticle | Another unnecessary layer of abstraction |
| CResonance | Class for resonances as internal particles |
| COrigin | Representation of the beamspot as a particle |
| ►CRecoParticle | Base for RecoPhoton RecoTrack |
| CRecoKlong | Representation of the Klong constraint |
| CRecoPhoton | Representation of the photon constraint |
| CRecoTrack | Representation of all charged final states FIXME rename since this name is taken in tracking
|
| 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 |
| CParticleListHelper | Class to help managing creation and adding to ParticleLists |
| CConst::ParticleSet | A set of ParticleType objects, with defined order |
| CMCParticleGraph::ParticleSorter | Class to go over all the particles in the Graph an sort them in a sensible way |
| ►CConst::ParticleType | For identifying different particle types |
| CConst::ChargedStable | Provides a type-safe way to pass members of the chargedStableSet set |
| CConst::Cluster | Provides a type-safe way to pass members of the clusterSet set |
| CParticleWeightingAxis | Class for handling LookUp tables |
| CParticleWeightingBinLimits | Just pair of numbers - min and max values of bin border |
| CParticleWeightingKeyMap | Class for handling KeyMap |
| ►CPathElement | Base for classes that can be elements of a Path |
| ►CModule | Base class for Modules |
| CAWESOMEBasicModule | The AWESOME basic module |
| CAllParticleCombinerModule | This module combines all particles of the provided list to one mother particle |
| CAnalysisConfigurationModule | Class to hold general basf2 configuration Used to initiate and configure CreateAnalysis object |
| CAsyncWrapper | Wraps a given Module to execute it asynchronously |
| 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 |
| CB2BIIMdstInputModule | Module reads Belle MDST files and converts Belle_event record to Belle II EventMetaData StoreObjectPointer |
| 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 |
| CBestCandidateSelectionModule | Ranks particles by the values of a variable |
| 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 |
| CBtubeCreatorModule | Create a B particle from a Bbar particle |
| 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 |
| 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 |
| CDensityScalerModule | Scale density of simulation/reconstruction geometry |
| 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 |
| CEnergyBiasCorrectionModule | Energy bias correction |
| CEventErrorFlagModule | Module to check or add error flags of the EventMetaData |
| CEventInfoPrinterModule | The event meta data info module |
| CEventInfoSetterModule | Module to set event, run, experiment numbers |
| CEventKinematicsModule | Module to compute global quantities related to the event kinematics, like total missing energy and mass2, visible energy, etc |
| CEventLimiterModule | The EventLimiter module |
| CEventShapeCalculatorModule | Module to compute event shape variables starting from three lists of particle objects (tracks, gammas, Klongs) |
| 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 |
| CFixMergedObjectsModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', then Relations of the objects are corrected |
| 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 |
| CGearboxModule | The Gearbox module |
| CGeometryModule | Module to facilitate Geometry creation |
| 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 |
| CB2BIIMCParticlesMonitorModule | Declaration of class B2BIIMCParticlesMonitor |
| CInclusiveBtagReconstructionModule | Inclusively reconstructs anti-B:tag from input ParticleLists for given B:sig |
| CInclusiveDstarReconstructionModule | Inclusive D* reconstruction module |
| CInteractiveModule | Start an interactive python shell in each call of event() |
| CIoVDependentConditionModule | Module which sets its return value based on the fact, if the event is in the given run/exp interval or not |
| CKlongDecayReconstructorExpertModule | Reco missing module |
| CKlongMomentumCalculatorExpertModule | Reco missing module |
| CKlongMomentumUpdaterExpertModule | Calculate and update the two body B decay kinematics |
| CLowEnergyPi0IdentificationExpertModule | Calculation of low-energy pi0 identification value |
| CLowEnergyPi0VetoExpertModule | Calculation of low-energy pi0 veto value |
| CMCDecayFinderModule | Find decays in MCParticle list matching a given DecayString |
| 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 |
| 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 |
| CMergeDataStoreModule | Internal module used by Path.add_independent_merge_path() |
| 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 |
| COnlyWriteOutParticleListsModule | Marks all objects in DataStore except those of type ParticleList as WrtieOut=False |
| CParticleKinematicFitterModule | Kinematic fitter module |
| COverlapCheckerModule | The geometry overlap check module |
| CPIDCalibrationWeightCreatorModule | Module that creates WeightMatrix and uploads it to the DB |
| CPIDNeuralNetworkParametersCreatorModule | Module that creates PID neural network parameters and uploads them to the DB |
| CPartialSelectModule | The PartialSelect module |
| 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 |
| 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 |
| CParticleMCDecayStringModule | Adds the Monte Carlo decay string to a Particle |
| 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 |
| 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 |
| CParticleVertexFitterModule | Vertex fitter module |
| CParticleWeightingLookUpCreatorModule | Module that creates LookUpTable and upload it to the DB |
| CParticleWeightingModule | Module to append weights from the database into the extraInfo of Particles |
| CPhotonEfficiencySystematicsModule | Adds Photon Detection Efficiency Data/MC ratios To Particle List |
| CPi0VetoEfficiencySystematicsModule | Adds Pi0Veto Efficiency Data/MC ratios To Particle List |
| CPostMergeUpdaterModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', several kinematic properties might need fix |
| CPrescaleModule | The Prescale module |
| CPrintBeamParametersModule | Print the BeamParameters everytime they change |
| CPrintCollectionsModule | Prints the contents of DataStore in each event, listing all objects and arrays (including size) |
| CPrintMCParticlesModule | The PrintMCParticles module |
| CProfileModule | A module that measures the execution time and memory usage per event |
| 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 |
| CPyModule | Python wrapper for Belle2::Module |
| CRandomBarrierModule | Sets gRandom to an independent generator for the following modules |
| CRemoveParticlesNotInListsModule | Removes all Particles that are not in a given list of ParticleLists (or daughters of those) |
| 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 |
| CRootInputModule | Module to read TTree data from file into the data store |
| CRootOutputModule | Write objects from DataStore into a ROOT file |
| CRxModule | Module to decode data store contents from RingBuffer |
| CSelectDaughtersModule | Redefine (select) the daughters of a particle |
| CSeqRootInputModule | Module to read files produced by SeqRootOutputModule |
| CSeqRootOutputModule | Output module for sequential ROOT I/O |
| 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 |
| CStatisticsSummaryModule | A module that displays the sum of multiple modules in the module statistics |
| CSteerRootInputModule | Internal module used by Path.add_independent_merge_path() |
| 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 |
| 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 |
| CTheKillerModule | This Modules kills basf2 as horribly as possible (or selected) |
| CTrackFitResultEstimatorModule | Create a TrackFitResult from the momentum of a Particle and make a relation between them |
| CTrackIsoCalculatorModule | Calculate track isolation variables on the input ParticleList |
| 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 |
| CTreeFitterModule | Module to fit an entire decay tree |
| 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 |
| CV0DaughterMassUpdaterModule | This module replaces the mass of two daughters of the selected V0 particles inside the given particleLists with masses of given pdgCode |
| CVRMLWriterModule | The VRML-writer module |
| CVariableToReturnValueModule | Module to calculate variable specified by the user and set return value accordingly |
| 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 |
| 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 |
| 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 |
| CPath | Implements a path consisting of Module and/or Path objects |
| CPathIterator | Iterator over a Path (returning Module pointers) |
| CGearbox::PathOverride | Struct to override a path in the XML file with a custom value |
| CPathUtils | Helper utils for path arithmetics needed in the pEventProcessor |
| CGearbox::PathValue | Struct for caching results from the xml file |
| CPayloadFile | A wrapper class for payload files used by the Database and DBStore classes |
| CPayloadInformation | |
| CPayloadProvider::PayloadLocation | Simple struct to represent a lookup location |
| CPayloadMetadata | Simple struct to group all information necessary for a single payload |
| CMetadataProvider::PayloadMetadataCache | Simple caching structure to keep the payload information for this and the last exp/run |
| CPayloadProvider | Class to find payload files in a list of locations |
| CPCmsLabTransform | Class to hold Lorentz transformations from/to CMS and boost vector |
| CPIDCalibrationWeightUtil | Class to call calibration weight matrix |
| CConst::PIDDetectors | A class that defines the valid set of PID detectors |
| CPIDNeuralNetwork | Class to call PID neural network |
| CPIDPriorsTable | This class holds the prior distribution for a single particle species |
| ►CPlotter | |
| CBox | |
| CCorrelation | |
| CCorrelationMatrix | |
| CDiagonal | |
| CDifference | |
| CDistribution | |
| CImportance | |
| CMultiplot | |
| COvertraining | |
| CPurityAndEfficiencyOverCut | |
| CPurityOverEfficiency | |
| CRejectionOverEfficiency | |
| CSignalToNoiseOverCut | |
| CTSNE | |
| CVerboseDistribution | |
| CPostProcessingParticleWeighting | Post-processing particle weighting |
| CPrior | |
| CPriors | |
| 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 |
| CProcessStatisticsPython | Python interface for ProcessStatistics |
| CProcessViewer | |
| CProcHandler | A class to manage processes for parallel processing |
| CProjection | Class to store the projected residuals and the corresponding jacobian as well as the covariance matrix in the system of residuals |
| CProxy | Internal class that registers a variable with Manager when constructed |
| CPyStoreArray | A (simplified) python wrapper for StoreArray |
| CPyStoreObj | (simplified) python wrapper for StoreObjPtr |
| CPythonInitializerSingleton | Singleton class which handles the initialization and finalization of Python and numpy |
| CPythonVariableManager | |
| CQuiet | |
| CQuiet | |
| CRandomNumbers | The class for handling the random number generation |
| CBFieldComponentQuad::range_t | Range data structure |
| 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 |
| CRawRootFile | |
| CRbTupleManager | Class to manage histograms defined in registered modules |
| CRootInputModule::ReadStats | For collecting statistics over multiple files |
| ►CReferenceFrame | Abstract base class of all reference frames |
| CCMSFrame | CMS frame |
| CCMSRotationFrame | Stack frame for cms and Rotation frame |
| CLabFrame | Lab frame |
| CRestFrame | Rest frame of a particle |
| CRotationFrame | Rotation frame around vector |
| CRelationEntry | Struct for relations |
| CRelationIndex< FROM, TO > | Provides access to fast ( O(log n) ) bi-directional lookups on a specified relation |
| ►CRelationIndexBase | Baseclass for all RelationIndexContainers |
| CRelationIndexContainer< FROM, TO > | Class to store a bidirectional index between two StoreArrays |
| CRelationIndexManager | Manager to keep a cache of existing RelationIndexContainers |
| ►CRelationVectorBase | Base class for RelationVector<T> |
| CRelationVector< T > | Class for type safe access to objects that are referred to in relations |
| CRelationArray::ReplaceMap< MapType > | Struct to replace indices based on a map-like container |
| CRelationArray::ReplaceVec< VecType > | Struct to replace indices based on a sequential container |
| CReweighter | |
| CReweighterParticle | |
| 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 |
| CRootFileInfo | Helper class to factorize some necessary tasks when working with Belle2 output files |
| CRunDB | |
| CRunningTagUpdater | |
| ►CRuntimeError | |
| CConditionsDB.RequestError | |
| CScopeGuard | Simple ScopeGuard to execute a function at the end of the object lifetime |
| ►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 |
| ►CSelectSubsetBase | Type-independent implementation details of SelectSubset |
| ►CSelectSubset< Particle > | |
| CParticleSubset | Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists |
| CSelectSubset< Belle2::ECLCluster > | |
| CSelectSubset< Belle2::Track > | |
| CSelectSubset< Belle2::KLMCluster > | |
| CSelectSubset< Belle2::V0 > | |
| CSelectSubset< StoredClass > | Class to create a subset of a given StoreArray together with the relations with other StoreArrays |
| CSemaphoreLocker | Handles creation, locking and unlocking of System V semaphores |
| ►CSensitiveDetectorBase | |
| CAWESOMESensitiveDetector | Sensitive Detector implementation of the AWESOME detector |
| CSeqFile | A class to manage I/O for a chain of blocked files |
| CSizeT< size_t > | Helper construct for TMP that provides an index at compile time to recurse through type lists |
| ►CSoftwareTriggerCutBase | Base class for the SoftwareTriggerCut and its DBRepresentation |
| CDBRepresentationOfSoftwareTriggerCut | Class to handle storing SoftwareTriggerCuts in the database |
| 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 |
| CState | |
| CState | |
| CState | |
| CState | |
| CState | |
| CState | |
| CState | |
| ►Cstatic_visitor | |
| CconvertToPythonObjectVisitor | Helper function object to unpack a value from a variant to a python object |
| ►CStatistics | |
| CBasf2CalculationQueueStatistics | |
| CStatistics | |
| CStatisticsColumn | |
| CStatisticsVisitor | |
| ►CStoreAccessorBase | Base class for StoreObjPtr and StoreArray for easier common treatment |
| CStoreArray< Particle > | |
| CStoreArray< Belle2::MCParticle > | |
| CStoreArray< Belle2::AWESOMESimHit > | |
| CStoreArray< Belle2::Particle > | |
| CStoreArray< Belle2::ECLCluster > | |
| CStoreArray< Belle2::KLMCluster > | |
| CStoreArray< Belle2::Track > | |
| CStoreArray< Belle2::TrackFitResult > | |
| CStoreArray< Belle2::V0 > | |
| CStoreArray< Belle2::BelleTrkExtra > | |
| CStoreArray< Belle2::PIDLikelihood > | |
| CStoreArray< Belle2::Btube > | |
| CStoreArray< Belle2::ContinuumSuppression > | |
| CStoreArray< Belle2::RestOfEvent > | |
| CStoreArray< Belle2::FlavorTaggerInfo > | |
| CStoreArray< Belle2::FlavorTaggerInfoMap > | |
| CStoreArray< Belle2::StringWrapper > | |
| CStoreArray< StoredClass > | |
| CStoreArray< TObject > | |
| CStoreArray< Belle2::TagVertex > | |
| CStoreObjPtr< Belle2::ParticleList > | |
| CStoreObjPtr< Belle2::EventMetaData > | |
| CStoreObjPtr< Belle2::EventExtraInfo > | |
| CStoreObjPtr< Belle2::FileMetaData > | |
| CStoreObjPtr< Belle2::MCInitialParticles > | |
| CStoreObjPtr< Belle2::MergedEventConsistency > | |
| CStoreObjPtr< Belle2::EventKinematics > | |
| CStoreObjPtr< Belle2::ProcessStatistics > | |
| CStoreObjPtr< Belle2::EventShapeContainer > | |
| CStoreObjPtr< Belle2::ParticleExtraInfoMap > | |
| CStoreObjPtr< Belle2::RestOfEvent > | |
| CStoreObjPtr< Belle2::DisplayData > | |
| CStoreObjPtr< Belle2::RootMergeable< TTree > > | |
| CStoreObjPtr< Belle2::SetMergeable< std::unordered_set< uint64_t > > > | |
| CStoreObjPtr< Belle2::StringWrapper > | |
| CStoreObjPtr< Belle2::RandomGenerator > | |
| CStoreObjPtr< Belle2::TauPairDecay > | |
| CStoreObjPtr< Belle2::RootMergeable< TH1D > > | |
| CStoreObjPtr< Belle2::RootMergeable< TH2D > > | |
| CRelationArray | Low-level class to create/modify relations between StoreArrays |
| CStoreArray< T > | Accessor to arrays stored in the data store |
| CStoreObjPtr< T > | Type-safe access to single objects in the data store |
| CStoreContent | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| CStoreContentList | |
| CStoreEntry | Wraps a stored array/object, stored under unique (name, durability) key |
| CStreamHelper | Helper class for data store serialization |
| ►CStreamInterceptor | Base class with all necessary features to intercept output to a file descriptor |
| CCaptureStream | Class to capture anything written to stream into a string |
| CDiscardStream | Simple class to just discard anything written to stream by redirecting it to /dev/null |
| CStringFormulaConstructor | Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging |
| CDataStore::SwitchableDataStoreContents | Encapsulates DataStoreContents, but allows transparently switching between different versions ('DataStore IDs') |
| ►CTDatabasePDG | |
| CEvtGenDatabasePDG | Replacement for TDatabasePDG that is filled from EvtGen's evt.pdl |
| ►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 |
| CCombinationTeacher | Teacher for the Combination MVA method |
| CFANNTeacher | Teacher for the FANN MVA method |
| CFastBDTTeacher | Teacher for the FastBDT MVA method |
| CPDFTeacher | Teacher for the PDF MVA method |
| CPythonTeacher | Teacher for the Python MVA method |
| CRegressionTeacher< BaseClassifierTeacher, RegressionClassifierOptions > | Core class for the training of regression methods based on binary classifiers |
| CReweighterTeacher | Teacher for the Reweighter 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 |
| CTrivialTeacher | Teacher for the Trivial MVA method |
| CTempDirCreator | Changes working directory into a newly created directory, and removes it (and contents) on destruction |
| ►CTest | |
| CBeamSpotTest | |
| CChargedParticleIdentificatorTest | Test the MVA-based charged PID |
| CECLClusterTest | Test class for the Track object |
| CEventLevelTrackingInfoTest | Unit tests for the event level tracking information |
| CHitPatternCDCTest | Unit tests for the CDC hit Patterns |
| CHitPatternVXDTest | |
| CKlIdTest | Test class for the KlId object |
| CPIDPriorsTest | |
| CLogMessageTest | Test fixture to be able to check the contents and types of emitted log messages in detail |
| CTestWithGearbox | This class provides a test fixture managing the opening and closing of the Gearbox with the default geometry file |
| CTrackFitResultTest | Set up a few arrays and objects in the datastore |
| CTrackIsoScoreCalculatorTest | Test the calculation of the track helix-based isolation score per particle |
| CTrackTest | Test class for the Track object |
| CV0Test | Set up a few arrays and objects in the datastore |
| CeventShapeCoreAlgorithmTest | |
| ►CTestCase | |
| CTestAllParticleCombiner | |
| CAwesomeExamplesTest | |
| CExamplesTest | |
| CTestParticleCombiner | |
| CTestCopyLists | |
| CSetModuleParameters | |
| CSteeringFileTest | |
| CTestChargedCluster | |
| CTestEmbedding | |
| CTestGTForwarding | |
| CTestIntervalOfValidity | |
| CTestIoVSet | |
| CTestMbcEff | |
| CTest | |
| CTestParticleExtractorFromROE | |
| CTestParticleLoader | |
| CTestNewMCDecayFinder | |
| CTestMergeStaging | |
| CTestStdCharged | |
| CTestStdHyperons | |
| CTestStdPhotons | |
| CTestStdPi0s | |
| CTestStdV0 | |
| CTestSysVar | |
| CTestVariableCollections | |
| CMetavariableDataTypeTest | |
| CTestVariableUtilities | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTestTreeFits | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTutorialsTest | |
| CTestingPayloadEntry | |
| CTestingPayloadStorage | Class to store and retrieve temporary payloads |
| CTestParticleFactory | This is a class, which generates DataStore particles, according to the provided decay string e.g |
| CLogMessage::TextHasher | Helper struct to hash and compare messages only by log level and message content |
| CTfDataBasf2 | |
| CTfDataBasf2Stub | |
| CThreeVector | |
| CThrust | Class to calculate the thrust axis |
| CTimer | Small helper class that prints its lifetime when destroyed |
| ►CTMessage | |
| CInMessage | Reusable Message class derived from TMessage (for reading only) |
| ►CTObject | |
| CBeamSpot | This class contains the beam spot position and size modeled as a gaussian distribution in space |
| CBinnedEventT0 | Database object for storing a binned EventT0 coming from the trigger |
| CBunchStructure | Class to store the fill pattern of colliding bunches |
| CChargedPidMVAWeights | Class to contain the payload of MVA weightfiles needed for charged particle identification |
| 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 |
| CDBRepresentationOfSoftwareTriggerCut | Class to handle storing SoftwareTriggerCuts in the database |
| CDatabaseRepresentationOfWeightfile | Database representation of a Weightfile object |
| CDisplayData | Add custom information to the display |
| CECLPhotonEnergyResolution | Class to hold the information ECL energy resolution derived from PERC |
| CECLTRGInformation | Class to store information about ECL trigger cells (TCs) |
| CEventExtraInfo | Class to stores ExtraInfo of the whole event |
| 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) |
| CEventMetaData | Store event, run, and experiment numbers |
| CEventT0 | Storage element for the eventwise T0 estimation |
| CFileMetaData | Metadata information about a file |
| CGeoComponent | Describe one component of the Geometry |
| CGeoConfiguration | Configuration of the geometry |
| CGeoMaterial | Class to represent a material informaion in the Database |
| CGeoMaterialComponent | Component of a material |
| CGeoMaterialProperty | Property of a material |
| CGeoOpticalSurface | Represent an optical finish of a surface |
| CHardwareClockSettings | Database object containing the nominal accelerator RF value and the prescales to derive the clock frequencies of the sub-detectors |
| ►CIntraRunDependency | Base class for handling changing conditions during a run |
| CEventDependency | Class for handling changing conditions as a function of event number |
| ►CMCInitialParticles | This class contains the initial state for the given event |
| CBeamParameters | This class contains the nominal beam parameters and the parameters used for smearing of the primary vertex and the beam energy and momentum |
| CMagneticField | Magnetic field map |
| ►CMergeable | Abstract base class for objects that can be merged |
| CBackgroundInfo | This class stores the information about what background was mixed or overlayed |
| CBackgroundMetaData | Metadata information about the beam background file |
| CMapMergeable< T > | Wrap an STL map to make it mergeable |
| CProcessStatistics | Class to collect call statistics for all modules |
| CRootMergeable< T > | Wrap a root histogram or TNtuple to make it mergeable |
| CSetMergeable< T > | Wrap an STL set to make it mergeable |
| CMergedEventConsistency | Mark if we want to merge the DataStore of a combination of events or not |
| 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 |
| CPIDCalibrationWeight | Class for handling the PID calibration weight matrix |
| CPIDDetectorWeights | Class for handling the PID weights per detector, used to calculate the track helix isolation score per particle |
| CPIDNeuralNetworkParameters | Class for handling the parameters for the neural-network PID |
| CPIDPriors | A database class to hold the prior probability for the particle identification |
| CParticleExtraInfoMap | Internal class to store string -> index maps for extra info stored in Particle |
| CParticleList | ParticleList is a container class that stores a collection of Particle objects |
| CParticleWeightingLookUpTable | Class for handling LookUp tables |
| CProfileInfo | Store execution time and memory usage |
| CRelationContainer | Class to store relations between StoreArrays in the DataStore |
| CRelationElement | Class to store a single element of a relation |
| CRunInfo | Database object for Run Information |
| CSoftwareTriggerMenu | Class to handle storing the trigger menu in the database |
| 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 |
| CTTDOffsets | This class contains information to correct the information obtained from the TTD (simple offsets) |
| CTestChunkData | Storable object which can be filled with random chunk data of a certain size |
| CdEdxPDFs | Base class for holding the dE/dx PDFs |
| CZMQLogger::toJSON | Visitor Helper for converting a variant value into a JSON string |
| ►CTParticlePDG | |
| CEvtGenParticlePDG | Helper class for setting additional TParticlePDG members and storing the ones it doesn't have yet |
| CConst::TrackingDetectors | A class that defines the valid set of tracking detectors |
| CTrainer | |
| ►CTRandom | |
| CRandomGenerator | Fast Random number Generator using on xorshift1024* [arXiv:1402.6246] |
| CTRandomWrapper | Wrap TRandom to be useable as a uniform random number generator with STL algorithms like std::shuffle |
| Ctriangle_t | Triangle structure |
| CTriangularInterpolation | The TriangularInterpolation class |
| CTwoVector | |
| CType< T > | 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 arugment 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 |
| CUnit | The Unit class |
| CUseReferenceFrame< T > | A template class to apply the reference frame |
| CUtility | Wrapper class for some utility functions |
| ►CValue | |
| C__CompilationDbNode | |
| ►CManager::VarBase | Base class for information common to all types of variables |
| CManager::MetaVar | A variable taking string arguments returning a variable |
| CManager::ParameterVar | A variable taking additional floating-point arguments to influence the behaviour |
| CManager::Var | A variable returning a floating-point value for a given Particle |
| CVariableFormulaConstructor | Struct to construct new variable function objects from a name or a double value or to apply operations on these variable function objects |
| CVariadicType< T, Types > | Recursively convert multiple types to type names (used for tuples) |
| CVariadicType< T > | Recursively convert multiple types to type names (used for tuples) |
| CVisitor< operation > | This is a class template which takes a template class operation as template argument |
| CConst::VXDDetectors | A class that defines the valid set of VXD detectors |
| CWeightfile | Serializes all information about a training into an xml tree |
| CPIDDetectorWeights::WeightsTable | Nested class acting as a container the per-detector weights |
| Cxy_t | A simple 2d vector stucture |
| CZMQAddressUtils | Summary of some address helpers |
| CZMQClient | A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket |
| ►CZMQLogger | Base class for the ZMQ connection to help monitor and log certain values |
| ►CZMQConnection | Base class for every connection with virtual functions to be implemented: |
| ►CZMQConnectionOverSocket | Specialized connection over a ZMQ socket |
| CZMQConfirmedInput | Input part of a confirmed connection |
| CZMQConfirmedOutput | Output part of a confirmed connection |
| CZMQLoadBalancedInput | Input part of a load-balanced connection |
| CZMQLoadBalancedOutput | Output part of a load-balanced connection |
| 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 |
| CZMQSimpleConnection | Connection type to be used for answering simple requests, e.g |
| CZMQNullConnection | Connection doing just nothing: without the capability to pull, send or receive. Useful for template interfaces |
| CZMQMessageFactory | Helper class for creating new ID/No-ID messages |
| CZMQMessageHelper | Internal helper for creating ZMQ messages (should not be used otherwise) |
| CZMQModuleMessage< AMessageFrameNumber > | A general message with as many parts as given as template argument |
| ►CZMQModuleMessage< 3 > | |
| CZMQNoIdMessage | A message without an associated socket ID. Is used in most cases |
| ►CZMQModuleMessage< 4 > | |
| CZMQIdMessage | A message with the socket ID. Needed in input<->worker communication |
| CZMQParent | A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed |
| ►CDataset | |
| CPriorDataLoader | |
| ►CDirective | |
| CRenderDocstring | |
| ►CDomain | |
| CBasf2Domain | |
| ►CEnum | |
| CRunningTagUpdateMode | |
| ►CFormatter | |
| CDefaultValueFormatter | |
| ►CIndex | |
| CBasf2ModuleIndex | |
| CBasf2VariableIndex | |
| ►CInMemoryDataset | |
| CGraphDataSet | |
| ►CLayer | |
| CEnhancedRelations | |
| CRelations | |
| ►CLexer | |
| CB2Lexer | |
| CB2ParameterLexer | |
| ►CMetric | |
| CPerfectEvent | |
| CPerfectLCA | |
| CPerfectMasses | |
| ►CModule | |
| CPrintObjectsModule | |
| CCDCPlotModule | |
| CTestDoWhile | |
| CMakeRelations | |
| CMinModule | |
| CStopModule | |
| ►Cobject | |
| CState | |
| CPerfectEvent | |
| CPerfectLCA | |
| CPerfectMasses | |
| ►CObjectDescription | |
| CBasf2Object | |
| ►CProcess | |
| ►CCalculationProcess | |
| CBasf2CalculationProcess | |
| ►CPrompts | |
| CBasf2IPythonPrompt | |
| ►CTs | |
| CVisitOverload< Ts > | Helper struct for the C++17 std::visit overload pattern to allow simple use of variants |
1.9.6