| ►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 | |
| ►Ntheano | |
| 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 |
| 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 |
| CBoostPythonModuleProxy | Proxy class to register python modules (the things you can 'import') |
| 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 |
| 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 |
| CRunInfo | Database object for Run Information |
| 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 | |
| ►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 | |
| ►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 |
1.13.2