 |
Belle II Software
release-08-01-10
|
|
Belle II Software
release-08-01-10
|
| ►N081_module | |
| CMinModule | |
| ►N083_module | |
| CMinModule | |
| ►N085_module | |
| CAccessingDataStoreModule | |
| ►N087_module | |
| CAccessingDataStoreModule | |
| ►N3_bunchFinderPlots | |
| CMakePlots | |
| ►Nadversary_network | |
| Cbatch_generator | |
| ►Nalignment | |
| ►Nconstraints | |
| CConstraint | |
| CConstraints | |
| CVXDHierarchyConstraints | |
| CCDCLayerConstraints | |
| CCDCTimeZerosConstraint | |
| CCDCWireConstraints | |
| ►Nconstraints_generator | |
| CConstraintsGenerator | |
| ►Nfancystuff | |
| ►Nsettings | |
| CProTool | |
| ►Ntools | |
| CProfilePlot | |
| ►Ntransform | |
| CTransform | |
| CCDF | |
| CToFlat | |
| ►Nmisalignment | |
| CGlobalDeformation | |
| CRadialExpansion | |
| CCurl | |
| CTelescope | |
| CElliptical | |
| CClamshell | |
| CSkew | |
| CBowing | |
| CTwist | |
| CZExpansion | |
| CCreateMisalignmentModule | |
| ►Nutils | |
| CAlignmentGeneratorConfig | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| CMillepedeCalibration | |
| ►Nallparticlecombiner | |
| CTestAllParticleCombiner | |
| ►NalphaRatioPlots | |
| CMakePlots | |
| ►Nanalyse | |
| CPDF | |
| CMVATeacherAndAnalyser | |
| ►Narich_packer_unpacker | |
| CPackerUnpackerTest | |
| ►NaverageQE | |
| CAverageQE | |
| ►Nawesome_examples | |
| CAwesomeExamplesTest | |
| ►NB0_GenDeltaTFit | |
| CfitDeltaT | |
| ►NB2A714-DeepContinuumSuppression_MVAModel | |
| Cbatch_generator | |
| ►Nb2bii_mdst_input | |
| CTestingModule | |
| ►Nb2pandas_utils | |
| CVariablesToHDF5 | |
| ►Nb2parser | |
| CB2ParameterLexer | |
| CB2Lexer | |
| ►Nb2test_utils | |
| ►Nclassversion | |
| CClassVersionError | |
| CErrorWithExtraVariables | |
| ►Ndatastoreprinter | |
| CDataStorePrinter | |
| CPrintObjectsModule | |
| ►Nlogfilter | |
| CLogReplacementFilter | |
| ►Nb2test_utils_analysis | |
| CExamplesTest | |
| ►NB2Tools | |
| ►Nb2latex | |
| CLatexObject | |
| CLatexFile | |
| CString | |
| CListing | |
| CDefineColourList | |
| CSection | |
| CSubSection | |
| CSubSubSection | |
| CGraphics | |
| CItemize | |
| CLongTable | |
| CTitlePage | |
| ►Nb2root | |
| ►CRawRootFile | |
| CKey | |
| ►Nformat | |
| CAttrDict | |
| CDefaultValueFormatter | |
| ►NbackgroundInfo | |
| CprintBGInfo | |
| ►Nbase_examples | |
| CExamplesTest | Extend the examples test class to actually run over the uncategorized examples: |
| ►Nbasf2_mva_python_interface | |
| ►Nhep_ml | |
| CState | |
| ►Nkeras | |
| CState | |
| ►Nsklearn | |
| CState | |
| ►Ntensorflow | |
| CState | |
| ►Ntest | |
| CState | |
| ►Ntheano | |
| CState | |
| ►Nxgboost | |
| CState | |
| ►Nbasf2_mva_util | |
| CMethod | |
| ►Nbasf2domain | |
| CBasf2Object | |
| CBasf2ModuleIndex | |
| CBasf2VariableIndex | |
| CBasf2Domain | |
| ►Nbasf2ext | |
| CRenderDocstring | |
| CModuleListDirective | |
| CVariableListDirective | |
| ►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 depedence of parameter, load their value from database, update te 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 |
| CGlobalDerivatives | Class for easier manipulation with global derivatives (and their labels) |
| CEmptyGlobalParamSet | Object representing no parameters |
| CIGlobalParamInterface | Some tentative base class to allow to add functionality to the default behavior, like manipulate constants in DB objects after clibration is finished All methods to override have default implementaion which does nothing |
| CCDCGlobalParamInterface | CDC interface |
| CVXDGlobalParamInterface | Very tentative interface for VXD |
| CGlobalParamSetAccess | Base accessor class to store different DBObjects e.g |
| CGlobalParamSet | Template class for generic access to DB objects |
| 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 |
| CGlobalDerivativesHierarchy | Class for alignment/calibration parameter hierarchy & constraints |
| CLorentShiftHierarchy | 1D Hierarchy for Lorentz shift correction |
| CRigidBodyHierarchy | 6D Hierarchy of rigid bodies |
| CGlobalCalibrationManager | Class to hold hierarchy of whole Belle2 |
| CPedeApplication | Class interfacing Millepede solver (Pede) |
| ►CPedeResult | Class to process Pede result file(s) |
| CparameterData | Struct to hold data for a parameter |
| ►Nanalysis | |
| CFourCFitKFit | FourCFitKFit is a derived class from KFitBase to perform 4 momentum-constraint kinematical fit |
| CKFitBase | KFitBase is a base class for kinematical fitters |
| CKFitConst | KFitConst is a container of constant names |
| CKFitError | KFitError is a container of error codes and a macro function |
| ►CKFitTrack | KFitTrack is a container of the track information (Lorentz vector, position, and error matrix), and a set of macro functions to set/get the contents |
| CKFitPXE | KFitPXE is a container of the track information (Lorentz vector, position, and error matrix) |
| CMakeMotherKFit | MakeMotherKFit is a class to build mother particle from kinematically fitted daughters |
| CMassFitKFit | MassFitKFit is a derived class from KFitBase to perform mass-constraint kinematical fit |
| CMassFourCFitKFit | MassFourCFitKFit is a derived class from KFitBase to perform mass and 4 momentum-constraint kinematical fit |
| CMassPointingVertexFitKFit | MassPointingVertexFitKFit is a derived class from KFitBase It performs a kinematical fit with three constraints: the invariant mass is constrained to its PDG value, the tracks are forced to a common vertex, and the momentum vector is forced to point to an externally provided space point |
| CMassVertexFitKFit | MassVertexFitKFit is a derived class from KFitBase to perform mass-vertex-constraint kinematical fit |
| CRecoilMassKFit | RecoilMassKFit is a derived class from KFitBase to perform a kinematical fit with a recoil mass constraint |
| CVertexFitKFit | VertexFitKFit is a derived class from KFitBase to perform vertex-constraint kinematical fit |
| CRaveKinematicVertexFitter | Part of the RaveInterface together with RaveSetup |
| CRaveSetup | Part of the RaveInterface together with RaveVertexFitter It holds all global options for the RaveVertexFitter and also takes care that stuff like the magnetic field is correctly set up in way Rave can access it |
| CRaveVertexFitter | Part of the RaveInterface together with RaveSetup |
| ►Narich | |
| CGeoARICHBtestCreator | The creator for the PXD geometry of the Belle II detector |
| CGeoARICHCreator | The creator for the ARICH geometry of the Belle II detector |
| CARICHBackgroundModule | ARICH digitizer module |
| 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 |
| ►NARICH | |
| CParticlesArray | Structure for particle hypothesis dependent arrays |
| CTrackHit | Structure for track parameters at ARICH |
| CARICHTree | Structure of a flat ntuple |
| ►NARICHTools | |
| ►NPrivateHelperClasses | |
| CTokenCast | Generic template for TokenCast<T> |
| CTokenCast< int > | Integer specialization of TokenCast<T> |
| CTokenCast< double > | Double specialization of TokenCast<T> the decimal point is set to ' |
| 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 | |
| CAWESOMEGeometryCreator | The creator for the AWESOME detector geometry |
| CAWESOMEBasicModule | The AWESOME basic module |
| CAWESOMESensitiveDetector | Sensitive Detector implementation of the AWESOME detector |
| ►Nbackground | |
| CBeamBGTypes | Class to define BG types and to convert between BG types and tags or v.v |
| ►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 |
| ►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 | |
| CTrack | Track parameters (neglecting curvature) |
| CEvent | Event containing two tracks |
| CSpotParam | Structure containing most of the beam spot parameters |
| CUnknowSpline | Spline with uncertainty obtained from the boot-strap replicas |
| CUnknowVar | Variable with uncertainty from boot-strap replicas |
| CUnknownPars | Structure including all variables of interest with uncertainties from boot-strap |
| ►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 | |
| CTrack | Track parameters (neglecting curvature) |
| CEvent | Event containing two tracks |
| CFunBoost | Functor to minimize median of residuals^2 |
| 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 | |
| CCrudeT0CalibrationAlgorithm | Algorithm class for crude T0 calibration |
| CFudgeFactorCalibrationAlgorithm | Class for CDC fudge factor calibration |
| CSpaceResolutionCalibration | Class for Space resolution calibration |
| CSpaceResolutionCalibrationAlgorithm | Class for Space resolution calibration |
| CT0CalibrationAlgorithm | Class for T0 Correction |
| CT0Correction | Class for T0 Correction |
| 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 |
| CCDCGeoControlPar | The Class for CDC Geometry Control Parameters |
| CCDCGeometryPar | The Class for CDC Geometry Parameters |
| CGeoCDCCreator | The GeoCDCCreator class |
| CGeoCDCCreatorReducedCDC | The GeoCDCCreatorReducedCDC class |
| CCDCCalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCFudgeFactorCalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCT0CalibrationCollectorModule | Collect hit information for cdc calibration with CAF |
| CCDCCosmicAnalysisModule | Analysis module for CDC CR data |
| CCDCCRTestModule | CDC Cosmic test calibration module |
| CCDCCrudeT0CollectorModule | Collector for crude t0 |
| CEDepInGas | The Class for Energy deposit in the gas |
| CCDCHitFilterModule | CDCHitFilter: Filters CDC hits according to given configuration criteria |
| CCDCChannelData | CDCChannelData |
| CCDCPackerModule | CDCPackerModule: The CDC Raw Hits Decoder |
| CCDCRecoTrackFilterModule | The module excluding hits of specified Slayers in the RecoTracks |
| CCDCUnpackerModule | CDCUnpackerModule: The CDC Raw Hits Decoder |
| CCDCSensitiveDetector | The Class for CDC Sensitive Detector |
| CCDCSimControlPar | The Class for CDC Simulation Control Parameters |
| CHelix | Helix parameter class |
| CADCCountTranslatorBase | Abstract Base class for the ADC count translator |
| CCDCGeometryTranslatorBase | Abstract Base class for the geometry translator |
| 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 |
| CTDCCountTranslatorBase | Base class for translation of Drift Time into Drift Length |
| ►NCDCTriggerUnpacker | |
| CTRG2DFinderTrack | TRG 2DFinder Track |
| CTRGNeuroTrack | TRG Neuro track |
| CB2LDataField | |
| ►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 |
| CCppOrPyList | Wrapper class for a list of strings to either be held in a std::vector or in a python list |
| CConfiguration | Class to enable configuration of the conditions database access in C++ and python |
| CDownloader | Simple class to encapsulate libcurl as used by the ConditionsDatabase |
| CLocalMetadataProvider | Class to obtain metadata of all valid payloads from a local SQLite file instead of the central server |
| ►CMetadataProvider | Base class for a payload metadata provider |
| ►CPayloadMetadataCache | Simple caching structure to keep the payload information for this and the last exp/run |
| CCacheEntry | Each cache entry |
| CNullMetadataProvider | Fallback provider if no providers are given: Will raise an error if used but allows processing if no payloads are requested or all are taken locally from testing payload storage |
| CPayloadMetadata | Simple struct to group all information necessary for a single payload |
| ►CPayloadProvider | Class to find payload files in a list of locations |
| CPayloadLocation | Simple struct to represent a lookup location |
| CTestingPayloadStorage | Class to store and retrieve temporary payloads |
| CCurlSession | Struct encapsulating all the state information needed by curl |
| ►Ncsi | Namespace to encapsulate code needed for the CSI detector |
| CCsiCreator | The creator for the CSI geometry |
| CCsiGeometryPar | The Class for CSI Geometry Parameters |
| CCsiDigitizer_v2Module | Csi tube digitizer_v2 |
| CCsIDigitizerModule | Digitizer for the BEAST CsI system |
| 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 | |
| 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 |
| CeclBhabhaTAlgorithm | Calibrate ecl crystals using bhabha events |
| CeclCosmicEAlgorithm | Class eclCosmiEAlgorithm |
| 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 |
| CeclLeakageAlgorithm | Calculate ECL energy leakage corrections |
| CeclMergingCrystalEAlgorithm | Calibrate ecl crystals using previously created payloads |
| CeclMergingCrystalTimingAlgorithm | Calibrate ecl crystals using previously created payloads |
| CeclMuMuEAlgorithm | Calibrate ecl crystals using muon pair events |
| 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) |
| CeclTimeShiftsAlgorithm | Calibrate ecl crystals using previously created payloads |
| 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 |
| CBitStream | Bit stream struct |
| 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 |
| CECLCompress | Abstract class (interface) for ECL waveform compression/decompression to/from the BitStream storage |
| CECLBaseCompress | ECL waveform compression/decompression to/from the BitStream storage with the BASE algorithm |
| CECLDeltaCompress | ECL waveform compression/decompression to/from the BitStream storage with the DELTA algorithm |
| CECLDCTCompress | ECL waveform compression/decompression to/from the BitStream storage based on the Discrete Cosine Transform (DCT) |
| ►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 |
| CECLSampledShaper | Digitisation shaper |
| ►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 |
| CWrapArray2D | Class to replace POD 2D array to save stack usage since it just allocates memory dynamically |
| CPlane_t | Struct for plane |
| CPoint_t | Struct for Point |
| CBelleCrystal | Belle crystal in Geant4 |
| CPolyhedronBelleCrystal | Belle crystal in polyhedron |
| Czr_t | Simple struct with z and r coordinates |
| Ccachezr_t | Cached z-r struct |
| Cvector_t | Struct for a three vector |
| Ctriangle_t | Struct for a triangle |
| CBelleLathe | BelleLathe class |
| CPolyhedronBelleLathe | Belle lathe polyhedron |
| ►CECLGeometryPar | The Class for ECL Geometry Parameters |
| CCrystalGeom_t | Crystal geometry |
| CEclNbr | EclNbr class |
| ►CTEclEnergyHit | Define class TEclEnergyHit |
| Cgreater_CellId | Struct greater_CellId |
| Cgreater_Energy | Struct greater_Energy |
| Cless_CellId | Struct less_CellId |
| Cless_Energy | Struct less_Energy |
| CECLLeakagePosition | Class to get position information for a cluster for leakage corrections |
| CECLNeighbours | Class to get the neighbours for a given cell id |
| CGeoECLCreator | The GeoECLCreator class |
| Cshape_t | Shape |
| Ccplacement_t | Placement struct |
| Cquadrilateral_t | Quadrilateral shape struct |
| Cquadrilateral_barrel_t | Quadrilateral struct for barrel |
| Cquadrilateral_endcap_t | Quadrilateral struct for end cap |
| Cpent_t | Pentagon shape |
| CECLChannelMapper | This class provides access to ECL channel map that is either a) Loaded from the database (see ecl/dbobject/include/ECLChannelMap.h) |
| CECLDQMInjectionModule | The ECL Occ after Injection DQM module |
| CECLLOMModule | This module simulates ECL Luminosity Online Monitor logic, i.e |
| CSensitiveDetector | Class for ECL Sensitive Detector |
| ►CSensitiveDiode | Class for ECL Sensitive Detector |
| Chit_t | Simple hit structure |
| CBkgSensitiveDiode | Class for ECL Sensitive Detector for neutron background study |
| CECLWaveformsTest | Declare ECLWaveforms test |
| CBitStreamTest | Declare BitStream test |
| CECLBaseCompressTest | Declare ECLBaseCompress test |
| CECLDeltaCompressTest | Declare ECLDeltaCompress test |
| CECLDCTCompressTest | Declare ECLDCTCompress test |
| CECLShapeFit | ShaperDSP fit results from _lftda function |
| 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) |
| CECLDspUtilities | This class contains static methods to make them accessible from pyROOT |
| CECLShowerId | Class to convert the shower id into CR, CS and Seed and vice versa |
| CECLTimingUtilities | Class to storing timing calibration functions |
| ►NEKLM | |
| CAlignmentChecker | Class for EKLM alignment checking |
| CArc2D | 2D arc |
| CCircle2D | 2D circle |
| CSectorSupportSolids | Sector support solids |
| CSectorSupportLogicalVolumes | Sector support logical volumes |
| CShieldLogicalVolumes | Shield logical volumes |
| CSolids | All solids of EKLM |
| CLogicalVolumes | Logical volumes of EKLM |
| CMaterials | Materials for EKLM |
| CVolumeNumbers | Volume numbers |
| CGeoEKLMCreator | Class GeoEKLMCreator |
| CGeometryData | EKLM geometry data |
| CLine2D | 2D line |
| CLineSegment2D | 2D line segment |
| CPolygon2D | 2D polygon |
| CTransformData | Transformation data |
| CTransformDataGlobalAligned | Transformation data (global, aligned): singleton version |
| ►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 |
| ►Ngroup_helper | |
| ►Ncomparators | |
| Con_common_args_t | |
| ►Ngroup_helper_imple__ | |
| Cprint_s | |
| Chas_type | |
| Chas_type< T, std::tuple< Us... > > | |
| Cis_tuple | |
| Cis_tuple< std::tuple< T... > > | |
| Cidentity | |
| ►C__range__impl_prj | |
| Cbegin_t | |
| Cto_range_ | |
| Cgroup | |
| Cgreater | |
| ►Nhe3tube | Namespace to encapsulate code needed for the HE3TUBE detector |
| CHe3tubeCreator | The creator for the HE3TUBE geometry |
| CHe3DigitizerModule | He3 tube digitizer |
| CHe3tubeModule | The He3tube module |
| CHe3tubeStudyModule | Study module for He3tubes (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the HE3TUBE detector |
| ►NHistogramFactory | |
| CParameter | This class represents a quantity which value can be set both permanently and temporarily |
| 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 |
| ►NInvariantMassBhadCalib | |
| CCandidate | Structure containing variables relevant to the B-candidate |
| CEvent | Structure containing variables relevant for the hadronic B decays |
| ►NInvariantMassMuMuCalib | |
| CInvariantMassMuMuIntegrator | The integrator aims to evaluate convolution of PDFgenLevel and resolution function |
| CTrack | Track parameters (neglecting curvature) |
| CEvent | Event containing two tracks |
| ►NIOIntercept | Encapsulate all classes needed to intercept stdout and stderr |
| CStreamInterceptor | Base class with all necessary features to intercept output to a file descriptor |
| CKeepStream | Dummy class which keeps the stream unmodified |
| CDiscardStream | Simple class to just discard anything written to stream by redirecting it to /dev/null |
| CCaptureStream | Class to capture anything written to stream into a string |
| CInterceptOutput | Class to intercept stdout and stderr and either capture, discard or keep them unmodified depending on the template arguments |
| COutputToLogMessages | Capture stdout and stderr and convert into log messages |
| CInterceptorScopeGuard | Simple RAII guard for output interceptor |
| CCaptureStreamAbortHandler | Small class to handle std::abort() calls by external libraries |
| ►Nir | |
| CGeoBeamPipeCreator | The creator for the BeamPipe geometry of the Belle II detector |
| CCryostatElement | The struct for CryostatElement |
| CGeoCryostatCreator | The creator for the Cryostat geometry of the Belle II detector |
| CFarBeamLineElement | The struct for FarBeamLineElement |
| CGeoFarBeamLineCreator | The creator for the FarBeamLine geometry of the Belle II detector |
| CSensitiveDetector | The IR Sensitive Detector class |
| ►NKLM | |
| CGeoKLMCreator | The creator for the KLM geometry of the Belle II detector |
| CKLMGeometryPar | Wrapper class around bklm::GeometryPar and EKLM::GeometryData |
| CChannelGroup | Channel group |
| 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) |
| CTpcDigitizerModule | Micro TPC digitizer |
| CTPCStudyModule | Study module for TPCs (BEAST) |
| CSensitiveDetector | Sensitive Detector implementation of the MICROTPC detector |
| ►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 | |
| CDataset | Abstract base class of all Datasets given to the MVA interface The current event can always be accessed via the public members of this class |
| CSingleDataset | Wraps the data of a single event into a Dataset |
| CMultiDataset | Wraps the data of a multiple event into a Dataset |
| CSubDataset | Wraps another Dataset and provides a view to a subset of its features and events |
| CCombinedDataset | Wraps two other Datasets, one containing signal, the other background events Used by the reweighting method to train mc files against data files |
| CROOTDataset | Proivdes a dataset from a ROOT file This is the usually used dataset providing training data to the mva methods |
| CExpert | Abstract base class of all Expert Each MVA library has its own implementation of this class, so all libraries can be accessed via this common interface |
| CAbstractInterface | Abstract Interface to third-party MVA libraries |
| CInterface | Template class to easily construct a interface for an MVA library using a library-specific Options, Teacher and Expert class |
| COptions | Abstract base class of all Options given to the MVA interface |
| CGeneralOptions | General options which are shared by all MVA trainings |
| CSpecificOptions | Specific Options, all method Options have to inherit from this class |
| CMetaOptions | Meta Options which modify the underlying training by doing sPlot, Multiclass and HyperparameterSearch |
| CTeacher | Abstract base class of all Teachers Each MVA library has its own implementation of this class, so all libraries can be accessed via this common interface |
| CWeightfile | Serializes all information about a training into an xml tree |
| CCombinationOptions | Options for the Combination MVA method |
| CCombinationTeacher | Teacher for the Combination MVA method |
| CCombinationExpert | Expert for the Combination MVA method |
| CFANNOptions | Options for the FANN MVA method |
| CFANNTeacher | Teacher for the FANN MVA method |
| CFANNExpert | Expert for the FANN MVA method |
| CFastBDTOptions | Options for the FANN MVA method |
| CFastBDTTeacher | Teacher for the FastBDT MVA method |
| CFastBDTExpert | Expert for the FastBDT MVA method |
| CPDFOptions | Options for the PDF MVA method |
| CPDFTeacher | Teacher for the PDF MVA method |
| CPDFExpert | Expert for the PDF MVA method |
| CPythonOptions | Options for the Python MVA method |
| CPythonTeacher | Teacher for the Python MVA method |
| CPythonExpert | Expert for the Python MVA method |
| CRegressionOptions | Generic options of the Regression MVA methods hosting the number of bins (and the base classifier options) |
| CRegressionDataSet | Dataset needed during the training of a regression method |
| CRegressionTeacher | Core class for the training of regression methods based on binary classifiers |
| CRegressionExpert | Generic expert for the regression applications |
| CRegressionFastBDTOptions | Explicit template specification for FastBDTs for regression options |
| CReweighterOptions | Options for the Reweighter MVA method |
| CReweighterTeacher | Teacher for the Reweighter MVA method |
| CReweighterExpert | Expert for the Reweighter MVA method |
| CTMVAOptions | Options for the TMVA MVA method |
| CTMVAOptionsClassification | Options for the TMVA Classification MVA method |
| CTMVAOptionsMulticlass | Options for the TMVA Multiclass MVA method |
| CTMVAOptionsRegression | Options for the TMVA Regression MVA method |
| CTMVATeacher | Teacher for the TMVA MVA method |
| CTMVATeacherClassification | Teacher for the TMVA Classification MVA method |
| CTMVATeacherMulticlass | Teacher for the TMVA Multiclass MVA method |
| CTMVATeacherRegression | Teacher for the TMVA Regression MVA method |
| CTMVAExpert | Expert for the TMVA MVA method |
| CTMVAExpertClassification | Expert for the TMVA Classification MVA method |
| CTMVAExpertMulticlass | Expert for the TMVA Multiclass MVA method |
| CTMVAExpertRegression | Expert for the TMVA Regression MVA method |
| CTrivialOptions | Options for the Trivial MVA method |
| CTrivialTeacher | Teacher for the Trivial MVA method |
| CTrivialExpert | Expert for the Trivial MVA method |
| CPythonInitializerSingleton | Singleton class which handles the initialization and finalization of Python and numpy |
| CBinning | Binning of a data distribution Provides PDF and CDF values of the distribution per bin |
| CReweightingDataset | Dataset for Reweighting Wraps a dataset and provides each data-point with a new weight |
| CSidebandDataset | Dataset for Sideband Subtraction Wraps a dataset and provides each data-point with a new weight |
| CSPlotDataset | Dataset for sPlot Wraps a dataset and provides each data-point twice, once as signal and once as background |
| CUtility | Wrapper class for some utility functions |
| ►NOrcaKinFit | |
| CParticleKinematicFitterModule | Kinematic fitter module |
| CBaseConstraint | Abstract base class for constraints of kinematic fits |
| CBaseDefs | |
| CBaseEvent | |
| CBaseFitObject | |
| CBaseFitter | Abstract base class for fitting engines of kinematic fits |
| CBaseHardConstraint | Abstract base class for constraints of kinematic fits |
| CBaseJetPairing | Abstract base class for jet pairings |
| CBaseSoftConstraint | Abstract base class for soft constraints of kinematic fits |
| CBaseTracer | Abstract base class for trace objects of kinematic fits |
| CFourVector | Yet another four vector class, with metric +— |
| CISRPhotonFitObject | |
| CJetFitObject | Class for jets with (E, eta, phi) in kinematic fits |
| CMassConstraint | Implements constraint 0 = mass1 - mass2 - m |
| CMomentumConstraint | Implements a constraint of the form efact*sum(E)+pxfact*sum(px)+pyfact*sum(py)+pzfact*sum(pz)=value |
| CNeutrinoFitObject | |
| CNewFitterGSL | A kinematic fitter using the Newton-Raphson method to solve the equations |
| CNewtonFitterGSL | |
| COPALFitterGSL | Description of the fit algorithm and interface: |
| CParticleConstraint | Abstract base class for constraints of kinematic fits |
| CParticleFitObject | |
| CPxPyPzMFitObject | |
| CRecoilMassConstraint | |
| CSoftGaussMassConstraint | Implements constraint 0 = mass1 - mass2 - m |
| CSoftGaussMomentumConstraint | Implements a soft constraint with chi^2=((efact*sum(E_i) + pxfact*sum(p_x,i)+pyfact*sum(p_y,i)+pzfact*sum(p_z,i)-value)/sigma)^2 |
| CSoftGaussParticleConstraint | Abstract base class for constraints of kinematic fits |
| CTextTracer | |
| CThreeVector | |
| CTrackConstraint | Abstract base class for constraints of kinematic fits |
| CTwoVector | |
| ►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 |
| CPindiodeCreator | The creator for the PINDIODE geometry |
| CPinDigitizerModule | Pin tube digitizer |
| 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 |
| CGeoPXDCreator | The creator for the PXD geometry of the Belle II detector |
| CSensorInfo | Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific information |
| ►CPXDBackgroundModule | PXD Background module |
| CSensorData | Struct to hold data of an PXD sensor |
| CPXDBeamBackHitFilterModule | The PXDBeamBackHitFilter module |
| ►CPXDBgTupleProducerModule | PXD Background Tuple Producer |
| CSensorData | Struct to hold data of an PXD sensor |
| ►CPXDMCBgTupleProducerModule | PXD MC Background Tuple Producer |
| CSensorData | Struct to hold data of an PXD sensor |
| CPXDDAQDQMModule | The PXD DAQ DQM module |
| CPXDGatedDHCDQMModule | The PXD Gatint after Injection DQM module |
| CPXDGatedModeDQMModule | The PXD for GatedMode DQM module |
| CPXDInjectionDQMModule | The PXD Occupancy after Injection DQM module |
| CPXDRawDQMChipsModule | The raw PXD DQM module |
| CPXDRawDQMModule | The raw PXD DQM module |
| CPXDROIDQMModule | The raw PXD DQM module |
| CPXDBadSensorTagModule | The PXD bad sensor tagger module |
| CPXDEventPlotModule | Plot each event with ROI and Pixels |
| CPXDRawDumperModule | Dump Raw PXD/ ONSEN event data |
| CPXDRawHitMaskingModule | The PXDRawHitMasking module |
| CPXDROIPlotModule | Plot each event with ROI and Pixels |
| CActivatePXDClusterPositionEstimatorModule | The ActivatePXDClusterPositionEstimator module |
| CActivatePXDGainCalibratorModule | The ActivatePXDGainCalibrator module |
| CActivatePXDPixelMaskerModule | The ActivatePXDPixelMasker module |
| CPXDClusterCheckModule | The PXDClusterCheck module |
| CPXDClusterizerModule | The PXDClusterizer module |
| CPXDDigitSorterModule | The PXDDigitSorter module |
| CPXDRawHitSorterModule | The PXDRawHitSorter module |
| CDigit | Class to represent the coordinates of one pixel |
| CDigitValue | Class representing the charge and particle contributions for one pixel |
| CPXDDigitizerModule | The PXD Digitizer module |
| CPXDGatedInfoFillerModule | PXD Gates Mode infromation on readout gate basis |
| CPXDPackerErrModule | The PXDPackerErr module |
| CPXDPackerModule | The PXDPacker module |
| CPXDPostErrorCheckerModule | The PXD DAQ Post Unpacking Error Check |
| 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 |
| 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 |
| CPXDReadRawONSENModule | A class definition of an input module for Sequential ROOT I/O |
| CPXDUnpackerModule | The PXDUnpacker module |
| CPXDUnpackerOldModule | The PXDUnpacker module |
| CPXDUnpackerOTModule | The PXDUnpackerOT module |
| 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 |
| CNoiseMap | Base Class to represent pixel dependent Noise Map |
| CPixel | Class to represent one pixel, used in clustering for fast access |
| 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 |
| CPXDGainCalibrator | Singleton class for managing gain corrections for the PXD |
| CPXDPixelMasker | Singleton class for managing pixel masking for the PXD |
| 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://confluence.desy.de/display/BI/PXD+WebHome?preview=/34029260/56330158/PXDwb.pdf |
| Cdhc_frame_header_word0 | DHC frame header word data struct |
| Cdhc_start_frame | DHC start frame data struct |
| Cdhc_dhe_start_frame | DHH start frame data struct |
| Cdhc_commode_frame | DHH common mode 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 supressed direct readout frame data struct |
| Cdhc_onsen_trigger_frame | ONSEN Trigger frame data struct |
| Cdhc_onsen_roi_frame | ONSEN (debug) ROI frame data struct |
| Cdhc_ghost_frame | DHC Ghost frame data struct |
| Cdhc_end_frame | DHC End frame data struct |
| Cdhc_dhe_end_frame | DHE End frame data struct |
| Cdhc_frames | DHC frame wrapper class |
| CCluster_t | Struct to hold variables for PXD clusters |
| CTrackPoint_t | Struct to hold variables for intersection points |
| CTrackCluster_t | Struct to hold variables for track clusters |
| CTrackBase_t | Struct to hold variables from a track which contains a vector of data type like TrackCluster |
| ►NPyObjConvUtils | Python object converter utilities namespace |
| CType | Converts a template argument into a string for corresponding Python type |
| CVariadicType | Recursively convert multiple types to type names (used for tuples) |
| CVariadicType< T > | Recursively convert multiple types to type names (used for tuples) |
| CType< std::vector< T > > | Converts a template argument into a string for corresponding Python type |
| CType< std::set< T > > | Convert a templeate arugment into a string for corresponding Python type |
| CType< std::map< A, B > > | Converts a template argument into a string for corresponding Python type |
| CType< unsigned int > | Converts a template argument into a string for corresponding Python type |
| CType< unsigned long int > | Converts a template argument into a string for corresponding Python type |
| CType< int > | Converts a template argument into a string for corresponding Python type |
| CType< bool > | Converts a template argument into a string for corresponding Python type |
| CType< float > | Converts a template argument into a string for corresponding Python type |
| CType< double > | Converts a template argument into a string for corresponding Python type |
| CType< std::string > | Converts a template argument into a string for corresponding Python type |
| CType< std::optional< T > > | Converts a template argument into a string for corresponding Python type |
| CType< std::tuple< Types... > > | Converts a template argument into a string for corresponding Python type |
| CType< boost::variant< Types... > > | Converts a template argument into a string for corresponding Python type |
| CType< std::shared_ptr< Path > > | Some modules take a path as argument so let's add this as well |
| CSizeT | Helper construct for TMP that provides an index at compile time to recurse through type lists |
| CconvertToPythonObjectVisitor | Helper function object to unpack a value from a variant to a python object |
| ►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 | |
| 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 |
| 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 |
| CPhysicsList | The basf2 physics list |
| CPrimaryGeneratorAction | Inherits from G4VuserPrimaryGeneratorAction and specifies how a primary event should be generated |
| ►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 |
| 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 |
| 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 |
| CNeutronPhysics | Neutron hadronic physics constructor for Belle II physics list |
| CPionPhysics | Pion hadronic physics constructor for Belle II physics list |
| CProtonPhysics | Proton hadronic physics constructor for Belle II physics list |
| ►NSoftwareTrigger | |
| CFilterCalculator | Implementation of a calculator used in the SoftwareTriggerModule to fill a SoftwareTriggerObject for doing HLT cuts |
| 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 |
| CFinalTriggerDecisionCalculator | Helper class to give the getFinalTriggerDecision to python |
| 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 |
| ►CSoftwareTriggerVariableManager | Variable Manager for the software trigger cuts |
| CSoftwareTriggerVariable | Class which represents an abstract variable in the SoftwareTriggerVariableManager |
| CSoftwareTriggerCutTest | Base class for the cut tests |
| CSoftwareTriggerDBHandlerTest | Class to test the down- and upload of trigger cuts to the DB |
| CSoftwareTriggerVariables | Storable object for the variables calculated in the SoftwareTriggerModule |
| CSoftwareTriggerModule | Module to perform cuts on various variables in the event |
| CSoftwareTriggerResultPrinterModule | Write out the software trigger results in an easily accessible summary table |
| CCosmicRayHLTDQMModule | A class definition of an input module for Sequential ROOT I/O |
| CSoftwareTriggerHLTDQMModule | Module defining the STM histograms |
| CStatisticsTimingHLTDQMModule | Module for Event Time Statistics DQM plots |
| CDBRepresentationOfSoftwareTriggerCutTest | Class to test the db representation of the cuts |
| ►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 |
| CSrsensorModule | The Srsensor module |
| CSensitiveDetector | Sensitive Detector implementation of the SRSENSOR detector |
| ►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 |
| CGeoSVDCreator | The creator for the SVD geometry of the Belle II detector |
| CSensorInfo | Specific implementation of SensorInfo for SVD Sensors which provides additional sensor specific information |
| ►CSVDBackgroundModule | SVD Background module |
| CSensorData | Struct to hold data of an SVD sensor |
| CSVDBeamBackHitFilterModule | The SVDBeamBackHitFilter module |
| CSVDDatabaseTestModule | Return the calibration results for the noises and the constants measured during the svd local runs (charge, ADC pulse, peaking time, pulse width) |
| ►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 |
| ►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 |
| CSVDClusterizerDirectModule | SVD Direct Clusterizer |
| CSVDClusterizerModule | The SVD Clusterizer |
| CSVDMissingAPVsClusterCreatorModule | SVDMissingAPVsClusterCreatorModule: The SVD MissingAPVsClusterCreator |
| CSVDNNClusterizerModule | SVD NN Clusterizer |
| CSVDNNShapeReconstructorModule | The SVD NNShapeReconstructor |
| CSVDRecoDigitCreatorModule | The SVD RecoDigit Creator |
| CSVDShaperDigitSorterModule | The SVDShaperDigitSorter module |
| CSVDSimpleClusterizerModule | SVDSimpleClusterizerModule: The SVD SimpleClusterizer |
| CSVDDigitizerModule | The SVD Digitizer module |
| ►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 |
| CNNWaveFitter | The class uses a neural network to find a probability distribution of arrival times for a sextet of APX25 signal samples |
| CEmpiricalDistributionFunction | Empirical distribution function object is basic for mainpulation of probabilities |
| CNNWaveFitTool | The class holds arrays of bins and bin centers, and a wave generator object containing information on the waveform function |
| CNoiseMap | Base Class to represent strip-dependent noise map |
| CStripInRawCluster | Structure containing the relevant informations of each strip of the raw cluster |
| CRawCluster | Class representing a raw cluster candidate during clustering of the SVD |
| CstripInCluster | Structure containing the relevant informations of eachstrip of the cluster |
| CSimpleClusterCandidate | Class representing a cluster candidate during simple clustering of the SVD |
| CSVDClusterCharge | Abstract Class representing the SVD cluster charge |
| 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 |
| 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 |
| CSVDOldDefaultPosition | Derived Class representing the SVD cluster position computed with the old algorithm (up to release-05) |
| CSVDRecoChargeFactory | Cluster Charge Factory Class |
| CSVDReconstructionBase | Class to check whether the reconstruction algorithms are available or not |
| CSVDRecoPositionFactory | Cluster Position Factory Class |
| CSVDRecoTimeFactory | Cluster Time Factory Class |
| CSVDSumSamplesCharge | Derived Class representing the SVD cluster charge computed summing the samples of each strip |
| CDefaultWave | A functor to provide a simple model of APV25 strip response |
| CWaveFitter | Waveform fitter class |
| CWaveGenerator | Waveform generator This is a functor to calculate APV samples from waveform |
| CTauEncoder | Encoder/decoder for neural network tau values |
| ►CSVDWaveform | The SVD waveform class |
| CElementaryWaveform | Type to store elementary waveform parameters |
| ►NTestHelpers | Some utilities to help with writing unit tests |
| CTestWithGearbox | This class provides a test fixture managing the opening and closing of the Gearbox with the default geometry file |
| CTempDirCreator | Changes working directory into a newly created directory, and removes it (and contents) on destruction |
| CLogMessageTest | Test fixture to be able to check the contents and types of emitted log messages in detail |
| ►NTOP | |
| ►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 |
| 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 and for finding optically decoupled PMT's |
| CTOPPulseHeightAlgorithm | Algorithm for pulse-height and threshold efficiency calibration |
| CTOPValidationAlgorithm | Algorithm for automatic validation of the calibration |
| CValidationTreeStruct | Calibration validation tree structure |
| CChannelMapper | Provides mapping between electronic channels and pixels |
| CFrontEndMapper | Provides mapping between electronics module position within a TOP module and SCROD ID, COPPER and Finesse slot |
| CGeoTOPCreator | Geometry creator for TOP counter |
| CTOPGeometryPar | Singleton class for TOP Geometry Parameters |
| 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 |
| ►CTimeDigitizer | Time digitization of simulated hits in a single electronic channel |
| CHit | Hit data other than time |
| CLaserCalibratorFit | A class do laser calibration fit provide different fitting method (under development) |
| CLikelihoods | Structure for TOPLikelihood members |
| CTrackHit | Structure for track parameters at TOP |
| CTOPTree | Structure of a flat ntuple |
| 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 |
| CBackgroundPDF | Parametrization of background PDF in pixels of single module |
| ►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 |
| 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 |
| 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 |
| ►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 |
| ►CSignalPDF | Parametrization of signal PDF in a single pixel |
| CPDFExtra | Extra information about single PDF peak |
| CPDFPeak | Single PDF peak |
| CTOPRecoManager | Singleton class providing pre-constructed reconstruction objects |
| ►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 |
| ►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 |
| CSensitiveBar | Class providing information on MCParticles hitting the bars |
| CSensitivePMT | Class providing SimHits |
| ►CChi2MinimumFinder1D | Minimum finder using tabulated chi^2 values in one dimension |
| CMinimum | Result of minimum finder |
| ►CTOPTemplateFitter | Class to perform template fit on TOP waveform data Minimzation 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 |
| CTrackSelector | Utility for the track selection - used in various calibration modules |
| ►NTrackFindingCDC | |
| CTFCDC_TrackQualityEstimatorModule | Module implementation using the TrackTrackQualityEstimator findlet |
| ►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 |
| CAsicBackgroundLibraryCreatorModule | Module for creating ASIC background library |
| CTFCDC_AxialTrackFinderLegendreModule | CDC tracking module, using Legendre transformation of the drift time circles |
| CTFCDC_AxialTrackFinderHoughModule | Module implementation using the AxialTrackFinderHough |
| CTFCDC_AxialTrackCreatorSegmentHoughModule | Module implementation using the AxialTrackCreatorSegmentHough |
| CTFCDC_AxialTrackCreatorMCTruthModule | Module implementation using the AxialTrackCreatorMCTruth |
| CTFCDC_MonopoleAxialTrackFinderLegendreModule | Module implementation using the MonopoleAxialTrackFinderLegendre Modification of conventional AxialTrackFinderLegendre |
| CTFCDC_AxialStraightTrackFinderModule | Module implementation using the AxialStraightTrackFinder |
| CCDCTrackingEventLevelMdstInfoFillerFindlet | Findlet description |
| CCDCTrackingEventLevelMdstInfoFillerModule | Module interface to the CDCTrackingEventLevelMdstInfoFillerFindlet |
| CTFCDC_ClusterPreparerModule | Module implementation using the ClusterPreparer |
| CTFCDC_SuperClusterCreatorModule | Module implementation using the SuperClusterCreator |
| CTFCDC_ClusterRefinerModule | Module implementation using the ClusterRefiner |
| CTFCDC_ClusterBackgroundDetectorModule | Module implementation using the ClusterBackgroundDetector |
| CTFCDC_TrackFinderSegmentPairAutomatonModule | Module implementation using the TrackFinderSegmentPairAutomaton |
| CTFCDC_TrackFinderSegmentTripleAutomatonModule | Module implementation using the TrackFinderSegmentTripleAutomaton |
| CTFCDC_TrackCreatorSingleSegmentsModule | Module implementation using the TrackCreatorSingleSegments |
| CTFCDC_TrackCreatorSegmentPairAutomatonModule | Module implementation using the TrackCreatorSegmentPairAutomaton |
| CTFCDC_TrackCreatorSegmentTripleAutomatonModule | Module implementation using the TrackCreatorSegmentTripleAutomaton |
| CTFCDC_SegmentPairCreatorModule | Module implementation using the SegmentPairCreator |
| CTFCDC_AxialSegmentPairCreatorModule | Module implementation using the AxialSegmentPairCreator |
| CTFCDC_SegmentTripleCreatorModule | Module implementation using the SegmentTripleCreator |
| CTFCDC_SegmentFinderFacetAutomatonModule | Module implementation using the SegmentFinderFacetAutomaton |
| CTFCDC_FacetCreatorModule | Module implementation using the FacetCreator |
| CTFCDC_SegmentCreatorFacetAutomatonModule | Module implementation using the SegmentCreatorFacetAutomaton |
| CTFCDC_SegmentLinkerModule | Module implementation using the SegmentLinker |
| CTFCDC_SegmentOrienterModule | Module implementation using the SegmentOrienter |
| CTFCDC_SegmentFitterModule | Module implementation using the SegmentFitter |
| CTFCDC_SegmentRejecterModule | Module implementation using the SegmentRejecter |
| CTFCDC_SegmentCreatorMCTruthModule | Module implementation using the SegmentCreatorMCTruth |
| CTFCDC_SegmentTrackCombinerModule | Module for the combination of tracks and segments |
| CTFCDC_StereoHitFinderModule | Tries to add CDC stereo hits to the found CDC tracks by applying a histogramming method with a quad tree |
| CTFCDC_MonopoleStereoHitFinderQuadraticModule | Tries to add CDC stereo hits to the found CDC tracks by applying a histogramming method with a quad tree |
| 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_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_TrackLinkerModule | Module implementation using the TrackLinker |
| CTFCDC_TrackCombinerModule | Module implementation using the TrackCombiner |
| CTFCDC_TrackRejecterModule | Module implementation using the TrackRejecter |
| CTFCDC_TrackQualityAsserterModule | Module implementation using the TrackQualityAsserter |
| CTFCDC_TrackOrienterModule | Module implementation using the TrackOrienter |
| CTFCDC_TrackFlightTimeAdjusterModule | Module implementation using the TrackFlightTimeAdjuster |
| CTFCDC_TrackExporterModule | Module implementation using the TrackExporter |
| CTFCDC_WireHitPreparerModule | Module to set up the cdcwire hits used in all CDC track finding algorithms (except Trasan) |
| CTFCDC_WireHitCreatorModule | Module implementation using the WireHitCreator |
| CTFCDC_HitReclaimerModule | Module to reclaim CDC hits |
| CTFCDC_WireHitBackgroundDetectorModule | Module counterpart to the WireHitBackgroundDetector findlet, which marks CDCWireHits as background based on the result of a filter |
| CAutomatonCell | Cell used by the cellular automata |
| CGetAutomatonCell | Getter functor for the automaton cell of an object |
| ►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 |
| CClusterizer | Implementation of the clustering Clusters elements of a given collection using the relations presented by a neighorhood |
| CMultipassCellularPathFinder | Class to combine the run of the cellular automaton and the repeated path extraction |
| CWithAutomatonCell | Mixin class to attach an automaton cell to an object or pointer |
| 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 |
| CRelationAdder | Class to add relations between the matched items |
| CStereoHitTrackAdder | Class to add the matched hits to the track and set the taken flag correctly |
| 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 |
| CSharingHitsMatcher | A generic matcher algorithm which outputs all combinations of elements with the number of shared hits as a weight |
| CStereoHitTrackQuadTreeMatcher | A matcher algorithm for using a stereo quad tree for matching rl tagged wire hits to tracks |
| 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 |
| CCutSelector | Selector to remove all weighted relations with a weight below a certain cut value |
| CFilterSelector | Selector to remove all weighted relations, where a definable Filter gives NaN as a result |
| 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) |
| CBoundingBox | A two dimensional rectangle that keeps track of the extend of a drawing |
| CStyling | Interface for a mapping of object and an index to styling attributes |
| CCDCSVGPlotter | Helper class to generated the svg image from the various tracking objects |
| CDefaultColorCycleMapping | Class template for coloring objects in different Colors |
| CColors | Utility functions related to colors |
| CEventDataPlotter | A class that can plot event related data types |
| CZeroDriftLengthStrokeWidthMap | CDCHit to stroke width map highlighting the CDCHits with 0 drift length |
| CZeroDriftLengthColorMap | CDCHit to color map highlighting the CDCHits with 0 drift length |
| CTakenFlagColorMap | CDCHit to color map highlighting the CDCHits that posses the do not use flag |
| CRLColorMap | CDCHit to color map by their local right left passage information from Monte Carlo truth |
| CPosFlagColorMap | CDCHit to color map by their assoziated CDCSimHit::getPosFlag property |
| CBackgroundTagColorMap | CDCHit to color map by their assoziated CDCSimHit::getBackgroundTag property |
| CMCSegmentIdColorMap | CDCHit to color map by their Monte Carlo segment id |
| CTOFColorMap | CDCHit to color map by their assoziated CDCSimHit::getFlightTime |
| CReassignedSecondaryMap | CDCHit to color map indicating the reassignment to a different MCParticle |
| CMCParticleColorMap | CDCHit to color map by their assoziated 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 |
| CSimHitPDGCodeColorMap | CDCHit to color map by the associated CDCSimHit::getPDG() |
| CSimHitIsBkgColorMap | CDCHit to color map by CDCSimHit::getBackgroundTag() |
| CNLoopsColorMap | Segment to color map by the number of passed loops |
| CMapping | Interface defining a mapping of objects to attribute values e.g. a color |
| CConstantMapping | Realizing a mapping returning a constant attribute value regardless of object or position |
| CCycleMapping | Realizing a mapping from a pool of values to be cycled from the index |
| CPrimitivePlotter | A base class for plots of primitive objects |
| CRecoTrackMatchingStatusColorMap | Color mapping showing the match status of the pattern recognition track |
| CMCRecoTrackMatchingStatusColorMap | Color mapping showing the match status of the monte carlo track |
| CSegmentMCTrackIdColorMap | Segment to color map based on the matched MCTrackId |
| CSegmentFBInfoColorMap | Segment to color map based on the forward or backward alignment relative to the match Monte Carlo track |
| CSegmentFirstInTrackIdColorMap | Segment to color map by the in track id of the first hit |
| CSegmentLastInTrackIdColorMap | Segment to color map by the in track id of the last hit |
| CSegmentFirstNPassedSuperLayersColorMap | Segment to color map by the number of passed superlayers of the first hit |
| CSegmentLastNPassedSuperLayersColorMap | Segment to color map by the number of passed superlayers of the last hit |
| CFixedStyling | Implementation of a styling from fixed attribute map |
| CChooseableStyling | Implementation of a styling composed from several predefined mappings chooseable by their name |
| CDefaultColorCycleStyling | Class template for coloring objects with stroke colors prepared to be the default color cycle |
| 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 |
| CChooseableHitStyling | This Class handles the mapping from the colormapping-method name given as a string to the actual color mapping for CDCHits |
| CSVGPrimitivePlotter | A concrete plotter that can draw primitive objects to standalone SVG files |
| CCDCFacet | Class representing a triple of neighboring oriented wire with additional trajectory information |
| CCDCRecoHit2D | Class representing a two dimensional reconstructed hit in the central drift chamber |
| CCDCRecoHit3D | Class representing a three dimensional reconstructed hit |
| 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 |
| ►CCDCRLWireHitTriple | Class representing a triple of neighboring wire hits |
| CShape | Type for the different shapes of a triple of neighboring wire hits |
| CCDCTangent | Class representating a linear track piece between two oriented wire hits |
| CCDCWireHit | Class representing a hit wire in the central drift chamber |
| CGetWireHit | Generic functor to get the wire hit from an object |
| CCDCFacetSegment | A segment consisting of adjacent facets |
| CCDCRLWireHitSegment | A segment consisting of two dimensional reconsturcted hits |
| CCDCSegment | A sequence of hits limited to one superlayer |
| CWeightedRelation | Type for two related objects with a weight |
| CRelation | Type for two related objects |
| CCDCSegment2D | A reconstructed sequence of two dimensional hits in one super layer |
| CCDCSegment3D | A segment consisting of three dimensional reconstructed hits |
| CCDCTangentSegment | A segment consisting of adjacent tangents |
| CCDCWireHitCluster | An aggregation of CDCWireHits |
| CCDCWireHitSegment | A segment consisting of two dimensional reconsturcted hits |
| CCDCAxialSegmentPair | Class representing a pair of reconstructed axial segements in adjacent superlayer |
| CCDCSegmentPair | Class representing a pair of one reconstructed axial segement and one stereo segment in adjacent superlayer |
| CCDCSegmentTriple | Class representing a triple of reconstructed segements in adjacent superlayer |
| CCDCTrack | Class representing a sequence of three dimensional reconstructed hits |
| CCDCBFieldUtil | Helper functions to interact with the magnetic field |
| 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 |
| 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 |
| CEnergyLossEstimator | Helper struct to provide consistent energy loss estimation throughout the CDC track finding |
| CFlightTimeEstimator | Helper struct to provide consistent flight time estimation throughout the CDC track finding |
| CBeamEventFlightTimeEstimator | Concrete estimator for the regular beam event setup |
| CCosmicRayFlightTimeEstimator | Concrete estimator for the cosmic ray setup - estimates negative times on incoming arm |
| CRecoTrackUtil | Structure to summarize utility function to output a list of hits into a RecoTrack |
| CAllAxialSegmentPairFilter | Filter accepting all axial to axial segment pairs |
| CAxialSegmentPairFilterFactory | Factory that can create appropriate axial segment pair filters from associated names |
| 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 |
| 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 |
| 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 |
| 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 |
| CMCAxialSegmentPairFilter | Filter for the constuction of axial to axial segment pairs based on simple criterions |
| CMVAFeasibleAxialSegmentPairFilter | Filter for the constuction of segment pairs based on simple criteria without the common fit |
| CMVARealisticAxialSegmentPairFilter | Final filter for the constuction of segment pairs |
| CSimpleAxialSegmentPairFilter | Filter for the constuction of axial to axial segment pairs based on simple criterions |
| 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 |
| CUnionRecordingAxialSegmentPairFilter | Filter to record multiple chooseable variable sets for axial segment pairs |
| CAllFilter | Filter adapter type that accepts all items (just for reference) |
| CAndFilter | Filter adapter type that joins two filter results in an and like fashion |
| CChoosableFromVarSet | Filter adapter to make a filter work on a set of variables and return on variable as the result of the filter |
| CChoosableFromVarSetFilter | Convience 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 |
| CFilter | Base class for filters on a generic object type |
| CFilterFactory | Factory that can create apropriate filter instances from a name |
| COnVarSet | Filter adapter to make a filter work on a set of variables |
| CFilterOnVarSet | Convience 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 |
| 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 |
| CMCSymmetric | Mixin for filters that use Monte Carlo information |
| CMVA | Filter based on a mva method |
| CMVAFilter | Convience template to create a mva filter for a set of variables |
| CNegativeFilter | Filter adapter type that negates the acceptance criterion for cross checks |
| CNoneFilter | Filter adapter type that rejects all items |
| 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 |
| CPassThroughFilter | Filter adapter type that passes the weight of a weighted relation as a result |
| CRandomFilter | Random filter resulting in a random weight between 0 and 1 |
| CRecording | Filter adapter to make a filter work on a set of variables and record the observed instances on invokation |
| CRecordingFilter | Convience template to create a recording filter for a set of variables |
| CRelationFilter | Base class for filtering the neighborhood of objects |
| CRelationFilterUtil | Name Structured creation of neighborhoods |
| CSloppy | A filter that accepts every <sloppinessFactor>th candidate on average (random selection) |
| CTruthVarFilter | MC Filter Type using a VarSet and the truth variable in it |
| CUnionRecording | A filter that records variables form given objects |
| CUnionRecordingFilter | Convience template to create a recording filter for a filter factory |
| CAllClusterFilter | Filter accepting all clusters |
| 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 |
| 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 |
| CClusterFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CMVABackgroundClusterFilter | Background cluster detection based on MVA package |
| CUnionRecordingClusterFilter | Filter to record multiple chooseable variable sets for wire hit clusters |
| CAllFacetFilter | Filter for the constuction of good facets based on simple criterions |
| 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 |
| 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 |
| CChi2FacetFilter | Filter for the constuction of good facets based in the chi2 fit |
| CFacetFilterFactory | Factory that can create appropriate facet filters from associated names |
| CFeasibleRLFacetFilter | Filter for the constuction of good facets investigating the feasability of the right left passage hypotheses combination |
| 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 |
| 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 |
| CMCFacetFilter | Filter for the constuction of good facets based on monte carlo information |
| CMVAFacetFilter | Background facet detection based on MVA |
| CRealisticFacetFilter | Filter for the constuction of good facets based on simple criterions |
| CSimpleFacetFilter | Filter for the constuction of good facets based on simple criterions |
| CUnionRecordingFacetFilter | Filter to record multiple chooseable variable sets for facets |
| CAllFacetRelationFilter | Filter accepting all facet relations with a default weight |
| CBaseFacetRelationFilter | Base class for filtering the neighborhood of facets |
| 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 |
| 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 |
| CChi2FacetRelationFilter | Class filtering the neighborhood of facets based on chi2 from a fit both facets |
| CFacetRelationFilterFactory | Factory that can create appropriate facet relation filters from associated names |
| 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 |
| CMCFacetRelationFilter | Class filtering the neighborhood of facets with monte carlo information |
| CMVAFacetRelationFilter | Background facetRelation detection based on MVA |
| CSimpleFacetRelationFilter | Class filtering the neighborhood of facets based on simple criterions |
| CUnionRecordingFacetRelationFilter | Filter to record multiple chooseable variable sets for facet relations |
| 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 |
| 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 |
| 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 |
| CSegmentFilterFactory | Factory that can create appropriate segment filters for new tracks from associated names |
| 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 |
| CAllSegmentPairFilter | Filter for the constuction of axial to stereo segment pairs based on simple criteria |
| 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 |
| CFitlessSegmentPairFilter | Filter for the constuction 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 |
| 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 |
| 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 |
| CMCSegmentPairFilter | Filter for the constuction of axial to stereo segment pairs based on MC information |
| CMVAFeasibleSegmentPairFilter | Filter for the constuction of segment pairs based on simple criteria without the common fit |
| CMVARealisticSegmentPairFilter | Final filter for the constuction of segment pairs |
| CSegmentPairFilterFactory | Factory that can create appropriate segment pair filters from associated names |
| CSimpleSegmentPairFilter | Filter for the constuction of axial to axial segment pairs based on simple criterions |
| 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 |
| 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 |
| 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 |
| CUnionRecordingSegmentPairFilter | Filter to record multiple chooseable variable sets for segment pairs |
| CAllSegmentPairRelationFilter | Relation filter that lets all possible combinations pass |
| CBaseSegmentPairRelationFilter | Base class for filtering the neighborhood of axial stereo segment pairs |
| 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 |
| 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 |
| CMCSegmentPairRelationFilter | Class filtering the neighborhood of axial stereo segment pairs with monte carlo information |
| CMVARealisticSegmentPairRelationFilter | Final filter for the constuction of segment pairs |
| CSegmentPairRelationFilterFactory | Factory that can create appropriate segment pair relation filters from associated names |
| CSimpleSegmentPairRelationFilter | Class filtering the neighborhood of axial stereo segment pairs based on simple criteria |
| 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 |
| CUnionRecordingSegmentPairRelationFilter | Filter to record multiple chooseable variable sets for segment pair relations |
| CBaseSegmentRelationFilter | Base class for filtering the neighborhood of segments |
| 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 |
| 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 |
| 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 |
| 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 |
| CMCSegmentRelationFilter | Filter for the constuction of segment relations based on MC information |
| CMVAFeasibleSegmentRelationFilter | Filter for the constuction of segment pairs based on simple criteria without the common fit |
| CMVARealisticSegmentRelationFilter | Final filter for the constuction of segment pairs |
| CSegmentRelationFilterFactory | Factory that can create appropriate segment relation filters from associated names |
| CUnionRecordingSegmentRelationFilter | Filter to record multiple chooseable variable sets for segment relations |
| 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 |
| CAllSegmentTripleFilter | Filter for the constuction of segment triples based on simple criterions |
| CMCSegmentTripleFilter | Filter for the constuction of segment triples based on monte carlo information |
| CSegmentTripleFilterFactory | Factory that can create appropriate segment triple filters from associated names |
| CSimpleSegmentTripleFilter | Filter for the constuction of segment triples based on simple criterions |
| CAllSegmentTripleRelationFilter | Class excepting all segment triples |
| CBaseSegmentTripleRelationFilter | Base class for filtering the neighborhood of segment triples |
| CMCSegmentTripleRelationFilter | Class filtering the neighborhood of segment triples with monte carlo information |
| CSegmentTripleRelationFilterFactory | Factory that can create appropriate segment triple relation filters from associated names |
| CSimpleSegmentTripleRelationFilter | Class filtering the neighborhood of segment triples based on simple criterions |
| CStereoHitFilterFactory | Factory that can create appropriate stereo hit to track combination filters from associated names |
| 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 |
| CBasicTrackVarSetNames | Vehicle class to transport the variable names |
| 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 |
| 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 |
| CTrackFilterFactory | Factory that can create appropriate track filters from associated names |
| 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 |
| 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 |
| CAllTrackRelationFilter | Relation filter that lets all possible combinations pass |
| CBaseTrackRelationFilter | Base class for filtering the neighborhood of tracks |
| 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 |
| 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 |
| 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 |
| CMCTrackRelationFilter | Filter for the constuction of track relations based on MC information |
| CMVAFeasibleTrackRelationFilter | Filter for the constuction of track pairs based on simple criteria without the common fit |
| CMVARealisticTrackRelationFilter | Final filter for the constuction of segment pairs |
| CPhiTrackRelationFilter | Relation filter that lets only possibilities with small phi distance pass |
| CTrackRelationFilterFactory | Factory that can create appropriate track relation filters from associated names |
| CUnionRecordingTrackRelationFilter | Filter to record multiple chooseable variable sets for track relations |
| CAllWireHitFilter | Filter accepting all hits |
| CCutsFromDBWireHitFilter | Filter rejecting hits according to DB values |
| CWireHitFilterFactory | Factory that can create appropriate wireHit filters from associated names |
| CBridgingWireHitRelationFilter | Wire hit relation filter that is compensating for hit inefficiencies |
| CWholeWireHitRelationFilter | Class mapping the neighborhood of wires to the neighborhood of wire hits |
| ►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 |
| CStoreArrayLoader | Helper findlet to allow combined findlets to import data from the DataStore |
| CStoreVectorSwapper | Refines the clustering of wire hits from clusters to clusters |
| CAxialStraightTrackFinder | Generates straight axial tracks from IP to an ECL cluster |
| 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 |
| CClusterPreparer | Findlet to cluster the wire hits in the CDC to form locally connected groups with two granularities."; |
| 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 |
| CSegmentFinderFacetAutomaton | Findlet implementing the segment finding part of the full track finder |
| CSegmentTrackCombiner | Findlet for the combination of tracks and segments |
| CStereoHitFinder | Complex findlet for finding stereo hits to a list of cdc tracks |
| 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 |
| CTrackQualityEstimator | Deletes fake tracks that have been rejected by a filter |
| CWireHitPreparer | Findlet preparing the wire hits for the track finding |
| CAsicBackgroundLibraryCreator | Finds ASICs with single signal hit, records info to the library |
| 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 |
| 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 |
| 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 |
| CAsicBackgroundDetector | Marks hits as background based on the result of a filter |
| CAxialSegmentPairCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CAxialStraightTrackCreator | A findlet that searches for straight tracks in CDC coming form 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 |
| 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 |
| CCDCMCCloneLookUpFiller | Findlet to exports CDCTracks as RecoTracks |
| CClusterBackgroundDetector | Marks clusters as background based on a background measure |
| CClusterCreator | Refines the clustering of wire hits from clusters to clusters |
| CClusterRefiner | Refines the clustering of wire hits from super clusters to clustexrs |
| CFacetCreator | Class providing construction combinatorics for the facets |
| CHitReclaimer | A small findlet that removes flags from hits not accepted by conventional tracking |
| CRLTaggedWireHitCreator | Findlet for creating a list of RLWireHits (always bot hypothesis) from a list of WireHits using only the non-taken non-axial hits |
| 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 |
| CSegmentFitter | Fits segments with the Riemann method |
| CSegmentLinker | Links segments in the same super cluster by linking paths of segments in a cellular automaton |
| CSegmentOrienter | Fixes the orientation of segments by a simple heuristic |
| CSegmentPairCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CSegmentRejecter | Deletes fake segments that have been rejected by a filter |
| CSegmentTrackAdderWithNormalization | Add the matched segments to the tracks and normalize the tracks afterwards |
| CSegmentTripleCreator | Class providing construction combinatorics for the axial stereo segment pairs |
| CSuperClusterCreator | Refines the clustering of wire hits from clusters to clusters |
| 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 |
| 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 |
| CTrackRejecter | Deletes fake tracks that have been rejected by a filter |
| CTrackSZFitter | Findlet for fitting a list of tracks in the SZ direction and replace their trajectory 3D |
| CWeightedRelationCreator | Findlet that combines geometrical constrained pairs of objects to relations and selects them by the filter given as template parameter |
| 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 |
| CWireHitMCMultiLoopBlocker | Marks all hits that are not on the first loop of the track as background |
| CFindletStoreArrayInput | Findlet which can wrap another Findlet and forward the contents of a StoreArray to the wrapped findlet |
| CCDCAxialStereoFusion | Utility class implementing the Kalmanesk combination of to two dimensional trajectories to one three dimensional trajectory |
| CCDCFitter2D | Class implementing a fit for two dimensional trajectory circle using a generic fitting backend |
| CCDCKarimakiFitter | Class implementing the fitter using Karimakis method |
| CCDCObservations2D | Class serving as a storage of observed drift circles to present to the Riemann fitter |
| CCDCRiemannFitter | Class implementing the Riemann fit for two dimensional trajectory circle |
| CCDCRobustSZFitter | Utility class implementing robust versions of linear sz trajectory line fits |
| 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 |
| CExtendedRiemannsMethod | Class implementing the Riemann fit for two dimensional trajectory circle |
| CFacetFitter | Utility class to fit hit triplet and relations of them |
| CKarimakisMethod | Class implementing the Karimaki fit for two dimensional trajectory circle |
| CRiemannsMethod | Class implementing the Riemann fit for two dimensional trajectory circle |
| CCircle2D | A two dimensional circle in its natural representation using center and radius as parameters |
| CGeneralizedCircle | A generalized circle |
| CHelix | Extension of the generalized circle also caching the perigee coordinates |
| CHelixUtil | Utility struct for functions and types related to the helix parameters |
| CLine2D | A two dimensional normal line |
| CLineUtil | Utility struct for functions and types related to the line parameters |
| CParameterLine2D | A line with a support point and tangential vector |
| CPerigeeCircle | Extension of the generalized circle also caching the perigee coordinates |
| CPerigeeUtil | Utility struct for functions and types related to the perigee parameters |
| CSZLine | A line in the sz space |
| CSZUtil | Utility struct for functions and types related to the sz plane parameters |
| 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 |
| CVector2D | A two dimensional vector which is equipped with functions for correct handeling of orientation related issues in addition to the expected vector methods |
| CVector3D | A three dimensional vector |
| CFirstOfPairInBox | Helper class to redirect only the first element in a pair to the child algorithm |
| 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 |
| 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 |
| CRangeInBox | Predicate class to check for the containment of items in a rangeobject in a hough space part |
| 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 |
| CTwoHitInBoxAlgorithm | Predicate class to check for the containment of items in a hough space part with two algorithms |
| CContinuousValue | Type to have values not based on discrete positions from an array |
| CDiscreteValue | Representation for a discrete position in an array of discrete positions |
| CCurvWithArcLength2DCache | Class representing a curvature value that also caches two dimensional arc length to each layer in the CDC |
| CLinearDivision | Factory object that constructs sub boxes from a given box with optional overlaps |
| CSameSignChecker | Small helper for checking the same sign of two, four or eight floats |
| CSectoredLinearDivision | Factory object that constructs sub boxes from a given box with optional overlaps |
| CUnmarkable | Mixin class to attach a mark that is shared among many instances |
| CWithSharedMark | Mixin class to attach a mark that is shared among many instances |
| CWithWeightedItems | A mixin class to attach a set of weighted items to a class |
| CBox | The base class for all boxes |
| CBox<> | Box Base class specification without any template arguments |
| CBox< AFirstType, ASubordinaryTypes... > | Box Base class specification without a first and subordinary types which can be used to "stack" various template until the full box is described correctly |
| CPQBox | A rectangular domain for the hough space over p and q |
| 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 |
| CZ0TanLambdaBox | A rectangular domain for the hough space over phi0 and two dimensional curvature |
| CHyperHough | Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type |
| 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 |
| CCurvBinsSpec | Strategy to construct discrete curv points from discrete overlap specifications |
| CGetLowerCurv | Functor to get the lower curvature bound of a hough box |
| CGetUpperCurv | Functor to get the upper curvature bound of a hough box |
| CImpactBinsSpec | Strategy to construct discrete impact points from discrete overlap specifications |
| CAImpactSweeped | Takes a basic object and sweeps it by some d0 range in the y direction |
| COffOrigin | Takes a basic object and passivelly moves it to any origin All subordinary coordinates have to be interpreted relative to this origin |
| CPhi0BinsSpec | Strategy to construct discrete phi0 points from discrete overlap specifications |
| CAPhi0Sweeped | Takes a basic object and sweeps it by some angle phi0 range a around the origin |
| CSimpleHitBasedHoughTree | A convenience class based on a BoxDivisionHoughTree for "hit-like" classes |
| CStereoHitContained | Predicate class to check for the containment of axial and stereo hits in some hough space part |
| CQuadraticLegendre | Hough Tree for finding StereoHits with using CDCRecoHit3D as the item type |
| 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 |
| CDebugableSimpleBoxDivisionHoughTree | A convenience class for adding debug information to a Simple Hough Tree |
| ►CDynTree | This is the base class for all hough trees |
| CNode | Class for a node in the tree |
| 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 |
| CWeightedParititioningDynTree | Type of tree for paritioning the hough space |
| CWeightedFastHoughTree | Dynamic tree structure with weighted items in each node which are markable through out the tree |
| CZ0TanLambdaLegendre | Hough Tree for finding StereoHits using a templated class as the item type |
| 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 |
| CAxialHitQuadTreeProcessor | A QuadTreeProcessor for TrackHits |
| CBaseCandidateReceiver | Base class that receives candidates found by quadtree |
| COffOriginExtension | Class performs extension (adding new hits) of given candidate using conformal transformation w.r.t point on the trajectory |
| 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 |
| CCDCMCCloneLookUp | Class providing information whether a PR CDC track is the best match or a clone |
| CCompareCDCTracks | Functor which which decides which of two tracks to declare as best match |
| CMCTrackIdPurityPair | Structure representing a matched Monte Carlo track id with the corresponding purity |
| 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 |
| CCDCSimHitLookUp | Singletone class to gather local information about the hits |
| ►CMVAExpert | Class to interact with the MVA package |
| CImpl | Implementation of the class to interact with the MVA package |
| CPyEstimator | Class to invoke a pretrained python estimator that follows the sklearn interface |
| ►CRecorder | Class to fill a tree from a set of variables |
| CImpl | Record the MVA variables |
| CAngleUtil | Utility functions to be used with angular quantities |
| CCovarianceMatrixUtil | Collection of functions related to covariance matrices |
| CJacobianMatrixUtil | Collection of functions related to jacobian matrices |
| CLookupTable | Class which holds precomputed values of a function |
| CParameterVectorUtil | Structure to gather some utility functions for the ParameterVector |
| CPlainMatrix | A matrix implementation to be used as an interface typ through out the track finder |
| CPlainMatrixUtil | Utility functions for the PlainMatrix |
| CPrecisionMatrixUtil | Collection of functions related to precision matrices |
| CSinEqLine | Helper class to calculate roots for the function f(x) = sin x - slope * x - intercept |
| CTMatrixConversion | Convert between TMatrix and CovarianceMatrix representations |
| CGetWeight | Generic functor to get the weight from an object |
| CWithWeight | A mixin class to attach a weight to an object |
| CAxialTrackUtil | Utility structure gathering heuristic functions used during the axial track finding |
| CLowHitsAxialTrackUtil | Utility structure gathering heuristic functions used during the search for non-helix or low hit count tracks |
| CTrackQualityTools | Tools to apply post corrections to a track after finding |
| 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 |
| ►CCDCSimpleSimulation | Class providing a simple simulation of the CDC mainly for quick unit test checks |
| CSimpleSimHit | Structure to accomdate information about the individual hits during the simluation |
| 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 |
| CDISABLED_Long_TrackFindingCDCTestWithTopology | Equivalent to |
| CCDCGeometryLoader | Load the CDC geometry from the conditions database |
| CCDCWire | Class representing a sense wire in the central drift chamber |
| CCDCWireLayer | Class representating a sense wire layer in the central drift chamber |
| CCDCWireSuperLayer | Class representating a sense wire superlayer in the central drift chamber |
| CCDCWireTopology | Class representating the sense wire arrangement in the whole of the central drift chamber |
| CGetEStereoKind | Generic functor to get the stereo kind from an object |
| CGetILayer | Generic functor to get the superlayer id from an object |
| CGetISuperLayer | Generic functor to get the superlayer id from an object |
| CISuperLayerUtil | This is a utility class for the free ISuperLayer type |
| CIWireUtil | This is a utility class for the free IWire type |
| 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 |
| CCommon | Adapter of a category function to find the common category of several objects |
| CCompositeProcessingSignalListener | Partial implemenation for an algorithm part that wants to dispatch processing signals to subobjects |
| CEvalVariadic | Structure to serve as a placeholder for a variadic initializer list of statements to be evaluated |
| CFirstTypeImpl | Helper type to take the first type of a variadic sequence of types |
| CFirstTypeImpl<> | Specialisation where there is exactly one type given |
| CFirstTypeImpl< AType > | Specialisation where there is exactly one type given |
| CFirstTypeImpl< AType, ATypes... > | Specialisation where there is more than one type given |
| CGetIndexInTuple | Looks up, at which index the given Type can be found in a tuple |
| CGetIndexInTuple< AType, std::tuple<> > | Specialisation to terminate the recursion in case it was not found |
| 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 |
| CId | Generic identity functor |
| CConstant | Generic functor to wrap a constant as a function |
| CComposition | Functor factory from the functional composition of two functors |
| 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 |
| CAlternation | Generic functor to try to functors and choose the first to be applicable |
| CVoid | Functor returning void from an abitrary objects |
| CGet | Functor to get the I part (as of std::get<I>) from an abitrary objects |
| CSize | Functor to get the .size() from an abitrary objects |
| CClear | Functor to get the .clear() from an abitrary objects |
| CNot | Functor to get the logical negation from an abitrary objects |
| CDeref | Functor to get the referenced object from an abitrary objects |
| CIndirect | Functor to get the indirection from an abitrary objects |
| CLess | Binary functor for less comparision of abitrary objects - equivalent to std::less<> (c++14) |
| CGreater | Binary functor for greater comparision of abitrary objects - equivalent to std::greater<> (c++14) |
| CEqual | Binary functor for equality comparision of abitrary objects - equivalent to std::equal_to<> (c++14) |
| CIsNaN | Unary functor for equality comparison to NAN |
| CFunctorTag | Tag class to facilitate marking of class as a functor in the sense of this code |
| 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 |
| CNamed | A mixin class to attach a name to an object |
| CAssignParameterVisitor | A helper class to unpack a boost::variant parameter value and set it in the parameter list |
| 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 specilisation for compile time computation of products |
| CProduct<> | Template class specilisation for compile time computation of products |
| CRange | A pair of iterators usable with the range base for loop |
| 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 |
| CSortedRange | A pair of iterators usable with the range base for loop |
| CTimeItResult | Class to capture the time a repeated execution took |
| CTupleGenerateImpl | Apply the template function F to each element of the index sequence |
| CTupleGenerateImpl< AGenerator, std::index_sequence< Is... > > | Specialisation for concrete indices |
| CWeightedRelationUtil | Utility structure with functions related to weighted relations |
| CBaseVarSet | Generic class that generates some named float values from a given object |
| CFixedSizeNamedFloatTuple | Generic class that contains a fixed number of named float values |
| CNamedFloatTuple | An abstract tuple of float value where each value has an associated name |
| CRelationVarSet | Generic class that generates the same variables from a each of a pair of instances |
| CUnionVarSet | Class that accomodates many variable sets and presents them as on set of variables |
| CVariadicUnionVarSet | Class that accomodates 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 |
| ►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 |
| CVisitOverload | Helper struct for the C++17 std::visit overload pattern to allow simple use of variants |
| CTimer | Small helper class that prints its lifetime when destroyed |
| ►NVariable | |
| ►CManager | Global list of available variables |
| CMetaVar | A variable taking string arguments returning a variable |
| CParameterVar | A variable taking additional floating-point arguments to influence the behaviour |
| CVar | A variable returning a floating-point value for a given Particle |
| CVarBase | Base class for information common to all types of variables |
| CProxy | Internal class that registers a variable with Manager when constructed |
| CGroupProxy | Internal class that registers a variable group with Manager when constructed |
| CDeprecateProxy | Internal class that registers a variable as deprecated |
| ►NVXD | Namespace to provide code needed by both Vertex Detectors, PXD and SVD, and also testbeam telescopes |
| CGeoCache | Class to faciliate 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 |
| CSensorInfoBase | Base class to provide Sensor Information for PXD and SVD |
| CSensorPlane | A Finite plane of one VXD Sensor |
| CVXDMisalignmentModule | The VXD misalignment module |
| 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 |
| ►NvxdHoughTracking | |
| ►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 |
| 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 |
| CPathFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CQualityIndicatorFilter | Filter for >= 3 hits using QualityEstimators |
| CThreeHitFilter | Filter for three hits |
| CThreeHitVariables | Class that allows the calculation of simple variables to estimate the quality of a triplet of hits |
| 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 |
| CAngleAndTimeRelationFilter | Filter for relations based on the polar angle difference and the time difference of the hits |
| CLayerRelationFilter | Relation filter the creation of relations |
| CRelationFilterFactory | Factory that can create appropriate filters for relations between hits from associated names |
| CSimpleRelationFilter | Filter for relations based on the polar angle difference |
| CTrackletFilterFactory | Factory that can create filters for tracklets = SpacePointTrackCands from associated names |
| 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 |
| 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 ) .. |
| COnHitApplier | Helper findlet which applies its () operator to all pairs of path and hit with all hits in the given child hit list |
| CPathLengthToggledApplier | A special findlet, which chooses the filter based on the current path length |
| 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 |
| CROIFinder | Findlet for performing the simple SVDHoughTracking ROI calculation |
| ►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 ) .. |
| 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 |
| CTrackCandidateOverlapResolver | Findlet for rejecting wrong SpacePointTrackCands and for removing bad hits |
| CTrackCandidateResultRefiner | Findlet for rejecting wrong SpacePointTrackCands and for removing bad hits |
| CMillepedeAlgorithm | Class implementing Millepede calibration algorithm |
| CMillepedeTreeConversionAlgorithm | Creation of a plain TTree with residual and global derivative values from GBL data saved to a ROOT file |
| CMilleData | Mergeable class holding list of so far opened mille binaries and providing the binaries |
| CPedeSteering | Class representing Millepede steering |
| CCDCCalibration | CDC alignment and calibration constants |
| CVXDAlignment | VXD alignment (and maybe some calibration) parameters |
| CGblMultipleScatteringController | TrackSegmentController for use with GblFitter in Belle2 |
| ►CGlobalLabel | Class to convert to/from global labels for Millepede II to/from detector & parameter identificators |
| CTimeInterval | Struct to hold intervals of validity |
| 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 |
| CCopyRecoTracksWithOverlapModule | Copy RecoTracks with overlap hits in VXD to a new StoreArray (Will need a refit) |
| CCosmicsAlignmentValidationModule | Module to find Track correlation in cosmic events |
| CMergerCosmicTracksModule | Module use to select two cosmic tracks event and merger these two tracks become one |
| CMillepedeCollectorModule | Calibration data collector for Millepede Algorithm |
| CSetRecoTrackMomentumModule | Set momentum magnitude for RecoTracks to given value (for runs without magnetic field) |
| CUpdateParticleTrackCandModule | Updates the seed in TrackCand based on fitted state (at vertex) |
| 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 |
| CGlobalLabelTest | Test fixture |
| CClusterUtils | Class to provide momentum-related information from ECLClusters |
| CCleoCones | Class to calculate the Cleo clone variables |
| CFoxWolfram | Class to calculate the Fox-Wolfram moments up to order 8 |
| CHarmonicMoments | Class to calculate the Harmonic moments up to order 8 with respect to a given axis |
| CKsfwMoments | Moment-calculation of the k_sfw improved Super-Fox-Wolfram moments |
| CSphericityEigenvalues | Class to calculate the Sphericity tensor eigenvalues and eigenvectors starting from an array of 3-momenta The tensor itself is not stored, only its eigenvalues and eigenvectors are |
| CThrust | Class to calculate the thrust axis |
| CBtube | For each MCParticle with hits in the CDC, this class stores some summarising information on those hits |
| CContinuumSuppression | This is a class for collecting variables used in continuum suppression |
| CECLEnergyCloseToTrack | Class to store energy information for ECL hits closest to a track |
| CECLTRGInformation | Class to store information about ECL trigger cells (TCs) |
| CECLTriggerCell | ECL Trigger cells |
| CEventKinematics | Class for collecting variables related to the global kinematics of the event |
| CEventShapeContainer | Class for collecting the basic objects related to the event shape |
| CFlavorTaggerInfo | This class stores the relevant information for the TagV vertex fit, extracted mainly from the Flavor Tagging Module |
| CFlavorTaggerInfoMap | This class stores the Flavor Tagger information for a specific method and particle filled in the Flavor Tagger Module |
| CParticle | Class to store reconstructed particles |
| CParticleExtraInfoMap | Internal class to store string -> index maps for extra info stored in Particle |
| CStoreObjPtr | Type-safe access to single objects in the data store |
| CParticleList | ParticleList is a container class that stores a collection of Particle objects |
| ►CRestOfEvent | This is a general purpose class for collecting reconstructed MDST data objects that are not used in reconstruction of given Particle – referred also as Rest Of the Event |
| CMask | Structure of Rest of Event mask |
| CStringWrapper | This class is a wrapper for strings, such as MCDecayStrings, to allow them to be associated with particles via a relation |
| CTagVertex | TagVertex data object: contains Btag Vertex and DeltaT |
| CTauPairDecay | Class for collecting variables related to tau-taubar MC decay process |
| CChargedPidMVAWeights | Class to contain the payload of MVA weightfiles needed for charged particle identification |
| CParticleWeightingAxis | Class for handling LookUp tables |
| CParticleWeightingBinLimits | Just pair of numbers - min and max values of bin border |
| CParticleWeightingKeyMap | Class for handling KeyMap |
| CParticleWeightingLookUpTable | Class for handling LookUp tables |
| CPIDCalibrationWeight | Class for handling the PID calibration weight matrix |
| ►CPIDDetectorWeights | Class for handling the PID weights per detector, used to calculate the track helix isolation score per particle |
| CWeightsTable | Nested class acting as a container the per-detector weights |
| CPIDNeuralNetworkParameters | Class for handling the parameters for the neural-network PID |
| CPIDPriors | A database class to hold the prior probability for the particle identification |
| CPIDPriorsTable | This class holds the prior distribution for a single particle species |
| CDecayDescriptor | The DecayDescriptor stores information about a decay tree or parts of a decay tree |
| CDecayDescriptorParticle | Represents a particle in the DecayDescriptor |
| CDecayStringDecay | Holds the information of a decay |
| CDecayStringGrammar | This class describes the grammar and the syntax elements of decay strings |
| CDecayStringParticle | Holds the information of a particle in the decay string |
| CParticleListHelper | Class to help managing creation and adding to ParticleLists |
| CAllParticleCombinerModule | This module combines all particles of the provided list to one mother particle |
| CAnalysisConfigurationModule | Class to hold general basf2 configuration Used to intiate and configure CreateAnalysis object |
| CBelleNbarMVAModule | Apply nbarMVA for Belle I |
| CBestCandidateSelectionModule | Ranks particles by the values of a variable |
| CEnergyBiasCorrectionModule | Energy bias correction |
| CBelleBremRecoveryModule | Brem recovery module (used in past belle analyses) This module add four vector of all the brem photon to the four vector associated to the charged particle |
| CBremsFinderModule | Bremsstrahlung finder correction module For each lepton in the input particle list, this module copies it to the output particle list and uses the results of the eclTrackBremFinder module to look for a possible bremsstrahlung photon; if this photon exists, adds its four momentum to the leptons in the output list |
| CBtubeCreatorModule | Create a B particle from a Bbar particle |
| CChargedPidMVAModule | This module evaluates the response of an MVA trained for binary charged particle identification between two hypotheses, S and B |
| CChargedPidMVAMulticlassModule | This module evaluates the response of a multi-class MVA trained for global charged particle identification |
| CContinuumSuppressionBuilderModule | Creates for each Particle in given ParticleList an ContinuumSuppression dataobject and makes basf2 relation between them |
| CCurlTaggerModule | This module is designed to tag curl tracks |
| CDistanceCalculatorModule | Calculates distance between two vertices, distance of closest approach between a vertex and a track, distance of closest approach between a vertex and Btube |
| CDuplicateVertexMarkerModule | Identify duplicate vertices (distinct particles, but built from the same daughters) and mark the one with best chi2 |
| CEventKinematicsModule | Module to compute global quantities related to the event kinematics, like total missing energy and mass2, visible energy, etc |
| CEventShapeCalculatorModule | Module to compute event shape variables starting from three lists of particle objects (tracks, gammas, Klongs) |
| CExtraInfoPrinterModule | Prints the names of the ExtraInfos for a ParticleList or for the Event |
| CExtraInfoRemoverModule | This module deletes the extrainfo of each particle in the given ParticleLists |
| CFlavorTaggerInfoBuilderModule | Creates for each Particle and RestOfEvent object in the DataStore a FlavorTaggerInfo dataobject and makes basf2 relation between them |
| CFlavorTaggerInfoFillerModule | Creates a new flavorTaggerInfoMap DataObject for the specific methods |
| CHelixErrorScalerModule | Scale the error of helix parameters |
| CInclusiveBtagReconstructionModule | Inclusively reconstructs anti-B:tag from input ParticleLists for given B:sig |
| CMap2Vector | Helper class to make a vector of all possible combinations of int numbers contained in the input vectors (passed as values in a map) |
| CInclusiveDstarReconstructionModule | Inclusive D* reconstruction module |
| CKlongDecayReconstructorExpertModule | Reco missing module |
| CKlongMomentumCalculatorExpertModule | Reco missing module |
| CKlongMomentumUpdaterExpertModule | Calculate and update the two body B decay kinematics |
| CLowEnergyPi0IdentificationExpertModule | Calculation of low-energy pi0 identification value |
| CLowEnergyPi0VetoExpertModule | Calculation of low-energy pi0 veto value |
| CDecayTree | This is a helper class for the MCDecayFinderModule |
| CMCDecayFinderModule | Find decays in MCParticle list matching a given DecayString |
| CMCMatcherParticlesModule | MC matching module: module performs MC matching (sets the relation Particle -> MCParticle) for all particles and its (grand)^N-daughter particles in the user-specified ParticleList |
| CNeutralHadron4MomentumCalculatorModule | Calculates 4-momentum of a neutral hadron in a given decay chain e.g |
| CNeutralHadronMatcherModule | Module to geometrically match neutral hadrons (KL, neutrons) to ECL clusters |
| COnlyWriteOutParticleListsModule | Marks all objects in DataStore except those of type ParticleList as WrtieOut=False |
| CParticleCombinerModule | Particle combiner module |
| CParticleCombinerFromMCModule | Particle combiner module |
| CParticleCopierModule | Module for creating copies of Particles |
| CParticleExtractorFromROEModule | Extract particles from ROE and fill them in ParticleList |
| CParticleListManipulatorModule | Module for copying Particles (actually their indices) from two or more ParticleLists(s) to another ParticleList |
| CParticleLoaderModule | Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList |
| CParticleMassUpdaterModule | This module replaces the mass of the particles inside the given particleLists with the invariant mass of the particle corresponding to the given pdgCode |
| CParticleMCDecayStringModule | Adds the Monte Carlo decay string to a Particle |
| CParticleMomentumUpdaterModule | This module replaces the momentum of the Particle in the target particle list by p(beam) - p(selected daughters) |
| CParticlePrinterModule | Prints particle list to screen |
| CParticleSelectorModule | Loops over all Particles in the ParticleList and removes those Particles from the ParticleList that do not pass given selection criteria |
| CParticleStatsModule | This module summarises the ParticleLists in the event |
| CParticleVertexFitterModule | Vertex fitter module |
| CParticleWeightingModule | Module to append weights from the database into the extraInfo of Particles |
| CParticleWeightingLookUpCreatorModule | Module that creates LookUpTable and upload it to the DB |
| CPhotonEfficiencySystematicsModule | Adds Photon Detection Efficiency Data/MC ratios To Particle List |
| CPi0VetoEfficiencySystematicsModule | Adds Pi0Veto Efficiency Data/MC ratios To Particle List |
| CPIDCalibrationWeightCreatorModule | Module that creates WeightMatrix and uploads it to the DB |
| CPIDNeuralNetworkParametersCreatorModule | Module that creates PID neural network parameters and uploads them to the DB |
| CPostMergeUpdaterModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', several kinematic properties might need fix |
| CPrintMCParticlesModule | The PrintMCParticles module |
| CPseudoVertexFitterModule | Pseudo Vertex fitter module |
| CRemoveParticlesNotInListsModule | Removes all Particles that are not in a given list of ParticleLists (or daughters of those) |
| CRestOfEventBuilderModule | Creates for each Particle in given ParticleList an RestOfEvent (ROE) dataobject and makes basf2 relation between them |
| CRestOfEventInterpreterModule | Creates a mask (vector of boolean values) for tracks and clusters in RestOfEvent regarding their usage |
| CRestOfEventPrinterModule | Prints ROE information and masks to screen |
| CRestOfEventUpdaterModule | Updates an existing mask (map of boolean values) for tracks or eclClusters in RestOfEvent with an available property (e.g |
| CSelectDaughtersModule | Redefine (select) the daughters of a particle |
| CSignalSideParticleFilterModule | The module returns true if the current RestOfEvent object is related to any of the Particles in the input ParticleLists |
| CSignalSideParticleListCreatorModule | The module creates a ParticleList and fills it with one of the daughter Particles |
| CSignalSideVariablesToDaughterExtraInfoModule | The module writes properties (values of specified variables) of the particle related to the current ROE as an ExtraInfo to the single particle in the input ParticleList |
| CSignalSideVariablesToExtraInfoModule | The module writes property of single particle found in the input ParticleList as an ExtraInfo to the Particle related to the current ROE |
| CSkimFilterModule | This module filters events based on presence of candidates in a list of ParticleLists |
| CTagUniqueSignalModule | Loops through the particle list finds a unique signal candidate for each event |
| CTagVertexModule | Tag side Vertex Fitter module for modular analysis |
| CParticleAndWeight | This struct is used to store and sort the tag tracks |
| CTauDecayMarkerModule | Module to identify generated tau pair decays, using MCParticle information |
| CTauDecayModeModule | Module to classify tau decay events according to a mapping given by the user or with a default mapping based on the TauolaBelle2 decay list |
| CTrackFitResultEstimatorModule | Create a TrackFitResult from the momentum of a Particle and make a relation between them |
| CTrackingEfficiencyModule | This set of module is designed for tracking systematics studies |
| CTrackingMomentumModule | Tracking momentum systematics |
| CTrackIsoCalculatorModule | Calculate track isolation variables on the input ParticleList |
| CTreeFitterModule | Module to fit an entire decay tree |
| CUdstListFilterModule | Module to filter udst content based on a particle list |
| CV0DaughterMassUpdaterModule | This module replaces the mass of two daughters of the selected V0 particles inside the given particleLists with masses of given pdgCode |
| CVariablesToEventBasedTreeModule | Module to calculate variables specified by the user for a given ParticleList and save them into a TTree |
| CVariablesToEventExtraInfoModule | For each particle in the input list the selected variables are saved in an event-extra-info field with the given name, Can be used to save MC truth information, for example, in a ntuple of reconstructed particles |
| CVariablesToExtraInfoModule | For each particle in the input list the selected variables are saved in an extra-info field with the given name, Can be used when wanting to save variables before modifying them, e.g |
| CVariablesToHistogramModule | Module to calculate variables specified by the user for a given ParticleList and save them into an Histogram |
| CVariablesToNtupleModule | Module to calculate variables specified by the user for a given ParticleList and save them into a ROOT TTree |
| CVariableToReturnValueModule | Module to calculate variable specified by the user and set return value accordingly |
| CParticleIndexGenerator | ParticleIndexGenerator is a generator for all the combinations of the particle indices stored in the particle lists |
| CListIndexGenerator | ListIndexGenerator is a generator for all the combinations of the sublists (FlavorSpecificParticle = 0, SelfConjugatedParticle = 1) of a set of particle lists |
| CParticleGenerator | ParticleGenerator is a generator for all the particles combined from the given ParticleLists |
| CChargedParticleIdentificatorTest | Test the MVA-based charged PID |
| CeventShapeCoreAlgorithmTest | |
| CPIDPriorsTest | |
| CTrackIsoScoreCalculatorTest | Test the calculation of the track helix-based isolation score per particle |
| CAnalysisConfiguration | Singleton class keeping configurables of analysis components |
| CDecayForest | Contains several DecayTree objects, which belong all to the same candidate |
| CDecayNode | DecayNode describes the decay of a particle identified by its pdg code, into list of daughters |
| CDetSurfCylBoundaries | Simple class to encapsulate a detector surface's boundaries in cylindrical coordinates |
| CDetectorSurface | Detector surfaces information |
| CGenB0Tag | Class to determine generated decay mode of B0 and B0bar |
| CGenBplusTag | Class to determine generated decay modes of B+ and B- |
| CGenBsTag | Class to determine generated decay mode of Bs0 and Bs0bar |
| CGenDTag | Class to determine generated decay mode of D*, Ds, D0, D+, and their anti-particles |
| CGenTauTag | Class to determine generated decay mode of tau+ and tau- |
| CKlongCalculatorUtils | Utility class to calculate the Klong kinematics |
| CMCMatching | Functions to perform Monte Carlo matching for reconstructed Particles |
| CParticleSubset | Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists |
| CPCmsLabTransform | Class to hold Lorentz transformations from/to CMS and boost vector |
| CPIDCalibrationWeightUtil | Class to call calibration weight matrix |
| CPIDNeuralNetwork | Class to call PID neural network |
| CReferenceFrame | Abstract base class of all reference frames |
| CRestFrame | Rest frame of a particle |
| CLabFrame | Lab frame |
| CCMSFrame | CMS frame |
| CRotationFrame | Rotation frame around vector |
| CCMSRotationFrame | Stack frame for cms and Rotation frame |
| CUseReferenceFrame | A template class to apply the reference frame |
| CVariableFormulaConstructor | Struct to construct new variable function objects from a name or a double value or to apply operations on these variable function objects |
| CARICHCalibrationChecker | ARICH calibration checker |
| CARICHChannelMaskMaker | ARICH channel mask calibration algorithm |
| CARICHDatabaseImporter | ARICH database importer |
| CARICHAeroHit | Datastore class that holds information on track parameters at the entrance in aerogel |
| CARICHDigit | ARICHDigit class for storing photon hit information |
| CARICHHit | Datastore class that holds photon hits. Input to the reconstruction |
| CARICHInfo | Datastore class to keep ARICH event infomation e.g. trigger type |
| CARICHLikelihood | This is a class to store ARICH likelihoods in the datastore |
| CARICHPhoton | Struct for ARICH reconstructed photon (hit related to track) information |
| ►CARICHRawDigit | |
| ►CFEBDigit | |
| CChannelDigit | |
| CARICHSimHit | Class ARICHSimHit - Geant4 simulated hit for ARICH |
| CARICHThParam | ARICHThParam class for storing photon hit information |
| CARICHTrack | Datastore class that holds position and momentum information of tracks that hit ARICH |
| CARICHAerogelInfo | The Class for ARICH Aerogel Parameters |
| CARICHAerogelMap | Map of the Aerogel placement |
| CARICHAerogelRayleighScatteringFit | The Class for ARICH aerogel Rayleigh scattering fit parameters |
| 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 | Contains manufacturer data of one of the 4 photo sensors chips |
| CARICHBiasCablesMapping | The Class for ARICH mapping of bias cables to modules |
| CARICHBiasChannelsMapping | The Class for ARICH mapping of bias power supply channels to modules |
| CARICHBiasCrateCableMapping | The Class for ARICH bias voltages at gain 40 |
| CARICHBiasVoltages | The Class for ARICH bias voltages at gain 40 |
| CARICHCableInfo | List of Cables |
| CARICHChannelMapping | The Class for ARICH HAPD channel mapping |
| CARICHChannelMask | The Class for ARICH HAPD channel mask |
| CARICHComponentTest | Test of the ARICH component |
| CARICHCopperMapping | The Class for ARICH mapping of merger to copper boards |
| CARICHFEBoardInfo | Front End Electronics Boards |
| CARICHFebTest | The Class for ARICH Aerogel Parameters |
| CARICHFirmware | ARICH firmware |
| ►CARICHGeoAerogelPlane | Geometry parameters of HAPD |
| Clayer | Struct to hold aerogel layer parameters Only for averaged properties of the aerogel tiles/layers |
| Ctilestr | Struct to hold individual aerogel tile parameters layer : 0 - up layer : 1 - down |
| 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 |
| 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 |
| 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 |
| CARICHMagnetTest | Contains fractions of dead times measured in a magnet |
| 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 | The Class for ARICH Aerogel Parameters |
| CARICHPositionElement | Position element for ARICH |
| CARICHReconstructionPar | The Class for ARICH reconstruction parameters |
| CARICHSensorModuleInfo | Sensor Module Information |
| CARICHSensorModuleMap | Mapping of the Sensor Board Connections to the detector |
| CARICHSimulationPar | The Class for ARICH simulation parameters |
| CtessellatedSolidStr | Structure which holds apexes of the tessellation volumes |
| CARICHTracking | Beamtest ARICH Geometry Tracking Class |
| CARICHBtestGeometryPar | The Class for ARICH Beamtest Geometry Parameters |
| CARICHGeometryPar | The Class for ARICH Geometry Parameters |
| CarichBtestModule | The UserTutorial module |
| CARICHChannelMaskModule | Testing module for collection of calibration data |
| CARICHDigitizerModule | ARICH digitizer module |
| CARICHDQMModule | Make summary of data quality from reconstruction |
| CARICHFillHitsModule | Fill ARICHHit collection from ARICHDigits |
| CARICHMCParticlesModule | Module to match ARICH hits to MCParticles |
| CARICHNtupleModule | ARICH reconstruction efficiency test module |
| CARICHPackerModule | Raw data packer for ARICH |
| CARICHRateCalModule | Fill ARICHHit collection from ARICHDigits |
| CARICHRawUnpackerModule | Fill ARICHHit collection from ARICHDigits |
| CARICHReconstruction | Internal ARICH track reconstruction |
| CARICHReconstructorModule | ARICH subdetector main module |
| CARICHRelateModule | Creates relations between ARICHAeroHits and ExtHits |
| CarichToNtupleModule | This module extends existing variablesToNtuple to append detailed arich information to candidates in the analysis output ntuple |
| CARICHRawHeader | |
| CARICHUnpackerModule | Raw data unpacker for ARICH |
| CARICHAerogelHist | Base class for geometry parameters |
| 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 |
| CBelleTrkExtra | Class stores mdst_trk_fit information for each track |
| CB2BIIMCParticlesMonitorModule | Declaration of class B2BIIMCParticlesMonitor |
| CB2BIIConvertBeamParamsModule | Convert the IpProfile and Benergy to BeamParameters, BeamSpot, CollisionInvariantMass and CollisionBoostVector |
| CB2BIIConvertMdstModule | Module converts Belle MDST objects (Panther records) to Belle II MDST objects |
| CB2BIIFixMdstModule | Declaration of class B2BIIFixMdst |
| CMuidProb | Class computes probability density for Muid calculation |
| CB2BIIMdstInputModule | Module reads Belle MDST files and converts Belle_event record to Belle II EventMetaData StoreObjectPointer |
| Ccal_scale_error_func_set_t | Structure type cal_scale_error_func_set_t |
| CBelleMCOutputModule | KLM digitization module |
| ►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) |
| CBGOverlayExecutorModule | Overlay of measured background with simulated data (Digits or Clusters) |
| CBGOverlayInputModule | Beam BG data input, either in form of Digits or raw data |
| CAnalysisPhase1StudyModule | Study module for BEAST |
| CNtuplePhase1_v6Module | Read SKB PVs, simulated measurements of BEAST sensors, and write scaled simulated Ntuple in BEAST phase 1 data format |
| CReprocessorModule | Reprocessor Module |
| CBeamabortHit | ClassBeamabortHit - digitization simulated hit for the Beamabort detector |
| CBeamabortSimHit | ClassBeamabortSimHit - Geant4 simulated hit for the Beamabort crystal in beast |
| CBeamabortGeo | Geometry parameters of Beamabort |
| CBgoHit | ClassBgoHit - Geant4 ulated hit for the Bgo crystal in beast |
| CBgoSimHit | ClassBgoSimHit - Geant4 simulated hit for the Bgo crystal in beast |
| CCaveSimHit | ClassCaveSimHit - Geant4 simulated hit for the Cave detector |
| CClawHit | ClassClawHit - digitization simulated hit for the Claw detector |
| CClawSimHit | ClassClawSimHit - Geant4 simulated hit for the Claw crystal in beast |
| CClawsHit | ClassClawsHit - digitization simulated hit for the Claws detector |
| CCLAWSSimHit | Class CLAWSSimHit - Geant4 simulated hit for the CLAWS detector |
| 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 |
| CDosiHit | ClassDosiHit - Geant4 ulated hit for the Dosi crystal in beast |
| CDosiSimHit | ClassDosiSimHit - Geant4 simulated hit for the Dosi crystal in beast |
| CFANGSHit | ClassFANGSHit - digitization simulated hit for the FANGS detector |
| CFANGSSimHit | Class FANGSSimHit - Geant4 simulated hit for the FANGS detector |
| 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 |
| 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 |
| 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 |
| CPh1bpipeSimHit | ClassPh1bpipeSimHit - Geant4 simulated hit for the Ph1bpipe detector |
| CPh1sustrSimHit | ClassPh1sustrSimHit - Geant4 simulated hit for the Ph1sustr detector |
| CPindiodeHit | ClassPindiodeHit - digitization simulated hit for the Pindiode detector |
| CPindiodeSimHit | ClassPindiodeSimHit - Geant4 simulated hit for the Pindiode crystal in beast |
| CPlumeHit | ClassPlumeHit - digitization simulated hit for the Microtpc detector |
| CPlumeSimHit | Class PlumeSimHit - Geant4 simulated hit for the PLUME detector |
| CQcsmonitorHit | ClassQcsmonitorHit - digitization simulated hit for the Qcsmonitor detector |
| CQcsmonitorSimHit | ClassQcsmonitorSimHit - Geant4 simulated hit for the Qcsmonitor crystal in beast |
| CSrsensorSimHit | ClassSrsensorSimHit - Geant4 simulated hit for the Srsensor detector |
| CMergeableNamed | Abstract base class for objects that can be merged but also named |
| CRunRange | Mergeable object holding (unique) set of (exp,run) pairs |
| CXmlFile | DB object which stores whole xml |
| CTestCalibMean | Test DBObject |
| CTestCalibObject | Test DBObject |
| CTestBoundarySettingAlgorithm | Test class implementing calibration algorithm |
| CTestCalibrationAlgorithm | Test class implementing calibration algorithm |
| CTestDBAccessAlgorithm | Test class implementing calibration algorithm |
| CCaTestModule | Testing module for collection of calibration data |
| CTestCalibDBAccessModule | Returns the calibration result from SoftwareTriigerResult for skimming out calibration flagged events |
| CCalibObjManager | Manager class for collector registered data. Handles much of the TDirectory/TObject manipulation |
| ►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 |
| 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 |
| CDummyCollectorModule | Basically empty Collector, makes only a tiny amount of output data |
| CTriggerSkimModule | Returns the calibration result from SoftwareTriigerResult for skimming out calibration flagged events |
| CCDCDatabaseImporter | CDC database importer |
| CSliceFit | Class to do the slice fit |
| CCDCHit | Class containing the result of the unpacker in raw data and the result of the digitizer in simulation |
| 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 |
| CWireID | Class to identify a wire inside the CDC |
| CCDCADCDeltaPedestals | Database object for ADC pedestals |
| CCDCAlignment | CDC alignment constants |
| CCDCBadWires | Database object for bad wires |
| CCDCChannelMap | Database object of CDC channel map |
| CCDCCorrToThresholds | Database object for correcting a simple threshold model in MC |
| CasicChannel | Record to be used to store ASIC info |
| CadcChannelPair | Pair ADC, channel |
| CadcAsicTuple | Tuple to store ADC,Channel -> 8 asicChannels |
| Cadc_search | Functions to search in the sorted list of tuples |
| CCDCCrossTalkLibrary | Database object for ASIC crosstalk library |
| CCDCDisplacement | Database object for displacement of sense wire position |
| CCDCEDepToADCConversions | Database object for energy-deposit to ADC-count conversion |
| CCDCFEElectronics | Database object for Fron-endt electronics params |
| CCDCFEEParams | Database object for FEE params |
| 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 |
| CCDCLayerAlignment | CDC layers alignment constants |
| CCDClayerTimeCut | Database object for timing offset (t0) |
| CCDCMisalignment | CDC misalignment constants |
| CCDCPropSpeeds | Database object for signal propagation speed along the wire |
| CCDCSpaceResols | Database object for space resolutions |
| CCDCTimeWalks | Database object for time-walk |
| CCDCTimeZeros | Database object for timing offset (t0) |
| CCDCTriggerPlane | Database object for timing offset (t0) |
| CCDCWireHitRequirements | Database object containing cut values to filter CDCWireHits |
| CCDCXtRelations | Database object for xt-relations |
| CCDCCosmicSelectorModule | The Class for |
| CCDCCosmicSelectorAfterFullSimModule | The Class for |
| ►CCDCCrossTalkAdderModule | The Class for overlaying signal-induced asic cross-talk |
| CXTalkInfo | Structure for saving the x-talk information |
| ►CCDCDigitizerModule | The Class for Detailed Digitization of CDC |
| CSignalInfo | Structure for saving the signal information |
| CXTalkInfo | Structure for saving the x-talk information |
| CcdcDQM7Module | The module for Data Quality Monitor |
| CCDCDQMModule | Make summary of data quality from reconstruction |
| CScanCDCGeoModule | Test module to save CDC geometry information to ntuple file |
| CCDCInitialT0DeterminationModule | Determine crude t0 |
| CCDCJobCntlParModifierModule | The Class for Detailed Digitization of CDC |
| CCDCCosmicTrackMergerModule | Module use to select two cosmic tracks event and merger these two tracks become one |
| CEvtSocketSend | |
| CEvtSocketRecv | |
| CEvtSocketManager | |
| CREvtSocketRecv | |
| CREvtSocketSend | |
| CRSocketSend | |
| CRSocketRecv | |
| CSocketIO | |
| CSocketRecv | |
| CSocketSend | |
| CSocketManager | |
| CDAQPerfModule | A class definition of an input module for Sequential ROOT I/O |
| CRxSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CTxSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CSendHeader | |
| CSendTrailer | |
| CSndHdrTemp | |
| CDqmMasterCallback | |
| CDqmMemFile | |
| CDqmSharedMem | |
| CHistoManager | |
| CHistoRelay | |
| CHistoServer | |
| CDqmHistoManagerModule | Class definition of DqmHistoManager module |
| CMonitorDataModule | A class definition of an input module for Sequential ROOT I/O |
| CTrackAnaModule | A class definition of an input module for Sequential ROOT I/O |
| CERecoDistributor | |
| CERecoEventProcessor | |
| CERecoEventSampler | |
| CERecoMaster | |
| CERecoMasterCallback | |
| CERecoRunControlCallback | |
| CEventSampler | |
| CEventServer | |
| CEventServerCallback | |
| CDs2SampleModule | A class definition of an input module for Sequential ROOT I/O |
| CGetEventFromSocketModule | A class definition of an input module for Sequential ROOT I/O |
| CReceiveEventModule | A class definition of an input module for Sequential ROOT I/O |
| CZMQStandardApp | Generic base class for all standalone ZMQ applications |
| CZMQReadySender | App to only send a ready on every incoming message - behaves the same as the input of a worker (but without an output) |
| 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) |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CZMQDistributor | Standard distributor app: receive data via a raw connection (e.g |
| CZMQInputAdapter | |
| CZMQHistogramToFileServer | 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 |
| CZMQHistogramToRawServer | 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 |
| CZMQHistoServerToZMQOutput | Send the histograms as compressed byte stream via a ZMQConfirmedOutput connection after merging with all the properties of a normal confirmed output |
| CZMQHistoServerToRawOutput | Same as ZMQHistoServerToZMQOutput just send uncompressed to a raw output |
| CZMQHistogramOutput | Add the common functionality to the histogram output classes |
| CZMQROIOutput | Dedicated output to send ROI messages to the PXD ONSEN system |
| CZMQDataAndROIOutput | Helper connection hosting both a normal raw and a ROI output and sending to both at the same time |
| 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) |
| CHLTZMQ2DsModule | Input module in the ZMQ reconstruction path receiving events via ZMQ and deserializing the to the data store |
| CHLTZMQ2DsDirectModule | Special ZMQ2Ds module without the HLT-specific handling of initialization and begin/end run |
| CStorageZMQ2DsModule | Input module in the ZMQ reconstruction path receiving events via ZMQ and deserializing the to the data store |
| CHistogramMapping | Utility to store received histograms (hierarchical tree structures) from clients (as an event message), with a function to add multiple histogram trees together |
| CHLTEventProcessor | EventProcessor to be used on the HLT with all specialities of the HLT processing: |
| CHLTStreamHelper | Helper class for data store serialization |
| CStorageStreamHelper | Helper class for data store serialization |
| CElapsedTimeModule | A class definition of an input module for Sequential ROOT I/O |
| CCprErrorMessage | |
| 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 |
| CDeSerializerModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| 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 |
| CDesSerPrePCMainModule | 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 |
| CDummyDataSourceFileModule | A class definition of an input module for Sequential ROOT I/O |
| CGenRawSendModule | |
| CMonitorDataCOPPERModule | A class definition of an input module for Sequential ROOT I/O |
| CRoot2RawModule | A class definition of an input module for Sequential ROOT I/O |
| CSerializerModule | A class definition of an input module for Sequential ROOT I/O |
| CHLTFile | |
| CHLTMainLoop | |
| CHLTSocket | |
| CRawRevRb2Sock | |
| CRb2Sock | |
| CRevRb2Sock | |
| CRevSock2Rb | |
| CSock2Rb | |
| CCertifyParallelModule | 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 |
| CEvReductionModule | A class definition of an input module for Sequential ROOT I/O |
| CFastRbuf2DsModule | A class definition of an input module for Sequential ROOT I/O |
| CRaw2DsModule | A class definition of an input module for Sequential ROOT I/O |
| CRawInputModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| CRFCommand | |
| CRFConf_t | |
| CRFConf | |
| CRFDqmServer | |
| CRFEventProcessor | |
| CRFEventServer | |
| CRFFlowStat | |
| CRFLogManager | |
| CRFMaster | |
| CRFMasterCallback | |
| CRfNodeInfo | |
| CRFNodeManager | |
| CRFNSM_Status | |
| CRFNSM | |
| CRFOutputServer | |
| CRFProcessManager | |
| CRFRoiSender | |
| CRFRunControlCallback | |
| CRFServerBase | |
| CRfShm_Cell | |
| CRfShm_Data | |
| CRFSharedMem | |
| ►CRfUnitInfo | |
| CRfNodeInfo | |
| CSharedMem | |
| CRoiSenderCallback | |
| CAbstractDBObject | |
| CConfigFile | |
| CConnection | |
| CDate | |
| CEnum | |
| CERRORNo | |
| CException | |
| CIOException | |
| CReader | |
| CSerializable | |
| CStringUtil | |
| CTimeoutException | |
| CWriter | |
| CDAQLogDB | |
| CDAQLogMessage | |
| CDBHandlerException | |
| CDBInterface | |
| ►CDBObject | |
| CNameValue | |
| CDBObjectLoader | |
| CDBRecord | |
| CMonitorDB | |
| CRunNumber | |
| CRunNumberTable | |
| CAbstractNSMCallback | |
| CCallback | |
| CNSMCallback | |
| CNSMCommand | |
| CNSMCommunicator | |
| ►CNSMData | |
| CNameValue | |
| ►CNSMDataPaket | |
| CHeader | |
| ►CNSMDataStore | |
| CEntry | |
| CHeader | |
| CNSMHandlerException | |
| CNSMMessage | |
| CNSMNode | |
| CNSMNodeDaemon | |
| CNSMNotConnectedException | |
| CNSMState | |
| CNSMVar | |
| CNSMVHandler | |
| CNSMVHandlerInt | |
| CNSMVHandlerFloat | |
| CNSMVHandlerText | |
| CNSMVHandlerIntArray | |
| CNSMVHandlerFloatArray | |
| CNSMVHandlerRef | |
| CPostgreSQLInterface | |
| CFlowMonitor | |
| CIOInfo | |
| CLogListener | |
| CProcessController | |
| CProcessSubmitter | |
| CProcessListener | |
| ►Cro_summary | |
| Cevent_header | |
| Cevent_header | |
| ►Cronode_info | |
| Cio_info | |
| ►Cronode_status | |
| Cevent_header | |
| CRunInfoBuffer | |
| CRCCallback | |
| CRCCommand | |
| CRCConfig | |
| CRCHandlerException | |
| CRCHandlerFatalException | |
| CRCNode | |
| CRCNodeDaemon | |
| CRCState | |
| CRCConfigHandler | |
| CBuffer | |
| CBufferedReader | |
| CBufferedWriter | |
| CCommandLine | |
| CCond | |
| CDaemon | |
| CDynamicLoader | |
| CDynamicLoadException | |
| CExecutor | |
| CFifo | |
| CFile | |
| CFileDescriptor | |
| CFileReader | |
| CFileWriter | |
| CFork | |
| CInotifyEvent | |
| CInotify | |
| CGenericLockGuard | Lock Guard for a Mutex instance |
| CLogFile | |
| CMCond | |
| CMMutex | |
| CMutex | |
| CProcess | |
| CPThread | |
| CRWLock | |
| CSharedMemory | |
| CStreamSizeCounter | |
| CTCPServerSocket | |
| CTCPSocket | |
| CTime | |
| CUDPSocket | |
| CBinTrailer | |
| CBinHeader | |
| CBinData | |
| ►CEventBuffer | |
| CHeader | |
| ►CONSENBinData | |
| Csose_frame_t | |
| ►CSharedEventBuffer | |
| CHeader | |
| CDataStorePackage | |
| CDs2RawFileModule | A class definition of an input module for Sequential ROOT I/O |
| CPartialSeqRootReaderModule | A class definition of an input module for Sequential ROOT I/O |
| CSeqRootMergerModule | A class definition of an input module for Sequential ROOT I/O |
| 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 |
| CEvtBuffer | |
| CSender | |
| CBrowsableWrapper | A wrapper for browsable objects to enable automatic redrawing |
| CModuleParam | A single parameter of the module |
| ►CDisplayUI | Control TEve browser user interface |
| CParameter | Wraps a module parameter that can be toggled from the UI |
| 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 wether user wants it visible or not |
| CMCTrack | Hold MC tracks and associated visualisation objects |
| CHtmlClassInspector | Pass to TObject::ShowMembers() to get tabular view of object data |
| ►CInfoWidget | Text-based info viewer showing DataStore contents |
| CURI | Parsed URI |
| CSplitGLView | Responsible for arranging the GL viewers and providing related functionality |
| ►CVisualRepMap | Defines a bidirectional (many to many) mapping between TObjects in DataStore and their visual representation |
| CDataStoreEveElementMap | Hide implementation in private class |
| CAsyncDisplayModule | Wraps DisplayModule and starts it in a forked process |
| CDisplayModule | The event display module |
| CHistDelta | Class to keep track of delta histograms |
| CHistObject | Class to keep track of delta histograms |
| 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 |
| 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 |
| CDQMHistAnalysisECLModule | This module is for analysis of ECL DQM histograms |
| CDQMHistAnalysisECLConnectedRegionsModule | 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 |
| 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 |
| CDQMHistAnalysisExampleModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisExampleFlagsModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisHLTModule | Class for HLT-related histogram analysis |
| CDQMHistAnalysisHLTMonObjModule | Creates monitoring object for HLT |
| 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 |
| CDQMHistAnalysisIPModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisKLMModule | Analysis of KLM DQM histograms |
| CDQMHistAnalysisKLM2Module | Analysis of KLM DQM histograms |
| CDQMHistAnalysisMiraBelleModule | Make summary of data quality from reconstruction |
| 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 |
| 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 |
| ►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 |
| CDQMHistAnalysisSVDOnMiraBelleModule | Class derived from HistoModule, for SVD monitoring variables at MiraBelle |
| CDQMHistAnalysisTOPModule | Class for TOP histogram analysis |
| CDQMHistAnalysisTrackingERModule | Analysis of ER Tracking DQM plots |
| CDQMHistAnalysisTrackingHLTModule | Analysis of HLT Tracking DQM plots |
| CDQMHistAnalysisTRGModule | DQM Trigger Histogram code and example |
| CDQMHistAnalysisTRGECLModule | Module for DQM histogram of ECL trigger event timing |
| CDQMHistAnalysisTRGGDLModule | Make summary of data quality from reconstruction |
| 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 |
| CDQMHistOutputToEPICSModule | Write DQM Histogram Content to EPICS Arrays |
| ►CDQMHistSnapshotsModule | Class for generating snapshots for histograms |
| CSSNODE | The struct for the snapshots |
| CDQMHistAnalysisInputModule | Class definition for the output module of Sequential ROOT I/O |
| CDQMHistAnalysisModule | The base class for the histogram analysis module |
| CMonitoringObject | MonitoringObject is a basic object to hold data for the run-dependency monitoring Run summary TCanvases and monitoring variables |
| CDQMFileMetaData | Metadata information about a DQM file |
| CDAQMonitorModule | A module for producing general DAQ DQM histograms |
| CDelayDQMModule | Processing Delay DQM Module |
| CIPDQMModule | This Module, made for monitors the position and the size of the interaction point using mu+mu- events |
| 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 |
| CPhysicsObjectsMiraBelleHadronModule | DQM modules to monitor hadron related variables |
| CPhysicsObjectsMiraBelleModule | A module template |
| CV0ObjectsDQMModule | DQM modules to monitor V0 objects |
| CDQMCommonUtils | The class collects utility functions for creating DQM histograms: prepared for PXD, SVD, VXD and Track DQM histograms |
| CECLCalDigit | Class to store calibrated ECLDigits: ECLCalDigits |
| CECLCellIdMapping | Class to store mapping between cell id and store array positions |
| CECLCNNPid | Class to store ECL CNN PID value |
| CECLConnectedRegion | Class to store connected regions (CRs) |
| CECLDebugHit | Class to store the average of ECLSimHit on crystals for debug only input for digitization module (ECLDigitizer) |
| CECLDigit | Class to store ECL digitized hits (output of ECLDigi) relation to ECLHit filled in ecl/modules/eclDigitizer/src/ECLDigitizerModule.cc |
| CECLDsp | Class to store ECL ShaperDSP waveform ADC data |
| CECLDspWithExtraMCInfo | Class to store ECL ShaperDSP waveform ADC data and additional information for ML studies |
| CECLHit | Class to store simulated hits which equate to average of ECLSImHit on crystals input for digitization module (ECLDigitizer) |
| CECLHitAssignment | Example Detector |
| CECLLocalMaximum | Class to store local maxima (LM) |
| 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 |
| CECLShower | Class to store ECL Showers |
| CECLSimHit | ClassECLSimHit - Geant4 simulated hit for the ECL |
| 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 |
| CECLWaveforms | Class to store ECL waveforms for entire calorimeter |
| CPackedAutoCovariance | Packed covariance matrix |
| CECLAutoCovariance | Covariance matrices for offline ECL waveform fit |
| CECLBeamBackgroundStudy | Flag for beam background study |
| CECLChannelMap | DB object to store correspondence table of type (Crate id, ShaperDSP id, Channel id) <-> (ECL CellID) |
| 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 |
| 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 |
| CECLCrystalCalib | General DB object to store one calibration number per ECL crystal |
| CECLCrystalLocalRunCalib | ECLCrystalLocalRunCalib is designed to store results of the ECL local run calibration to database |
| CECLCrystalsShapeAndPosition | Crystal shapes and positions |
| CECLDatabaseImporter | ECL database importer |
| CECLDigitEnergyConstants | Energy calibration constants per digit |
| 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 |
| CECLDspData | This object contains ECL DSP coefs – electromagnetic calorimeter digital signal processing coefficients |
| CECLHadronComponentEmissionFunction | Hadron Component Emission Function for hadron pulse shape simulations |
| CECLLeakageCorrections | DB object to store leakage corrections, including nCrys dependence |
| CECLLocalRunCalibRef | ECLLocalRunCalibRef is designed to store reference marks to database for ECL local run calibration |
| 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 |
| CECLReferenceCrystalPerCrateCalib | General DB object to store one reference crystal per per ECL crate for calibration purposes |
| CECLShowerCorrectorLeakageCorrection | Class to hold the information for the ECL shower leakage corrections |
| CECLShowerEnergyCorrectionTemporary | Class to hold the information for the ECL shower energy corrections This is a temperary class as there is no information about phi dependence |
| CECLShowerShapeSecondMomentCorrection | Corrections to the second moment shower shape |
| CECLTrackClusterMatchingParameterizations | Class to hold the parameterizations of the RMS for the difference in polar and azimuthal angle between tracks and ECL clusters |
| CECLTrackClusterMatchingThresholds | Class to hold the matching thresholds for the track-ECLCluster matching |
| CECLWaveformData | ECLWaveformData - container for inverse covariant matrix and shape parameters for time and amplitude fit of ecl crystal waveform |
| CECLWFAlgoParams | Container for constant parameters used in waveform fits |
| CECLNoiseData | Container for constant matrix used to generate electronic noise |
| CECLLookupTable | Class for a lookup table |
| 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 |
| CECLCrystalData | Class for obtaining crystal details for a given crystal cell An evolved look-up table |
| 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 |
| CECLChargedPIDModule | The module implements charged particle identification using ECL-related observables |
| 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) |
| CECLChargedPIDMVAModule | This module implements charged particle identification using ECL-related observables via a multiclass MVA |
| 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 |
| CeclCosmicECollectorModule | Class eclCosmicECollectorModule |
| CECLCovarianceMatrixModule | Class to perform the shower correction |
| CECLCovarianceMatrixPureCsIModule | The very same module but for PureCsI |
| CECLCRFinderModule | Class to find connected regions |
| CECLCRFinderPureCsIModule | Class to find connected regions, pureCsI version |
| CEclCovMatrixNtupleModule | Module to write ECL waveform and fitted time and amplitude information in a root ntuple |
| CECLDataAnalysisModule | The ECL Data Analysis Module |
| CECLDigiStudyModule | A module to analyse digit level information |
| CECLDigitCalibratorModule | Class to find calibrate digits and convert waveform fit information to physics quantities |
| CECLDigitCalibratorPureCsIModule | Class derived from ECLDigitCalibratorModule, only difference are the names |
| ►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 |
| CEclData | This class contains data for ECLSimHit's and provides several relevant conversion functions for better event display |
| CEclDisplayAsyncModule | Displays energy distribution in ECL |
| CEclDisplayModule | Displays energy distribution in ECL |
| CEclFrame | Root TGMainFrame that contains multiple widgets that display the ECLSimHit's w.r.t |
| 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 |
| CMultilineWidget | Widget which contains the dynamic amount of TGLabel objects |
| CECLDQMModule | This module is created to monitor ECL Data Quality |
| 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 |
| CECLDQMOutOfTimeDigitsModule | This module produces DQM histograms to monitor the distribution of out-of-time ECLCalDigits |
| 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 |
| CECLEventT0Module | EventT0 from ECL |
| CECLFillCellIdMappingModule | Fills a dataobject that provides maping between cell id and ECLCalDigit store array |
| CECLFinalizerModule | Class to perform the shower correction |
| CECLFinalizerPureCsIModule | The very same module but for PureCsI |
| CeclGammaGammaECollectorModule | Calibration collector module that uses e+e- --> gamma gamma to do ECL single crystal energy calibration |
| CeclHadronTimeCalibrationValidationCollectorModule | This module generates 'TimevsCrys' histogram to later (in eclBhabhaTAlgorithm) find time offset from bhabha events |
| CECLHitDebugModule | Class to represent the hit of one cell |
| CeclLeakageCollectorModule | Store information needed to calculate ECL energy leakage corrections |
| 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 |
| CECLLocalRunCalibUnit | ECLLocalRunCalibUnit is the class designed for the control of mean value and the standard deviation accumulators |
| CStoreArray | Accessor to arrays stored in the data store |
| 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 |
| 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 |
| CECLShowerCalibratorModule | Class to perform the shower correction |
| CECLShowerCalibratorPureCsIModule | The very same module but for PureCsI |
| CECLShowerCorrectorModule | Class to perform the shower correction |
| CECLShowerCorrectorPureCsIModule | The very same module but for PureCsI |
| ►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 |
| 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 |
| CBestMatchContainer | Multiple entries can be added, but only the one will be kept, which has the best quality estimator |
| CBremFindingMatchCompute | Module to compute if an extrapolation to the ECL matches the position of an secondary ECLCLuster to find bremsstrahlung clusters |
| 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 |
| 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 |
| CECLTRGInformationModule | Module to get ECL TRG energy information |
| 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 |
| CCovariancePacked | Struct to keep upper triangle of the covariance matrix |
| CSignalInterpolation2 | Interpolation of signal shape using function values and the first derivative |
| CECLWaveformFitModule | Module performs offline fit for saved ECL waveforms |
| CeclWaveformTemplateCalibrationC1CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CeclWaveformTemplateCalibrationC2CollectorModule | Calibration collector module that uses delayed Bhabha to compute coveriance matrix |
| CMCMatcherECLClustersModule | Class to represent the hit of one cell |
| CMCMatcherECLClustersPureCsIModule | Same module but for pure CsI |
| CECLCalDigitTest | Set up a few arrays and objects in the datastore |
| CECLChargedPIDTest | Test the ECL charged PID |
| CECLDigitTest | Set up a few arrays and objects in the datastore |
| CECLHitTest | Set up a few arrays and objects in the datastore |
| CECLHitAssignmentTest | Set up a few arrays and objects in the datastore |
| CECLShowerTest | Set up a few arrays and objects in the datastore |
| CECLSimHitTest | Set up a few arrays and objects in the datastore |
| CECLDBTool | The ECLDBTool class is designed to read / write object from / to database |
| CCreateConsistencyInfoModule | If you want to merge two events with the 'MergeDataStoreModule', it might be necessary to make sure that this combination of events make sense |
| CDataFlowVisualization | Class to visualize data flow between modules |
| CEnvironment | This class stores all environment information required to run the framework, such as module or data filepaths, number of processes to be used in parallel processing etc |
| ►CEventProcessor | Core event processing loop |
| CStoppedBySignalException | Exception thrown when execution is stopped by a signal |
| CFileCatalog | This class provides an interface to the file (metadata) catalog |
| CHistoModule | HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions to be managed by HistoManager |
| CInputController | A static class to control supported input modules |
| CMemoryPool | Class to provide a constant access time memory pool for one kind of objects |
| CMergeDataStoreModule | Internal module used by Path.add_independent_merge_path() |
| CMetadataService | This class provides a service for writing metadata about the basf2 execution and about output files to a json file |
| CModule | Base class for Modules |
| CModuleProxyBase | The base module proxy class is used to create new instances of a module |
| CModuleCondition | Wraps a condition set on a Module instance |
| CModuleManager | The ModuleManager Class |
| CModuleParamBase | Base class for module parameter |
| CModuleParamInfoPython | Class to store basic information about a parameter |
| CModuleParamList | The Module parameter list class |
| CModuleStatistics | Keep track of time and memory consumption during processing |
| CMRUCache | Class implementing a generic Most Recently Used cache |
| CPath | Implements a path consisting of Module and/or Path objects |
| CPathElement | Base for classes that can be elements of a Path |
| CPathIterator | Iterator over a Path (returning Module pointers) |
| CProcessStatistics | Class to collect call statistics for all modules |
| CPyModule | Python wrapper for Belle2::Module |
| CRandomGenerator | Fast Random number Generator using on xorshift1024* [arXiv:1402.6246] |
| CRandomNumbers | The class for handling the random number generation |
| CSteerRootInputModule | Internal module used by Path.add_independent_merge_path() |
| CSubEventModule | Framework-internal module that implements the functionality of Path::forEach() as well as Path::doWhile() |
| CSwitchDataStoreModule | Internal module used by Path.add_independent_path() |
| ►CDatabase | Singleton base class for the low-level interface to the database |
| CDBImportQuery | Struct for bulk write queries |
| CDBAccessorBase | Base class for DBObjPtr and DBArray for easier common treatment |
| CDBArray | Class for accessing arrays of objects in the database |
| COptionalDBArray | Optional DBArray: This class behaves the same as the DBArray except that it will not raise errors when an object could not be found in the database |
| CDBImportArray | Class for importing array of objects to the database |
| CDBImportBase | Base class for importing objects to the database |
| CDBImportObjPtr | Class for importing a single object to the database |
| CDBObjPtr | Class for accessing objects in the database |
| COptionalDBObjPtr | Optional DBObjPtr: This class behaves the same as the DBObjPtr except that it will not raise errors when an object could not be found in the database |
| CDBPointer | Class for pointing to an element in an array stored in the database |
| CDBStore | Singleton class to cache database objects |
| CDBStoreEntry | Class to hold one entry from the ConditionsDB in the DBStore |
| CEventDependency | Class for handling changing conditions as a function of event number |
| CIntervalOfValidity | A class that describes the interval of experiments/runs for which an object in the database is valid |
| CIntraRunDependency | Base class for handling changing conditions during a run |
| CPayloadFile | A wrapper class for payload files used by the Database and DBStore classes |
| CDBObjPtr< PayloadFile > | Specialization of DBObjPtr in case of PayloadFiles |
| ►CBackgroundInfo | This class stores the information about what background was mixed or overlayed |
| CBackgroundDescr | Structure for background description |
| CBackgroundMetaData | Metadata information about the beam background file |
| CBinnedEventT0 | Database object for storing a binned EventT0 coming from the trigger |
| CDigitBase | A common base for subdetector Digits |
| ►CDisplayData | Add custom information to the display |
| CArrow | Stores data associated with an arrow |
| CEventExtraInfo | Class to stores ExtraInfo of the whole event |
| CEventMetaData | Store event, run, and experiment numbers |
| ►CEventT0 | Storage element for the eventwise T0 estimation |
| CEventT0Component | Structure for storing the extracted event t0s together with its detector and its uncertainty |
| CFileMetaData | Metadata information about a file |
| CHelix | This class represents an ideal helix in perigee parameterization |
| CMCInitialParticles | This class contains the initial state for the given event |
| CMergedEventConsistency | Mark if we want to merge the DataStore of a combination of events or not |
| CProfileInfo | Store execution time and memory usage |
| CRelationContainer | Class to store relations between StoreArrays in the DataStore |
| CRelationElement | Class to store a single element of a relation |
| CTestChunkData | Storable object which can be filled with random chunk data of a certain size |
| CUncertainHelix | This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters |
| CRelationVector | Class for type safe access to objects that are referred to in relations |
| ►CDataStore | In the store you can park objects that have to be accessed by various modules |
| CSwitchableDataStoreContents | Encapsulates DataStoreContents, but allows transparently switching between different versions ('DataStore IDs') |
| ►CDependencyMap | Collect information about the dependencies between modules |
| CModuleInfo | Stores information on inputs/outputs of a module, as obtained by requireInput()/optionalInput()/registerEntry(); |
| ►CRelationArray | Low-level class to create/modify relations between StoreArrays |
| CIdentity | Struct for identity transformation on indices |
| CReplaceMap | Struct to replace indices based on a map-like container |
| CReplaceVec | Struct to replace indices based on a sequential container |
| CRelationEntry | Struct for relations |
| CRelationIndex | Provides access to fast ( O(log n) ) bi-directional lookups on a specified relation |
| CRelationIndexBase | Baseclass for all RelationIndexContainers |
| ►CRelationIndexContainer | Class to store a bidirectional index between two StoreArrays |
| CElement | Element type for the index |
| CRelationIndexManager | Manager to keep a cache of existing RelationIndexContainers |
| CRelationsInterface | Defines interface for accessing relations of objects in StoreArray |
| CRelationVectorBase | Base class for RelationVector<T> |
| CSelectSubsetBase | Type-independent implementation details of SelectSubset |
| CSelectSubset | Class to create a subset of a given StoreArray together with the relations with other StoreArrays |
| CStoreAccessorBase | Base class for StoreObjPtr and StoreArray for easier common treatment |
| CStoreEntry | Wraps a stored array/object, stored under unique (name, durability) key |
| CBeamParameters | This class contains the nominal beam parameters and the parameters used for smearing of the primary vertex and the beam energy and momentum |
| CBunchStructure | Class to store the fill pattern of colliding bunches |
| CHardwareClockSettings | Database object containing the nominal accelerator RF value and the prescales to derive the clock frequencies of the sub-detectors |
| CMagneticField | Magnetic field map |
| CMagneticFieldComponent | Abstract base class for BField components |
| CMagneticFieldComponentConstant | Describe one component of the Geometry |
| CRunInfo | Database object for Run Information |
| ►CConst | This class provides a set of constants for the framework |
| CChargedStable | Provides a type-safe way to pass members of the chargedStableSet set |
| CCluster | Provides a type-safe way to pass members of the clusterSet set |
| CClusterDetectors | A class that defines the valid set of Cluster detectors |
| ►CDetectorSet | For sets of detector IDs in the form of EDetector values |
| CIterator | Iterator |
| CParticleSet | A set of ParticleType objects, with defined order |
| CParticleType | For identifying different particle types |
| CPIDDetectors | A class that defines the valid set of PID detectors |
| CRestrictedDetectorSet | A class for sets of detector IDs whose content is limited to restricted set of valid detector IDs |
| CTrackingDetectors | A class that defines the valid set of tracking detectors |
| CVXDDetectors | A class that defines the valid set of VXD detectors |
| ►CGearbox | Singleton class responsible for loading detector parameters from an XML file |
| CPathOverride | Struct to override a path in the XML file with a custom value |
| CPathValue | Struct for caching results from the xml file |
| CInputHandlerFactory | Helper class to easily register new input handlers |
| CGearDir | GearDir is the basic class used for accessing the parameter store |
| CUnit | The Unit class |
| CB2Vector3 | A fast and root compatible alternative to TVector3 |
| CBFieldManager | Bfield manager to obtain the magnetic field at any point |
| CLogConfig | The LogConfig class |
| CLogConnectionBase | Abstract base class for the different types of log connections |
| CLogConnectionConsole | Implements a log connection to an IO Stream |
| CLogConnectionFilter | Implements a log connection that filters repeated messages |
| CLogConnectionJSON | Implements a log connection to stdout but with messages formatted as json objects to allow easy parsing by other tools, say jupyter notebooks |
| CLogConnectionTxtFile | Implements a log connection to a text file |
| CLogConnectionUDP | Log Connection to send the log message as JSON to a UDP server |
| ►CLogMessage | The LogMessage class |
| CTextHasher | Helper struct to hash and compare messages only by log level and message content |
| CLogMethod | The LogMethod class |
| CLogSystem | Class for logging debug, info and error messages |
| CEventErrorFlagModule | Module to check or add error flags of the EventMetaData |
| CEventInfoPrinterModule | The event meta data info module |
| CEventInfoSetterModule | Module to set event, run, experiment numbers |
| CEventLimiterModule | The EventLimiter module |
| CInteractiveModule | Start an interactive python shell in each call of event() |
| CIoVDependentConditionModule | Module which sets its return value based on the fact, if the event is in the given run/exp interval or not |
| CPrescaleModule | The Prescale module |
| CPrintBeamParametersModule | Print the BeamParameters everytime they change |
| CPrintCollectionsModule | Prints the contents of DataStore in each event, listing all objects and arrays (including size) |
| CProgressBarModule | Display a progress bar and an estimate of remaining time when number of events is known (e.g |
| CProgressModule | Periodically writes the number of processed events/runs to the logging system to give a progress indication |
| CPruneDataStoreModule | Clears the content of the DataStore while it keeps entries matching the regex expression in the matchEntries option |
| CRandomBarrierModule | Sets gRandom to an independent generator for the following modules |
| CTheKillerModule | This Modules kills basf2 as horribly as possible (or selected) |
| CGearboxModule | The Gearbox module |
| CHistoManagerModule | Class definition of HistoManager module |
| ►CProfileModule | A module that measures the execution time and memory usage per event |
| CMemTime | An internal struct to store pairs of memory usage and time |
| CStatisticsSummaryModule | A module that displays the sum of multiple modules in the module statistics |
| ►CRootInputModule | Module to read TTree data from file into the data store |
| CReadStats | For collecting statistics over multiple files |
| CRootOutputModule | Write objects from DataStore into a ROOT file |
| CSeqRootInputModule | Module to read files produced by SeqRootOutputModule |
| CSeqRootOutputModule | Output module for sequential ROOT I/O |
| CEvtGenDatabasePDG | Replacement for TDatabasePDG that is filled from EvtGen's evt.pdl |
| CEvtGenParticlePDG | Helper class for setting additional TParticlePDG members and storing the ones it doesn't have yet |
| CAsyncWrapper | Wraps a given Module to execute it asynchronously |
| CDataStoreStreamer | Stream/restore DataStore objects to/from EvtMessage |
| CEvtHeader | Header structure of streamed object list |
| CEvtMessage | Class to manage streamed object |
| CGlobalProcHandler | A class to manage processes for parallel processing |
| CMapMergeable | Wrap an STL map to make it mergeable |
| CMergeable | Abstract base class for objects that can be merged |
| CCharBuffer | Dynamic character buffer that knows its size |
| CInMessage | Reusable Message class derived from TMessage (for reading only) |
| CMsgHandler | A class to encode/decode an EvtMessage |
| CPathUtils | Helper utils for path arithmetics needed in the pEventProcessor |
| CpEventProcessor | This class provides the core event processing loop for parallel processing |
| CProcessMonitor | Class to monitor all started framework processes (input, workers, output), kill them if requested and handle the signals from the OS |
| CProcHandler | A class to manage processes for parallel processing |
| CRbTupleManager | Class to manage histograms defined in registered modules |
| CRingBufInfo | Internal metadata structure for RingBuffer |
| CRingBuffer | Class to manage a Ring Buffer placed in an IPC shared memory |
| CRootMergeable | Wrap a root histogram or TNtuple to make it mergeable |
| CRxModule | Module to decode data store contents from RingBuffer |
| CSemaphoreLocker | Handles creation, locking and unlocking of System V semaphores |
| CSeqFile | A class to manage I/O for a chain of blocked files |
| CSetMergeable | Wrap an STL set to make it mergeable |
| CTxModule | Module for encoding data store contents into a RingBuffer |
| CZMQEventProcessor | This class provides the core event processing loop for parallel processing with ZMQ |
| CZMQConfirmedInput | Input part of a confirmed connection |
| CZMQConfirmedOutput | Output part of a confirmed connection |
| CZMQConnection | Base class for every connection with virtual functions to be implemented: |
| CZMQConnectionOverSocket | Specialized connection over a ZMQ socket |
| CZMQLoadBalancedInput | Input part of a load-balanced connection |
| CZMQLoadBalancedOutput | Output part of a load-balanced connection |
| CZMQNullConnection | Connection doing just nothing: without the capability to pull, send or receive. Useful for template interfaces |
| CZMQRawInput | Input connection allowing to speak with non-zmq sockets via a ZMQ_STREAM socket |
| CZMQRawOutput | Output connection to speak to non-zmq sockets via a ZMQ_STREAM socket |
| CZMQSimpleConnection | Connection type to be used for answering simple requests, e.g |
| CZMQIdMessage | A message with the socket ID. Needed in input<->worker communication |
| CZMQMessageFactory | Helper class for creating new ID/No-ID messages |
| CZMQMessageHelper | Internal helper for creating ZMQ messages (should not be used otherwise) |
| CZMQModuleMessage | A general message with as many parts as given as template argument |
| CZMQNoIdMessage | A message without an associated socket ID. Is used in most cases |
| CProcessedEventBackup | Storage item for the event backup storing the event message, the time stamp and the event meta data |
| CProcessedEventsBackupList | List-like structure for storing and retaining event backups |
| CZMQRxOutputModule | Module connecting the worker path with the output path on the output side |
| CZMQRxWorkerModule | Module connecting the input path with the worker path on the worker side |
| CZMQTxInputModule | Module connecting the input path with the worker path on the input side |
| CZMQTxWorkerModule | Module connecting the worker path with the output path on the worker side |
| CZMQClient | A helper class for communicating over ZMQ. Includes a multicast and (if needed) also a data socket |
| CEventMetaDataSerialization | Helper class for (de)serializing the event meta data used for the event backup transferral |
| CStreamHelper | Helper class for data store serialization |
| CZMQAddressUtils | Summary of some address helpers |
| ►CZMQLogger | Base class for the ZMQ connection to help monitor and log certain values |
| CDecrementor | Visitor Helper for decrementing a numerical value |
| CIncrementor | Visitor Helper for incrementing a numerical value |
| CtoJSON | Visitor Helper for converting a variant value into a JSON string |
| CZMQParent | A helper class for creating ZMQ sockets keeping track of the ZMQ context and terminating it if needed |
| CFramework | This class combines all subsystems of the framework, and exports the main interface to Python |
| CLogPythonInterface | Thin wrapper to expose a usable interface to the logging framework in python |
| CProcessStatisticsPython | Python interface for ProcessStatistics |
| CPyDBArray | Class to access a DB Array from Python |
| CPyDBObj | Class to access a DBObjPtr from Python |
| CPyStoreArray | A (simplified) python wrapper for StoreArray |
| CPyStoreObj | (simplified) python wrapper for StoreObjPtr |
| CAbstractBooleanNode | A parsed cut-string naturally has a tree shape which incorporates the infomation of operator precedence and evaluation order of the statements |
| CAbstractExpressionNode | AbstractExpressionNode Superclass for all nodes which host expressions |
| CBaseAngle | Class to compare if two angles are compatible withing a given error range |
| CThetaAngle | |
| CPhiAngle | |
| CObjArrayIterator | Optimizes class to iterate over TObjArray and classes inheriting from it |
| CArrayIterator | Generic iterator class for arrays, allowing use of STL algorithms, range-based for etc |
| CCalcMeanCov | Class to calculate mean and and covariance between a number of parameters on running data without storing the actual values, also for weighted entries |
| CConditionalGaussGenerator | Class implementing n-dimensional random number generator from Gaussian distribution where the first component of the vector is generated first (using some external source) and the remaining components are generated based on the value of the first component |
| CVisitor | This is a class template which takes a template class operation as template argument |
| CEqualVisitor | Seperate Visitor struct for equal_to comparison of variant<double, int bool> |
| CUnaryBooleanNode | Nodeclass with a single AbstractBooleanNode as child |
| CBinaryBooleanNode | Nodeclass with two AbstractBooleanNode as children and a Boolean Operator (AND, OR) Check() method evaluates the child nodes and returns the result of the boolean operation |
| CUnaryRelationalNode | Nodeclass with a single AbstractExpressioNode as child |
| CBinaryRelationalNode | BooleanNode which has two AbstractExpressionNodes nodes and a ComparisonOperator |
| CTernaryRelationalNode | BooleanNode which has three AbstractExpressionNodes nodes and two ComparisonOperator |
| CUnaryExpressionNode | UnaryExpressionNode Node class with a single expression node as child |
| CBinaryExpressionNode | BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation |
| CDataNode | Template class for storing the Constants (int, double, bool) of the Cutstring |
| CIdentifierNode | Class which stores the name of a variable |
| CFunctionNode | FunctionNode Node class for handling MetaVariables in cuts |
| CEnvironmentVariables | Utility functions related to environment variables |
| ►CFileSystem | Utility functions related to filename validation and filesystem access |
| CLock | Helper class for locking a file |
| CTemporaryFile | Helper file to create a temporary file and ensure deletion if object goes out of scope |
| CFormulaParserBase | Base class with the non-templated part of the formula parser |
| CFormulaParser | FormulaParser to parse a text formula like "a + b * c ^ d" where the separate parts can be either variables (with and without arguments) or numbers |
| CStringFormulaConstructor | Example struct to be used with the FormulaParser to create a string representation of the formula, mainly for testing and debugging |
| CGeneralCut | This class implements a common way to implement cut/selection functionality for arbitrary objects |
| CKeyValuePrinter | Create human-readable or JSON output for key value pairs |
| CMakeROOTCompatible | Helper class for converting strings into a ROOT-friendly format (e.g |
| CMultivariateNormalGenerator | Class to generate normal distributed, correlated random numbers given the mean values and the covariance matrix of all dimensions |
| CNodeFactory | Wrapper class for static node compile functions |
| CBoostPythonModuleProxy | Proxy class to register python modules (the things you can 'import') |
| CRootFileCreationManager | This single instance class takes track of all open ROOT files open in "create" mode, usually meant for all the ntuple output modules |
| CScopeGuard | Simple ScopeGuard to execute a function at the end of the object lifetime |
| CTRandomWrapper | Wrap TRandom to be useable as a uniform random number generator with STL algorithms like std::shuffle |
| CSHA3Hash | Simple interface to calculate SHA3 hash sum (FIPS 202 draft) with fixed size from given data inputs |
| CShakeHash | Simple interface to calculate SHAKE256 hash sum (FIPS 202 draft) with variable size from given data inputs |
| CAAFHInterface | Class to inferface AAFH/DIAG36 Generator written in Fortran |
| CBabayagaNLO | C++ Interface for the Fortran Bhabha and exclusive two photon generator BABAYAGA.NLO |
| CBBBrem | Generator for low scattering angle radiative Bhabha events (Beam-Beam Bremsstrahlung) |
| CBHWide | C++ Interface for the Fortran Bhabha scattering generator BHWide |
| ►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 |
| CCRY | C++ Interface for the generator CRY |
| CEvtBSemiTauonicDecayRateCalculator | Class to calculate the differential decay rate, R(D), R(D*), polarizations of tau and D* using BSTD model based on [M |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CEvtPhspCP | Register Decay model EvtPhspCP |
| CHepevtReader | Class to read Hepevt files and store the content in a MCParticle graph |
| CHepMCReader | Class to read HepMC files and store the content in a MCParticle graph |
| CKKGenInterface | Interface class for using the KKMC generator |
| CKoralW | C++ interface for the FORTRAN 4-fermion final state generator KoralW |
| CLHEReader | Class to read LHE files and store the content in a MCParticle graph |
| CAafhInputModule | AAFH Generator to generate 2-fermion events like e+e- -> e+e-e+e- |
| CBabayagaNLOInputModule | The Babayaga.NLO Generator module |
| CBBBremInputModule | The BBBrem Generator module |
| CBHWideInputModule | The BHWide Generator module.vectorToPair |
| CCRYInputModule | The CRY Generator module |
| CEvtGenDecayModule | This module decays unstable particles using EvtGen |
| CEvtGenInputModule | The EvtGenInput module |
| CFragmentationRndm | Minimal class for external random generator to be used in PYTHIA |
| CFragmentationModule | The Fragmentation module |
| CHepMCInputModule | The HepMCInput module |
| CHepMCOutputModule | The HepMCOutput module |
| CBeamParametersModule | Setting of beam parameters |
| CBoostMCParticlesModule | Module for boosting the MCParticles from CM to LAB frame |
| CCosmicsModule | The Cosmics module Generates tracks with the cosmics generator and store them into the MCParticle class |
| 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 |
| CGeneratedVertexDisplacerModule | "Takes a list of PDG values and lifetime paramters 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 |
| CHepevtInputModule | The HepevtInput module |
| CHepevtOutputModule | The HepevtOutput module |
| CInclusiveParticleCheckerModule | Check for the existence of an inclusive particle in the list of generated particles |
| CLHEInputModule | The LHEInput module |
| COverrideGenerationFlagsModule | Ovverride generation flags |
| CParticleGunModule | The ParticleGun module |
| CPrintTauTauMCParticlesModule | The PrintTauTauMCParticles module |
| CRemoveMCParticlesModule | The RemoveMCParticles module |
| CSADInputModule | The SAD Input module |
| CSmearPrimaryVertexModule | This module smears the primary vertex (the interaction point) according to the values stored in BeamParameters |
| CTouschekTURTLEInputModule | The TouschekTURTLE Input module |
| CKKGenInputModule | The KKGenInput module |
| CKoralWInputModule | The KoralW Generator module |
| CPairGenModule | The PairGen module |
| CPhokharaInputModule | The Phokhara Generator module.vectorToPair |
| CTeeggInputModule | The TEEGG Generator module.vectorToPair |
| CTrepsInputModule | Input from TREPS generator for ee->eeff |
| ►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 |
| CPhokhara | C++ Interface for the Fortran generator PHOKHARA |
| CSADMetaHit | ClassSADMetaHit - digitization simulated metahit for the SAD detector |
| ►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 |
| CTeegg | C++ Interface for the Fortran generator TEEGG |
| CEvtBCLFFTest | The fixture for testing the EvtBCLFF |
| CParticleGunTest | The fixture for testing the Particlegun |
| CTouschekReaderTURTLE | Class to read Touschek files and store their content in a MCParticle graph |
| 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 |
| CGeneralVector | 3-vector with members of arbitrary type, especially members can be dual numbers |
| CInitialParticleGeneration | Generate Collision |
| CBFieldComponent3d | The BFieldComponent3d class |
| CBFieldComponentAbs | The BFieldComponentAbs class |
| CBFieldComponentBeamline | The BFieldComponentBeamline class |
| CBFieldComponentConstant | The BFieldComponentConstant class |
| ►CBFieldComponentKlm1 | The Bfieldcomponentklm1 class |
| CBFieldPoint | Trivial struct representing rz coordinate |
| ►CBFieldComponentQuad | The BFieldComponentQuad class |
| CApertPoint | Aperture data structure |
| Cirange_t | Start and stop indicies to narrow search in array |
| CParamPoint3 | Quadrupole lense data structure |
| Crange_t | Range data structure |
| ►CBFieldComponentRadial | The BFieldComponentRadial class |
| CBFieldPoint | Magnetic field data structure |
| CBFieldFrameworkInterface | Simple BFieldComponent to just wrap the existing BFieldMap with the new BFieldManager |
| CBFieldMap | This class represents the magnetic field of the Belle II detector |
| CGeoMagneticField | The GeoMagneticField class |
| Ctriangle_t | Triangle structure |
| Cxy_t | A simple 2d vector stucture |
| CTriangularInterpolation | The TriangularInterpolation class |
| CBeamlineFieldMapInterpolation | The BeamlineFieldMapInterpolation class |
| CGeoComponent | Describe one component of the Geometry |
| CGeoConfiguration | Configuration of the geometry |
| CGeoMaterial | Class to represent a material informaion in the Database |
| CGeoMaterialComponent | Component of a material |
| CGeoMaterialProperty | Property of a material |
| CGeoOpticalSurface | Represent an optical finish of a surface |
| CMagneticFieldComponent3D | Describe one component of the Geometry |
| CMyDBPayloadClass | Class containing all the parameters needed to create the geometry and suitable to save into a ROOT file to be used from the Database |
| CMyDBCreator | Very simple Creator class which actually does not do anything but shows how creators should implement loading the geometry from database |
| CFBXWriterModule | The FBX-writer module |
| CCreateFieldMapModule | Create Field maps of the Belle II magnetic field used in the simulation |
| CDensityScalerModule | Scale density of simulation/reconstruction geometry |
| CExportGeometryModule | The ExportGeometry module |
| CGeometryModule | Module to facilitate Geometry creation |
| COverlapCheckerModule | The geometry overlap check module |
| CVRMLWriterModule | The VRML-writer module |
| COnlineEventT0 | Storage element for the eventwise T0 estimation computed on HLT |
| COnlineEventT0CreatorModule | Module to write the EventT0s computed on the online systems (HLT) |
| CIRSimHit | Class for saving raw hit data of the IR |
| CBeamPipeGeo | Geometry parameters of BeamPipe |
| CCryostatGeo | Geometry parameters of Cryostat |
| CFarBeamLineGeo | Geometry parameters of far beam line |
| CIRGeoBase | Base class for IR geometry parameters |
| CBKLMDatabaseImporter | This module writes BKLM data to database |
| CBKLMAnaModule | A class defining a module that perform efficiencies studies on bklm |
| CBKLMDigitAnalyzerModule | Module useful to quickly analyze BKLM unpacked data |
| CBKLMSimHistogrammerModule | Convert BKLM raw simulation hits to digitizations |
| CBKLMTrackFinder | Track finding procedure |
| CBKLMTrackFitter | Track fitting procedure |
| CBKLMTrackingModule | This module perform straight line track finding and fitting for BKLM |
| CKLMCalibrationChecker | KLM calibration checker |
| ►CKLMChannelStatusAlgorithm | KLM channel status calibration algorithm |
| CResults | Calibration results |
| CKLMDatabaseImporter | KLM database importer |
| CKLMDisplacementGenerator | Module for generation of KLM displacement or alignment data |
| CKLMElectronicsMapImporter | KLM database importer |
| CKLMLikelihoodParametersImporter | This class imports KLMLikelihoodParameters into the database |
| ►CKLMStripEfficiencyAlgorithm | KLM channel status calibration algorithm |
| CResults | Calibration results or supplementary results calculated from the input data |
| ►CKLMTimeAlgorithm | KLM time calibration algorithm |
| CEvent | Event data |
| CBKLMElementNumbers | BKLM element numbers |
| CBKLMHit1d | Store one reconstructed BKLM 1D hit as a ROOT object |
| CBKLMStatus | BKLM hit status |
| CBKLMTrack | Store one BKLM Track as a ROOT object |
| CEKLMAlignmentHit | This dataobject is used only for EKLM alignment |
| CEKLMElementNumbers | EKLM element numbers |
| CKLMChannelArrayIndex | KLM channel array index |
| CKLMChannelIndex | KLM channel index |
| CKLMChannelMapValue | KLM channel map |
| CKLMClusterShape | Variable for KLM cluster shape analysis |
| CKLMDigit | KLM digit (class representing a digitized hit in RPCs or scintillators) |
| CKLMDigitEventInfo | Class to store debugging informations from the unpacker (event based) |
| CKLMDigitRaw | Class to store the raw words from the unpacker, digit-by-digit |
| CKLMElementArrayIndex | KLM element array index |
| CKLMElementNumbers | KLM element numbers |
| CKLMHit2d | KLM 2d hit |
| 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 informations related to the extrapolation |
| CKLMPlaneArrayIndex | KLM plane array index |
| CKLMScintillatorFirmwareFitResult | FPGA fit simulation data |
| CKLMSectorArrayIndex | KLM sector array index |
| CKLMSimHit | KLM simulation hit |
| CBKLMAlignment | Class to store BKLM alignment data in the database |
| CBKLMGeometryPar | The Class for BKLM geometry |
| CBKLMSimulationPar | Provides BKLM simulation parameters |
| CEKLMAlignment | Class to store EKLM alignment data in the database |
| ►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 |
| CEKLMSegmentAlignment | Class to store EKLM alignment data in the database |
| CKLMAlignmentData | KLM Alignment data |
| CKLMChannelStatus | KLM channel status |
| CKLMElectronicsChannel | BKLM electronics channel |
| CKLMElectronicsMap | BKLM electronics map |
| CKLMLikelihoodParameters | Database object used to store the parameters for KLM likelihood computation |
| CKLMReconstructionParameters | Class to store KLM reconstruction parameters in the database |
| 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 |
| CKLMStripEfficiency | DBObject used to store the efficiencies of KLM strips |
| CKLMTimeCableDelay | Class to store BKLM delay time coused by cable in the database |
| 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 |
| ►CEKLMAlignmentAlongStripsAlgorithm | EKLM time calibration algorithm |
| CEvent | Event: time, distance from hit to SiPM |
| CG4TriangularPrism | Triangular prism |
| CEKLMAlignmentAlongStripsCollectorModule | EKLM time calibration (data collection) |
| ►CEKLMDataCheckerModule | Module for checking of collected data |
| CStripData | Strip data information |
| CKLMChannelStatusCollectorModule | KLM channel status calibration (data collection) |
| CKLMClusterAnaModule | Module for KLM cluster reconstruction efficiency studies |
| CKLMClusterEfficiencyModule | Module for KLM cluster reconstruction efficiency studies |
| CKLMClustersReconstructorModule | Module KLMClustersReconstructorModule |
| CKLMDigitizerModule | KLM digitization module |
| CKLMDigitTimeShifterModule | KLM digit time shifter module |
| CKLMDQMModule | KLM data quality monitor module |
| ►CKLMDQM2Module | Additional Module for KLMDQM plots after HLT filters |
| CHitData | Hit data |
| CKLMPackerModule | KLM raw packer |
| CKLMReconstructorModule | Create BKLMHit1ds from BKLMDigits and then create KLMHit2ds from BKLMHit1ds; create KLMHit2ds from EKLMDigits |
| CKLMScintillatorSimulatorModule | Module KLMScintillatorSimulatorModule |
| ►CKLMStripEfficiencyCollectorModule | Module KLMStripEfficiencyCollectorModule |
| CHitData | Hit data |
| CKLMTimeCollectorModule | Collect hit information for KLM time calibration with CAF |
| CKLMUnpackerModule | KLM unpacker |
| CMCMatcherKLMClustersModule | Module for MC matching for KLM clusters |
| CMuidBuilder | Build the Muid likelihoods starting from the hit pattern and the transverse scattering in the KLM |
| CMuidElementNumbers | Muid element numbers |
| CKLMMuidLikelihoodTest | Test class for the KLMMuidLikelihood object |
| CMuidBuilderTest | Test for the MuidBuilder class, using the payloads in the default Global Tag |
| CKLMTime | KLM time conversion |
| CMasterClassModule | Module to write out data in a format for Belle II masterclasses |
| CBeamParametersFitter | Fitter calculating BeamParameters from CollisionBoostVector and CollisionInvariantMass |
| CCluster | Class to collect log likelihoods from Clusters from ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability |
| CECLCluster | ECL cluster data |
| CEventLevelClusteringInfo | ECL/KLM clustering event level information: |
| CEventLevelTrackingInfo | Tracking-related info on event-level, for example number of unassigned measurements |
| CEventLevelTriggerTimeInfo | Storage element for information from the Trigger Timing Distribution (TTD) |
| CHitPatternCDC | Hit pattern of CDC hits within a track |
| CHitPatternVXD | Hit pattern of the VXD within a track |
| CKlId | Klong identifcation (KlId) datastore object to store results from KlId calculations |
| CKLMCluster | KLM cluster data |
| CMCParticle | A Class to store the Monte Carlo particle information |
| ►CMCParticleGraph | Class to build, validate and sort a particle decay chain |
| CGraphParticle | Class to represent Particle data in graph |
| CParticleSorter | Class to go over all the particles in the Graph an sort them in a sensible way |
| CPIDLikelihood | Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes functions to return combined likelihood probability |
| CSoftwareTriggerResult | Dataobject to store the results of the cut calculations performed by the SoftwareTriggerModule |
| CTrack | Class that bundles various TrackFitResults |
| CTrackFitResult | Values of the result of a track fit with a given particle hypothesis |
| CTRGSummary | Trigger Summary Information input bits input bits from subdetectors ftdl (Final Trigger Decision Logic) bits output bits of trigger logic psnm (Prescale and Mask) bits prescaled ftdl bits timType types of trigger timing source defined in b2tt firmware |
| CV0 | Object holding information for V0s |
| CBeamSpot | This class contains the beam spot position and size modeled as a gaussian distribution in space |
| CCollisionAxisCMS | This class contains the measured values of the orientation of the collision axis in the CM system obtained by pure Lorentz boost angleXZ = atan(pHERcms.X / pHERcms.Z) angleYZ = atan(pHERcms.Y / pHERcms.Z) where pHERcms is HER momentum in CM system obtained by boost |
| CCollisionBoostVector | This class contains the measured average boost vector vec(beta) = (beta_x, beta_y, beta_z) = vec(p_e+e-)/E_e+e- of the center-of-mass system in the lab frame and its uncertainty |
| CCollisionInvariantMass | This class contains the measured average center-of-mass energy, which is equal to the invariant mass of the colliding beams, and its uncertainty |
| CDBRepresentationOfSoftwareTriggerCut | Class to handle storing SoftwareTriggerCuts in the database |
| CSoftwareTriggerCutBase | Base class for the SoftwareTriggerCut and its DBRepresentation |
| CSoftwareTriggerMenu | Class to handle storing the trigger menu in the database |
| CTRGGDLDBBadrun | The payload class for GDL badrun |
| CTRGGDLDBFTDLBits | The payload class for FTDL output bit |
| CTRGGDLDBInputBits | The payload class for GDL input bit |
| CTRGGDLDBPrescales | The payload class for GDL psnm |
| CTTDOffsets | This class contains information to correct the information obtained from the TTD (simple offsets) |
| CBeamSpotTest | |
| CFixMergedObjectsModule | If the content of two DataStores are merged using the 'MergeDataStoreModule', then Relations of the objects are corrected |
| CECLClusterTest | Test class for the Track object |
| CEventLevelTrackingInfoTest | Unit tests for the event level tracking information |
| CHitPatternCDCTest | Unit tests for the CDC hit Patterns |
| CHitPatternVXDTest | |
| CKlIdTest | Test class for the KlId object |
| CTrackTest | Test class for the Track object |
| CTrackFitResultTest | Set up a few arrays and objects in the datastore |
| CV0Test | Set up a few arrays and objects in the datastore |
| CDatabaseRepresentationOfWeightfile | Database representation of a Weightfile object |
| CMVAExpertModule | This module adds an ExtraInfo to the Particle objects in a given ParticleList |
| CMVAMultipleExpertsModule | This module adds an ExtraInfo to the Particle objects in a given ParticleList |
| CMVAPrototypeModule | This module can be used as a prototype for your own module which uses MVA weightfiles |
| CAWESOMESimHit | A Geant4 simulated hit for the AWESOME detector |
| CPXDAnalyticGainCalibrationAlgorithm | Class implementing the PXD gain calibration algorithm |
| CPXDChargeCalibrationAlgorithm | Class implementing the PXD median cluster charge calibration algorithm |
| CPXDClusterPositionCalibrationAlgorithm | Class implementing the PXD cluster position calibration algorithm |
| CPXDDataMCGainCalibrationAlgorithm | Class implementing the PXD median cluster charge calibration algorithm |
| CPXDGainCalibrationAlgorithm | Class implementing the PXD gain calibration algorithm |
| CPXDHotPixelMaskCalibrationAlgorithm | Class implementing PXD hot pixel masking calibration algorithm |
| CPXDValidationAlgorithm | Class implementing the PXD calibration validation 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 |
| 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 |
| CPXDDigit | The PXD digit class |
| CPXDEnergyDepositionEvent | Class PXDEnergyDepositionEvent: PXDSimHit data container for background studies |
| CPXDGatedModeInfo | The PXD Gated Info Class |
| CPXDInjectionBGTiming | The PXDInjectionBGTiming class |
| CPXDNeutronFluxEvent | Class PXDNeutronFluxEvent: PXDTrueHit data container for background studies |
| CPXDOccupancyEvent | Class PXDOccupancyEvent: PXDCluster data container for background studies |
| CPXDRawAdc | The PXD Raw Adc class This class stores information about Raw Adc for Pedestals |
| CPXDRawHit | The PXD Raw Hit class This class stores information about PXD Pixel hits and makes them available in a root tree |
| CPXDRawROIs | The PXD Raw ROIs class This class stores information about the ROIs processed by ONSEN and makes them available in a root tree |
| CPXDSimHit | Class PXDSimHit - Geant4 simulated hit for the PXD |
| CPXDTrueHit | Class PXDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| CPXDClusterChargeMapPar | The payload class for PXD cluster charge calibrations |
| CPXDClusterOffsetPar | The class for PXD cluster position offset payload |
| CPXDClusterPositionErrorPar | The payload class for PXD cluster position error |
| CPXDClusterPositionEstimatorPar | The class for PXD cluster position lookup table payload |
| CPXDClusterShapeClassifierPar | The class for PXD cluster shape classifier payload |
| CPXDClusterShapeIndexPar | The class for PXD cluster shape index payload |
| CPXDDeadPixelPar | The payload telling which PXD pixel is dead (=Readout system does not receive signals) |
| CPXDDHHFirmwareVersionPar | The payload stores the firmware version from the DHH, which has influence on the structure and content of the RawPXD package |
| CPXDGainMapPar | The payload class for PXD gain corrections |
| CPXDGeometryPar | The Class for VXD geometry |
| CPXDMaskedPixelPar | The payload telling which PXD pixel to mask (ignore) |
| CPXDOccupancyInfoPar | The payload collecting some meta information from running the masking algorithm |
| CPXDSensorInfoPar | The Class for VXD geometry |
| CPXDClusterChargeCollectorModule | Collector module for PXD gain calibration |
| CPXDClusterPositionCollectorModule | Calibration collector module for PXD cluster position estimation |
| 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 |
| CPXDRawDQMCorrModule | PXD DQM Corr Module |
| CPXDTrackClusterDQMModule | DQM of cluster in matched tracks |
| CPXDHotPixelMaskCollectorModule | Calibration Collector Module for PXD hot pixel masking from PXDDigits |
| CPXDRawHotPixelMaskCollectorModule | Calibration Collector Module for PXD hot pixel masking from PXDRawHits |
| CPXDTrackingEventLevelMdstInfoFillerModule | This module adds additional global event level information about PXD track finding to the MDST object 'EventLevelTrackingInfo' |
| CPXDClustersFromTracksModule | The PXDClustersFromTracks module |
| CPXDPerformanceModule | PXD Performance module |
| CPXDPerformanceCollectorModule | Collector module for PXD gain calibration and PXD calibration validation |
| CPXDPerformanceVariablesCollectorModule | Collector module for PXD gain calibration and PXD calibration validation |
| CPXDClusterPropFilterModule | The module produce a StoreArray of PXDCluster with specific properties |
| CPXDInjectionVetoEmulatorModule | The module produces a StoreObjPtr of PXDInjectionBGTiming containing PXD timing for gated mode operation |
| CPXDSpacePointCreatorModule | Imports Clusters of the pxd detector and converts them to spacePoints |
| CPXDIgnoredPixelsMap | This class provides a check for ignored (=cold, hot or otherwise deffective) pixels for the use in PXD data reconstruction |
| CPXDRecoHit | PXDRecoHit - an extended form of PXDCluster containing geometry information |
| CPXDLocalDAQFile | A class to manage I/O for a chain of blocked files |
| CPXD2TrackBase | Class PXD2TrackBase: Event data container for performance and calibration studies |
| CPXD2TrackEvent | Class PXD2TrackEvent: Event data container for performance and calibration studies |
| 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 |
| 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 |
| CRawDataBlock | The RawDataBlock class Base class for rawdata handling |
| CRawDataBlockFormat | The RawDataBlockFormat class Format information for rawdata handling |
| 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 |
| CRawKLM | The Raw KLM class Class for RawCOPPER class data taken by KLM |
| CRawPXD | The Raw PXD class |
| 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 |
| CRawCOPPERPackerInfo | Struct to contain header information used by RawCOPPERFormat::Packer() |
| CCheckErrorEventModule | Count the number of CRC error events by checking RawCOPPER's header/trailer and EventMetaData |
| CConvert2RawDetModule | A class definition of a module to convert from RawCOPPER or RawDataBlock to RawDetector objects |
| CDummyDataPackerModule | Module to store dummy data in RawCOPPER object |
| CHexDataPackerModule | Module to store dummy data in RawCOPPER object |
| CMakeDumHSLBDataModule | Module to make a binary file from Raw*** events for input of wirte-dumhsbx |
| 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 |
| CRoot2BinaryModule | Dump basf2 objects to a binary file |
| CTTDDQMModule | TTD Injection DQM module |
| CTTDUnpackerModule | TTD Unpacker module |
| CCDCDedx1DCellAlgorithm | A calibration algorithm for CDC dE/dx electron: 1D enta cleanup correction |
| CCDCDedx2DCellAlgorithm | A calibration algorithm for CDC dE/dx electron 2D enta vs doca correction |
| CCDCDedxBadWireAlgorithm | A calibration algorithm for CDC dE/dx to find the bad wires |
| CCDCDedxCosEdgeAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxCosineAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxInjectTimeAlgorithm | A calibration algorithm for CDC dE/dx injection time (HER/LER) |
| CCDCDedxMomentumAlgorithm | A calibration algorithm for CDC dE/dx electron cos(theta) dependence |
| CCDCDedxRunGainAlgorithm | A calibration algorithm for CDC dE/dx run gains |
| CCDCDedxWireGainAlgorithm | A calibration algorithm for CDC dE/dx wire gains |
| CCDCDedxLikelihood | Container for likelihoods obtained by the CDC dE/dx PID (CDCDedxPIDModule) |
| CCDCDedxTrack | Debug output for CDCDedxPID module |
| CVXDDedxLikelihood | Container for likelihoods obtained by the VXD dE/dx PID (VXDDedxPIDModule) |
| CVXDDedxTrack | Debug output for VXDDedxPID module |
| CCDCDedx1DCell | DE/dx wire gain calibration constants |
| CCDCDedx2DCell | DE/dx wire gain calibration constants |
| CCDCDedxADCNonLinearity | DE/dx eletronic ADC non-linearity correction for highly ionising particles (used in offline hadron saturation calibration) paramters 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 |
| CCDCDedxBadWires | DE/dx wire gain calibration constants |
| 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 |
| CCDCDedxHadronCor | DE/dx hadron saturation parameterization constants |
| CCDCDedxInjectionTime | DE/dx injection time calibration constants |
| CCDCDedxMeanPars | DE/dx mean (curve versus beta-gamma) parameterization constants |
| CCDCDedxMomentumCor | DE/dx wire gain calibration constants |
| CCDCDedxRunGain | DE/dx run gain calibration constants |
| CCDCDedxScaleFactor | DE/dx run gain calibration constants |
| CCDCDedxSigmaPars | DE/dx sigma (versus beta-gamma) parameterization constants |
| CCDCDedxWireGain | DE/dx wire gain calibration constants |
| CDedxPDFs | DE/dx wire gain calibration constants |
| CEventsOfDoomParameters | DBObject containing parameters used in EventsOfDoomBuster module |
| CCDCDedxCorrectionModule | This module may be used to apply the corrections to dE/dx per the calibration constants |
| 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 |
| CCDCDedxPIDModule | Extract CDC dE/dx information from fitted tracks |
| CCDCDedxScanModule | This class performs the same function as CDCDedxPIDModule, but does so without using real objects from basf2 |
| 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 |
| CDedxLine | A class to hold the endpoints and slope of a line |
| CDedxDriftCell | A class to hold the geometry of a cell |
| CCDCDedxSkimModule | This module may be used to skim a data sample according to a specific set of cuts |
| CCDCDedxSkimCDSTModule | Extracts dE/dx information for calibration testing |
| CCDCDedxValidationModule | First version commited on Feb 21 2019 Extracts dE/dx information for validation and writes a ROOT file |
| CClusterMatcherModule | Match KLM Clusters to close ECL Clusters |
| CDetectorOccupanciesDQMModule | DQM Module for basic detector quantities before the HLT filter |
| CEventsOfDoomBusterModule | Module that flags an event destined for doom at reconstruction, based on the size of selected hits/digits containers after the unpacking |
| 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 |
| CHitLevelInfoWriterModule | Extracts dE/dx information for calibration testing |
| CDataWriterModule | Module to write Ntuples for KlId BKG classifier training |
| CECLExpertModule | Module to perform the ECL Klong ID classification |
| CKLMExpertModule | Module to perform the KLM KlId classification |
| CKlongValidationModule | Module used by the validation server to generate root files for the validation |
| CMdstPIDModule | Module to fill PIDLikelihoods |
| CPIDNtupleModule | Makes PID ntuple from mdst input |
| CHelixHelper | Helper class representing a helical track |
| CVXDDedxPIDModule | Extract dE/dx from fitted tracks |
| CCDCDedxMeanPred | Class to hold the prediction of mean as a function of beta-gamma (bg) |
| CCDCDedxSigmaPred | Class to hold the prediction of resolution depending dE/dx, nhit, and cos(theta) |
| CBkgNeutronWeight | The class to get the weighting factor for a 1-MeV-equivalent neutron flux on silicon |
| CBkgSensitiveDetector | The Class for BeamBackground Sensitive Detector |
| CBeamBackHit | Class BeamBackHit - Stores hits from beam backgound simulation |
| CMCParticleTrajectory | Class to save the full simulated trajectory of a particle |
| CMCTrajectoryPoint | Small struct to encode a position/momentum without additional overhead |
| CSimClockState | Simulated hardware clock state |
| CSimHitBase | Class SimHitBase - A common base for subdetector SimHits |
| CROISimulationParameters | The payload containing all PXD ROI parameters |
| CDetectorConstruction | Class responsible to connect to geometry to simulation |
| CRandomEngine | Interface class to make Geant4 use the Belle2 RandomGenerator |
| 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 |
| CROIfindingConditionFromDBModule | Module which sets its return value based on the payload whether ROI-finding was enabled for the given run/exp interval or not |
| CFullSimModule | The full Geant4 simulation module |
| CFullSimTimingModule | Provide more detailled timing info for FullSim module |
| CMaterialScanBase | Base class for Material Scans |
| ►CMaterialScan2D | Base class to create a Material Scan of the detector geometry |
| CScanParams | Helper struct to Store Parameters of a Scan |
| CMaterialScanSpherical | Specific implementation of MaterialScan to do Spherical scanning |
| CMaterialScanPlanar | Specific implementaion 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 |
| CMaterialScanModule | The MaterialScan module |
| 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) |
| CCOILGeometryPar | The Class for COIL geometry parameters |
| 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 |
| CServiceGapsMomVolPar | The class for the mother volume of the Service Materials |
| CThicknessDensityPar | The class for the thicknesses and the density of gap element cell |
| CServiceGapsMaterialsPar | The Class for services materials geometry |
| CSTRGeometryPar | The Class for STR geometry |
| 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 |
| CSVDChargeSimulationCalibrations | This class defines the dbobject and the methods to access SVD simulation calibrations; coupling constants and Geant4 electron weight |
| CSVDClustering | This class defines the dbobject and the methods to access the calibration of the cluster reconstruction |
| CSVDClusterTimeShifterAlgorithm | Class implementing SVDClusterTimeShifter algorithm |
| 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 |
| CSVDCrossTalkCalibrationsAlgorithm | Class implementing SVDCrossTalkCalibrations calibration algorithm |
| CSVDCrossTalkStripsCalibrations | This class defines the dbobject and the method to access strips which are masked at FADC level |
| CSVDDatabaseImporter | This class import to the database the dbobjects SVDNoiseCalibrations and SVDPulseShapeCalibrations |
| CSVDDetectorConfigurationImporter | This class import to the database the dbobjects SVDGlobalConfigParameters and SVDLocalConfigParameters |
| CSVDFADCMaskedStrips | This class defines the dbobject and the method to access strips which are masked at FADC level |
| CSVDHitTimeSelection | This class defines the dbobject and the methods to access the calibration of the cluster reconstruction |
| CSVDHotStripsCalibrations | This class defines the wrapper to retrieve the the list of the hot strips flgged offline |
| CSVDHotStripsCalibrationsAlgorithm | Class implementing SVDHotStripsCalibrations calibration algorithm |
| CSVDLocalCalibrationsImporter | This class import to the database the dbobjects storing the SVD Local Calibrations |
| 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 |
| CSVDNoiseCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| CSVDOccupancyCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| CSVDOccupancyCalibrationsAlgorithm | Class implementing SVDOccupancyCalibrations calibration algorithm |
| CSVDOldDefaultErrorScaleFactors | This class defines the dbobject and the methods to access the scaling factors for the OldDefault position algorithm |
| CSVDPedestalCalibrations | This class defines the dbobject and the method to access SVD calibrations from the noise local runs |
| 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 |
| CSVDTimeValidationAlgorithm | Class implementing SVDTimeValidation algorithm |
| CSVDAPVHistograms | Template class for the APV Histograms |
| CSVDCluster | The SVD Cluster class This class stores all information about reconstructed SVD clusters |
| CSVDDAQDiagnostic | Class to store SVD DAQ diagnostic information |
| CSVDEnergyDepositionEvent | Class SVDEnergyDepositionEvent: SVDSimHit data container for background studies |
| CSVDEventInfo | Stores SVDModeByte object with Trigger time, DAQ mode, Run type & Event type! Also - the information of any inconsistencies of these variables within one event are stored |
| CSVDHistograms | Template class for SVd histograms |
| CSVDModeByte | Class to store SVD mode information |
| CSVDNeutronFluxEvent | Class SVDNeutronFluxEvent: SVDTrueHit data container for background studies |
| CSVDOccupancyEvent | Class SVDOccupancyEvent: SVDCluster data container for background studies |
| CSVDRecoDigit | The SVD RecoDigit class |
| CSVDRecoTimeBase | The SVD RecoTimeBase class |
| CSVDShaperDigit | The SVD ShaperDigit class |
| CSVDSimHit | Class SVDSimHit - Geant4 simulated hit for the SVD |
| CSVDSummaryPlots | Class to summarize SVD quantities per sensor and side |
| CSVDTransparentDigit | The SVD digit class |
| CSVDTriggerType | Class to store Trigger Type information |
| CSVDTrueHit | Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| 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 |
| CSVDChargeSimCal | Simulation calibration parameters |
| CSVDClusterCuts | Clustering parameters |
| CSVDClusterTimeShifter | This class store the shift in svd time w.r.t |
| CSVDCoGCalibrationFunction | Class to contain the CoG Time calibrations |
| CSVDCoolingPipesPar | The Class for SVD Cooling Pipes |
| CSVDEndringsTypePar | The Class for SVD Endring Type |
| CSVDEndringsPar | The Class for SVD Endring |
| 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 |
| CSVDHitTimeSelectionFunction | Class to contain the cut on svd hit time at SP creation step |
| 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 |
| CSVDMCFudgeFactorFunction | Class to contain the MC fudge factor formulae |
| CSVDPosErrScaleFactors | Scaling factors for the cluster position error |
| CSVDPositionErrorFunction | Class to contain the Cluster Position Error Formulae |
| CSVDRecoConfiguration | This class store the reconstruction configuration of SVD |
| CSVDSensorInfoPar | The Class for VXD geometry |
| CSVDSpacePointSNRFractionSelector | Class to contain the cut on SVDSpacePoint |
| CSVDStripCalAmp | Parameter of the APV pulse |
| CSVDSupportBoxPar | The Class for SVD Support Box |
| CSVDSupportTabPar | The Class for SVD Support Rib Tab |
| CSVDEndmountPar | The Class for SVD Support Rib Endmounts |
| CSVDSupportRibsPar | The Class for SVD Support Ribs (one layer) |
| CSVDTimeGroupingParameters | Structure containing the relevant informations of SVDTimeGrouping module |
| CSVDTimeGroupingConfiguration | This class store the reconstruction configuration of SVDTimeGrouping module |
| CSVDChannelMappingModule | The Channel Mapping Check Module |
| CSVDClusterCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded calibration constants |
| CSVDHotStripFinderModule | A module template |
| CSVDLatencyCalibrationModule | This module perfoms an analysis to find the APV25 latency |
| CSVDLocalCalibrationsCheckModule | Module to produce a list of histogram showing the uploaded local calibration constants |
| CSVDLocalCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded local calibration constants |
| CSVDPositionErrorScaleFactorImporterModule | Module that produces a localdb with position error scale factors for different position algoritms |
| CSVDTimeCalibrationsMonitorModule | Module to produce a list of histogram showing the uploaded calibration constants |
| 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 |
| CSVDClusterQualityEstimatorCalibrationModule | Generate PDFs for assigning probability that cluster generated from signal particle |
| CSVDClusterQualityEstimatorModule | Calculates the probability of a cluster originating from signal hit |
| CSVDCrossTalkCalibrationsCollectorModule | Collector module used to create the histograms needed for the cross talk calibration |
| CSVDCrossTalkFinderModule | Flags potential cross talk strips on Origami sensors |
| 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 |
| CSVDUnpackerDQMModule | SVD DQM Module for the Unpacker |
| CsvdDumpModule | Class definition of svdClsHistoManager module |
| CSVDTrackingEventLevelMdstInfoFillerModule | This module adds additional global event level information about SVD track finding to the MDST object 'EventLevelTrackingInfo' |
| 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 |
| CSVDB4CommissioningPlotsModule | The SVD B4CommissioningPlots Module |
| CSVDClusterEvaluationModule | The SVD ClusterEvaluation Module |
| CSVDClusterEvaluationTrueInfoModule | Clustering Performance, using true informations |
| CSVDClusterFilterModule | Generates a new StoreArray from the input StoreArray which has all specified Clusters removed |
| CSVDEventT0PerformanceTTreeModule | The module is used to create a TTree to study SVD EventT0 |
| CSVDMaxStripTTreeModule | The module is used to create a TTree to study the number of strips fired per event per APV chip |
| CSVDOccupancyAnalysisModule | The SVD OccupancyAnalysis Module |
| 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 |
| CSVDShaperDigitsFromTracksModule | Generates two new StoreArray from the input StoreArray |
| CSVDCoGTimeEstimatorModule | This module builds the SVDRecoDigits (calibrated and fitted strips) from the SVDShaperDigits |
| CSVDDataFormatCheckModule | This module checks the format of the data that we are going to reconstruct checking the SVDModeByte and the SVDDAQDiagnostic |
| CSVDStripMaskingModule | This module removes the strips to be masked read form the SVDHotStripsCalibration |
| CSVD3SamplesEmulatorModule | This module takes the SVDShaperDigit as input and select three consecutive samples starting from the one choosen by the user |
| CSVDEventInfoSetterModule | Module to set the SVDEventInfo in the simulation |
| CSVDTriggerQualityGeneratorModule | This module generates a StoreObjPtr that contains random trigger quality chosen between FINE and CORSE |
| CSVDZeroSuppressionEmulatorModule | This module filters out strips that do not pass a ZS cut from the SVDShaperDigit StoreArray |
| CSVD6SampleEventSkimModule | SVD 6-sample event skim module |
| CClustersOnSensor | Small struct for storing all clusters of the same sensor in one container |
| CSVDSpacePointCreatorModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDSpacePointQICalibrationModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDClusterTimeShifterCollectorModule | This module creates and fills histograms based on cluster-sizes so that the mean of SVD-cluster time distribution could be calculated |
| CSVDTimeCalibrationCollectorModule | Collector module used to create the histograms needed for the SVD CoG-Time calibration |
| CSVDTimeGroupingModule | Imports Clusters of the SVD detector and converts them to spacePoints |
| CSVDTimeValidationCollectorModule | Collector module used to create the histograms needed for the SVD CoG-Time calibration |
| CSVDIgnoredStripsMap | This class provides a list of ignored (=cold, hot or otherwise deffective) strips for the use in SVD data reconstruction |
| ►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 informations |
| CSensorID | Class to hold numbers related to sensor |
| CSensorInfo | Struct to hold data about a sensor |
| CSVDStripNoiseMap | Strip noise map |
| CSVDRecoHit | SVDRecoHit - an extended form of SVDHit containing geometry information |
| CSVDRecoHit2D | SVDRecoHit - an extended form of SVDHit containing geometry information |
| CTOPDatabaseImporter | TOP database importer |
| CTOPAsicMask | Class to store bit fields of masked ASICs, as reported in raw data |
| ►CTOPAssociatedPDF | Class to store analytic PDF associated with a photon |
| CPDFPeak | Parameters of a PDF peak |
| CTOPBarHit | Class to store track parameters of incoming MC particles relation to MCParticle filled in top/simulation/src/SensitiveBar.cc |
| CTOPDigit | Class to store TOP digitized hits (output of TOPDigitizer or raw data unpacker) relations to TOPSimHits, MCParticles |
| CTOPInterimFEInfo | Class to store debug info of raw data in Interim FE format |
| CTOPLikelihood | Class to store TOP log likelihoods (output of TOPReconstructor) |
| CTOPLikelihoodScanResult | Class to store the result of the TOP LL scan (output of TOPLLScanner) |
| ►CTOPPDFCollection | Class to store analytical PDF relation from Tracks filled top/modules/TOPPDFDebugger/src/TOPPDFDebuggerModule.cc |
| CGaussian | Parameters to describe a Gaussian |
| CTOPPixelLikelihood | Class to store pixel-by-pixel likelihoods for a track relation from Tracks filled in top/modules/TOPPDFDebugger/src/TOPPDFDebuggerModule.cc |
| 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 |
| 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 |
| ►CTOPRawWaveform | Class to store raw data waveforms |
| CFeatureExtraction | Feature extraction data |
| CTOPRecBunch | Class to store results of TOPBunchFinder |
| 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 |
| CTOPTemplateFitResult | Class to store template fit result from feature extraction data |
| CTOPTimeZero | Class to store T0 information |
| CTOPTriggerDigit | Class to store trigger time stamps |
| CTOPTriggerMCInfo | Class to store Monte Carlo information useful for trigger studies |
| CTOPASICChannel | Calibration constants of a singe ASIC channel: pedestals, gains and time axis |
| CTOPASICGains | Calibration constants of a single ASIC window: gains |
| CTOPASICPedestals | Calibration constants of a single ASIC window: pedestals |
| 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 |
| 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 |
| CTOPFrontEndMap | Mapping of a boardstack number within a module to SCROD and COPPER/Finesse |
| CTOPFrontEndSetting | Front-end settings: storage depths, lookback, readout windows etc |
| 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 |
| 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) |
| 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 |
| 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 |
| CTOPPulseHeightPar | Struct holding the pulse height parameterizations for the TOP counter |
| CTOPSampleTimes | Calibration constants of a singe ASIC channel: time axis (sample times) |
| CTOPSignalShape | Normalized shape of single photon pulse (waveform) Pulse must be positive |
| CTOPWavelengthFilter | Bulk transmittance of wavelength filter |
| CTOPAlignmentCollectorModule | Collector for geometrical alignment of a TOP module with dimuons or Bhabhas |
| CTOPAsicShiftsBS13dCollectorModule | Collector for carrier shifts of BS13d |
| CTOPChannelMaskCollectorModule | Collector for preparing masks of hot and dead channels |
| CTOPCommonT0BFCollectorModule | Collector for common T0 calibration with a fit of bunch finder residuals (method BF) |
| CTOPCommonT0LLCollectorModule | Collector for common T0 calibration with neg |
| CTOPModuleT0DeltaTCollectorModule | Collector for module T0 calibration with chi2 minimization of time differences between slots (method DeltaT) |
| CTOPModuleT0LLCollectorModule | Collector for module T0 calibration with neg |
| CTOPOffsetCollectorModule | Collector for eventT0 and fill pattern offset calibrations |
| CTOPPhotonYieldsCollectorModule | Collector for photon pixel yields aimed for PMT ageing studies and for finding optically decoupled PMT's |
| CTOPPulseHeightCollectorModule | Collector for channel pulse-height distributions |
| CTOPValidationCollectorModule | Collector for automatic validation of calibration with dimuon events |
| COpticalGunModule | Source of optical photons for the simulation of the TOP laser system |
| CTOPAlignerModule | Alignment of TOP |
| CTOPBackgroundModule | TOP backgound module |
| ►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 |
| 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) |
| CTOPCommonT0CalibratorModule | A module for common T0 calibration with collision data (dimuons or bhabhas) |
| CTOPCosmicT0FinderModule | Event T0 finder for global cosmic runs |
| ►CTOPDigitizerModule | TOP digitizer |
| CTimeOffset | Utility structure for time offset |
| CTOPTriggerDigitizerModule | Digitizer that provides time stamps for TOP trigger |
| CTOPCalPulseGeneratorModule | Generator of calibration pulses Output to TOPSimCalPulses |
| CTOPDoublePulseGeneratorModule | Generator of double calibration pulses Output to TOPDigits |
| CTOPDQMModule | TOP DQM histogrammer |
| CTOPGainEfficiencyCalculatorModule | Module for channel-by-channel gain/efficiency analysis |
| ►CTOPLaserHitSelectorModule | Module for pixel-by-pixel gain/efficiency analysis |
| ChitInfo_t | Structure to hold hit information, used in double cal |
| CTOPGeometryParInitializerModule | Class for initializing TOPGeometryPar |
| CTOPInterimFENtupleModule | Module to produce ntuple from TOPDigits and TOPRawDigits |
| CTOPLaserCalibratorModule | T0 Laser calibration module (under development) |
| CTOPLaserCalibratorCollectorModule | Collector module for the TOP channelT0 calibration and, more in general, for the time resolution studies using the laser and pulser data |
| 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 |
| CTOPNtupleModule | Module to write out a ntuple summarizing TOP reconstruction output |
| CTOPPackerModule | Raw data packer |
| CTOPPDFCheckerModule | Module for checking analytic PDF used in likelihood calculation |
| CTOPPDFDebuggerModule | TOP reconstruction module |
| CTOPRawDigitConverterModule | TOPRawDigits to TOPDigits converter |
| ►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 |
| CTOPTBCComparatorModule | Module for the comparison of different sets of time base correction (TBC) constants and to produce monitoring plots out of a given set |
| CHit | Structure to hold some of the calpulse data |
| CTwoTimes | Structure to hold calpulse raw times expressed in samples since sample 0 of window 0 |
| 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! |
| CTOPUnpackerModule | Raw data unpacker |
| 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 |
| CTOPXTalkChargeShareSetterModule | Crosstalk & chargeshare flag setter |
| CBeamSpotAlgorithm | Class implementing BeamSpot calibration algorithm |
| CBoostVectorAlgorithm | Class implementing BoostVector calibration algorithm |
| CCalibPars | The parameters related to single calibration interval |
| CCalibrationData | Parameters and data relevant for single calibration interval |
| CChebFitter | Unbinned Maximum Likelihood fitter with a possibility to use Chebyshev interpolation |
| CInvariantMassAlgorithm | Class implementing InvariantMass calibration algorithm |
| CAtom | Very small (few mins) calibration interval which cannot be further divided : Atom |
| CExpRun | Struct containing exp number and run number |
| CExpRunEvt | Struct with expNum, runNum, evtNum |
| CSplitter | Class that allows to split runs into the intervals of intended properties given by the lossFunction |
| CSpline | Spline structure for zero-order & linear splines |
| CCDCCKFState | Define states for CKF algorithm, which can be seed track or CDC wire hit |
| 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") |
| CCDCPathPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CChi2BasedCDCPathPairFilter | Prefers path with smallest sum dist^2 / length of path |
| CDistanceBasedCDCPathPairFilter | For the two paths with the same number of hits prefers one with smallest sum dist^2 |
| CDuplicateCDCPathPairFilter | Simple filter to distinguish between photon conversion and Bremsstrahlung |
| CHitDistanceBasedCDCPathPairFilter | Prefers path with smallest sum dist^2 / length of path |
| CMCTruthCDCPathPairFilter | For the two paths select the one with the most of MC matched hits |
| CCDCfromEclPathTruthVarNames | Vehicle class to transport the variable names |
| CCDCfromEclPathTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| 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 |
| CCDCPathTruthVarNames | Vehicle class to transport the variable names |
| CCDCPathTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| CSeedChargeCDCPathFilter | Check if charge of fitted path corresponds to charge of seed |
| CSizeCDCPathFilter | Return the size of the path |
| CCDCfromEclStateTruthVarNames | Vehicle class to transport the variable names |
| CCDCfromEclStateTruthVarSet | Var set to store basic quantities related to CDC CKF (using truth information) |
| 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) |
| CDistanceCDCStateFilter | Give a weight based on the distance from the hit to the path |
| CExtrapolateAndUpdateCDCStateFilter | An extrapolateAndUpdate filter for all CDC states |
| 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) |
| CRoughCDCfromEclStateFilter | A very rough filter for all CDC states |
| CRoughCDCStateFilter | A very rough filter for all CDC states |
| 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 resutling tracks and relations on the dataStore |
| CCDCCKFSeedCreator | Create a CKF seed based on RecoTrack (presumably from VXDTF2) |
| ►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 |
| CCKFToCDCFindlet | Main findlet of the ToCDCCKF module |
| CCKFToCDCFromEclFindlet | Main findlet of the ToCDCCKF module |
| CStackTreeSearcher | CKF tree searcher which traces several best paths |
| 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 |
| 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 |
| 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 |
| 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 |
| CCKFRelationCreator | Findlet for applying filters for creating hit-hit and hit-seed relations |
| CLayerToggledApplier | A special findlet, which is chooseable based on a given findlet for layers higher than N, N and for the rest |
| 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 |
| COnStateApplier | Helper findlet which applies its () operator to all pairs of path and state with all states in the given child state list |
| COverlapResolver | Simple findlet for searching the best candidate for a given seed aplying the given filter |
| CResultStorer | This findlet does also handle the storing of the results |
| CSpacePointTagger | Findlet for tagging all space points in the results vector as used |
| 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 |
| CTrackFitterAndDeleter | Findlet to fit tracks and remove all non fitted ones |
| CTrackLoader | Findlet for loading the seeds from the data store |
| CTreeSearcher | Findlet for constructing result paths out of a list of states, which are connected with weighted relations |
| CAdvancer | Helper findlet for performing an extrapolation of a mSoP of one plane to another plane using the representation stored in the mSoP |
| CSeedGetter | Helper Functor to get the Seed of a given result |
| CNumberOfHitsGetter | Helper Functor to get the Number of hits of a given result |
| CGetArcLength | Helper Functor to get the arc length of a given result |
| CKalmanStepper | Class to bundle all algorithms needed for the kalman update procedure |
| CCKFToPXDResult | Specialized CKF Result for extrapolating into the PXD |
| CCKFToPXDState | Specialized CKF State for extrapolating into the PXD |
| CDistancePXDPairFilter | Base filter for CKF PXD states |
| CLayerPXDRelationFilter | Base filter for CKF PXD states |
| CLoosePXDPairFilter | Base filter for CKF PXD states |
| CPXDPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| CSensorPXDPairFilter | Base filter for CKF PXD states |
| 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 |
| CSizePXDResultFilter | Base filter for CKF PXD results (on overlap check) |
| CAllPXDStateFilter | A very simple filter for all space points |
| 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 |
| CSimplePXDStateFilter | A very simple filter for all space points |
| CCKFToPXDFindlet | Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (PXD) and collect space points |
| CPXDKalmanStepper | Kalman stepper implementation for the PXD CKF |
| CMCUtil | Class bundling all helper functions for the MC information used in the PXD CKF |
| CCKFToSVDResult | Specialized CKF Result for extrapolating into the SVD |
| CCKFToSVDState | Specialized CKF State for extrapolating into the SVD |
| CDistanceSVDPairFilter | Base filter for CKF SVD states |
| CLayerSVDRelationFilter | Base filter for CKF SVD states |
| CLooseSVDPairFilter | Base filter for CKF SVD states |
| CSectorMapBasedSVDPairFilter | Filter for relations between CKF SVD states based on SectorMaps |
| CSensorSVDPairFilter | Base filter for CKF SVD states |
| CSVDPairFilterFactory | Factory that can create appropriate cluster filters from associated names |
| 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 |
| CSizeSVDResultFilter | Base filter for CKF SVD results (on overlap check) |
| 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 |
| CWeightSVDResultFilter | Base filter for CKF SVD results (on overlap check) |
| CAllSVDStateFilter | A very simple filter for all space points |
| CResidualSVDStateFilter | A very simple filter for all space points |
| CSimpleSVDStateFilter | A very simple filter for all space points |
| 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 |
| CCKFToSVDFindlet | Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (SVD) and collect space points |
| CCKFToSVDSeedFindlet | Findlet for combining CDC tracks with SVD tracks |
| CRecoTrackRelator | The results of the CKF ar in the form (seed -> vector of hits) |
| CRelationApplier | Relate the SVD and CDC tracks in the given relations also in the store array |
| 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 |
| CSpacePointLoader | Load the space points from the store array to the given vector |
| CSVDKalmanStepper | Kalman stepper implementation for the SVD CKF |
| CBremHit | A bremsstrahlung hit that correlates an ECLCluster with a RecoTrack |
| CExtHit | Store one Ext hit as a ROOT object |
| CFilterID | Class to identify a filter type used by sectorFriends |
| CFilterInfo | Helper class to store the information for a Filter |
| CFullSecID | Class to identify a sector inside of the VXD |
| ►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 |
| CMCParticleInfo | This struct is used by the TrackingPerformanceEvaluation Module to save information of reconstructed tracks |
| CObserverInfo | Helper class that stores the information an Observer stores: i.e |
| CPXDIntercept | PXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an PXD sensor |
| 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 |
| CRecoTrackGenfitAccess | This class allows access to the genfit::Track of the RecoTrack |
| 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? This Object contains a binary blob which is send as whole from the HLT Roi Sender output node to the ONSEN system, containing the trigger decision and the Region od Interest (ROI) for data selection on the PXD modules See Data format definitions [BELLE2-NOTE-TE-2016-009] on https://docs.belle2.org/ |
| CROIrawID | ROIrawID |
| CSectorMapConfig | Simple struct containing all the configuration data needed for the SecMapTrainer |
| CSpacePointInfo | Helper class to store the SpacePoint information as coding convention prohibits to use the SpacePoint class here |
| CSVDIntercept | SVDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an SVD sensor |
| CTrackClusterSeparation | Store one Track-KLMCluster separation as a ROOT object |
| CV0ValidationVertex | Class which stores some additional information on V0 vertices |
| CVXDIntercept | VXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with a VXD sensor |
| CDATCONSVDClusterCandidate | Struct containing a cluster candidate for easier handling |
| CDATCONSVDDigit | The DATCONSVDDigit class |
| CDATCONFPGAFindlet | Findlet for performing the DATCON ROI calculation close to the implementation on FPGA |
| 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 |
| CFastInterceptFinder2DFPGA | Findlet for finging intersections of sinosoidal curves in the 2D Hough space by iteratively calling fastInterceptFinder2d |
| CROICalculator | Findlet to calculate ROI on the PXD sensors based on input hits |
| CSVDShaperDigitConverter | Findlet for converting SVDShaperDigits into DATCONSVDDigits |
| CToPXDExtrapolator | Findlet to extrapolate found tracks to the PXD sensors and calculate intercepts |
| CCKFParameters | The payload containing all parameters for the PXD and SVD CKF |
| CDAFparameters | The payload containing the DAF parameters |
| CROICalculationParameters | The payload containing all PXD ROI parameters |
| CTrackFitMomentumRange | The payload containing the momentum threshold to disable the particle hypothesis in the track fit |
| CTrackFlippingCuts | The payload containing the cuts for 2 mva based filters to decide whether a RecoTrack should be flipped or not |
| CTrackingMVAFilterParameters | Class for the MVA filter payloads |
| CDQMEventProcessorBase | The purpose of this class is to process one event() in DQMHistoModuleBase, which is a base for TrackDQMModule and AlignDQMModule |
| CDQMHistoModuleBase | This class serves as a base for the TrackDQMModule and AlignDQMModule (and possibly other DQM histogram modules) |
| CBaseEventTimeExtractor | Class to extract the event t0 |
| CBaseEventTimeExtractorModuleFindlet | Base class for most of the time extraction modules doing a track selection beforehand |
| CChi2BasedEventTimeExtractor | Event time extraction based on the principle of arXiv:0810.2241 |
| CDriftLengthBasedEventTimeExtractor | Event time extraction based on the principle of the CDC drift time calculation |
| CFullGridChi2TrackTimeExtractor | Class to extract the event t0 using the chi-squared approach |
| CFullGridDriftLengthTrackTimeExtractor | Class to extract the event t0 using the drift-length approach |
| CGridEventTimeExtractor | Generic findlet applying a certain time extractor multiple times |
| CHitBasedT0Extractor | Findlet to extract the T0 time of an event only using CDC Hits |
| 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 |
| CTrackSelector | Select the tracks for the event time extraction |
| CTimeExtractionUtils | Helper class to perform all kind of track extrapolations using the methods from arXiv:0810.2241 |
| CTrackMatchLookUp | Class to provide convenient methods to look up matching information between pattern recognition and Monte Carlo tracks |
| CBeamSpotCollectorModule | This collects the track parameters of the mu+mu- events for calibration of the BeamSpot using CAF and AirFlow |
| CBoostVectorCollectorModule | This collects the track parameters and momenta of the mu+mu- events for calibration of the BoostVector using CAF and AirFlow |
| CCDCToSVDSpacePointCKFModule | Combinatorical Kalman Filter used for extrapolating CDC tracks into SVD and create merged tracks |
| CCDCToSVDSeedCKFModule | Seed-finding combinatorical Kalman Filter that combines every RecoTrack with every SVD track, then filters the combinations |
| CToPXDCKFModule | Combinatorical Kalman Filter that extrapolates every RecoTrack into the PXD and collects space points |
| CToCDCCKFModule | Combinatorical Kalman Filter that extrapolates every RecoTrack into the CDC and collects wire hits |
| CToCDCFromEclCKFModule | Combinatorical Kalman Filter that extrapolates every ECLShower into the CDC and collects wire hits |
| 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 |
| CPhiRecoTrackRelationFilter | Relation filter that lets only possibilities with small phi distance pass |
| CDATCONModule | DATCON module which implementation is close to the one actually used on the FPGA |
| CEcmsCollectorModule | Collector for the collision energy calibration based on the hadronic modes |
| CSVDEventT0EstimatorModule | This module estimates the EventT0 as the average of cluster time of SVD clusters associated to tracks |
| CDriftLengthBasedT0ExtractorModule | Module implementation using only the drift lengths |
| CChi2BasedT0ExtractorModule | Module implementation using only the chi2 |
| CFullGridChi2TrackTimeExtractorModule | Module implementation using only the chi2 |
| CFullGridDriftLengthTrackTimeExtractorModule | Module implementation using the drift length and the chi2 |
| CCDCHitBasedT0ExtractionModule | Module implementation using the CDCHitBasedT0Extractor |
| CExtModule | The geant4e-based track extrapolation module |
| CBaseRecoFitterModule | A base class for all modules that implement a fitter for reco tracks |
| CDAFRecoFitterModule | DAF fitter |
| CFittedTracksStorerModule | A module to copy only the fitted reco tracks to the output store array |
| CKalmanRecoFitterModule | Kalman fitter |
| CRecoTrackCreatorModule | Module turning trackCands to reco tracks (will be unneeded once we create reco tracks from the beginning) |
| CBaseTrackTimeEstimatorModule | Base Module estimating the track time of RecoTracks - before or after the fit |
| CIPTrackTimeEstimatorModule | Base Module estimating the track time of RecoTracks - before or after the fit |
| CPlaneTriggerTrackTimeEstimatorModule | Module estimating the track time of RecoTracks - before or after the fit |
| CRadiusTrackTimeEstimatorModule | Module estimating the track time of RecoTracks - before or after the fit |
| 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 |
| CRegisterEventLevelTrackingInfoModule | Module to create the EventLevelTrackingInfo that is used to set general tracking-related flags |
| CGeant4MaterialInterface | AbsMaterialInterface implementation for use with Geant4's navigator |
| CSetupGenfitExtrapolationModule | Setup material handling and magnetic fields for use by genfit's extrapolation code (RKTrackRep) |
| CGeant4MaterialInterfaceExceptioHandler | This class implements a custom exception handler for Geant4 which is used to record whether a critical exception occurred when calling the G4Navigator |
| CG4SafeNavigator | Guards against leaving the physical volume |
| CGenfitVisModule | Visualize genfit::Tracks using the genfit::EventDisplay |
| CBeamSpotMonitorModule | Module for the monitoring of the BeamSpot position and size |
| CChi2MCTrackMatcherModule | Monte Carlo matcher using the helix parameters for matching by chi2-method |
| 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 |
| CMCV0MatcherModule | A module matching the V0s from the mcV0Matcher to MC particles |
| CTrackToMCParticleRelatorModule | A module to set relations from Track to MCParticle via the RecoTrack the Track is related to |
| CMCTrackCandClassifierModule | The MCTrackCandClassifier Definition Module |
| CMuidModule | The geant4e-based muon identification module |
| CPruneGenfitTracksModule | Module to prune genfit::Tracks |
| CPruneRecoHitsModule | Module to prune RecoTracks |
| CPruneRecoTracksModule | Module to prune RecoTracks |
| CMCSlowPionPXDROICreatorModule | The MCSlowPionPXDROICreatorModule module Create artificial ROI just for PXDDigits from slow pions from D* decays on MC information |
| CPXDclusterFilterModule | The module produce a StoreArray of PXDCluster inside the ROIs |
| CPXDdigiFilterModule | The module produce a StoreArray of PXDDigit inside the ROIs, thus simulating "ONSEN" ROI selection |
| CPXDRawHitFilterModule | The module produce a StoreArray of PXDRawHit inside the ROIs |
| CPXDROIFinderAnalysisModule | The PXD Data Reduction Analysis Module |
| CPXDROIFinderModule | The PXD ROI Finder Module |
| ►CROIDQMModule | The HLT ROI DQM module |
| CROIHistoAccumulateAndFill | Struct: histograms to be filled once per event + filling fucntion + accumulate function |
| CROIGeneratorModule | The ROI generator Module |
| CROIPayloadAssemblerModule | The ROI Payload Assembler Module |
| CROIReadTestModule | The ROI to ONSEN Module |
| CROISenderModule | The ROI to ONSEN Module |
| CPXDSVDCutModule | The module to deactivate the SpacePointTrackCandidates with less than minSVDSPs SVD SpacePoints |
| CRecoTrackParticleLoaderModule | Takes fitted RecoTracks and creates Particles from them directly, skipping the step of creating Tracks and TrackFitResults |
| CRecoTracksCopierModule | Module to copy RecoTracks |
| CRecoTracksReverterModule | Module to revert RecoTracks |
| CCDCCKFTracksCombinerModule | Module to combine RecoTracks |
| CMCRelationCreatorModule | Module to combine RecoTracks |
| CRecoTrackStoreArrayCombinerModule | Module to combine RecoTracks |
| CRelatedTracksCombinerModule | Module to combine RecoTracks |
| ►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 |
| CGFTC2SPTCConverterModule | Module for converting genfit::TrackCands to SpacePointTrackCands |
| ►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 |
| CRT2SPTCConverterModule | Module for converting RecoTracks to SpacePointTrackCands |
| CTrueHitInfo | Helper struct that holds information that is needed for the registration of the relation between SpacePoint and TrueHit |
| ►CSpacePoint2TrueHitConnectorModule | Module that tries to register a relation between SpacePoints and TrueHits, hence making some MC Information easily accesible for other modules working with SpacePoints (e.g |
| CRootVariables | Helper struct to access root variables inside the module |
| 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! |
| CSpacePointCreatorTestModule | Tester module for the validity of the SpacePointCreatorModule |
| CSPTC2GFTCConverterModule | Module for converting SpacePointTrackCands to genfit::SpacePointTrackCands |
| 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) |
| CSPTCvirtualIPRemoverModule | A module for checking and removing the virtual IP if wanted |
| CTCConvertersTestModule | Module for testing if the converting Modules do their job as intened |
| CParticleProperties | This struct is used by the StandardTrackingPerformanceModule to save information of reconstructed tracks |
| 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 |
| ►CSVDROIDQMModule | Creates basic DQM for ROI creation on ExpressReco |
| CROIHistoAccumulateAndFill | Struct: histograms to be filled once per event + filling fucntion + 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 |
| CSVDShaperDigitFilterModule | The module produce a StoreArray of SVDShaperDigit inside the ROIs |
| 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 |
| CParallelTrackFilterModule | Generates a new StoreArray from the input StoreArray which contains only tracks that meet the specified criteria |
| 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 |
| CCollectorTestModule | CollectorTestModules |
| CStudyMaterialEffectsModule | StudyMaterialEffectsModule |
| 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 |
| CTrackingAbortDQMModule | Tracking DQM Module to monitor aborts & background conditions before the HLT filter |
| CTrackingExpressRecoDQMModule | Tracking ExpressReco DQM |
| CTrackingHLTDQMModule | Tracking HLT DQM |
| 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 |
| 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 |
| CHitXPModule | This module from a data root file builds a tree of hitXP (see the class to know all the informations contained) |
| 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 recongnition algorithms |
| 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 recongnition algorithms |
| 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 |
| 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) |
| CAddVXDTrackCandidateSubSetsModule | Module that creates additional candidates that each miss a different SpacePoint |
| 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 |
| CSVDOverlapResolverModule | SVD overlap resolver module |
| CTrackSetEvaluatorGreedyDEVModule | The Greedy algoritm Track-set-evaluator |
| CTrackSetEvaluatorHopfieldNNDEVModule | The Hopfield algoritm Trackset Evaluator |
| CVXDTrackCandidatesQualityIndicatorCutterModule | Module that selects a subset with a fixed minimum qualityIndicator out of all SpacePointTrackCandidates |
| CTrackTimeEstimatorModule | Computes the track time, defined as the difference between the average of SVD clusters time and the SVDEvent T0 |
| CV0FinderModule | V0 finder module |
| 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 |
| CStoreArrayMerger | This findlet has helper function to |
| CVXDCDCTrackMergerModule | VXDCDCTrackMergerModule a module to merge VXD and CDC tracks |
| CSVDHoughTrackingModule | Full Hough Transformation based SVD track finding |
| COverlapResidualsModule | The module studies VXD hits from overlapping sensors of a same VXD layer |
| CRawSecMapMergerModule | The RawSecMapMergerModule |
| 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 |
| CSecMapTrainerVXDTFModule | The SecMapTrainerVXDTFModule this module analyzes a big number of events (pGun or evtGen) to create raw sectorMaps which are needed for the VXDTF |
| CVXDSimpleClusterizerModule | Module to convert TrueHits into Clusters using a simplified process |
| CQualityEstimatorVXDModule | Quality estimation module for SpacePointTrackCandidates |
| 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) |
| CFastBDTClassifierAnalyzerModule | Module to evaluate a trained fastBDT |
| CFastBDTClassifierTrainingModule | Module for collecting the data and training a FastBDT classifier |
| CMLSegmentNetworkProducerModule | Segment network producer module with a Machine Learning classifier |
| CNoKickCutsEvalModule | This module evaluate the cuts used to select the training sample of the SectorMap |
| 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 |
| ►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 |
| CSPTC2RTConverterModule | Module turning SpacePointsTrackCands to RecoTracks |
| 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 |
| CVXDTFTrainingDataCollectorModule | The VXDTFTrainingDataCollectorModule |
| CPXDInterceptor | Fills a StoreArray of PXDIntercepts that will be used to define the PXD ROIs |
| CROIDetPlane | ROIDetPlane describes the plane containing a sensor |
| CROIGeometry | This class appends the PXDIntercept infos of a track to the list of intercepts |
| CROIPixelTranslator | Translator for ROI-geometry-information into a list of pixels |
| CMCVXDPurityInfo | The MC VXD Purity info container class |
| CSpacePoint | SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters |
| CSpacePointTrackCand | Storage for (VXD) SpacePoint-based track candidates |
| CMapHelperFunctionsTest | Function object that implements cosecans(x) == 1/cos(x) by tan(x) / sin(x) |
| CSpacePointTest | Set up a few arrays and objects in the datastore |
| CSpacePointTrackCandTest | Test class for the SpacePointTrackCand class |
| CROIStripTranslator | Translator for ROI-geometry-information into a list of pixels |
| CSVDInterceptor | This Class implements the interceptor of the SVD tracks on the PXD layers |
| CSVDROIGeometry | This class appends the SVDIntercept infos of a track to the list of intercepts |
| CRecoTrackTest | Test class for the RecoTrack object |
| CCollectorTFInfoTest | Set up a few arrays and objects in the datastore |
| CFilterIDTest | Set up a few arrays and objects in the datastore |
| CFullSecIDTest | Testing everything from FullSecID |
| CVerbosityClass | Should behave differently for different verbosity-levels given - class |
| CSandBox4TestingTest | Testing autoAssignment of vectors for functions |
| CSectorTest | Set up a few arrays and objects in the datastore |
| CThreeHitFiltersTest | Set up a few arrays and objects in the datastore |
| CTwoHitFiltersTest | Set up a few arrays and objects in the datastore |
| CExtState | Data structure to define extrapolation state |
| CIntersection | Intersection of muid-extrapolated track with a KLM layer |
| CTrackExtrapolateG4e | Geant4e-based track extrapolation |
| CCALogger | Simple logger for CA algorithm |
| CCAValidator | Validation tool for CA algorithm |
| CCellularAutomaton | The CellularAutomaton class This class serves as a functor for the algorithm itself |
| 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) |
| CNodeFamilyDefiner | This class assigns a common family identifier to all CACells in the network that are connected |
| CPathCollectorRecursive | Path finder for generic ContainerType |
| CSPTCSelectorXBestPerFamily | Algorithm to collect the x best TrackCandidates per family based on a VXD Quality estimator method output |
| CStandaloneCosmicsCollector | Track finding algorithm class for linear tracks produced by cosmics in the VXD without magnetic field |
| CTrackerAlgorithmBase | Base class for TrackerAlgorithms. shall allow a common base for algorithms like the cellular automaton |
| ►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 |
| CAnalyzingAlgorithmLostVClusters | Class for storing an algorithm to find out how many v-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 |
| CAnalyzingAlgorithmLostVEDep | Class for storing an algorithm to find out the energy deposit of v-type-clusters the testTC lost compared to the refTC |
| CAnalyzingAlgorithmTotalUClusters | Class for storing an algorithm to find out how many 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 |
| CAnalyzingAlgorithmTotalUEDep | Class for storing an algorithm to find out the energy deposit of u-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 |
| 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 |
| CAnalyzingAlgorithmResidualPT | Class for storing an algorithm determining the residual (ref-test) of momentum in pT |
| CAnalyzingAlgorithmResidualP | Class for storing an algorithm determining the residual (ref-test) of momentum in |p| |
| CAnalyzingAlgorithmResidualPTheta | Class for storing an algorithm determining the residual (ref-test) of momentum in theta (in degrees) |
| CAnalyzingAlgorithmResidualPPhi | Class for storing an algorithm determining the residual (ref-test) of momentum in phi (in degrees) |
| CAnalyzingAlgorithmResidualPAngle | Class for storing an algorithm determining the residual (ref-test) of momentum in its angle (direction residual in degrees) |
| CAnalyzingAlgorithmResidualPTAngle | Class for storing an algorithm determining the residual (ref-test) of pT in angle (transverse 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) |
| 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 |
| CAnalyzingAlgorithmValuePT | Class for storing an algorithm determining the momentum in pT |
| CAnalyzingAlgorithmValueP | Class for storing an algorithm determining the momentum in |p| |
| CAnalyzingAlgorithmValuePTheta | Class for storing an algorithm determining the momentum in theta (in degrees) |
| CAnalyzingAlgorithmValuePPhi | Class for storing an algorithm determining the momentum in phi (in degrees) |
| 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) |
| CAnalyzingAlgorithmValueQI | Class for storing an algorithm determining the quality indicator of the TC |
| CAlgoritmType | Small class for classifying types of analyzing algorithms |
| CAnalizerTCInfo | Simple class storing infos relevant for a TC for analizing it |
| CKeyValBox | Minimal container storing a pair of < KeyType, ValueType> |
| CRootParameterTracker | Production notes for RootParameterTracker: |
| CTCType | Small class for classifying types of reconstructed track candidates |
| CVXDTFFilters | Class that contains all the static sectors to which the filters are attached |
| 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 |
| CFilter | This class is used to select pairs, triplets.. |
| 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< > | 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 |
| CFilter< Variable, RangeType, Observer > | Basic Filter /// |
| CFilter< Variable, RangeType, Belle2::BypassableFilter, Observer > | Bypassable Filter /// |
| CFilter< Variable, RangeType, Belle2::ActivatableFilter, Observer > | Activatable Filter /// TODO: Remove, as it is no longer used...? |
| CFilter< Belle2::OperatorNot, someFilter, templateObserverType > | Realization of a NOT operator for the Filter classes |
| CFilter< Belle2::OperatorAnd, FilterA, FilterB, templateObserverType > | Realization of the AND operator between two objects of the Filter class |
| CFilter< Belle2::OperatorOr, FilterA, FilterB, templateObserverType > | Realization of the OR operator between two objects of the Filter class |
| CLowerBoundedSet | Represents a lower bounded set of arithmetic types |
| CObserver | Observer base class which can be used to evaluate the VXDTF2's Filters |
| CRange | Represents a range of arithmetic types |
| ►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 |
| CSingleElementSet | Represents a set containing a single element; |
| CUpperBoundedSet | Represents an upper bounded set of arithmetic types |
| CVoidObserver | The most CPU efficient Observer for the VXDTF filter tools (even if useless) |
| 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 |
| CCompactSecIDs | This class provides a computer convenient numbering scheme for the sectors in the sector map and for the N sectors combinations |
| CFiltersContainer | This class contains everything needed by the VXDTF that is not going to change during a RUN, i.e |
| CSectorsOnSensor | This class associates to an ordered pairs of normalized local coordinates a compact sector id |
| 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 |
| 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 |
| 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): |
| 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 |
| CDISTANCEINTIME | This variable returns the difference among the V and U side clusters of th ecenter space point |
| CHELIXPARAMETERFIT_NAME | Calculates the helixparameter describing the deviation in z per unit angle, returning unit: none |
| CMLHANDOVER_NAME | SelectionVariable that is used for the Machine Learning (ML) based filters |
| CPT_NAME | Calculates the estimation of the transverse momentum of the 3-hit-tracklet, returning unit: GeV/c |
| CSIGNCURVATUREXY_NAME | Calculates the sign of the curvature for three hits |
| CSIGNCURVATUREXYERROR_NAME | Calculates the sign of the curvature for three hits |
| 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) |
| CVariablesTTree | Dump on a TTree the values of all the variables in a filter |
| CVariablesTTree<> | Defines the interface using an empty template pack |
| CVariablesTTree< Filter< Variable, other ... > > | Specialization for a simple filter |
| CVariablesTTree< Filter< unaryOperator, Filter< args ... >, other ... > > | Specialization for unary operators acting on a filter |
| CVariablesTTree< Filter< binaryOperator, Filter< argsA ... >, Filter< argsB ... >, other ... > > | Specialization for binary operators acting on a filter |
| CVariableTBranch | This class contains |
| CVariablesOnTTree | Test for VariablesTTree |
| 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 |
| 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 |
| 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 |
| 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 |
| CDecorrelationMatrix | Class holding a Matrix that can be used to decorrelate input data to Machine Learning classifiers |
| CFBDTClassifier | FastBDT as RelationsObject to make it storeable and accesible on/via the DataStore |
| CFBDTTrainSample | Bundle together the classifier input and the target value into one struct for easier passing around |
| CMLRange | Range used for the Machine Learning assisted TrackFinding approach |
| 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 |
| 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) |
| CSelectionVariableFactory | The factory,as the name implies, does not implement at all the factory paradigm |
| CSelVarHelper | Collection of functions and related stuff needed for SelectionVariables implementing 2-, 3- and 4-hitfilters |
| CMVAExpert | Class to interact with the MVA package, based on class with same name in CDC package |
| CActivatedSector | ActivatedSector is carrying the dynamic part of a Sector |
| CBranchInterface | Simple struct for interfacing the Branch |
| ►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 |
| CSecIDPair | Allows to set outer and inner secID |
| CSecIDTriplet | Allows to set outer, center and inner secID |
| CSecIDQuadruplet | Allows to set outer, outerCenter, innerCenter and inner secID |
| CFilterValueDataSet | Relevant information needed for filling a TTree containing train-data for the secMap |
| 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 |
| CNoKickCuts | This class is an auxiliary class that implement methods to access to a single cut, used in NoKickRTSel class |
| CNoKickRTSel | This class implement some methods useful for the application of cuts evaluated in NoKickCutsEval module |
| CRawDataCollectedMinMax | Takes care of collecting raw data and staying below RAM-threshold |
| CRawSecMapRootInterface | To be used as an interface to root-stuff |
| CSecMapTrainer | This class contains all relevant tools for training a VXDTFFilters |
| CSecMapTrainerHit | Simple Hit class used for sectorMap-training |
| CSecMapTrainerTC | Simple Hit class used for sectorMap-training |
| 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 |
| CSectorMapComparer | A root tool that compares two Sectormaps (local root files) and produces some statistics output |
| 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 |
| CActiveSector | The ActiveSector Class |
| CCACell | The CACell class This Class stores all relevant information one wants to have stored in a cell for a Cellular automaton |
| CDirectedNode | The Node-Class |
| CDirectedNodeNetwork | Network of directed nodes of the type EntryType |
| CDirectedNodeNetworkContainer | The Container stores the output produced by the SegmentNetworkProducerModule |
| CSegment | The Segment class This class represents segments of track candidates needed for TrackFinderVXD-Modules |
| CStaticSector | Class to describe a static sector of the sector map |
| CTrackNode | Minimal class to store combination of sector and spacePoint, since SpacePoint can not carry sectorConnection |
| CVoidMetaInfo | The most CPU efficient MetaInfo for the DirectedNode-requirements (even if useless) |
| CSpacePointTrackCandCreator | Small class to take simple vectors of SpacePoints and convert them to real SpacePointTrackCands |
| 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 |
| CAlwaysYesFilter | AlwaysYesFilter is a simple filter saying always yes, which is meant for testing purposes |
| CFilterBase | FilterBase is the baseClass for filters applied on (chains of) spacepoints |
| CHopfieldNetwork | Hopfield Algorithm with number based inputs |
| COverlapMatrixCreator | Creates a vector of vectors, that knows which track is conflicting with which other |
| COverlapNetwork | Hold information about overlap of SpacePointTrackCand |
| COverlapResolverNodeInfo | Struct for holding information needed by overlap resolving algorithms for one node |
| CScrooge | Executes greedy algorithm for vector of QITrackOverlap structs |
| CNamed | A mixin class to attach a name to an object. Based on class with same name in CDC package |
| CClusterInfoExtractor | Class to extract info from individual clusters and combine for SPTC |
| CQEResultsExtractor | Class to extract results from qualityEstimation |
| CSimpleVariableRecorder | Class to write collected variables into a root file, Used by VXDQETrainingDataCollectorModule |
| CVariableExtractor | Class to extract individual variables |
| CTrackFitter | Algorithm class to handle the fitting of RecoTrack objects |
| CMeasurementAdder | Algorithm class to translate the added detector hits (e.g |
| 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 |
| CCoordinateMeasurementCreator | A measurement creator for normal coordinate measurements out of cdc/svd/pxd hits |
| CVXDMomentumEstimationMeasurementCreator | Creator for VXDMeasurements with momentum estimation based on the dEdX information |
| CAdditionalMeasurementCreatorFactory | Add measurement creators that do not rely on a specific hit type, but rather add measurements without corresponding hit |
| CBKLMMeasurementCreatorFactory | Add all measurement creators related to BKLM hits |
| CCDCMeasurementCreatorFactory | Add all measurement creators related to CDC hits |
| CEKLMMeasurementCreatorFactory | Add all measurement creators related to EKLM hits |
| CMeasurementCreatorFactory | This is the base class for all MeasurementCreatorFactories used in the MeasurementCreatorModule |
| CPXDMeasurementCreatorFactory | Add all measurement creators related to PXD hits |
| CSVDMeasurementCreatorFactory | Add all measurement creators related to SVD hits |
| CHMatrixQP | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| 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) |
| CTrackBuilder | TrackBuilder class to create the Track/TrackFitResult mdst output from the RecoTrack |
| CEventInfoExtractor | Class to extract results from qualityEstimation |
| CFlipRecoTrackExtractor2nd | Class to extract results from qualityEstimation |
| CFlipRecoTrackExtractor | Class to extract results from qualityEstimation |
| CHitInfoExtractor | Class to extract info from individual clusters and combine for SPTC |
| CRecoTrackExtractor | Class to extract results from qualityEstimation |
| CSubRecoTrackExtractor | Class to extract results from qualityEstimation |
| CVertexVector | Need this container for exception-safe cleanup, GFRave's interface isn't exception-safe as is |
| ►CNewV0Fitter | Improved V0 fitter class |
| CFittedTrack | Structure to save track data of the last successful iteration |
| CV0Fitter | V0Fitter class to create V0 mdst's from reconstructed tracks |
| CV0FitterTest | Set up a few arrays and objects in the datastore |
| 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) |
| CFilterExceptions | Exception which are thrown by members of the FilterClasses |
| CFourHitFilters | The class 'FourHitFilters' bundles filter methods using 4 hits which are stored in B2Vector3Ds |
| CGlobalNames | Bundles filter methods using 2 hits |
| CThreeHitFilters | The class 'ThreeHitFilters' bundles filter methods using 3 hits which are stored in B2Vector3Ds |
| CTwoHitFilters | The class 'TwoHitFilters' bundles filter methods using 2 hits which are stored in B2Vector3Ds |
| 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 |
| ►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 |
| CVXDMomentumEstimationTools | Tools needed for the VXD momentum estimation to, e.g |
| CBitstream | Class to hold one clock cycle of raw bit content |
| CCDCTriggerFinderClone | Additional information from the 2D finder unpacker of the CDC trigger |
| CCDCTriggerHoughCluster | Cluster created by the Hough finder of the CDC trigger |
| 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 |
| CCDCTriggerSegmentHit | Combination of several CDCHits to a track segment hit for the trigger |
| CCDCTriggerTrack | Track created by the CDC trigger |
| CTRGCDCETFUnpackerStore | Example Detector |
| CTRGCDCT3DUnpackerStore | Example Detector |
| CTRGCDCTSFUnpackerStore | Example Detector |
| CCDCTrigger2DConfig | The payload class for delay of GDL input bit |
| CCDCTriggerDeadch | The payload class for delay of GDL input bit |
| ►CCDCTriggerNeuroConfig | The payload class for all CDC Neurotrigger information |
| CB2FormatLine | |
| 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 |
| Cclusterer_params | |
| CSimpleCluster | Type for found clusters |
| CClusterizend | Clustering module |
| 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 |
| Ccellweight | |
| CNDFinderTrack | Store track parameters of found tracks |
| ►CNDFinder | Class to represent the CDC NDFinder |
| Cndparameters | Struct of ndFinder parameters |
| Cndbinning | Default binning in a (7/32) phi-sector |
| ►CNeuroTrigger | Class to represent the CDC Neurotrigger |
| CParameters | Struct to keep neurotrigger parameters |
| CNNTParam | Class to represent a complete set to describe a Neurotrigger |
| CNeuroTriggerParameters | |
| CTRGOpticalLinkFrontEnd | A class to represent a serial link between trigger modules |
| 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 |
| 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 |
| CTRGCDC | The instance of TRGCDC is a singleton |
| CTRGCDCTrack | A class to represent a reconstructed charged track in TRGCDC |
| 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 |
| ►CCDCTriggerNeuroDQMModule | CDC Trigger DQM Module |
| CTSLine | |
| CCDCTrigger2DFitterModule | Module for the 2D Fitter of the CDC trigger |
| CCDCTrigger3DFitterModule | Module for the 3D Fitter of the CDC trigger |
| CCDCTriggerHoughCand | Hough Candidates class |
| CCDCTriggerHoughETFModule | |
| CCDCTrigger2DFinderModule | |
| CCDCTriggerMCMatcherModule | A module to match CDCTriggerTracks to MCParticles |
| CCDCTriggerRecoHitMatcherModule | A module to match CDCTriggerTracks to RecoTracks |
| CCDCTriggerRecoMatcherModule | A module to match CDCTriggerTracks to RecoTracks |
| CCDCTriggerNDFinderModule | CDC Trigger NDFinder Module |
| CCDCTriggerNeuroDataModule | |
| CCDCTriggerNeuroIDHistModule | Description |
| CCDCTriggerNeuroModule | The neural network module of the CDC trigger |
| CCDCTriggerETFModule | Module for the Event Time Finder of the CDC trigger |
| CCDCTriggerTrackCombinerModule | Module to combine the information from the various track trigger stages |
| 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 |
| CTRGCDCModule | A module to simulate the CDC trigger |
| CTRGCDCT2DDQMModule | DQM module of TRGCDCT2D |
| CTRGCDCT3DDQMModule | DQM module for TRGCDCT3D |
| CTRGCDCTSFDQMModule | DQM module of TRGCDCTSF |
| CTRGCDCTSStreamModule | A module to process CDC trigger data |
| CSubTrigger | Enum class SubTriggerType : unsigned char {Merger, TSF, T2D, T3D, Neuro, ETF}; |
| CCDCTriggerUnpackerModule | Unpack the trigger data recorded in B2L |
| CMerger | Unpacker for the merger reader (TSF which reads the merger output) |
| CTracker2D | Unpacker for the 2D tracker |
| CNeuro | Unpacker for the Neuro |
| CTRGECLBGTCHit | Example Detector |
| CTRGECLCluster | Example Detector |
| CTRGECLDigi | Digitize result |
| CTRGECLDigi0 | Raw TC result nefor digitizing |
| CTRGECLDigi0MC | Example Detector |
| CTRGECLFAMAna | Digitize result |
| CTRGECLHit | Example Detector |
| CTRGECLHitMC | Example Detector |
| CTRGECLTiming | Digitize result |
| CTRGECLTrg | Example Detector |
| CTRGECLUnpackerEvtStore | Example Detector |
| CTRGECLUnpackerStore | Example Detector |
| CTRGECLUnpackerSumStore | Example Detector |
| CTRGECLWaveform | Digitize result |
| CTRGECLBadRun | Raw TC result nefor digitizing |
| CTrgEclDatabaseImporter | Database importer of TRGECL |
| CTRGECLETMPara | Raw TC result nefor digitizing |
| CTRGECLFAMPara | Raw TC result nefor digitizing |
| CTRGECLTMMPara | Raw TC result nefor digitizing |
| CTrgEclBeamBKG | A Class of ECL Trigger clustering |
| CTrgEclBhabha | A Class of ECL Trigger clustering |
| CTrgEclCluster | A Class of ECL Trigger clustering |
| CTrgEclDataBase | Class TrgEclDataBase; |
| CTrgEclDigitizer | FAM module |
| CTrgEclFAMFit | FAM module |
| CTrgEclMapping | A class of TC Mapping |
| CTrgEclMaster | ETM class |
| CTrgEclTiming | A Class of ECL Trigger clustering |
| CMCMatcherTRGECLModule | Class to represent the hit of one cell |
| CTRGECLFAMModule | A module of FAM |
| CTRGECLModule | A module of ETM |
| CTRGECLBGTCHitModule | |
| CTRGECLDQMModule | |
| CTRGECLEventTimingDQMModule | This module is for ecl trigger DQM related to L1 event timing |
| CTRGECLQAMModule | |
| CTRGECLRawdataAnalysisModule | A module of ETM |
| CTRGECLTimingCalModule | Class ECL Trigger Timiing Calibration Module |
| CTRGECLUnpackerModule | A module of TRG ECL Unpacker |
| CTRGGDLDST | |
| CTRGGDLResults | |
| CTRGGDLUnpackerStore | Example Detector |
| CTRGGDLDBAlgs | The payload class for GDL algorithm |
| CTRGGDLDBDelay | The payload class for delay of GDL input bit |
| CTRGGDLDBUnpacker | The payload class for PXD cluster charge calibrations |
| ►CTrgBit | A general interface to get a trigger response |
| CInputBitPattern | Input bit pattern class |
| COutputBitPattern | Output bit pattern class |
| CTRGGDL | The instance of TRGGDL is a singleton |
| CTRGGDLCosmicRunModule | Module that returns true if the trigger condition for the 2017 cosmic runs is fulfilled |
| CTRGGDLModule | A module to simulate the Global Decision Logic |
| CTRGGDLDQMModule | |
| CTRGGDLDSTModule | |
| CTRGGDLSummaryModule | |
| 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 |
| CTRGGRLInfo | Class to store TRGGRL TSIM info |
| CTRGGRLInnerTrack | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLMATCH | Class for CDC2D-ECL Matching in TRGGRL |
| CTRGGRLMATCHKLM | Class for CDC2D-KLM Matching in TRGGRL |
| CTRGGRLPHOTON | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLShortTrack | Class for neutral ECL cluster in TRGGRL |
| CTRGGRLUnpackerStore | Example Detector |
| ►CGRLNeuro | Class to represent the GRL Neuro |
| CParameters | Struct to keep neurotrigger parameters |
| CTRGGRL | Class for TRGGRL |
| CTRGGRLMatch | A class to represent a matching candidate in TRGGRL A matching candidate consists of a TRGCDCTrack and TRGECLCluster |
| CTRGGRLMatchModule | Match between CDC trigger track and ECL trigger cluster |
| CTRGGRLModule | A module to simulate the Global Decision Logic |
| CTRGGRLProjectsModule | A module to simulate the Global Decision Logic |
| CTRGGRLDQMModule | |
| CGRLNeuroModule | The module for application of the neural networks of the GRL |
| CGRLNeuroTrainerModule | The trainer module for the neural networks of the CDC trigger |
| CKLMTrgFittedTrack | Store KLM TRG track information as a ROOT object |
| CKLMTrgSummary | Store KLM TRG track information as a ROOT object |
| CKLMTriggerHit | Store KLM TRG hit information as a ROOT object |
| CKLMTriggerTrack | Store KLM TRG track information as a ROOT object |
| CKLMTriggerParameters | DBObject containing parameters used in KLMTrigger module |
| CKLM_TRG_definitions | |
| ►CKLMTriggerModule | |
| Cgeometry_data | |
| CLinear_fit_of_Hits_t | |
| CTRGTOPCombinedT0Decision | Example Detector |
| CTRGTOPSlotTiming | Example Detector |
| CTRGTOPTimeStamp | Example Detector |
| CTRGTOPTimeStampsSlot | Example Detector |
| CTRGTOPTimingISim | Example Detector |
| CTRGTOPTimingISimSlot | Example Detector |
| CTRGTOPUnpackerStore | Example Detector |
| CTRGTOPWaveFormTimeStamp | Example Detector |
| CTRGTOPWaveFormTimeStampsSlot | Example Detector |
| ►CTRGTOPDQMModule | |
| ClargestEnergy | |
| ClargestNHits | |
| CslotDecision | |
| CtcEcl | |
| ►CTRGTOPTRD2TTSConverterModule | TRG TOP Raw Digits to TimeStamps Converter |
| CinterimTimeStamp | Event number (according to L1/global) |
| CtimeOrder | |
| CTRGTOPUnpackerModule | TRG TOP Unpacker |
| CTRGTOPUnpackerWaveformModule | TRG TOP Unpacker for Timestamps |
| CTRGTOPWaveformPlotterModule | |
| CTRGTiming | Trigger Timing Information for a fired bit |
| CTRGArea2D | A class to represent an 2D area |
| CTRGBitStream | A class to represent a bit stream |
| CTRGBoard | A class to represent a trigger board |
| 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 |
| CTRGOpticalLink | A class to represent a serial link between trigger modules |
| CTRGPoint2D | A class to represent a point in 2D |
| 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 |
| CTRGTime | A class to represent a signal timing in the trigger system |
| CTRGUtilities | A class to provide TRG utility functions |
| CTRGRAWDATAModule | |
| CVXDElectronDeposit | Packed class to represent energy deposit along a path in electrons |
| CVxdID | Class to uniquely identify a any structure of the PXD and SVD |
| CVXDSimHit | Class VXDSimHit - Geant4 simulated hit for the VXD |
| CVXDTrueHit | Class VXDTrueHit - Records of tracks that either enter or leave the sensitive volume |
| CHeavyMetalShieldGeometryPar | The Class for VXD Heavy Metal Shield |
| CVXDAlignmentPar | The Class for VXD Alignment payload |
| CVXDEnvelopePar | The Class for VXD Envelope parameters |
| CVXDGeoComponentPar | The Class for VXD geometry component |
| CVXDGeoLadderPar | The Class for VXD Ladder payload |
| CVXDGeometryPar | The Class for VXD geometry |
| CVXDGeoPlacementPar | The Class for VXD placement payload |
| CVXDGeoRadiationSensorsPositionPar | The Class for VXD Radiation Sensor Position parameters |
| CVXDGeoRadiationSensorsPar | The Class for VXD Radiation Sensor parameters |
| CVXDGeoSensorPar | The Class for VXD Sensor payload |
| CVXDGeoSensorPlacementPar | The Class for VXD Sensor Placement payload |
| CVXDGlobalPar | The Class for VXD global paramter payload |
| CVXDHalfShellPar | The Class for VXD half shell payload |
| CVXDPolyConePlanePar | The Class for VXD Polycone Plane |
| CVXDPolyConePar | The Class for VXD PolyCone, possibly with coutouts |
| CVXDRotationSolidPar | The Class for VXD Envelope parameters |
| CVXDSensorInfoBasePar | Namespace to provide code needed by both Vertex Detectors, PXD and SVD |
| CVXDBoxTypesPar | The Class for VXD doc box |
| CVXDSlotsPar | The Class for Slot types |
| CVXDBoxPositionsPar | The Class for VXD doc box envelope |
| CVXDServiceGeometryPar | The Class for VXD service geometry |
| CVXDGeoPlacement | Class holding all parameters to place a VXD geometry subcomponent |
| CVXDGeoComponent | Class holding all parameters for an VXD geometry component |
| CVXDGeoSensor | Struct holding all parameters for a completeVXD Sensor |
| CVXDGeoSensorPlacement | Struct holding the information where a sensor should be placed inside the ladder |
| CVXDGeoLadder | Struct containing all parameters of one ladder |
| CGeoVXDRadiationSensors | Class to create the diamond radiation sensor geometry if defined |
| CVXDDQMExpressRecoModule | VXD DQM Module |
| CvxdDigitMaskingModule | PXD DQM Module |
| CStepInformation | Simple struct to keep information about steps in the sensitive detector |
| CSensorTraversal | Class to keep track of the traversal of the sensitive volume for one track |
| ►Nbest_candidate_selection | |
| CGenerator | |
| CRankChecker | |
| CNumBestChecker | |
| ►NBHWidePlots | |
| CShowMCParticles | |
| ►Ncaf_cdcdedx | |
| CCDCDedxCalibration | |
| ►Ncdc_and_svd_ckf_merger_mva_training | |
| CGenerateSimTask | |
| CSplitNMergeSimTask | |
| CResultRecordingTask | |
| CCKFResultFilterTeacherTask | |
| CValidationAndOptimisationTask | |
| CMainTask | |
| ►Ncdc_packer_unpacker | |
| CPackerUnpackerTestModule | |
| ►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 | |
| ►NCellularAutomatonTests | These tests cover the functionality of the classes: DirectedNode, DirectedNodeNetwork |
| CCellularAutomatonTest | Test class demonstrating the behavior of The Cellular Automaton and the PathCollectorRecursive |
| ►Nchain_input | |
| CNoopModule | |
| CTestModule | |
| ►NchargeConjugation | |
| CTestParticleCombiner | |
| ►Ncheck_payload_metadata | |
| CCheckPayloadMetadata | |
| ►Ncheck_payload_names | |
| CCheckPayloadNames | |
| ►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 | |
| CClusterFilterValidationRun | |
| CClusterFilterValidationModule | |
| ►Ncolours | |
| Cbcolours | |
| ►Ncombined_cdc_to_svd_ckf_mva_training | |
| CGenerateSimTask | |
| CSplitNMergeSimTask | |
| CStateRecordingTask | |
| CCKFStateFilterTeacherTask | |
| CResultRecordingTask | |
| CCKFResultFilterTeacherTask | |
| CValidationAndOptimisationTask | |
| CMainTask | |
| ►Ncombined_quality_estimator_teacher | |
| CGenerateSimTask | |
| CSplitNMergeSimTask | |
| CCheckExistingFile | |
| CVXDQEDataCollectionTask | |
| CCDCQEDataCollectionTask | |
| CRecoTrackQEDataCollectionTask | |
| CTrackQETeacherBaseTask | |
| CVXDQETeacherTask | |
| CCDCQETeacherTask | |
| CRecoTrackQETeacherTask | |
| CHarvestingValidationBaseTask | |
| CVXDQEHarvestingValidationTask | |
| CCDCQEHarvestingValidationTask | |
| CRecoTrackQEHarvestingValidationTask | |
| CTrackQEEvaluationBaseTask | |
| CVXDTrackQEEvaluationTask | |
| CCDCTrackQEEvaluationTask | |
| CRecoTrackQEEvaluationTask | |
| CPlotsFromHarvestingValidationBaseTask | |
| CVXDQEValidationPlotsTask | |
| CCDCQEValidationPlotsTask | |
| CRecoTrackQEValidationPlotsTask | |
| CQEWeightsLocalDBCreatorTask | |
| CMasterTask | |
| ►Ncombined_to_pxd_ckf_mva_training | |
| CGenerateSimTask | |
| CSplitNMergeSimTask | |
| CStateRecordingTask | |
| CCKFStateFilterTeacherTask | |
| CResultRecordingTask | |
| CCKFResultFilterTeacherTask | |
| CValidationAndOptimisationTask | |
| CMainTask | |
| ►NCombinedSVDTrackingValidation | |
| CCombinedSVDTrackingValidation | |
| ►NCombinedSVDTrackingValidationBkg | |
| CCombinedSVDTrackingValidationBkg | |
| ►Ncompilation_db | |
| C__CompilationDbNode | |
| ►Nconditional_iov | |
| CPrinterModule | |
| ►Nconditions_db | |
| ►Ncli_main | |
| CFullHelpAction | |
| ►Ncli_management | |
| CCommandIoVsHelper | |
| ►Ncli_utils | |
| CItemFilter | |
| ►Niov | |
| CIntervalOfValidity | |
| CIoVSet | |
| ►Nlocal_metadata | |
| CLocalMetadataProvider | |
| ►Nrunningupdate | |
| CRunningTagUpdateMode | |
| CRunningTagUpdaterError | |
| CRunningTagUpdater | |
| ►Ntesting_payloads | |
| CTestingPayloadEntry | |
| CBearerAuth | |
| CPayloadInformation | |
| ►CConditionsDB | |
| CRequestError | |
| ►Ncopylists | |
| CTestCopyLists | |
| ►NcosmicsAxialHoughTrackingValidation | |
| CCosmicsAxialHough | |
| ►NcosmicsHoughTrackingValidation | |
| CCosmicsHough | |
| ►NcosmicsTrackingValidation | |
| CCosmics | |
| ►NCreateProdScripts | |
| CGenericOptionFile | |
| CTextOptionFile | |
| CPythonOptionFile | |
| CEventType | |
| CColoredFormatter | |
| ►NDBImporter | |
| CPayloadImporter | |
| ►NDBImportTBC | |
| CPayloadImporter | |
| ►Ndebug_display | |
| CCDCDebugDisplayRun | |
| ►NdecayHash | |
| CDecayHashMap | |
| ►NdefaultEvaluationParameters | |
| CQuiet | |
| ►Ndft | |
| ►Ntensorflow_dnn_model | |
| CLayer | |
| CMultilayerPerceptron | |
| CDefaultModel | |
| CTrainer | |
| ►NTfData | |
| CTfDataBasf2 | |
| CTfDataBasf2Stub | |
| ►NDirectedNodeNetworkTests | These tests cover the functionality of the classes: DirectedNode, DirectedNodeNetwork |
| CDirectedNodeNetworkTest | Test class demonstrating the behavior of TCNetworkContainer |
| ►Ndisplay | |
| CCDCDisplayRun | |
| ►Ndisplaydata | |
| CDisplayDataTest | |
| ►Ndisplaytriggered | |
| CDisplayHLTTags | |
| ►Ndowhile | |
| CTestDoWhile | |
| ►Ndplot | |
| CPrior | |
| ►Ndqm | |
| CDQM | |
| ►NDumpDigits | |
| CDumpDigits | |
| ►NdumpGeometryParameters | |
| CprintSVDPitches | Test SVD geometry |
| CprintSVDSizes | |
| CprintSVDStripLengths | |
| CprintSVDStripPositions | |
| CprintSVDSensors | |
| CprintSVDLadders | |
| ►NdumpSensorInfoParameters | |
| CprintVelocity | Test SVD SensorInfo getters |
| CprintMobility | |
| ►NdumpSimulationParameters | |
| CprintElectronicNoise | Test SVD SensorInfo getters |
| CprintAduEquivalent | |
| ►Necl_packer_unpacker | |
| CaddECLDigitsModule | |
| CECLPackerUnpackerTestModule | |
| ►NEclShapeFitter | |
| CShapeFitterModule | |
| ►NeclTrackBremFinderTest | |
| CCheckRelationBremClusterTestModule | |
| CSearchForHits | |
| ►Nemptyrelations | |
| CMakeRelations | |
| ►NETF_OldVsNew | |
| CTestModule | |
| ►NevalPriors | |
| CPriors | |
| ►NEventCountLimiter | |
| CEventCountLimiter | |
| ►NEventDisplayer | |
| CEventDisplayer | |
| ►NEventInspector | |
| CEventInspector | |
| ►NEventInspectorLookback | |
| CEventInspectorLookback | |
| ►NEventInspectorPocketDAQ | |
| CEventInspectorPocketDAQ | |
| ►NeventLevelClusteringInfo_countOutOfTime | |
| CaddECLCalDigitsModule | |
| CcheckNumOutOfTimeDigitsModule | |
| ►Neventlimiter | |
| CCountEvents | |
| ►Nevtmetadata | |
| CNoopModule | |
| CEvtMetaDataTest | |
| ►Nfei_examples | |
| CExamplesTest | Extend the examples test class to actually run over the FEI examples: |
| ►Nfirm2d | |
| CSkim | |
| ►NFitter_OldVsNew | |
| CTestModule | |
| ►Nfitting_examples | |
| CExamplesTest | Extend the examples test class to actually run over the fitting examples: |
| ►NfitValidation | |
| CFitValidationModule | |
| CFitValidation | |
| ►Nforeach | |
| CTestModule | |
| ►NfullTrackingTableValidationCreateData | |
| CVxdCdcPartFinderHarvester | |
| ►NfullTrackingValidation | |
| CFull | |
| ►NfullTrackingValidation_plusEclSeeding | |
| CfullTrackingValidation_plusECL | |
| ►NfullTrackingValidation_releaseValidation | |
| CFull | |
| ►NfullTrackingValidationBkg | |
| CFullBkg | |
| ►Ngatgap | |
| CGATModule | |
| CGATGAPModel | |
| ►Ngbl | Namespace for the general broken lines package |
| CBorderedBandMatrix | (Symmetric) Bordered Band Matrix |
| CGblData | Data (block) for independent scalar measurement |
| CGblPoint | Point on trajectory |
| CGblTrajectory | GBL trajectory |
| CMilleBinary | Millepede-II (binary) record |
| CVVector | Simple Vector based on std::vector<double> |
| CVMatrix | Simple Matrix based on std::vector<double> |
| CVSymMatrix | Simple symmetric Matrix based on std::vector<double> |
| ►Ngenfit | Defines for I/O streams used for error and debug printing |
| CAbsBField | Abstract Interface to magnetic fields in GENFIT |
| CAbsFinitePlane | Abstract base class for finite detector planes |
| CAbsFitter | Abstract base class for fitters |
| CAbsFitterInfo | This class collects all information needed and produced by a specific AbsFitter and is specific to one AbsTrackRep of the Track |
| CAbsHMatrix | HMatrix for projecting from AbsTrackRep parameters to measured parameters in a DetPlane |
| CAbsMeasurement | Contains the measurement and covariance in raw detector coordinates |
| CMatStep | Simple struct containing MaterialProperties and stepsize in the material |
| CAbsTrackRep | Abstract base class for a track representation |
| CDetPlane | Detector plane |
| CException | Exception class for error handling in GENFIT (provides storage for diagnostic information) |
| CfieldCache | Cache B field at a position |
| CFieldManager | Singleton which provides access to magnetic field maps |
| CPruneFlags | Info which information has been pruned from the Track |
| CFitStatus | Class where important numbers and properties of a fit can be stored |
| CMaterial | |
| CMeasuredStateOnPlane | #StateOnPlane with additional covariance matrix |
| CMeasurementFactory | Factory object to create AbsMeasurement objects from digitized and clustered data |
| CMeasurementOnPlane | Measured coordinates on a plane |
| CAbsMeasurementProducer | Abstract interface class for MeasurementProducer |
| CMeasurementProducer | Template class for a measurement producer module |
| CSharedPlanePtrCreator | Class allowing to create a SharedPlanePtr from a DetPlane from Python |
| CStateOnPlane | A state with arbitrary dimension defined in a DetPlane |
| CThinScatterer | Thin or thick scatterer |
| CTrackPointComparator | Helper class for TrackPoint sorting, used in Track::sort() |
| CTrack | Collection of TrackPoint objects, AbsTrackRep objects and FitStatus objects |
| CTrackCand | Track candidate – seed values and indices |
| CTrackCandHit | Hit object for use in TrackCand |
| CTrackPoint | Object containing AbsMeasurement and AbsFitterInfo objects |
| CEventDisplay | Event display designed to run with Genfit |
| CConstField | Constant Magnetic field |
| CRectangularFinitePlane | Rectangular finite plane |
| CAbsKalmanFitter | Abstract base class for Kalman fitter and derived fitting algorithms |
| CDAF | Determinstic Annealing Filter (DAF) implementation |
| CKalmanFitStatus | FitStatus for use with AbsKalmanFitter implementations |
| CKalmanFittedStateOnPlane | #MeasuredStateOnPlane with additional info produced by a Kalman filter or DAF |
| CKalmanFitter | Simple Kalman filter implementation |
| CKalmanFitterInfo | Collects information needed and produced by a AbsKalmanFitter implementations and is specific to one AbsTrackRep of the Track |
| CKalmanFitterRefTrack | Kalman filter implementation with linearization around a reference track |
| CReferenceStateOnPlane | #StateOnPlane with linearized transport to that #ReferenceStateOnPlane from previous and next #ReferenceStateOnPlane |
| CGblFitStatus | FitStatus for use with GblFitter |
| CGblFitter | Generic GBL implementation |
| CGblFitterInfo | Collects information needed and produced by a GblFitter/GBL and is specific to one AbsTrackRep of the Track |
| CGblTrackSegmentController | TrackSegmentController for use with GblFitter |
| CGFGbl | Generic GBL implementation |
| CICalibrationParametersDerivatives | Abstract base class to establish an interface between physical representation of the detector for alignment/calibration and (fitted) state on genfit::Track |
| CGFRaveMagneticField | GFRaveMagneticField class Uses the FieldManager to provide a magnetic field to rave |
| CGFRavePropagator | GFRavePropagator class |
| CGFRaveTrackParameters | GFRaveTrackParameters class Contains a pointer to the original genfit::Track, the weight of the track in the vertex, and smoothed (with the vertex information) state and covariance of the track |
| CGFRaveVertex | GFRaveVertex class |
| CtrackAndState | Simple struct containing a Track pointer and a MeasuredStateOnPlane |
| CGFRaveVertexFactory | Vertex factory for producing GFRaveVertex objects from Track objects |
| CFullMeasurement | Measurement class implementing a measurement of all track parameters |
| CHMatrixPhi | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CHMatrixU | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CHMatrixUnit | AbsHMatrix implementation for 5-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CHMatrixUV | AbsHMatrix implementation for two-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CHMatrixV | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| CPlanarMeasurement | Measurement class implementing a planar hit geometry (1 or 2D) |
| CProlateSpacepointMeasurement | Class for measurements implementing a space point hit geometry with a very prolate form of the covariance matrix |
| CSpacepointMeasurement | Class for measurements implementing a space point hit geometry |
| CWireMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| CWireMeasurementNew | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| CWirePointMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which can measure the coordinate along the wire |
| CWireTrackCandHit | Hit object for use in TrackCand |
| CAbsMaterialInterface | Abstract base class for geometry interfacing |
| CMaterialEffects | Stepper and energy loss/noise matrix calculation |
| CMplTrackRep | Monopole track representation |
| CRKMatrix | |
| CRKStep | Helper for RKTrackRep |
| CExtrapStep | Helper for RKTrackRep |
| CRKTrackRep | AbsTrackRep with 5D track parameterization in plane coordinates: (q/p, u', v', u, v) |
| CStepLimits | Helper to store different limits on the stepsize for the RKTRackRep |
| CTGeoMaterialInterface | AbsMaterialInterface implementation for use with ROOT's TGeoManager |
| CHelixTrackModel | Helix track model for testing purposes |
| CMeasurementCreator | Create different measurement types along a HelixTrackModel for testing purposes |
| CmySpacepointDetectorHit | Example class for a spacepoint detector hit |
| CmySpacepointMeasurement | Example class for a spacepoint measurement which can be created from mySpacepointDetectorHit via the MeasurementFactory |
| ►NgenPixelLikelihoods | |
| CWriteData | |
| ►NGeoCacheDemo | |
| CPrintPXDHits | |
| ►NGeoCacheHierarchy | |
| CCompareTransformationsModule | |
| ►NgetModuleT0Histo | |
| CSaveModuleT0 | |
| ►NgetTBCInfo | |
| CPrintInfo | |
| ►Nharvester | |
| CVXDMomentumEnergyEstimator | |
| CMCTrajectoryHarvester | |
| CMCParticleHarvester | |
| CVXDHarvester | |
| CPXDHarvester | |
| CSVDHarvester | |
| CFitHarvester | |
| CReconstructionPositionHarvester | |
| CWrongRLInfoCounter | |
| CSegmentFakeRatesModule | |
| CSegmentFinderParameterExtractorModule | |
| CSeedsAnalyser | |
| ►Nhep_ipython_tools | |
| ►Ncalculation | |
| CCalculation | |
| ►Ncalculation_process | |
| CCalculationProcess | |
| ►Ncalculation_queue | |
| CCalculationQueue | |
| CCalculationQueueItem | |
| ►Nentities | |
| CStoreContent | Basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders |
| CStoreContentList | |
| CStatisticsColumn | |
| CStatistics | |
| ►Ninformation | |
| CEnvironmentInformation | |
| ►Nipython_handler | |
| CIPythonHandler | |
| ►Nipython_handler_basf2 | |
| ►Ncalculation | |
| CBasf2Calculation | |
| ►Ncalculation_process | |
| CBasf2CalculationProcess | |
| ►Nentities | |
| CModuleStatistics | |
| CBasf2CalculationQueueStatistics | |
| ►Ninformation | |
| CBasf2EnvironmentInformation | |
| CBasf2ModulesInformation | |
| ►Nipython_handler | |
| CBasf2IPythonHandler | |
| ►Npython_modules | |
| CPrintCollections | |
| CProgressPython | |
| ►Nviewer | |
| CStylingWidget | |
| CPathViewer | |
| CModuleViewer | |
| CDependencyViewer | |
| ►Nviewer | |
| CIPythonWidget | |
| CStylingWidget | |
| CProgressBarViewer | |
| CCollectionsViewer | |
| CStatisticsViewer | |
| CProcessViewer | |
| CLogViewer | |
| ►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 | |
| CJsonBase | |
| CRevision | |
| CRevisions | |
| CScript | |
| CPlotFile | |
| CPlot | |
| CNTuple | |
| CHtmlContent | |
| CPackage | |
| CComparisonState | |
| CComparisonResult | |
| CComparisonPlotFile | |
| CComparisonPlot | |
| CComparisonNTuple | |
| CComparisonHtmlContent | |
| CComparisonPackage | |
| CComparisonRevision | |
| CComparison | |
| ►Nkeras_relational | |
| CRelations | |
| CEnhancedRelations | |
| ►Nklm_alignment | |
| CKLMAlignment | |
| ►Nklm_channel_status | |
| CKLMChannelStatus | |
| ►Nklm_packer_unpacker | |
| CPackerUnpackerTest | |
| ►Nklm_strip_efficiency | |
| CKLMStripEfficiency | |
| ►NKLMK0LPlotModule | |
| CKLMK0LPlotModule | |
| ►NKoralWPlots | |
| CShowMCParticles | |
| ►NlaserPixelIlumination | |
| CHistogrammer | |
| ►Nlocal_metadata_provider | |
| CLocalMetadataComparison | |
| ►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 | |
| ►Nmcparticle_relations | |
| CTestModule | |
| ►Nmemcheck | |
| CStopModule | |
| ►Nmetaoptions | |
| CMetaOptionParser | |
| ►Nmixed_runs | |
| CDelayEvents | |
| ►Nmodule_paths | |
| CSelectOddEvents | |
| CReturnFalse | |
| CPrintName | |
| ►Nmodule_setparameters | |
| CSetModuleParameters | |
| ►Nmonitor_module | |
| CMonitor | |
| ►NmuonTrackingValidation | |
| CMuon | |
| ►Nmva_examples | |
| CExamplesTest | Extend the examples test class to actually run over the mva examples: |
| ►NndFinderTest | |
| CQuickCheck | |
| ►Nneurotrigger | |
| Ccasefilter | |
| Cnnt_eventfilter | |
| Crandommaker | |
| ►Nnntd | |
| Cnntd | |
| ►NnoCKFValidationBkg | |
| CCKFBkg | |
| ►NObserverCheckMCPurityTests | |
| CObserverCheckMCPurityTest | Test class for SelectionVariableFactory object |
| ►Nonline_book_statistics | |
| CStatistics | |
| CStatisticsVisitor | |
| ►Nparallel_processing | |
| CCheckEventNumbers | |
| ►NParticleGunPlots | |
| CShowMCParticles | |
| ►Nper_event_statistics | |
| CPerEventStatisticsGetterModule | |
| ►Nperfect_match | |
| CPrintTRGTime | |
| ►Npgun_vertex | |
| CVisualizeVertex | |
| ►NPhokharaEvtgenAnalyze | |
| CPhokharaEvtgenAnalysisModule | |
| ►Npickable_basf2 | |
| CBASF2StateRecorder | |
| ►Npid_ttree_writer | |
| CTreeWriterModule | |
| ►Npidcalibration_examples | |
| CExamplesTest | Extend the examples test class to actually run over the PID calibration examples: |
| ►NpidTrainWeights | |
| CWeightNet | |
| ►Nplot_LL_diff | |
| CMinModule | |
| ►NplotPXDPositionEstimator | |
| CPlotClusterPositionEstimatorPayload | |
| ►Nplotting | |
| CPlotter | |
| CPurityAndEfficiencyOverCut | |
| CSignalToNoiseOverCut | |
| CPurityOverEfficiency | |
| CRejectionOverEfficiency | |
| CMultiplot | |
| CDiagonal | |
| CDistribution | |
| CBox | |
| CDifference | |
| COvertraining | |
| CVerboseDistribution | |
| CCorrelation | |
| CTSNE | |
| CImportance | |
| CCorrelationMatrix | |
| ►NpmtPulseHeights | |
| CSaveCanvases | |
| ►Npostmdstidentification_examples | |
| CExamplesTest | Extend the examples test class to actually run over the post mdst identification examples: |
| ►Npreprocessing | |
| Cfast_equal_frequency_binning | |
| ►Nprescale | |
| CCountEvents | |
| ►Nprint_calib_trig_results | |
| CPrintCalibTriggerResults | |
| ►NprintPIDLikelihoods | |
| CprintPIDLikelihoods | |
| ►NPrintTrueHits | |
| CCheckTrueHits | |
| ►NpriorDataLoaderAndModel | |
| CPriorDataLoader | |
| CPriorModel | |
| ►Nprune_datastore | |
| CTestModule | |
| ►NPurityCalcTests | |
| CcompFirst | Small helper functor to find a pair in a container of pairs, where .first matches the passed integer COULDDO: make this templated to take any arguments to the pair, instead of only ints and shorts |
| CcompMCId | Small helper functor to get the MCVXDPurityInfo with the passed ParticleId from a container of MCVXDPurityInfos |
| CPurityCalculatorToolsTest | Class for testing the purity calculator tools (i.e |
| ►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 |
| ►Nresnet | |
| CResidualBlock | Class for the residual block layer |
| CModel | Class for the ResNet generator model |
| CPXDBackgroundGenerator | Class for the PXD background generator module |
| ►Ncalibration | |
| ►Ncalibration_checker | |
| CCalibrationCheckerBase | |
| CPXDHotPixelMaskCalibrationChecker | |
| ►Ncondition_checker | |
| CConditionCheckerBase | |
| CPXDOccupancyInfoChecker | |
| CPXDMaskedPixelsChecker | |
| CPXDDeadPixelsChecker | |
| CPXDGainMapChecker | |
| ►Npxd_packer_unpacker | |
| CPxdPackerUnpackerTestModule | |
| ►Npxd_roi_payload | |
| CPxdROIPayloadTestModule | |
| ►NPXDHitErrors | |
| CPXDHitErrors | |
| ►NPXDHitErrorsTTree | |
| CPXDHitErrorsTTree | |
| ►NPXDROIUnpackerModule | |
| CPXDRawROIUnpackerModule | |
| CPXDPayloadROIUnpackerModule | |
| ►Nqam | |
| CQAM | |
| ►NquadTreePlotter | |
| CQuadTreePlotter | |
| CSegmentQuadTreePlotter | |
| CStereoQuadTreePlotter | |
| CQueueStereoQuadTreePlotter | |
| ►Nquantity_extract | |
| CRootQuantityExtract | |
| ►NReadTSIMInfo | |
| CCreateLogics | |
| ►Nreconstruction_examples | |
| CExamplesTest | Extend the examples test class to actually run over the reconstruction examples: |
| ►Nrecord | |
| CElossHarvestingRun | |
| CElossHarvestingModule | |
| CLegendreBinningValidationRun | |
| CLegendreBinningValidationModule | |
| CSegmentFitValidationRun | |
| CSegmentFitValidationModule | |
| CSegmentPairFitValidationRun | |
| CSegmentPairFitValidationModule | |
| CAxialStereoPairFitterModule | |
| ►Nregister_pystorearray | |
| CSillyGeneratorModule | |
| CParticleStatisticsModule | |
| ►Nrelations | |
| Cearly_stopping | |
| ►Nroot_handler | |
| CTrackingValidationResult | |
| ►Nroot_input | |
| CNoopModule | |
| CTestingModule | |
| CBrokenEventsModule | |
| ►Nrundb | |
| CRunDB | |
| ►NRunSADBgMC_phase1 | |
| CPyTrigger | |
| ►NSavedMCParticles | |
| CCheckMCParticles | |
| ►NsavingFlippingVariables | |
| CSaving1stMVAData | |
| ►NsavingFlippingVariablesFor2ndMVA | |
| CSaving2ndMVAData | |
| ►Nscripts | |
| ►Nbitstring | |
| CError | |
| CReadError | |
| CInterpretError | |
| CByteAlignError | |
| CCreationError | |
| CConstByteStore | |
| CByteStore | |
| CMmapByteArray | |
| CBits | |
| CBitArray | |
| CConstBitStream | |
| CBitStream | |
| ►NeffCalculation | |
| CEffModule | |
| ►Nreadout | |
| CMinModule | |
| ►Nwriter | |
| CVCDPhaseError | |
| CVCDWriter | |
| CVariable | |
| CScalarVariable | |
| CRealVariable | |
| CVectorVariable | |
| ►Nsegment_quad_tree | |
| CSegmentQuadTreeRun | |
| ►NsegmentPairCreationValidation | |
| CSegmentPairCreationValidationRun | |
| CSegmentPairCreationValidationModule | |
| ►Nseqroot_input | |
| CTestModule | |
| ►NSetMetaTimeModule | |
| CSetMetaTimeModule | |
| ►NSetSensitiveThreshold | |
| CSetVXDSensitiveThreshold | |
| ►NshowFEWaveforms | |
| CWFDisplay | |
| ►Nsignals | |
| CTestModule | |
| ►NsimpleEventDisplay | |
| CTOPDisplay | |
| ►Nsimulation_examples | |
| CExamplesTest | Extend the examples test class to actually run over the simulation examples: |
| ►NsmartBKG | |
| ►NNN_filter_module | |
| CNNFilterModule | |
| ►Nsoftwaretrigger | |
| ►Ncli | |
| CHashableCut | |
| CDownloadableDatabase | |
| ►Nconstants | |
| CRunTypes | |
| CSoftwareTriggerModes | |
| CLocation | |
| CDQMModes | |
| ►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 |
| CSQLiteError | Simple error class to be thrown if there is any sqlite error on any of the operations |
| ►CObjectStatement | SQLite prepared statement wrapper |
| Citerator | Iterator class to allow iterating over the rows |
| CConnection | Simple wrapper for a SQLite database connection |
| ►Nstd | STL namespace |
| Chash< std::set< int > > | Hash function used by unordered_set |
| Chash< Belle2::SubGraphID > | Customized hash-function for being able to use unordered_map |
| ►Nsteering | |
| CRandomTestModule | |
| ►Nsteering_files | |
| CSteeringFileTest | |
| ►Nstop_on_error | |
| CErrorInInit | |
| CErrorInEvent | |
| ►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 | |
| CskimOutRNDTrgModule | |
| CskimSVDBurstEventsModule | |
| Cskim6SampleEventsPyModule | |
| CskimSVDTriggerBinEventsPyModule | |
| CskimFineTRGEventsPyModule | |
| CskimLowHighEventT0EventsPyModule | |
| ►NsvdCoGCalibrationAnalysisToolModule | |
| CsvdCoGCalibrationAnalysisTool | |
| ►NSVDSimBase | |
| Ctau_encoder | |
| CSampleGenerator | |
| ►Nsvd_packer_unpacker | |
| CSvdPackerUnpackerTestModule | |
| ►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 | |
| ►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 | |
| ►Nt0CalTime | |
| CNtuple | |
| ►Ntagging_examples | |
| CExamplesTest | Extend the examples test class to actually run over the tagging examples: |
| ►Ntest6_CPVFlavorTaggerEfficiency | |
| CQuiet | |
| ►Ntest_caf_machine | |
| CTest_Machine | |
| ►Ntest_caf_utils | |
| CTestUtils_topological_sort | |
| CTestUtils_getiov | |
| ►Ntest_chargedCluster | |
| CTestChargedCluster | |
| ►Ntest_cluster_position_estimator | |
| CPXDPositionEstimation | |
| ►Ntest_clustercontroldrmaa | |
| ►CTestClusterControlDrmaa | |
| ►CSessionMock | |
| CJobState | |
| ►Ntest_collector | |
| CCollectorTestCase | |
| CFinalCollectorTestCase | |
| ►Ntest_comparison | |
| CTestGetComparison | |
| CTestComparison | |
| ►Ntest_distributor | |
| CDistributorTestCase | |
| ►Ntest_embedding_example | |
| CTestEmbedding | |
| ►Ntest_geotools | |
| CCheckNumbering | |
| ►Ntest_globaltag_forwarding | |
| CTestGTForwarding | |
| ►Ntest_histogram | |
| CHistogramTestCase | |
| CHistogramStopTestCase | |
| ►Ntest_hlt | |
| CHLTTestCase | |
| CDyingHLTTestCase | |
| ►Ntest_iov | |
| CTestIntervalOfValidity | |
| CTestIoVSet | |
| ►Ntest_mbc_cut_eff | |
| CTestMbcEff | |
| ►Ntest_mixing_overlay_equivalence | |
| CSetAsideSimHits | |
| CInjectSimHits | |
| ►Ntest_MVAExpertModule | |
| CMVAExtraInfoChecker | |
| ►Ntest_online_book_statistics | |
| CTest | |
| ►Ntest_particleExtractorFromROE | |
| CTestParticleExtractorFromROE | |
| ►Ntest_prompt_scripts | |
| CTest_Prompt | |
| ►Ntest_prompt_validation_scripts | |
| CTest_Prompt | |
| ►Ntest_quantity_extract | |
| CTestQuantityExtract | |
| ►Ntest_reconstructmcdecay | |
| CTestNewMCDecayFinder | |
| ►Ntest_runningupdate | |
| CTestMergeStaging | |
| ►Ntest_shaperdigit_sorter | |
| CCreateDigits | |
| CCheckOrderingOfDigits | |
| CPrintDigitsAndClusters | |
| ►Ntest_std_charged | |
| CTestStdCharged | |
| ►Ntest_std_hyperons | |
| CTestStdHyperons | |
| ►Ntest_std_photons | |
| CTestStdPhotons | |
| ►Ntest_std_pi0s | |
| CTestStdPi0s | |
| ►Ntest_std_v0 | |
| CTestStdV0 | |
| ►Ntest_validation | |
| CValidationTest | |
| ►Ntest_validation_metadata_tools | |
| CTestValidationMetadataSetter | |
| ►Ntest_validationfunctions | |
| CValidationFunctionstTest | |
| ►Ntest_validationscript | |
| CValidationScriptTest | |
| ►Ntest_variables_collections | |
| CTestVariableCollections | |
| ►Ntest_variables_meta | |
| CMetavariableDataTypeTest | |
| ►Ntest_variables_utils | |
| CTestVariableUtilities | |
| ►Ntest_worker | |
| CWorkerTestCase | |
| CNormalWorkerTestCase | |
| CDyingWorkerTestCase | |
| ►NtestCosmicT0Finder | |
| CShiftDigits | |
| CNtuple | |
| ►NtestNewReco | |
| CSVDClustersQuickCheck | |
| CSVDRecoDigitsQuickCheck | |
| ►NTestUtilities | |
| CTestParticleFactory | This is a class, which generates DataStore particles, according to the provided decay string e.g |
| ►NtoCDCCKFTrackingValidationBkg | |
| CtoCDCCKFValidationBkg | |
| ►NtoCDCfromEclCKFTrackingValidation | |
| CtoCDCfromEclCKF | |
| ►NtoCDCfromEclCKFTrackingValidation_onlyEclSeed | |
| CtoCDCfromEclCKF | |
| ►Ntop_digits_raw_digits | |
| CDigitTest | |
| ►Ntop_packer_unpacker | |
| CDigitsTest | |
| CRawDigitsTest | |
| ►NTOPFE_qualityPlots | |
| CWaveformAnalyzer | |
| ►Ntorch_tcce | |
| CTCCE | |
| ►Ntrack_to_mcparticle_relation_test | |
| CCheckPresenceOfTrackToMCParticleRelation | |
| ►Ntrackfindingcdc | |
| ►Ncdcdisplay | |
| ►Nsvgdrawing | |
| ►Nattributemaps | |
| CCDCHitStrokeWidthMap | |
| CZeroDriftLengthStrokeWidthMap | |
| CCDCHitColorMap | |
| CZeroDriftLengthColorMap | |
| CTakenFlagColorMap | |
| CRLColorMap | |
| CWrongRLColorMap | |
| CPosFlagColorMap | |
| CBackgroundTagColorMap | |
| CMCSegmentIdColorMap | |
| CTOFColorMap | |
| CReassignedSecondaryMap | |
| CMCParticleColorMap | |
| CMCPDGCodeColorMap | |
| CMCPrimaryColorMap | |
| CCDCSegmentColorMap | |
| CSegmentMCTrackIdColorMap | |
| CSegmentFBInfoColorMap | |
| CSegmentFirstInTrackIdColorMap | |
| CSegmentLastInTrackIdColorMap | |
| CSegmentFirstNPassedSuperLayersColorMap | |
| CSegmentLastNPassedSuperLayersColorMap | |
| CCDCSVGPlotter | |
| CCDCSVGDisplayModule | |
| ►Nmodules | |
| CCDCHitUniqueAssumer | |
| CHitCleaner | |
| ►Ntracking | |
| ►Nharvest | |
| ►Nharvesting | |
| CHarvestingModule | |
| ►Nrefiners | |
| CRefiner | |
| CSaveFiguresOfMeritRefiner | |
| CSaveHistogramsRefiner | |
| CPlot2DRefiner | |
| CSaveProfilesRefiner | |
| CSaveScatterRefiner | |
| CSaveClassificationAnalysisRefiner | |
| CSavePullAnalysisRefiner | |
| CSaveTreeRefiner | |
| CFilterRefiner | |
| CSelectRefiner | |
| CGroupByRefiner | |
| CCdRefiner | |
| CExpertLevelRefiner | |
| ►Nrun | |
| CHarvestingRunMixin | |
| CHarvestingRun | |
| ►Nharvesting_validation | |
| ►Ncombined_module | |
| CCombinedTrackingValidationModule | |
| ►Neventwise_module | |
| CEventwiseTrackingValidationModule | |
| ►Nmc_side_module | |
| CMCSideTrackingValidationModule | |
| ►Npr_side_module | |
| CPRSideTrackingValidationModule | |
| ►Nrecorded_data_module | |
| CEventInfoHarvester | |
| CTrackInfoHarvester | |
| CHitInfoHarvester | |
| ►Nmetamodules | |
| CWrapperModule | |
| CPyProfilingModule | |
| CIfModule | |
| CIfStoreArrayPresentModule | |
| CIfStoreArrayNotPresentModule | |
| CIfMCParticlesPresentModule | |
| CPathModule | |
| ►Nrun | |
| ►Nevent_generation | |
| CReadOrGenerateEventsRun | |
| CStandardEventGenerationRun | |
| ►Nminimal | |
| CEmptyRun | |
| CMinimalRun | |
| ►Nmixins | |
| CRunMixin | |
| CPostProcessingRunMixin | |
| CBrowseTFileOnTerminateRunMixin | |
| CRootOutputRunMixin | |
| ►Ntracked_event_generation | |
| CReadOrGenerateTrackedEventsRun | |
| CStandardReconstructionEventsRun | |
| ►Nutilities | |
| CArgumentParser | |
| CNonstrictChoices | |
| ►Nutilities | |
| CDefaultHelpArgumentParser | |
| CNonstrictChoices | |
| ►Nvalidation | |
| ►Nclassification | |
| CClassificationAnalysis | |
| CCutClassifier | |
| CCutAtBackgroundRejectionClassifier | |
| ►Nfom | |
| CValidationFiguresOfMerit | |
| CValidationManyFiguresOfMerit | |
| ►Nhit_module | |
| CExpertTrackingValidationModule | |
| ►Nmatplotting | |
| Cdefaults | |
| ►Nmodule | |
| CFilterProperties | |
| CAlwaysPassFilter | |
| CTrackingValidationModule | |
| ►Nplot | |
| CValidationPlot | |
| ►Npull | |
| CPullAnalysis | |
| ►Nresolution | |
| CResolutionAnalysis | |
| ►Nrun | |
| CTrackingValidationRun | |
| ►Ntolerate_missing_key_formatter | |
| CNoReplacementField | |
| CTolerateMissingKeyFormatter | |
| CTolerateMissingKeyFormatterTest | |
| ►NTrackingValidation | |
| CStandalone | |
| ►Ntrain | |
| CDEDXEstimationTrainer | |
| CGroupedDEDXEstimationTrainer | |
| CFittedGroupedDEDXEstimatorTrainer | |
| CFunctionFittedGroupedDEDXEstimatorTrainer | |
| CGaussianEstimatorTrainer | |
| CLandauEstimatorTrainer | |
| CMaximumEstimatorTrainer | |
| CMedianEstimatorTrainer | |
| CGaussianEstimatorTrainerSQRT | |
| CLandauEstimatorTrainerSQRT | |
| CMaximumEstimatorTrainerSQRT | |
| CMedianEstimatorTrainerSQRT | |
| CMVADEDXEstimationTrainer | |
| CClassificationOverview | |
| ►NtrainBackgroundClusterFilter | |
| CBackgroundClusterFilterTrainingRun | |
| ►NtrainFacetFilter | |
| CFacetFilterTrainingRun | |
| ►NtrainFacetRelationFilter | |
| CFacetRelationFilterTrainingRun | |
| ►NtrainFeasibleAxialSegmentPairFilter | |
| CFeasibleAxialSegmentPairFilterTrainingRun | |
| ►NtrainFeasibleSegmentPairFilter | |
| CFeasibleSegmentPairFilterTrainingRun | |
| ►NtrainFeasibleSegmentRelationFilter | |
| CFeasibleSegmentRelationFilterTrainingRun | |
| ►NtrainFeasibleTrackRelationFilter | |
| CFeasibleTrackRelationFilterTrainingRun | |
| ►Ntraining | |
| CTrainingRunMixin | |
| ►NtrainRealisticAxialSegmentPairFilter | |
| CRealisticAxialSegmentPairFilterTrainingRun | |
| ►NtrainRealisticSegmentPairFilter | |
| CRealisticSegmentPairFilterTrainingRun | |
| ►NtrainRealisticSegmentPairRelationFilter | |
| CRealisticSegmentPairRelationFilterTrainingRun | |
| ►NtrainRealisticSegmentRelationFilter | |
| CRealisticSegmentRelationFilterTrainingRun | |
| ►NtrainRealisticTrackRelationFilter | |
| CRealisticTrackRelationFilterTrainingRun | |
| ►NtrainSegmentTrackFilter | |
| CSegmentTrackFilterTrainingRun | |
| ►NtrainTrackFilter | |
| CTrackFilterTrainingRun | |
| ►NtreeFit | |
| CTestTreeFits | |
| ►NtreeFit_beam_momentum_constrain | |
| CTestTreeFits | |
| ►NtreeFit_referenced | |
| CTestTreeFits | |
| ►NtreeFit_referenced_bremscorrection | |
| CTestTreeFits | |
| ►NtreeFit_referenced_charged_tree | |
| CTestTreeFits | |
| ►NtreeFit_referenced_charged_tree_2dBeam | |
| CTestTreeFits | |
| ►NtreeFit_referenced_ignore_charged | |
| CTestTreeFits | |
| ►NtreeFit_referenced_ignore_klong | |
| CTestTreeFits | |
| ►NtreeFit_referenced_klong | |
| CTestTreeFits | |
| ►NtreeFit_referenced_pipipi0 | |
| CTestTreeFits | |
| ►NtreeFit_referenced_single_displaced_vertex | |
| CTestTreeFits | |
| ►NtreeFit_referenced_single_vertex | |
| CTestTreeFits | |
| ►NtreeFit_referenced_tree_with_neutral | |
| CTestTreeFits | |
| ►NtreeFit_referenced_tree_with_neutral_custom_origin | |
| CTestTreeFits | |
| ►NTreeFitter | |
| CComposite | A class for composite particles, where the daughters must be ignored by the fitter |
| CConstraint | Class to manage the order of constraints and their filtering |
| CConstraintConfiguration | Constainer |
| CDecayChain | This class does a lot of stuff: Build decaytree structure allowing to index particles and handle the filtering of constraints across the tree |
| CErrCode | Abstract errorocode be aware that the default is success |
| CFitManager | This class |
| CFitParameterDimensionException | Exception template, runtime_error implements what() |
| CFitParams | Class to store and manage fitparams (statevector) |
| CHelixUtils | Utility for helix<->x,p conversions |
| CInternalParticle | Another unnecessary layer of abstraction |
| CKalmanCalculator | Does the calculation of the gain matrix, updates the cov and fitpars |
| CMergedConstraint | Merge multiple constraints that we want to project simultaneously |
| COrigin | Representation of the beamspot as a particle |
| CParticleBase | Base class for all particles |
| CProjection | Class to store the projected residuals and the corresponding jacobian as well as the covariance matrix in the system of residuals |
| CRecoKlong | Representation of the Klong constraint |
| CRecoParticle | Base for RecoPhoton RecoTrack |
| CRecoPhoton | Representation of the photon constraint |
| CRecoResonance | A class for resonances |
| CRecoTrack | Representation of all charged final states FIXME rename since this name is taken in tracking |
| CResonance | Class for resonances as internal particles |
| ►NtrgcdcReadout | |
| CTestModule | |
| ►Ntrgcdct3dUnpackerConverter | |
| Cis2DSkim | |
| ►NTRGValidation | |
| CMakePlots | |
| ►NtriggerKLs | |
| CPyTrigger | |
| ►NTSF_OldVsNew | |
| CTestModule | |
| ►Ntutorials_B2A2XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A3XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A4XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A5XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A6XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A7XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A8XX | |
| CTutorialsTest | |
| ►Ntutorials_B2A9XX | |
| CTutorialsTest | |
| ►Nv0ValidationCreatePlots | |
| CV0ValidationPlots | |
| ►Nvalidate | |
| CBGHistogrammer | |
| ►NvalidateOverlay | |
| CHistogrammer | |
| ►NvalidatePhase2Cosmics | |
| CCosmicAnalysis | |
| ►Nvalidation | |
| CIntervalSelector | |
| ►Nvalidationpath | |
| CTagFolderRainbowTable | |
| ►Nvalidationscript | |
| ►CScriptStatus | Enumeration of the states a script can be during its execution cycle |
| Ccached | |
| Cfailed | |
| Cfinished | |
| Crunning | |
| Cskipped | |
| Cwaiting | |
| ►Nvalidationserver | |
| CValidationRoot | |
| ►Nvariablemanager_examples | |
| CExamplesTest | Extend the examples test class to actually run over the variable manager examples: |
| ►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 temporaryly stored in a separate header! |
| CTestSpacePoint | Helper struct for SpacePoint Tests |
| CDecorrelationMatrixTest | Test Class |
| ►NVXDTFfilterTest | |
| CspacePoint | Just a small proto-container storing coordinates |
| CSquaredDistance3D | Small filter illustrating the behavior of a distance3D-filter |
| CSquaredDistance2Dxy | Small filter illustrating the behavior of a distance2D-filter in XY |
| CSquaredDistance1Dx | Small filter illustrating the behavior of a distance1D-filter in X |
| CBooleanVariable | Small filter illustrating the behavior of a filter which is compatible with boolean comparisons |
| Ccounter | Small class counting usage |
| CObserver | This observer does simply count the number of times, the attached Filter was used |
| CFilterTest | Test class for Filter object |
| ►NVXDTFfourHitFilterTest | |
| CFourHitFilterTest | Test class for these new and shiny two-hit-filters |
| CResultsObserver | Takes result, prints it and stores it to lastResult |
| ►NVXDTFMinMaxCollectorTest | |
| CMinMaxCollectorTest | Test class for these new and shiny two-hit-filters |
| ►NVXDTFObserversTest | TODO next steps: |
| CObserversTest | Test class for testing and developing new Observers |
| Ccounter | Tiny counter class for counting stuff |
| ►CCountContainer | Container for counting accepted and rejected stuff, just delivers some interfaces to make the code more readable |
| CAcceptRejectPair | Simple struct for counting accepted and rejected cases |
| CcounterMC | Tiny counter class for counting stuff retrieved from MC-bla |
| CCountUsedObserver | This observer does simply count the number of times, the attached SelectionVariable was used |
| CCountAcceptRejectObserver | This observer does simply count the number of times, the attached SelectionVariable was accepted or rejected |
| CCountBadCaseObserver | This observer does simply count the number of times, the attached Filter resulted in isinf or isnan |
| CInfoObserver | This observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning |
| CCountAcceptedRejectedMCParticleObserver | This observer identifies the McParticles responsible for creating underlying clusters for given spacePoints and counts how often a particle type was accepted and how often it was rejected |
| CProvideBasicInfoObserver | This observer combines all the easy-to-get info retrievable by observers and prints it to screen |
| CVectorOfObservers | WARNING TODO: |
| ►NVXDTFthreeHitFilterTest | |
| CThreeHitFilterTest | Test class for these new and shiny two-hit-filters |
| CResultsObserver | Takes result, prints it and stores it to lastResult |
| ►NVXDTFtrackletFilterTest | |
| CTrackletFilterTest | Test class for these new and shiny two-hit-filters |
| CResultsObserver | Takes result, prints it and stores it to lastResult |
| ►NVXDTFtwoHitFilterTest | |
| CTwoHitFilterTest | Test class for these new and shiny two-hit-filters |
| Ccounter | Tiny counter class for counting stuff |
| CCountingObserver | This observer does simply count the number of times, the attached Filter was used |
| CErrorObserver | This observer does simply print the name of the SelectionVariable and the result of its value-function as an Error |
| CInfoObserver | This observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning |
| CVectorOfObservers | This observer does simply collect other observers which are to be executed during the call of the corresponding notify function(s) |
| ►Nwirehit_preparation | |
| CWireHitPreparerRunMixin | |
| ►Nwrapper | |
| CQueueDrawer | |
| CQueueHarvester | |
| ►Nz0_with_clone_suppression | |
| CSkim | |
| CAna | |
| ►Nzero_suppression | |
| CCheckZS | |
| ►Nzmq_daq | |
| ►Nexample_support | |
| CSleepOnInitModule | |
| ►Ntest_support | |
| CHLTZMQTestCase | |
| CBaseCollectorTestCase | |
| CBeginRec | Begin record structure for the beamtest data |
| CBEvent | The Class for Masterclass event parameters |
| CBParticle | The Class for Masterclass particle information This class provides the data structure of the particle that are used by Belle II Masterclass application |
| ►CCDCTriggerNeuroDQMOnlineModule | CDC Trigger DQM Module |
| CTSLine | |
| Ccopper_footer | |
| Ccopper_header | |
| CcrystalInfo | Struct to hold relavent Crystal information |
| Ccurl_t | Curl struct |
| Ccycle_detector | Simple struct to check boost graph for cyclic references |
| CDISABLED_TrackFindingCDCTestRootification | |
| 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 |
| ►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 |
| 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 |
| CEvtYmSToYnSpipiCLEOboost | Register Decay model EvtYmSToYnSpipiCLEOboost |
| CFileHandler | |
| CFitter3DUtility | A class that holds functions for 3D tracking |
| CFpgaUtility | A class that holds FPGA related functions |
| CGFGeant4Field | Interface of the Belle II B-field with GenFit |
| Ch2m_footer_t | |
| Ch2m_header_t | |
| Chepevt_type | HEPEVT common block of PYTHIA6 |
| CHopfieldNetworkTest | Test of HopfieldNetwork Class |
| CHough3DFinder | A class to finded stereo TS hits related to 2D tracks |
| CInputParser | |
| CKeccakHashInstance | Since we cannot forward declare the memory structure directly due to some typedeffing we inherit from it |
| CLogModRealm | Class to modify the log level dependent on the execution realm |
| CLogVar | Class to store variables with their name which were sent to the logging service |
| CLogVariableStream | Specialized implementation of an ostream-like class where the << operator can be used to insert values |
| 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 | |
| COverlapMatrixCreatorTest | Test the overlap-matrix creator using known input |
| COverlapNetworkTest | Test OverlapNetwork Class |
| CPlane | Plane |
| CPlane_t | Define plane struct |
| 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 |
| CSecondaryWireNeighborhoodTest | |
| 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 | |
| CTerm | |
| CTestCase | |
| CTNiel | TNiel - the class providing values for NIEL factors |
| Cvlistentry_t | |
| CXT | Class to perform fitting for each xt function |
| CXY | Point |
1.9.1