 |
Belle II Software development
|
|
Belle II Software development
|
| ►N081_module | |
| CMinModule | |
| ►N083_module | |
| CMinModule | |
| ►N085_module | |
| CAccessingDataStoreModule | |
| ►N087_module | |
| CAccessingDataStoreModule | |
| ►N3_bunchFinderPlots | |
| CMakePlots | |
| ►Nalignment | |
| ►Nconstraints | |
| CCDCLayerConstraints | |
| CCDCTimeZerosConstraint | |
| CCDCWireConstraints | |
| CConstraint | |
| CConstraints | |
| CVXDHierarchyConstraints | |
| ►Nconstraints_generator | |
| CConstraintsGenerator | |
| ►Nfancystuff | |
| ►Nsettings | |
| CProTool | |
| ►Ntools | |
| CProfilePlot | |
| ►Ntransform | |
| CCDF | |
| CToFlat | |
| CTransform | |
| ►Nmisalignment | |
| CBowing | |
| CClamshell | |
| CCreateMisalignmentModule | |
| CCurl | |
| CElliptical | |
| CGlobalDeformation | |
| CRadialExpansion | |
| CSkew | |
| CTelescope | |
| CTwist | |
| CZExpansion | |
| ►Nutils | |
| CAlignmentGeneratorConfig | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| CMillepedeCalibration | |
| ►NalphaRatioPlots | |
| CMakePlots | |
| ►NaverageQE | |
| CAverageQE | |
| ►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 | |
| ►Nbackends | |
| CArgumentsGenerator | |
| CArgumentsSplitter | |
| CBackend | |
| CBackendError | |
| CBatch | |
| CDIRAC | |
| ►CHTCondor | |
| CHTCondorResult | |
| CJob | |
| CJobError | |
| ►CLocal | |
| CLocalResult | |
| ►CLSF | |
| CLSFResult | |
| CMaxFilesSplitter | |
| CMaxSubjobsSplitter | |
| ►CPBS | |
| CPBSResult | |
| CResult | |
| CSplitterError | |
| CSubJob | |
| CSubjobSplitter | |
| ►NbackgroundInfo | |
| CprintBGInfo | |
| ►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 | |
| ►NbeamBkgHitRates | |
| CSelectTRGTypes | |
| ►Nbeast_tuple_producer | |
| CCalculationProcess | |
| ►NBelle2 | Abstract base class for different kinds of events |
| ►Nalignment | |
| ►Ntimeline | |
| CGlobalParamTimeLine | Convenient class to automatically create payloads from allowed time dependence of parameter, load their value from database, update the constants one by one usually from Millepde result) and output the final payloads (including EventDependencies) such that one can store them (updated) in the database |
| CCDCGlobalParamInterface | CDC interface |
| CEmptyGlobalParamSet | Object representing no parameters |
| CGlobalCalibrationManager | Class to hold hierarchy of whole Belle2 |
| CGlobalDerivatives | Class for easier manipulation with global derivatives (and their labels) |
| CGlobalDerivativesHierarchy | Class for alignment/calibration parameter hierarchy & constraints |
| CGlobalParamSet | Template class for generic access to DB objects |
| CGlobalParamSetAccess | Base accessor class to store different DBObjects e.g |
| CGlobalParamVector | The central user class to manipulate any global constant in any DB object Used to retrieve global parameters from database and access the for update |
| CIGlobalParamInterface | Some tentative base class to allow to add functionality to the default behavior, like manipulate constants in DB objects after calibration is finished All methods to override have default implementation which does nothing |
| CLorentShiftHierarchy | 1D Hierarchy for Lorentz shift correction |
| CPedeApplication | Class interfacing Millepede solver (Pede) |
| ►CPedeResult | Class to process Pede result file(s) |
| CparameterData | Struct to hold data for a parameter |
| CRigidBodyHierarchy | 6D Hierarchy of rigid bodies |
| CVXDGlobalParamInterface | Very tentative interface for VXD |
| ►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 |
| ►NARICH | |
| CARICHTree | Structure of a flat ntuple |
| CParticlesArray | Structure for particle hypothesis dependent arrays |
| CTrackHit | Structure for track parameters at ARICH |
| ►Narich | |
| CARICHBackgroundModule | ARICH digitizer module |
| CGeoARICHBtestCreator | The creator for the PXD geometry of the Belle II detector |
| CGeoARICHCreator | The creator for the ARICH geometry of the Belle II detector |
| CSensitiveAero | This is optional (temporary) class that provides information on track parameters on aerogel plane, until tracking is not prepared |
| CSensitiveDetector | The Class for ARICH Sensitive Detector |
| ►NARICHTools | |
| ►NPrivateHelperClasses | |
| CTokenCast | Generic template for TokenCast<T> |
| CTokenCast< double > | Double specialization of TokenCast<T> the decimal point is set to ' |
| CTokenCast< int > | Integer specialization of TokenCast<T> |
| CTokenCast< ModuleID_t > | ModuleID_t specialization of TokenCast<T> the decimal point is set to ' |
| CModuleID_t | Intermediate object generated to contain configurations in a sorted fashion |
| CStringToVector | Converts a given string to the std::vector<T> |
| ►NAWESOME | |
| CAWESOMEBasicModule | The AWESOME basic module |
| CAWESOMEGeometryCreator | The creator for the AWESOME detector geometry |
| CAWESOMESensitiveDetector | Sensitive Detector implementation of the AWESOME detector |
| ►NBackground | |
| ►CARICHHitRateCounter | Class for monitoring beam background hit rates of ARICH |
| CTreeStruct | Tree structure |
| ►CCDCHitRateCounter | Class for monitoring beam background hit rates of CDC |
| CTreeStruct | Tree structure |
| ►CECLHitRateCounter | Class for monitoring beam background hit rates of ECL |
| CTreeStruct | Tree structure |
| CHitRateBase | Abstract base class for monitoring beam background hit rates All the monitoring classes must inherit from this one |
| ►CKLMHitRateCounter | Class for monitoring beam background hit rates of EKLM |
| CTreeStruct | Tree data structure |
| ►CPXDHitRateCounter | Class for monitoring beam background hit rates of PXD |
| CTreeStruct | Tree structure |
| ►CSVDHitRateCounter | Class for monitoring beam background hit rates of SVD |
| CTreeStruct | Tree structure |
| ►CTOPHitRateCounter | Class for monitoring beam background hit rates of TOP |
| CTreeStruct | Tree structure |
| ►Nbackground | |
| CBeamBGTypes | Class to define BG types and to convert between BG types and tags or v.v |
| ►Nbeamabort | Namespace to encapsulate code needed for the BEAMABORT detector |
| CBeamabortCreator | The creator for the BEAMABORT geometry |
| CBeamabortModule | The Beamabort module |
| CBeamabortStudyModule | Study module for Beamaborts (BEAST) |
| CBeamDigitizerModule | Beam tube digitizer |
| CSensitiveDetector | Sensitive Detector implementation of the BEAMABORT detector |
| ►NBeamSpotCalib | |
| CEvent | Event containing two tracks |
| CSpotParam | Structure containing most of the beam spot parameters |
| CTrack | Track parameters (neglecting curvature) |
| CUnknownPars | Structure including all variables of interest with uncertainties from boot-strap |
| CUnknowSpline | Spline with uncertainty obtained from the boot-strap replicas |
| CUnknowVar | Variable with uncertainty from boot-strap replicas |
| ►NBEAST_v5 | |
| CBEASTTree_v5 | Structure for the input of the data BEAST (TTree "Data_BEAST") |
| ►Nbgo | Namespace to encapsulate code needed for the BGO detector |
| CBgoCreator | The creator for the BGO geometry |
| CBgoDigitizerModule | Bgo tube digitizer |
| CBgoModule | The Bgo module |
| CBgoStudyModule | Study module for Bgos (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the BGO detector |
| ►Nbklm | |
| CGeoBKLMCreator | This class creates the BKLM geometry of the Belle II detector |
| CGeometryPar | Provides BKLM geometry parameters for simulation, reconstruction etc (from Gearbox or DataBase) |
| CModule | Define the geometry of a BKLM module Each sector [octant] contains Modules |
| ►NBoostVectorCalib | |
| CEvent | Event containing two tracks |
| CFunBoost | Functor to minimize median of residuals^2 |
| CTrack | Track parameters (neglecting curvature) |
| CVectorVar | Structure to store all bootstrap replicas |
| ►Ncave | Namespace to encapsulate code needed for the CAVE detector |
| CCaveCreator | The creator for the CAVE geometry |
| CCaveModule | The Cave module |
| CSensitiveDetector | Sensitive Detector implementation of the CAVE detector |
| ►NCDC | |
| CADCCountTranslatorBase | Abstract Base class for the ADC count translator |
| CCDCBadWireCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCCalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCChannelData | CDCChannelData |
| CCDCCosmicAnalysisModule | Analysis module for CDC CR data |
| CCDCCRTestModule | CDC Cosmic test calibration module |
| CCDCCrudeT0CollectorModule | Collector for crude t0 |
| CCDCFudgeFactorCalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCGeoControlPar | The Class for CDC Geometry Control Parameters |
| CCDCGeometryPar | The Class for CDC Geometry Parameters |
| CCDCGeometryTranslatorBase | Abstract Base class for the geometry translator |
| CCDCHitFilterModule | CDCHitFilter: Filters CDC hits according to given configuration criteria |
| CCDCPackerModule | CDCPackerModule: The CDC Raw Hits Decoder |
| CCDCRecoTrackFilterModule | The module excluding hits of specified Slayers in the RecoTracks |
| CCDCSensitiveDetector | The Class for CDC Sensitive Detector |
| CCDCSimControlPar | The Class for CDC Simulation Control Parameters |
| CCDCT0CalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCUnpackerModule | CDCUnpackerModule: The CDC Raw Hits Decoder |
| CCrudeT0CalibrationAlgorithm | Algorithm class for crude T0 calibration |
| CEDepInGas | The Class for Energy deposit in the gas |
| CFudgeFactorCalibrationAlgorithm | Class for CDC fudge factor calibration |
| CGeoCDCCreator | The GeoCDCCreator class |
| CGeoCDCCreatorReducedCDC | The GeoCDCCreatorReducedCDC class |
| CHelix | Helix parameter class |
| CIdealCDCGeometryTranslator | This class uses the ideal detector geometry for the translation of wire IDs into geometric positions |
| CLinearGlobalADCCountTranslator | This class simply assumes a linear translation through (0,0) |
| CRealisticCDCGeometryTranslator | This class uses the realistic detector geometry (the one after alignment procedure) for the translation of wire IDs into geometric positions |
| CRealisticTDCCountTranslator | Translator mirroring the realistic Digitization |
| CSpaceResolutionCalibration | Class for Space resolution calibration |
| CSpaceResolutionCalibrationAlgorithm | Class for Space resolution calibration |
| CT0CalibrationAlgorithm | Class for T0 Correction |
| CT0Correction | Class for T0 Correction |
| CTDCCountTranslatorBase | Base class for translation of Drift Time into Drift Length |
| CTimeWalkCalibration | Class for Time walk calibration |
| CTimeWalkCalibrationAlgorithm | Class for Time walk calibration |
| CWireEfficiencyAlgorithm | Class for Wire Efficiency estimation |
| CXTCalibration | Class to perform xt calibration for drift chamber |
| CXTCalibrationAlgorithm | Class to perform xt calibration for drift chamber |
| CXTFunction | Class to perform fitting for each xt function |
| ►NCDCTriggerUnpacker | |
| CB2LDataField | |
| CB2LDataField_DNN | |
| CTRG2DFinderTrack | TRG 2DFinder Track |
| CTRGNeuroTrack | TRG Neuro track |
| ►Nclaw | Namespace to encapsulate code needed for the CLAW detector |
| CClawCreator | The creator for the CLAW geometry |
| CClawDigitizerModule | Claw tube digitizer |
| CClawModule | The Claw module |
| CClawStudyModule | Study module for Claws (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the CLAW detector |
| ►Nclaws | Namespace to encapsulate code needed for the CLAWS detector |
| CCLAWSCreator | The creator for the CLAWS geometry |
| CClawsDigitizerModule | Claws tube digitizer |
| CCLAWSModule | The CLAWS module |
| CClawsStudyModule | Study module for Clawss (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the CLAWS detector |
| CSensorTraversal | Class to keep track of the traversal of the sensitive volume for one track |
| ►Ncoil | |
| CGeoCOILCreator | The GeoCoilCreator class |
| ►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 |
| ►Ncsi | Namespace to encapsulate code needed for the CSI detector |
| CCsiCreator | The creator for the CSI geometry |
| CCsiDigitizer_v2Module | Csi tube digitizer_v2 |
| CCsIDigitizerModule | Digitizer for the BEAST CsI system |
| CCsiGeometryPar | The Class for CSI Geometry Parameters |
| CCsiModule | The Csi module |
| CCsiStudy_v2Module | Study module for Csis (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the CSI detector |
| ►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 |
| ►NDBField | |
| CProperty | |
| ►Ndosi | Namespace to encapsulate code needed for the DOSI detector |
| CDosiCreator | The creator for the DOSI geometry |
| CDosiDigitizerModule | Dosi tube digitizer |
| CDosiModule | The Dosi module |
| CDosiStudyModule | Study module for Dosis (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the DOSI detector |
| ►NECL | |
| CBelleCrystal | Belle crystal in Geant4 |
| CBelleLathe | BelleLathe class |
| CBitStream | Bit stream struct |
| CBkgSensitiveDiode | Class for ECL Sensitive Detector for neutron background study |
| Ccachezr_t | Cached z-r struct |
| Ccplacement_t | Placement struct |
| CeclAutocovarianceCalibrationC1Algorithm | Calibrate covariance matrix for crystals using delayed Bhabha events |
| CeclAutocovarianceCalibrationC3Algorithm | Calibrate covariance matrix for crystals using delayed Bhabha events |
| CeclAutocovarianceCalibrationC4Algorithm | Calibrate covariance matrix for crystals using delayed Bhabha events |
| CECLBaseCompress | ECL waveform compression/decompression to/from the BitStream storage with the BASE algorithm |
| CeclBhabhaTAlgorithm | Calibrate ecl crystals using bhabha events |
| CECLChannelMapper | This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbobject/include/ECLChannelMap.h) |
| CECLCompress | Abstract class (interface) for ECL waveform compression/decompression to/from the BitStream storage |
| ►CEclConfiguration | Singleton class to hold the ECL configuration |
| Cadccounts_t | Struct for the ADC count |
| Calgoparams_t | Struct for the parameters of the algorithm |
| Cfitparams_t | Struct for the fit parameters |
| Csignalsample_t | Struct for a signal sample |
| ►CEclConfigurationPure | Singleton class to hold the ECL configuration for pure CsI calorimeter |
| Cadccountspure_t | Struct for the fit parameters for the pure CsI calorimeter |
| Cfitparamspure_t | A struct for the fit parameters for a single channel of the pure CsI calorimeter (in the simulation, all calorimeter channels normally use the same set of fit parameters) |
| Csignalsamplepure_t | Struct for a signal sample for the pure CsI calorimeter |
| CeclCosmicEAlgorithm | Class eclCosmiEAlgorithm |
| CECLDCTCompress | ECL waveform compression/decompression to/from the BitStream storage based on the Discrete Cosine Transform (DCT) |
| CECLDeltaCompress | ECL waveform compression/decompression to/from the BitStream storage with the DELTA algorithm |
| CECLDQMInjectionModule | The ECL Occ after Injection DQM module |
| CECLDspUtilities | This class contains static methods to make them accessible from pyROOT |
| CeclEdgeAlgorithm | ..Obtain payloads specifying the location of the edges of each ECL crystal |
| Ceclee5x5Algorithm | Calibrate ecl crystals using Bhabha events |
| CeclGammaGammaEAlgorithm | Calibrate ecl crystals using gamma pair events |
| ►CECLGeometryPar | The Class for ECL Geometry Parameters |
| CCrystalGeom_t | Crystal geometry |
| CeclLeakageAlgorithm | Calculate ECL energy leakage corrections |
| CECLLeakagePosition | Class to get position information for a cluster for leakage corrections |
| CECLLOMModule | This module simulates ECL Luminosity Online Monitor logic, i.e |
| CeclMergingCrystalEAlgorithm | Calibrate ecl crystals using previously created payloads |
| CeclMergingCrystalTimingAlgorithm | Calibrate ecl crystals using previously created payloads |
| CeclMuMuEAlgorithm | Calibrate ecl crystals using muon pair events |
| CEclNbr | EclNbr class |
| CECLNeighbours | Class to get the neighbours for a given cell id |
| CeclNOptimalAlgorithm | Algorithm that works with eclNOptimalCollector to find the number of crystals to be summed to get the best energy resolution for each test energy and for each group of crystals (8 groups per thetaID in the barrel) |
| CECLPedestalFit | This struct is returned by the pedestalFit method that fits the first 16 samples of the waveform (pedestal points) to find a peak there (that corresponds to background) |
| CECLSampledShaper | Digitisation shaper |
| CECLShapeFit | ShaperDSP fit results from _lftda function |
| CECLShowerId | Class to convert the shower id into CR, CS and Seed and vice versa |
| CeclTimeShiftsAlgorithm | Calibrate ecl crystals using previously created payloads |
| CECLTimingUtilities | Class to storing timing calibration functions |
| CeclTValidationAlgorithm | Validate the ecl timing calibrations using a hadronic event selection |
| CeclWaveformTemplateCalibrationC1Algorithm | Calibrate ecl crystals using gamma pair events |
| CeclWaveformTemplateCalibrationC2Algorithm | Calibrate ecl crystals using gamma pair events |
| CeclWaveformTemplateCalibrationC3Algorithm | Calibrate ecl crystals using gamma pair events |
| CeclWaveformTemplateCalibrationC4Algorithm | Calibrate ecl crystals using gamma pair events |
| CGeoECLCreator | The GeoECLCreator class |
| Cpent_t | Pentagon shape |
| CPlane_t | Struct for plane |
| CPoint_t | Struct for Point |
| CPolyhedronBelleCrystal | Belle crystal in polyhedron |
| CPolyhedronBelleLathe | Belle lathe polyhedron |
| Cquadrilateral_barrel_t | Quadrilateral struct for barrel |
| Cquadrilateral_endcap_t | Quadrilateral struct for end cap |
| Cquadrilateral_t | Quadrilateral shape struct |
| CSensitiveDetector | Class for ECL Sensitive Detector |
| ►CSensitiveDiode | Class for ECL Sensitive Detector |
| Chit_t | Simple hit structure |
| Cshape_t | Shape |
| ►CShaperDSP_t | Class include function that calculate electronic response from energy deposit |
| Cshaperdspshift_t | Struct for a shift of the shaper dsp |
| Csv123shift_t | Struct to encapsulate the electronic response from energy deposit |
| ►CTEclEnergyHit | Define class TEclEnergyHit |
| Cgreater_CellId | Struct greater_CellId |
| Cgreater_Energy | Struct greater_Energy |
| Cless_CellId | Struct less_CellId |
| Cless_Energy | Struct less_Energy |
| Ctriangle_t | Struct for a triangle |
| Cvector_t | Struct for a three vector |
| Cwidth_t | Bit widths for the prefix coding to encode integers which are mainly concentrated around zero and probability density are decreasing for large absolute values |
| CWrapArray2D | Class to replace POD 2D array to save stack usage since it just allocates memory dynamically |
| Czr_t | Simple struct with z and r coordinates |
| ►NEKLM | |
| CAlignmentChecker | Class for EKLM alignment checking |
| CArc2D | 2D arc |
| CCircle2D | 2D circle |
| CGeoEKLMCreator | Class GeoEKLMCreator |
| CGeometryData | EKLM geometry data |
| CLine2D | 2D line |
| CLineSegment2D | 2D line segment |
| CLogicalVolumes | Logical volumes of EKLM |
| CMaterials | Materials for EKLM |
| CPolygon2D | 2D polygon |
| CSectorSupportLogicalVolumes | Sector support logical volumes |
| CSectorSupportSolids | Sector support solids |
| CShieldLogicalVolumes | Shield logical volumes |
| CSolids | All solids of EKLM |
| CTransformData | Transformation data |
| CTransformDataGlobalAligned | Transformation data (global, aligned): singleton version |
| CVolumeNumbers | Volume numbers |
| ►Nfangs | Namespace to encapsulate code needed for the FANGS detector |
| CFANGSCreator | The creator for the FANGS geometry |
| CFANGSDigitizerModule | FANGS ATLAS FE-I4B ASIC chip digitizer |
| CFANGSModule | The FANGS module |
| CFANGSStudyModule | Study module for Fangs (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the FANGS detector |
| CSensorTraversal | Class to keep track of the traversal of the sensitive volume for one track |
| ►NGDL | |
| CTRGGDLUnpackerModule | A module of TRG TRG Unpacker |
| ►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 |
| ►Nhe3tube | Namespace to encapsulate code needed for the HE3TUBE detector |
| CHe3DigitizerModule | He3 tube digitizer |
| CHe3tubeCreator | The creator for the HE3TUBE geometry |
| CHe3tubeModule | The He3tube module |
| CHe3tubeStudyModule | Study module for He3tubes (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the HE3TUBE detector |
| ►NHistogramFactory | |
| CAxis | This class unites some parameters for Factory which describe one axis of histogram |
| CFactory | This class is used for creating TH1F and TH2F objects |
| CParameter | This class represents a quantity which value can be set both permanently and temporarily |
| ►NHLTPrefilter | |
| CCDCECLCutState | Helper for CDCECLCut state |
| CTimingCutState | Helper for TimingCut state |
| ►NInvariantMassBhadCalib | |
| CCandidate | Structure containing variables relevant to the B-candidate |
| CEvent | Structure containing variables relevant for the hadronic B decays |
| ►NInvariantMassMuMuCalib | |
| CEvent | Event containing two tracks |
| CInvariantMassMuMuIntegrator | The integrator aims to evaluate convolution of PDFgenLevel and resolution function |
| CTrack | Track parameters (neglecting curvature) |
| ►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 |
| ►Nir | |
| CCryostatElement | The struct for CryostatElement |
| CFarBeamLineElement | The struct for FarBeamLineElement |
| CGeoBeamPipeCreator | The creator for the BeamPipe geometry of the Belle II detector |
| CGeoCryostatCreator | The creator for the Cryostat geometry of the Belle II detector |
| CGeoFarBeamLineCreator | The creator for the FarBeamLine geometry of the Belle II detector |
| CSensitiveDetector | The IR Sensitive Detector class |
| ►NKLM | |
| CChannelGroup | Channel group |
| CGeoKLMCreator | The creator for the KLM geometry of the Belle II detector |
| CKLMGeometryPar | Wrapper class around bklm::GeometryPar and EKLM::GeometryData |
| CRawData | KLM raw data |
| CScintillatorFirmware | FPGA fitter class |
| ►CScintillatorSimulator | Digitize EKLMSim2Hits to get EKLM StripHits |
| CPhotoelectron | Photoelectron data |
| CSensitiveDetector | KLM sensitive-detector class |
| ►Nmicrotpc | Namespace to encapsulate code needed for the MICROTPC detector |
| CMicrotpcCreator | The creator for the MICROTPC geometry |
| CMicrotpcModule | The Microtpc module |
| CMicrotpcStudyModule | Study module for Microtpcs (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the MICROTPC detector |
| CTpcDigitizerModule | Micro TPC digitizer |
| CTPCStudyModule | Study module for TPCs (BEAST) |
| ►NMonopoles | |
| CG4Monopole | A class to hold monopole description as a particle |
| CG4MonopoleEquation | Monopole equation of motion class |
| CG4MonopoleFieldSetup | Monopole field setup singleton class, that takes care of switching between conventional particle transportation and monopole transportation |
| CG4MonopolePhysics | Monopole physics class to register on the physics list |
| CG4MonopoleTransportation | Concrete class that does the geometrical transport |
| CG4mplIonisation | Monopole ionisation class |
| CG4mplIonisationWithDeltaModel | Concrete monopole ionisation model |
| ►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 | |
| ►Nph1bpipe | Namespace to encapsulate code needed for the PH1BPIPE detector |
| CPh1bpipeCreator | The creator for the PH1BPIPE geometry |
| CPh1bpipeModule | The Ph1bpipe module |
| CSensitiveDetector | Sensitive Detector implementation of the PH1BPIPE detector |
| ►Nph1sustr | Namespace to encapsulate code needed for the PH1SUSTR detector |
| CPh1sustrCreator | The creator for the PH1SUSTR geometry |
| CPh1sustrModule | The Ph1sustr module |
| CSensitiveDetector | Sensitive Detector implementation of the PH1SUSTR detector |
| ►NPID | |
| CLogLikelihoods | Structure for the output of PID log likelihoods to a flat ntuple |
| CPIDTree | Structure for the output of PID log likelihoods + tracking info to a flat ntuple |
| ►Npindiode | Namespace to encapsulate code needed for the PINDIODE detector |
| CPinDigitizerModule | Pin tube digitizer |
| CPindiodeCreator | The creator for the PINDIODE geometry |
| CPindiodeModule | The Pindiode module |
| CPindiodeStudyModule | Study module for Pindiodes (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the PINDIODE detector |
| ►Nplume | Namespace to encapsulate code needed for the PLUME detector |
| CPlumeCreator | The creator for the PLUME geometry |
| CPlumeDigitizerModule | PLUME digitizer |
| CPlumeModule | The Plume module |
| CSensitiveDetector | Sensitive Detector implementation of the PLUME detector |
| ►NPXD | Namespace to encapsulate code needed for simulation and reconstrucion of the PXD |
| CActivatePXDClusterPositionEstimatorModule | The ActivatePXDClusterPositionEstimator module |
| CActivatePXDGainCalibratorModule | The ActivatePXDGainCalibrator module |
| CActivatePXDPixelMaskerModule | The ActivatePXDPixelMasker module |
| CCluster_t | Struct to hold variables for PXD clusters |
| CClusterCache | Class to remember recently assigned clusters This class will remember the current and the last pixel row to allow fast finding of the correct cluster a pixel belongs to |
| CClusterCandidate | Class representing a possible cluster during clustering of the PXD It supports merging of different clusters and keeps track of the highest charge inside the cluster |
| CClusterProjection | Helper struct to collect information about the 1D projection of a Pixel cluster |
| Cdhc_commode_frame | DHH common mode frame data struct |
| Cdhc_dhe_end_frame | DHE End frame data struct |
| Cdhc_dhe_start_frame | DHH start frame data struct |
| Cdhc_direct_readout_frame | DHC direct readout frame data struct |
| Cdhc_direct_readout_frame_raw | DHC RAW direct readout frame data struct |
| Cdhc_direct_readout_frame_zsd | DHC Zero suppressed direct readout frame data struct |
| Cdhc_end_frame | DHC End frame data struct |
| Cdhc_frame_header_word0 | DHC frame header word data struct |
| Cdhc_frames | DHC frame wrapper class |
| Cdhc_ghost_frame | DHC Ghost frame data struct |
| Cdhc_onsen_roi_frame | ONSEN (debug) ROI frame data struct |
| Cdhc_onsen_trigger_frame | ONSEN Trigger frame data struct |
| Cdhc_start_frame | DHC start frame data struct |
| CDigit | Class to represent the coordinates of one pixel |
| CDigitValue | Class representing the charge and particle contributions for one pixel |
| CGeoPXDCreator | The creator for the PXD geometry of the Belle II detector |
| CNoiseMap | Base Class to represent pixel dependent Noise Map |
| CPixel | Class to represent one pixel, used in clustering for fast access |
| ►CPXDBackgroundModule | PXD Background module |
| CSensorData | Struct to hold data of an PXD sensor |
| CPXDBadSensorTagModule | The PXD bad sensor tagger module |
| CPXDBeamBackHitFilterModule | The PXDBeamBackHitFilter module |
| ►CPXDBgTupleProducerModule | PXD Background Tuple Producer |
| CSensorData | Struct to hold data of an PXD sensor |
| CPXDClusterCheckModule | The PXDClusterCheck module |
| CPXDClusterizerModule | The PXDClusterizer module |
| CPXDClusterPositionEstimator | Singleton class that estimates cluster positions taking into account the estimated track incidence angles into the sensor |
| CPXDClusterShape | Class to correct estimation of cluster error and position base on its shape |
| CPXDDAQDQMModule | The PXD DAQ DQM module |
| CPXDDigitizerModule | The PXD Digitizer module |
| CPXDDigitSorterModule | The PXDDigitSorter module |
| CPXDEventPlotModule | Plot each event with ROI and Pixels |
| CPXDGainCalibrator | Singleton class for managing gain corrections for the PXD |
| CPXDGatedDHCDQMModule | The PXD Gatint after Injection DQM module |
| CPXDGatedInfoFillerModule | PXD Gates Mode information on readout gate basis |
| CPXDGatedModeDQMModule | The PXD for GatedMode DQM module |
| CPXDInjectionDQMModule | The PXD Occupancy after Injection DQM module |
| CPXDMappingLookup | Class to make the mapping between u/v cell ID of pixels back to DCD drain lines, pixel row/col, DCD and Switcher IDs Details: Belle Note: BELLE2-NOTE-TE-2015-01 "The vertex detector numbering scheme" https://docs.belle2.org/record/243/files/Belle%20II%20note%200010.pdf PXD WhiteBook 3.1.3 Sensor Design and Appendix #3 https://xwiki.desy.de/xwiki/bin/download/BI/Belle%20II%20Internal/Detector%20WebHome/PXD%20WebHome/WebHome/PXDwb.pdf?rev=2.1 |
| ►CPXDMCBgTupleProducerModule | PXD MC Background Tuple Producer |
| CSensorData | Struct to hold data of an PXD sensor |
| CPXDPackerErrModule | The PXDPackerErr module |
| CPXDPackerModule | The PXDPacker module |
| CPXDPixelMasker | Singleton class for managing pixel masking for the PXD |
| CPXDPostErrorCheckerModule | The PXD DAQ Post Unpacking Error Check |
| CPXDRawDQMChipsModule | The raw PXD DQM module |
| CPXDRawDQMModule | The raw PXD DQM module |
| CPXDRawDumperModule | Dump Raw PXD/ ONSEN event data |
| CPXDRawHitMaskingModule | The PXDRawHitMasking module |
| CPXDRawHitSorterModule | The PXDRawHitSorter module |
| CPXDReadRawBonnDAQMatchedModule | Module to Load BonnDAQ file and store it as RawPXD in Data Store This is meant for lab use (standalone testing, debugging) without an event builder |
| CPXDReadRawBonnDAQModule | Module to Load Raw PXD Data from DHH network-dump file and store it as RawPXD in Data Store This is meant for lab use (standalone testing, debugging) without an event builder |
| CPXDReadRawONSENModule | A class definition of an input module for Sequential ROOT I/O |
| CPXDROIDQMModule | The raw PXD DQM module |
| CPXDROIPlotModule | Plot each event with ROI and Pixels |
| CPXDUnpackerModule | The PXDUnpacker module |
| CPXDUnpackerOldModule | The PXDUnpacker module |
| CPXDUnpackerOTModule | The PXDUnpackerOT module |
| CSensorInfo | Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific information |
| CTrackBase_t | Struct to hold variables from a track which contains a vector of data type like TrackCluster |
| CTrackCluster_t | Struct to hold variables for track clusters |
| CTrackPoint_t | Struct to hold variables for intersection points |
| ►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) |
| ►Nqcsmonitor | Namespace to encapsulate code needed for the QCSMONITOR detector |
| CQcsmonitorCreator | The creator for the QCSMONITOR geometry |
| CQcsmonitorDigitizerModule | Qcsmonitor tube digitizer |
| CQcsmonitorModule | The Qcsmonitor module |
| CQcsmonitorStudyModule | Study module for Qcsmonitor (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the QCSMONITOR detector |
| ►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 |
| ►NSimulation | |
| CAntiBaryonPhysics | Anti-baryon hadronic physics constructor for Belle II physics list |
| CBelle2PhysicsList | Custom Geant4 physics list for Belle II with options to add optical physics, standard EM physics and high precision neutrons |
| CEnergyLossForExtrapolator | Calculate energy loss, fluctuation, and multiple-scattering angle for extrapolator |
| CEventAction | The Event Action class |
| CExtCylSurfaceTarget | Defines a closed cylinder for the geant4e "target", the surface that encloses the volume within which track extrapolation is done |
| CExtEnergyLoss | Define physics process to calculate energy loss without fluctuations |
| CExtMagFieldLimitProcess | Defines the physics process that avoids hit invocation in sensitive volumes |
| CExtManager | It is the main interface for the user to define the setup and start the propagation |
| CExtMessenger | Define the mechanism by which the user can communicate with the geant4e extrapolator using geant4 UI commands |
| CExtPhysicsConstructor | Define geant4e-specific physics |
| CExtPhysicsList | Standalone physics list for the geant4e extrapolator |
| CExtStepLengthLimitProcess | Defines the physics process that avoids hit invocation in sensitive volumes |
| CGammaLeptoNuclearPhysics | Gamma-nuclear, electro-nuclear and muon-nuclear physics constructor for Belle II physics list |
| CGeant4ePhysics | Define geant4e-specific physics |
| CHyperonPhysics | Hyperon hadronic physics constructor for Belle II physics list |
| CIonPhysics | Ion hadronic physics constructor for Belle II physics list |
| CKaonPhysics | Kaon hadronic physics constructor for Belle II physics list |
| CMagneticField | The Class for the Belle2 magnetic field implementation for Geant4 |
| CMCParticleGenerator | This class creates Geant4 primary particles from MCParticle list The generator assumes that each particle in the list has exactly one mother |
| CNeutronPhysics | Neutron hadronic physics constructor for Belle II physics list |
| CPhysicsList | The basf2 physics list |
| CPionPhysics | Pion hadronic physics constructor for Belle II physics list |
| CPrimaryGeneratorAction | Inherits from G4VuserPrimaryGeneratorAction and specifies how a primary event should be generated |
| CProtonPhysics | Proton hadronic physics constructor for Belle II physics list |
| ►CRunManager | The run manager controls the flow of the Geant4 program and manages the event loop(s) within a run |
| CSingletonDestroyer | Destroyer class to delete the instance of the RunManager class when the program terminates |
| CSensitiveDetectorBase | Base class for all Sensitive Detectors to create hits during simulation |
| CStackingAction | The basf2 stacking action |
| CSteppingAction | The Class for the stepping action |
| CStepTiming | Class to perform more detailed timing studies of the Geant4 simulation |
| CTrackingAction | The Tracking Action class |
| CUserInfo | UserInfo class which is used to attach additional information to Geant4 particles and tracks |
| ►NSoftwareTrigger | |
| CCosmicRayHLTDQMModule | A class definition of an input module for Sequential ROOT I/O |
| CFilterCalculator | Implementation of a calculator used in the SoftwareTriggerModule to fill a SoftwareTriggerObject for doing HLT cuts |
| CFinalTriggerDecisionCalculator | Helper class to give the getFinalTriggerDecision to python |
| CSkimSampleCalculator | Implementation of a calculator used in the SoftwareTriggerModule to fill a SoftwareTriggerObject for selecting particles for skimming and data quality monitoring |
| CSoftwareTriggerCalculation | Base class for all calculation algorithms to be used when calculating the variables needed in the SoftwareTrigger modules for the cuts |
| CSoftwareTriggerCut | Software Trigger Cut to be used in the Software Trigger Modules |
| CSoftwareTriggerDBHandler | Helper class for performing up- and downloads of SoftwareTriggerCuts from the database |
| CSoftwareTriggerHLTDQMModule | Module defining the STM histograms |
| CSoftwareTriggerModule | Module to perform cuts on various variables in the event |
| CSoftwareTriggerResultPrinterModule | Write out the software trigger results in an easily accessible summary table |
| ►CSoftwareTriggerVariableManager | Variable Manager for the software trigger cuts |
| CSoftwareTriggerVariable | Class which represents an abstract variable in the SoftwareTriggerVariableManager |
| CSoftwareTriggerVariables | Storable object for the variables calculated in the SoftwareTriggerModule |
| CStatisticsTimingHLTDQMModule | Module for Event Time Statistics DQM plots |
| ►Nsrsensor | Namespace to encapsulate code needed for the DIAMOND detector |
| CDiamondCreator | The creator for the DIAMOND geometry |
| CFei4Creator | The creator for the FEI4 geometry |
| CSddCreator | The creator for the SDD geometry |
| CSensitiveDetector | Sensitive Detector implementation of the SRSENSOR detector |
| CSrsensorModule | The Srsensor module |
| ►Nstructure | Namespace to encapsulate code needed for simulation and reconstrucion of the structure |
| CGeoServiceMaterialCreator | The creator for the Service Material geometry of the Belle II detector |
| CGeoSTRCreator | To create the Belle2 structure geometry |
| ►NSuperKEKB | |
| CSuperKEKBTree | Structure for the input of the data SUPERKEKB (TTree "Data_SUPERKEKB") |
| ►NSVD | Namespace to encapsulate code needed for simulation and reconstrucion of the SVD |
| CDefaultWave | A functor to provide a simple model of APV25 strip response |
| CGeoSVDCreator | The creator for the SVD geometry of the Belle II detector |
| CNoiseMap | Base Class to represent strip-dependent noise map |
| CRawCluster | Class representing a raw cluster candidate during clustering of the SVD |
| CSensorInfo | Specific implementation of SensorInfo for SVD Sensors which provides additional sensor specific information |
| CSimpleClusterCandidate | Class representing a cluster candidate during simple clustering of the SVD |
| CstripInCluster | Structure containing the relevant information of eachstrip of the cluster |
| CStripInRawCluster | Structure containing the relevant information of each strip of the raw cluster |
| ►CSVDBackgroundModule | SVD Background module |
| CSensorData | Struct to hold data of an SVD sensor |
| CSVDBeamBackHitFilterModule | The SVDBeamBackHitFilter module |
| CSVDClusterCharge | Abstract Class representing the SVD cluster charge |
| CSVDClusterizerModule | The SVD Clusterizer |
| CSVDClusterPosition | Abstract Class representing the SVD cluster position |
| CSVDClusterTime | Abstract Class representing the SVD cluster time |
| CSVDCoG3Time | Derived Class representing the SVD cluster time computed with the CoG3 algorithm |
| CSVDCoG6Time | Derived Class representing the SVD cluster time computed with the CoG6 algorithm |
| CSVDCoGOnlyPosition | Derived Class representing the SVD cluster position computed with the CoGOnly algorithm |
| CSVDDatabaseTestModule | Return the calibration results for the noises and the constants measured during the svd local runs (charge, ADC pulse, peaking time, pulse width) |
| CSVDDigitizerModule | The SVD Digitizer module |
| ►CSVDDQMDoseModule | The SVD dose-monitoring DQM module |
| CSensorGroup | A struct to define non-trivial histograms in a human-readable way |
| CSVDDQMInjectionModule | The SVD Occupancy after Injection DQM module |
| CSVDELS3Charge | Derived Class representing the SVD cluster charge computed with the ELS3 algorithm |
| CSVDELS3Time | Derived Class representing the SVD cluster time computed with the ELS3 algorithm |
| CSVDMaxSampleCharge | Derived Class representing the SVD cluster charge computed summing the max sample of each strip |
| CSVDMaxSumAlgorithm | Class implementing the MaxSum algorithm |
| CSVDMissingAPVsClusterCreatorModule | SVDMissingAPVsClusterCreatorModule: The SVD MissingAPVsClusterCreator |
| CSVDOldDefaultPosition | Derived Class representing the SVD cluster position computed with the old algorithm (up to release-05) |
| ►CSVDPackerModule | SVDPackerModule: The SVD Raw Hits Creator |
| CAPVHeader | Implementation of APV Header |
| Cdata_A | Implementation of the first data word |
| Cdata_B | Implementation of the second data word |
| CDataInfo | 6 samples and APV channel struct |
| CFADCTrailer | Implementation of FADC Trailer |
| CFTBHeader | Implementation of FTB Header |
| CFTBTrailer | Implementation of FTB Trailer |
| CMainHeader | Implementation of FADC Header |
| CSVDRecoChargeFactory | Cluster Charge Factory Class |
| CSVDRecoDigitCreatorModule | The SVD RecoDigit Creator |
| CSVDReconstructionBase | Class to check whether the reconstruction algorithms are available or not |
| CSVDRecoPositionFactory | Cluster Position Factory Class |
| CSVDRecoTimeFactory | Cluster Time Factory Class |
| CSVDShaperDigitSorterModule | The SVDShaperDigitSorter module |
| CSVDSimpleClusterizerModule | SVDSimpleClusterizerModule: The SVD SimpleClusterizer |
| CSVDSumSamplesCharge | Derived Class representing the SVD cluster charge computed summing the samples of each strip |
| ►CSVDUnpackerModule | SVDUnpackerModule: The SVD Raw Hits Decoder |
| CAPVHeader | Implementation of APV Header |
| Cdata_A | Implementation of the first data word |
| Cdata_B | Implementation of the second data word |
| CFADCTrailer | Implementation of FADC Trailer |
| CFTBHeader | Implementation of FTB Header |
| CFTBTrailer | Implementation of FTB Trailer |
| CMainHeader | Implementation of FADC Header |
| CSVDVariablesToStorageModule | A module for validating SVD data |
| ►CSVDWaveform | The SVD waveform class |
| CElementaryWaveform | Type to store elementary waveform parameters |
| CTauEncoder | Encoder/decoder for neural network tau values |
| CWaveFitter | Waveform fitter class |
| CWaveGenerator | Waveform generator This is a functor to calculate APV samples from waveform |
| ►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 |
| ►NTOP | |
| CBackgroundPDF | Parametrization of background PDF in pixels of single module |
| CChannelMapper | Provides mapping between electronic channels and pixels |
| ►CChi2MinimumFinder1D | Minimum finder using tabulated chi^2 values in one dimension |
| CMinimum | Result of minimum finder |
| CDataArray | Helper class for getting data words from a finesse buffer Keeps checksum counter for each extracted data word and calculates tcp checksum on request |
| ►CDeltaRayPDF | Parametrization of delta-ray PDF in pixels of single module |
| CGausXY | Normal (Gaussian) distribution: an entry for the table |
| CEnergyMask | A mask for energy masking |
| CFastRaytracer | Fast photon propagation in quartz optics |
| CFrontEndMapper | Provides mapping between electronics module position within a TOP module and SCROD ID, COPPER and Finesse slot |
| CGeoTOPCreator | Geometry creator for TOP counter |
| CHelixSwimmer | Utility for propagation of a particle along helix |
| ►CInverseRaytracer | Utility for solving inverse ray-tracing problem |
| CCerenkovAngle | Sine and cosine of Cerenkov angle |
| CSolution | Solution of inverse ray-tracing |
| CLaserCalibratorFit | A class do laser calibration fit provide different fitting method (under development) |
| CLikelihoods | Structure for TOPLikelihood members |
| CModuleAlignment | Alignment of a TOP module |
| CPDF1Dim | Binned one dimensional PDF (a projection of PDF to time axis) |
| ►CPDFConstructor | PDF construction and log likelihood determination for a given track and particle hypothesis |
| CInverseRaytracerDirect | Structure that enables defining a template function: direct photons |
| CInverseRaytracerReflected | Structure that enables defining a template function: reflected photons |
| CLogL | Useful data type for returning the results of log likelihood calculation |
| CPrismSolution | Solution of inverse raytracing in prism |
| CPull | Data type for storing photon pull w.r.t PDF peak |
| CPhotonState | State of the Cerenkov photon in the quartz optics |
| CPixelEfficiencies | Pixel relative efficiencies of a single module |
| CPixelMasks | Pixel masks of a single module |
| ►CPixelPositions | Pixel positions and dimensions in module local frame |
| CPixelData | Position and size of a pixel |
| CPulseHeightGenerator | Generates pulse height according to distribution: P(x) = (x/x0)^p1 * exp(-(x/x0)^p2), p1 >= 0, p2 > 0 in the range 0 to xmax |
| ►CRaytracerBase | Base class with geometry data |
| CBarSegment | Bar segment data in module local frame |
| CMirror | Spherical mirror data in module local frame |
| CPrism | Prism data in module local frame |
| CSensitiveBar | Class providing information on MCParticles hitting the bars |
| CSensitivePMT | Class providing SimHits |
| ►CSignalPDF | Parametrization of signal PDF in a single pixel |
| CPDFExtra | Extra information about single PDF peak |
| CPDFPeak | Single PDF peak |
| ►CTimeDigitizer | Time digitization of simulated hits in a single electronic channel |
| CHit | Hit data other than time |
| ►CTOPAlignmentAlgorithm | Algorithm for geometrical alignment of TOP modules with dimuons or Bhabhas |
| CAlignData | Data structure |
| CTOPAsicShiftsBS13dAlgorithm | Calibration algorithm for carrier shifts of BS13d |
| CTOPChannelMaskAlgorithm | Algorithm for masking of dead and hot channels |
| CTOPCommonT0BFAlgorithm | Algorithm for common T0 calibration with a fit of bunch finder residuals |
| CTOPCommonT0LLAlgorithm | Algorithm for common T0 calibration with neg |
| CTOPEventT0OffsetAlgorithm | Algorithm for event T0 offset calibration |
| CTOPFillPatternOffsetAlgorithm | Algorithm for calibration of fill pattern offset |
| CTOPGeometryPar | Singleton class for TOP Geometry Parameters |
| CTOPLocalCalFitter | This module is the fitter for the CAF collector TOPLaserCalibratorCollector |
| CTOPModuleT0DeltaTAlgorithm | Algorithm for module T0 calibration with chi2 minimization of time differences between slots (method DeltaT) |
| CTOPModuleT0LLAlgorithm | Algorithm for module T0 calibration with neg |
| CTOPPhotonYieldsAlgorithm | Algorithm for photon pixel yields aimed for PMT ageing studies, for calibration of relative pixel efficiencies and for finding optically decoupled PMT's |
| CTOPPulseHeightAlgorithm | Algorithm for pulse-height and threshold efficiency calibration |
| CTOPRecoManager | Singleton class providing pre-constructed reconstruction objects |
| ►CTOPTemplateFitter | Class to perform template fit on TOP waveform data Minimization method is described here http://wwwa1.kph.uni-mainz.de/Vorlesungen/SS11/Statistik/ |
| CFitResult | Structure holding values from template fit |
| CMinimizationSums | Variables used during template fit minimization |
| CTemplateParameters | Parameters of the template function |
| ►CTOPTrack | Reconstructed track at TOP |
| CAssumedEmission | Assumed photon emission point in local frame |
| CSelectedHit | Selected photon hit from TOPDigits |
| CTrackAngles | Sine and cosine of track polar and azimuthal angles at assumed photon emission |
| CTOPTree | Structure of a flat ntuple |
| CTOPValidationAlgorithm | Algorithm for automatic validation of the calibration |
| CTrackHit | Structure for track parameters at TOP |
| CTrackSelector | Utility for the track selection - used in various calibration modules |
| CValidationTreeStruct | Calibration validation tree structure |
| ►CYScanner | Utility for expanding the PDF in y direction |
| CDerivatives | Derivatives |
| CPixelProjection | Down-stream projection of a pixel to prism entrance window w/ a clip on bar exit thickness |
| CResult | Single PDF peak data |
| CTable | A table of equidistant entries |
| CTableEntry | Table entry |
| ►NTrackFindingCDC | |
| CAdderInterface | Base class for a findlet, which uses a reduced/thinned list of weighted relations between collector and collection items to absorb the matched collection items into a collector item |
| CAdvancedSegmentVarNames | Vehicle class to transport the variable names |
| CAdvancedSegmentVarSet | Class to compute floating point variables from a segment which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CAImpactSweeped | Takes a basic object and sweeps it by some d0 range in the y direction |
| CAllAxialSegmentPairFilter | Filter accepting all axial to axial segment pairs |
| CAllClusterFilter | Filter accepting all clusters |
| CAllFacetFilter | Filter for the construction of good facets based on simple criteria |
| CAllFacetRelationFilter | Filter accepting all facet relations with a default weight |
| CAllFilter | Filter adapter type that accepts all items (just for reference) |
| CAllSegmentPairFilter | Filter for the construction of axial to stereo segment pairs based on simple criteria |
| CAllSegmentPairRelationFilter | Relation filter that lets all possible combinations pass |
| CAllSegmentTripleFilter | Filter for the construction of segment triples based on simple criteria |
| CAllSegmentTripleRelationFilter | Class excepting all segment triples |
| CAllTrackRelationFilter | Relation filter that lets all possible combinations pass |
| CAllWireHitFilter | Filter accepting all hits |
| CAlternation | Generic functor to try to functors and choose the first to be applicable |
| CAndFilter | Filter adapter type that joins two filter results in an and like fashion |
| CAngleUtil | Utility functions to be used with angular quantities |
| CAPhi0Sweeped | Takes a basic object and sweeps it by some angle phi0 range a around the origin |
| CAsicBackgroundDetector | Marks hits as background based on the result of a filter |
| CAsicBackgroundLibraryCreator | Finds ASICs with single signal hit, records info to the library |
| CAsicBackgroundLibraryCreatorModule | Module for creating ASIC background library |
| CAssignParameterVisitor | A helper class to unpack a boost::variant parameter value and set it in the parameter list |
| CAutomatonCell | Cell used by the cellular automata |
| CAxialHitQuadTreeProcessor | A QuadTreeProcessor for TrackHits |
| CAxialLegendreLeafProcessor | Predicate class that is feed the nodes in a WeightedHoughTree walk It decides if a node should be further expanded and extracts items from nodes that are considered as leafs to build tracks |
| CAxialSegmentPairCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CAxialSegmentPairFilterFactory | Factory that can create appropriate axial segment pair filters from associated names |
| CAxialStraightTrackCreator | A findlet that searches for straight tracks in CDC coming form IP to an ECL cluster |
| CAxialStraightTrackFinder | Generates straight axial tracks from IP to an ECL cluster |
| CAxialTrackCreatorHitHough | Generates axial tracks from hit using the special leaf processing inspired by the legendre algorithm |
| CAxialTrackCreatorHitLegendre | Generates axial tracks from hit using special leaf postprocessing |
| CAxialTrackCreatorMCTruth | Findlet that generates tracks from wire hits using the mc truth information |
| CAxialTrackCreatorSegmentHough | Generates axial tracks from segments using the hough algorithm |
| CAxialTrackFinderHough | Generates axial tracks from hit using the special leaf processing inspired by the hough algorithm |
| CAxialTrackFinderLegendre | Generates axial tracks from hit using special leaf postprocessing |
| CAxialTrackHitMigrator | Exchanges hits between axial tracks based on their distance to the respective trajectory |
| CAxialTrackMerger | Findlet implementing the merging of axial tracks found in the legendre tree search |
| CAxialTrackUtil | Utility structure gathering heuristic functions used during the axial track finding |
| CBackgroundTagColorMap | CDCHit to color map by their associated CDCSimHit::getBackgroundTag property |
| CBaseCandidateReceiver | Base class that receives candidates found by quadtree |
| CBaseFacetRelationFilter | Base class for filtering the neighborhood of facets |
| CBaseSegmentPairRelationFilter | Base class for filtering the neighborhood of axial stereo segment pairs |
| CBaseSegmentRelationFilter | Base class for filtering the neighborhood of segments |
| CBaseSegmentTripleRelationFilter | Base class for filtering the neighborhood of segment triples |
| CBaseTrackRelationFilter | Base class for filtering the neighborhood of tracks |
| CBaseVarSet | Generic class that generates some named float values from a given object |
| CBasicAxialSegmentPairVarNames | Vehicle class to transport the variable names |
| CBasicAxialSegmentPairVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicClusterVarNames | Vehicle class to transport the variable names |
| CBasicClusterVarSet | Class to compute floating point variables from a wire hit cluster which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicFacetRelationVarNames | Vehicle class to transport the variable names |
| CBasicFacetRelationVarSet | Class to compute floating point variables from a facet relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicFacetVarNames | Vehicle class to transport the variable names |
| CBasicFacetVarSet | Class to compute floating point variables from a facet which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicSegmentPairRelationVarNames | Vehicle class to transport the variable names |
| CBasicSegmentPairRelationVarSet | Class to compute floating point variables from an axial stereo segment pair relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicSegmentPairVarNames | Vehicle class to transport the variable names |
| CBasicSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicSegmentRelationVarNames | Vehicle class to transport the variable names |
| CBasicSegmentRelationVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicSegmentVarNames | Vehicle class to transport the variable names |
| CBasicSegmentVarSet | Class to compute floating point variables from a segment which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicTrackRelationVarNames | Vehicle class to transport the variable names |
| CBasicTrackRelationVarSet | Class to compute floating point variables from a track relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicTrackVarSet | Class to compute floating point variables from a track which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBasicTrackVarSetNames | Vehicle class to transport the variable names |
| CBeamEventFlightTimeEstimator | Concrete estimator for the regular beam event setup |
| CBendFacetRelationVarNames | Vehicle class to transport the variable names |
| CBendFacetRelationVarSet | Class to compute floating point variables from a facet relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBendFacetVarNames | Vehicle class to transport the variable names |
| CBendFacetVarSet | Class to compute floating point variables from a facet which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBestMatchedTruthVarNames | Vehicle class to transport the variable names |
| CBestMatchedTruthVarSet | Class to compute floating point variables from a track which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBestMatchSelector | Selector to remove all relations in the list, which share the same collection item - except the one which the highest weight - and vice versa |
| CBinaryJoin | Functor factory turning a binary functor and two functors into a new functor which executes the binary operation with input from the two given functors |
| CBkgTruthClusterVarNames | Vehicle class to transport the variable names |
| CBkgTruthClusterVarSet | Class to compute floating point variables from a wire hit cluster which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBkgTruthSegmentVarSet | Class to compute floating point variables from a segment which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CBoundingBox | A two dimensional rectangle that keeps track of the extend of a drawing |
| CBox | The base class for all boxes |
| CBox<> | Box Base class specification without any template arguments |
| CBoxDivisionHoughTree | A fast hough algorithm with rectangular boxes, which are split linearly by a fixed number of divisions in each coordinate up to a maximal level |
| CBridgingWireHitRelationFilter | Wire hit relation filter that is compensating for hit inefficiencies |
| CCDCAxialSegmentPair | Class representing a pair of reconstructed axial segments in adjacent superlayer |
| CCDCAxialStereoFusion | Utility class implementing the Kalmanesk combination of to two dimensional trajectories to one three dimensional trajectory |
| CCDCBFieldUtil | Helper functions to interact with the magnetic field |
| CCDCFacet | Class representing a triple of neighboring oriented wire with additional trajectory information |
| CCDCFacetSegment | A segment consisting of adjacent facets |
| CCDCFitter2D | Class implementing a fit for two dimensional trajectory circle using a generic fitting backend |
| CCDCGeometryLoader | Load the CDC geometry from the conditions database |
| CCDCKarimakiFitter | Class implementing the fitter using Karimakis method |
| CCDCMCCloneLookUp | Class providing information whether a PR CDC track is the best match or a clone |
| CCDCMCCloneLookUpFiller | Findlet to exports CDCTracks as RecoTracks |
| CCDCMCHitCollectionLookUp | Interface class to the Monte Carlo information for collections of hits |
| CCDCMCHitLookUp | Interface class to the Monte Carlo information for individual hits |
| CCDCMCManager | Class to organize and present the Monte Carlo hit information |
| CCDCMCMap | Class to organize and present the Monte Carlo hit information |
| CCDCMCSegment2DLookUp | Specialisation of the lookup for the truth values of two dimensional segments |
| CCDCMCSegment3DLookUp | Specialisation of the lookup for the truth values of two dimensional segments |
| CCDCMCSegmentLookUp | Legacy for python : interface to obtain the two dimensional segment mc lookup |
| CCDCMCTrackLookUp | Specialisation of the lookup for the truth values of reconstructed tracks |
| CCDCMCTrackStore | Class to organize and present the monte carlo hit information |
| CCDCObservations2D | Class serving as a storage of observed drift circles to present to the Riemann fitter |
| CCDCRecoHit2D | Class representing a two dimensional reconstructed hit in the central drift chamber |
| CCDCRecoHit3D | Class representing a three dimensional reconstructed hit |
| CCDCRiemannFitter | Class implementing the Riemann fit for two dimensional trajectory circle |
| CCDCRLWireHit | Class representing an oriented hit wire including a hypotheses whether the causing track passes left or right |
| CCDCRLWireHitPair | A pair of oriented wire hits |
| CCDCRLWireHitSegment | A segment consisting of two dimensional reconstructed hits |
| ►CCDCRLWireHitTriple | Class representing a triple of neighboring wire hits |
| CShape | Type for the different shapes of a triple of neighboring wire hits |
| CCDCRobustSZFitter | Utility class implementing robust versions of linear sz trajectory line fits |
| CCDCSegment | A sequence of hits limited to one superlayer |
| CCDCSegment2D | A reconstructed sequence of two dimensional hits in one super layer |
| CCDCSegment3D | A segment consisting of three dimensional reconstructed hits |
| CCDCSegmentPair | Class representing a pair of one reconstructed axial segment and one stereo segment in adjacent superlayer |
| CCDCSegmentTriple | Class representing a triple of reconstructed segments in adjacent superlayer |
| CCDCSimHitLookUp | Singletone class to gather local information about the hits |
| ►CCDCSimpleSimulation | Class providing a simple simulation of the CDC mainly for quick unit test checks |
| CSimpleSimHit | Structure to accommodate information about the individual hits during the simulation |
| CCDCSVGPlotter | Helper class to generated the svg image from the various tracking objects |
| CCDCSZFitter | Class implementing the z coordinate over travel distance line fit |
| CCDCSZObservations | Class serving as a storage of observed sz positions to present to the sz line fitters |
| CCDCTangent | Class representing a linear track piece between two oriented wire hits |
| CCDCTangentSegment | A segment consisting of adjacent tangents |
| CCDCTrack | Class representing a sequence of three dimensional reconstructed hits |
| CCDCTrackingEventLevelMdstInfoFillerFromHitsFindlet | Findlet for storing in mdsts some hit-based information per event |
| CCDCTrackingEventLevelMdstInfoFillerFromHitsModule | Module interface to the CDCTrackingEventLevelMdstInfoFillerFromHitsFindlet |
| CCDCTrackingEventLevelMdstInfoFillerFromSegmentsFindlet | Findlet for storing in mdsts some segment-based information per event |
| CCDCTrackingEventLevelMdstInfoFillerFromSegmentsModule | Module interface to the CDCTrackingEventLevelMdstInfoFillerFromSegmentsFindlet |
| CCDCTrajectory2D | Particle trajectory as it is seen in xy projection represented as a circle |
| CCDCTrajectory3D | Particle full three dimensional trajectory |
| CCDCTrajectorySZ | Linear trajectory in sz space |
| CCDCWire | Class representing a sense wire in the central drift chamber |
| CCDCWireHit | Class representing a hit wire in the central drift chamber |
| CCDCWireHitCluster | An aggregation of CDCWireHits |
| CCDCWireHitSegment | A segment consisting of two dimensional reconstructed hits |
| CCDCWireHitVarNames | Vehicle class to transport the variable names |
| CCDCWireHitVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| CCDCWireLayer | Class representing a sense wire layer in the central drift chamber |
| CCDCWireSuperLayer | Class representing a sense wire superlayer in the central drift chamber |
| CCDCWireTopology | Class representing the sense wire arrangement in the whole of the central drift chamber |
| ►CCellularAutomaton | Implements the weighted cellular automaton algorithm |
| CCycleException | Type for the very basic exception signal used in the detection of cycles |
| CCellularPathFollower | Implements to pick up of the highest value path in neighborhood Following high value paths can be done two ways |
| CChi2FacetFilter | Filter for the construction of good facets based in the chi2 fit |
| CChi2FacetRelationFilter | Class filtering the neighborhood of facets based on chi2 from a fit both facets |
| CChoosableFromVarSet | Filter adapter to make a filter work on a set of variables and return on variable as the result of the filter |
| CChoosableFromVarSetFilter | Convince template to create a filter returning on variable from a set of variables |
| CChooseable | Filter can delegate to a filter chosen and set up at run time by parameters |
| CChooseableFilter | Convenvience wrapper to setup a Chooseable filter from a specific factory object |
| CChooseableHitStyling | This Class handles the mapping from the colormapping-method name given as a string to the actual color mapping for CDCHits |
| CChooseableRecoTrackStyling | This Class handles the mapping from the colormapping-method name given as a string to the actual color mapping for RecoTrack |
| CChooseableSegmentStyling | This Class handles the mapping from the colormapping-method name given as a string to the actual AColorMap for CDCSegments |
| CChooseableStyling | Implementation of a styling composed from several predefined mappings chooseable by their name |
| CCircle2D | A two dimensional circle in its natural representation using center and radius as parameters |
| CClear | Functor to get the .clear() from an arbitrary objects |
| CClusterBackgroundDetector | Marks clusters as background based on a background measure |
| CClusterCreator | Refines the clustering of wire hits from clusters to clusters |
| CClusterFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CClusterizer | Implementation of the clustering Clusters elements of a given collection using the relations presented by a neighborhood |
| CClusterPreparer | Findlet to cluster the wire hits in the CDC to form locally connected groups with two granularities."; |
| CClusterRefiner | Refines the clustering of wire hits from super clusters to clustexrs |
| CColors | Utility functions related to colors |
| CCommon | Adapter of a category function to find the common category of several objects |
| CCompareCDCTracks | Functor which which decides which of two tracks to declare as best match |
| CCompositeProcessingSignalListener | Partial implementation for an algorithm part that wants to dispatch processing signals to subobjects |
| CComposition | Functor factory from the functional composition of two functors |
| CConstant | Generic functor to wrap a constant as a function |
| CConstantMapping | Realizing a mapping returning a constant attribute value regardless of object or position |
| CContinuousValue | Type to have values not based on discrete positions from an array |
| CCosmicRayFlightTimeEstimator | Concrete estimator for the cosmic ray setup - estimates negative times on incoming arm |
| CCovarianceMatrixUtil | Collection of functions related to covariance matrices |
| CCurvBinsSpec | Strategy to construct discrete curve points from discrete overlap specifications |
| CCurvWithArcLength2DCache | Class representing a curvature value that also caches two dimensional arc length to each layer in the CDC |
| CCutSelector | Selector to remove all weighted relations with a weight below a certain cut value |
| CCutsFromDBWireHitFilter | Filter rejecting hits according to DB values |
| CCycleMapping | Realizing a mapping from a pool of values to be cycled from the index |
| CDebugableSimpleBoxDivisionHoughTree | A convenience class for adding debug information to a Simple Hough Tree |
| CDefaultColorCycleMapping | Class template for coloring objects in different Colors |
| CDefaultColorCycleStyling | Class template for coloring objects with stroke colors prepared to be the default color cycle |
| CDeref | Functor to get the referenced object from an arbitrary objects |
| CDetectPropertyImpl | Implementation of the detection idiom - base case is not detected |
| CDetectPropertyImpl< ToVoid< AToPredicate< Ts... > >, AToPredicate, Ts... > | Implementation of the detection idiom - specialisation for the detected case |
| CDISABLED_Long_TrackFindingCDCTestWithTopology | Equivalent to |
| CDiscreteValue | Representation for a discrete position in an array of discrete positions |
| CDriftLengthEstimator | Helper construct implementing the (re)estimation of the drift length for various hit objects |
| CDriftTimeUtil | Structure to expose some drift time and length functions from the CDCGeometryPar to Python |
| ►CDynTree | This is the base class for all hough trees |
| CNode | Class for a node in the tree |
| CEnergyLossEstimator | Helper struct to provide consistent energy loss estimation throughout the CDC track finding |
| CEqual | Binary functor for equality comparison of arbitrary objects - equivalent to std::equal_to<> (c++14) |
| CEvalVariadic | Structure to serve as a placeholder for a variadic initializer list of statements to be evaluated |
| CEventDataPlotter | A class that can plot event related data types |
| CExtendedRiemannsMethod | Class implementing the Riemann fit for two dimensional trajectory circle |
| CFacetCreator | Class providing construction combinatorics for the facets |
| CFacetFilterFactory | Factory that can create appropriate facet filters from associated names |
| CFacetFitter | Utility class to fit hit triplet and relations of them |
| CFacetRelationFilterFactory | Factory that can create appropriate facet relation filters from associated names |
| CFeasibleRLFacetFilter | Filter for the construction of good facets investigating the feasibility of the right left passage hypotheses combination |
| CFilter | Base class for filters on a generic object type |
| CFilterFactory | Factory that can create appropriate filter instances from a name |
| CFilterOnVarSet | Convenience template to create a filter operating on a specific set of variables |
| ►CFilterParamMap | Variant of types allowed to be forwarded to a filter selected at runtime |
| CImpl | Define the implementation |
| CFilterSelector | Selector to remove all weighted relations, where a definable Filter gives NaN as a result |
| CFilterVarNames | Vehicle class to transport the variable names |
| CFilterVarSet | Class to compute floating point variables from a filter response which can be recorded as a flat TNtuple or serve as input to a MVA method |
| ►CFindlet | Interface for a minimal algorithm part that wants to expose some parameters to a module |
| CToVectorImpl | Forward a range of mutable objects |
| CToVectorImpl< const T > | Specialisation to only forward a range for immutable types |
| CFindletModule | Adapter of a findlet to a module that exposes the parameters of the findlet and manages the IO with the DataStore |
| CFindletStoreArrayInput | Findlet which can wrap another Findlet and forward the contents of a StoreArray to the wrapped findlet |
| CFirstOfPairInBox | Helper class to redirect only the first element in a pair to the child algorithm |
| CFirstTypeImpl | Helper type to take the first type of a variadic sequence of types |
| CFirstTypeImpl< AType > | Specialisation where there is exactly one type given |
| CFirstTypeImpl< AType, ATypes... > | Specialisation where there is more than one type given |
| CFirstTypeImpl<> | Specialisation where there is exactly one type given |
| CFitAxialSegmentPairVarNames | Vehicle class to transport the variable names |
| CFitAxialSegmentPairVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitFacetRelationVarNames | Vehicle class to transport the variable names |
| CFitFacetRelationVarSet | Class to compute floating point variables from a facet relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitFacetVarNames | Vehicle class to transport the variable names |
| CFitFacetVarSet | Class to compute floating point variables from a facet which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitlessAxialSegmentPairVarNames | Vehicle class to transport the variable names |
| CFitlessAxialSegmentPairVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitlessFacetVarNames | Vehicle class to transport the variable names |
| CFitlessFacetVarSet | Class to compute floating point variables from a facet which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitlessSegmentPairFilter | Filter for the construction of segment pairs based on simple criteria without the common fit |
| CFitlessSegmentPairVarNames | Vehicle class to transport the variable names |
| CFitlessSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitlessSegmentRelationVarNames | Vehicle class to transport the variable names |
| CFitlessSegmentRelationVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitSegmentPairRelationVarNames | Vehicle class to transport the variable names |
| CFitSegmentPairRelationVarSet | Class to compute floating point variables from an axial stereo segment pair relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitSegmentPairVarNames | Vehicle class to transport the variable names |
| CFitSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitSegmentRelationVarNames | Vehicle class to transport the variable names |
| CFitSegmentRelationVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFitTrackRelationVarNames | Vehicle class to transport the variable names |
| CFitTrackRelationVarSet | Class to compute floating point variables from a track relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CFixedSizeNamedFloatTuple | Generic class that contains a fixed number of named float values |
| CFixedStyling | Implementation of a styling from fixed attribute map |
| CFlightTimeEstimator | Helper struct to provide consistent flight time estimation throughout the CDC track finding |
| CFunctorTag | Tag class to facilitate marking of class as a functor in the sense of this code |
| CGeneralizedCircle | A generalized circle |
| CGet | Functor to get the I part (as of std::get<I>) from an arbitrary objects |
| CGetAutomatonCell | Getter functor for the automaton cell of an object |
| CGetEStereoKind | Generic functor to get the stereo kind from an object |
| CGetILayer | Generic functor to get the superlayer id from an object |
| CGetIndexInTuple | Looks up, at which index the given Type can be found in a tuple |
| CGetIndexInTuple< AType, std::tuple< AHeadType, ATailTypes... > > | Specialisation for the case that the first type in the tuple is not the AType asked for. Recursion case |
| CGetIndexInTuple< AType, std::tuple< AType, ATailTypes... > > | Specialisation for the case that the first type in the tuple is equal to the AType asked for. Recursion end |
| CGetIndexInTuple< AType, std::tuple<> > | Specialisation to terminate the recursion in case it was not found |
| CGetISuperLayer | Generic functor to get the superlayer id from an object |
| CGetLowerCurv | Functor to get the lower curvature bound of a hough box |
| CGetUpperCurv | Functor to get the upper curvature bound of a hough box |
| CGetWeight | Generic functor to get the weight from an object |
| CGetWireHit | Generic functor to get the wire hit from an object |
| CGreater | Binary functor for greater comparison of arbitrary objects - equivalent to std::greater<> (c++14) |
| CHelix | Extension of the generalized circle also caching the perigee coordinates |
| CHelixUtil | Utility struct for functions and types related to the helix parameters |
| CHitGapAxialSegmentPairVarNames | Vehicle class to transport the variable names |
| CHitGapAxialSegmentPairVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CHitGapSegmentPairVarNames | Vehicle class to transport the variable names |
| CHitGapSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CHitGapSegmentRelationVarNames | Vehicle class to transport the variable names |
| CHitGapSegmentRelationVarSet | Class to compute floating point variables from a segment relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CHitGapTrackRelationVarNames | Class vehicle to transport the variable names |
| CHitGapTrackRelationVarSet | Class to compute floating point variables from a track relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CHitInHyperBox | An algorithm to check if a hit is contained in a hyperbolic cosine hough box |
| CHitInQuadraticBox | Predicate class to check for the containment of hits in a p q hough space part |
| CHitInZ0TanLambdaBox | Predicate class to check for the containment of hits in a z0 tan lambda hough space part |
| CHitInZ0TanLambdaBoxUsingZ | Predicate class to check for the containment of hits in a z0 tan lambda hough space part using a different algorithm than normal |
| CHitReclaimer | A small findlet that removes flags from hits not accepted by conventional tracking |
| CHyperHough | Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type |
| CId | Generic identity functor |
| CImpactBinsSpec | Strategy to construct discrete impact points from discrete overlap specifications |
| CIndirect | Functor to get the indirection from an arbitrary objects |
| CInPhi0Box | Checker if a position is contained in a family of curves over phi0 |
| CInPhi0CurvBox | Checker if a position is contained in a family of curves over phi0 and curvature |
| CInPhi0CurvTanLBox | Checker if a position is contained in a family of curves over phi0 and tan lambda |
| CInPhi0ImpactBox | Checker if a position is contained in a family of curves over phi0 and impact |
| CInPhi0ImpactCurvBox | Checker if a position is contained in a family of curves over phi0, impact and curvature |
| CInPhi0TanLBox | Checker if a position is contained in a family of curves over phi0 and tan lambda |
| CIsNaN | Unary functor for equality comparison to NAN |
| CISuperLayerUtil | This is a utility class for the free ISuperLayer type |
| CIWireUtil | This is a utility class for the free IWire type |
| CJacobianMatrixUtil | Collection of functions related to jacobian matrices |
| CKarimakisMethod | Class implementing the Karimaki fit for two dimensional trajectory circle |
| CLess | Binary functor for less comparison of arbitrary objects - equivalent to std::less<> (c++14) |
| CLine2D | A two dimensional normal line |
| CLinearDivision | Factory object that constructs sub boxes from a given box with optional overlaps |
| CLineUtil | Utility struct for functions and types related to the line parameters |
| CLookupTable | Class which holds precomputed values of a function |
| CLowHitsAxialTrackUtil | Utility structure gathering heuristic functions used during the search for non-helix or low hit count tracks |
| CMapping | Interface defining a mapping of objects to attribute values e.g. a color |
| CMatcherInterface | Base class for a findlet, which outputs a list of weighted relations between elements in a list of CollectorItems and a list of CollectionItems |
| CMCAxialSegmentPairFilter | Filter for the construction of axial to axial segment pairs based on simple criteria |
| CMCFacetFilter | Filter for the construction of good facets based on Monte Carlo information |
| CMCFacetRelationFilter | Class filtering the neighborhood of facets with Monte Carlo information |
| CMCParticleColorMap | CDCHit to color map by their associated MCParticle::getArrayId() property |
| CMCPDGCodeColorMap | CDCHit to color map by the associated MCParticle::getPDG() |
| CMCPrimaryColorMap | CDCHit to color map by the isPrimary information as well as the secondary process type in case the particle is not primary |
| CMCRecoTrackMatchingStatusColorMap | Color mapping showing the match status of the monte carlo track |
| CMCSegmentIdColorMap | CDCHit to color map by their Monte Carlo segment id |
| CMCSegmentPairFilter | Filter for the construction of axial to stereo segment pairs based on MC information |
| CMCSegmentPairRelationFilter | Class filtering the neighborhood of axial stereo segment pairs with monte carlo information |
| CMCSegmentRelationFilter | Filter for the construction of segment relations based on MC information |
| CMCSegmentTripleFilter | Filter for the construction of segment triples based on Monte Carlo information |
| CMCSegmentTripleRelationFilter | Class filtering the neighborhood of segment triples with monte carlo information |
| CMCSymmetric | Mixin for filters that use Monte Carlo information |
| CMCTrackIdPurityPair | Structure representing a matched Monte Carlo track id with the corresponding purity |
| CMCTrackRelationFilter | Filter for the construction of track relations based on MC information |
| CMonopoleAxialTrackFinderLegendre | Generates monopole-like axial tracks from hit using special leaf postprocessing |
| CMonopoleStereoHitFinder | Complex findlet for finding stereo hits from monopoles to a list of cdc tracks |
| CMonopoleStereoHitFinderQuadratic | Complex findlet for finding stereo hits from monopoles to a list of cdc tracks |
| CMultipassCellularPathFinder | Class to combine the run of the cellular automaton and the repeated path extraction |
| CMVA | Filter based on a mva method |
| CMVABackgroundClusterFilter | Background cluster detection based on MVA package |
| ►CMVAExpert | Class to interact with the MVA package |
| CImpl | Implementation of the class to interact with the MVA package |
| CMVAFacetFilter | Background facet detection based on MVA |
| CMVAFacetRelationFilter | Background facetRelation detection based on MVA |
| CMVAFeasibleAxialSegmentPairFilter | Filter for the construction of segment pairs based on simple criteria without the common fit |
| CMVAFeasibleSegmentPairFilter | Filter for the construction of segment pairs based on simple criteria without the common fit |
| CMVAFeasibleSegmentRelationFilter | Filter for the construction of segment pairs based on simple criteria without the common fit |
| CMVAFeasibleTrackRelationFilter | Filter for the construction of track pairs based on simple criteria without the common fit |
| CMVAFilter | Convenience template to create a mva filter for a set of variables |
| CMVARealisticAxialSegmentPairFilter | Final filter for the construction of segment pairs |
| CMVARealisticSegmentPairFilter | Final filter for the construction of segment pairs |
| CMVARealisticSegmentPairRelationFilter | Final filter for the construction of segment pairs |
| CMVARealisticSegmentRelationFilter | Final filter for the construction of segment pairs |
| CMVARealisticTrackRelationFilter | Final filter for the construction of segment pairs |
| CNamed | A mixin class to attach a name to an object |
| CNamedFloatTuple | An abstract tuple of float value where each value has an associated name |
| CNegativeFilter | Filter adapter type that negates the acceptance criterion for cross checks |
| CNLoopsColorMap | Segment to color map by the number of passed loops |
| CNoneFilter | Filter adapter type that rejects all items |
| CNot | Functor to get the logical negation from an arbitrary objects |
| CNotFilter | Filter adapter type that inverts the acceptance criterion for cross checks |
| CObserverFilter | Observer listening to the number of yes and no answers from the filter |
| COffOrigin | Takes a basic object and passively moves it to any origin All subordinary coordinates have to be interpreted relative to this origin |
| COffOriginExtension | Class performs extension (adding new hits) of given candidate using conformal transformation w.r.t point on the trajectory |
| COnVarSet | Filter adapter to make a filter work on a set of variables |
| CParameterLine2D | A line with a support point and tangential vector |
| CParameterVectorUtil | Structure to gather some utility functions for the ParameterVector |
| CPassThroughFilter | Filter adapter type that passes the weight of a weighted relation as a result |
| CPerigeeCircle | Extension of the generalized circle also caching the perigee coordinates |
| CPerigeeUtil | Utility struct for functions and types related to the perigee parameters |
| CPhi0BinsSpec | Strategy to construct discrete phi0 points from discrete overlap specifications |
| CPhiTrackRelationFilter | Relation filter that lets only possibilities with small phi distance pass |
| CPlainMatrix | A matrix implementation to be used as an interface typ through out the track finder |
| CPlainMatrixUtil | Utility functions for the PlainMatrix |
| CPosFlagColorMap | CDCHit to color map by their associated CDCSimHit::getPosFlag property |
| CPQBox | A rectangular domain for the hough space over p and q |
| CPrecisionMatrixUtil | Collection of functions related to precision matrices |
| CPrecisionUtil | Utility collection for functions to determine a curvature precision such at a hough box covers a certain percentage of hits in the legendre algorithms |
| CPrimitivePlotter | A base class for plots of primitive objects |
| CProcessingSignalListener | Interface for an algorithm part that needs to receive the module processing signals |
| CProduct | Template class for compile time computation of products |
| CProduct< factor, factors... > | Template class specialisation for compile time computation of products |
| CProduct<> | Template class specialisation for compile time computation of products |
| CPyEstimator | Class to invoke a pretrained python estimator that follows the sklearn interface |
| CQuadraticLegendre | Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type |
| CQuadTreeItem | This class serves as a wrapper around all things that should go into a QuadTree |
| CQuadTreeNode | Class which holds quadtree structure |
| CQuadTreeProcessor | This abstract class serves as a base class for all implementations of track processors |
| CRandomFilter | Random filter resulting in a random weight between 0 and 1 |
| CRange | A pair of iterators usable with the range base for loop |
| CRangeInBox | Predicate class to check for the containment of items in a rangeobject in a hough space part |
| CRealisticFacetFilter | Filter for the construction of good facets based on simple criteria |
| CReassignedSecondaryMap | CDCHit to color map indicating the reassignment to a different MCParticle |
| ►CReattachCDCWireHitsToRecoTracksModule | Module to loop over low-ADC/TOT CDCWireHits and fitted RecoTracks, and reattach the hits to the tracks if they are closer than a given distance |
| CHitToAddInfo | Internal structure to store the information about a hit to be added |
| CReconstructionResults | Internal structure to store the results of the reconstruction |
| ►CRecorder | Class to fill a tree from a set of variables |
| CImpl | Record the MVA variables |
| CRecording | Filter adapter to make a filter work on a set of variables and record the observed instances on invocation |
| CRecordingFilter | Convenience template to create a recording filter for a set of variables |
| CRecoTrackMatchingStatusColorMap | Color mapping showing the match status of the pattern recognition track |
| CRecoTrackUtil | Structure to summarize utility function to output a list of hits into a RecoTrack |
| CRelation | Type for two related objects |
| CRelationAdder | Class to add relations between the matched items |
| CRelationFilter | Base class for filtering the neighborhood of objects |
| CRelationFilterUtil | Name Structured creation of neighborhoods |
| CRelationVarSet | Generic class that generates the same variables from a each of a pair of instances |
| CRiemannsMethod | Class implementing the Riemann fit for two dimensional trajectory circle |
| CRLColorMap | CDCHit to color map by their local right left passage information from Monte Carlo truth |
| CRLTaggedWireHitCreator | Findlet for creating a list of RLWireHits (always bot hypothesis) from a list of WireHits using only the non-taken non-axial hits |
| CSameSignChecker | Small helper for checking the same sign of two, four or eight floats |
| CScalar | Class wrapping a scalar type (for which std::is_scalar is true) |
| CScalarToClassImpl | Helper type function to replace a T with Scalar<T> when std::is_scalar<T> |
| CScalarToClassImpl< T, true > | Specialisation for scalar types |
| CSectoredLinearDivision | Factory object that constructs sub boxes from a given box with optional overlaps |
| CSegmentAliasResolver | Resolves between the potential alias versions of the segments and contained hits |
| CSegmentCreatorFacetAutomaton | Findlet that generates segments within clusters based on a cellular automaton on triples of hits |
| CSegmentCreatorMCTruth | Findlet that generates segments from wire hits using the mc truth information |
| CSegmentFBInfoColorMap | Segment to color map based on the forward or backward alignment relative to the match Monte Carlo track |
| CSegmentFilterFactory | Factory that can create appropriate segment filters for new tracks from associated names |
| CSegmentFinderFacetAutomaton | Findlet implementing the segment finding part of the full track finder |
| CSegmentFirstInTrackIdColorMap | Segment to color map by the in track id of the first hit |
| CSegmentFirstNPassedSuperLayersColorMap | Segment to color map by the number of passed superlayers of the first hit |
| CSegmentFitter | Fits segments with the Riemann method |
| CSegmentInPhi0CurvBox | Predicate class to check for the containment of segments in a phi0 curv hough space part |
| CSegmentInZ0TanLambdaBox | Predicate class to check for the containment of hits in a z0 tan lambda hough space part |
| CSegmentLastInTrackIdColorMap | Segment to color map by the in track id of the last hit |
| CSegmentLastNPassedSuperLayersColorMap | Segment to color map by the number of passed superlayers of the last hit |
| CSegmentLinker | Links segments in the same super cluster by linking paths of segments in a cellular automaton |
| CSegmentMCTrackIdColorMap | Segment to color map based on the matched MCTrackId |
| CSegmentOrienter | Fixes the orientation of segments by a simple heuristic |
| CSegmentPairCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CSegmentPairFilterFactory | Factory that can create appropriate segment pair filters from associated names |
| CSegmentPairRelationFilterFactory | Factory that can create appropriate segment pair relation filters from associated names |
| CSegmentRejecter | Deletes fake segments that have been rejected by a filter |
| CSegmentRelationFilterFactory | Factory that can create appropriate segment relation filters from associated names |
| CSegmentTrackAdderWithNormalization | Add the matched segments to the tracks and normalize the tracks afterwards |
| CSegmentTrackCombiner | Findlet for the combination of tracks and segments |
| CSegmentTrackFilterFactory | Factory that can create appropriate segment to track combinations filters from associated names |
| CSegmentTrackTruthVarNames | Vehicle class to transport the variable names |
| CSegmentTrackTruthVarSet | Class to compute floating point variables from a segment to track match which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CSegmentTrackVarNames | Vehicle class to transport the variable names |
| CSegmentTrackVarSet | Class to compute floating point variables from a segment to track match which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CSegmentTripleCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CSegmentTripleFilterFactory | Factory that can create appropriate segment triple filters from associated names |
| CSegmentTripleRelationFilterFactory | Factory that can create appropriate segment triple relation filters from associated names |
| CSharingHitsMatcher | A generic matcher algorithm which outputs all combinations of elements with the number of shared hits as a weight |
| CSimHitIsBkgColorMap | CDCHit to color map by CDCSimHit::getBackgroundTag() |
| CSimHitPDGCodeColorMap | CDCHit to color map by the associated CDCSimHit::getPDG() |
| CSimpleAxialSegmentPairFilter | Filter for the construction of axial to axial segment pairs based on simple criteria |
| CSimpleBoxDivisionHoughTree | Convenience class for the typical usage-case: A box divisioned hough tree with maximum and minimum values in both directions |
| CSimpleBoxDivisionHoughTree3D | Convenience class for the typical usage-case: A box divisioned hough tree with maximum and minimum values in both directions |
| CSimpleFacetFilter | Filter for the construction of good facets based on simple criteria |
| CSimpleFacetRelationFilter | Class filtering the neighborhood of facets based on simple criterions |
| CSimpleHitBasedHoughTree | A convenience class based on a BoxDivisionHoughTree for "hit-like" classes |
| CSimpleSegmentPairFilter | Filter for the construction of axial to axial segment pairs based on simple criterions |
| CSimpleSegmentPairRelationFilter | Class filtering the neighborhood of axial stereo segment pairs based on simple criteria |
| CSimpleSegmentTripleFilter | Filter for the construction of segment triples based on simple criteria |
| CSimpleSegmentTripleRelationFilter | Class filtering the neighborhood of segment triples based on simple criterions |
| CSinEqLine | Helper class to calculate roots for the function f(x) = sin x - slope * x - intercept |
| CSingleMatchSelector | Selector to remove all relations in the list, which share the same collection item - except one in case the useOnlySingleBestCandidate is set to false (then, only the one with the heightest weight is used) |
| CSize | Functor to get the .size() from an arbitrary objects |
| CSkimmedHitGapSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CSloppy | A filter that accepts every "sloppinessFactor"th candidate on average (random selection) |
| CSortedRange | A pair of iterators usable with the range base for loop |
| CStereoHitContained | Predicate class to check for the containment of axial and stereo hits in some hough space part |
| CStereoHitFilterFactory | Factory that can create appropriate stereo hit to track combination filters from associated names |
| CStereoHitFinder | Complex findlet for finding stereo hits to a list of cdc tracks |
| CStereoHitTrackAdder | Class to add the matched hits to the track and set the taken flag correctly |
| CStereoHitTrackQuadTreeMatcher | A matcher algorithm for using a stereo quad tree for matching rl tagged wire hits to tracks |
| CStereoHitTruthVarNames | Vehicle class to transport the variable names |
| CStereoHitTruthVarSet | Class to compute floating point variables from a stereo hit to track match which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CStereoHitVarNames | Vehicle class to transport the variable names |
| CStereoHitVarSet | Class to compute floating point variables from a stereo hit to track match which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CStoreArrayLoader | Helper findlet to allow combined findlets to import data from the DataStore |
| CStoreVectorSwapper | Refines the clustering of wire hits from clusters to clusters |
| CStoreWrappedObjPtr | This class is for convenience access and registration of objects, that are stored inside the StoreWrapper on the DataStore |
| CStoreWrapper | This template functions as a wrapper for objects that do not inherit from TObject to be put on the DataStore |
| CStyling | Interface for a mapping of object and an index to styling attributes |
| CSuperClusterCreator | Refines the clustering of wire hits from clusters to clusters |
| CSVGPrimitivePlotter | A concrete plotter that can draw primitive objects to standalone SVG files |
| CSweepBoxImpl | Function to add a new dimension to a box It sweeps the original box over a finite range in the new dimension |
| CSweepBoxImpl< ANewType, ABox< AOldTypes... > > | Actual implementation pasting together the new dimension with the original box |
| CSZLine | A line in the sz space |
| CSZUtil | Utility struct for functions and types related to the sz plane parameters |
| CTakenFlagColorMap | CDCHit to color map highlighting the CDCHits that posses the do not use flag |
| CTFCDC_AxialSegmentPairCreatorModule | Module implementation using the AxialSegmentPairCreator |
| CTFCDC_AxialStraightTrackFinderModule | Module implementation using the AxialStraightTrackFinder |
| CTFCDC_AxialTrackCreatorMCTruthModule | Module implementation using the AxialTrackCreatorMCTruth |
| CTFCDC_AxialTrackCreatorSegmentHoughModule | Module implementation using the AxialTrackCreatorSegmentHough |
| CTFCDC_AxialTrackFinderHoughModule | Module implementation using the AxialTrackFinderHough |
| CTFCDC_AxialTrackFinderLegendreModule | CDC tracking module, using Legendre transformation of the drift time circles |
| CTFCDC_ClusterBackgroundDetectorModule | Module implementation using the ClusterBackgroundDetector |
| CTFCDC_ClusterPreparerModule | Module implementation using the ClusterPreparer |
| CTFCDC_ClusterRefinerModule | Module implementation using the ClusterRefiner |
| CTFCDC_FacetCreatorModule | Module implementation using the FacetCreator |
| CTFCDC_HitReclaimerModule | Module to reclaim CDC hits |
| CTFCDC_MonopoleAxialTrackFinderLegendreModule | Module implementation using the MonopoleAxialTrackFinderLegendre Modification of conventional AxialTrackFinderLegendre |
| CTFCDC_MonopoleStereoHitFinderModule | Tries to add CDC stereo hits to the found CDC tracks by applying a histogramming method with a 3D hough tree looking for hyperbolic cosines |
| CTFCDC_MonopoleStereoHitFinderQuadraticModule | Tries to add CDC stereo hits to the found CDC tracks by applying a histogramming method with a quad tree |
| CTFCDC_SegmentCreatorFacetAutomatonModule | Module implementation using the SegmentCreatorFacetAutomaton |
| CTFCDC_SegmentCreatorMCTruthModule | Module implementation using the SegmentCreatorMCTruth |
| CTFCDC_SegmentFinderFacetAutomatonModule | Module implementation using the SegmentFinderFacetAutomaton |
| CTFCDC_SegmentFitterModule | Module implementation using the SegmentFitter |
| CTFCDC_SegmentLinkerModule | Module implementation using the SegmentLinker |
| CTFCDC_SegmentOrienterModule | Module implementation using the SegmentOrienter |
| CTFCDC_SegmentPairCreatorModule | Module implementation using the SegmentPairCreator |
| CTFCDC_SegmentRejecterModule | Module implementation using the SegmentRejecter |
| CTFCDC_SegmentTrackCombinerModule | Module for the combination of tracks and segments |
| CTFCDC_SegmentTripleCreatorModule | Module implementation using the SegmentTripleCreator |
| CTFCDC_StereoHitFinderModule | Tries to add CDC stereo hits to the found CDC tracks by applying a histogramming method with a quad tree |
| CTFCDC_SuperClusterCreatorModule | Module implementation using the SuperClusterCreator |
| CTFCDC_TrackCombinerModule | Module implementation using the TrackCombiner |
| CTFCDC_TrackCreatorSegmentPairAutomatonModule | Module implementation using the TrackCreatorSegmentPairAutomaton |
| CTFCDC_TrackCreatorSegmentTripleAutomatonModule | Module implementation using the TrackCreatorSegmentTripleAutomaton |
| CTFCDC_TrackCreatorSingleSegmentsModule | Module implementation using the TrackCreatorSingleSegments |
| CTFCDC_TrackExporterModule | Module implementation using the TrackExporter |
| CTFCDC_TrackFinderAutomatonModule | Module for the cellular automaton tracking for the CDC on regular events |
| CTFCDC_TrackFinderCosmicsModule | Module for the cellular automaton tracking for the CDC on cosmic events |
| CTFCDC_TrackFinderModule | Module for the track finder combining global and local search |
| CTFCDC_TrackFinderSegmentPairAutomatonModule | Module implementation using the TrackFinderSegmentPairAutomaton |
| CTFCDC_TrackFinderSegmentTripleAutomatonModule | Module implementation using the TrackFinderSegmentTripleAutomaton |
| CTFCDC_TrackFlightTimeAdjusterModule | Module implementation using the TrackFlightTimeAdjuster |
| CTFCDC_TrackLinkerModule | Module implementation using the TrackLinker |
| CTFCDC_TrackOrienterModule | Module implementation using the TrackOrienter |
| CTFCDC_TrackQualityAsserterModule | Module implementation using the TrackQualityAsserter |
| CTFCDC_TrackQualityEstimatorModule | Module implementation using the TrackTrackQualityEstimator findlet |
| CTFCDC_TrackRejecterModule | Module implementation using the TrackRejecter |
| CTFCDC_WireHitBackgroundDetectorModule | Module counterpart to the WireHitBackgroundDetector findlet, which marks CDCWireHits as background based on the result of a filter |
| CTFCDC_WireHitCreatorModule | Module implementation using the WireHitCreator |
| CTFCDC_WireHitPreparerModule | Module to set up the cdcwire hits used in all CDC track finding algorithms (except Trasan) |
| CTimeItResult | Class to capture the time a repeated execution took |
| CTMatrixConversion | Convert between TMatrix and CovarianceMatrix representations |
| CTOFColorMap | CDCHit to color map by their associated CDCSimHit::getFlightTime |
| CTrackCombiner | Combines two sets of tracks to one final set by merging tracks that have large overlaps |
| CTrackCreatorSegmentPairAutomaton | Findlet that generates tracks based on a cellular automaton of segment pairs |
| CTrackCreatorSegmentTripleAutomaton | Findlet that generates tracks based on a cellular automaton of segment triples |
| CTrackCreatorSingleSegments | Searches for segments that have not been used at all and creates tracks from them |
| CTrackExporter | Findlet to exports CDCTracks as RecoTracks |
| CTrackFilterFactory | Factory that can create appropriate track filters from associated names |
| CTrackFinder | Complete findlet implementing track finding with the cellular automaton in two stages |
| CTrackFinderAutomaton | Complete findlet implementing track finding with the cellular automaton in two stages |
| CTrackFinderCosmics | Complete findlet implementing track finding with the cellular automaton in two stages - version suitable for cosmics |
| CTrackFinderSegmentPairAutomaton | Findlet implementing the track finding from segments using a cellular automaton over segment pairs |
| CTrackFinderSegmentTripleAutomaton | Findlet implementing the track finding from segments using a cellular automaton over segment triples |
| CTrackFindingCDCTestWithSimpleSimulation | Equivalent to |
| CTrackFindingCDCTestWithTopology | This class provides the declaration of the common test fixture to all test of the track finding in the CDC code |
| CTrackFlightTimeAdjuster | Findlet to adjust the flight time of tracks relative to the flight time zero |
| CTrackInspector | Findlet for inspecting and printing out CDCtracks on a R-z plane for debug purposes |
| CTrackLinker | Links tracks based on a filter criterion |
| CTrackNormalizer | Findlet for normalizing the track (trajectory) into common requirements (e.g. let it start at the first hit etc.) |
| CTrackOrienter | Fixes the orientation of tracks by a simple heuristic |
| CTrackQualityAsserter | This module applies configurable correction functions to all found tracks |
| CTrackQualityEstimator | Deletes fake tracks that have been rejected by a filter |
| CTrackQualityFilterFactory | Derived class of TrackFilterFactory with a truth target that also discards clones Probably this whole class could be removed if TrackFilterFactory would be templated with the type of the TruthVarSet as a template argument |
| CTrackQualityTools | Tools to apply post corrections to a track after finding |
| CTrackRejecter | Deletes fake tracks that have been rejected by a filter |
| CTrackRelationFilterFactory | Factory that can create appropriate track relation filters from associated names |
| CTrackSZFitter | Findlet for fitting a list of tracks in the SZ direction and replace their trajectory 3D |
| CTrailSegmentPairVarNames | Vehicle class to transport the variable names |
| CTrailSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTreeTraversal | General implementation of a tree search algorithm using a given classes as state and results and one strategy class to decide, which child states should be traversed next |
| CTruthAxialSegmentPairVarNames | Vehicle class to transport the variable names |
| CTruthAxialSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTruthSegmentPairRelationVarNames | Vehicle class to transport the variable names |
| CTruthSegmentPairRelationVarSet | Class to compute floating point variables from an axial stereo segment pair relation which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTruthSegmentPairVarNames | Vehicle class to transport the variable names |
| CTruthSegmentPairVarSet | Class to compute floating point variables from an axial stereo segment pair which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTruthSegmentVarNames | Vehicle class to transport the variable names |
| CTruthSegmentVarSet | Class to compute floating point variables from a segment which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTruthTrackVarNames | Vehicle class to transport the variable names |
| CTruthTrackVarSet | Class to compute floating point variables from a track which can be recorded as a flat TNtuple or serve as input to a MVA method |
| CTruthVarFilter | MC Filter Type using a VarSet and the truth variable in it |
| CTupleGenerateImpl | Apply the template function F to each element of the index sequence |
| CTupleGenerateImpl< AGenerator, std::index_sequence< Is... > > | Specialisation for concrete indices |
| CTwoHitInBoxAlgorithm | Predicate class to check for the containment of items in a hough space part with two algorithms |
| CUncertainHelix | A general helix class including a covariance matrix |
| CUncertainParameterLine2D | A parameter line including including an line covariance matrix which is interpreted as located in the support point |
| CUncertainParametersUtil | Utility struct to instantiate a couple of helper function related to a set of uncertain parameters |
| CUncertainPerigeeCircle | Adds an uncertainty matrix to the circle in perigee parameterisation |
| CUncertainSZLine | A line in sz where s is the transverse travel distance as seen in the xy projection with uncertainties in the slope and intercept of the line |
| CUnionRecording | A filter that records variables form given objects |
| CUnionRecordingAxialSegmentPairFilter | Filter to record multiple chooseable variable sets for axial segment pairs |
| CUnionRecordingClusterFilter | Filter to record multiple chooseable variable sets for wire hit clusters |
| CUnionRecordingFacetFilter | Filter to record multiple chooseable variable sets for facets |
| CUnionRecordingFacetRelationFilter | Filter to record multiple chooseable variable sets for facet relations |
| CUnionRecordingFilter | Convenience template to create a recording filter for a filter factory |
| CUnionRecordingSegmentPairFilter | Filter to record multiple chooseable variable sets for segment pairs |
| CUnionRecordingSegmentPairRelationFilter | Filter to record multiple chooseable variable sets for segment pair relations |
| CUnionRecordingSegmentRelationFilter | Filter to record multiple chooseable variable sets for segment relations |
| CUnionRecordingTrackRelationFilter | Filter to record multiple chooseable variable sets for track relations |
| CUnionVarSet | Class that accommodates many variable sets and presents them as on set of variables |
| CUnmarkable | Mixin class to attach a mark that is shared among many instances |
| CVariadicUnionVarSet | Class that accommodates many variable sets and presents them as on set of variables |
| CVarNames | Class that specifies the names of the variables |
| ►CVarSet | Generic class that generates some named float values from a given object |
| CAssignFinite | Helper construct to assign a finite value to float variables |
| CVector2D | A two dimensional vector which is equipped with functions for correct handling of orientation related issues in addition to the expected vector methods |
| CVector3D | A three dimensional vector |
| CVoid | Functor returning void from an arbitrary objects |
| CWeightedFastHoughTree | Dynamic tree structure with weighted items in each node which are markable through out the tree |
| CWeightedParititioningDynTree | Type of tree for partitioning the hough space |
| CWeightedRelation | Type for two related objects with a weight |
| CWeightedRelationCreator | Findlet that combines geometrical constrained pairs of objects to relations and selects them by the filter given as template parameter |
| CWeightedRelationUtil | Utility structure with functions related to weighted relations |
| CWeightedTreeTraversal | General implementation of a tree search algorithm using a given classes as state and results and one strategy class to decide, which child states should be traversed next |
| CWholeWireHitRelationFilter | Class mapping the neighborhood of wires to the neighborhood of wire hits |
| CWireHitBackgroundBlocker | Marks hits as background based on simple heuristics |
| CWireHitBackgroundDetector | Marks hits as background based on the result of a filter |
| CWireHitCreator | Combines the geometrical information and the raw hit information into wire hits, which can be used from all modules after that |
| CWireHitFilterFactory | Factory that can create appropriate wireHit filters from associated names |
| CWireHitMCMultiLoopBlocker | Marks all hits that are not on the first loop of the track as background |
| CWireHitPreparer | Findlet preparing the wire hits for the track finding |
| CWireLine | A three dimensional limited line represented by its closest approach to the z-axes (reference position ) and its skew parameter |
| CWireNeighborKind | Type for the neighbor relationship from one wire to another |
| CWireNeighborPair | Class representing a pair of neighbors in the CDC in a single layer For certain circumstances it is allowed that both wires point to nullptr, e.g |
| CWithAutomatonCell | Mixin class to attach an automaton cell to an object or pointer |
| CWithSharedMark | Mixin class to attach a mark that is shared among many instances |
| CWithWeight | A mixin class to attach a weight to an object |
| CWithWeightedItems | A mixin class to attach a set of weighted items to a class |
| CZ0TanLambdaBox | A rectangular domain for the hough space over phi0 and two dimensional curvature |
| CZ0TanLambdaLegendre | Hough Tree for finding StereoHits using a templated class as the item type |
| CZeroDriftLengthColorMap | CDCHit to color map highlighting the CDCHits with 0 drift length |
| CZeroDriftLengthStrokeWidthMap | CDCHit to stroke width map highlighting the CDCHits with 0 drift length |
| ►NTracking | |
| CTrackFinderVXDAnalizerModule | The TrackFinderVXDAnalizerModule |
| ►NTRGCDCETFUNPACKERSPACE | |
| CTRGCDCETFUnpackerModule | A module of TRGCDCETFUnpacker |
| ►NTRGCDCT3DCONVERTERSPACE | |
| CTRGCDCT3DConverterModule | A module of TRGCDCT3DConverter |
| ►NTRGCDCT3DUNPACKERSPACE | |
| CTRGCDCT3DUnpackerModule | A module of TRGCDCT3DUnpacker |
| ►NTRGCDCTSF | |
| CTRGCDCTSFUnpackerModule | A module of TRGCDCTSF Unpacker |
| ►NTRGGRLUNPACKERSPACE | |
| CTRGGRLUnpackerModule | A module of TRGGRLUnpacker |
| ►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 |
| ►NVariablePersistenceManager | |
| CBinnedVariable | A variable with binning information |
| CConcreteVariablesToHistogramPersistenceManager | A PersistenceManager that writes variables to ROOT histograms (TH1D) |
| CConcreteVariablesToNtuplePersistenceManager | A PersistenceManager that writes variables to a ROOT TTree |
| CPersistenceManager | Abstract base class defining the interface for persisting variables |
| CPersistenceManagerFactory | A factory class that creates specific PersistenceManager objects |
| CTypedVariable | A variable with a specified data type |
| CVariable | Base class representing a generic variable |
| ►NVXD | Namespace to provide code needed by both Vertex Detectors, PXD and SVD, and also testbeam telescopes |
| CGeoCache | Class to facilitate easy access to sensor information of the VXD like coordinate transformations or pitch size |
| CGeoHeavyMetalShieldCreator | The creator for the HeavyMetalShield geometry of the Belle II detector |
| CGeoTools | The class collects utility functions for numbering layers, sensors snd chips based on current VXD geometry |
| CGeoVXDAssembly | Class to group some Geant4 volumes and place them all at once with a given transformation matrix |
| CGeoVXDCreator | The creator for the VXD geometry of the Belle II detector |
| CGeoVXDServiceCreator | The creator for the VXD Service geometry of the Belle II detector |
| CMisalignmentCache | Class to hold misalignment information |
| CSensitiveDetector | Sensitive Detector implementation of PXD and SVD |
| CSensitiveDetectorBase | Base class for Sensitive Detector implementation of PXD and SVD |
| ►CSensitiveDetectorDebugHelper | Small helper class to facilitate debugging of VXD::SensitiveDetector implementation |
| Cinfo | Struct with all the branches needed |
| CSensorInfoBase | Base class to provide Sensor Information for PXD and SVD |
| CSensorPlane | A Finite plane of one VXD Sensor |
| CVXDMisalignmentModule | The VXD misalignment module |
| ►NvxdHoughTracking | |
| CAngleAndTimeRelationFilter | Filter for relations based on the polar angle difference and the time difference of the hits |
| CFiveHitFilter | Basic working principle: use ThreeHitVariables and provide three B2Vector3D to each variable |
| CFourHitFilter | Filter for four hits |
| CFourHitVariables | Class that allows the calculation of simple variables to estimate the quality of two triplets of hits using four hits |
| CHitSelector | Select hits to be analysed in the Hough Space intercept finder for a given layer 6 sensor based on the simple sensor friend map |
| CLayerRelationFilter | Relation filter the creation of relations |
| CLimitedOnHitApplier | Specialisation of the OnHitApplier, which (a) uses a filter for the () operator, which is configurable (b) does only allow for the best N candidates in the child hits |
| ►CMultiHoughSpaceFastInterceptFinder | Findlet for finding intersections of sinusoidal curves in the 2D Hough space by iteratively calling FastInterceptFinder2d |
| Cpaircompare | This sorting makes sure the clusters can be searched from bottom left of the HS to top right normally, a C++ array looks like a matrix: (0, 0 ) ... (maxX, 0 ) ... ... (0, maxY) ... (maxX, maxY) but for sorting we want it to be like regular coordinates (0, maxY) ... (maxX, maxY) ... ... (0, 0 ) ... (maxX, 0 ) By setting the offset to the maximum allowed number of cells (2^14) and simplifying (16384 - lhs.second) * 16384 + lhs.first < (16384 - rhs.second) * 16384 + rhs.first to (rhs.second - lhs.second) * 16384 < rhs.first - lhs.first we get the formula below |
| COnHitApplier | Helper findlet which applies its () operator to all pairs of path and hit with all hits in the given child hit list |
| CPathFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CPathLengthToggledApplier | A special findlet, which chooses the filter based on the current path length |
| CQualityIndicatorFilter | Filter for >= 3 hits using QualityEstimators |
| CRawTrackCandCleaner | Findlet for rejecting wrong SpacePointTrackCands and for removing bad hits |
| CRecoTrackStorer | Store RecoTracks into StoreArray |
| CRelationCreator | Findlet for applying filters for creating hit-hit relations in each track candidate |
| CRelationFilterFactory | Factory that can create appropriate filters for relations between hits from associated names |
| CROIFinder | Findlet for performing the simple SVDHoughTracking ROI calculation |
| CSimpleRelationFilter | Filter for relations based on the polar angle difference |
| ►CSingleHoughSpaceFastInterceptFinder | Findlet for finding intersections of sinusoidal curves in the 2D Hough space by iteratively calling FastInterceptFinder2d |
| Cpaircompare | This sorting makes sure the clusters can be searched from bottom left of the HS to top right normally, a C++ array looks like a matrix: (0, 0 ) ... (maxX, 0 ) ... ... (0, maxY) ... (maxX, maxY) but for sorting we want it to be like regular coordinates (0, maxY) ... (maxX, maxY) ... ... (0, 0 ) ... (maxX, 0 ) By setting the offset to the maximum allowed number of cells (2^14) and simplifying (16384 - lhs.second) * 16384 + lhs.first < (16384 - rhs.second) * 16384 + rhs.first to (rhs.second - lhs.second) * 16384 < rhs.first - lhs.first we get the formula below |
| CSpacePointLoaderAndPreparer | Findlet for loading SVDSpacePoints and prepare them for usage in the FastInterceptFinder2D by creating VXDHoughStates in which the BeamSpotPosition is used to calculate the conformal transformed x,y coordinates and the creating pairs of coordinates for finding track candidates in r-phi and r-z |
| CSVDHoughTracking | Main Findlet for the SVDHoughTracking |
| CSVDHoughTrackingTreeSearcher | Findlet for constructing result paths out of a list of hits, which are connected with weighted relations |
| CThreeHitFilter | Filter for three hits |
| CThreeHitVariables | Class that allows the calculation of simple variables to estimate the quality of a triplet of hits |
| CTrackCandidateOverlapResolver | Findlet for rejecting wrong SpacePointTrackCands and for removing bad hits |
| CTrackCandidateResultRefiner | Findlet for rejecting wrong SpacePointTrackCands and for removing bad hits |
| CTrackletFilterFactory | Factory that can create filters for tracklets = SpacePointTrackCands from associated names |
| CTwoHitVariables | Class that allows the calculation of simple variables to check whether a combination of two hits should be used or discarded in tracking |
| CTwoHitVirtualIPFilter | Filter for two hits plus a virtual IP |
| CTwoHitVirtualIPQIFilter | Filter for two hits plus a virtual IP using QualityEstimators |
| ►CVXDHoughState | Simple container for hit information to be used during intercept finding |
| CDataCache | Cache containing the most important information of this state which will often be needed |
| CAafhInputModule | AAFH Generator to generate 2-fermion events like e+e- -> e+e-e+e- |
| CAAFHInterface | Class to interface AAFH/DIAG36 Generator written in Fortran |
| CAbstractBooleanNode | A parsed cut-string naturally has a tree shape which incorporates the information of operator precedence and evaluation order of the statements |
| CAbstractDBObject | |
| CAbstractExpressionNode | AbstractExpressionNode Superclass for all nodes which host expressions |
| CAbstractNSMCallback | |
| CActivatedSector | ActivatedSector is carrying the dynamic part of a Sector |
| CActiveSector | The ActiveSector Class |
| Cadc_search | Functions to search in the sorted list of tuples |
| CadcAsicTuple | Tuple to store ADC,Channel -> 8 asicChannels |
| CadcChannelPair | Pair ADC, channel |
| CAdditionalMeasurementCreatorFactory | Add measurement creators that do not rely on a specific hit type, but rather add measurements without corresponding hit |
| CAddVXDTrackCandidateSubSetsModule | Module that creates additional candidates that each miss a different SpacePoint |
| CAdvanceFilter | Filter which can be used on a pair of path (vector of states) and states, which will call the extrapolate function of the given advancer class, to extrapolate the last path state to the plane of the new state and store the mSoP in the new state |
| CAdvancer | Helper findlet for performing an extrapolation of a mSoP of one plane to another plane using the representation stored in the mSoP |
| CAlgoritmType | Small class for classifying types of analyzing algorithms |
| CAlignableBKLMRecoHit | Alignable BKLM hit |
| CAlignableCDCRecoHit | This class is used to transfer CDC information to the track fit and Millepede |
| CAlignableEKLMRecoHit | Alignable EKLM hit |
| CAlignablePXDRecoHit | This class is used to transfer PXD information to the track fit |
| CAlignableSVDRecoHit | This class is used to transfer SVD information to the track fit |
| CAlignableSVDRecoHit2D | This class is used to transfer SVD information to the track fit |
| CAlignDQMEventProcessor | The purpose of this class is to process one event() in AlignDQMModule |
| CAlignDQMModule | DQM of Alignment for off line residuals per sensor, layer, keep also On-Line DQM from tracking: their momentum, Number of hits in tracks, Number of tracks |
| CAlignmentGeneratorModule | Generate VXD misalignment and store in database |
| Call_same | The all_same struct is meant to check that all the types in a template pack are of the same type |
| Call_same< > | The all_same struct is meant to check that all the types in a template pack are of the same type |
| Call_same< T > | The all_same struct is meant to check that all the types in a template pack are of the same type |
| Call_same< T, T, types ... > | The all_same struct is meant to check that all the types in a template pack are of the same type |
| CAllParticleCombinerModule | This module combines all particles of the provided list to one mother particle |
| CAllPXDStateFilter | A very simple filter for all space points |
| CAllSVDStateFilter | A very simple filter for all space points |
| CAlwaysYesFilter | AlwaysYesFilter is a simple filter saying always yes, which is meant for testing purposes |
| CAnalizerTCInfo | Simple class storing infos relevant for a TC for analyzing it |
| CAnalysisConfiguration | Singleton class keeping configurables of analysis components |
| CAnalysisConfigurationModule | Class to hold general basf2 configuration Used to initiate and configure CreateAnalysis object |
| CAnalysisPhase1StudyModule | Study module for BEAST |
| ►CAnalyzingAlgorithmBase | Base class for storing an algorithm determining the data one wants to have |
| CTcPair | Minimal struct for keeping track which tc is which |
| CAnalyzingAlgorithmLostUClusters | Class for storing an algorithm to find out how many u-type-clusters the testTC lost compared to the refTC |
| CAnalyzingAlgorithmLostUEDep | Class for storing an algorithm to find out the energy deposit of u-type-clusters the testTC lost compared to the refTC |
| CAnalyzingAlgorithmLostVClusters | Class for storing an algorithm to find out how many v-type-clusters the testTC lost compared to the refTC |
| CAnalyzingAlgorithmLostVEDep | Class for storing an algorithm to find out the energy deposit of v-type-clusters the testTC lost compared to the refTC |
| CAnalyzingAlgorithmResidualP | Class for storing an algorithm determining the residual (ref-test) of momentum in |p| |
| CAnalyzingAlgorithmResidualPAngle | Class for storing an algorithm determining the residual (ref-test) of momentum in its angle (direction residual in degrees) |
| CAnalyzingAlgorithmResidualPosition | Class for storing an algorithm determining the residual (ref-test) of the seed position in 3D |
| CAnalyzingAlgorithmResidualPositionXY | Class for storing an algorithm determining the residual (ref-test) of the seed position in XY (=r) |
| CAnalyzingAlgorithmResidualPPhi | Class for storing an algorithm determining the residual (ref-test) of momentum in phi (in degrees) |
| CAnalyzingAlgorithmResidualPT | Class for storing an algorithm determining the residual (ref-test) of momentum in pT |
| CAnalyzingAlgorithmResidualPTAngle | Class for storing an algorithm determining the residual (ref-test) of pT in angle (transverse direction residual in degrees) |
| CAnalyzingAlgorithmResidualPTheta | Class for storing an algorithm determining the residual (ref-test) of momentum in theta (in degrees) |
| CAnalyzingAlgorithmResidualPX | INFO This file contains all the algorithms calculating residuals of something |
| CAnalyzingAlgorithmResidualPY | Class for storing an algorithm determining the residual (ref-test) of momentum in Y |
| CAnalyzingAlgorithmResidualPZ | Class for storing an algorithm determining the residual (ref-test) of momentum in Z |
| CAnalyzingAlgorithmTotalUClusters | Class for storing an algorithm to find out how many u-type-clusters the given TC had |
| CAnalyzingAlgorithmTotalUEDep | Class for storing an algorithm to find out the energy deposit of u-type-clusters the given TC had |
| CAnalyzingAlgorithmTotalVClusters | Class for storing an algorithm to find out how many v-type-clusters the given TC had |
| CAnalyzingAlgorithmTotalVEDep | Class for storing an algorithm to find out the energy deposit of v-type-clusters the given TC had |
| CAnalyzingAlgorithmValueDistSeed2IP | Class for storing an algorithm determining the the distance seedHit to IP in 3D |
| CAnalyzingAlgorithmValueDistSeed2IPXY | Class for storing an algorithm determining the distance seedHit to IP in XY (=r) |
| CAnalyzingAlgorithmValueDistSeed2IPZ | Class for storing an algorithm determining the distance seedHit to IP in XY (=r) |
| CAnalyzingAlgorithmValueP | Class for storing an algorithm determining the momentum in |p| |
| CAnalyzingAlgorithmValuePPhi | Class for storing an algorithm determining the momentum in phi (in degrees) |
| CAnalyzingAlgorithmValuePT | Class for storing an algorithm determining the momentum in pT |
| CAnalyzingAlgorithmValuePTheta | Class for storing an algorithm determining the momentum in theta (in degrees) |
| CAnalyzingAlgorithmValuePX | INFO This file contains all the algorithms calculating a certain value of something |
| CAnalyzingAlgorithmValuePY | Class for storing an algorithm determining the momentum in Y |
| CAnalyzingAlgorithmValuePZ | Class for storing an algorithm determining the momentum in Z |
| CAnalyzingAlgorithmValueQI | Class for storing an algorithm determining the quality indicator of the TC |
| CANGLE3DFULL_NAME | Calculates the angle between the hits/vectors (3D), returning unit: angle in degrees |
| CANGLE3DSIMPLE_NAME | Calculates the angle between the hits/vectors (3D), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use Angle3DFull instead) |
| CANGLERZFULL_NAME | Calculates the angle between the hits/vectors (RZ), returning unit: angle in degrees |
| CANGLERZSIMPLE_NAME | Calculates the angle between the hits/vectors (RZ), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use AngleRZFull instead) |
| CANGLEXYFULL_NAME | Calculates the angle between the hits/vectors (XY), returning unit: angle in degrees |
| CAngularDistancePXDPairFilter | Base filter for CKF PXD states |
| CArcLengthBasedCDCfromEclPathPairFilter | For the two paths with the same number of hits prefers one with shortest arcLength ("densest path") |
| CArcLengthBasedCDCPathPairFilter | For the two paths with the same number of hits prefers one with shortest arcLength ("densest path") |
| CARICHAerogelHist | Base class for geometry parameters |
| CARICHAerogelInfo | The Class for ARICH Aerogel Parameters |
| CARICHAerogelMap | Map of the Aerogel placement |
| CARICHAerogelRayleighScatteringFit | The Class for ARICH aerogel Rayleigh scattering fit parameters |
| CARICHAeroHit | Datastore class that holds information on track parameters at the entrance in aerogel |
| CARICHAeroTilesAlignment | Alignment parameters for aerogel tiles |
| CARICHAeroTilesInfo | The Class for ARICH aerogel tiles properties for even reconstruction |
| CARICHAsicChannelMask | ARICH Channel Mask |
| CARICHAsicInfo | Tested ASIC chips |
| CARICHB2LinkInfo | List of Belle2Link boards |
| CARICHBadChannels | ARICH bad channels |
| CARICHBiasCablesMapping | The Class for ARICH mapping of bias cables to modules |
| CARICHBiasChannelsMapping | This class provides ARICH mapping of HAPD modules to bias power supply channels |
| CARICHBiasCrateCableMapping | This class provides ARICH bias voltages at gain 40 |
| CARICHBiasVoltages | The Class for ARICH bias voltages at gain 40 |
| CARICHBtestGeometryPar | The Class for ARICH Beamtest Geometry Parameters |
| CarichBtestModule | The UserTutorial module |
| CARICHCableInfo | List of cables |
| CARICHCalibrationChecker | ARICH calibration checker |
| CARICHChannelHist | ARICH histogram with HAPD plane 3 options for bin segmentation are available type 0 - one bin per HAPD, type 1 - one bin per channel, type 2 - one bin per APD chip HAPD numbering is 1-420 (software numbering), channel is ASIC channel, APD is ASIC channel / 36 |
| CARICHChannelMapping | The Class for ARICH HAPD channel mapping |
| CARICHChannelMask | The Class for ARICH HAPD channel mask |
| CARICHChannelMaskMaker | ARICH channel mask calibration algorithm |
| CARICHChannelMaskModule | ARICH channel-mask calibration: data collector |
| CARICHComponentTest | Test of the ARICH component |
| CARICHCopperMapping | The Class for ARICH mapping of merger to copper boards |
| CARICHDatabaseImporter | ARICH database importer |
| CARICHDigit | ARICHDigit class for storing photon hit information |
| CARICHDigitizerModule | ARICH digitizer module |
| CARICHDQMModule | Make summary of data quality from reconstruction |
| CARICHFEBoardInfo | Front End Electronics Boards |
| CARICHFebTest | ARICH FEB test data |
| CARICHFillHitsModule | Fill ARICHHit collection from ARICHDigits |
| CARICHFirmware | ARICH firmware |
| ►CARICHGeoAerogelPlane | Geometry parameters of HAPD |
| Clayer | Struct to hold aerogel layer parameters |
| Ctilestr | Struct to hold individual aerogel tile parameters |
| CARICHGeoBase | Base class for geometry parameters |
| CARICHGeoCablesEnvelope | Geometry parameters of cable envelope |
| CARICHGeoCooling | Geometry parameters of cooling system |
| CARICHGeoDetectorPlane | Geometry parameters of ARICH photon detector plane |
| CARICHGeoFEBCooling | Geometry parameters of Cooling System - version2 (v2) |
| CARICHGeoGlobalDisplacement | Global displacement parameters for ARICH |
| CARICHGeoHAPD | Geometry parameters of HAPD |
| CARICHGeoMasterVolume | Geometry parameters of ARICH Master volume (envelope) |
| CARICHGeoMerger | Geometry parameters of Merger PCB |
| CARICHGeoMergerCooling | Geometry parameters of Merger Cooling System - version2 (v2) |
| CARICHGeometryConfig | The Class for ARICH Geometry Parameters |
| CARICHGeometryPar | The Class for ARICH Geometry Parameters |
| CARICHGeoMirrorDisplacement | Mirror displacement parameters for ARICH |
| CARICHGeoMirrors | Geometry parameters of HAPD |
| ►CARICHGeoSupport | Geometry parameters of ARICH support structures and neutron shield |
| Cbox | Struct to hold parameters of box volumes (examples, scintilators for cosmic test) |
| Ctube | Struct to hold tube parameters |
| Cwedge | Struct to hold wedge parameters |
| CARICHGlobalAlignment | Geometry parameters of ARICH Master volume (envelope) |
| CARICHHapdChipInfo | Contains manufacturer data of one of the 4 photo sensors chips |
| CARICHHapdInfo | Contains manufacturer data of the photo sensor - HAPD |
| CARICHHapdMask | ARICH HAPD Sensor Mask: map of operational/nonoperational HAPDs : one bit per sensor |
| CARICHHapdQA | Contains manufacturer data of the photo sensor - HAPD |
| CARICHHapdQE | Contains manufacturer data of the photo sensor - HAPD |
| CARICHHighVoltageConfig | Configuration parameters of the High Voltage Channel |
| CARICHHit | Datastore class that holds photon hits. Input to the reconstruction |
| CARICHHvCablesMapping | The Class for ARICH mapping of bias cables to modules |
| CARICHHvChannelsMapping | The Class for ARICH mapping of bias power supply channels to modules |
| CARICHHvCrateCableMapping | The Class for ARICH bias voltages at gain 40 |
| CARICHInfo | Datastore class to keep ARICH event information e.g. trigger type |
| CARICHLikelihood | This is a class to store ARICH likelihoods in the datastore |
| CARICHMagnetTest | Contains fractions of dead times measured in a magnet |
| CARICHMCParticlesModule | Module to match ARICH hits to MCParticles |
| CARICHMergerInfo | List of MergerBoards |
| CARICHMergerMap | Mapping of the merger board to the detector |
| CARICHMergerMapping | The Class for ARICH mapping of modules to merger boards |
| CARICHMirrorAlignment | Mirror alignment parameters for ARICH |
| CARICHMirrorInfo | List of MergerBoards |
| CARICHMirrorMap | Mapping of the mirrors on the detector |
| CARICHModulesInfo | The Class for information on HAPD modules installed in ARICH |
| CARICHModuleTest | ARICH module test data |
| CARICHNtupleModule | ARICH reconstruction efficiency test module |
| CARICHPackerModule | Raw data packer for ARICH |
| CARICHPhoton | Struct for ARICH reconstructed photon (hit related to track) information |
| CARICHPositionElement | Position element for ARICH |
| CARICHRateCalModule | Fill ARICHHit collection from ARICHDigits |
| ►CARICHRawDigit | Class of ARICH raw digits |
| ►CFEBDigit | Struct for front-end board |
| CChannelDigit | Struct for ChannelDigit within FEBDigit struct |
| CARICHRawHeader | ARICH raw-data header |
| CARICHRawUnpackerModule | Fill ARICHHit collection from ARICHDigits |
| CARICHReconstruction | Internal ARICH track reconstruction |
| CARICHReconstructionPar | The Class for ARICH reconstruction parameters |
| CARICHReconstructorModule | ARICH subdetector main module |
| CARICHRelateModule | Creates relations between ARICHAeroHits and ExtHits |
| CARICHSensorModuleInfo | Sensor-module information |
| CARICHSensorModuleMap | Mapping of the sensor-board connections to the detector |
| CARICHSimHit | Class ARICHSimHit - Geant4 simulated hit for ARICH |
| CARICHSimulationPar | The Class for ARICH simulation parameters |
| CARICHThParam | ARICHThParam class for storing photon hit information |
| CarichToNtupleModule | This module extends existing variablesToNtuple to append detailed arich information to candidates in the analysis output ntuple |
| CARICHTrack | Datastore class that holds position and momentum information of tracks that hit ARICH |
| CARICHTracking | Beamtest ARICH Geometry Tracking Class |
| CARICHUnpackerModule | Raw data unpacker for ARICH |
| CArrayIterator | Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc |
| CasicChannel | Record to be used to store ASIC info |
| CAsyncDisplayModule | Wraps DisplayModule and starts it in a forked process |
| CAsyncWrapper | Wraps a given Module to execute it asynchronously |
| CAtom | Very small (few mins) calibration interval which cannot be further divided : Atom |
| 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 |
| CBabayagaNLO | C++ Interface for the Fortran Bhabha and exclusive two photon generator BABAYAGA.NLO |
| CBabayagaNLOInputModule | The Babayaga.NLO Generator module |
| ►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 |
| CBaseEventTimeExtractor | Class to extract the event t0 |
| CBaseEventTimeExtractorModuleFindlet | Base class for most of the time extraction modules doing a track selection beforehand |
| CBaseMeasurementCreator | Base class for all measurement creators |
| CBaseMeasurementCreatorFromCoordinateMeasurement | Baseclass to create measurement track points based on the coordinate measurements |
| CBaseMeasurementCreatorFromHit | Base Class to create measurements based on a given hit related to the RecoTrack |
| CBaseRecoFitterModule | A base class for all modules that implement a fitter for reco tracks |
| CBaseTrackTimeEstimatorModule | Base Module estimating the track time of RecoTracks - before or after the fit |
| CBBBrem | Generator for low scattering angle radiative Bhabha events (Beam-Beam Bremsstrahlung) |
| CBBBremInputModule | The BBBrem Generator module |
| CBeamabortGeo | Geometry parameters of Beamabort |
| CBeamabortHit | ClassBeamabortHit - digitization simulated hit for the Beamabort detector |
| CBeamabortSimHit | ClassBeamabortSimHit - Geant4 simulated hit for the Beamabort crystal in beast |
| CBeamBackHit | Class BeamBackHit - Stores hits from beam background simulation |
| ►CBeamBkgGeneratorModule | Beam background generator based on SAD files |
| CSADTree | Structure of the TTree in the SAD file |
| CBeamBkgHitRateMonitorModule | A module to monitor detector hit rates of beam background Output is to a flat ntuple |
| ►CBeamBkgMixerModule | New beam background mixer; this one doesn't need ROF files |
| CBkgFiles | Structure to hold samples of a particular background type |
| CBkgHits | An input event buffer definition for background SimHits |
| CBeamBkgTagSetterModule | A module that sets m_backgroundTag variable in SimHits (see BackgroundMetaData.h) |
| 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 |
| CBeamParametersFitter | Fitter calculating BeamParameters from CollisionBoostVector and CollisionInvariantMass |
| CBeamParametersModule | Setting of beam parameters |
| CBeamPipeGeo | Geometry parameters of BeamPipe |
| CBeamSpot | This class contains the beam spot position and size modeled as a gaussian distribution in space |
| CBeamSpotAlgorithm | Class implementing BeamSpot calibration algorithm |
| CBeamSpotCollectorModule | This collects the track parameters of the mu+mu- events for calibration of the BeamSpot using CAF and AirFlow |
| CBeamSpotMonitorModule | Module for the monitoring of the BeamSpot position and size |
| 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 |
| CBestMatchContainer | Multiple entries can be added, but only the one will be kept, which has the best quality estimator |
| CBestVXDFamilyCandidateSelectorModule | Module that selects the best candidate for each SPTC family |
| CBestVXDTrackCandidatesSelectorModule | Module that selects a subset with a fixed size x out of all SpacePointTrackCandidates |
| 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 |
| CBgoHit | ClassBgoHit - Geant4 ulated hit for the Bgo crystal in beast |
| CBgoSimHit | ClassBgoSimHit - Geant4 simulated hit for the Bgo crystal in beast |
| CBGOverlayExecutorModule | Overlay of measured background with simulated data (Digits or Clusters) |
| CBGOverlayInputModule | Beam BG data input, either in form of Digits or raw data |
| CBHWide | C++ Interface for the Fortran Bhabha scattering generator BHWide |
| CBHWideInputModule | The BHWide Generator module.vectorToPair |
| 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 |
| CBinData | |
| CBinHeader | |
| CBinnedEventT0 | Database object for storing a binned EventT0 coming from the trigger |
| CBinTrailer | |
| CBitstream | Class to hold one clock cycle of raw bit content |
| CBkgNeutronWeight | The class to get the weighting factor for a 1-MeV-equivalent neutron flux on silicon |
| CBkgSensitiveDetector | The Class for BeamBackground Sensitive Detector |
| CBKLMAlignment | Class to store BKLM alignment data in the database |
| CBKLMAnaModule | A class defining a module that perform efficiencies studies on bklm |
| CBKLMDatabaseImporter | This module writes BKLM data to database |
| CBKLMDigitAnalyzerModule | Module useful to quickly analyze BKLM unpacked data |
| CBKLMElementNumbers | BKLM element numbers |
| CBKLMGeometryPar | The Class for BKLM geometry |
| CBKLMHit1d | Store one reconstructed BKLM 1D hit as a ROOT object |
| CBKLMMeasurementCreatorFactory | Add all measurement creators related to BKLM hits |
| CBKLMSimHistogrammerModule | Convert BKLM raw simulation hits to digitizations |
| CBKLMSimulationPar | Provides BKLM simulation parameters |
| CBKLMStatus | BKLM hit status |
| CBKLMTrack | Store one BKLM Track as a ROOT object |
| CBKLMTrackFinder | Track finding procedure |
| CBKLMTrackFitter | Track fitting procedure |
| CBKLMTrackingModule | This module perform straight line track finding and fitting for BKLM |
| CBoostMCParticlesModule | Module for boosting the MCParticles from CM to LAB frame |
| CBoostPythonModuleProxy | Proxy class to register python modules (the things you can 'import') |
| CBoostVectorAlgorithm | Class implementing BoostVector calibration algorithm |
| CBoostVectorCollectorModule | This collects the track parameters and momenta of the mu+mu- events for calibration of the BoostVector using CAF and AirFlow |
| CBranchInterface | Simple struct for interfacing the Branch |
| CBremFindingMatchCompute | Module to compute if an extrapolation to the ECL matches the position of an secondary ECLCLuster to find bremsstrahlung clusters |
| CBremHit | A bremsstrahlung hit that correlates an ECLCluster with a RecoTrack |
| 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 |
| CBrowsableWrapper | A wrapper for browsable objects to enable automatic redrawing |
| 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 |
| CBuffer | |
| CBufferedReader | |
| CBufferedWriter | |
| CBunchStructure | Class to store the fill pattern of colliding bunches |
| CCACell | The CACell class This Class stores all relevant information one wants to have stored in a cell for a Cellular automaton |
| 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 |
| CCalibObjManager | Manager class for collector registered data. Handles much of the TDirectory/TObject manipulation |
| CCalibPars | The parameters related to single calibration interval |
| ►CCalibrationAlgorithm | Base class for calibration algorithms |
| CExecutionData | A class to hold all data that is needed ONLY for the most recent single execution of the algorithm |
| CCalibrationCollectorModule | Calibration collector module base class |
| CCalibrationData | Parameters and data relevant for single calibration interval |
| CCallback | |
| CCALogger | Simple logger for CA algorithm |
| CCaTestModule | Testing module for collection of calibration data |
| CCAValidator | Validation tool for CA algorithm |
| CCaveSimHit | ClassCaveSimHit - Geant4 simulated hit for the Cave detector |
| CCDCADCDeltaPedestals | Database object for ADC pedestals |
| CCDCAlignment | CDC alignment constants |
| CCDCAlphaScaleFactorForAsymmetry | Database object for scale factors on alpha for CDC hit charge asymmetry |
| CCDCBadBoards | Database object for bad boards |
| CCDCBadWires | Database object for bad wires |
| CCDCCalibration | CDC alignment and calibration constants |
| CCDCChannelMap | Database object of CDC channel map |
| CCDCCKFDuplicateRemover | Remove duplicate paths created from ECLShowers These typically come from the seeding with two charge assumptions and Bremsstrahlung |
| CCDCCKFEclSeedCreator | Findlet for |
| CCDCCKFPathMerger | Merge similar paths |
| CCDCCKFPathSelector | Select the m_maximalCandidatesInFlight paths for further processing |
| CCDCCKFResultFinalizer | Findlet to finalize CKF Paths in terms of final result |
| CCDCCKFResultStorer | Store resulting tracks and relations on the dataStore |
| CCDCCKFSeedCreator | Create a CKF seed based on RecoTrack (presumably from VXDTF2) |
| CCDCCKFState | Define states for CKF algorithm, which can be seed track or CDC wire hit |
| ►CCDCCKFStateCreator | Create CKF states, based on the current path. Perform some basic selection at this stage (based on phi, max. jump of layers) |
| CCDCCKFWireHitCache | Store basic wire info for faster access |
| CCDCCKFStateFilter | A stack of pre-, helix-extrapolation- , Kalman-extrapolation- and Kalman-update-filters |
| CCDCCKFTracksCombinerModule | Module to combine RecoTracks |
| CCDCCorrToThresholds | Database object for correcting a simple threshold model in MC |
| CCDCCosmicSelectorAfterFullSimModule | The Class for |
| CCDCCosmicSelectorModule | The Class for |
| CCDCCosmicTrackMergerModule | Module use to select two cosmic tracks event and merger these two tracks become one |
| ►CCDCCrossTalkAdderModule | The Class for overlaying signal-induced asic cross-talk |
| CXTalkInfo | Structure for saving the x-talk information |
| CCDCCrossTalkLibrary | Database object for ASIC crosstalk library |
| CCDCDatabaseImporter | CDC database importer |
| CCDCDedx1DCell | DE/dx wire gain calibration constants |
| CCDCDedx1DCellAlgorithm | A calibration algorithm for CDC dE/dx electron: 1D enta cleanup correction |
| CCDCDedx2DCell | DE/dx wire gain calibration constants |
| CCDCDedx2DCellAlgorithm | A calibration algorithm for CDC dE/dx electron 2D enta vs doca correction |
| CCDCDedxADCNonLinearity | DE/dx electronic ADC non-linearity correction for highly ionising particles (used in offline hadron saturation calibration) parameters are for X vs Y relation and sep for inner and outer layer vector array 0,1 for inner and 2,3 for outer layers |
| CCDCDedxBadWireAlgorithm | A calibration algorithm for CDC dE/dx to find the bad wires |
| CCDCDedxBadWires | DE/dx wire gain calibration constants |
| CCDCDedxCorrectionModule | This module may be used to apply the corrections to dE/dx per the calibration constants |
| CCDCDedxCosEdgeAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxCosineAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxCosineCor | DE/dx wire gain calibration constants |
| CCDCDedxCosineEdge | DE/dx special large cosine calibration to fix bending shoulder at large costh |
| CCDCDedxDatabaseImporter | DE/dx database importer |
| CCDCDedxDQMModule | This module to design collect CDC dEdx monitoring for DQM and only minimal information are stored |
| CCDCDedxElectronCollectorModule | A collector module for CDC dE/dx electron calibrations |
| CCDCDedxHadBGAlgorithm | A calibration algorithm for beta gamma curve and resolution fitting and save payloads |
| CCDCDedxHadronCollectorModule | A collector module for CDC dE/dx hadron calibrations |
| CCDCDedxHadronCor | DE/dx hadron saturation parameterization constants |
| CCDCDedxHadSat | Class to hold the hadron saturation functions |
| CCDCDedxHadSatAlgorithm | A calibration algorithm for hadron saturation |
| CCDCDedxHit | Class to store CDC hit information needed for dedx |
| CCDCDedxHitSaverModule | Module that stores CDC hit information needed for dedx |
| CCDCDedxInjectionTime | DE/dx injection time calibration constants |
| CCDCDedxInjectTimeAlgorithm | A calibration algorithm for CDC dE/dx injection time (HER/LER) |
| CCDCDedxLikelihood | Container for likelihoods obtained by the CDC dE/dx PID (CDCDedxPIDModule) |
| CCDCDedxMeanPars | DE/dx mean (curve versus beta-gamma) parameterization constants |
| CCDCDedxMeanPred | Class to hold the prediction of mean as a function of beta-gamma (bg) |
| CCDCDedxMomentumAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxMomentumCor | DE/dx wire gain calibration constants |
| CCDCdEdxPDFs | Specialized class for holding the CDC dE/dx PDFs |
| ►CCDCDedxPIDCreatorModule | Module that creates PID likelihoods from CDC hit information stored in CDCDedxHits using parameterized means and resolutions |
| CDEDX | Helper structure for merging dEdx measurements |
| CCDCDedxPIDModule | Extract CDC dE/dx information from fitted tracks |
| CCDCDedxRunGain | DE/dx run gain calibration constants |
| CCDCDedxRunGainAlgorithm | A calibration algorithm for CDC dE/dx run gains |
| CCDCDedxScaleFactor | DE/dx run gain calibration constants |
| CCDCDedxScanModule | This class performs the same function as CDCDedxPIDModule, but does so without using real objects from basf2 |
| CCDCDedxSigmaPars | DE/dx sigma (versus beta-gamma) parameterization constants |
| CCDCDedxSigmaPred | Class to hold the prediction of resolution depending dE/dx, nhit, and cos(theta) |
| CCDCDedxSkimCDSTModule | Extracts dE/dx information for calibration testing |
| CCDCDedxSkimModule | This module may be used to skim a data sample according to a specific set of cuts |
| CCDCDedxTrack | Debug output for CDCDedxPID module |
| CCDCDedxValidationAlgorithm | A validation algorithm for CDC dE/dx electron |
| CCDCDedxValidationModule | First version committed on Feb 21 2019 Extracts dE/dx information for validation and writes a ROOT file |
| CCDCDedxWidgetCurve | Class to hold the beta-gamma (bg) mean function |
| CCDCDedxWidgetSigma | Class to hold the beta-gamma (bg) resolution function |
| CCDCDedxWireGain | DE/dx wire gain calibration constants |
| CCDCDedxWireGainAlgorithm | A calibration algorithm for CDC dE/dx wire gains |
| ►CCDCDigitizerModule | The Class for Detailed Digitization of CDC |
| CSignalInfo | Structure for saving the signal information |
| CXTalkInfo | Structure for saving the x-talk information |
| CCDCDisplacement | Database object for displacement of sense wire position |
| CcdcDQM7Module | The module for Data Quality Monitor |
| CCDCDQMModule | Make summary of data quality from reconstruction |
| CCDCEDepToADCConversions | Database object for energy-deposit to ADC-count conversion |
| CCDCFEElectronics | Database object for Fron-endt electronics params |
| CCDCFEEParams | Database object for FEE params |
| CCDCfromEclPathTruthVarNames | Vehicle class to transport the variable names |
| CCDCfromEclPathTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| CCDCfromEclStateTruthVarNames | Vehicle class to transport the variable names |
| CCDCfromEclStateTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| CCDCFudgeFactorsForSigma | Database object for fudge factors for CDC space resol |
| ►CCDCGeometry | The Class for CDC geometry |
| CCover | Cover structure geometry parameters |
| CCover2 | Cover2 structure geometry parameters |
| CEndPlate | Endplate geometry parameters |
| CEndPlateLayer | Endplate layer geometry parameters |
| CFieldLayer | Field layer geometry parameters |
| CFrontend | Frontend layer geometry parameters |
| CInnerWall | Inner wall geometry parameters |
| CMotherVolume | Mother volume geometry parameters |
| CNeutronShield | Neutron shield geometry parameters |
| COuterWall | Outer wall geometry parameters |
| CRib | Rib structure geometry parameters |
| CRib2 | Rib2 structure geometry parameters |
| CRib3 | Rib3 structure geometry parameters |
| CRib4 | Rib4 structure geometry parameters |
| CRib5 | Rib5 structure geometry parameters |
| CSenseLayer | Sense layer geometry parameters |
| CCDCHit | Class containing the result of the unpacker in raw data and the result of the digitizer in simulation |
| CCDCHitBasedT0ExtractionModule | Module implementation using the CDCHitBasedT0Extractor |
| CCDCInitialT0DeterminationModule | Determine crude t0 |
| CCDCJobCntlParModifierModule | The Class for Detailed Digitization of CDC |
| CCDCLayerAlignment | CDC layers alignment constants |
| CCDClayerTimeCut | Database object for timing offset (t0) |
| CCDCMeasurementCreatorFactory | Add all measurement creators related to CDC hits |
| CCDCMisalignment | CDC misalignment constants |
| CCDCPathBasicVarNames | Vehicle class to transport the variable names |
| CCDCPathBasicVarSet | Var set to store basic quantities related to CDC CKF |
| CCDCPathFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CCDCPathPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CCDCPathTruthVarNames | Vehicle class to transport the variable names |
| CCDCPathTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| CCDCPropSpeeds | Database object for signal propagation speed along the wire |
| CCDCRawHit | The CDCRawHit (suppressed mode) class |
| CCDCRawHitWaveForm | The CDCRawHitWaveForm (Full output mode) class |
| CCDCRecoHit | This class is used to transfer CDC information to the track fit |
| CCDCSimHit | Example Detector |
| CCDCSpaceResols | Database object for space resolutions |
| CCDCStateBasicVarNames | Vehicle class to transport the variable names |
| CCDCStateBasicVarSet | Var set to store basic quantities related to CDC CKF |
| CCDCStateFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CCDCStateTruthVarNames | Vehicle class to transport the variable names |
| CCDCStateTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| CCDCTimeWalks | Database object for time-walk |
| CCDCTimeZeros | Database object for timing offset (t0) |
| CCDCToSVDSeedCKFModule | Seed-finding combinatorial Kalman Filter that combines every RecoTrack with every SVD track, then filters the combinations |
| CCDCToSVDSpacePointCKFModule | Combinatorial Kalman Filter used for extrapolating CDC tracks into SVD and create merged tracks |
| CCDCTrigger2DConfig | The payload class for delay of GDL input bit |
| CCDCTrigger2DFinderModule | |
| CCDCTrigger2DFitterModule | Module for the 2D Fitter of the CDC trigger |
| CCDCTrigger3DFinderInfo | Extra info for analysis of the 3DFinder of the CDC trigger |
| ►CCDCTrigger3DFitterModule | Module for the 3D Fitter of the CDC trigger |
| CHoughVoter | Class for the Hough voter |
| CCDCTriggerDeadch | The payload class for delay of GDL input bit |
| CCDCTriggerETFModule | Module for the Event Time Finder of the CDC trigger |
| CCDCTriggerFinderClone | Additional information from the 2D finder unpacker of the CDC trigger |
| CCDCTriggerHoughCand | Hough Candidates class |
| CCDCTriggerHoughCluster | Cluster created by the Hough finder of the CDC trigger |
| CCDCTriggerHoughETFModule | |
| CCDCTriggerMCMatcherModule | A module to match CDCTriggerTracks to MCParticles |
| CCDCTriggerMLP | Class to keep all parameters of an expert MLP for the neuro trigger |
| ►CCDCTriggerMLPData | Struct for training data of a single MLP for the neuro trigger |
| CHeaderSet | |
| CNeuroSet | Struct to keep one set of training data for either training, validation or testing |
| CCDCTriggerMLPInput | Class to hold some intermediate information for the monitoring of the neurotrigger |
| CCDCTriggerNDFinderModule | CDC Trigger NDFinder Module |
| ►CCDCTriggerNeuroConfig | The payload class for all CDC Neurotrigger information |
| CB2FormatLine | |
| CCDCTriggerNeuroDataModule | |
| ►CCDCTriggerNeuroDQMModule | CDC Trigger DQM Module |
| CTSLine | |
| ►CCDCTriggerNeuroDQMOnlineModule | CDC Trigger DQM Module |
| CTSLine | |
| CCDCTriggerNeuroIDHistModule | Description |
| CCDCTriggerNeuroModule | The neural network module of the CDC trigger |
| CCDCTriggerPlane | Database object for timing offset (t0) |
| CCDCTriggerRecoHitMatcherModule | A module to match CDCTriggerTracks to RecoTracks |
| CCDCTriggerRecoMatcherModule | A module to match CDCTriggerTracks to RecoTracks |
| CCDCTriggerSegmentHit | Combination of several CDCHits to a track segment hit for the trigger |
| CCDCTriggerTrack | Track created by the CDC trigger |
| CCDCTriggerTrackCombinerModule | Module to combine the information from the various track trigger stages |
| CCDCTriggerTSFConfig | The payload class for TSF run-dependent parameter |
| CCDCTriggerTSFFirmwareModule | This class is the interface between TSim/basf2 TSF module and the firmware simulation core of XSim/ISim |
| CCDCTriggerTSFModule | Module for the Track Segment Finder of the CDC trigger |
| CCDCTriggerUnpackerModule | Unpack the trigger data recorded in B2L |
| CCDCWireHit | Class representing a hit wire in the central drift chamber |
| CCDCWireHitRequirements | Database object containing cut values to filter CDCWireHits |
| CCDCXtRelations | Database object for xt-relations |
| CCellularAutomaton | The CellularAutomaton class This class serves as a functor for the algorithm itself |
| CCertifyParallelModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| CChebFitter | Unbinned Maximum Likelihood fitter with a possibility to use Chebyshev interpolation |
| CCheckErrorEventModule | Count the number of CRC error events by checking RawCOPPER's header/trailer and EventMetaData |
| CChi2BasedCDCPathPairFilter | Prefers path with smallest sum dist^2 / length of path |
| CChi2BasedEventTimeExtractor | Event time extraction based on the principle of arXiv:0810.2241 |
| CChi2BasedT0ExtractorModule | Module implementation using only the chi2 |
| CChi2MCTrackMatcherModule | Monte Carlo matcher using the helix parameters for matching by chi2-method |
| CCIRCLECENTERXY_NAME | Calculates the center of the circle for 3 hits in the XY plane and returns a B2Vector3 with the result (z=0) |
| CCIRCLEDIST2IP_NAME | Calculates the distance of the point of closest approach of circle to the IP, returning unit: cm |
| CCIRCLERADIUS_NAME | Calculates the estimation of the circle radius of the 3-hit-tracklet, returning unit: cm |
| CCKFParameters | The payload containing all parameters for the PXD and SVD CKF |
| CCKFRelationCreator | Findlet for applying filters for creating hit-hit and hit-seed relations |
| CCKFResult | Object for temporary storage of a CKF tree search result |
| ►CCKFState | State object to store one step in the CKF algorithm together with its parent (the state before), the hit (e.g |
| CstateCache | Cache containing the most important information of this state which will often be needed |
| CCKFToCDCFindlet | Main findlet of the ToCDCCKF module |
| CCKFToCDCFromEclFindlet | Main findlet of the ToCDCCKF module |
| CCkfToPXDFiltersSetting | The payload containing |
| CCKFToPXDFindlet | Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (PXD) and collect space points |
| CCKFToPXDResult | Specialized CKF Result for extrapolating into the PXD |
| CCKFToPXDState | Specialized CKF State for extrapolating into the PXD |
| CCKFToSVDFindlet | Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (SVD) and collect space points |
| CCKFToSVDResult | Specialized CKF Result for extrapolating into the SVD |
| CCKFToSVDSeedFindlet | Findlet for combining CDC tracks with SVD tracks |
| CCKFToSVDState | Specialized CKF State for extrapolating into the SVD |
| CClawHit | ClassClawHit - digitization simulated hit for the Claw detector |
| CClawsHit | ClassClawsHit - digitization simulated hit for the Claws detector |
| CClawSimHit | ClassClawSimHit - Geant4 simulated hit for the Claw crystal in beast |
| CCLAWSSimHit | Class CLAWSSimHit - Geant4 simulated hit for the CLAWS detector |
| CCleoCones | Class to calculate the Cleo clone variables |
| CClosedLowerBoundedSet | Represents a closed lower bounded set of arithmetic types |
| CClosedRange | Represents a closed set of arithmetic types |
| CClosedUpperBoundedSet | Represents an upper bounded set of arithmetic types |
| CCluster | Class to collect log likelihoods from Clusters from ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability |
| CClustererParameters | Struct containing the parameters for the clustering |
| CClusterInfoExtractor | Class to extract info from individual clusters and combine for SPTC |
| ►CClusterizend | Clustering module |
| CDeletionBounds | Struct containing the deletion bounds of a omega row |
| CClusterMatcherModule | Match KLM Clusters to close ECL Clusters |
| CClustersOnSensor | Small struct for storing all clusters of the same sensor in one container |
| CClusterUtils | Class to provide momentum-related information from ECLClusters |
| CCMSFrame | CMS frame |
| CCMSRotationFrame | Stack frame for cms and Rotation frame |
| CCOILGeometryPar | The Class for COIL geometry parameters |
| CCollectorTestModule | CollectorTestModules |
| 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 |
| CCommandLine | |
| CCompactSecIDs | This class provides a computer convenient numbering scheme for the sectors in the sector map and for the N sectors combinations |
| CCond | |
| 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 |
| CConfigFile | |
| CConnection | |
| ►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 |
| CConvert2RawDetModule | A class definition of a module to convert from RawCOPPER or RawDataBlock to RawDetector objects |
| CCoordinateMeasurementCreator | A measurement creator for normal coordinate measurements out of cdc/svd/pxd hits |
| CCopyRecoTracksWithOverlapModule | Copy RecoTracks with overlap hits in VXD to a new StoreArray (Will need a refit) |
| CCOSANGLEXY_NAME | Calculates the angle between the hits/vectors (XY), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use AngleXYFull instead): |
| CCOSDIRECTIONXY_NAME | This is a specialization returning floats, where value calculates the cos of the angle of the segment of two hits in the XY plane |
| CCosmicsAlignmentValidationModule | Module to find Track correlation in cosmic events |
| CCosmicsModule | The Cosmics module Generates tracks with the cosmics generator and store them into the MCParticle class |
| CCosmicsTrackMergerFindlet | Links tracks based on a filter criterion. It is based on the TrackLinker in the TF_CDC package |
| CCosmicsTrackMergerModule | Module linking tracks based on their Phi parameter |
| CCovariancePacked | Struct to keep upper triangle of the covariance matrix |
| CCprErrorMessage | |
| 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 |
| CCRY | C++ Interface for the generator CRY |
| CCRYInputModule | The CRY Generator module |
| CCryostatGeo | Geometry parameters of Cryostat |
| CCsiDigiHit | Class to store Csi digitized hits (output of CsIDigitizer) relation to CsiHit filled in beast/csi/modules/src/CsIDigitizerModule.cc |
| CCsiHit | Class to store simulated hits which equate to average of CsiSimHit on crystals Input for digitization module (CsiDigitizer) |
| CCsiHit_v2 | ClassCsiHit_v2 - Geant4 simulated hits in CsI crystals in BEAST |
| CCsiSimHit | ClassCsiSimHit - Geant4 simulated hits in CsI crystals in BEAST |
| CCsIStudyModule | Analyze simulations of CsI readings in BEAST |
| ►CCurlingTrackCandSplitterModule | Module for checking SpacePointTrackCandidates for curling behaviour and splitting them into Track Candidate Stubs (each of them being a SpacePointTrackCand again) which do not show curling behaviour |
| CRootVariables | Internal DataStore for ROOT output variables |
| CTaggedUVPos | Struct for easier handling of getting U- & V-position of SpacePoints and some difficulties that arise within this task |
| CCurlTaggerModule | This module is designed to tag curl tracks |
| CCylinderDistancePXDPairFilter | Base filter for CKF PXD states |
| CDaemon | |
| CDAFConfiguration | The payload containing all the DAFParameters configuration, one for each different track fit option |
| CDAFParameters | The payload containing the DAF parameters |
| CDAFRecoFitterModule | DAF fitter |
| CDAQLogDB | |
| CDAQLogMessage | |
| CDAQMonitorModule | A module for producing general DAQ DQM histograms |
| CDAQPerfModule | A class definition of an input module for Sequential ROOT I/O |
| ►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') |
| CDataStorePackage | |
| CDataStoreStreamer | Stream/restore DataStore objects to/from EvtMessage |
| CDataWriterModule | Module to write Ntuples for KlId BKG classifier training |
| CDATCONFPGAFindlet | Findlet for performing the DATCON ROI calculation close to the implementation on FPGA |
| CDATCONModule | DATCON module which implementation is close to the one actually used on the FPGA |
| CDATCONSVDClusterCandidate | Struct containing a cluster candidate for easier handling |
| CDATCONSVDClusterizer | Findlet for clustering DATCONSVDDigits and creating SVDClusters that are used for tracking in DATCON |
| CDATCONSVDClusterLoaderAndPreparer | Findlet for loading SVDClusters that were created by the DATCONSVDClusterizer findlet and prepare them for usage in the FastInterceptFinder2D by calculating the conformal transformed x,y coordinates and the creating pairs of coordinates for finding track candidates in r-phi and r-z |
| CDATCONSVDDigit | The DATCONSVDDigit class |
| CDate | |
| CDBAccessorBase | Base class for DBObjPtr and DBArray for easier common treatment |
| CDBArray | Class for accessing arrays of objects in the database |
| CDBHandlerException | |
| 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 |
| CDBInterface | |
| CDBObjCalibrationConstMapBase | Base for calibration or alignment parameters identified by two unsigned shorts Typically first is some identifier of a sub-detector element (sensor, layer, wire, board...) and the second is number of parameter |
| ►CDBObject | |
| CNameValue | |
| CDBObjectLoader | |
| 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 |
| CDBRecord | |
| 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 |
| CDecorrelationMatrix | Class holding a Matrix that can be used to decorrelate input data to Machine Learning classifiers |
| CDedxDriftCell | A class to hold the geometry of a cell |
| CDedxLine | A class to hold the endpoints and slope of a line |
| CdEdxPDFs | Base class for holding the dE/dx PDFs |
| CDedxPoint | A collection of classes that are useful for making a simple path length correction to the dE/dx measurement for each hit in a CDC cell |
| CDelayDQMModule | Processing Delay DQM Module |
| CDELTACIRCLERADIUS_NAME | Calculates delta-circleRadius-value (difference in circle radii of 2 subsets of the hits), returning unit: cm |
| CDELTADISTCIRCLECENTER_NAME | Calculates the distance between the estimated circle centers (using 2 subsets of given hits) in the xy-plane, returning unit: cm |
| CDELTAPT_NAME | Calculates dpt-value (dpt= difference in transverse momentum of 2 subsets of the hits), returning unit: GeV/c |
| CDELTASLOPERZ_NAME | Calculates deviations in the slope of the inner segment and the outer segment, returning unit: none |
| CDELTASLOPEZOVERS_NAME | Compares the "slopes" z over arc length |
| CDELTASOVERZ_NAME | Calculates the helixparameter describing the deviation in arc length per unit in z |
| 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(); |
| CDeSerializerCOPPERModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerFILEModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerHLTModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerPCModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerPrePCModule | A class definition of an input module for Sequential ROOT I/O |
| CDeSerializerPXDModule | A class definition of an input module for Sequential ROOT I/O |
| CDesSer | A class definition of an input module for Sequential ROOT I/O |
| CDesSerCOPPER | A class definition of an input module for Sequential ROOT I/O |
| CDesSerPrePC | A class definition of an input module for Sequential ROOT I/O |
| CDesSerPrePCMainModule | A class definition of an input module for Sequential ROOT I/O |
| CDetectorConstruction | Class responsible to connect to geometry to simulation |
| CDetectorOccupanciesDQMModule | DQM Module for basic detector quantities before the HLT filter |
| CDetectorSurface | Detector surfaces information |
| CDetSurfCylBoundaries | Simple class to encapsulate a detector surface's boundaries in cylindrical coordinates |
| CDigitBase | A common base for subdetector Digits |
| CDirectedNode | The Node-Class |
| CDirectedNodeNetwork | Network of directed nodes of the type EntryType |
| CDirectedNodeNetworkContainer | The Container stores the output produced by the SegmentNetworkProducerModule |
| ►CDisplayData | Add custom information to the display |
| CArrow | Stores data associated with an arrow |
| CDisplayModule | The event display module |
| ►CDisplayUI | Control TEve browser user interface |
| CParameter | Wraps a module parameter that can be toggled from the UI |
| CDISTANCE1DZ_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the distance between two hits in 1D on the Z-axis |
| CDISTANCE1DZSQUARED_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 1D on the Z-axis |
| CDISTANCE2DXYSQUARED_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 2D on the X-Y-plane |
| CDISTANCE3DNORMED_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the normed distance between two hits in 3D |
| CDISTANCE3DSQUARED_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 3D |
| CDistanceBasedCDCPathPairFilter | For the two paths with the same number of hits prefers one with smallest sum dist^2 |
| 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 |
| CDistanceCDCStateFilter | Give a weight based on the distance from the hit to the path |
| CDISTANCEINTIME | This variable returns the difference among the V and U side clusters of th ecenter space point |
| CDISTANCEINTIME_U_NAME | This variable returns the time difference among the U side clusters of the two space points |
| CDISTANCEINTIME_V_NAME | This variable returns the time difference among the V side clusters of the two space points |
| CDistanceSVDPairFilter | Base filter for CKF SVD states |
| CDosiHit | ClassDosiHit - Geant4 ulated hit for the Dosi crystal in beast |
| CDosiSimHit | ClassDosiSimHit - Geant4 simulated hit for the Dosi crystal in beast |
| CDQMCommonUtils | The class collects utility functions for creating DQM histograms: prepared for PXD, SVD, VXD and Track DQM histograms |
| CDQMEventProcessorBase | The purpose of this class is to process one event() in DQMHistoModuleBase, which is a base for TrackDQMModule and AlignDQMModule |
| CDQMFileMetaData | Metadata information about a DQM file |
| CDQMHistAnalysisARICHModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisARICHMonObjModule | Example module of how to use MonitoringObject in DQMHistAnalysis module |
| CDQMHistAnalysisCDCDedxModule | DQM analysis module grab canvases from DQM module and perform higher level operation like histogram fitting and add many useful cosmetic |
| CDQMHistAnalysisCDCEpicsModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisCDCMonObjModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisDAQMonObjModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisDeltaEpicsMonObjExampleModule | DQM Delta Histogram Test code and example |
| CDQMHistAnalysisDeltaTestModule | DQM Delta Histogram Test code and example |
| CDQMHistAnalysisECLConnectedRegionsModule | This module is for analysis of ECL DQM histograms |
| CDQMHistAnalysisECLModule | This module is for analysis of ECL DQM histograms |
| CDQMHistAnalysisECLOutOfTimeDigitsModule | This module exports the average value of out-of-time ECLCalDigits into EPICS and MiraBelle |
| CDQMHistAnalysisECLShapersModule | This module is for analysis of ECL DQM histograms |
| ►CDQMHistAnalysisECLSummaryModule | This module provides a high-level display to show which ECLCollectors have channels with various type of issues See https://indico.belle2.org/event/10116/contributions/66837/attachments/23993/35443/2023.09.06_ecl.dqm.status_mikhail.remnev.pdf |
| Cdbr_sts_long_array | Structure to get an array of long values from EPICS |
| CECLAlarmType | Definition for different ECL alarm types |
| CDQMHistAnalysisEcmsMonObjModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisEpicsEnableModule | Example module of how to use MonitoringObject in DQMHistAnalysis module |
| CDQMHistAnalysisEpicsExampleModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisEpicsOutputModule | Example module of how to use MonitoringObject in DQMHistAnalysis module |
| CDQMHistAnalysisEventT0EfficiencyModule | Class definition |
| CDQMHistAnalysisEventT0TriggerJitterModule | Class definition |
| CDQMHistAnalysisExampleFlagsModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisExampleModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisHLTModule | Class for HLT-related histogram analysis |
| CDQMHistAnalysisHLTMonObjModule | Creates monitoring object for HLT |
| CDQMHistAnalysisInput2Module | Class to read histograms from a root file for online analysis modules |
| CDQMHistAnalysisInputPVSrvModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisInputRootFileModule | Class to read histograms from a root file for offline testing of analysis modules |
| CDQMHistAnalysisInputTestModule | Class to dynamically fill histograms from a config file for offline testing of analysis modules |
| CDQMHistAnalysisKLM2Module | Analysis of KLM DQM histograms |
| CDQMHistAnalysisKLMModule | Analysis of KLM DQM histograms |
| CDQMHistAnalysisMiraBelleModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisModule | The base class for the histogram analysis module |
| CDQMHistAnalysisMonObjModule | Example module of how to use MonitoringObject in DQMHistAnalysis module |
| CDQMHistAnalysisOutputFileModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisOutputImagesModule | Class definition for the output to image module |
| CDQMHistAnalysisOutputMonObjModule | Class definition for the module to store MonitoringObject to output root file |
| CDQMHistAnalysisOutputRelayMsgModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisPeakModule | DQM Histogram Analysis for simple peaking distributions |
| CDQMHistAnalysisPhysicsModule | DQM Histogram Analysis for Physics |
| CDQMHistAnalysisPXDChargeModule | DQM Histogram Analysis for PXD Cluster Charge |
| CDQMHistAnalysisPXDCMModule | DQM Histogram Analysis for PXD Common Modes |
| CDQMHistAnalysisPXDDAQModule | DQM Histogram Analysis for PXD DAQ |
| CDQMHistAnalysisPXDEffModule | DQM Histogram Analysis for PXD Efficiency |
| CDQMHistAnalysisPXDERModule | PXD DQM AnalysisModule |
| CDQMHistAnalysisPXDFitsModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisPXDInjectionModule | DQM Histogram Analysis for PXD occupancy after Injection |
| CDQMHistAnalysisPXDReductionModule | DQM Histogram Analysis for PXD Reduction |
| CDQMHistAnalysisPXDTrackChargeModule | DQM Histogram Analysis for PXD Cluster Charge |
| CDQMHistAnalysisRooFitExampleModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisRunNrModule | DQM Histogram Analysis for PXD Common Modes |
| CDQMHistAnalysisSVDClustersOnTrackModule | Class definition for the output module of Sequential ROOT I/O |
| ►CDQMHistAnalysisSVDDoseModule | The SVD dose-monitoring DQM analysis module |
| CSensorGroup | A struct to define the sensors group we average over |
| CDQMHistAnalysisSVDEfficiencyModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisSVDGeneralModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisSVDModule | Class definition for common method |
| CDQMHistAnalysisSVDOccupancyModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisSVDOnMiraBelleModule | Class derived from HistoModule, for SVD monitoring variables at MiraBelle |
| CDQMHistAnalysisSVDUnpackerModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisTOPModule | Class for TOP histogram analysis |
| CDQMHistAnalysisTrackingAbortModule | Analysis of HLT Tracking DQM plots |
| CDQMHistAnalysisTrackingERModule | Analysis of ER Tracking DQM plots |
| CDQMHistAnalysisTrackingHLTModule | Analysis of HLT Tracking DQM plots |
| CDQMHistAnalysisTRGECLModule | Module for DQM histogram of ECL trigger event timing |
| CDQMHistAnalysisTRGEFFModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisTRGGDLModule | Make summary of data quality from reconstruction |
| CDQMHistAnalysisTRGModule | DQM Trigger Histogram code and example |
| CDQMHistAnalysisV0Module | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAutoCanvasModule | Class definition for the reference histogram display |
| ►CDQMHistComparitorModule | Class definition for the reference histogram display |
| CCMPNODE | The struct for reference histogram comparison |
| ►CDQMHistDeltaHistoModule | Class for generating snapshots for histograms |
| CSSNODE | The struct for the snapshots |
| CDQMHistInjectionModule | DQM Histogram Analysis for PXD Efficiency |
| CDqmHistoManagerModule | Class definition of DqmHistoManager module |
| CDQMHistoModuleBase | This class serves as a base for the TrackDQMModule and AlignDQMModule (and possibly other DQM histogram modules) |
| CDQMHistOutputToEPICSModule | Write DQM Histogram Content to EPICS Arrays |
| CDQMHistReferenceModule | Class to add DQM reference histograms |
| ►CDQMHistSnapshotsModule | Class for generating snapshots for histograms |
| CSSNODE | The struct for the snapshots |
| CDqmMasterCallback | |
| CDqmMemFile | |
| CDqmSharedMem | |
| CDriftLengthBasedEventTimeExtractor | Event time extraction based on the principle of the CDC drift time calculation |
| CDriftLengthBasedT0ExtractorModule | Module implementation using only the drift lengths |
| CDs2RawFileModule | A class definition of an input module for Sequential ROOT I/O |
| CDs2RawModule | A class definition of an input module for Sequential ROOT I/O |
| CDs2RbufModule | A class definition of an input module for Sequential ROOT I/O |
| CDs2SampleModule | A class definition of an input module for Sequential ROOT I/O |
| CDualNumber | Simple structure implementing dual numbers which are used for exact evaluation of the derivatives, see https://en.wikipedia.org/wiki/Automatic_differentiation#Automatic_differentiation_using_dual_numbers |
| CDummyCollectorModule | Basically empty Collector, makes only a tiny amount of output data |
| CDummyDataPackerModule | Module to store dummy data in RawCOPPER object |
| CDummyDataSourceFileModule | A class definition of an input module for Sequential ROOT I/O |
| CDummyDataSourceModule | A class definition of an input module for Sequential ROOT I/O |
| CDuplicateCDCPathPairFilter | Simple filter to distinguish between photon conversion and Bremsstrahlung |
| CDuplicateVertexMarkerModule | Identify duplicate vertices (distinct particles, but built from the same daughters) and mark the one with best chi2 |
| CDynamicLoader | |
| CDynamicLoadException | |
| CECLAutoCovariance | Covariance matrices for offline ECL waveform fit |
| CeclAutocovarianceCalibrationC1CollectorModule | Calibration collector module to estimate noise level of delayed Bhabha waveforms |
| CeclAutocovarianceCalibrationC3CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CeclAutocovarianceCalibrationC4CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CECLBackgroundModule | A module to study background campaigns and produce histograms |
| CECLBeamBackgroundStudy | Flag for beam background study |
| CECLBhabhaTCollectorModule | This module generates time vs crystal 2D histograms to later (in eclBhabhaTAlgorithm) find time crystal/crate offsets from bhabha events |
| CeclBhabhaTimeCalibrationValidationCollectorModule | This module generates 'TimevsCrys' histogram to later (in eclBhabhaTAlgorithm) find time offset from bhabha events |
| CECLCalDigit | Class to store calibrated ECLDigits: ECLCalDigits |
| CECLCellIdMapping | Class to store mapping between cell id and store array positions |
| CECLChannelMap | DB object to store correspondence table of type (Crate id, ShaperDSP id, Channel id) <-> (ECL CellID) |
| CECLChargedPIDDataAnalysisModule | The ECL Charged PID Data Analysis Module |
| CECLChargedPIDDataAnalysisValidationModule | This module dumps a tree and a set of histograms of ECL PID-related info used for validation, starting from an input file w/ particle-gun-generated charged stable particles (and antiparticles) |
| CECLChargedPIDModule | The module implements charged particle identification using ECL-related observables |
| CECLChargedPIDMVAModule | This module implements charged particle identification using ECL-related observables via a multiclass MVA |
| CECLChargedPIDMVAWeights | Class to contain payload of everything needed for MVA based charged particle identification |
| ►CECLChargedPidPDFs | Class representing the DB payload w/ information about ECL PDF parameters for a set of particle hypotheses 'signed pdgId' values, i.e |
| CVarTransfoSettings | Class to hold parameters needed to perform pre-processing of input variables (e.g., gaussianisation, decorrelation) to build a multi-dimensional likelihood model |
| CECLChargedPIDPhasespaceBinning | Class to store the N dimensional phasespace binning of the MVA categorical training |
| CECLChargedPIDPhasespaceCategory | Stores all required information for the ECLChargedPIDMVA for a phasespace category |
| CECLCluster | ECL cluster data |
| CECLClusteringParameters | DB object to parameters that store clustering behaviour in ECLCRFinder and ECLLocalMaximumFinder |
| CECLClusterPropertiesModule | This module calculates some properties of ECL clusters |
| CECLClusterPSDModule | This module computes shower variables using pulse shape information from offline two component fits |
| CECLClusterPSDPureCsIModule | Class derived from ECL, only difference are the names |
| CECLCompressBGOverlayModule | The ECLCompressBGOverlay module compresses recorded waveforms triggered by the random trigger and to use them in simulation to follow background conditions |
| CECLConnectedRegion | Class to store connected regions (CRs) |
| CeclCosmicECollectorModule | Class eclCosmicECollectorModule |
| CECLCovarianceMatrixModule | Class to perform the shower correction |
| CECLCovarianceMatrixPureCsIModule | The very same module but for PureCsI |
| CEclCovMatrixNtupleModule | Module to write ECL waveform and fitted time and amplitude information in a root ntuple |
| CECLCRFinderModule | Class to find connected regions |
| CECLCRFinderPureCsIModule | Class to find connected regions, pureCsI version |
| CECLCrystalCalib | General DB object to store one calibration number per ECL crystal |
| CECLCrystalData | Class for obtaining crystal details for a given crystal cell An evolved look-up table |
| CECLCrystalLocalRunCalib | ECLCrystalLocalRunCalib is designed to store results of the ECL local run calibration to database |
| CECLCrystalsShapeAndPosition | Crystal shapes and positions |
| CEclData | This class contains data for ECLSimHit's and provides several relevant conversion functions for better event display |
| CECLDataAnalysisModule | The ECL Data Analysis Module |
| CECLDatabaseImporter | ECL database importer |
| CECLDBTool | The ECLDBTool class is designed to read / write object from / to database |
| CECLDebugHit | Class to store the average of ECLSimHit on crystals for debug only input for digitization module (ECLDigitizer) |
| CECLDigiStudyModule | A module to analyse digit level information |
| CECLDigit | Class to store ECL digitized hits (output of ECLDigi) relation to ECLHit filled in ecl/modules/eclDigitizer/src/ECLDigitizerModule.cc |
| CECLDigitCalibratorModule | Class to find calibrate digits and convert waveform fit information to physics quantities |
| CECLDigitCalibratorPureCsIModule | Class derived from ECLDigitCalibratorModule, only difference are the names |
| CECLDigitEnergyConstants | Energy calibration constants per digit |
| ►CECLDigitizerModule | The ECLDigitizer module |
| Ccalibration_t | Calibration constants per channel |
| Ccrystallinks_t | Indices in arrays with info on ECL channels |
| ►CECLDigitizerPureCsIModule | The ECLDigitizerPureCsI module |
| Ccrystallinks_t | Indices in arrays with info on ECL channels |
| CECLDigitTimeConstants | Time and time resolution calibration constants per digit |
| CECLDigitWaveformParameters | DB object to store photon, hadron and diode shape parameters |
| CECLDigitWaveformParametersForMC | DB object to store photon, hadron and diode shape parameters used in simulations |
| CEclDisplayAsyncModule | Displays energy distribution in ECL |
| CEclDisplayModule | Displays energy distribution in ECL |
| CECLDQMConnectedRegionsModule | This module is created to monitor ECL Data Quality |
| CECLDQMEXTENDEDModule | This module is created to monitor ECL electronics logic in frame of DQM system |
| CECLDQMModule | This module is created to monitor ECL Data Quality |
| CECLDQMOutOfTimeDigitsModule | This module produces DQM histograms to monitor the distribution of out-of-time ECLCalDigits |
| CECLDsp | Class to store ECL ShaperDSP waveform ADC data |
| CECLDspData | This object contains ECL DSP coefs – electromagnetic calorimeter digital signal processing coefficients |
| CECLDspWithExtraMCInfo | Class to store ECL ShaperDSP waveform ADC data and additional information for ML studies |
| CECLDumpGeometryModule | Dump location and direction of all ECL crystals |
| CeclEdgeCollectorModule | Collector to store ECL crystal locations |
| Ceclee5x5CollectorModule | Calibration collector module that uses e+e- --> e+e- to do ECL single crystal energy calibration |
| CECLEnergyCloseToTrack | Class to store energy information for ECL hits closest to a track |
| CECLEventT0Module | EventT0 from ECL |
| CECLExpertModule | Module to perform the ECL Klong ID classification |
| CECLFillCellIdMappingModule | Fills a dataobject that provides mapping between cell id and ECLCalDigit store array |
| CECLFinalizerModule | Class to perform the shower correction |
| CECLFinalizerPureCsIModule | The very same module but for PureCsI |
| CEclFrame | Root TGMainFrame that contains multiple widgets that display the ECLSimHit's w.r.t |
| CeclGammaGammaECollectorModule | Calibration collector module that uses e+e- --> gamma gamma to do ECL single crystal energy calibration |
| CECLHadronComponentEmissionFunction | Hadron Component Emission Function for hadron pulse shape simulations |
| CeclHadronTimeCalibrationValidationCollectorModule | This module generates 'TimevsCrys' histogram to later (in eclBhabhaTAlgorithm) find time offset from bhabha events |
| CECLHit | Class to store simulated hits which equate to average of ECLSImHit on crystals input for digitization module (ECLDigitizer) |
| CECLHitAssignment | Example Detector |
| CECLHitDebugModule | Class to represent the hit of one cell |
| CeclLeakageCollectorModule | Store information needed to calculate ECL energy leakage corrections |
| CECLLeakageCorrections | DB object to store leakage corrections, including nCrys dependence |
| CECLLocalMaximum | Class to store local maxima (LM) |
| CECLLocalMaximumFinderModule | Class to find connected regions |
| CECLLocalMaximumFinderPureCsIModule | Class to find connected regions, pureCsI version |
| CECLLocalRunCalibAcc | ECLLocalRunCalibAcc is the class designed to accumulate mean values, standard deviation and number of accepted events |
| CECLLocalRunCalibratorModule | ECLLocalRunCalibratorModule is the module developed to perform ECL local run calibration |
| CECLLocalRunCalibRef | ECLLocalRunCalibRef is designed to store reference marks to database for ECL local run calibration |
| CECLLocalRunCalibUnit | ECLLocalRunCalibUnit is the class designed for the control of mean value and the standard deviation accumulators |
| CECLLookupTable | Class for a lookup table |
| CECLMatchingPerformanceExpertModule | This module takes the Track collection as input and checks if one of the related ExtHits matches with an ECLCalDigit of at least 2 MeV |
| CeclMuMuECollectorModule | Calibration collector module that uses muon pairs to do ECL single crystal energy calibration |
| CECLNoiseData | Container for constant matrix used to generate electronic noise |
| CECLnOptimal | DB object to store the optimal number of crystals to be used in a cluster energy sum, and the corresponding corrections for bias and contained (raw) energy |
| CeclNOptimalCollectorModule | Collector that runs on single photon MC samples to find the number of crystals to be summed to get the best energy resolution for each test energy and for each group of crystals (8 groups per thetaID in the barrel) |
| CECLPackerModule | Module that pack's MC info into a dataformat that comes from the detector |
| CEclPainter | Painter for EclData, parent class, created with EclPainterFactory |
| CEclPainter1D | Painter for EclData, 1D histograms |
| CEclPainter2D | Painter for EclData, 2D histograms |
| CEclPainterCommon | Painter for EclData that shows common event characteristics on 1D histograms |
| CEclPainterFactory | Class that implements Factory pattern to create objects inherited from EclPainter |
| CEclPainterPolar | Painter for EclData, polar energy/event_count distribution |
| CECLPhotonEnergyResolution | Class to hold the information ECL energy resolution derived from PERC |
| CECLPidLikelihood | Container for likelihoods with ECL PID (ECLChargedPIDModule) |
| CECLPureCsIInfo | Class to store ECL crystal type relation to ECLDigit for the simulation pure CsI upgrade option filled in ecl/modules/eclDigitizer/src/ECLDigitizerPureCsIModule.cc |
| CECLReferenceCrystalPerCrateCalib | General DB object to store one reference crystal per per ECL crate for calibration purposes |
| CECLShower | Class to store ECL Showers |
| CECLShowerCorrectorLeakageCorrection | Class to hold the information for the ECL shower leakage corrections |
| CECLShowerCorrectorModule | Class to perform the shower correction |
| CECLShowerCorrectorPureCsIModule | The very same module but for PureCsI |
| CECLShowerEnergyCorrectionTemporary | Class to hold the information for the ECL shower energy corrections This is a temporary class as there is no information about phi dependence |
| ►CECLShowerShapeModule | Class to perform the shower correction |
| CProjectedECLDigit | Struct used to hold information of the digits projected to a plane perpendicular to the shower direction |
| CECLShowerShapePureCsIModule | The very same module but for PureCsI |
| CECLShowerShapeSecondMomentCorrection | Corrections to the second moment shower shape |
| CECLSimHit | ClassECLSimHit - Geant4 simulated hit for the ECL |
| CECLSplitterN1Module | Class to perform the shower correction |
| CECLSplitterN1PureCsIModule | The very same module but for PureCsI |
| CECLSplitterN2Module | Class to perform the shower correction |
| CECLSplitterN2PureCsIModule | The very same module but for PureCsI |
| CeclTimeShiftsPlottingCollectorModule | This modules looks up crystal and crate time offset constants from the database and saves them to a tree for the algorithm to plot as a function of run number |
| CECLTimeWalkCorrection | This object contain parameters of the Time-Walk correction function of the ECL |
| CECLTrackBremFinderModule | Module to assign ECL Clusters resulting from Bremsstrahlung to the primary electron track |
| CECLTrackCalDigitMatchModule | Module to find the closest ECLCalDigits to an extrapolated track |
| CECLTrackClusterMatchingModule | The module creates and saves a Relation between Tracks and ECLCluster in the DataStore |
| CECLTrackClusterMatchingParameterizations | Class to hold the parameterizations of the RMS for the difference in polar and azimuthal angle between tracks and ECL clusters |
| CECLTrackClusterMatchingParametrizationExpertModule | The module saves information on ExtHits and related cluster into a file |
| CECLTrackClusterMatchingPerformanceModule | This module takes the MCParticle collection as input and checks if the related reconstructed track is matched to an ECLCluster |
| CECLTrackClusterMatchingThresholds | Class to hold the matching thresholds for the track-ECLCluster matching |
| CECLTRGInformation | Class to store information about ECL trigger cells (TCs) |
| CECLTRGInformationModule | Module to get ECL TRG energy information |
| CECLTrig | Class to store ECLTrig, still need to be study relation to ECLHit filled in ecl/modules/eclDigitizer/src/ECLDigitizerModule.cc and ecl/modules/eclUnpacker/ECLUnpacker.cc |
| CECLTriggerCell | ECL Trigger cells |
| CECLTriggerClusterMatcherModule | Match ECLTRGClusters to ECLClusters |
| CECLTrimShowersAndDigitsModule | Create new dataobjects containing only the ECLShower and ECLCalDigits associated with the selected ECLCluster, which is the one with maximum related MC energy |
| CECLUnpackerModule | ECL unpacker module |
| CeclWaveformCalibCollectorModule | Store information needed to calculate ECL waveform template shapes |
| CECLWaveformData | ECLWaveformData - container for inverse covariant matrix and shape parameters for time and amplitude fit of ecl crystal waveform |
| CECLWaveformFitModule | Module performs offline fit for saved ECL waveforms |
| CECLWaveforms | Class to store ECL waveforms for entire calorimeter |
| CeclWaveformTemplateCalibrationC1CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CeclWaveformTemplateCalibrationC2CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CECLWFAlgoParams | Container for constant parameters used in waveform fits |
| CEcmsCollectorModule | Collector for the collision energy calibration based on the hadronic modes |
| CEffPlotsModule | This module takes the MCParticles, the RecoTracks and Tracks/V0 in input and produce a root file containing various histograms showing the efficiencies (as a function of different variables) of the V0 finding module |
| CEKLMAlignment | Class to store EKLM alignment data in the database |
| ►CEKLMAlignmentAlongStripsAlgorithm | EKLM time calibration algorithm |
| CEvent | Event: time, distance from hit to SiPM |
| CEKLMAlignmentAlongStripsCollectorModule | EKLM time calibration (data collection) |
| CEKLMAlignmentHit | This dataobject is used only for EKLM alignment |
| ►CEKLMDataCheckerModule | Module for checking of collected data |
| CStripData | Strip data information |
| CEKLMElementNumbers | EKLM element numbers |
| ►CEKLMGeometry | Class to store EKLM geometry data in the database |
| CElementPosition | Position information for the elements of detector |
| CEndcapStructureGeometry | Endcap srtucture geometry parameters |
| CPlasticSheetGeometry | Plastic sheet geometry data |
| CPoint | 2D point |
| CSectorSupportGeometry | Sector support geometry data |
| CSegmentSupportGeometry | Segment support geometry data |
| CSegmentSupportPosition | Segment support position |
| CShieldDetailGeometry | Shield layer detail geometry data |
| CShieldGeometry | Shield layer geometry data |
| CStripGeometry | Strip geometry data |
| CEKLMMeasurementCreatorFactory | Add all measurement creators related to EKLM hits |
| CEKLMSegmentAlignment | Class to store EKLM alignment data in the database |
| CElapsedTimeModule | A class definition of an input module for Sequential ROOT I/O |
| CElectronValCollectorModule | A collector module for CDC dE/dx electron calibrations |
| CEnergyBiasCorrectionModule | Energy bias correction |
| CEnum | |
| 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> |
| CERecoDistributor | |
| CERecoEventProcessor | |
| CERecoEventSampler | |
| CERecoMaster | |
| CERecoMasterCallback | |
| CERecoRunControlCallback | |
| CERRORNo | |
| Cevent_header | |
| ►CEventBuffer | |
| CHeader | |
| 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 |
| CEventInfoExtractor | Class to extract results from qualityEstimation |
| 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 |
| CEventSampler | |
| CEventServer | |
| CEventServerCallback | |
| 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 |
| CEventsOfDoomBusterModule | Module that flags an event destined for doom at reconstruction, based on the size of selected hits/digits containers after the unpacking |
| CEventsOfDoomParameters | DBObject containing parameters used in EventsOfDoomBuster module |
| ►CEventT0 | Storage element for the eventwise T0 estimation |
| CEventT0Component | Structure for storing the extracted event t0s together with its detector and its uncertainty |
| CEventT0CombinerModule | Module to combine the EventT0 values from multiple sub-detectors |
| CEventT0DQMModule | This module to design collect the event t0 values base on different detectors and physics processes |
| CEventT0GeneratorModule | Module generates discrete event t0 in ~4ns steps (bunch spacing) according to (double) gaussian distribution and adds it to the production and decay times of MCParticles |
| CEventT0ShifterModule | Module that shifts the time of all MCParticles so that the collision is at t=0 |
| CEventT0ValidationModule | This module to design collect the event t0 values base on different detectors and physics processes |
| CEveTower | Handles selection of individual ECLClusters (getting them out of TEve is hard) |
| CEveVisBField | Provide magnetic field values for TEveTrackPropagator |
| ►CEVEVisualization | Produces visualisation for MCParticles, simhits, genfit::Tracks, geometry and other things |
| CElementGroup | Group of TEveElements, remembers whether user wants it visible or not |
| CMCTrack | Hold MC tracks and associated visualisation objects |
| CEvReductionModule | A class definition of an input module for Sequential ROOT I/O |
| CEvtB0toKsKK | Register Decay model EvtB0toKsKK |
| CEvtBCL | The class provides the form factors for orbitally excited semileptonic decays |
| CEvtBCLFF | BCL Form Factors |
| CEvtBSemiTauonic | The EvtGen model of semi-tauonic B decays including new physics effects based on [M |
| CEvtBSemiTauonic2HDMType2 | The EvtGen model of semi-tauonic B decays including the charged higgs effect of 2HDM Type2 based on [M |
| CEvtBSemiTauonicAmplitude | The base class for the calculation of the spin dependent amplitudes for the BSemiTauonic model based on [M |
| CEvtBSemiTauonicDecayRateCalculator | Class to calculate the differential decay rate, R(D), R(D*), polarizations of tau and D* using BSTD model based on [M |
| CEvtBSemiTauonicHelicityAmplitudeCalculator | The class calculates the helicity amplitude of semi-tauonic B decays including new physics effects based on [M |
| CEvtBSemiTauonicScalarMesonAmplitude | The class calculates the spin dependent amplitudes of B->Dtaunu decays for the BSemiTauonic model based on [M |
| CEvtBSemiTauonicVectorMesonAmplitude | The class calculates the spin dependent amplitudes of B->D*taunu decays for the BSemiTauonic model based on [M |
| CEvtBtoXsnunu_FERMI | The evtgen model to produce non-resonant B-> Xs nu nubar decay sample |
| CEvtBuffer | |
| CEvtEtaFullDalitz | Class for the simulation of the eta -> pi+pi-pi0 decay with an improved dalitz description |
| CEvtEtaPi0Dalitz | Class for the simulation of the eta -> 3pi0 and eta'->3pi0 decays |
| CEvtEtaPrimeDalitz | Class for the simulation of the eta' -> pi+ pi- eta and pi0 pi0 eta decays |
| CEvtFlatDaughter | The evtgen model to produce flat invariant mass distribution for 2nd and 3rd daughters |
| CEvtGenDatabasePDG | Replacement for TDatabasePDG that is filled from EvtGen's evt.pdl |
| CEvtGenDecayModule | This module decays unstable particles using EvtGen |
| CEvtGenInputModule | The EvtGenInput module |
| CEvtGenInterface | Class to interface EvtGen |
| ►CEvtGenModelRegister | Class to keep a register of all Belle2 EvtDecayBases |
| CFactory | Helper Class to easily register new EvtDecayBases for Belle2 |
| CEvtGenParticlePDG | Helper class for setting additional TParticlePDG members and storing the ones it doesn't have yet |
| CEvtHeader | Header structure of streamed object list |
| CEvtKnunu | The evtgen model to produce B-> K nu nubar decay sample |
| CEvtKstarnunu_REV | The evtgen model to produce B-> Kstar nu nubar decay sample |
| CEvtMessage | Class to manage streamed object |
| CEvtPhspCP | Register Decay model EvtPhspCP |
| CEvtSocketManager | |
| CEvtSocketRecv | |
| CEvtSocketSend | |
| CException | |
| CExecutor | |
| CExporterEventInfo | Bundles information for a single event to be stored by NonRootDataExportModule |
| CExporterHitInfo | Bundles information for a single hit to be stored by EventInfo (needed for HitExporter, which is needed by NonRootDataExportModule) |
| CExporterTcInfo | Bundles information for a single track candidate to be stored by EventInfo (needed for HitExporter, which is needed by NonRootDataExportModule) |
| CExportGeometryModule | The ExportGeometry module |
| CExpRun | Struct containing exp number and run number |
| CExpRunEvt | Struct with expNum, runNum, evtNum |
| CExtHit | Store one Ext hit as a ROOT object |
| CExtModule | The geant4e-based track extrapolation 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 |
| CExtrapolateAndUpdateCDCStateFilter | An extrapolateAndUpdate filter for all CDC states |
| CExtState | Data structure to define extrapolation state |
| CFANGSHit | ClassFANGSHit - digitization simulated hit for the FANGS detector |
| CFANGSSimHit | Class FANGSSimHit - Geant4 simulated hit for the FANGS detector |
| CFarBeamLineGeo | Geometry parameters of far beam line |
| CFastBDTClassifierAnalyzerModule | Module to evaluate a trained fastBDT |
| CFastBDTClassifierTrainingModule | Module for collecting the data and training a FastBDT classifier |
| CFastInterceptFinder2DFPGA | Findlet for finging intersections of sinosoidal curves in the 2D Hough space by iteratively calling fastInterceptFinder2d |
| CFastRbuf2DsModule | A class definition of an input module for Sequential ROOT I/O |
| CFBDTClassifier | FastBDT as RelationsObject to make it storable and accessible on/via the DataStore |
| CFBDTTrainSample | Bundle together the classifier input and the target value into one struct for easier passing around |
| CFBXWriterModule | The FBX-writer module |
| CFifo | |
| CFile | |
| CFileCatalog | This class provides an interface to the file (metadata) catalog |
| CFileDescriptor | |
| CFileMetaData | Metadata information about a file |
| CFileReader | |
| ►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 |
| CFileWriter | |
| CFillTrackFitNtupleModule | This module takes the Tracks and the RecoTrack input and produce a root file containing an nutple showing the track fit members in parallel for different particle hypotheses |
| CFilter | This class is used to select pairs, triplets... of objects |
| CFilter< Belle2::OperatorAnd, FilterA, FilterB, templateObserverType > | Realization of the AND operator between two objects of the Filter class |
| CFilter< Belle2::OperatorNot, someFilter, templateObserverType > | Realization of a NOT operator for the Filter classes |
| CFilter< Belle2::OperatorOr, FilterA, FilterB, templateObserverType > | Realization of the OR operator between two objects of the Filter class |
| CFilter< Variable, RangeType, Belle2::ActivatableFilter, Observer > | Activatable Filter /// TODO: Remove, as it is no longer used...? |
| CFilter< Variable, RangeType, Belle2::BypassableFilter, Observer > | Bypassable Filter /// |
| CFilter< Variable, RangeType, Observer > | Basic Filter /// |
| CFilterBase | FilterBase is the baseClass for filters applied on (chains of) spacepoints |
| CFilterExceptions | Exception which are thrown by members of the FilterClasses |
| CFilterID | Class to identify a filter type used by sectorFriends |
| CFilterInfo | Helper class to store the information for a Filter |
| ►CFilterMill | Small class which stores the filters/selectionVariables to be used for a secMap and has an interface for applying them |
| CHitPair | Small struct containing pointers to two hits |
| CHitQuadruplet | Small struct containing pointers to four hits |
| CHitTriplet | Small struct containing pointers to three hits |
| CFiltersContainer | This class contains everything needed by the VXDTF that is not going to change during a RUN, i.e |
| CFilterValueDataSet | Relevant information needed for filling a TTree containing train-data for the secMap |
| CFittedTracksStorerModule | A module to copy only the fitted reco tracks to the output store array |
| 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 |
| CFlippedRecoTracksMergerModule | Module to merge the original and flipped RecoTracks |
| CFlipQualityModule | This module can be used for applying the MVA filters and get the 2 flipping QIs |
| CFlipRecoTrackExtractor | Class to extract results from qualityEstimation |
| CFlipRecoTrackExtractor2nd | Class to extract results from qualityEstimation |
| CFlowMonitor | |
| CFork | |
| 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 |
| CFourHitFilters | The class 'FourHitFilters' bundles filter methods using 4 hits which are stored in B2Vector3Ds |
| CFoxWolfram | Class to calculate the Fox-Wolfram moments up to order 8 |
| CFragmentationModule | The Fragmentation module |
| CFragmentationRndm | Minimal class for external random generator to be used in PYTHIA |
| CFramework | This class combines all subsystems of the framework, and exports the main interface to Python |
| CFullGridChi2TrackTimeExtractor | Class to extract the event t0 using the chi-squared approach |
| CFullGridChi2TrackTimeExtractorModule | Module implementation using only the chi2 |
| CFullGridDriftLengthTrackTimeExtractor | Class to extract the event t0 using the drift-length approach |
| CFullGridDriftLengthTrackTimeExtractorModule | Module implementation using the drift length and the chi2 |
| CFullSecID | Class to identify a sector inside of the VXD |
| CFullSimModule | The full Geant4 simulation module |
| CFullSimTimingModule | Provide more detailed timing info for FullSim module |
| CFunctionNode | FunctionNode Node class for handling MetaVariables in cuts |
| CG4LongLivedNeutral | A class to hold long-lived neutral particle description |
| CG4LongLivedNeutralDecay | This class is a decay process |
| CG4LongLivedNeutralPhysics | LongLivedNeutral physics Class – to be registered in the physics list |
| CG4LongLivedNeutralTransportation | Concrete class that does the geometrical transport |
| CG4SafeNavigator | Guards against leaving the physical volume |
| CG4TriangularPrism | Triangular prism |
| CGblMultipleScatteringController | TrackSegmentController for use with GblFitter in Belle2 |
| CGeant4MaterialInterface | AbsMaterialInterface implementation for use with Geant4's navigator |
| CGeant4MaterialInterfaceExceptioHandler | This class implements a custom exception handler for Geant4 which is used to record whether a critical exception occurred when calling the G4Navigator |
| ►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 |
| CGeneralVector | 3-vector with members of arbitrary type, especially members can be dual numbers |
| CGeneratedVertexDisplacerModule | "Takes a list of PDG values and lifetime parameters to displaces the vertex of MCParticles with matching PDG value and their subsequent daughters corresponding to the given lifetime parameter(s). Can be used between the generator and the detector simulation. Lifetime options are "flat", "fixed" and "exponential" where the lifetime(s) should be passed as c*tau in units of [cm]. Furthermore, a "fixedLength" option can be used where the lifetime parameter takes the desired fixed decaylength in units of [cm] |
| CGeneratorBaseModule | The base module for generator modules, which sets the generator information as EventExtraInfo |
| CGeneratorPreselectionLeptonicModule | Generator filtering |
| CGeneratorPreselectionModule | Generator preselection |
| CGenericLockGuard | Lock Guard for a Mutex instance |
| CGenfitVisModule | Visualize genfit::Tracks using the genfit::EventDisplay |
| CGenRawSendModule | |
| 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 |
| CGeoVXDRadiationSensors | Class to create the diamond radiation sensor geometry if defined |
| CGetArcLength | Helper Functor to get the arc length of a given result |
| CGetEventFromSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CGFTC2SPTCConverterModule | Module for converting genfit::TrackCands to SpacePointTrackCands |
| ►CGlobalLabel | Class to convert to/from global labels for Millepede II to/from detector & parameter identificators |
| CTimeInterval | Struct to hold intervals of validity |
| CGlobalNames | Bundles filter methods using 2 hits |
| CGlobalProcHandler | A class to manage processes for parallel processing |
| CGridEventTimeExtractor | Generic findlet applying a certain time extractor multiple times |
| CGRLMLP | Class to keep all parameters of an expert MLP for the neuro trigger |
| CGRLMLPData | Struct for training data of a single MLP for the neuro trigger |
| ►CGRLNeuro | Class to represent the GRL Neuro |
| CParameters | Struct to keep neurotrigger parameters |
| CGRLNeuroModule | The module for application of the neural networks of the GRL |
| CGRLNeuroTrainerModule | The trainer module for the neural networks of the CDC trigger |
| CHadronBgPrep | Class to prepare sample for fitting in beta gamma bins |
| CHadronCalibration | Class to perform the fitting in beta gamma bins |
| CHadronPrep | Class to prepare sample for hadron saturation calibration |
| CHadronSaturation | Class to perform the hadron saturation calibration |
| 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 |
| CHE3G4TrackInfo | Class HE3G4TrackInfo - Geant4 simulated hit for the Microtpc detector |
| CHe3MCParticle | Class He3MCParticle - Geant4 simulated hit for the Microtpc detector |
| CHe3tubeHit | ClassHe3Hit - digitization simulated hit for the He3tube detector |
| CHe3tubeSimHit | ClassHe3tubeSimHit - Geant4 simulated hit for the He3tube detector |
| CHeavyMetalShieldGeometryPar | The Class for VXD Heavy Metal Shield |
| CHelix | This class represents an ideal helix in perigee parameterization |
| CHelixErrorScalerModule | Scale the error of helix parameters |
| CHelixHelper | Helper class representing a helical track |
| CHELIXPARAMETERFIT_NAME | Calculates the helixparameter describing the deviation in z per unit angle, returning unit: none |
| CHepevtInputModule | The HepevtInput module |
| CHepevtOutputModule | The HepevtOutput module |
| CHepevtReader | Class to read Hepevt files and store the content in a MCParticle graph |
| CHepMCInputModule | The HepMCInput module |
| CHepMCOutputModule | The HepMCOutput module |
| CHepMCReader | Class to read HepMC files and store the content in a MCParticle graph |
| CHexDataPackerModule | Module to store dummy data in RawCOPPER object |
| CHistDelta | Class to keep track of delta histograms |
| CHistObject | Class to keep track of delta histograms |
| CHistogramMapping | Utility to store received histograms (hierarchical tree structures) from clients (as an event message), with a function to add multiple histogram trees together |
| CHistoManager | |
| CHistoManager2 | |
| 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 |
| CHistoRelay | |
| CHistoRelay2 | |
| CHistoServer | |
| CHistoServer2 | |
| CHit | Structure to hold some of the calpulse data |
| CHitBasedT0Extractor | Findlet to extract the T0 time of an event only using CDC Hits |
| CHitDistanceBasedCDCPathPairFilter | Prefers path with smallest sum dist^2 / length of path |
| CHitInfo | Struct containing the track segment (hit) information from the Track Segment Finder (TSF) |
| CHitInfoExtractor | Class to extract info from individual clusters and combine for SPTC |
| CHitLevelInfoWriterModule | Extracts dE/dx information for calibration testing |
| CHitPatternCDC | Hit pattern of CDC hits within a track |
| CHitPatternVXD | Hit pattern of the VXD within a track |
| ►ChitXP | This class collects some information of a TrueHit, using SVDCLuster and MCParticle information too |
| CtimeCompare | This structure allows to compare times of 2 hitXP point input (first hit, second hit) output (boolean: true if time of the hit1< time of hit2) |
| ChitXPDerivate | This class is the derivate of HitXP, and complete it with a constructor that use all other complex types (classes) of basf2 |
| CHitXPModule | This module from a data root file builds a tree of hitXP (see the class to know all the information contained) |
| CHLTDQM2ZMQModule | Module to collect DQM histograms (written out by HistoModules) and send them every time period to a running ZMQ DQM server (either a finalhistoserver or a proxyhistorver) |
| CHLTDs2ZMQModule | On every event, serialize the data store and send the binary data out to the connected ZMQ application (most likely a collector or final collector) |
| CHLTDs2ZMQRawModule | On every event, serialize the data store and send the binary data out to the connected ZMQ application (most likely a collector or final collector) |
| CHLTEventProcessor | EventProcessor to be used on the HLT with all specialities of the HLT processing: |
| CHLTFile | |
| CHLTMainLoop | |
| CHLTPrefilterModule | Prefilter module to suppress the injection background |
| CHLTPrefilterParameters | DBObject containing parameters used in HLTprefilter module |
| CHLTSocket | |
| CHLTStreamHelper | Helper class for data store serialization |
| CHLTZMQ2DsDirectModule | Special ZMQ2Ds module without the HLT-specific handling of initialization and begin/end run |
| CHLTZMQ2DsModule | Input module in the ZMQ reconstruction path receiving events via ZMQ and deserializing the to the data store |
| CHMatrixQP | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CHopfieldNetwork | Hopfield Algorithm with number based inputs |
| CHtmlClassInspector | Pass to TObject::ShowMembers() to get tabular view of object data |
| 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 |
| CInclusiveParticleCheckerModule | Check for the existence of an inclusive particle in the list of generated particles |
| ►CInfoWidget | Text-based info viewer showing DataStore contents |
| CURI | Parsed URI |
| CInitialParticleGeneration | Generate Collision |
| CInMessage | Reusable Message class derived from TMessage (for reading only) |
| CInotify | |
| CInotifyEvent | |
| 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() |
| CInterceptDistancePXDPairFilter | Base filter for CKF PXD states |
| CIntersection | Intersection of muid-extrapolated track with a KLM layer |
| 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 |
| CInvariantMassAlgorithm | Class implementing InvariantMass calibration algorithm |
| CIOException | |
| CIOInfo | |
| CIoVDependentConditionModule | Module which sets its return value based on the fact, if the event is in the given run/exp interval or not |
| CIPDQMModule | This Module, made for monitors the position and the size of the interaction point using mu+mu- events |
| CIPTrackTimeEstimatorModule | Base Module estimating the track time of RecoTracks - before or after the fit |
| CIRGeoBase | Base class for IR geometry parameters |
| CIRSimHit | Class for saving raw hit data of the IR |
| CIterativeChi2BasedEventTimeExtractor | Class to iteratively extract the event t0 using the chi-squared approach |
| CIterativeDriftLengthBasedEventTimeExtractor | Class to iteratively extract the event t0 using the drift-length approach |
| CIterativeEventTimeExtractor | Generic findlet applying a certain time extractor multiple times |
| CKalmanFilter | Filter which can be used on a pair of path (vector of states) and states, which will call the kalmanStep function of the given stepper class, to update the mSoP of the new state with a klaman update |
| CKalmanRecoFitterModule | Kalman fitter |
| CKalmanStepper | Class to bundle all algorithms needed for the kalman update procedure |
| CKeyValBox | Minimal container storing a pair of < KeyType, ValueType> |
| CKeyValuePrinter | Create human-readable or JSON output for key value pairs |
| CKink | Object holding information for Kinks |
| ►CKinkFinderModule | Kink finder module |
| CCDCForwardBackwardWallLine | Structure to store the information about forward and backward walls of CDC |
| CKinkFinderParameters | The payload containing the parameters for the kinkFinder |
| CKinkFitter | KinkFitter class to create Kink mdst's objects from reconstructed tracks |
| CKKGenInputModule | The KKGenInput module |
| CKKGenInterface | Interface class for using the KKMC generator |
| CKlId | Klong identification (KlId) datastore object to store results from KlId calculations |
| CKLMAlignmentData | KLM Alignment data |
| CKLMCalibrationChecker | KLM calibration checker |
| CKLMChannelArrayIndex | KLM channel array index |
| CKLMChannelIndex | KLM channel index |
| CKLMChannelMapValue | KLM channel map |
| CKLMChannelStatus | KLM channel status |
| ►CKLMChannelStatusAlgorithm | KLM channel status calibration algorithm |
| CResults | Calibration results |
| CKLMChannelStatusCollectorModule | KLM channel status calibration (data collection) |
| CKLMCluster | KLM cluster data |
| CKLMClusterAnaModule | Module for KLM cluster reconstruction efficiency studies |
| CKLMClusterEfficiencyModule | Module for KLM cluster reconstruction efficiency studies |
| CKLMClusterShape | Variable for KLM cluster shape analysis |
| CKLMClustersReconstructorModule | Module KLMClustersReconstructorModule |
| CKLMDatabaseImporter | KLM database importer |
| CKLMDigit | KLM digit (class representing a digitized hit in RPCs or scintillators) |
| CKLMDigitEventInfo | Class to store debugging information from the unpacker (event based) |
| CKLMDigitizerModule | KLM digitization module |
| CKLMDigitRaw | Class to store the raw words from the unpacker, digit-by-digit |
| CKLMDigitTimeShifterModule | KLM digit time shifter module |
| CKLMDisplacementGenerator | Module for generation of KLM displacement or alignment data |
| ►CKLMDQM2Module | Additional Module for KLMDQM plots after HLT filters |
| CHitData | Hit data |
| CKLMDQMModule | KLM data quality monitor module |
| CKLMElectronicsChannel | BKLM electronics channel |
| CKLMElectronicsMap | BKLM electronics map |
| CKLMElectronicsMapImporter | KLM database importer |
| CKLMElementArrayIndex | KLM element array index |
| CKLMElementNumbers | KLM element numbers |
| CKLMExpertModule | Module to perform the KLM KlId classification |
| CKLMHit2d | KLM 2d hit |
| CKLMLikelihoodParameters | Database object used to store the parameters for KLM likelihood computation |
| CKLMLikelihoodParametersImporter | This class imports KLMLikelihoodParameters into the database |
| CKLMModuleArrayIndex | KLM module array index |
| CKLMMuidHit | Store one muon-identification hit in the KLM as a ROOT object |
| CKLMMuidLikelihood | Class to store the likelihoods from KLM with additional information related to the extrapolation |
| CKLMMuonIDDNNExpertModule | KLMMuonIDDNNExpert for calculating Neural Network based muonID |
| CKLMMuonIDDNNInputVariable | KLM MuonID DNN input variables datastore object to store the input variables for retraining KLMMuonIDDNNExpertModule |
| CKLMPackerModule | KLM raw packer |
| CKLMPlaneArrayIndex | KLM plane array index |
| CKLMReconstructionParameters | Class to store KLM reconstruction parameters in the database |
| CKLMReconstructorModule | Create BKLMHit1ds from BKLMDigits and then create KLMHit2ds from BKLMHit1ds; create KLMHit2ds from EKLMDigits |
| CKLMScintillatorDigitizationParameters | Class to store KLM scintillator simulation parameters in the database |
| CKLMScintillatorFEEData | EKLM channel data |
| CKLMScintillatorFEEParameters | Class to store EKLM alignment data in the database |
| CKLMScintillatorFirmware | KLM scintillator firmware |
| CKLMScintillatorFirmwareFitResult | FPGA fit simulation data |
| CKLMScintillatorSimulatorModule | Module KLMScintillatorSimulatorModule |
| CKLMSectorArrayIndex | KLM sector array index |
| CKLMSimHit | KLM simulation hit |
| CKLMStripEfficiency | DBObject used to store the efficiencies of KLM strips |
| ►CKLMStripEfficiencyAlgorithm | KLM channel status calibration algorithm |
| CResults | Calibration results or supplementary results calculated from the input data |
| ►CKLMStripEfficiencyCollectorModule | Module KLMStripEfficiencyCollectorModule |
| CHitData | Hit data |
| CKLMTime | KLM time conversion |
| ►CKLMTimeAlgorithm | KLM time calibration algorithm |
| CEvent | Event data |
| CKLMTimeCableDelay | Class to store BKLM delay time coused by cable in the database |
| CKLMTimeCollectorModule | Collect hit information for KLM time calibration with CAF |
| CKLMTimeConstants | Class to store KLM constants related to time |
| CKLMTimeConversion | KLM time conversion |
| CKLMTimeResolution | Class to store KLM time resolution in the database |
| CKLMTimeWindow | DBObject containing KLM time window parameters used in KLMReconstructor module |
| CKLMTrack | Store one KLM Track as a ROOT object |
| CKLMTrackFinder | Track finding procedure |
| CKLMTrackFitter | Track fitting procedure |
| CKLMTrackingModule | This module perform straight line track finding and fitting for BKLM/EKLM |
| CKLMTrgFittedTrack | Store KLM TRG track information as a ROOT object |
| CklmtrgLayerCounter | |
| CklmtrgLinearFit | |
| CKLMTrgSummary | Store KLM TRG track information as a ROOT object |
| CKLMTriggerModule | |
| CKLMTriggerParameters | DBObject containing parameters used in KLMTrigger module |
| CKLMUnpackerModule | KLM unpacker |
| 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 |
| CKlongValidationModule | Module used by the validation server to generate root files for the validation |
| CKoralW | C++ interface for the FORTRAN 4-fermion final state generator KoralW |
| CKoralWInputModule | The KoralW Generator module |
| 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 |
| CLayerPXDRelationFilter | Base filter for CKF PXD states |
| CLayerSVDRelationFilter | Base filter for CKF SVD states |
| CLayerToggledApplier | A special findlet, which is chooseable based on a given findlet for layers higher than N, N and for the rest |
| CLHEInputModule | The LHEInput module |
| CLHEReader | Class to read LHE files and store the content in a MCParticle graph |
| CLimitedOnStateApplier | Specialisation of the OnStateApplier, which (a) uses a filter for the () operator, which is configurable (b) does only allow for the best N candidates in the child states |
| CLinear_fit_of_Hits_t | |
| 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 |
| CLogFile | |
| CLogListener | |
| ►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 |
| CLoosePXDPairFilter | Base filter for CKF PXD states |
| CLooseSVDPairFilter | Base filter for CKF SVD states |
| CLowEnergyPi0IdentificationExpertModule | Calculation of low-energy pi0 identification value |
| CLowEnergyPi0VetoExpertModule | Calculation of low-energy pi0 veto value |
| CLowerBoundedSet | Represents a lower bounded set of arithmetic types |
| 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 |
| CMakeDumHSLBDataModule | Module to make a binary file from Raw*** events for input of wirte-dumhsbx |
| 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 |
| CMasterClassModule | Module to write out data in a format for Belle II masterclasses |
| ►CMaterialScan2D | Base class to create a Material Scan of the detector geometry |
| CScanParams | Helper struct to Store Parameters of a Scan |
| CMaterialScanBase | Base class for Material Scans |
| CMaterialScanModule | The MaterialScan module |
| CMaterialScanPlanar | Specific implementation of MaterialScan to scan parallel to a given plane |
| CMaterialScanRay | MaterialScan implementation to shoot one ray along a defined direction and record the Material as a function of travel depth |
| CMaterialScanSpherical | Specific implementation of MaterialScan to do Spherical scanning |
| CMCDecayFinderModule | Find decays in MCParticle list matching a given DecayString |
| CMCInitialParticles | This class contains the initial state for the given event |
| CMCMatcherECLClustersModule | Class to represent the hit of one cell |
| CMCMatcherECLClustersPureCsIModule | Same module but for pure CsI |
| CMCMatcherKLMClustersModule | Module for MC matching for KLM clusters |
| 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 |
| CMCMatcherTRGECLModule | Class to represent the hit of one cell |
| CMCMatching | Functions to perform Monte Carlo matching for reconstructed Particles |
| CMCond | |
| 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 |
| CMCParticleInfo | This struct is used by the TrackingPerformanceEvaluation Module to save information of reconstructed tracks |
| CMCParticleTrajectory | Class to save the full simulated trajectory of a particle |
| CMCPXDROICreatorModule | The MCPXDROICreatorModule module Create artificial ROI just for PXDDigits from either all charged primary MCParticles or slow pions from D* decays on MC information |
| CMCRecoTracksMatcherModule | This module compares tracks generated by some pattern recognition algorithm for PXD, SVD and CDC to ideal Monte Carlo tracks and performs a matching from the former to the underlying MCParticles |
| CMCRelationCreatorModule | Module to combine RecoTracks |
| CMCTrackCandClassifierModule | The MCTrackCandClassifier Definition Module |
| CMCTrajectoryPoint | Small struct to encode a position/momentum without additional overhead |
| CMCTruthCDCPathPairFilter | For the two paths select the one with the most of MC matched hits |
| CMCTruthCDCStateFilter | Give a weight based on the mc truth information (1 or NAN) |
| CMCTruthEclSeedFilter | Give a weight based on the mc truth information (1 or NAN) |
| CMCUtil | Class bundling all helper functions for the MC information used in the PXD CKF |
| CMCV0MatcherModule | A module matching the V0s from the mcV0Matcher to MC particles |
| CMCVXDCDCTrackMergerFindlet | Findlet for merging VXD and CDC tracks with MC information |
| CMCVXDCDCTrackMergerModule | This module merges tracks which are reconstructed, separately, in the silicon (PXD+VXD) and in the CDC using MC |
| CMCVXDPurityInfo | The MC VXD Purity info container class |
| CMdstPIDModule | Module to fill PIDLikelihoods |
| CMeasurementAdder | Algorithm class to translate the added detector hits (e.g |
| CMeasurementCreatorFactory | This is the base class for all MeasurementCreatorFactories used in the MeasurementCreatorModule |
| 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 |
| CMergeableNamed | Abstract base class for objects that can be merged but also named |
| 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 |
| CMerger | Unpacker for the merger reader (TSF which reads the merger output) |
| CMergerCosmicTracksModule | Module use to select two cosmic tracks event and merger these two tracks become one |
| CMetadataService | This class provides a service for writing metadata about the basf2 execution and about output files to a json file |
| CMicrotpcDataHit | ClassMicrotpcDataHit - digitization simulated datahit for the Microtpc detector |
| CMicrotpcHit | ClassMicrotpcHit - digitization simulated hit for the Microtpc detector |
| CMicrotpcMetaEDataHit | ClassMicrotpcDataHit - digitization simulated datahit for the Microtpc detector |
| CMicrotpcMetaHit | ClassMicrotpcMetaHit - digitization simulated metahit for the Microtpc detector |
| CMicrotpcRecoTrack | ClassMicrotpcRecoTrack - fit tracks after the digitization |
| CMicrotpcSimHit | ClassMicrotpcSimHit - Geant4 simulated hit for the Microtpc detector |
| CMilleData | Mergeable class holding list of so far opened mille binaries and providing the binaries |
| CMillepedeAlgorithm | Class implementing Millepede calibration algorithm |
| CMillepedeCollectorModule | Calibration data collector for Millepede Algorithm |
| CMillepedeTreeConversionAlgorithm | Creation of a plain TTree with residual and global derivative values from GBL data saved to a ROOT file |
| CMinMax | Small class for storing min and max |
| CMinMaxCollector | A container for collecting data, where min- and max-quantiles near q(0) and q(1) are to be found |
| CMLHANDOVER_NAME | SelectionVariable that is used for the Machine Learning (ML) based filters |
| CMLRange | Range used for the Machine Learning assisted TrackFinding approach |
| CMLSegmentNetworkProducerModule | Segment network producer module with a Machine Learning classifier |
| CMMutex | |
| 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 |
| CMonitorDataCOPPERModule | A class definition of an input module for Sequential ROOT I/O |
| CMonitorDataModule | A class definition of an input module for Sequential ROOT I/O |
| CMonitorDB | |
| CMonitoringObject | MonitoringObject is a basic object to hold data for the run-dependency monitoring Run summary TCanvases and monitoring variables |
| CMRUCache | Class implementing a generic Most Recently Used cache |
| CMsgHandler | A class to encode/decode an EvtMessage |
| CMuidBuilder | Build the Muid likelihoods starting from the hit pattern and the transverse scattering in the KLM |
| CMuidElementNumbers | Muid element numbers |
| CMuidModule | The geant4e-based muon identification module |
| CMuidProb | Class computes probability density for Muid calculation |
| CMultilineWidget | Widget which contains the dynamic amount of TGLabel objects |
| CMultivariateNormalGenerator | Class to generate normal distributed, correlated random numbers given the mean values and the covariance matrix of all dimensions |
| CMutex | |
| CMVAExpert | Class to interact with the MVA package, based on class with same name in CDC package |
| 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 |
| CNamed | A mixin class to attach a name to an object. Based on class with same name in CDC package |
| ►CNDFinder | Class to represent the CDC NDFinder |
| CContributionInfo | Collection of the hit contribution information needed for the hit to cluster relations |
| CSectorBinning | Data type to collect a binning |
| CWireInfo | Collection of the hit information needed for the hit representations |
| CNDFinderParameters | Struct of NDFinder parameters |
| CNDFinderTrack | Class for a found NDFinder track |
| CNeuro | Unpacker for the Neuro |
| ►CNeuroTrigger | Class to represent the CDC Neurotrigger |
| CParameters | Struct to keep neurotrigger parameters |
| CNeuroTriggerParameters | |
| 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 |
| ►CNewV0Fitter | Improved V0 fitter class |
| CFittedTrack | Structure to save track data of the last successful iteration |
| CNNTParam | Class to represent a complete set to describe a Neurotrigger |
| CNodeCompatibilityCheckerBase | Most trivial node compatibility checker, says always true |
| CNodeCompatibilityCheckerCA | Simple NodeCompatibilityChecker, which checks for compatible Neighboring states of passed nodes (does no extended validation check) |
| CNodeCompatibilityCheckerPathCollector | Simple NodeCompatibilityChecker, which checks for compatible Neighboring states of passed nodes (does no extended validation check) |
| CNodeFactory | Wrapper class for static node compile functions |
| CNodeFamilyDefiner | This class assigns a common family identifier to all CACells in the network that are connected |
| CNoKickCuts | This class is an auxiliary class that implement methods to access to a single cut, used in NoKickRTSel class |
| CNoKickCutsEvalModule | This module evaluate the cuts used to select the training sample of the SectorMap |
| CNoKickRTSel | This class implement some methods useful for the application of cuts evaluated in NoKickCutsEval module |
| CNonIPCrossingStateFilter | Reusable filter for checking the direction of a new state if it is in the correct orientation (forwards or backwards) by their arc length |
| CNSMCallback | |
| CNSMCommand | |
| CNSMCommunicator | |
| ►CNSMData | |
| CNameValue | |
| ►CNSMDataPaket | |
| CHeader | |
| ►CNSMDataStore | |
| CEntry | |
| CHeader | |
| CNSMHandlerException | |
| CNSMMessage | |
| CNSMNode | |
| CNSMNodeDaemon | |
| CNSMNotConnectedException | |
| CNSMState | |
| CNSMVar | |
| CNSMVHandler | |
| CNSMVHandlerFloat | |
| CNSMVHandlerFloatArray | |
| CNSMVHandlerInt | |
| CNSMVHandlerIntArray | |
| CNSMVHandlerRef | |
| CNSMVHandlerText | |
| CNtuplePhase1_v6Module | Read SKB PVs, simulated measurements of BEAST sensors, and write scaled simulated Ntuple in BEAST phase 1 data format |
| CNumberOfHitsGetter | Helper Functor to get the Number of hits of a given result |
| CObjArrayIterator | Optimizes class to iterate over TObjArray and classes inheriting from it |
| CObserver | Observer base class which can be used to evaluate the VXDTF2's Filters |
| CObserver3HitPrintResults | This observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning(if failed) or as an Info (if succeeded) |
| CObserverCheckFilters | This observer searches logs the response for each of SelectionVariables used in the filters If the pointer to the StoreArray is set the results will be put into the datastore |
| CObserverCheckMCPurity | This observer searches for mcParticles attached to the hits given and stores the information found to be retrieved later |
| CObserverInfo | Helper class that stores the information an Observer stores: i.e |
| CObserverPrintResults | This observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning(if failed) or as an Info (if succeeded) |
| COnlineEventT0 | Storage element for the eventwise T0 estimation computed on HLT |
| COnlineEventT0CreatorModule | Module to write the EventT0s computed on the online systems (HLT) |
| COnlyWriteOutParticleListsModule | Marks all objects in DataStore except those of type ParticleList as WrtieOut=False |
| ►CONSENBinData | |
| Csose_frame_t | |
| COnStateApplier | Helper findlet which applies its () operator to all pairs of path and state with all states in the given child state list |
| COpticalGunModule | Source of optical photons for the simulation of the TOP laser system |
| 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 |
| COverlapMatrixCreator | Creates a vector of vectors, that knows which track is conflicting with which other |
| COverlapNetwork | Hold information about overlap of SpacePointTrackCand |
| COverlapResidualsModule | The module studies VXD hits from overlapping sensors of a same VXD layer |
| COverlapResolver | Simple findlet for searching the best candidate for a given seed applying the given filter |
| COverlapResolverNodeInfo | Struct for holding information needed by overlap resolving algorithms for one node |
| COverrideGenerationFlagsModule | Override generation flags |
| CPackedAutoCovariance | Packed covariance matrix |
| CPairGenModule | The PairGen module |
| CParallelTrackFilterModule | Generates a new StoreArray from the input StoreArray which contains only tracks that meet the specified criteria |
| CPartialSelectModule | The PartialSelect module |
| CPartialSeqRootReaderModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| ►CParticleGun | Class to generate tracks in the particle gun and store them in a MCParticle graph |
| CParameters | Struct to keep all necessary parameters for the particle gun |
| CParticleGunModule | The ParticleGun module |
| 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 |
| CParticleProperties | This struct is used by the StandardTrackingPerformanceModule to save information of reconstructed tracks |
| 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 |
| CPathCollectorRecursive | Path finder for generic ContainerType |
| 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 |
| CPedeSteering | Class representing Millepede steering |
| CPerformanceEvaluationBaseClass | This module takes the MCParticles, the genfit Tracks, the genfit TrackCand, and the MCTrackCands input and produce a root file containing various histograms showing the performance of the tracking package: fitter, pattern recognition algorithms |
| CpEventProcessor | This class provides the core event processing loop for parallel processing |
| CPh1bpipeSimHit | ClassPh1bpipeSimHit - Geant4 simulated hit for the Ph1bpipe detector |
| CPh1sustrSimHit | ClassPh1sustrSimHit - Geant4 simulated hit for the Ph1sustr detector |
| ►CPhaseSpaceAnalysisModule | Module for analysing the phase space of genfit::TrackCand(s) and SpacePointTrackCand(s) NOTE: this is just a very simple module that takes the MCParticleID of any TC and collects some information from them |
| CRootVariables | Helper class to have all RootVariables assembled in one container |
| CPhiAngle | |
| CPhiRecoTrackRelationFilter | Relation filter that lets only possibilities with small phi distance pass |
| CPhokhara | C++ Interface for the Fortran generator PHOKHARA |
| CPhokharaInputModule | The Phokhara Generator module.vectorToPair |
| CPhotonEfficiencySystematicsModule | Adds Photon Detection Efficiency Data/MC ratios To Particle List |
| CPhysicsObjectsDQMModule | Physics objects DQM module |
| CPhysicsObjectsMiraBelleBhabhaModule | A module template |
| CPhysicsObjectsMiraBelleDst2Module | DQM modules to monitor D* related variables |
| CPhysicsObjectsMiraBelleDstModule | DQM modules to monitor D* related variables |
| CPhysicsObjectsMiraBelleEcmsBBModule | Collector for the collision energy calibration based on the hadronic modes |
| CPhysicsObjectsMiraBelleHadronModule | DQM modules to monitor hadron related variables |
| CPhysicsObjectsMiraBelleModule | A module template |
| 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 |
| CPIDNtupleModule | Makes PID ntuple from mdst input |
| 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 |
| CPindiodeHit | ClassPindiodeHit - digitization simulated hit for the Pindiode detector |
| CPindiodeSimHit | ClassPindiodeSimHit - Geant4 simulated hit for the Pindiode crystal in beast |
| CPlanarMomentumMeasurement | Measurement class implementing a planar hit geometry (1 or 2D) with only a momentum measurement |
| CPlanarVXDMomentumMeasurement | Measurement class implementing a planar hit geometry (1 or 2D) with a momentum measurement based on the VXD dEdX information with setable parameters (see VXDMomentumEstimationMeasurementCreator) |
| CPlaneTriggerTrackTimeEstimatorModule | Module estimating the track time of RecoTracks - before or after the fit |
| CPlumeHit | ClassPlumeHit - digitization simulated hit for the Microtpc detector |
| CPlumeSimHit | Class PlumeSimHit - Geant4 simulated hit for the PLUME detector |
| CPostgreSQLInterface | |
| CPostMergeUpdaterModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', several kinematic properties might need fix |
| CPostProcessingParticleWeighting | Post-processing particle weighting |
| CPostRawCOPPERFormat_latest | The Raw COPPER class ver |
| CPostRawCOPPERFormat_v1 | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CPostRawCOPPERFormat_v2 | The Raw COPPER class ver.2 This class stores data received by COPPER via belle2link Data from all detectors except PXD are stored in this class |
| CPreRawCOPPERFormat_latest | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CPreRawCOPPERFormat_v1 | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CPreRawCOPPERFormat_v2 | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| 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) |
| CPrintDataModule | Read RawCOPPER objects and shows their hex dump |
| CPrintDataTemplateModule | Module to get data from DataStore and send it to another network node |
| CPrintEventRateModule | Print event rate of input data |
| CPrintMCParticlesModule | The PrintMCParticles module |
| CPrintTauTauMCParticlesModule | The PrintTauTauMCParticles module |
| CProcess | |
| CProcessController | |
| 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 |
| CProcessListener | |
| 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 |
| CProcessSubmitter | |
| 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 |
| CPruneGenfitTracksModule | Module to prune genfit::Tracks |
| CPruneRecoHitsModule | Module to prune RecoTracks |
| CPruneRecoTracksModule | Module to prune RecoTracks |
| CPseudoVertexFitterModule | Pseudo Vertex fitter module |
| CPT_NAME | Calculates the estimation of the transverse momentum of the 3-hit-tracklet, returning unit: GeV/c |
| CPThread | |
| CPXD2TrackBase | Class PXD2TrackBase: Event data container for performance and calibration studies |
| CPXD2TrackEvent | Class PXD2TrackEvent: Event data container for performance and calibration studies |
| CPXDAnalyticGainCalibrationAlgorithm | Class implementing the PXD gain calibration algorithm |
| CPXDChargeCalibrationAlgorithm | Class implementing the PXD median cluster charge calibration algorithm |
| CPXDCluster | The PXD Cluster class This class stores all information about reconstructed PXD clusters The position error matrix has the form ((m_uSigma^2, m_uvRho * m_uSigma * m_vSigma), (m_uvRho * m_uSigma * m_vSigma, m_vSigma^2)) The correlation coefficient is derived from the shape of the cluster |
| CPXDClusterChargeCollectorModule | Collector module for PXD gain calibration |
| CPXDClusterChargeMapPar | The payload class for PXD cluster charge calibrations |
| CPXDclusterFilterModule | The module produce a StoreArray of PXDCluster inside the ROIs |
| CPXDClusterOffsetPar | The class for PXD cluster position offset payload |
| CPXDClusterPositionCalibrationAlgorithm | Class implementing the PXD cluster position calibration algorithm |
| CPXDClusterPositionCollectorModule | Calibration collector module for PXD cluster position estimation |
| CPXDClusterPositionErrorPar | The payload class for PXD cluster position error |
| CPXDClusterPositionEstimatorPar | The class for PXD cluster position lookup table payload |
| CPXDClusterPropFilterModule | The module produce a StoreArray of PXDCluster with specific properties |
| CPXDClustersFromTracksModule | The PXDClustersFromTracks module |
| CPXDClusterShapeClassifierPar | The class for PXD cluster shape classifier payload |
| CPXDClusterShapeIndexPar | The class for PXD cluster shape index payload |
| CPXDDAQDHCStatus | The PXD DAQ DHC Status class |
| CPXDDAQDHEStatus | The PXD DAQ DHE Status class |
| CPXDDAQDHPStatus | The PXD DAQ DHP Status class |
| CPXDDAQPacketStatus | The PXD DAQ Packet Status class |
| CPXDDAQStatus | The PXD DAQ Status class |
| CPXDDataMCGainCalibrationAlgorithm | Class implementing the PXD median cluster charge calibration algorithm |
| CPXDDeadPixelPar | The payload telling which PXD pixel is dead (=Readout system does not receive signals) |
| CPXDdEdxPDFs | Specialized class for holding the PXD dE/dx PDFs |
| CPXDDHHFirmwareVersionPar | The payload stores the firmware version from the DHH, which has influence on the structure and content of the RawPXD package |
| CPXDdigiFilterModule | The module produce a StoreArray of PXDDigit inside the ROIs, thus simulating "ONSEN" ROI selection |
| CPXDDigit | The PXD digit class |
| CPXDDQMClustersModule | PXD DQM Module |
| CPXDDQMCorrModule | PXD DQM Corr Module |
| CPXDDQMEfficiencyModule | Creates the basic histograms for PXD Efficiency DQM Simplified and adopted version of the testbeam pxd efficiency module |
| CPXDDQMEfficiencyNtupleModule | Creates Ntuples for PXD Efficiency analysis |
| CPXDDQMEfficiencyNtupleSelftrackModule | Creates Ntuples for PXD Efficiency analysis |
| CPXDDQMEfficiencySelftrackModule | Creates the basic histograms for PXD Efficiency DQM Simplified and adopted version of the testbeam pxd efficiency module |
| CPXDDQMExpressRecoModule | PXD DQM Module |
| CPXDDQMTrackRawNtupleModule | Creates Ntuples for PXD Trigger analysis |
| CPXDEnergyDepositionEvent | Class PXDEnergyDepositionEvent: PXDSimHit data container for background studies |
| CPXDGainCalibrationAlgorithm | Class implementing the PXD gain calibration algorithm |
| CPXDGainMapPar | The payload class for PXD gain corrections |
| CPXDGatedModeInfo | The PXD Gated Info Class |
| CPXDGeometryPar | The Class for VXD geometry |
| CPXDHotPixelMaskCalibrationAlgorithm | Class implementing PXD hot pixel masking calibration algorithm |
| CPXDHotPixelMaskCollectorModule | Calibration Collector Module for PXD hot pixel masking from PXDDigits |
| CPXDIgnoredPixelsMap | This class provides a check for ignored (=cold, hot or otherwise deffective) pixels for the use in PXD data reconstruction |
| CPXDInjectionBGTiming | The PXDInjectionBGTiming class |
| CPXDInjectionVetoEmulatorModule | The module produces a StoreObjPtr of PXDInjectionBGTiming containing PXD timing for gated mode operation |
| CPXDIntercept | PXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an PXD sensor |
| CPXDKalmanStepper | Kalman stepper implementation for the PXD CKF |
| CPXDLocalDAQFile | A class to manage I/O for a chain of blocked files |
| CPXDMaskedPixelPar | The payload telling which PXD pixel to mask (ignore) |
| CPXDMeasurementCreatorFactory | Add all measurement creators related to PXD hits |
| CPXDNeutronFluxEvent | Class PXDNeutronFluxEvent: PXDTrueHit data container for background studies |
| CPXDOccupancyEvent | Class PXDOccupancyEvent: PXDCluster data container for background studies |
| CPXDOccupancyInfoPar | The payload collecting some meta information from running the masking algorithm |
| CPXDPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CPXDPerformanceCollectorModule | Collector module for PXD gain calibration and PXD calibration validation |
| CPXDPerformanceModule | PXD Performance module |
| CPXDPerformanceVariablesCollectorModule | Collector module for PXD gain calibration and PXD calibration validation |
| CPXDRawAdc | The PXD Raw Adc class This class stores information about Raw Adc for Pedestals |
| CPXDRawDQMCorrModule | PXD DQM Corr Module |
| CPXDRawHit | The PXD Raw Hit class This class stores information about PXD Pixel hits and makes them available in a root tree |
| CPXDRawHitFilterModule | The module produce a StoreArray of PXDRawHit inside the ROIs |
| CPXDRawHotPixelMaskCollectorModule | Calibration Collector Module for PXD hot pixel masking from PXDRawHits |
| CPXDRawROIs | The PXD Raw ROIs class This class stores information about the ROIs processed by ONSEN and makes them available in a root tree |
| CPXDRecoHit | PXDRecoHit - an extended form of PXDCluster containing geometry information |
| CPXDResultFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CPXDResultTruthVarNames | Vehicle class to transport the variable names |
| CPXDResultTruthVarSet | Var set used in the CKF for calculating the probability of a correct result, which knows the truth information if two tracks belong together or not |
| CPXDResultVarNames | Vehicle class to transport the variable names |
| CPXDResultVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| CPXDROIFinderAnalysisModule | The PXD Data Reduction Analysis Module |
| CPXDROIFinderModule | The PXD ROI Finder Module |
| CPXDSensorInfoPar | The Class for VXD geometry |
| CPXDSimHit | Class PXDSimHit - Geant4 simulated hit for the PXD |
| CPXDSpacePointCreatorModule | Imports Clusters of the pxd detector and converts them to spacePoints |
| CPXDStateBasicVarNames | Vehicle class to transport the variable names |
| CPXDStateBasicVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match |
| CPXDStateFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CPXDStateTruthVarNames | Vehicle class to transport the variable names |
| CPXDStateTruthVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| CPXDSVDCutModule | The module to deactivate the SpacePointTrackCandidates with less than minSVDSPs SVD SpacePoints |
| CPXDTrackClusterDQMModule | DQM of cluster in matched tracks |
| CPXDTrackingEventLevelMdstInfoFillerModule | This module adds additional global event level information about PXD track finding to the MDST object 'EventLevelTrackingInfo' |
| CPXDTrueHit | Class PXDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| CPXDValidationAlgorithm | Class implementing the PXD calibration validation algorithm |
| 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 |
| CQcsmonitorHit | ClassQcsmonitorHit - digitization simulated hit for the Qcsmonitor detector |
| CQcsmonitorSimHit | ClassQcsmonitorSimHit - Geant4 simulated hit for the Qcsmonitor crystal in beast |
| CQEResultsExtractor | Class to extract results from qualityEstimation |
| CQualityEstimationResults | Container for complete fit/estimation results |
| CQualityEstimatorBase | BaseClass for QualityEstimators |
| CQualityEstimatorCircleFit | Class containing the algorithm to perform the simple circle fit |
| CQualityEstimatorLineFit3D | Testbeam: Coords: Sensors: ^ |
| CQualityEstimatorMC | Class implementing the algorithm used for the MC based quality estimation |
| CQualityEstimatorRandom | Class implementing a random quality estimation |
| CQualityEstimatorRiemannHelixFit | Based on R |
| CQualityEstimatorTripletFit | Does a tripletFit of the given hits The filter is based on the paper 'A New Three-Dimensional Track Fit with Multiple Scattering' by Andre Schoening et al |
| CQualityEstimatorVXDModule | Quality estimation module for SpacePointTrackCandidates |
| CRadiusTrackTimeEstimatorModule | Module estimating the track time of RecoTracks - before or after the fit |
| CRandomBarrierModule | Sets gRandom to an independent generator for the following modules |
| CRandomEngine | Interface class to make Geant4 use the Belle2 RandomGenerator |
| CRandomGenerator | Fast Random number Generator using on xorshift1024* [arXiv:1402.6246] |
| CRandomNumbers | The class for handling the random number generation |
| CRange | Represents a range of arithmetic types |
| CRaw2DsModule | A class definition of an input module for Sequential ROOT I/O |
| CRawARICH | The Raw ARICH class Class for RawCOPPER class data taken by ARICH Currently, this class is almost same as RawCOPPER class |
| CRawCDC | The Raw CDC class Class for RawCOPPER class data taken by CDC Currently, this class is almost same as RawCOPPER class |
| CRawCOPPER | The Raw COPPER class This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERFormat | The Raw COPPER class This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERFormat_latest | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERFormat_v0 | The Raw COPPER class ver.0 ( from August, 2013 to April, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERFormat_v1 | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERFormat_v2 | The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class |
| CRawCOPPERPackerInfo | Struct to contain header information used by RawCOPPERFormat::Packer() |
| CRawDataBlock | The RawDataBlock class Base class for rawdata handling |
| CRawDataBlockFormat | The RawDataBlockFormat class Format information for rawdata handling |
| CRawDataCollectedMinMax | Takes care of collecting raw data and staying below RAM-threshold |
| CRawECL | The Raw ECL class Class for RawCOPPER class data taken by ECL Currently, this class is almost same as RawCOPPER class |
| CRawFTSW | The Raw FTSW class |
| CRawFTSWFormat | The Raw FTSW class |
| CRawFTSWFormat_latest | The Raw FTSW class 3 ( 2019.8.20 ) |
| CRawFTSWFormat_v1 | The Raw FTSW class ver.1 |
| CRawFTSWFormat_v2 | The Raw FTSW class ver.2 |
| CRawHeader_latest | The Raw Header class ver.1 ( the latest version since May, 2014 ) This class defines the format of the header of RawCOPPER class data and used for extracting header info from RawCOPPER object |
| CRawHeader_v0 | The Raw Header class ver.0 ( from August, 2013 to April, 2014 ) This class defines the format of the header of RawCOPPER class data and used for extracting header info from RawCOPPER object |
| CRawHeader_v1 | The Raw Header class ver.1 ( the latest version since May, 2014 ) This class defines the format of the header of RawCOPPER class data and used for extracting header info from RawCOPPER object |
| CRawHeader_v2 | The Raw Header class ver.1 ( the latest version since May, 2014 ) This class defines the format of the header of RawCOPPER class data and used for extracting header info from RawCOPPER object |
| CRawInputModule | A class definition of an input module for Sequential ROOT I/O |
| CRawKLM | The Raw KLM class Class for RawCOPPER class data taken by KLM |
| CRawPXD | The Raw PXD class |
| CRawRevRb2Sock | |
| CRawSecMapMergerModule | The RawSecMapMergerModule |
| CRawSecMapRootInterface | To be used as an interface to root-stuff |
| CRawSVD | The Raw SVD class Class for RawCOPPER class data taken by SVD Currently, this class is almost same as RawCOPPER class |
| CRawTLU | The Raw TLU class Class for data from DAQ PC for TLU(Trigger Logic Unit) It is supposed to be used only in the DESY beam test |
| CRawTLUFormat | The Raw TLU class Class for data from DAQ PC for TLU(Trigger Logic Unit) It is supposed to be used only in the DESY beam test |
| CRawTOP | The Raw TOP class Class for RawCOPPER class data taken by TOP Currently, this class is almost same as RawCOPPER class |
| CRawTrailer_latest | The Raw Trailer class ver.1 ( the latest version since May, 2014 ) This class defines the format of the trailer of RawCOPPER class data and used for extracting trailer info from RawCOPPER object |
| CRawTrailer_v0 | The Raw Trailer class ver.0 ( from August, 2013 to April, 2014 ) This class defines the format of the trailer of RawCOPPER class data and used for extracting trailer info from RawCOPPER object |
| CRawTrailer_v1 | The Raw Trailer class ver.1 ( the latest version since May, 2014 ) This class defines the format of the trailer of RawCOPPER class data and used for extracting trailer info from RawCOPPER object |
| CRawTrailer_v2 | The Raw Trailer class ver.1 ( the latest version since May, 2014 ) This class defines the format of the trailer of RawCOPPER class data and used for extracting trailer info from RawCOPPER object |
| CRawTRG | The Raw TOP class Class for RawCOPPER class data taken by TOP Currently, this class is almost same as RawCOPPER class |
| CRb2Sock | |
| CRbTupleManager | Class to manage histograms defined in registered modules |
| CRbuf2DsModule | A class definition of an input module for Sequential ROOT I/O |
| CRbuf2RbufModule | A class definition of an input module for Sequential ROOT I/O |
| CRCCallback | |
| CRCCommand | |
| CRCConfig | |
| CRCConfigHandler | |
| CRCHandlerException | |
| CRCHandlerFatalException | |
| CRCNode | |
| CRCNodeDaemon | |
| CRCState | |
| CReader | |
| ►CReaderSAD | Class to read files that have been created by SAD and store their content in a MCParticle graph |
| CbendingElement | Sensitive Element |
| CstraightElement | Calculates the transformation matrix from local SAD to global geant4 space |
| CReceiveEventModule | A class definition of an input module for Sequential ROOT I/O |
| CRecoHitInformation | This class stores additional information to every CDC/SVD/PXD hit stored in a RecoTrack |
| CRecoTrack | This is the Reconstruction Event-Data Model Track |
| CRecoTrackCreatorModule | Module turning trackCands to reco tracks (will be unneeded once we create reco tracks from the beginning) |
| CRecoTrackExtractor | Class to extract results from qualityEstimation |
| CRecoTrackGenfitAccess | This class allows access to the genfit::Track of the RecoTrack |
| CRecoTrackParticleLoaderModule | Takes fitted RecoTracks and creates Particles from them directly, skipping the step of creating Tracks and TrackFitResults |
| CRecoTrackRelator | The results of the CKF ar in the form (seed -> vector of hits) |
| CRecoTracksCopierModule | Module to copy RecoTracks |
| CRecoTracksReverterModule | Module to revert RecoTracks |
| CRecoTrackStoreArrayCombinerModule | Module to combine RecoTracks |
| CReferenceFrame | Abstract base class of all reference frames |
| CRefHistObject | Class to keep track of reference histograms with the original |
| CRegisterEventLevelTrackingInfoModule | Module to create the EventLevelTrackingInfo that is used to set general tracking-related flags |
| CRelatedTracksCombinerModule | Module to combine RecoTracks |
| CRelationApplier | Relate the SVD and CDC tracks in the given relations also in the store array |
| ►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 |
| CRelationFromSVDTracksCreator | Simplified relation creator only creating relations between states of CDC Reco Track seeds and states with SpacePoints, that: (a) for the seed states: connect every seed with every lst hit of the SVD Reco Tracks (b) for the hit states: are in the same SVD Reco Track and follow each other directly |
| 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 |
| CRelationSVDResultVarNames | Vehicle class to transport the variable names |
| CRelationSVDResultVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| CRelationVector | Class for type safe access to objects that are referred to in relations |
| CRelationVectorBase | Base class for RelationVector<T> |
| CRemoveMCParticlesModule | The RemoveMCParticles module |
| CRemoveParticlesNotInListsModule | Removes all Particles that are not in a given list of ParticleLists (or daughters of those) |
| CReprocessorModule | Reprocessor Module |
| CResidualSVDStateFilter | A very simple filter for all space points |
| 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 |
| CResultStorer | This findlet does also handle the storing of the results |
| CRevRb2Sock | |
| CRevSock2Rb | |
| CREvtSocketRecv | |
| CREvtSocketSend | |
| CRFCommand | |
| CRFConf | |
| CRFConf_t | |
| CRFDqmServer | |
| CRFEventProcessor | |
| CRFEventServer | |
| CRFFlowStat | |
| CRFLogManager | |
| CRFMaster | |
| CRFMasterCallback | |
| CRfNodeInfo | |
| CRFNodeManager | |
| CRFNSM | |
| CRFNSM_Status | |
| CRFOutputServer | |
| CRFProcessManager | |
| CRFRoiSender | |
| CRFRunControlCallback | |
| CRFServerBase | |
| CRFSharedMem | |
| CRfShm_Cell | |
| CRfShm_Data | |
| ►CRfUnitInfo | |
| CRfNodeInfo | |
| CRingBuffer | Class to manage a Ring Buffer placed in an IPC shared memory |
| CRingBufInfo | Internal metadata structure for RingBuffer |
| ►Cro_summary | |
| Cevent_header | |
| CROICalculationParameters | The payload containing all PXD ROI parameters |
| CROICalculator | Findlet to calculate ROI on the PXD sensors based on input hits |
| CROIDetPlane | ROIDetPlane describes the plane containing a sensor |
| ►CROIDQMModule | The HLT ROI DQM module |
| CROIHistoAccumulateAndFill | Struct: histograms to be filled once per event + filling function + accumulate function |
| CROIfindingConditionFromDBModule | Module which sets its return value based on the payload whether ROI-finding was enabled for the given run/exp interval or not |
| CROIGeneratorModule | The ROI generator Module |
| CROIGeometry | This class appends the VXDIntercept infos of a track to the list of intercepts |
| CROIid | ROIid stores the U and V ids and the sensor id of the Region Of Interest |
| CROIpayload | ROIpayload TODO: Better explanation, Is there a reason to inherit from TObject and not Relationsobject here? |
| CROIPayloadAssemblerModule | The ROI Payload Assembler Module |
| CROIrawID | ROIrawID |
| CROIReadTestModule | The ROI to ONSEN Module |
| CRoiSenderCallback | |
| CROISenderModule | The ROI to ONSEN Module |
| CROISimulationParameters | The payload containing all PXD ROI parameters |
| CROIToUnitTranslator | Translator for ROI-geometry-information into a list of pixels or strips |
| ►Cronode_info | |
| Cio_info | |
| ►Cronode_status | |
| Cevent_header | |
| CRoot2BinaryModule | Dump basf2 objects to a binary file |
| CRoot2RawModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| CRootParameterTracker | Production notes for RootParameterTracker: |
| CRotationFrame | Rotation frame around vector |
| CRoughCDCfromEclStateFilter | A very rough filter for all CDC states |
| CRoughCDCStateFilter | A very rough filter for all CDC states |
| CRSocketRecv | |
| CRSocketSend | |
| CRT2SPTCConverterModule | Module for converting RecoTracks to SpacePointTrackCands |
| CRunInfo | Database object for Run Information |
| CRunInfoBuffer | |
| CRunNumber | |
| CRunNumberTable | |
| CRunRange | Mergeable object holding (unique) set of (exp,run) pairs |
| CRWLock | |
| CRxModule | Module to decode data store contents from RingBuffer |
| CRxSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CSADInputModule | The SAD Input module |
| CSADMetaHit | ClassSADMetaHit - digitization simulated metahit for the SAD detector |
| CScanCDCGeoModule | Test module to save CDC geometry information to ntuple file |
| CScopeGuard | Simple ScopeGuard to execute a function at the end of the object lifetime |
| CScrooge | Executes greedy algorithm for vector of QITrackOverlap structs |
| CSecIDPair | Allows to set outer and inner secID |
| CSecIDQuadruplet | Allows to set outer, outerCenter, innerCenter and inner secID |
| CSecIDTriplet | Allows to set outer, center and inner secID |
| CSecMapTrainer | This class contains all relevant tools for training a VXDTFFilters |
| CSecMapTrainerBaseModule | The SecMapTrainerBaseModule this module analyzes a big number of events (pGun or evtGen) to create raw sectorMaps which are needed for the VXDTF 2.0 |
| CSecMapTrainerHit | Simple Hit class used for sectorMap-training |
| CSecMapTrainerTC | Simple Hit class used for sectorMap-training |
| CSecMapTrainerVXDTFModule | The SecMapTrainerVXDTFModule this module analyzes a big number of events (pGun or evtGen) to create raw sectorMaps which are needed for the VXDTF |
| CSector | Sector is a central part of storing information for VXD trackFinders |
| CSectorFriendship | SectorFriendship is carrying the link between parent sector and a connected sector (socalled Friendsector) |
| CSectorGraph | All subgraphs |
| CSectorMapBasedSVDPairFilter | Filter for relations between CKF SVD states based on SectorMaps |
| CSectorMapBootstrapModule | The SegmentFilterConverterModule is a module able to read the cutoff values for filtering the Segments written in the xml gear box and write it in the new redesigned format |
| CSectorMapComparer | A root tool that compares two Sectormaps (local root files) and produces some statistics output |
| CSectorMapConfig | Simple struct containing all the configuration data needed for the SecMapTrainer |
| CSectorsOnSensor | This class associates to an ordered pairs of normalized local coordinates a compact sector id |
| CSeedChargeCDCPathFilter | Check if charge of fitted path corresponds to charge of seed |
| CSeedGetter | Helper Functor to get the Seed of a given result |
| CSegment | The Segment class This class represents segments of track candidates needed for TrackFinderVXD-Modules |
| ►CSegmentNetworkAnalyzerModule | Class for analyzing the contents of the SegmentNetwork |
| CRootVariables | Keep all the variables for rootoutput in one struct |
| ►CSegmentNetworkProducerModule | The Segment Network Producer Module |
| CRawSectorData | Simple struct for collecting raw data for a single sector |
| CSelectDaughtersModule | Redefine (select) the daughters of a particle |
| ►CSelectionVariable | Base class of the selection variable objects used for pair filtering |
| CFunctionOf | This struct is an internal utility |
| CFunctionOf< 0, returnType, parameterType, Ts... > | This struct is an internal utility |
| CSelectionVariableFactory | The factory,as the name implies, does not implement at all the factory paradigm |
| CSelectSubset | Class to create a subset of a given StoreArray together with the relations with other StoreArrays |
| CSelectSubsetBase | Type-independent implementation details of SelectSubset |
| CSelVarHelper | Collection of functions and related stuff needed for SelectionVariables implementing 2-, 3- and 4-hitfilters |
| CSemaphoreLocker | Handles creation, locking and unlocking of System V semaphores |
| CSender | |
| CSendHeader | |
| CSendTrailer | |
| CSensorPXDPairFilter | Base filter for CKF PXD states |
| CSensorSVDPairFilter | Base filter for CKF SVD states |
| CSensorTraversal | Class to keep track of the traversal of the sensitive volume for one track |
| CSeqFile | A class to manage I/O for a chain of blocked files |
| CSeqRootInputModule | Module to read files produced by SeqRootOutputModule |
| CSeqRootMergerModule | A class definition of an input module for Sequential ROOT I/O |
| CSeqRootOutputModule | Output module for sequential ROOT I/O |
| CSerializable | |
| CSerializerModule | A class definition of an input module for Sequential ROOT I/O |
| CServiceGapsMaterialsCdcArichTopPar | The Class for Service Materials between CDC and ECL, ARICH and TOP, TOP and ECL |
| CServiceGapsMaterialsEclPar | The Class for Service Materials between barrel and endcap of ECL |
| CServiceGapsMaterialsPar | The Class for services materials geometry |
| CServiceGapsMomVolPar | The class for the mother volume of the Service Materials |
| CSetMergeable | Wrap an STL set to make it mergeable |
| CSetRecoTrackMomentumModule | Set momentum magnitude for RecoTracks to given value (for runs without magnetic field) |
| CSetupGenfitExtrapolationModule | Setup material handling and magnetic fields for use by genfit's extrapolation code (RKTrackRep) |
| ►CSGCosmic | Class to generate tracks in the cosmics generator and store them in a MCParticle graph |
| CParameters | Struct to keep all necessary parameters for the cosmic generator |
| ►CSharedEventBuffer | |
| CHeader | |
| CSharedMem | |
| CSharedMemory | |
| CSignalInterpolation2 | Interpolation of signal shape using function values and the first derivative |
| 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 |
| CSIGNCURVATUREXY_NAME | Calculates the sign of the curvature for three hits |
| CSIGNCURVATUREXYERROR_NAME | Calculates the sign of the curvature for three hits |
| CSimClockState | Simulated hardware clock state |
| CSimHitBase | Class SimHitBase - A common base for subdetector SimHits |
| CsimpleBitfield | Helper class for setting up a bitfield that can be used to store several flags in one variable TODO: move this from this header (possibly to some helperStuff header) and make some tests! |
| CSimpleCluster | Type for found clusters |
| CSimplePXDStateFilter | A very simple filter for all space points |
| CSimpleSVDStateFilter | A very simple filter for all space points |
| CSimpleVariableRecorder | Class to write collected variables into a root file, Used by VXDQETrainingDataCollectorModule |
| CSimulateEventLevelTriggerTimeInfoModule | Module to create the EventLevelTriggerTimeInfo that stores information from the Trigger Timing Distribution (TTD) Will not be registered if it already exists as we want to use the EventLevelTriggerTimeInfo from the BG Overlay For now this module creates just an empty object (flag is set to indicate that it is invalid) |
| CSingleElementSet | Represents a set containing a single element; |
| CSizeCDCPathFilter | Return the size of the path |
| CSizePXDResultFilter | Base filter for CKF PXD results (on overlap check) |
| CSizeSVDResultFilter | Base filter for CKF SVD results (on overlap check) |
| CSkimFilterModule | This module filters events based on presence of candidates in a list of ParticleLists |
| CSliceFit | Class to do the slice fit |
| CSLOPERZ_NAME | This is the specialization for SpacePoints with returning floats, where value calculates the slope in R-Z for a given pair of hits |
| CSmearPrimaryVertexModule | This module smears the primary vertex (the interaction point) according to the values stored in BeamParameters |
| CSndHdrTemp | |
| CSock2Rb | |
| CSocketIO | |
| CSocketManager | |
| CSocketRecv | |
| CSocketSend | |
| 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 |
| CSpacePoint | SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters |
| ►CSpacePoint2TrueHitConnectorModule | Module that tries to register a relation between SpacePoints and TrueHits, hence making some MC Information easily accessible for other modules working with SpacePoints (e.g |
| CRootVariables | Helper struct to access root variables inside the module |
| CSpacePointCreatorTestModule | Tester module for the validity of the SpacePointCreatorModule |
| CSpacePointInfo | Helper class to store the SpacePoint information as coding convention prohibits to use the SpacePoint class here |
| CSpacePointLoader | Load the space points from the store array to the given vector |
| CSpacePointTagger | Findlet for tagging all space points in the results vector as used |
| CSpacePointTrackCand | Storage for (VXD) SpacePoint-based track candidates |
| CSpacePointTrackCandCreator | Small class to take simple vectors of SpacePoints and convert them to real SpacePointTrackCands |
| 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 |
| CSpline | Spline structure for zero-order & linear splines |
| CSplitGLView | Responsible for arranging the GL viewers and providing related functionality |
| CSplitter | Class that allows to split runs into the intervals of intended properties given by the lossFunction |
| CSPTC2GFTCConverterModule | Module for converting SpacePointTrackCands to genfit::SpacePointTrackCands |
| CSPTC2RTConverterModule | Module turning SpacePointsTrackCands to RecoTracks |
| CSPTCmomentumSeedRetrieverModule | A module for creating momentum seeds for spacepoint track candidates |
| CSPTCRefereeModule | Module that does some sanity checks on SpacePointTrackCands that have been created by conversion from genfit::TrackCands by the TrackFinderMCTruth (or any other for that matter) |
| CSPTCSelectorXBestPerFamily | Algorithm to collect the x best TrackCandidates per family based on a VXD Quality estimator method output |
| CSPTCvirtualIPRemoverModule | A module for checking and removing the virtual IP if wanted |
| CSrsensorSimHit | ClassSrsensorSimHit - Geant4 simulated hit for the Srsensor detector |
| CStackTreeSearcher | CKF tree searcher which traces several best paths |
| CStandaloneCosmicsCollector | Track finding algorithm class for linear tracks produced by cosmics in the VXD without magnetic field |
| CStandardTrackingPerformanceModule | This module takes the MCParticle and the genfit::Track collection as input and writes out a root file with some information of the reconstructed tracks |
| CStateCreator | Create new states and add them to a vector from a given object vector |
| CStateCreatorWithReversal | An adaption of the normal state creator introducing another parameter to reverse the seed |
| CStateRejecter | Reject some (or all) states from a given list of child states using 5 filters |
| CStaticSector | Class to describe a static sector of the sector map |
| CStatisticsSummaryModule | A module that displays the sum of multiple modules in the module statistics |
| CSteerRootInputModule | Internal module used by Path.add_independent_merge_path() |
| CStepInformation | Simple struct to keep information about steps in the sensitive detector |
| CStorageDeserializerModule | A class definition of an input module for Sequential ROOT I/O |
| CStorageRootOutputModule | Write objects from DataStore into a ROOT file |
| CStorageSerializerModule | Class definition for the output module of Sequential ROOT I/O |
| CStorageStreamHelper | Helper class for data store serialization |
| CStorageZMQ2DsModule | Input module in the ZMQ reconstruction path receiving events via ZMQ and deserializing the to the data store |
| CStoreAccessorBase | Base class for StoreObjPtr and StoreArray for easier common treatment |
| CStoreArray | Accessor to arrays stored in the data store |
| CStoreArrayMerger | This findlet has helper function to |
| CStoreEntry | Wraps a stored array/object, stored under unique (name, durability) key |
| CStoreObjPtr | Type-safe access to single objects in the data store |
| CStoreWrappedObjPtr | This class is for convenience access and registration of objects, that are stored inside the StoreWrapper on the DataStore |
| CStreamHelper | Helper class for data store serialization |
| CStreamSizeCounter | |
| CSTRGeometryPar | The Class for STR geometry |
| CStringFormulaConstructor | Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging |
| CStringUtil | |
| CStringWrapper | This class is a wrapper for strings, such as MCDecayStrings, to allow them to be associated with particles via a relation |
| CStudyMaterialEffectsModule | StudyMaterialEffectsModule |
| CSubEventModule | Framework-internal module that implements the functionality of Path::forEach() as well as Path::doWhile() |
| CSubGraph | All relevant stuff needed for dealing with a subGraph |
| CSubGraphID | Stores the ID of a subgraph, which is basically a chain of FullSecID coded as unsigned ints |
| CSubRecoTrackExtractor | Class to extract results from qualityEstimation |
| CSubTrigger | Enum class SubTriggerType : unsigned char {Merger, TSF, T2D, T3D, Neuro, ETF}; |
| CSVD3SampleCoGTimeCalibrationAlgorithm | Class implementing SVD3SampleCoGTimeCalibration calibration algorithm |
| CSVD3SampleCoGTimeCalibrations | This class defines the dbobject and the methods to access the SVD calibrations from the local runs providing the constants needed to correct the cluster time computed with the 3-sample CoG |
| CSVD3SampleELSTimeCalibrationAlgorithm | Class implementing SVD3SampleELSTimeCalibration calibration algorithm |
| CSVD3SampleELSTimeCalibrations | This class defines the dbobject and the methods to access the SVD calibrations from the local runs providing the constants needed to correct the cluster time computed with the 3-sample ELS |
| CSVD3SamplesEmulatorModule | This module takes the SVDShaperDigit as input and select three consecutive samples starting from the one chosen by the user |
| CSVD6SampleEventSkimModule | SVD 6-sample event skim module |
| CSVDAbsoluteClusterTimeShift | This class store the shift of the cluster time w.r.t a full calibration |
| CSVDAPVHistograms | Template class for the APV Histograms |
| CSVDB4CommissioningPlotsModule | The SVD B4CommissioningPlots Module |
| CSVDCalibrationsBase | Base class for calibrations classes |
| CSVDCalibrationsBitmap | Class for digital (0/1) calibration values per srtip |
| CSVDCalibrationsScalar | Template class for scalar (one per side) calibrations |
| CSVDCalibrationsVector | Template class for vector (one per strip) calibrations |
| CSVDChannelMappingModule | The Channel Mapping Check Module |
| CSVDChargeSharingAnalysisModule | Module for monitoring DSSD cluster charge deposition in regard of capacitive charge sharing between adjacent strips in a cluster for data and the simulation |
| CSVDChargeSimCal | Simulation calibration parameters |
| CSVDChargeSimulationCalibrations | This class defines the dbobject and the methods to access SVD simulation calibrations; coupling constants and Geant4 electron weight |
| CSVDCluster | The SVD Cluster class This class stores all information about reconstructed SVD clusters |
| CSVDClusterCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded calibration constants |
| CSVDClusterCuts | Clustering parameters |
| CSVDClusterEvaluationModule | The SVD ClusterEvaluation Module |
| CSVDClusterEvaluationTrueInfoModule | Clustering Performance, using true information |
| CSVDClusterFilterModule | Generates a new StoreArray from the input StoreArray which has all specified Clusters removed |
| CSVDClustering | This class defines the dbobject and the methods to access the calibration of the cluster reconstruction |
| CSVDClusterQualityEstimatorCalibrationModule | Generate PDFs for assigning probability that cluster generated from signal particle |
| CSVDClusterQualityEstimatorModule | Calculates the probability of a cluster originating from signal hit |
| CSVDClusterTimeShifter | This class store the shift in svd time w.r.t |
| CSVDClusterTimeShifterAlgorithm | Class implementing SVDClusterTimeShifter algorithm |
| CSVDClusterTimeShifterCollectorModule | This module creates and fills histograms based on cluster-sizes so that the mean of SVD-cluster time distribution could be calculated |
| CSVDCoGCalibrationFunction | Class to contain the CoG Time calibrations |
| CSVDCoGOnlyErrorScaleFactors | This class defines the dbobject and the methods to access the scaling factors for the CoGOnly position algorithm |
| CSVDCoGOnlyPositionError | This class defines the dbobject and the methods to access the SVD position error parameters and provide the position error for the CoGOnly algorithm |
| CSVDCoGTimeCalibrationAlgorithm | Class implementing SVDCoGTimeCalibration calibration algorithm |
| CSVDCoGTimeCalibrations | This class defines the dbobject and the methods to access the SVD calibrations from the local runs providing the constants needed to correct the strip time computed with the CoG |
| CSVDCoGTimeEstimatorModule | This module builds the SVDRecoDigits (calibrated and fitted strips) from the SVDShaperDigits |
| CSVDCoolingPipesPar | The Class for SVD Cooling Pipes |
| CSVDCrossTalkCalibrationsAlgorithm | Class implementing SVDCrossTalkCalibrations calibration algorithm |
| CSVDCrossTalkCalibrationsCollectorModule | Collector module used to create the histograms needed for the cross talk calibration |
| CSVDCrossTalkFinderModule | Flags potential cross talk strips on Origami sensors |
| CSVDCrossTalkStripsCalibrations | This class defines the dbobject and the method to access strips which are masked at FADC level |
| CSVDDAQDiagnostic | Class to store SVD DAQ diagnostic information |
| CSVDDataFormatCheckModule | This module checks the format of the data that we are going to reconstruct checking the SVDModeByte and the SVDDAQDiagnostic |
| CSVDdEdxCalibrationAlgorithm | Class implementing the SVD dEdx calibration algorithm |
| CSVDdEdxCollectorModule | Collector module used to create the histograms needed for the SVD dE/dx calibration |
| CSVDdEdxPDFs | Specialized class for holding the SVD dE/dx PDFs |
| CSVDdEdxValidationAlgorithm | Class implementing the SVD dEdx calibration algorithm |
| CSVDdEdxValidationCollectorModule | Collector module used to create the histograms needed for the SVD dE/dx calibration |
| CSVDDetectorConfigurationImporter | This class import to the database the dbobjects SVDGlobalConfigParameters and SVDLocalConfigParameters |
| CSVDDQMClustersOnTrackModule | SVD DQM Module for Clusters related to Tracks |
| CSVDDQMEfficiencyModule | Creates the basic histograms for SVD Efficiency DQM |
| CSVDDQMExpressRecoModule | SVD DQM Module for Express Reco |
| CSVDDQMHitTimeModule | This module to design collect the svd hit time for different detectors trigger timing and physics processes |
| CSVDDQMPlotsConfiguration | This class handle DQM plots configuration: additional histograms (Charge, SNR, Time), 3Samples flag, etc.. |
| CsvdDumpModule | Class definition of svdClsHistoManager module |
| CSVDEndmountPar | The Class for SVD Support Rib Endmounts |
| CSVDEndringsPar | The Class for SVD Endring |
| CSVDEndringsTypePar | The Class for SVD Endring Type |
| CSVDEnergyDepositionEvent | Class SVDEnergyDepositionEvent: SVDSimHit data container for background studies |
| CSVDEventInfo | Stores SVDModeByte object with Trigger time, DAQ mode, Run type & Event type! |
| CSVDEventInfoSetterModule | Module to set the SVDEventInfo in the simulation |
| CSVDEventT0Configuration | This class store the configuration of the selections applied on the tracks used to compute the SVD EventT0 |
| CSVDEventT0EstimatorModule | This module estimates the EventT0 as the average of cluster time of SVD clusters associated to tracks |
| CSVDEventT0PerformanceTTreeModule | The module is used to create a TTree to study SVD EventT0 |
| CSVDFADCMaskedStrips | This class defines the dbobject and the method to access strips which are masked at FADC level |
| CSVDGeometryPar | The Class for VXD geometry |
| CSVDGlobalConfigParameters | This class defines the payload which stores to the central DB the SVD global configuring parameters, and the methods to import and retrieve these parameters |
| CSVDHistograms | Template class for SVd histograms |
| CSVDHitTimeSelection | This class defines the dbobject and the methods to access the calibration of the cluster reconstruction |
| CSVDHitTimeSelectionFunction | Class to contain the cut on svd hit time at SP creation step |
| CSVDHotStripFinderModule | A module template |
| CSVDHotStripsCalibrations | This class defines the wrapper to retrieve the list of the hot strips flagged offline |
| CSVDHotStripsCalibrationsAlgorithm | Class implementing SVDHotStripsCalibrations calibration algorithm |
| CSVDHoughTrackingModule | Full Hough Transformation based SVD track finding |
| CSVDIgnoredStripsMap | This class provides a list of ignored (=cold, hot or otherwise deffective) strips for the use in SVD data reconstruction |
| CSVDIntercept | SVDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an SVD sensor |
| CSVDKalmanStepper | Kalman stepper implementation for the SVD CKF |
| CSVDLatencyCalibrationModule | This module performs an analysis to find the APV25 latency |
| CSVDLocalCalibrationsCheckModule | Module to produce a list of histogram showing the uploaded local calibration constants |
| CSVDLocalCalibrationsImporter | This class import to the database the dbobjects storing the SVD Local Calibrations |
| CSVDLocalCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded local calibration constants |
| CSVDLocalConfigParameters | This class defines the payload which stores to the central DB the SVD local configuring parameters, and the methods to import and retrieve these parameters |
| CSVDLocalRunBadStrips | This class defines the dbobject and the method to access the information on bad strips flagged during local runs |
| CSVDMaxStripTTreeModule | The module is used to create a TTree to study the number of strips fired per event per APV chip |
| CSVDMCClusterPositionFudgeFactor | This class defines the dbobject and the methods to access the SVD cluster position fudge factors for the SVDClusterizer module |
| CSVDMCClusterTimeFudgeFactor | This class defines the dbobject and the methods to access the SVD time fudge factors for MC reconstruction |
| CSVDMCFudgeFactorFunction | Class to contain the MC fudge factor formulae |
| CSVDMeasurementCreatorFactory | Add all measurement creators related to SVD hits |
| CSVDModeByte | Class to store SVD mode information |
| CSVDNeutronFluxEvent | Class SVDNeutronFluxEvent: SVDTrueHit data container for background studies |
| CSVDNoiseCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| CSVDOccupancyAnalysisModule | The SVD OccupancyAnalysis Module |
| CSVDOccupancyCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| CSVDOccupancyCalibrationsAlgorithm | Class implementing SVDOccupancyCalibrations calibration algorithm |
| CSVDOccupancyCalibrationsCollectorModule | This This module collects hits from shaper digits to compute per sensor SVD occupancy using mu+mu- events for calibration of the SVDOccupancyCalibration payload using CAF |
| CSVDOccupancyEvent | Class SVDOccupancyEvent: SVDCluster data container for background studies |
| CSVDOldDefaultErrorScaleFactors | This class defines the dbobject and the methods to access the scaling factors for the OldDefault position algorithm |
| ►CSVDOnlineToOfflineMap | This class implements the methods to map raw SVD hits to basf2 SVD hits |
| CChipID | Class to hold FADC+APV25 numbers |
| CChipInfo | Struct to hold data about an APV25 chip |
| CmissingAPV | Struct to hold missing APVs information |
| CSensorID | Class to hold numbers related to sensor |
| CSensorInfo | Struct to hold data about a sensor |
| CSVDOverlapResolverModule | SVD overlap resolver module |
| CSVDPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CSVDPedestalCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| CSVDPerformanceModule | The (TB) SVD Performance Module |
| CSVDPerformanceTTreeModule | The module is used to create a TTree to study SVD clusters, genfit unbiased residuals and many other properties related to the track they belong to |
| CSVDPosErrScaleFactors | Scaling factors for the cluster position error |
| CSVDPositionErrorFunction | Class to contain the Cluster Position Error Formulae |
| CSVDPositionErrorScaleFactorImporterModule | Module that produces a localdb with position error scale factors for different position algorithms |
| CSVDPulseShapeCalibrations | This class defines the dbobject and the methods to access the SVD calibrations from the local runs providing the constants needed to calibrate the SVDShaperDigit: the charge, the ADC counts, the peaking time and the width |
| CSVDRecoConfiguration | This class store the reconstruction configuration of SVD |
| CSVDRecoDigit | The SVD RecoDigit class |
| CSVDRecoHit | SVDRecoHit - an extended form of SVDHit containing geometry information |
| CSVDRecoHit2D | SVDRecoHit - an extended form of SVDHit containing geometry information |
| CSVDRecoTimeBase | The SVD RecoTimeBase class |
| CSVDResultFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CSVDResultTruthVarNames | Vehicle class to transport the variable names |
| CSVDResultTruthVarSet | Var set used in the CKF for calculating the probability of a correct result, which knows the truth information if two tracks belong together or not |
| CSVDResultVarNames | Vehicle class to transport the variable names |
| CSVDResultVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| ►CSVDROIDQMModule | Creates basic DQM for ROI creation on ExpressReco |
| CROIHistoAccumulateAndFill | Struct: histograms to be filled once per event + filling function + accumulate function |
| CSVDROIFinderAnalysisDataModule | The Module evaluates the efficiency on SVD based on the number of empty ROIs |
| CSVDROIFinderAnalysisModule | This module performs the analysis of the SVD data reduction module performances |
| CSVDROIFinderModule | The SVD ROI Finder Module |
| CSVDSensorInfoPar | The Class for VXD geometry |
| CSVDShaperDigit | The SVD ShaperDigit class |
| CSVDShaperDigitConverter | Findlet for converting SVDShaperDigits into DATCONSVDDigits |
| CSVDShaperDigitFilterModule | The module produce a StoreArray of SVDShaperDigit inside the ROIs |
| CSVDShaperDigitsFromTracksModule | Generates two new StoreArray from the input StoreArray |
| CSVDSimHit | Class SVDSimHit - Geant4 simulated hit for the SVD |
| CSVDSpacePointCreatorModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDSpacePointQICalibrationModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDSpacePointSNRFractionSelector | Class to contain the cut on SVDSpacePoint |
| CSVDStateBasicVarNames | Vehicle class to transport the variable names |
| CSVDStateBasicVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match |
| CSVDStateFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CSVDStateTruthVarNames | Vehicle class to transport the variable names |
| CSVDStateTruthVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not |
| CSVDStateVarNames | Vehicle class to transport the variable names |
| CSVDStateVarSet | Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match |
| CSVDStripCalAmp | Parameter of the APV pulse |
| CSVDStripMaskingModule | This module removes the strips to be masked read form the SVDHotStripsCalibration |
| CSVDStripNoiseMap | Strip noise map |
| CSVDSummaryPlots | Class to summarize SVD quantities per sensor and side |
| CSVDSupportBoxPar | The Class for SVD Support Box |
| CSVDSupportRibsPar | The Class for SVD Support Ribs (one layer) |
| CSVDSupportTabPar | The Class for SVD Support Rib Tab |
| CSVDTimeCalibrationCollectorModule | Collector module used to create the histograms needed for the SVD CoG-Time calibration |
| CSVDTimeCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded calibration constants |
| CSVDTimeGroupingConfiguration | This class store the reconstruction configuration of SVDTimeGrouping module |
| CSVDTimeGroupingModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDTimeGroupingParameters | Structure containing the relevant information of SVDTimeGrouping module |
| CSVDTimeValidationAlgorithm | Class implementing SVDTimeValidation algorithm |
| CSVDTimeValidationCollectorModule | Collector module used to create the histograms needed for the SVD CoG-Time calibration |
| CSVDTrackingEventLevelMdstInfoFillerModule | This module adds additional global event level information about SVD track finding to the MDST object 'EventLevelTrackingInfo' |
| CSVDTransparentDigit | The SVD digit class |
| CSVDTriggerQualityGeneratorModule | This module generates a StoreObjPtr that contains random trigger quality chosen between FINE and COARSE |
| CSVDTriggerType | Class to store Trigger Type information |
| CSVDTrueHit | Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| CSVDUnpackerDQMModule | SVD DQM Module for the Unpacker |
| CSVDZeroSuppressionEmulatorModule | This module filters out strips that do not pass a ZS cut from the SVDShaperDigit StoreArray |
| 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 |
| CTCConvertersTestModule | Module for testing if the converting Modules do their job as intened |
| CTCPServerSocket | |
| CTCPSocket | |
| CTCType | Small class for classifying types of reconstructed track candidates |
| CTeegg | C++ Interface for the Fortran generator TEEGG |
| CTeeggInputModule | The TEEGG Generator module.vectorToPair |
| CTernaryRelationalNode | BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator |
| CtessellatedSolidStr | Structure which holds apexes of the tessellation volumes |
| CTestBoundarySettingAlgorithm | Test class implementing calibration algorithm |
| CTestCalibDBAccessModule | Returns the calibration result from SoftwareTriigerResult for skimming out calibration flagged events |
| CTestCalibMean | Test DBObject |
| CTestCalibObject | Test DBObject |
| CTestCalibrationAlgorithm | Test class implementing calibration algorithm |
| CTestChunkData | Storable object which can be filled with random chunk data of a certain size |
| CTestDBAccessAlgorithm | Test class implementing calibration algorithm |
| CTheKillerModule | This Modules kills basf2 as horribly as possible (or selected) |
| CThetaAngle | |
| CThicknessDensityPar | The class for the thicknesses and the density of gap element cell |
| CThreeHitFilters | The class 'ThreeHitFilters' bundles filter methods using 3 hits which are stored in B2Vector3Ds |
| CThrust | Class to calculate the thrust axis |
| CTime | |
| CTimeExtractionUtils | Helper class to perform all kind of track extrapolations using the methods from arXiv:0810.2241 |
| CTimeoutException | |
| CToCDCCKFModule | Combinatorial Kalman Filter that extrapolates every RecoTrack into the CDC and collects wire hits |
| CToCDCFromEclCKFModule | Combinatorial Kalman Filter that extrapolates every ECLShower into the CDC and collects wire hits |
| CTOPAlignerModule | Alignment of TOP |
| CTOPAlignmentCollectorModule | Collector for geometrical alignment of a TOP module with dimuons or Bhabhas |
| CTOPASICChannel | Calibration constants of a single ASIC channel: pedestals, gains and time axis |
| CTOPASICGains | Calibration constants of a single ASIC window: gains |
| CTOPAsicMask | Class to store bit fields of masked ASICs, as reported in raw data |
| CTOPASICPedestals | Calibration constants of a single ASIC window: pedestals |
| CTOPAsicShiftsBS13dCollectorModule | Collector for carrier shifts of BS13d |
| ►CTOPAssociatedPDF | Class to store analytic PDF associated with a photon |
| CPDFPeak | Parameters of a PDF peak |
| CTOPBackgroundModule | TOP background module |
| CTOPBarHit | Class to store track parameters of incoming MC particles relation to MCParticle filled in top/simulation/src/SensitiveBar.cc |
| ►CTOPBunchFinderModule | Bunch finder: searches for the bunch crossing where the interaction happened using track-based TOP likelihood |
| CTimeSeed | Structure to hold the time seed from a chosen detector component |
| CTOPCalAsicShift | Calibration constants for ASIC shifts of all 16 modules |
| CTOPCalChannelMask | Channel status for all 512 channels of 16 modules |
| CTOPCalChannelNoise | R.m.s |
| CTOPCalChannelPulseHeight | Pulse height parameterizations for all 512 channels of 16 modules |
| CTOPCalChannelRQE | Class to store relative quantum efficiency of channels w.r.t initial one measured in PMT QA QE is expected to decrease during the experiment due to aging induced by acuumulated charge |
| CTOPCalChannelT0 | Channel T0 calibration constants for all 512 channels of 16 modules |
| CTOPCalChannelThreshold | Value of the threshold (in ADC counts) used for the pulse identification, for all 512 channels of 16 modules |
| CTOPCalChannelThresholdEff | Class to store the threshold efficiency (i.e |
| CTOPCalCommonT0 | Common T0 calibration constant |
| ►CTOPCalEventT0Offset | Class to store the calibrated EventT0 offsets of other detector components The offsets are measured relative to TOP EventT0 (e.g CDC - TOP etc) |
| COffsetData | Calibration constants of a detector component |
| CTOPCalFillPatternOffset | Class to store the offset of reconstructed fill pattern |
| CTOPCalIntegratedCharge | Class to store integrated charge per channel |
| CTOPCalModuleAlignment | Alignment constants for all 16 modules |
| CTOPCalModuleT0 | Module T0 calibration constants for all 16 modules |
| CTOPCalPhotonYields | Class to store photon pixel yields for PMT ageing studies, and equalized alpha ratios for finding optically decoupled PMT's |
| CTOPCalPulseGeneratorModule | Generator of calibration pulses Output to TOPSimCalPulses |
| CTOPCalTimebase | Sample time calibration constants for all channels |
| CTOPCalTimeWalk | Calibration constants for time-walk correction and for tuning of electronic time resolution in digitization |
| CTOPChannelMap | Map of pixels and channels within the carrier board |
| CTOPChannelMaskCollectorModule | Collector for preparing masks of hot and dead channels |
| CTOPChannelMaskerModule | Masks dead PMs from the reconstruction |
| CTOPChannelT0CalibratorModule | A module for alternative channel T0 calibration with collision data Note: after this kind of calibration one cannot do the geometrical alignment This module can also be used to check the calibration |
| CTOPChannelT0MCModule | TOP Channel T0 MC Extraction module (under development) |
| CTOPCommonT0BFCollectorModule | Collector for common T0 calibration with a fit of bunch finder residuals (method BF) |
| CTOPCommonT0CalibratorModule | A module for common T0 calibration with collision data (dimuons or bhabhas) |
| CTOPCommonT0LLCollectorModule | Collector for common T0 calibration with neg |
| CTOPCosmicT0FinderModule | Event T0 finder for global cosmic runs |
| CTOPDatabaseImporter | TOP database importer |
| CTOPDigit | Class to store TOP digitized hits (output of TOPDigitizer or raw data unpacker) relations to TOPSimHits, MCParticles |
| ►CTOPDigitizerModule | TOP digitizer |
| CTimeOffset | Utility structure for time offset |
| CTOPDoublePulseGeneratorModule | Generator of double calibration pulses Output to TOPDigits |
| CTOPDQMModule | TOP DQM histogrammer |
| CTOPFrontEndMap | Mapping of a boardstack number within a module to SCROD and COPPER/Finesse |
| CTOPFrontEndSetting | Front-end settings: storage depths, lookback, readout windows etc |
| CTOPGainEfficiencyCalculatorModule | Module for channel-by-channel gain/efficiency analysis |
| CTOPGeoBarSegment | Geometry parameters of a quartz bar segment |
| CTOPGeoBase | Base class for geometry parameters |
| CTOPGeoColdPlate | Geometry parameters of cold plate (simplified) |
| CTOPGeoEndPlate | Geometry parameters of forward end plate (simplified) |
| CTOPGeoFrontEnd | Geometry parameters of board stack (front-end electronic module) |
| CTOPGeoHoneycombPanel | Geometry parameters of honeycomb panel |
| CTOPGeometry | Geometry parameters of TOP |
| CTOPGeometryParInitializerModule | Class for initializing TOPGeometryPar |
| CTOPGeoMirrorSegment | Geometry parameters of a mirror segment |
| CTOPGeoModule | Geometry parameters of a module (optical components + positioning) |
| CTOPGeoModuleDisplacement | Displacement parameters of a TOP module |
| CTOPGeoPMT | Geometry parameters of MCP-PMT |
| CTOPGeoPMTArray | Geometry parameters of MCP-PMT array |
| CTOPGeoPMTArrayDisplacement | Displacement parameters of MCP-PMT array |
| ►CTOPGeoPrism | Geometry parameters of prism |
| CPeelOffRegion | Parameters of peel-off cookie region (corresponds to 2x2 PMT's) |
| CUnfoldedWindow | Unfolded prism exit window |
| CTOPGeoPrismEnclosure | Geometry parameters of prism enclosure (simplified) |
| CTOPGeoQBB | Geometry parameters of Quartz Bar Box (mother class) |
| CTOPGeoSideRails | Geometry parameters of side rails (simplified) |
| CTOPInterimFEInfo | Class to store debug info of raw data in Interim FE format |
| CTOPInterimFENtupleModule | Module to produce ntuple from TOPDigits and TOPRawDigits |
| CTOPLaserCalibratorCollectorModule | Collector module for the TOP channelT0 calibration and, more in general, for the time resolution studies using the laser and pulser data |
| CTOPLaserCalibratorModule | T0 Laser calibration module (under development) |
| ►CTOPLaserHitSelectorModule | Module for pixel-by-pixel gain/efficiency analysis |
| ChitInfo_t | Structure to hold hit information, used in double cal |
| CTOPLikelihood | Class to store TOP log likelihoods (output of TOPReconstructor) |
| CTOPLikelihoodScanResult | Class to store the result of the TOP LL scan (output of TOPLLScanner) |
| CTOPLLScannerModule | A module to perform the TOP PID likelihood scan and find the actual minimum as function of the mass |
| CTOPMCTrackMakerModule | Constructs Tracks and ExtHits from MCParticles and TOPBarHits Utility needed for testing and debugging of TOP reconstruction |
| CTOPModuleT0CalibratorModule | A module for module T0 calibration with collision data (dimuons or bhabhas) Useful when the geometrical alignment need not to be repeated |
| CTOPModuleT0DeltaTCollectorModule | Collector for module T0 calibration with chi2 minimization of time differences between slots (method DeltaT) |
| CTOPModuleT0LLCollectorModule | Collector for module T0 calibration with neg |
| CTOPNominalQE | Nominal quantum efficiency of PMT |
| CTOPNominalTDC | Nominal time-to-digit conversion parameters (simplified model) |
| ►CTOPNominalTTS | Nominal time transition spread of PMT |
| CGauss | Gaussian distribution parameters |
| CTOPNtupleModule | Module to write out a ntuple summarizing TOP reconstruction output |
| CTOPOffsetCollectorModule | Collector for eventT0 and fill pattern offset calibrations |
| CTOPPackerModule | Raw data packer |
| CTOPPDFCheckerModule | Module for checking analytic PDF used in likelihood calculation |
| ►CTOPPDFCollection | Class to store analytical PDF relation from Tracks filled top/modules/TOPPDFDebugger/src/TOPPDFDebuggerModule.cc |
| CGaussian | Parameters to describe a Gaussian |
| CTOPPDFDebuggerModule | TOP reconstruction module |
| CTOPPhotonYieldsCollectorModule | Collector for photon pixel yields aimed for PMT ageing studies and for finding optically decoupled PMT's |
| CTOPPixelLikelihood | Class to store pixel-by-pixel likelihoods for a track relation from Tracks filled in top/modules/TOPPDFDebugger/src/TOPPDFDebuggerModule.cc |
| CTOPPmtGainPar | Parameterized PMT gain (from laser testing at Nagoya) |
| CTOPPmtInstallation | PMT position within a module |
| CTOPPmtObsoleteData | PMT specs from Hamamatsu |
| CTOPPmtQE | Nagoya measurements of quantum efficiency |
| CTOPPmtTTSHisto | Raw measurements of TTS (histograms) for each PMT pixel |
| ►CTOPPmtTTSPar | Parameterized TTS for each PMT pixel |
| CGaussian | Gaussian distribution parameters |
| CTOPProductionEventDebug | Class to store debugging information about the event headers in the by the TOP production debugging raw data format one of these should be available per boardstack per event |
| CTOPProductionHitDebug | Class to store debugging information about the hit headers in the TOP production debugging raw data format |
| CTOPPull | Class to store photon pull in respect to PDF used in reconstruction |
| CTOPPulseHeightCollectorModule | Collector for channel pulse-height distributions |
| CTOPPulseHeightPar | Struct holding the pulse height parameterizations for the TOP counter |
| CTOPRawDigit | Class to store unpacked raw data (hits in feature-extraction format) It provides also calculation of 50% CFD leading and falling edge times and errors |
| CTOPRawDigitConverterModule | TOPRawDigits to TOPDigits converter |
| ►CTOPRawWaveform | Class to store raw data waveforms |
| CFeatureExtraction | Feature extraction data |
| CTOPRecBunch | Class to store results of TOPBunchFinder |
| ►CTOPReconstructorModule | TOP reconstruction module |
| CPDFCollection | A collection of PDF's of charged stable particles for a given track |
| CTOPRingPlotterModule | A module to plot the x-t images from TOP, and in general study the distribution of the digits associated to the particles in a particleList |
| CTOPSampleTimes | Calibration constants of a single ASIC channel: time axis (sample times) |
| CTOPSignalShape | Normalized shape of single photon pulse (waveform) Pulse must be positive |
| CTOPSimCalPulse | Calibration pulse time and amplitude generated by TOPCalPulseGenerator |
| CTOPSimHit | Class to store simulated hits of Cherenkov photons on PMT's input for digitization module (TOPDigitizer) |
| CTOPSimPhoton | Class to store Cherenkov photons at emission and at detection relation to TOPSimHit filled in top/simulation/src/SensitivePMT.cc |
| CTOPSlowData | Class to store slow data unpacked from raw data |
| CTOPTBCComparatorModule | Module for the comparison of different sets of time base correction (TBC) constants and to produce monitoring plots out of a given set |
| CTOPTemplateFitResult | Class to store template fit result from feature extraction data |
| CTOPTimeBaseCalibratorModule | Time base calibrator |
| CTOPTimeRecalibratorModule | Utility module for re-calibrating time of TOPDigits pulseWidth and timeError are not changed although they may depend no calibration! |
| CTOPTimeZero | Class to store T0 information |
| CTOPTriggerDigit | Class to store trigger time stamps |
| CTOPTriggerDigitizerModule | Digitizer that provides time stamps for TOP trigger |
| CTOPTriggerMCInfo | Class to store Monte Carlo information useful for trigger studies |
| CTOPUnpackerModule | Raw data unpacker |
| CTOPValidationCollectorModule | Collector for automatic validation of calibration with dimuon events |
| CTOPWaveformFeatureExtractorModule | Waveform feature extractor: module adds rawDigits that are found in waveforms by feature extraction but are not already present in RawDigits |
| CTOPWaveformQualityPlotterModule | Plots and histograms of waveforms and feature extracted parameters |
| CTOPWavelengthFilter | Bulk transmittance of wavelength filter |
| CToPXDCKFModule | Combinatorial Kalman Filter that extrapolates every RecoTrack into the PXD and collects space points |
| CToPXDExtrapolator | Findlet to extrapolate found tracks to the PXD sensors and calculate intercepts |
| CTOPXTalkChargeShareSetterModule | Crosstalk & chargeshare flag setter |
| CTouschekReaderTURTLE | Class to read Touschek files and store their content in a MCParticle graph |
| CTouschekTURTLEInputModule | The TouschekTURTLE Input module |
| CTPCG4TrackInfo | Class TPCG4TrackInfo - Geant4 simulated hit for the Microtpc detector |
| CTpcMCParticle | Class TpcMCParticle - Geant4 simulated hit for the Microtpc detector |
| CTPCSimHit | ClassTPCSimHit - Geant4 simulated hit for the TPC crystal in beast |
| CTrack | Class that bundles various TrackFitResults |
| ►Ctrack_maker_t | |
| Cinternal | |
| CTrackAnaModule | A class definition of an input module for Sequential ROOT I/O |
| CTrackBuilder | TrackBuilder class to create the Track/TrackFitResult mdst output from the RecoTrack |
| CTrackClusterSeparation | Store one Track-KLMCluster separation as a ROOT object |
| CTrackCreatorModule | Takes RecoTracks coming from the event reconstructions and fits them with the configured list of particles hypothesis and stores the result in MDST-usable Belle2::Track and Belle2::TrackFitResult classes |
| CTrackDQMEventProcessor | The purpose of this class is to process one event() in TrackDQMModule |
| CTrackDQMModule | DQM of tracks their momentum, Number of hits in tracks, Number of tracks |
| CTracker2D | Unpacker for the 2D tracker |
| CTrackerAlgorithmBase | Base class for TrackerAlgorithms. shall allow a common base for algorithms like the cellular automaton |
| CTrackExtrapolateG4e | Geant4e-based track extrapolation |
| CTrackFilterModule | Generates a new StoreArray from the input StoreArray which has all specified Tracks removed |
| CTrackFinderMCTruthRecoTracksModule | This module uses the simulated truth information (MCParticles and their relations) to determine which hits belong to which particles and writes track candidates filled with necessary information into the DataStore |
| CTrackFinderVXDBasicPathFinderModule | The TrackFinderVXDBasicPathFinder is a low momentum Si-only trackfinder |
| CTrackFinderVXDCellOMatModule | The TrackFinderVXDCellOMatModule is a low momentum Si-only trackfinder |
| CTrackFinderVXDCosmicsStandaloneModule | The TrackFinderVXDCosmicsStandaloneModule Track finder for linear cosmic tracks measured by the VXD without magnetic field and without other subdetectors |
| CTrackFitMomentumRange | The payload containing the momentum threshold to disable the particle hypothesis in the track fit |
| 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 |
| CTrackFitter | Algorithm class to handle the fitting of RecoTrack objects |
| CTrackFitterAndDeleter | Findlet to fit tracks and remove all non fitted ones |
| CTrackFlippingCuts | The payload containing the cuts for 2 mva based filters to decide whether a RecoTrack should be flipped or not |
| CTrackingAbortDQMModule | Tracking DQM Module to monitor aborts & background conditions before the HLT filter |
| 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 |
| CTrackingExpressRecoDQMModule | Tracking ExpressReco DQM |
| CTrackingHLTDQMModule | Tracking HLT DQM |
| CTrackingMomentumScaleFactorsModule | Tracking momentum systematics module: allows for the application of a corrective momentum scale factor which is read from a ParticleWeightingLookUpTable payload |
| CTrackingMVAFilterParameters | Class for the MVA filter payloads |
| CTrackingPerformanceEvaluationModule | This module takes the MCParticles, the Tracks, the RecoTrack, and the MCRecoTracks input and produce a root file containing various histograms showing the performance of the tracking package: fitter, pattern recognition algorithms |
| CTrackIsoCalculatorModule | Calculate track isolation variables on the input ParticleList |
| CTrackLoader | Findlet for loading the seeds from the data store |
| CTrackMatchLookUp | Class to provide convenient methods to look up matching information between pattern recognition and Monte Carlo tracks |
| CTrackNode | Minimal class to store combination of sector and spacePoint, since SpacePoint can not carry sectorConnection |
| CTrackQETrainingDataCollectorModule | Quality Estimator Data Collector Module to collect data for a MVA training using VXDQE_teacher.py |
| CTrackQualityEstimatorMVAModule | Quality estimation module for SpacePointTrackCandidates using multivariate analysis (MVA) |
| CTrackSelector | Select the tracks for the event time extraction |
| CTrackSetEvaluatorGreedyDEVModule | The Greedy algorithm Track-set-evaluator |
| CTrackSetEvaluatorHopfieldNNDEVModule | The Hopfield algorithm Trackset Evaluator |
| CTrackTimeEstimatorModule | Computes the track time, defined as the difference between the average of SVD clusters time and the SVDEvent T0 |
| CTrackToMCParticleRelatorModule | A module to set relations from Track to MCParticle via the RecoTrack the Track is related to |
| 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 |
| CTreeSearcher | Findlet for constructing result paths out of a list of states, which are connected with weighted relations |
| CTrepsInputModule | Input from TREPS generator for ee->eeff |
| CTRGArea2D | A class to represent an 2D area |
| ►CTrgBit | A general interface to get a trigger response |
| CInputBitPattern | Input bit pattern class |
| COutputBitPattern | Output bit pattern class |
| CTRGBitStream | A class to represent a bit stream |
| CTRGBoard | A class to represent a trigger board |
| CTRGCDC | The instance of TRGCDC is a singleton |
| CTRGCDCCell | A class to represent a wire in CDC |
| CTRGCDCCellHit | A class to represent a wire hit in CDC |
| CTRGCDCCircle | A class to represent a circle |
| CTRGCDCCircleFitter | A class to fit a TTrackBase object to a circle |
| CTRGCDCETFUnpackerStore | Example Detector |
| CTRGCDCEventTime | A class of TRGCDC Event Time |
| CTRGCDCEventTimeFinder | A class of TRGCDC Event Time Finder |
| CTRGCDCFitter | A class to fit a TRGCDCTrackBase object |
| CTRGCDCFitter3D | A class to fit tracks in 3D |
| CTRGCDCFrontEnd | A class to represent a CDC front-end board |
| CTRGCDCHelix | TRGCDCHelix parameter class |
| CTRGCDCHough3DFinder | Class of TRGCDCHough3DFinder |
| CTRGCDCHoughFinder | A class to find tracks using Hough algorithm |
| CTRGCDCHoughPlane | A class to represent a Hough parameter plane |
| CTRGCDCHoughPlaneBase | A class to represent a Hough parameter plane |
| CTRGCDCHoughPlaneBoolean | A class to represent a Hough parameter plane |
| CTRGCDCHoughPlaneMulti | A class to represent a Hough parameter plane |
| CTRGCDCHoughPlaneMulti2 | A class to represent a Hough parameter plane |
| CTRGCDCHoughTransformation | An abstract class to represent a Hough transformation |
| CTRGCDCHoughTransformationCircle | A class to represent circle Hough transformation |
| CTRGCDCJLUT | A class to use LUTs for TRGCDC |
| CTRGCDCJSignal | A class to use Signals for TRGCDC 3D tracker |
| CTRGCDCJSignalData | A class to hold common data for JSignals |
| CTRGCDCLayer | A class to represent a cell layer |
| CTRGCDCLink | A class to relate TRGCDCCellHit and TRGCDCTrack objects |
| ►CTRGCDCLpar | TRGCDCLpar class |
| CCpar | Private class cpar |
| ►CTRGCDCLpav | TRGCDCLpav class |
| CSingular | Exception class, no covarience matrix |
| CSingular_c | Exception class, no covarience matrix_c |
| CTRGCDCLUT | A class to use LUTs for TRGCDC |
| CTRGCDCMerger | A class to represent a CDC merger board |
| CTRGCDCModule | A module to simulate the CDC trigger |
| CTRGCDCPeakFinder | A class to find peaks in Hough Plane |
| CTRGCDCPerfectFinder | A class to find 2D tracks using MC information |
| CTRGCDCRelation | A class to represent a wire in CDC |
| CTRGCDCSegment | A class to represent a wire in CDC |
| CTRGCDCSegmentHit | A class to represent a track segment hit in CDC |
| CTRGCDCSteppingAction | A class to control a track in G4 |
| CTRGCDCT2DDQMModule | DQM module of TRGCDCT2D |
| CTRGCDCT3DDQMModule | DQM module for TRGCDCT3D |
| CTRGCDCT3DUnpackerStore | Example Detector |
| CTRGCDCTrack | A class to represent a reconstructed charged track in TRGCDC |
| CTRGCDCTrackBase | A class to represent a track object in TRGCDC |
| CTRGCDCTracker2D | A class to represent a CDC 2D tracker board |
| CTRGCDCTrackMC | A class to represent a GEN_HEPEVT particle in tracking |
| CTRGCDCTrackSegmentFinder | Class of TrackSegmentFinder in TRGCDC |
| CTRGCDCTSFDQMModule | DQM module of TRGCDCTSF |
| CTRGCDCTSFUnpackerStore | Example Detector |
| CTRGCDCTSStreamModule | A module to process CDC trigger data |
| CTRGCDCWire | A class to represent a wire in CDC |
| CTRGCDCWireHit | A class to represent a wire hit in CDC |
| CTRGCDCWireHitMC | A class to represent a MC wire hit in CDC |
| CTRGChannel | A class to represent a serial link between trigger hardware modules |
| CTRGClock | A class to represent a digitized signal. Unit is nano second |
| CTRGDebug | A class for debugging of TSIM |
| CTRGECLBadRun | Raw TC result nefor digitizing |
| CTrgEclBeamBKG | A Class of ECL Trigger clustering |
| CTRGECLBGTCHit | Example Detector |
| CTRGECLBGTCHitModule | |
| CTrgEclBhabha | A Class of ECL Trigger clustering |
| CTRGECLCluster | Example Detector |
| CTrgEclCluster | A Class of ECL Trigger clustering |
| CTrgEclDataBase | Class TrgEclDataBase; |
| CTrgEclDatabaseImporter | Database importer of TRGECL |
| CTRGECLDigi | Digitize result |
| CTRGECLDigi0 | Raw TC result nefor digitizing |
| CTRGECLDigi0MC | Example Detector |
| CTrgEclDigitizer | FAM module |
| CTRGECLDQMModule | Module of ecl trigger DQM |
| CTRGECLETMPara | Raw TC result nefor digitizing |
| CTRGECLETMParameters | DB object to store parameters used in ETM |
| CTRGECLEventTimingDQMModule | This module is for ecl trigger DQM related to L1 event timing |
| CTRGECLFAMAna | Digitize result |
| CTrgEclFAMFit | FAM module |
| CTRGECLFAMModule | A module of FAM |
| CTRGECLFAMPara | Raw TC result nefor digitizing |
| CTRGECLHit | Example Detector |
| CTRGECLHitMC | Example Detector |
| CTrgEclMapping | A class of TC Mapping |
| CTrgEclMaster | ETM class |
| CTRGECLModule | A module of ETM |
| CTRGECLQAMModule | |
| CTRGECLRawdataAnalysisModule | A module of ETM |
| CTRGECLTiming | Digitize result |
| CTrgEclTiming | A Class of ECL Trigger clustering |
| CTRGECLTimingCalModule | Class ECL Trigger Timiing Calibration Module |
| CTRGECLTMMPara | Raw TC result nefor digitizing |
| CTRGECLTrg | Example Detector |
| CTRGECLUnpackerEvtStore | Example Detector |
| CTRGECLUnpackerModule | A module of TRG ECL Unpacker |
| CTRGECLUnpackerStore | Example Detector |
| CTRGECLUnpackerSumStore | Example Detector |
| CTRGECLWaveform | Digitize result |
| CTRGEFFDQMModule | Make summary of data quality from reconstruction |
| CTRGGDL | The instance of TRGGDL is a singleton |
| CTRGGDLCosmicRunModule | Module that returns true if the trigger condition for the 2017 cosmic runs is fulfilled |
| CTRGGDLDBAlgs | The payload class for GDL algorithm |
| CTRGGDLDBBadrun | The payload class for GDL badrun |
| CTRGGDLDBDelay | The payload class for delay of GDL input bit |
| CTRGGDLDBFTDLBits | The payload class for FTDL output bit |
| CTRGGDLDBInputBits | The payload class for GDL input bit |
| CTRGGDLDBPrescales | The payload class for GDL psnm |
| CTRGGDLDBUnpacker | The payload class for PXD cluster charge calibrations |
| CTRGGDLDQMModule | |
| CTRGGDLDST | |
| CTRGGDLDSTModule | |
| CTRGGDLModule | A module to simulate the Global Decision Logic |
| CTRGGDLResults | |
| CTRGGDLSummaryModule | |
| CTRGGDLUnpackerStore | Example Detector |
| CTRGGRL | Class for TRGGRL |
| CTRGGRLConfig | The payload class for GRL parameters |
| CTRGGRLDQMModule | |
| CTRGGRLInfo | Class to store TRGGRL TSIM info |
| CTRGGRLInjectionVetoFromOverlayModule | Module for adding to MC samples the information about the TRG active veto from beam background overlay files |
| CTRGGRLInnerTrack | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLMATCH | Class for CDC2D-ECL Matching in TRGGRL |
| CTRGGRLMatch | A class to represent a matching candidate in TRGGRL A matching candidate consists of a TRGCDCTrack and TRGECLCluster |
| CTRGGRLMATCHKLM | Class for CDC2D-KLM Matching in TRGGRL |
| CTRGGRLMatchModule | Match between CDC trigger track and ECL trigger cluster |
| CTRGGRLModule | A module to simulate the Global Decision Logic |
| CTRGGRLPHOTON | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLProjectsModule | A module to simulate the Global Decision Logic |
| CTRGGRLShortTrack | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLUnpackerStore | Example Detector |
| CTRGOpticalLink | A class to represent a serial link between trigger modules |
| CTRGOpticalLinkFrontEnd | A class to represent a serial link between trigger modules |
| CTRGPoint2D | A class to represent a point in 2D |
| CTRGRAWDATAModule | |
| CTRGSignal | A class to represent a digitized signal. Unit is nano second |
| CTRGSignalBundle | A class to represent a bundle of SignalVectors |
| CTRGSignalVector | A class to represent a bundle of digitized signals |
| CTRGState | A class to represent a state of multi bits |
| 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 |
| CTRGTime | A class to represent a signal timing in the trigger system |
| CTRGTiming | Trigger Timing Information for a fired bit |
| CTRGTOPCombinedT0Decision | TRGTOPCombinedT0Decision |
| ►CTRGTOPDQMModule | |
| ClargestEnergy | |
| ClargestNHits | |
| CslotDecision | |
| CtcEcl | |
| CTRGTOPSlotTiming | TRGTOPSlotTiming |
| CTRGTOPTimeStamp | TRGTOPTimeStamp |
| CTRGTOPTimeStampsSlot | TRGTOPTimeStampsSlot |
| CTRGTOPTimingISim | TRGTOPTimingISim |
| CTRGTOPTimingISimSlot | TRGTOPTimingISimSlot |
| ►CTRGTOPTRD2TTSConverterModule | TRG TOP Raw Digits to TimeStamps Converter |
| CinterimTimeStamp | |
| CtimeOrder | |
| CTRGTOPUnpackerModule | TRG TOP Unpacker |
| CTRGTOPUnpackerStore | TRGTOPUnpackerStore |
| CTRGTOPUnpackerWaveformModule | TRG TOP Unpacker for Timestamps |
| CTRGTOPWaveformPlotterModule | |
| CTRGTOPWaveFormTimeStamp | TRGTOPWaveFormTimeStamp |
| CTRGTOPWaveFormTimeStampsSlot | TRGTOPWaveFormTimeStampsSlot |
| CTRGUtilities | A class to provide TRG utility functions |
| Ctriangle_t | Triangle structure |
| CTriangularInterpolation | The TriangularInterpolation class |
| CTriggerSkimModule | Returns the calibration result from SoftwareTriigerResult for skimming out calibration flagged events |
| CTrueHitInfo | Helper struct that holds information that is needed for the registration of the relation between SpacePoint and TrueHit |
| CTTDDQMModule | TTD Injection DQM module |
| CTTDOffsets | This class contains information to correct the information obtained from the TTD (simple offsets) |
| CTTDUnpackerModule | TTD Unpacker module |
| 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 |
| CTwoHitFilters | The class 'TwoHitFilters' bundles filter methods using 2 hits which are stored in B2Vector3Ds |
| CTwoTimes | Structure to hold calpulse raw times expressed in samples since sample 0 of window 0 |
| CTxModule | Module for encoding data store contents into a RingBuffer |
| CTxSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CUDPSocket | |
| 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 |
| CUpdateParticleTrackCandModule | Updates the seed in TrackCand based on fitted state (at vertex) |
| CUpperBoundedSet | Represents an upper bounded set of arithmetic types |
| 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 |
| CV0FinderModule | V0 finder module |
| CV0findingPerformanceEvaluationModule | This module takes the MCParticles, the V0 candidates input and produce a root file containing various histograms showing the performance of the V0 finding module |
| CV0Fitter | V0Fitter class to create V0 mdst's from reconstructed tracks |
| CV0ObjectsDQMModule | DQM modules to monitor V0 objects |
| CV0ValidationVertex | Class which stores some additional information on V0 vertices |
| CVariableExtractor | Class to extract individual variables |
| 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 |
| CVariablesTTree | Dump on a TTree the values of all the variables in a filter |
| CVariablesTTree< Filter< binaryOperator, Filter< argsA ... >, Filter< argsB ... >, other ... > > | Specialization for binary operators acting on a filter |
| CVariablesTTree< Filter< unaryOperator, Filter< args ... >, other ... > > | Specialization for unary operators acting on a filter |
| CVariablesTTree< Filter< Variable, other ... > > | Specialization for a simple filter |
| CVariablesTTree<> | Defines the interface using an empty template pack |
| CVariableTBranch | This class contains |
| CVariableToReturnValueModule | Module to calculate variable specified by the user and set return value accordingly |
| CVertexVector | Need this container for exception-safe cleanup, GFRave's interface isn't exception-safe as is |
| CVisitor | This is a class template which takes a template class operation as template argument |
| ►CVisualRepMap | Defines a bidirectional (many to many) mapping between TObjects in DataStore and their visual representation |
| CDataStoreEveElementMap | Hide implementation in private class |
| CVoidMetaInfo | The most CPU efficient MetaInfo for the DirectedNode-requirements (even if useless) |
| CVoidObserver | The most CPU efficient Observer for the VXDTF filter tools (even if useless) |
| CVRMLWriterModule | The VRML-writer module |
| CVXDAlignment | VXD alignment (and maybe some calibration) parameters |
| CVXDAlignmentPar | The Class for VXD Alignment payload |
| CVXDBoxPositionsPar | The Class for VXD doc box envelope |
| CVXDBoxTypesPar | The Class for VXD doc box |
| CVXDCDCTrackMergerModule | VXDCDCTrackMergerModule a module to merge VXD and CDC tracks |
| CVXDDedxLikelihood | Container for likelihoods obtained by the VXD dE/dx PID (VXDDedxPIDModule) |
| CVXDDedxPIDModule | Extract dE/dx from fitted tracks |
| CVXDDedxPIDRemakerModule | Module that re-makes VXD PID likelihoods by taking dE/dx stored in VXDDedxTracks and lookup table PDF's from DB |
| CVXDDedxTrack | Debug output for VXDDedxPID module |
| CvxdDigitMaskingModule | PXD DQM Module |
| CVXDDQMExpressRecoModule | VXD DQM Module |
| CVXDElectronDeposit | Packed class to represent energy deposit along a path in electrons |
| CVXDEnvelopePar | The Class for VXD Envelope parameters |
| CVXDGeoComponent | Class holding all parameters for an VXD geometry component |
| CVXDGeoComponentPar | The Class for VXD geometry component |
| CVXDGeoLadder | Struct containing all parameters of one ladder |
| CVXDGeoLadderPar | The Class for VXD Ladder payload |
| CVXDGeometryPar | The Class for VXD geometry |
| CVXDGeoPlacement | Class holding all parameters to place a VXD geometry subcomponent |
| CVXDGeoPlacementPar | The Class for VXD placement payload |
| CVXDGeoRadiationSensorsPar | The Class for VXD Radiation Sensor parameters |
| CVXDGeoRadiationSensorsPositionPar | The Class for VXD Radiation Sensor Position parameters |
| CVXDGeoSensor | Struct holding all parameters for a completeVXD Sensor |
| CVXDGeoSensorPar | The Class for VXD Sensor payload |
| CVXDGeoSensorPlacement | Struct holding the information where a sensor should be placed inside the ladder |
| CVXDGeoSensorPlacementPar | The Class for VXD Sensor Placement payload |
| CVXDGlobalPar | The Class for VXD global parameter payload |
| CVXDHalfShellPar | The Class for VXD half shell payload |
| CVxdID | Class to uniquely identify a any structure of the PXD and SVD |
| CVXDIntercept | VXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with a VXD sensor |
| CVXDInterceptor | This Class implements the interceptor of the SVD tracks on the PXD layers |
| ►CVXDMomentumEstimation | Class doing the momentum estimation from dEdX for SVDClusters and PXDClusters |
| CCorrectionFitParameters | Struct holding the parameters of the correction function to map them median of the estimation function to 0 |
| CFitParameters | Struct holding the parameters of the estimation function which maps dEdX to p |
| CVXDMomentumEstimationMeasurementCreator | Creator for VXDMeasurements with momentum estimation based on the dEdX information |
| CVXDMomentumEstimationTools | Tools needed for the VXD momentum estimation to, e.g |
| CVXDPolyConePar | The Class for VXD PolyCone, possibly with coutouts |
| CVXDPolyConePlanePar | The Class for VXD Polycone Plane |
| CVXDQETrainingDataCollectorModule | VXD Quality Estimator Data Collector Module to collect data for a MVA training using VXDQE_teacher.py |
| CVXDQualityEstimatorMVAModule | Quality estimation module for SpacePointTrackCandidates using multivariate analysis (MVA) |
| CVXDRotationSolidPar | The Class for VXD Envelope parameters |
| CVXDSensorInfoBasePar | Namespace to provide code needed by both Vertex Detectors, PXD and SVD |
| CVXDServiceGeometryPar | The Class for VXD service geometry |
| CVXDSimHit | Class VXDSimHit - Geant4 simulated hit for the VXD |
| CVXDSimpleClusterizerModule | Module to convert TrueHits into Clusters using a simplified process |
| CVXDSlotsPar | The Class for Slot types |
| CVXDTFFilters | Class that contains all the static sectors to which the filters are attached |
| CVXDTFTrainingDataCollectorModule | The VXDTFTrainingDataCollectorModule |
| CVXDTrackCandidatesQualityIndicatorCutterModule | Module that selects a subset with a fixed minimum qualityIndicator out of all SpacePointTrackCandidates |
| CVXDTrueHit | Class VXDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| CWeightSVDResultFilter | Base filter for CKF SVD results (on overlap check) |
| CWireID | Class to identify a wire inside the CDC |
| CWriter | |
| CXHitFilterFactory | The factory serves as an interface between all x-hit-filters and a user only knowing their name (in string), but not their type |
| CXmlFile | DB object which stores whole xml |
| Cxy_t | A simple 2d vector structure |
| CZIGGZAGGRZ_NAME | Checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the R-Z-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging) |
| CZIGGZAGGXY_NAME | Checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the X-Y-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging) |
| CZIGGZAGGXYWITHSIGMA_NAME | Checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the X-Y-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging) |
| CZMQAcceptor | App to only send a confirmation on every incoming message - behaves the same as the input of a (final)collector (but without an output) |
| CZMQAddressUtils | Summary of some address helpers |
| CZMQClient | A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket |
| CZMQCollector | Normal collector app: receive messages on the input reacting with a confirmation message and sends them out via a load-balanced connection to ready workers |
| 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 |
| CZMQDataAndROIOutput | Helper connection hosting both a normal raw and a ROI output and sending to both at the same time |
| CZMQDistributor | Standard distributor app: receive data via a raw connection (e.g |
| CZMQEventProcessor | This class provides the core event processing loop for parallel processing with ZMQ |
| CZMQFinalCollector | Final collector app: receive messages on the input reacting with a confirmation message and sends them out via a raw connection (e.g |
| CZMQFinalCollectorWithROI | Special form of the ZMQFinalCollector for sending out the additional data message to a ROI receiver |
| CZMQHistogramOutput | Add the common functionality to the histogram output classes |
| CZMQHistogramToFileServer | Final histogram app: receive histogram messages from all clients and react with a confirmation message |
| CZMQHistogramToRawServer | Non-Final histogram app: receive histogram messages from all clients and react with a confirmation message |
| CZMQHistogramToZMQServer | Non-Final histogram app: receive histogram messages from all clients and react with a confirmation message |
| CZMQHistoServerToFileOutput | Output histograms into a ROOT file and shared memory after merging |
| CZMQHistoServerToRawOutput | Same as ZMQHistoServerToZMQOutput just send uncompressed to a raw output |
| CZMQHistoServerToZMQOutput | Send the histograms as compressed byte stream via a ZMQConfirmedOutput connection after merging with all the properties of a normal confirmed output |
| CZMQIdMessage | A message with the socket ID. Needed in input<->worker communication |
| CZMQInputAdapter | |
| 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 |
| CZMQOutputAdapter | Special collector app for translating between ZMQ and raw connections: send ready messages (like a typical worker) on the input and send all received events to the raw connection at output |
| CZMQParent | A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed |
| CZMQProxyCollector | Special collector app: receive messages on the input reacting with a confirmation message and sends them out via a confirmed connection to ready workers |
| 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 |
| CZMQReadySender | App to only send a ready on every incoming message - behaves the same as the input of a worker (but without an output) |
| CZMQROIOutput | Dedicated output to send ROI messages to the PXD ONSEN system |
| 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 |
| CZMQStandardApp | Generic base class for all standalone ZMQ applications |
| 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 |
| CZMQWorker | App to mimick a basf2-worker by accepting an incoming message with a ready message and sending it out via the output - requiring a confirmation message from the next step |
| ►NBHWidePlots | |
| CShowMCParticles | |
| ►Ncaf_cdc | |
| CCDCCalibration | |
| ►Ncaf_cdcdedx_electron | |
| CCDCDedxCalibration | |
| ►Ncdc_and_svd_ckf_merger_mva_training | |
| CCKFResultFilterTeacherTask | |
| CGenerateSimTask | |
| CLSFMemoryIntensiveTask | |
| CLSFTask | |
| CResultRecordingTask | |
| CSplitNMergeSimTask | |
| CSummaryTask | |
| CValidationAndOptimisationTask | |
| ►NcdcAutomatonTrackingValidation | |
| CCDCAutomaton | |
| ►NcdcAutomatonTrackingValidationBkg | |
| CCDCAutomaton | |
| ►NcdcCombinedTrackingValidation | |
| CCDCCombined | |
| ►NcdcCombinedTrackingValidationBkg | |
| CCDCCombined | |
| ►NcdcCRTrackingValidation | |
| CCDCCR | |
| ►NcdcFullTrackingValidation | |
| CCDCFull | |
| ►NcdcFullTrackingValidationBkg | |
| CCDCFull | |
| ►NCDCHistMaker | |
| CCDCHistMakerModule | |
| ►NcdcLegendreTrackingValidation | |
| CCDCLegendre | |
| ►NcdcLegendreTrackingValidationBkg | |
| CCDCLegendre | |
| ►Ncdcplotmodule | |
| CCDCPlotModule | |
| ►Ncdst_timeResoNtuple | |
| CNtuple | |
| ►NcheckCalibDB | |
| CCheckCalibDB | |
| ►NcheckCalpulse | |
| CHistogrammer | |
| ►NcheckDB-commonT0 | |
| CCheckCalibDB | |
| ►NcheckDB-moduleT0 | |
| CCheckCalibDB | |
| ►NcheckDB-photonYields | |
| CSaveHisto | |
| ►NcheckEventInfo | |
| CCheck_info | |
| ►NcheckFrontEndMaps | |
| CCheckFrontEndMaps | |
| ►NcheckHitHeightAndWidth | |
| CHistogrammer | |
| ►NCheckNegativeWeights | |
| CCheckNegativeWeights | |
| ►NcheckTBCAsic | |
| CCheckTBCAsic | |
| ►Nckf | |
| ►Nvalidation | |
| CVxdCdcMergerHarvesterMCSide | |
| CVxdCdcMergerHarvesterPRSide | |
| ►Nclean_bg_file | |
| CSVDTrigger | |
| ►Nclustercontrol | |
| CCluster | |
| ►Nclustercontrolbase | |
| CClusterBase | |
| ►Nclustercontroldrmaa | |
| CCluster | |
| ►Nclustercontrolsge | |
| CCluster | |
| ►NClusterEfficiency | |
| CClusterEfficiency | |
| ►NclusterFilterValidation | |
| CClusterFilterValidationModule | |
| CClusterFilterValidationRun | |
| ►Ncombined_cdc_to_svd_ckf_mva_training | |
| CCKFResultFilterTeacherTask | |
| CCKFStateFilterTeacherTask | |
| CGenerateSimTask | |
| CLSFMemoryIntensiveTask | |
| CLSFTask | |
| CResultRecordingTask | |
| CSplitNMergeSimTask | |
| CStateRecordingTask | |
| CSummaryTask | |
| CValidationAndOptimisationTask | |
| ►Ncombined_to_pxd_ckf_mva_training | |
| CCKFResultFilterTeacherTask | |
| CCKFStateFilterTeacherTask | |
| CGenerateSimTask | |
| CLSFMemoryIntensiveTask | |
| CLSFTask | |
| CResultRecordingTask | |
| CSplitNMergeSimTask | |
| CStateRecordingTask | |
| CSummaryTask | |
| CValidationAndOptimisationTask | |
| ►NCombinedSVDTrackingValidation | |
| CCombinedSVDTrackingValidation | |
| ►NCombinedSVDTrackingValidationBkg | |
| CCombinedSVDTrackingValidationBkg | |
| ►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 | |
| ►NcosmicsAxialHoughTrackingValidation | |
| CCosmicsAxialHough | |
| ►NcosmicsHoughTrackingValidation | |
| CCosmicsHough | |
| ►NcosmicsTrackingValidation | |
| CCosmics | |
| ►Ncreate_trainer | |
| CGraFEIIgniteTrainer | |
| ►Ndataset | |
| CArrayDataset | |
| ►NDBImporter | |
| CPayloadImporter | |
| ►NDBImportTBC | |
| CPayloadImporter | |
| ►Ndebug_display | |
| CCDCDebugDisplayRun | |
| ►NdecayHash | |
| CDecayHashMap | |
| ►Ndft | |
| ►Ntensorflow_dnn_model | |
| CDefaultModel | |
| CLayer | |
| CMultilayerPerceptron | |
| CTrainer | |
| ►NTfData | |
| CTfDataBasf2 | |
| CTfDataBasf2Stub | |
| ►Ndisplaydata | |
| CDisplayDataTest | |
| ►Ndisplaytriggered | |
| CDisplayHLTTags | |
| ►Ndplot | |
| CPrior | |
| ►Ndqm | |
| CDQM | |
| ►NDumpDigits | |
| CDumpDigits | |
| ►NdumpGeometryParameters | |
| CprintSVDLadders | |
| CprintSVDPitches | Test SVD geometry |
| CprintSVDSensors | |
| CprintSVDSizes | |
| CprintSVDStripLengths | |
| CprintSVDStripPositions | |
| ►NdumpSensorInfoParameters | |
| CprintMobility | |
| CprintVelocity | Test SVD SensorInfo getters |
| ►NdumpSimulationParameters | |
| CprintAduEquivalent | |
| CprintElectronicNoise | Test SVD SensorInfo getters |
| ►NEclShapeFitter | |
| CShapeFitterModule | |
| ►Necms | |
| CPlotter | |
| ►NETF_OldVsNew | |
| CTestModule | |
| ►NevalPriors | |
| CPriors | |
| ►NEventCountLimiter | |
| CEventCountLimiter | |
| ►NEventDisplayer | |
| CEventDisplayer | |
| ►NEventInspector | |
| CEventInspector | |
| ►NEventInspectorLookback | |
| CEventInspectorLookback | |
| ►NEventInspectorPocketDAQ | |
| CEventInspectorPocketDAQ | |
| ►Nfei | |
| ►Nconfig | |
| CParticle | |
| ►Ncore | |
| CFSPLoader | |
| CPostReconstruction | |
| CPreReconstruction | |
| CTeacher | |
| CTrainingData | |
| CTrainingDataInformation | |
| ►Nmonitoring | |
| CMonitoringBranchingFractions | |
| CMonitoringHist | |
| CMonitoringModuleStatistics | |
| CMonitoringNTuple | |
| CMonitoringParticle | |
| CStatistic | |
| ►Nfill_array_example | |
| CInjectPXDDigits | |
| ►Nfirm2d | |
| CSkim | |
| ►NFitter_OldVsNew | |
| CTestModule | |
| ►NfitValidation | |
| CFitValidation | |
| CFitValidationModule | |
| ►Nframework | |
| CAlgorithm | |
| CCAF | |
| CCalibration | |
| CCalibrationBase | |
| CCollection | |
| ►NfullInvertedTrackingValidationBkg | |
| CInvertedFullBkg | |
| ►NfullTrackingTableValidationCreateData | |
| CVxdCdcPartFinderHarvester | |
| ►NfullTrackingValidation | |
| CFull | |
| ►NfullTrackingValidation_plusEclSeeding | |
| CfullTrackingValidation_plusECL | |
| ►NfullTrackingValidation_releaseValidation | |
| CFull | |
| ►NfullTrackingValidationBkg | |
| CFullBkg | |
| ►Ngatgap | |
| CGATGAPModel | |
| CGATModule | |
| ►NgenPixelLikelihoods | |
| CWriteData | |
| ►NGeoCacheDemo | |
| CPrintPXDHits | |
| ►Ngeometric_datasets | |
| CGraphDataSet | |
| ►Ngeometric_layers | |
| CEdgeLayer | |
| CGlobalLayer | |
| CNodeLayer | |
| ►Ngeometric_network | |
| CGraFEIModel | |
| ►NgetModuleT0Histo | |
| CSaveModuleT0 | |
| ►NgetTBCInfo | |
| CPrintInfo | |
| ►NGraFEIModule | |
| CGraFEIModule | |
| ►Nharvester | |
| CFitHarvester | |
| CMCParticleHarvester | |
| CMCTrajectoryHarvester | |
| CPXDHarvester | |
| CReconstructionPositionHarvester | |
| CSeedsAnalyser | |
| CSegmentFakeRatesModule | |
| CSegmentFinderParameterExtractorModule | |
| CSVDHarvester | |
| CVXDHarvester | |
| CVXDMomentumEnergyEstimator | |
| CWrongRLInfoCounter | |
| ►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 | |
| ►NHepGeom | |
| CPoint3D | |
| ►Nhighlight_particle | |
| CHighlighterModule | |
| ►Nhistogram | |
| CHistograms | |
| ►Nhistogram_monitor | |
| CGenerateHist | |
| ►Nhlt | |
| ►Nclean_execution | |
| CCleanBasf2Execution | |
| ►Nhow_to_use_arbitrary_methods | |
| CMyFancyClassifier | |
| ►NimportFrontEndMaps | |
| CImportFrontEndMaps | |
| ►Ninspector | |
| CInspectorModule | |
| ►Ninteractive | |
| CBasf2IPythonPrompt | |
| ►Ninteractive_python | |
| CMinModule | |
| ►Njson_objects | |
| CComparison | |
| CComparisonHtmlContent | |
| CComparisonNTuple | |
| CComparisonPackage | |
| CComparisonPlot | |
| CComparisonPlotFile | |
| CComparisonResult | |
| CComparisonRevision | |
| CComparisonState | |
| CHtmlContent | |
| CJsonBase | |
| CNTuple | |
| CPackage | |
| CPlot | |
| CPlotFile | |
| CRevision | |
| CRevisions | |
| CScript | |
| ►Nkeras_relational | |
| CEnhancedRelations | |
| CRelations | |
| ►Nklm_alignment | |
| CKLMAlignment | |
| ►Nklm_channel_status | |
| CKLMChannelStatus | |
| ►Nklm_strip_efficiency | |
| CKLMStripEfficiency | |
| ►NKLMK0LPlotModule | |
| CKLMK0LPlotModule | |
| ►NKoralWPlots | |
| CShowMCParticles | |
| ►NlaserPixelIlumination | |
| CHistogrammer | |
| ►Nlca_to_adjacency | |
| CInvalidLCAMatrix | |
| CNode | |
| ►NLCASaverModule | |
| CLCASaverModule | |
| ►Nlow_multiplicity_sorcery | |
| ►Nconstants | |
| CEventCode | |
| ►Nutils | |
| CEventRangePathSplitter | |
| CExtraInfoPathSplitter | |
| ►Nmail_log | |
| CMails | Provides functionality to send mails in case of failed scripts / validation plots |
| ►NmakeBGOverlayFromData | |
| CSelectTRGTypes | |
| ►Nmetaoptions | |
| CMetaOptionParser | |
| ►Nmetrics | |
| CPerfectEvent | |
| CPerfectLCA | |
| CPerfectMasses | |
| ►Nmonitor_module | |
| CMonitor | |
| ►NmultiTrain | |
| CMultiTrainLoss | |
| ►NmuonTrackingValidation | |
| CMuon | |
| ►Nneurotrigger | |
| Ccasefilter | |
| Cnnt_eventfilter | |
| Crandommaker | |
| ►NNN_filter_module | |
| CNNFilterModule | |
| ►NNN_trainer_module | |
| Cdata_production | |
| CSaveFlag | |
| CTrainDataSaver | |
| ►Nnntd | |
| Cnntd | |
| ►NnoCKFValidationBkg | |
| CCKFBkg | |
| ►Nnt | |
| ►Nalgorithms | |
| C__group | |
| Cidentity_t | |
| ►Ncomparators | |
| C_nt_compare | |
| Con_common_args_t | |
| Cax_name_container | |
| ►Cax_name_container_base | |
| Ctype_wrap | |
| Cax_name_container_base_const | |
| Cax_type | |
| Cax_type2 | |
| Cbase_maker | |
| Ccontains_type | |
| Ccontains_type< T, ntuple< ARGS... > > | |
| Cdataframe | |
| Cdataframe_maker | |
| Cdataframe_maker< ntuple< T... > > | |
| Cntuple | |
| ►Cspan | |
| Citerator | |
| Ctype_container | |
| ►Nonline_book_statistics | |
| CStatistics | |
| CStatisticsVisitor | |
| ►NParticleGunPlots | |
| CShowMCParticles | |
| ►Nper_event_statistics | |
| CPerEventStatisticsGetterModule | |
| ►Nperfect_match | |
| CPrintTRGTime | |
| ►Npgun_vertex | |
| CVisualizeVertex | |
| ►NPhokharaEvtgenAnalyze | |
| CPhokharaEvtgenAnalysisModule | |
| ►Npickable_basf2 | |
| CBASF2StateRecorder | |
| ►Npid_ttree_writer | |
| CTreeWriterModule | |
| ►NpidTrainWeights | |
| CWeightNet | |
| ►Nplot_LL_diff | |
| CMinModule | |
| ►NplotPXDPositionEstimator | |
| CPlotClusterPositionEstimatorPayload | |
| ►Nplotting | |
| CBox | |
| CCorrelation | |
| CCorrelationMatrix | |
| CDiagonal | |
| CDifference | |
| CDistribution | |
| CImportance | |
| CMultiplot | |
| COvertraining | |
| CPlotter | |
| CPrecisionRecallCurve | |
| CPurityAndEfficiencyOverCut | |
| CPurityOverEfficiency | |
| CRejectionOverEfficiency | |
| CSignalToNoiseOverCut | |
| CTrueVsFalsePositiveRate | |
| CTSNE | |
| CVerboseDistribution | |
| ►NpmtPulseHeights | |
| CSaveCanvases | |
| ►Npreprocessing | |
| Cfast_equal_frequency_binning | |
| ►Nprint_calib_trig_results | |
| CPrintCalibTriggerResults | |
| ►NprintPIDLikelihoods | |
| CprintPIDLikelihoods | |
| ►NPrintTrueHits | |
| CCheckTrueHits | |
| ►NpriorDataLoaderAndModel | |
| CPriorDataLoader | |
| CPriorModel | |
| ►Npxd | |
| ►Nbackground_generator | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| ►Nmodels | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| ►Nconvnet | |
| CModel | Class for the ConvNet generator model |
| ►Nieagan | |
| CAttention | |
| Cbn | |
| CCBAM_attention | |
| Cccbn | |
| CEncoderBlock | |
| CGBlock | |
| CGenerator | |
| Cidentity | |
| CILA | |
| CModel | |
| CMultiheadAttention | |
| CmyBN | |
| CRelationalReasoning | |
| CSN | |
| CSNConv2d | |
| CSNEmbedding | |
| CSNLinear | |
| ►Nresnet | |
| CModel | Class for the ResNet generator model |
| CResidualBlock | Class for the residual block layer |
| CPXDBackgroundGenerator | Class for the PXD background generator module |
| ►Ncalibration | |
| ►Ncalibration_checker | |
| CCalibrationCheckerBase | |
| CPXDHotPixelMaskCalibrationChecker | |
| ►Ncondition_checker | |
| CConditionCheckerBase | |
| CPXDDeadPixelsChecker | |
| CPXDGainMapChecker | |
| CPXDMaskedPixelsChecker | |
| CPXDOccupancyInfoChecker | |
| ►NPXDHitErrors | |
| CPXDHitErrors | |
| ►NPXDHitErrorsTTree | |
| CPXDHitErrorsTTree | |
| ►NPXDROIUnpackerModule | |
| CPXDPayloadROIUnpackerModule | |
| CPXDRawROIUnpackerModule | |
| ►Nqam | |
| CQAM | |
| ►Nquantity_extract | |
| CRootQuantityExtract | |
| ►Nread_array_example | |
| CPXDReader | |
| ►NReadTSIMInfo | |
| CCreateLogics | |
| ►Nrecord | |
| CElossHarvestingModule | |
| CElossHarvestingRun | |
| CLegendreBinningValidationModule | |
| CLegendreBinningValidationRun | |
| CSegmentFitValidationModule | |
| CSegmentFitValidationRun | |
| ►Nregister_pystorearray | |
| CParticleStatisticsModule | |
| CSillyGeneratorModule | |
| ►Nrelations | |
| Cearly_stopping | |
| ►Nroot_handler | |
| CTrackingValidationResult | |
| ►Nrundb | |
| CRunDB | |
| ►Nrunners | |
| CAlgorithmsRunner | |
| CRunner | |
| CRunnerError | |
| CSeqAlgorithmsRunner | |
| ►NRunSADBgMC_phase1 | |
| CPyTrigger | |
| ►NSavedMCParticles | |
| CCheckMCParticles | |
| ►NsavingFlippingVariables | |
| CSaving1stMVAData | |
| ►NsavingFlippingVariablesFor2ndMVA | |
| CSaving2ndMVAData | |
| ►Nscripts | |
| ►Nbitstring | |
| CBitArray | |
| CBits | |
| CBitStream | |
| CByteAlignError | |
| CByteStore | |
| CConstBitStream | |
| CConstByteStore | |
| CCreationError | |
| CError | |
| CInterpretError | |
| CMmapByteArray | |
| CReadError | |
| ►NeffCalculation | |
| CEffModule | |
| ►Nreadout | |
| CMinModule | |
| ►Nwriter | |
| CRealVariable | |
| CScalarVariable | |
| CVariable | |
| CVCDPhaseError | |
| CVCDWriter | |
| CVectorVariable | |
| ►Nsegment_quad_tree | |
| CSegmentQuadTreeRun | |
| ►NsegmentPairCreationValidation | |
| CSegmentPairCreationValidationModule | |
| CSegmentPairCreationValidationRun | |
| ►NSetMetaTimeModule | |
| CSetMetaTimeModule | |
| ►NSetSensitiveThreshold | |
| CSetVXDSensitiveThreshold | |
| ►NshowFEWaveforms | |
| CWFDisplay | |
| ►Nsimple | |
| CModel | |
| CmyModel | |
| ►NsimpleEventDisplay | |
| CTOPDisplay | |
| ►Nsoftwaretrigger | |
| ►Ncli | |
| CDownloadableDatabase | |
| CHashableCut | |
| ►Nconstants | |
| CDQMModes | |
| CEventDistributionModes | |
| CHLTPrefilterModes | |
| CLocation | |
| CRunTypes | |
| CSoftwareTriggerModes | |
| ►Ntest_support | |
| CCheckForCorrectHLTResults | |
| ►Nvariable_modules | |
| CPickleHarvestingModule | |
| CSummarizeTriggerResults | |
| CSummarizeTriggerVariables | |
| ►Nsplit_file | |
| CSplit | |
| ►NSplitMultiplicities | |
| CSplitMultiplicities | |
| ►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 |
| ►Nstate_machines | |
| CAlgorithmMachine | |
| CCalibrationMachine | |
| CConditionError | |
| CMachine | |
| CMachineError | |
| CState | |
| CTransitionError | |
| ►Nstd | STL namespace |
| Chash< Belle2::SubGraphID > | Customized hash-function for being able to use unordered_map |
| Chash< std::set< int > > | Hash function used by unordered_set |
| ►Nsteering | |
| CRandomTestModule | |
| ►Nstrategies | |
| CAlgorithmStrategy | |
| CSequentialBoundaries | |
| CSequentialRunByRun | |
| CSimpleRunByRun | |
| CSingleIOV | |
| CStrategyError | |
| ►NstudyLaserLight | |
| CTOPLaserHistogrammerModule | |
| ►NstudyTBCResolution | |
| CTOPTBCResolution | |
| ►Nsvd | |
| ►NCoGCalibration_utils | |
| CSVDCoGTimeCalibrationImporterModule | |
| ►NCoGCalibration_utils_checkCalibration | |
| CSVDCoGTimeCalibrationCheckModule | |
| ►NCoGCalibration_utils_tbindependent | |
| CSVDCoGTimeCalibrationImporterModule | |
| ►NcrossTalkSkim_util | |
| CskimCrossTalkEventsModule | |
| ►Ndump_clusters | |
| Cdump_clusters | |
| ►Ndump_digits | |
| Cdump_digits | |
| ►NexecutionTime_utils | |
| CSVDExtraEventStatisticsModule | |
| ►Nskim_utils | |
| Cskim6SampleEventsPyModule | |
| CskimFineTRGEventsPyModule | |
| CskimLowHighEventT0EventsPyModule | |
| CskimOutRNDTrgModule | |
| CskimSVDBurstEventsModule | |
| CskimSVDTriggerBinEventsPyModule | |
| ►NsvdCoGCalibrationAnalysisToolModule | |
| CsvdCoGCalibrationAnalysisTool | |
| ►NSVDSimBase | |
| CSampleGenerator | |
| Ctau_encoder | |
| ►NSVDChannelMappingImporter | |
| CdbImporterModule | |
| ►NSVDChargeSharing | |
| CSVDChargeSharing | |
| ►NSVDChargeSimulationImporter | |
| CdefaultChargeSimulationImporter | |
| ►NSVDDefault3SampleCoGTimeCalibrationImporter | |
| CdefaultCoGTimeCalibrationImporter_pol1TBdep | |
| CdefaultCoGTimeCalibrationImporter_pol3TBindep | |
| ►NSVDDefault3SampleELSTimeCalibrationImporter | |
| CdefaultELSTimeCalibrationImporter_pol1TBdep | |
| CdefaultELSTimeCalibrationImporter_pol3TBindep | |
| ►NSVDDefault6SampleCoGTimeCalibrationImporter | |
| CdefaultCoGTimeCalibrationImporter_pol1TBdep | |
| CdefaultCoGTimeCalibrationImporter_pol3TBindep | |
| ►NSVDDefaultClusteringImporter | |
| CdefaultSVDClusteringImporter | |
| ►NSVDDefaultCoGOnlyErrorScaleFactorsImporter | |
| CdefaultSVDCoGOnlyErrorScaleFactorsImporter | |
| ►NSVDDefaultCoGOnlyPositionErrorImporter | |
| CdefaultSVDCoGOnlyPositionErrorImporter | |
| ►NSVDDefaultCrossTalkStripsImporter | |
| CdefaultCrossTalkStripsImporter | |
| ►NSVDDefaultDetectorConfigurationImporter | |
| CdefaultSVDConfigParametersImporter | |
| ►NSVDDefaultFADCMaskedStripsImporter | |
| CdefaultFADCMaskedStripsImporter | |
| ►NSVDDefaultHitTimeSelectionImporter | |
| CdefaultSVDHitTimeSelectionImporter | |
| ►NSVDDefaultHotStripsImporter | |
| CdefaultHotStripsImporter | |
| ►NSVDDefaultNoiseImporter | |
| CdefaultNoiseImporter | |
| ►NSVDDefaultOccupancyImporter | |
| CdefaultOccupancyImporter | |
| ►NSVDDefaultOldDefaultErrorScaleFactorsImporter | |
| CdefaultSVDOldDefaultErrorScaleFactorsImporter | |
| ►NSVDDefaultPedestalImporter | |
| CdefaultPedestalImporter | |
| ►NSVDDefaultPulseShapeImporter | |
| CdefaultPulseShapeImporter | |
| ►NSVDDetectorConfigurationImporter | |
| CconfigImporterToDBModule | |
| ►NSVDEventT0ConfigurationImporter | |
| CsvdEventT0ConfigurationImporter | |
| ►NsvdGroupingPerformance | |
| CSVDGroupingPerformance | |
| ►NSVDHoughTrackingValidation | |
| CSVDHoughTrackingValidation | |
| ►NSVDHoughTrackingValidationBkg | |
| CSVDHoughTrackingValidationBkg | |
| ►NSVDLocalCalibrationsImporter | |
| CdbImporterModule | |
| ►NSVDRecoConfigurationImporter | |
| CrecoConfigurationImporter | |
| ►NSVDShaperDigitsOrderingTest | |
| CtestSVDShaperDigitOrdering | |
| ►NSVDSpacePointSNRFractionSelectorImporter | |
| CsvdSpacePointSelectionFunctionImporter | |
| ►NSVDTimeGroupingConfigurationImporter | |
| CtimeGroupingConfigurationImporter | |
| ►NSVDValidationTTreeCluster | |
| CSVDValidationTTreeCluster | |
| ►NSVDValidationTTreeRecoDigit | |
| CSVDValidationTTreeRecoDigit | |
| ►NSVDValidationTTreeRecoTrack | |
| CSVDValidationTTreeRecoTrack | |
| ►NSVDValidationTTreeSimhit | |
| CSVDValidationTTreeSimhit | |
| ►NSVDValidationTTreeSpacePoint | |
| CSVDValidationTTreeSpacePoint | |
| ►NSVDValidationTTreeStrip | |
| CSVDValidationTTreeStrip | |
| ►NSVDValidationTTreeTrueHit | |
| CSVDValidationTTreeTrueHit | |
| ►Nsysvar | |
| CReweighter | |
| CReweighterParticle | |
| ►Nt0CalTime | |
| CNtuple | |
| ►Nterminal_utils | |
| CANSIColors | |
| CInputEditor | |
| CPager | |
| ►Ntest6_CPVFlavorTaggerEfficiency | |
| CQuiet | |
| ►Ntest_cluster_position_estimator | |
| CPXDPositionEstimation | |
| ►NtestCosmicT0Finder | |
| CNtuple | |
| CShiftDigits | |
| ►NtestNewReco | |
| CSVDClustersQuickCheck | |
| CSVDRecoDigitsQuickCheck | |
| ►NtoCDCCKFTrackingValidationBkg | |
| CtoCDCCKFValidationBkg | |
| ►NtoCDCfromEclCKFTrackingValidation | |
| CtoCDCfromEclCKF | |
| ►NtoCDCfromEclCKFTrackingValidation_onlyEclSeed | |
| CtoCDCfromEclCKF | |
| ►NTOPFE_qualityPlots | |
| CWaveformAnalyzer | |
| ►Ntorch_tcce | |
| CTCCE | |
| ►Ntrackfindingcdc | |
| ►Ncdcdisplay | |
| ►Nsvgdrawing | |
| ►Nattributemaps | |
| CBackgroundTagColorMap | |
| CCDCHitColorMap | |
| CCDCHitStrokeWidthMap | |
| CCDCSegmentColorMap | |
| CMCParticleColorMap | |
| CMCPDGCodeColorMap | |
| CMCPrimaryColorMap | |
| CMCSegmentIdColorMap | |
| CPosFlagColorMap | |
| CReassignedSecondaryMap | |
| CRLColorMap | |
| CSegmentFBInfoColorMap | |
| CSegmentFirstInTrackIdColorMap | |
| CSegmentFirstNPassedSuperLayersColorMap | |
| CSegmentLastInTrackIdColorMap | |
| CSegmentLastNPassedSuperLayersColorMap | |
| CSegmentMCTrackIdColorMap | |
| CTakenFlagColorMap | |
| CTOFColorMap | |
| CWrongRLColorMap | |
| CZeroDriftLengthColorMap | |
| CZeroDriftLengthStrokeWidthMap | |
| CCDCSVGPlotter | |
| ►Nmodules | |
| CCDCHitUniqueAssumer | |
| CHitCleaner | |
| ►Ntracking | |
| ►Nharvest | |
| ►Nharvesting | |
| CHarvestingModule | |
| ►Nrefiners | |
| CCdRefiner | |
| CExpertLevelRefiner | |
| CFilterRefiner | |
| CGroupByRefiner | |
| CPlot2DRefiner | |
| CRefiner | |
| CSaveClassificationAnalysisRefiner | |
| CSaveFiguresOfMeritRefiner | |
| CSaveHistogramsRefiner | |
| CSaveProfilesRefiner | |
| CSavePullAnalysisRefiner | |
| CSaveScatterRefiner | |
| CSaveTreeRefiner | |
| CSelectRefiner | |
| ►Nharvesting_validation | |
| ►Ncombined_module | |
| CCombinedTrackingValidationModule | |
| ►Neventwise_module | |
| CEventwiseTrackingValidationModule | |
| ►Nmc_side_module | |
| CMCSideTrackingValidationModule | |
| ►Npr_side_module | |
| CPRSideTrackingValidationModule | |
| ►Nrecorded_data_module | |
| CEventInfoHarvester | |
| CHitInfoHarvester | |
| CTrackInfoHarvester | |
| ►Nmetamodules | |
| CIfMCParticlesPresentModule | |
| CIfModule | |
| CIfStoreArrayNotPresentModule | |
| CIfStoreArrayPresentModule | |
| CPathModule | |
| CPyProfilingModule | |
| CWrapperModule | |
| ►Nrun | |
| ►Nevent_generation | |
| CReadOrGenerateEventsRun | |
| CStandardEventGenerationRun | |
| ►Nminimal | |
| CEmptyRun | |
| CMinimalRun | |
| ►Nmixins | |
| CBrowseTFileOnTerminateRunMixin | |
| CPostProcessingRunMixin | |
| CRootOutputRunMixin | |
| CRunMixin | |
| ►Ntracked_event_generation | |
| CReadOrGenerateTrackedEventsRun | |
| CStandardReconstructionEventsRun | |
| ►Nutilities | |
| CArgumentParser | |
| CNonstrictChoices | |
| ►NsecMapTraining | |
| ►NCreateSensorDisplacements | |
| CReader | |
| ►Nutilities | |
| CDefaultHelpArgumentParser | |
| CNonstrictChoices | |
| ►Nvalidation | |
| ►Nclassification | |
| CClassificationAnalysis | |
| CCutAtBackgroundRejectionClassifier | |
| CCutClassifier | |
| ►Nfom | |
| CValidationFiguresOfMerit | |
| CValidationManyFiguresOfMerit | |
| ►Nhit_module | |
| CExpertTrackingValidationModule | |
| ►Nmatplotting | |
| Cdefaults | |
| ►Nmodule | |
| CAlwaysPassFilter | |
| CFilterProperties | |
| CTrackingValidationModule | |
| ►Npull | |
| CPullAnalysis | |
| ►Nresolution | |
| CResolutionAnalysis | |
| ►Nrun | |
| CTrackingValidationRun | |
| ►Ntolerate_missing_key_formatter | |
| CNoReplacementField | |
| CTolerateMissingKeyFormatter | |
| CTolerateMissingKeyFormatterTest | |
| ►NTrackingValidation | |
| CStandalone | |
| ►Ntrain | |
| CClassificationOverview | |
| CDEDXEstimationTrainer | |
| CFittedGroupedDEDXEstimatorTrainer | |
| CFunctionFittedGroupedDEDXEstimatorTrainer | |
| CGaussianEstimatorTrainer | |
| CGaussianEstimatorTrainerSQRT | |
| CGroupedDEDXEstimationTrainer | |
| CLandauEstimatorTrainer | |
| CLandauEstimatorTrainerSQRT | |
| CMaximumEstimatorTrainer | |
| CMaximumEstimatorTrainerSQRT | |
| CMedianEstimatorTrainer | |
| CMedianEstimatorTrainerSQRT | |
| CMVADEDXEstimationTrainer | |
| ►NtrainBackgroundClusterFilter | |
| CBackgroundClusterFilterTrainingRun | |
| ►NtrainFacetFilter | |
| CFacetFilterTrainingRun | |
| ►NtrainFacetRelationFilter | |
| CFacetRelationFilterTrainingRun | |
| ►NtrainFeasibleAxialSegmentPairFilter | |
| CFeasibleAxialSegmentPairFilterTrainingRun | |
| ►NtrainFeasibleSegmentPairFilter | |
| CFeasibleSegmentPairFilterTrainingRun | |
| ►NtrainFeasibleSegmentRelationFilter | |
| CFeasibleSegmentRelationFilterTrainingRun | |
| ►NtrainFeasibleTrackRelationFilter | |
| CFeasibleTrackRelationFilterTrainingRun | |
| ►NtrainRealisticAxialSegmentPairFilter | |
| CRealisticAxialSegmentPairFilterTrainingRun | |
| ►NtrainRealisticSegmentPairFilter | |
| CRealisticSegmentPairFilterTrainingRun | |
| ►NtrainRealisticSegmentPairRelationFilter | |
| CRealisticSegmentPairRelationFilterTrainingRun | |
| ►NtrainRealisticSegmentRelationFilter | |
| CRealisticSegmentRelationFilterTrainingRun | |
| ►NtrainRealisticTrackRelationFilter | |
| CRealisticTrackRelationFilterTrainingRun | |
| ►NtrainSegmentTrackFilter | |
| CSegmentTrackFilterTrainingRun | |
| ►NtrainTrackFilter | |
| CTrackFilterTrainingRun | |
| ►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 |
| ►NtrgcdcReadout | |
| CTestModule | |
| ►Ntrgcdct3dUnpackerConverter | |
| Cis2DSkim | |
| ►NTRGValidation | |
| CMakePlots | |
| ►NtriggerKLs | |
| CPyTrigger | |
| ►NTSF_OldVsNew | |
| CTestModule | |
| ►Nv0ValidationCreatePlots | |
| CV0ValidationPlots | |
| ►Nvalidate | |
| CBGHistogrammer | |
| ►NvalidateOverlay | |
| CHistogrammer | |
| ►NvalidatePhase2Cosmics | |
| CCosmicAnalysis | |
| ►Nvalidation | |
| CIntervalSelector | |
| ►Nvalidation_tools | |
| ►Nmetadata | |
| CValidationMetadataSetter | |
| ►Nvalidationcomparison | |
| CAndersonDarlingTest | |
| CChi2Test | |
| CComparisonBase | |
| CComparisonFailed | |
| CDifferingBinCount | |
| CKolmogorovTest | |
| CObjectsNotSupported | |
| CPvalueTest | |
| CTablePrinter | |
| CTooFewBins | |
| ►Nvalidationpath | |
| CTagFolderRainbowTable | |
| ►Nvalidationscript | |
| ►CScriptStatus | Enumeration of the states a script can be during its execution cycle |
| Ccached | |
| Cfailed | |
| Cfinished | |
| Crunning | |
| Cskipped | |
| Cwaiting | |
| ►Nvalidationserver | |
| CValidationRoot | |
| ►Nvariables | |
| ►Nutils | |
| CDecayParticleNode | |
| CPythonVariableManager | |
| ►NvxdCdcMergerValidationCreatePlots | |
| CVxdCdcMergerValidationPlots | |
| ►NvxdCdcMergerValidationGenerateSample | |
| CVxdCdcMergerHarvester | |
| ►NVXDTF2TrackingValidation | |
| CVXDTF2TrackingValidation | |
| ►NVXDTF2TrackingValidationBkg | |
| CVXDTF2TrackingValidationBkg | |
| ►NVXDTFFilterTest | Helper struct for testing purposes providing the necessary coordinate accessors NOTE: this is only temporarily stored in a separate header! |
| CTestSpacePoint | Helper struct for SpacePoint Tests |
| ►Nwirehit_preparation | |
| CWireHitPreparerRunMixin | |
| ►Nwrapper | |
| CQueueDrawer | |
| CQueueHarvester | |
| ►Nwrite_test_files | |
| CModel | |
| CTrivialModel | |
| ►Nz0_with_clone_suppression | |
| CAna | |
| CSkim | |
| ►Nzmq_daq | |
| ►Nexample_support | |
| CSleepOnInitModule | |
| ►Ntest_support | |
| CBaseCollectorTestCase | |
| CHLTZMQTestCase | |
| ►Carray | STL class |
| Cconst_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Citerator | STL iterator class |
| Creverse_iterator | STL iterator class |
| CBeginRec | Begin record structure for the beamtest data |
| CBEvent | The Class for Masterclass event parameters |
| Cbitset | STL class |
| CBParticle | The Class for Masterclass particle information This class provides the data structure of the particle that are used by Belle II Masterclass application |
| CBW_t | Description: The class to treat resonances, their lineshapes, and dispersion relation integral |
| CCompareMCParticlesByIndex | Comparison of MCParticles by index |
| Ccopper_footer | |
| Ccopper_header | |
| CCosGainData | Container for cosine gain data |
| CCounters | Holds various counters for tracking event, run, and cluster data |
| CcrystalInfo | Struct to hold relevant Crystal information |
| Ccurl_t | Curl struct |
| Ccycle_detector | Simple struct to check boost graph for cyclic references |
| Ceb_statistics | |
| CEndRec | End record structure for the beamtest data |
| CEventRec | Event record structure for the beamtest data |
| CEvtBGL | The class provides the form factors for orbitally excited semileptonic decays |
| CEvtBGL2 | The class provides the form factors for orbitally excited semileptonic decays |
| CEvtBGL2FF | The class provides the form factors for semileptonic D and D* decays with full mass dependence |
| CEvtBGLFF | The class provides the form factors for semileptonic D and D* decays with full mass dependence |
| CEvtBToDstarlnuNP | Implementation of  |
| CEvtbTosllNPR | Description: Implementation of the B->K(*)l^+l^- decays with New Physics contributions and c\bar{c} resonances included at the amplitude level according to the note by Rahul Sinha and Rusa Mandal |
| ►CEvtGenDecays | A class to perform decays via the external EvtGen decay program, see http://evtgen.warwick.ac.uk/, the program manual provided with the EvtGen distribution, and D |
| CSignal | Map of signal particle info |
| CEvtGenFwRandEngine | Evtgen random generator |
| CEvtGenRandom | A class to wrap the Pythia random number generator for use by EvtGen |
| CEvtHQET3 | The class provides the form factors for orbitally excited semileptonic decays |
| CEvtHQET3FF | The class provides the form factors for semileptonic D & D* decays with full mass dependence |
| CEvtLinSample | Description: The simple helper class to generate arbitrary distribution based on a linear piece-wise approximation of it |
| CEvtLLSW | The class provides the decay amplitude for orbitally excited semileptonic decays |
| CEvtLLSWFF | The class provides the form factors for orbitally excited semileptonic decays |
| CEvtPHSPBBMix | The class provides routine to decay vector-> particle particle with B0 mixing, coherent B0B0-like mixing if any |
| CEvtPHSPBMix | The class provides routine to decay vector-> particle particle with B0 mixing, handles states with only one neutral B |
| CEvtPointf | Description: struct for 2-dimensional point in the float format instead of double to save memory |
| CEvtVSSBMixNP | Routine to decay vector-> scalar scalar with BB-like mixing and decoherence parameter lambda |
| CEvtVSSBMixSD | Routine to decay vector -> scalar scalar with Spontaneous Disentanglement |
| CEvtYmSToYnSpipiCLEOboost | Register Decay model EvtYmSToYnSpipiCLEOboost |
| CFileHandler | |
| CFitter3DUtility | A class that holds functions for 3D tracking |
| CFpgaUtility | A class that holds FPGA related functions |
| CG4QGSModel | |
| CGFGeant4Field | Interface of the Belle II B-field with GenFit |
| Ch2m_footer_t | |
| Ch2m_header_t | |
| Chepevt_type | HEPEVT common block of PYTHIA6 |
| CHough3DFinder | A class to finded stereo TS hits related to 2D tracks |
| Cifstream | STL class |
| CInputParser | |
| Cios | STL class |
| Cistream | STL class |
| 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 |
| ►Cmap | STL class |
| Cconst_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Citerator | STL iterator class |
| Creverse_iterator | STL iterator class |
| CMapping_t | Mapping class |
| CMaximumPtTrack | Temporary data structure holding the track(s) with the maximum pT |
| ►Cmybuf | |
| Cio_status | |
| CNSMcon | |
| CNSMcontext_struct | |
| Cnsmd_tcpq | |
| CNSMdat | |
| CNSMdat_rcv | |
| CNSMdat_snd | |
| CNSMdmsg | |
| CNSMmem_struct | |
| CNSMmsg | |
| CNSMnod | |
| CNSMparse_struct | |
| CNSMref | |
| CNSMreg | |
| CNSMreq | |
| CNSMrequest | |
| CNSMsch | |
| CNSMsys_struct | |
| CNSMtcphead_struct | |
| CNSMudpbuf | |
| Cofstream | STL class |
| COnedData | Container for 1D gain data |
| Costream | STL class |
| Cpair | STL class |
| CPlane | Plane |
| CPlane_t | Define plane struct |
| CPoint3D | |
| Cpydat2_type | PYDAT2 common block of PYTHIA6 |
| CRawRevSock2Rb | |
| Crfnodeinfo | |
| CROIinfo | ROIinfo contains the parameters that can be changed by the user in the python script |
| CSelectedECLCluster | Temporary data structure holding the ECL clusters used for this analysis |
| Csender_argv | |
| Csolution_t | Solution struct |
| CStepExceptionHandler | Class to handle G4Exception raised during PropagateOneStep() |
| Cstream_statistics | |
| ►Cstring | STL class |
| Cconst_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Citerator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cstringstream | STL class |
| CTerm | |
| CTNiel | TNiel - the class providing values for NIEL factors |
| ►Cvector | STL class |
| Cconst_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Citerator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cvlistentry_t | |
| CWireGainData | Container for wire gain data |
| CXT | Class to perform fitting for each xt function |
| CXY | Point |
1.13.2