| ►N081_module | |
| CMinModule | |
| ►N083_module | |
| CMinModule | |
| ►N085_module | |
| CAccessingDataStoreModule | |
| ►N087_module | |
| CAccessingDataStoreModule | |
| ►Nadversary_network | |
| Cbatch_generator | |
| ►Nallparticlecombiner | |
| CTestAllParticleCombiner | |
| ►Nawesome_examples | |
| CAwesomeExamplesTest | |
| ►NB0_GenDeltaTFit | |
| CfitDeltaT | |
| ►NB2A714-DeepContinuumSuppression_MVAModel | |
| Cbatch_generator | |
| ►Nb2bii_mdst_input | |
| CTestingModule | |
| ►Nb2pandas_utils | |
| CVariablesToHDF5 | |
| ►Nb2parser | |
| CB2ParameterLexer | |
| CB2Lexer | |
| ►Nb2test_utils | |
| ►Nclassversion | |
| CClassVersionError | |
| CErrorWithExtraVariables | |
| ►Ndatastoreprinter | |
| CDataStorePrinter | |
| CPrintObjectsModule | |
| ►Nlogfilter | |
| CLogReplacementFilter | |
| ►Nb2test_utils_analysis | |
| CExamplesTest | |
| ►NB2Tools | |
| ►Nb2latex | |
| CLatexObject | |
| CLatexFile | |
| CString | |
| CListing | |
| CDefineColourList | |
| CSection | |
| CSubSection | |
| CSubSubSection | |
| CGraphics | |
| CItemize | |
| CLongTable | |
| CTitlePage | |
| ►Nb2root | |
| ►CRawRootFile | |
| CKey | |
| ►Nformat | |
| CAttrDict | |
| CDefaultValueFormatter | |
| ►Nbase_examples | |
| CExamplesTest | Extend the examples test class to actually run over the uncategorized examples: |
| ►Nbasf2_mva_python_interface | |
| ►Nhep_ml | |
| CState | |
| ►Nkeras | |
| CState | |
| ►Nsklearn | |
| CState | |
| ►Ntensorflow | |
| CState | |
| ►Ntest | |
| CState | |
| ►Ntheano | |
| CState | |
| ►Nxgboost | |
| CState | |
| ►Nbasf2_mva_util | |
| CMethod | |
| ►Nbasf2domain | |
| CBasf2Object | |
| CBasf2ModuleIndex | |
| CBasf2VariableIndex | |
| CBasf2Domain | |
| ►Nbasf2ext | |
| CRenderDocstring | |
| ►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 |
| 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 |
| 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 |
| ►NAWESOME | |
| CAWESOMEGeometryCreator | The creator for the AWESOME detector geometry |
| CAWESOMEBasicModule | The AWESOME basic module |
| CAWESOMESensitiveDetector | Sensitive Detector implementation of the AWESOME detector |
| ►NConditions | |
| CCentralMetadataProvider | Class to obtain payload metadata from the central database server via REST requests |
| CCppOrPyList | Wrapper class for a list of strings to either be held in a std::vector or in a python list |
| CConfiguration | Class to enable configuration of the conditions database access in C++ and python |
| 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 |
| CCurlSession | Struct encapsulating all the state information needed by curl |
| ►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 |
| CStreamInterceptor | Base class with all necessary features to intercept output to a file descriptor |
| CKeepStream | Dummy class which keeps the stream unmodified |
| CDiscardStream | Simple class to just discard anything written to stream by redirecting it to /dev/null |
| CCaptureStream | Class to capture anything written to stream into a string |
| CInterceptOutput | 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 |
| CInterceptorScopeGuard | Simple RAII guard for output interceptor |
| CCaptureStreamAbortHandler | Small class to handle std::abort() calls by external libraries |
| ►NMVA | |
| 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 |
| CSingleDataset | Wraps the data of a single event into a Dataset |
| CMultiDataset | Wraps the data of a multiple event into a Dataset |
| CSubDataset | Wraps another Dataset and provides a view to a subset of its features and events |
| CCombinedDataset | Wraps two other Datasets, one containing signal, the other background events Used by the reweighting method to train mc files against data files |
| CROOTDataset | Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods |
| 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 |
| CAbstractInterface | Abstract Interface to third-party MVA libraries |
| CInterface | Template class to easily construct a interface for an MVA library using a library-specific Options, Teacher and Expert class |
| COptions | Abstract base class of all Options given to the MVA interface |
| CGeneralOptions | General options which are shared by all MVA trainings |
| CSpecificOptions | Specific Options, all method Options have to inherit from this class |
| CMetaOptions | Meta Options which modify the underlying training by doing sPlot, Multiclass and HyperparameterSearch |
| 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 |
| CWeightfile | Serializes all information about a training into an xml tree |
| CCombinationOptions | Options for the Combination MVA method |
| CCombinationTeacher | Teacher for the Combination MVA method |
| CCombinationExpert | Expert for the Combination MVA method |
| CFANNOptions | Options for the FANN MVA method |
| CFANNTeacher | Teacher for the FANN MVA method |
| CFANNExpert | Expert for the FANN MVA method |
| CFastBDTOptions | Options for the FANN MVA method |
| CFastBDTTeacher | Teacher for the FastBDT MVA method |
| CFastBDTExpert | Expert for the FastBDT MVA method |
| CPDFOptions | Options for the PDF MVA method |
| CPDFTeacher | Teacher for the PDF MVA method |
| CPDFExpert | Expert for the PDF MVA method |
| CPythonOptions | Options for the Python MVA method |
| CPythonTeacher | Teacher for the Python MVA method |
| CPythonExpert | Expert for the Python MVA method |
| CRegressionOptions | Generic options of the Regression MVA methods hosting the number of bins (and the base classifier options) |
| CRegressionDataSet | Dataset needed during the training of a regression method |
| CRegressionTeacher | Core class for the training of regression methods based on binary classifiers |
| CRegressionExpert | Generic expert for the regression applications |
| CRegressionFastBDTOptions | Explicit template specification for FastBDTs for regression options |
| CReweighterOptions | Options for the Reweighter MVA method |
| CReweighterTeacher | Teacher for the Reweighter MVA method |
| CReweighterExpert | Expert 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 |
| 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 |
| 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 |
| CTrivialOptions | Options for the Trivial MVA method |
| CTrivialTeacher | Teacher for the Trivial MVA method |
| CTrivialExpert | Expert for the Trivial MVA method |
| CPythonInitializerSingleton | Singleton class which handles the initialization and finalization of Python and numpy |
| CBinning | Binning of a data distribution Provides PDF and CDF values of the distribution per bin |
| CReweightingDataset | Dataset for Reweighting Wraps a dataset and provides each data-point with a new weight |
| CSidebandDataset | Dataset for Sideband Subtraction 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 |
| CUtility | Wrapper class for some utility functions |
| ►NOrcaKinFit | |
| CParticleKinematicFitterModule | Kinematic fitter module |
| 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 | |
| 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 |
| CType | 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) |
| CType< std::vector< 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::map< A, B > > | 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 |
| CType< int > | 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< float > | 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< std::string > | 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::tuple< Types... > > | 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< std::shared_ptr< Path > > | Some modules take a path as argument so let's add this as well |
| CSizeT | Helper construct for TMP that provides an index at compile time to recurse through type lists |
| CconvertToPythonObjectVisitor | Helper function object to unpack a value from a variant to a python object |
| ►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 |
| CTestWithGearbox | This class provides a test fixture managing the opening and closing of the Gearbox with the default geometry file |
| CTempDirCreator | Changes working directory into a newly created directory, and removes it (and contents) on destruction |
| CLogMessageTest | Test fixture to be able to check the contents and types of emitted log messages in detail |
| ►NUtils | General utility functions |
| CVisitOverload | Helper struct for the C++17 std::visit overload pattern to allow simple use of variants |
| CTimer | Small helper class that prints its lifetime when destroyed |
| ►NVariable | |
| ►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 |
| CGroupProxy | Internal class that registers a variable group with Manager when constructed |
| CDeprecateProxy | Internal class that registers a variable as deprecated |
| CClusterUtils | Class to provide momentum-related information from ECLClusters |
| CCleoCones | Class to calculate the Cleo clone variables |
| CFoxWolfram | Class to calculate the Fox-Wolfram moments up to order 8 |
| CHarmonicMoments | Class to calculate the Harmonic moments up to order 8 with respect to a given axis |
| CKsfwMoments | Moment-calculation of the k_sfw improved Super-Fox-Wolfram moments |
| 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 |
| CThrust | Class to calculate the thrust axis |
| CBtube | For each MCParticle with hits in the CDC, this class stores some summarising information on those hits |
| CContinuumSuppression | This is a class for collecting variables used in continuum suppression |
| CECLEnergyCloseToTrack | Class to store energy information for ECL hits closest to a track |
| CECLTRGInformation | Class to store information about ECL trigger cells (TCs) |
| 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 |
| CParticle | Class to store reconstructed particles |
| CParticleExtraInfoMap | Internal class to store string -> index maps for extra info stored in Particle |
| CStoreObjPtr | Type-safe access to single objects in the data store |
| CParticleList | ParticleList is a container class that stores a collection of Particle objects |
| ►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 |
| CStringWrapper | This class is a wrapper for strings, such as MCDecayStrings, to allow them to be associated with particles via a relation |
| CTagVertex | TagVertex data object: contains Btag Vertex and DeltaT |
| CTauPairDecay | Class for collecting variables related to tau-taubar MC decay process |
| CChargedPidMVAWeights | Class to contain the payload of MVA weightfiles needed for charged particle identification |
| CECLPhotonEnergyResolution | Class to hold the information ECL energy resolution derived from PERC |
| CParticleWeightingAxis | Class for handling LookUp tables |
| CParticleWeightingBinLimits | Just pair of numbers - min and max values of bin border |
| CParticleWeightingKeyMap | Class for handling KeyMap |
| CParticleWeightingLookUpTable | Class for handling LookUp tables |
| 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 |
| CWeightsTable | Nested class acting as a container the per-detector weights |
| CPIDNeuralNetworkParameters | Class for handling the parameters for the neural-network PID |
| 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 |
| CDecayDescriptor | The DecayDescriptor stores information about a decay tree or parts of a decay tree |
| CDecayDescriptorParticle | Represents a particle in the DecayDescriptor |
| 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 |
| CParticleListHelper | Class to help managing creation and adding to ParticleLists |
| 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 |
| CBelleNbarMVAModule | Apply nbarMVA for Belle I |
| CBestCandidateSelectionModule | Ranks particles by the values of a variable |
| CEnergyBiasCorrectionModule | Energy bias correction |
| 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 |
| 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 |
| CCurlTaggerModule | This module is designed to tag curl tracks |
| 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 |
| CEventKinematicsModule | Module to compute global quantities related to the event kinematics, like total missing energy and mass2, visible energy, etc |
| CEventShapeCalculatorModule | Module to compute event shape variables starting from three lists of particle objects (tracks, gammas, Klongs) |
| 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 |
| 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 |
| CHelixErrorScalerModule | Scale the error of helix parameters |
| CInclusiveBtagReconstructionModule | Inclusively reconstructs anti-B:tag from input ParticleLists for given B:sig |
| 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) |
| CInclusiveDstarReconstructionModule | Inclusive D* reconstruction module |
| 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 |
| CDecayTree | This is a helper class for the MCDecayFinderModule |
| 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 |
| 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 |
| CParticleCombinerModule | Particle combiner module |
| CParticleCombinerFromMCModule | 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 |
| 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 |
| CParticleVertexFitterModule | Vertex fitter module |
| CParticleWeightingModule | Module to append weights from the database into the extraInfo of Particles |
| CParticleWeightingLookUpCreatorModule | Module that creates LookUpTable and upload it to the DB |
| CPhotonEfficiencySystematicsModule | Adds Photon Detection Efficiency Data/MC ratios To Particle List |
| CPi0VetoEfficiencySystematicsModule | Adds Pi0Veto Efficiency Data/MC ratios To Particle List |
| 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 |
| CPostMergeUpdaterModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', several kinematic properties might need fix |
| CPrintMCParticlesModule | The PrintMCParticles module |
| CPseudoVertexFitterModule | Pseudo Vertex fitter module |
| 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 |
| CSelectDaughtersModule | Redefine (select) the daughters of a particle |
| 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 |
| CTagUniqueSignalModule | Loops through the particle list finds a unique signal candidate for each event |
| CTagVertexModule | Tag side Vertex Fitter module for modular analysis |
| CParticleAndWeight | This struct is used to store and sort the tag tracks |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CParticleIndexGenerator | ParticleIndexGenerator is a generator for all the combinations of the particle indices stored in the particle lists |
| CListIndexGenerator | ListIndexGenerator is a generator for all the combinations of the sublists (FlavorSpecificParticle = 0, SelfConjugatedParticle = 1) of a set of particle lists |
| CParticleGenerator | ParticleGenerator is a generator for all the particles combined from the given ParticleLists |
| CChargedParticleIdentificatorTest | Test the MVA-based charged PID |
| CeventShapeCoreAlgorithmTest | |
| CPIDPriorsTest | |
| CTrackIsoScoreCalculatorTest | Test the calculation of the track helix-based isolation score per particle |
| CAnalysisConfiguration | Singleton class keeping configurables of analysis components |
| 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 |
| CDetSurfCylBoundaries | Simple class to encapsulate a detector surface's boundaries in cylindrical coordinates |
| CDetectorSurface | Detector surfaces information |
| 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 |
| CGenTauTag | Class to determine generated decay mode of tau+ and tau- |
| CKlongCalculatorUtils | Utility class to calculate the Klong kinematics |
| CMCMatching | Functions to perform Monte Carlo matching for reconstructed Particles |
| CParticleSubset | Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists |
| CPCmsLabTransform | Class to hold Lorentz transformations from/to CMS and boost vector |
| CPIDCalibrationWeightUtil | Class to call calibration weight matrix |
| CPIDNeuralNetwork | Class to call PID neural network |
| CPostProcessingParticleWeighting | Post-processing particle weighting |
| CReferenceFrame | Abstract base class of all reference frames |
| CRestFrame | Rest frame of a particle |
| CLabFrame | Lab frame |
| CCMSFrame | CMS frame |
| CRotationFrame | Rotation frame around vector |
| CCMSRotationFrame | Stack frame for cms and Rotation frame |
| CUseReferenceFrame | A template class to apply the reference frame |
| CVariableFormulaConstructor | Struct to construct new variable function objects from a name or a double value or to apply operations on these variable function objects |
| CBelleTrkExtra | Class stores mdst_trk_fit information for each track |
| CB2BIIMCParticlesMonitorModule | Declaration of class B2BIIMCParticlesMonitor |
| 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 |
| CMuidProb | Class computes probability density for Muid calculation |
| CB2BIIMdstInputModule | Module reads Belle MDST files and converts Belle_event record to Belle II EventMetaData StoreObjectPointer |
| Ccal_scale_error_func_set_t | Structure type cal_scale_error_func_set_t |
| CBelleMCOutputModule | KLM digitization module |
| 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 |
| CDataFlowVisualization | Class to visualize data flow between modules |
| 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 |
| ►CEventProcessor | Core event processing loop |
| CStoppedBySignalException | Exception thrown when execution is stopped by a signal |
| CFileCatalog | This class provides an interface to the file (metadata) catalog |
| CHistoModule | HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions to be managed by HistoManager |
| CInputController | A static class to control supported input modules |
| CMemoryPool | Class to provide a constant access time memory pool for one kind of objects |
| CMergeDataStoreModule | Internal module used by Path.add_independent_merge_path() |
| 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 |
| CModuleProxyBase | The base module proxy class is used to create new instances of a module |
| 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 |
| CModuleStatistics | Keep track of time and memory consumption during processing |
| CMRUCache | Class implementing a generic Most Recently Used cache |
| 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) |
| CProcessStatistics | Class to collect call statistics for all modules |
| CPyModule | Python wrapper for Belle2::Module |
| CRandomGenerator | Fast Random number Generator using on xorshift1024* [arXiv:1402.6246] |
| CRandomNumbers | The class for handling the random number generation |
| 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() |
| ►CDatabase | Singleton base class for the low-level interface to the database |
| CDBImportQuery | Struct for bulk write queries |
| CDBAccessorBase | Base class for DBObjPtr and DBArray for easier common treatment |
| CDBArray | Class for accessing arrays of objects in the database |
| 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 |
| 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 |
| 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 |
| CDBPointer | 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 |
| CEventDependency | Class for handling changing conditions as a function of event number |
| 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 |
| CPayloadFile | A wrapper class for payload files used by the Database and DBStore classes |
| CDBObjPtr< PayloadFile > | Specialization of DBObjPtr in case of PayloadFiles |
| ►CBackgroundInfo | This class stores the information about what background was mixed or overlayed |
| CBackgroundDescr | Structure for background description |
| CBackgroundMetaData | Metadata information about the beam background file |
| CBinnedEventT0 | Database object for storing a binned EventT0 coming from the trigger |
| CDigitBase | A common base for subdetector Digits |
| ►CDisplayData | Add custom information to the display |
| CArrow | Stores data associated with an arrow |
| CEventExtraInfo | Class to stores ExtraInfo of the whole event |
| CEventMetaData | Store event, run, and experiment numbers |
| ►CEventT0 | Storage element for the eventwise T0 estimation |
| CEventT0Component | Structure for storing the extracted event t0s together with its detector and its uncertainty |
| CFileMetaData | Metadata information about a file |
| CHelix | This class represents an ideal helix in perigee parameterization |
| CMCInitialParticles | This class contains the initial state for the given event |
| CMergedEventConsistency | Mark if we want to merge the DataStore of a combination of events or not |
| 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 |
| CTestChunkData | Storable object which can be filled with random chunk data of a certain size |
| CUncertainHelix | This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters |
| CRelationVector | Class for type safe access to objects that are referred to in relations |
| ►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') |
| ►CDependencyMap | Collect information about the dependencies between modules |
| CModuleInfo | Stores information on inputs/outputs of a module, as obtained by requireInput()/optionalInput()/registerEntry(); |
| CStoreArray | Accessor to arrays stored in the data store |
| ►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 |
| 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 |
| CRelationVectorBase | Base class for RelationVector<T> |
| CSelectSubsetBase | Type-independent implementation details of SelectSubset |
| CSelectSubset | Class to create a subset of a given StoreArray together with the relations with other StoreArrays |
| CStoreAccessorBase | Base class for StoreObjPtr and StoreArray for easier common treatment |
| CStoreEntry | Wraps a stored array/object, stored under unique (name, durability) key |
| CBeamParameters | This class contains the nominal beam parameters and the parameters used for smearing of the primary vertex and the beam energy and momentum |
| CBunchStructure | Class to store the fill pattern of colliding bunches |
| CHardwareClockSettings | Database object containing the nominal accelerator RF value and the prescales to derive the clock frequencies of the sub-detectors |
| CMagneticField | Magnetic field map |
| CMagneticFieldComponent | Abstract base class for BField components |
| CMagneticFieldComponentConstant | Describe one component of the Geometry |
| CRunInfo | Database object for Run Information |
| ►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 |
| ►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 |
| CInputHandlerFactory | Helper class to easily register new input handlers |
| CGearDir | GearDir is the basic class used for accessing the parameter store |
| CUnit | The Unit class |
| CB2Vector3 | A fast and root compatible alternative to TVector3 |
| CBFieldManager | Bfield manager to obtain the magnetic field at any point |
| 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 |
| CLogSystem | Class for logging debug, info and error messages |
| 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 |
| CEventLimiterModule | The EventLimiter 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 |
| 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) |
| 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 |
| CRandomBarrierModule | Sets gRandom to an independent generator for the following modules |
| CTheKillerModule | This Modules kills basf2 as horribly as possible (or selected) |
| CGearboxModule | The Gearbox module |
| CHistoManagerModule | Class definition of HistoManager module |
| ►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 |
| CStatisticsSummaryModule | A module that displays the sum of multiple modules in the module statistics |
| ►CRootInputModule | Module to read TTree data from file into the data store |
| CReadStats | For collecting statistics over multiple files |
| CRootOutputModule | Write objects from DataStore into a ROOT file |
| CSeqRootInputModule | Module to read files produced by SeqRootOutputModule |
| CSeqRootOutputModule | Output module for sequential ROOT I/O |
| 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 |
| CAsyncWrapper | Wraps a given Module to execute it asynchronously |
| CDataStoreStreamer | Stream/restore DataStore objects to/from EvtMessage |
| CEvtHeader | Header structure of streamed object list |
| CEvtMessage | Class to manage streamed object |
| CGlobalProcHandler | A class to manage processes for parallel processing |
| CMapMergeable | Wrap an STL map to make it mergeable |
| CMergeable | Abstract base class for objects that can be merged |
| CCharBuffer | Dynamic character buffer that knows its size |
| CInMessage | Reusable Message class derived from TMessage (for reading only) |
| CMsgHandler | A class to encode/decode an EvtMessage |
| CPathUtils | Helper utils for path arithmetics needed in the pEventProcessor |
| CpEventProcessor | This class provides the core event processing loop for parallel processing |
| CProcessMonitor | Class to monitor all started framework processes (input, workers, output), kill them if requested and handle the signals from the OS |
| CProcHandler | A class to manage processes for parallel processing |
| CRbTupleManager | Class to manage histograms defined in registered modules |
| CRingBufInfo | Internal metadata structure for RingBuffer |
| CRingBuffer | Class to manage a Ring Buffer placed in an IPC shared memory |
| CRootMergeable | Wrap a root histogram or TNtuple to make it mergeable |
| CRxModule | Module to decode data store contents from RingBuffer |
| CSemaphoreLocker | Handles creation, locking and unlocking of System V semaphores |
| CSeqFile | A class to manage I/O for a chain of blocked files |
| CSetMergeable | Wrap an STL set to make it mergeable |
| CTxModule | Module for encoding data store contents into a RingBuffer |
| CZMQEventProcessor | This class provides the core event processing loop for parallel processing with ZMQ |
| 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 |
| CZMQLoadBalancedInput | Input part of a load-balanced connection |
| CZMQLoadBalancedOutput | Output part of a load-balanced connection |
| CZMQNullConnection | Connection doing just nothing: without the capability to pull, send or receive. Useful for template interfaces |
| 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 |
| CZMQIdMessage | A message with the socket ID. Needed in input<->worker communication |
| 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 |
| 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 |
| 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 |
| CZMQClient | A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket |
| CEventMetaDataSerialization | Helper class for (de)serializing the event meta data used for the event backup transferral |
| CStreamHelper | Helper class for data store serialization |
| CZMQAddressUtils | Summary of some address helpers |
| ►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 |
| CZMQParent | A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed |
| CFramework | This class combines all subsystems of the framework, and exports the main interface to Python |
| CLogPythonInterface | Thin wrapper to expose a usable interface to the logging framework in python |
| CProcessStatisticsPython | Python interface for ProcessStatistics |
| CPyDBArray | Class to access a DB Array from Python |
| CPyDBObj | Class to access a DBObjPtr from Python |
| CPyStoreArray | A (simplified) python wrapper for StoreArray |
| CPyStoreObj | (simplified) python wrapper for StoreObjPtr |
| CAbstractBooleanNode | A parsed cut-string naturally has a tree shape which incorporates the infomation of operator precedence and evaluation order of the statements |
| CAbstractExpressionNode | AbstractExpressionNode Superclass for all nodes which host expressions |
| CBaseAngle | Class to compare if two angles are compatible withing a given error range |
| CThetaAngle | |
| CPhiAngle | |
| CObjArrayIterator | Optimizes class to iterate over TObjArray and classes inheriting from it |
| CArrayIterator | Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc |
| 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 |
| 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 |
| CVisitor | This is a class template which takes a template class operation as template argument |
| CEqualVisitor | Seperate Visitor struct for equal_to comparison of variant<double, int bool> |
| CUnaryBooleanNode | Nodeclass with a single AbstractBooleanNode as child |
| 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 |
| CUnaryRelationalNode | Nodeclass with a single AbstractExpressioNode as child |
| CBinaryRelationalNode | BooleanNode which has two AbstractExpressionNodes nodes and a ComparisonOperator |
| CTernaryRelationalNode | BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator |
| CUnaryExpressionNode | UnaryExpressionNode Node class with a single expression node as child |
| CBinaryExpressionNode | BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation |
| CDataNode | Template class for storing the Constants (int, double, bool) of the Cutstring |
| CIdentifierNode | Class which stores the name of a variable |
| CFunctionNode | FunctionNode Node class for handling MetaVariables in cuts |
| CEnvironmentVariables | Utility functions related to environment variables |
| ►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 |
| CFormulaParserBase | Base class with the non-templated part of the formula parser |
| 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 |
| CStringFormulaConstructor | Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging |
| CGeneralCut | This class implements a common way to implement cut/selection functionality for arbitrary objects |
| CKeyValuePrinter | Create human-readable or JSON output for key value pairs |
| CLabToCms | Class implementing general Lorentz Transformation between LAB and CMS system |
| CMakeROOTCompatible | Helper class for converting strings into a ROOT-friendly format (e.g |
| CMultivariateNormalGenerator | Class to generate normal distributed, correlated random numbers given the mean values and the covariance matrix of all dimensions |
| CNodeFactory | Wrapper class for static node compile functions |
| CBoostPythonModuleProxy | Proxy class to register python modules (the things you can 'import') |
| CRootFileCreationManager | This single instance class takes track of all open ROOT files open in "create" mode, usually meant for all the ntuple output modules |
| CScopeGuard | Simple ScopeGuard to execute a function at the end of the object lifetime |
| CTRandomWrapper | Wrap TRandom to be useable as a uniform random number generator with STL algorithms like std::shuffle |
| CSHA3Hash | Simple interface to calculate SHA3 hash sum (FIPS 202 draft) with fixed size from given data inputs |
| CShakeHash | Simple interface to calculate SHAKE256 hash sum (FIPS 202 draft) with variable size from given data inputs |
| 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 indicies 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 |
| CBFieldMap | This class represents the magnetic field of the Belle II detector |
| CGeoMagneticField | The GeoMagneticField class |
| Ctriangle_t | Triangle structure |
| Cxy_t | A simple 2d vector stucture |
| CTriangularInterpolation | The TriangularInterpolation class |
| CBeamlineFieldMapInterpolation | The BeamlineFieldMapInterpolation class |
| 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 |
| CMagneticFieldComponent3D | Describe one component of the Geometry |
| 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 |
| CMyDBCreator | Very simple Creator class which actually does not do anything but shows how creators should implement loading the geometry from database |
| CFBXWriterModule | The FBX-writer module |
| CCreateFieldMapModule | Create Field maps of the Belle II magnetic field used in the simulation |
| CDensityScalerModule | Scale density of simulation/reconstruction geometry |
| CExportGeometryModule | The ExportGeometry module |
| CGeometryModule | Module to facilitate Geometry creation |
| COverlapCheckerModule | The geometry overlap check module |
| CVRMLWriterModule | The VRML-writer module |
| CBeamParametersFitter | Fitter calculating BeamParameters from CollisionBoostVector and CollisionInvariantMass |
| CCluster | Class to collect log likelihoods from Clusters from ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability |
| CECLCluster | ECL cluster data |
| 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) |
| CHitPatternCDC | Hit pattern of CDC hits within a track |
| CHitPatternVXD | Hit pattern of the VXD within a track |
| CKlId | Klong identifcation (KlId) datastore object to store results from KlId calculations |
| CKLMCluster | KLM cluster data |
| 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 |
| 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 |
| CSoftwareTriggerResult | Dataobject to store the results of the cut calculations performed by the SoftwareTriggerModule |
| CTrack | Class that bundles various TrackFitResults |
| CTrackFitResult | Values of the result of a track fit with a given particle hypothesis |
| 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 |
| CV0 | Object holding information for V0s |
| CBeamSpot | This class contains the beam spot position and size modeled as a gaussian distribution in space |
| 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 |
| CSoftwareTriggerCutBase | Base class for the SoftwareTriggerCut and its DBRepresentation |
| 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) |
| CBeamSpotTest | |
| CFixMergedObjectsModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', then Relations of the objects are corrected |
| 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 |
| CTrackTest | Test class for the Track object |
| CTrackFitResultTest | Set up a few arrays and objects in the datastore |
| CV0Test | Set up a few arrays and objects in the datastore |
| CDatabaseRepresentationOfWeightfile | Database representation of a Weightfile object |
| 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 |
| CAWESOMESimHit | A Geant4 simulated hit for the AWESOME detector |
| ►Nbest_candidate_selection | |
| CGenerator | |
| CRankChecker | |
| CNumBestChecker | |
| ►Ncdcplotmodule | |
| CCDCPlotModule | |
| ►Nchain_input | |
| CNoopModule | |
| CTestModule | |
| ►NchargeConjugation | |
| CTestParticleCombiner | |
| ►Ncheck_payload_metadata | |
| CCheckPayloadMetadata | |
| ►Ncheck_payload_names | |
| CCheckPayloadNames | |
| ►Ncompilation_db | |
| C__CompilationDbNode | |
| ►Nconditional_iov | |
| CPrinterModule | |
| ►Nconditions_db | |
| ►Ncli_main | |
| CFullHelpAction | |
| ►Ncli_management | |
| CCommandIoVsHelper | |
| ►Ncli_utils | |
| CItemFilter | |
| ►Niov | |
| CIntervalOfValidity | |
| CIoVSet | |
| ►Nlocal_metadata | |
| CLocalMetadataProvider | |
| ►Nrunningupdate | |
| CRunningTagUpdateMode | |
| CRunningTagUpdaterError | |
| CRunningTagUpdater | |
| ►Ntesting_payloads | |
| CTestingPayloadEntry | |
| CBearerAuth | |
| CPayloadInformation | |
| ►CConditionsDB | |
| CRequestError | |
| ►Ncopylists | |
| CTestCopyLists | |
| ►Ncreate_trainer | |
| CGraFEIIgniteTrainer | |
| ►NdecayHash | |
| CDecayHashMap | |
| ►NdefaultEvaluationParameters | |
| CQuiet | |
| ►Ndft | |
| ►Ntensorflow_dnn_model | |
| CLayer | |
| CMultilayerPerceptron | |
| CDefaultModel | |
| CTrainer | |
| ►NTfData | |
| CTfDataBasf2 | |
| CTfDataBasf2Stub | |
| ►Ndowhile | |
| CTestDoWhile | |
| ►Ndplot | |
| CPrior | |
| ►Nemptyrelations | |
| CMakeRelations | |
| ►NevalPriors | |
| CPriors | |
| ►NeventLevelClusteringInfo_countOutOfTime | |
| CaddECLCalDigitsModule | |
| CcheckNumOutOfTimeDigitsModule | |
| ►Neventlimiter | |
| CCountEvents | |
| ►Nevtmetadata | |
| CNoopModule | |
| CEvtMetaDataTest | |
| ►Nfei_examples | |
| CExamplesTest | Extend the examples test class to actually run over the FEI examples: |
| ►Nfitting_examples | |
| CExamplesTest | Extend the examples test class to actually run over the fitting examples: |
| ►Nforeach | |
| CTestModule | |
| ►Ngeometric_datasets | |
| CGraphDataSet | |
| ►Ngeometric_layers | |
| CEdgeLayer | |
| CNodeLayer | |
| CGlobalLayer | |
| ►Ngeometric_network | |
| CGraFEIModel | |
| ►NgraFEI_examples | |
| CExamplesTest | Extend the examples test class to actually run over the GraFEI examples: |
| ►NGraFEIModule | |
| CGraFEIModule | |
| ►Nhep_ipython_tools | |
| ►Ncalculation | |
| CCalculation | |
| ►Ncalculation_process | |
| CCalculationProcess | |
| ►Ncalculation_queue | |
| CCalculationQueue | |
| CCalculationQueueItem | |
| ►Nentities | |
| CStoreContent | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| CStoreContentList | |
| CStatisticsColumn | |
| CStatistics | |
| ►Ninformation | |
| CEnvironmentInformation | |
| ►Nipython_handler | |
| CIPythonHandler | |
| ►Nipython_handler_basf2 | |
| ►Ncalculation | |
| CBasf2Calculation | |
| ►Ncalculation_process | |
| CBasf2CalculationProcess | |
| ►Nentities | |
| CModuleStatistics | |
| CBasf2CalculationQueueStatistics | |
| ►Ninformation | |
| CBasf2EnvironmentInformation | |
| CBasf2ModulesInformation | |
| ►Nipython_handler | |
| CBasf2IPythonHandler | |
| ►Npython_modules | |
| CPrintCollections | |
| CProgressPython | |
| ►Nviewer | |
| CStylingWidget | |
| CPathViewer | |
| CModuleViewer | |
| CDependencyViewer | |
| ►Nviewer | |
| CIPythonWidget | |
| CStylingWidget | |
| CProgressBarViewer | |
| CCollectionsViewer | |
| CStatisticsViewer | |
| CProcessViewer | |
| CLogViewer | |
| ►Nhistogram | |
| CHistograms | |
| ►Nhow_to_use_arbitrary_methods | |
| CMyFancyClassifier | |
| ►Ninteractive | |
| CBasf2IPythonPrompt | |
| ►Ninteractive_python | |
| CMinModule | |
| ►Nkeras_relational | |
| CRelations | |
| CEnhancedRelations | |
| ►Nlca_to_adjacency | |
| CInvalidLCAMatrix | |
| CNode | |
| ►NLCASaverModule | |
| CLCASaverModule | |
| ►Nlocal_metadata_provider | |
| CLocalMetadataComparison | |
| ►Nmemcheck | |
| CStopModule | |
| ►Nmetrics | |
| CPerfectLCA | |
| CPerfectMasses | |
| CPerfectEvent | |
| ►Nmixed_runs | |
| CDelayEvents | |
| ►Nmodule_paths | |
| CSelectOddEvents | |
| CReturnFalse | |
| CPrintName | |
| ►Nmodule_setparameters | |
| CSetModuleParameters | |
| ►NmultiTrain | |
| CMultiTrainLoss | |
| ►Nmva_examples | |
| CExamplesTest | Extend the examples test class to actually run over the mva examples: |
| ►Nonline_book_statistics | |
| CStatistics | |
| CStatisticsVisitor | |
| ►Nparallel_processing | |
| CCheckEventNumbers | |
| ►Nper_event_statistics | |
| CPerEventStatisticsGetterModule | |
| ►Npickable_basf2 | |
| CBASF2StateRecorder | |
| ►Npidcalibration_examples | |
| CExamplesTest | Extend the examples test class to actually run over the PID calibration examples: |
| ►NpidTrainWeights | |
| CWeightNet | |
| ►Nplotting | |
| CPlotter | |
| CPurityAndEfficiencyOverCut | |
| CSignalToNoiseOverCut | |
| CPurityOverEfficiency | |
| CRejectionOverEfficiency | |
| CMultiplot | |
| CDiagonal | |
| CDistribution | |
| CBox | |
| CDifference | |
| COvertraining | |
| CVerboseDistribution | |
| CCorrelation | |
| CTSNE | |
| CImportance | |
| CCorrelationMatrix | |
| ►Npostmdstidentification_examples | |
| CExamplesTest | Extend the examples test class to actually run over the post mdst identification examples: |
| ►Npreprocessing | |
| Cfast_equal_frequency_binning | |
| ►Nprescale | |
| CCountEvents | |
| ►NprintPIDLikelihoods | |
| CprintPIDLikelihoods | |
| ►NpriorDataLoaderAndModel | |
| CPriorDataLoader | |
| CPriorModel | |
| ►Nprune_datastore | |
| CTestModule | |
| ►Nreconstruction_examples | |
| CExamplesTest | Extend the examples test class to actually run over the reconstruction examples: |
| ►Nregister_pystorearray | |
| CSillyGeneratorModule | |
| CParticleStatisticsModule | |
| ►Nrelations | |
| Cearly_stopping | |
| ►Nroot_input | |
| CNoopModule | |
| CTestingModule | |
| CBrokenEventsModule | |
| ►Nrundb | |
| CRunDB | |
| ►Nseqroot_input | |
| CTestModule | |
| ►Nsignals | |
| CTestModule | |
| ►Nsimulation_examples | |
| CExamplesTest | Extend the examples test class to actually run over the simulation examples: |
| ►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 |
| CSQLiteError | Simple error class to be thrown if there is any sqlite error on any of the operations |
| ►CObjectStatement | SQLite prepared statement wrapper |
| Citerator | Iterator class to allow iterating over the rows |
| CConnection | Simple wrapper for a SQLite database connection |
| ►Nstd | STL namespace |
| Chash< std::set< int > > | Hash function used by unordered_set |
| ►Nsteering_files | |
| CSteeringFileTest | |
| ►Nstop_on_error | |
| CErrorInInit | |
| CErrorInEvent | |
| ►Ntagging_examples | |
| CExamplesTest | Extend the examples test class to actually run over the tagging examples: |
| ►Ntest6_CPVFlavorTaggerEfficiency | |
| CQuiet | |
| ►Ntest_chargedCluster | |
| CTestChargedCluster | |
| ►Ntest_embedding_example | |
| CTestEmbedding | |
| ►Ntest_globaltag_forwarding | |
| CTestGTForwarding | |
| ►Ntest_iov | |
| CTestIntervalOfValidity | |
| CTestIoVSet | |
| ►Ntest_mbc_cut_eff | |
| CTestMbcEff | |
| ►Ntest_MVAExpertModule | |
| CMVAExtraInfoChecker | |
| ►Ntest_online_book_statistics | |
| CTest | |
| ►Ntest_particleExtractorFromROE | |
| CTestParticleExtractorFromROE | |
| ►Ntest_particleLoader | |
| CTestParticleLoader | |
| ►Ntest_reconstructmcdecay | |
| CTestNewMCDecayFinder | |
| ►Ntest_runningupdate | |
| CTestMergeStaging | |
| ►Ntest_std_charged | |
| CTestStdCharged | |
| ►Ntest_std_hyperons | |
| CTestStdHyperons | |
| ►Ntest_std_photons | |
| CTestStdPhotons | |
| ►Ntest_std_pi0s | |
| CTestStdPi0s | |
| ►Ntest_std_v0 | |
| CTestStdV0 | |
| ►Ntest_variables_collections | |
| CTestVariableCollections | |
| ►Ntest_variables_meta | |
| CMetavariableDataTypeTest | |
| ►Ntest_variables_utils | |
| CTestVariableUtilities | |
| ►NTestUtilities | |
| CTestParticleFactory | This is a class, which generates DataStore particles, according to the provided decay string e.g |
| ►Ntorch_tcce | |
| CTCCE | |
| ►NtreeFit | |
| CTestTreeFits | |
| ►NtreeFit_beam_momentum_constrain | |
| CTestTreeFits | |
| ►NtreeFit_referenced | |
| CTestTreeFits | |
| ►NtreeFit_referenced_bremscorrection | |
| CTestTreeFits | |
| ►NtreeFit_referenced_charged_tree | |
| CTestTreeFits | |
| ►NtreeFit_referenced_charged_tree_2dBeam | |
| CTestTreeFits | |
| ►NtreeFit_referenced_ignore_charged | |
| CTestTreeFits | |
| ►NtreeFit_referenced_ignore_klong | |
| CTestTreeFits | |
| ►NtreeFit_referenced_klong | |
| CTestTreeFits | |
| ►NtreeFit_referenced_pipipi0 | |
| CTestTreeFits | |
| ►NtreeFit_referenced_single_displaced_vertex | |
| CTestTreeFits | |
| ►NtreeFit_referenced_single_vertex | |
| CTestTreeFits | |
| ►NtreeFit_referenced_tree_with_neutral | |
| CTestTreeFits | |
| ►NtreeFit_referenced_tree_with_neutral_custom_origin | |
| CTestTreeFits | |
| ►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 |
| CRecoKlong | Representation of the Klong constraint |
| CRecoParticle | Base for RecoPhoton RecoTrack |
| CRecoPhoton | Representation of the photon constraint |
| 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 |
| ►Ntutorials_B2A2XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A3XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A4XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A5XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A6XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A7XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A8XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A9XX | |
| CTutorialsTest | |
| ►Nvariablemanager_examples | |
| CExamplesTest | Extend the examples test class to actually run over the variable manager examples: |
| ►Nvariables | |
| ►Nutils | |
| CDecayParticleNode | |
| CPythonVariableManager | |
| Ccycle_detector | Simple struct to check boost graph for cyclic references |
| CKeccakHashInstance | Since we cannot forward declare the memory structure directly due to some typedeffing we inherit from it |
| 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 |
1.9.1