__init__.py

#!/usr/bin/env python3
 

 
import basf2 as b2
 
from geometry import is_detector_present, is_any_detector_present
 
# Many scripts import these functions from `tracking`, so leave these imports here
from tracking.path_utils import (  # noqa
    add_default_cdc_svd_tracking_chain,
    add_inverted_svd_cdc_tracking_chain,
    add_cdc_cr_track_finding,
    add_cr_track_fit_and_track_creator,
    add_eclcdc_track_finding,
    add_geometry_modules,
    add_hit_preparation_modules,
    add_mc_matcher,
    add_prune_tracks,
    add_flipping_of_recoTracks,
    add_pxd_cr_track_finding,
    add_pxd_track_finding,
    add_svd_track_finding,
    add_prefilter_track_fit_and_track_creator,
    add_postfilter_track_fit_and_track_creator,
    add_svd_standalone_tracking,
)
 
from pxd import add_pxd_reconstruction
 
 
def add_tracking_reconstruction(path, components=None, pruneTracks=False, skipGeometryAdding=False,
                                mcTrackFinding=False, trackFitHypotheses=None,
                                reco_tracks="RecoTracks", prune_temporary_tracks=True, fit_tracks=True,
                                with_cdc_cellular_automaton=False,
                                use_second_cdc_hits=False, skipHitPreparerAdding=False,
                                svd_standalone_mode="VXDTF2",
                                use_svd_to_cdc_ckf=True, use_ecl_to_cdc_ckf=False,
                                add_cdcTrack_QI=True, add_vxdTrack_QI=False, add_recoTrack_QI=True,
                                pxd_filtering_offline=False,
                                create_intercepts_for_pxd_ckf=False,
                                append_full_grid_cdc_eventt0=True,
                                v0_finding=True, flip_recoTrack=True,
                                skip_full_grid_cdc_eventt0_if_svd_time_present=True,
                                inverted_tracking=False,
                                use_cat_finder=False):
    """
    This function adds the **standard tracking reconstruction** modules
    to a path:
 
    #. first we find tracks using the CDC hits only, see :ref:`CDC Track Finding<tracking_trackFindingCDC>`
 
    #. CDC tracks are extrapolated to SVD and SVD hits are attached, see :ref:`CDC to SVD SpacePoint CKF<tracking_cdc2svd_ckf>`
 
    #. remaining  SVD hits are used to find SVD tracks, see :ref:`SVD Track Finding<tracking_trackFindingSVD>`
 
    #. CDC standalone tracks which don't have SVD hits attached to them from the \
    :ref:`CDC to SVD CKF<tracking_cdc2svd_ckf>` are combined with SVD standalone tracks found in the previous step using the \
    :ref:`CDC to SVD Seed CKF<tracking_svdcdc_merger_ckf>`
 
    #. SVD tracks are extrapolated to CDC to attach CDC hits, see :ref:`SVD to CDC CKF<tracking_svd2cdc_ckf>`
 
    #. SVD and CDC tracks are merged and fitted, see :ref:`Track Fitting<tracking_trackFitting>`
 
    #. merged SVD+CDC tracks are extrapolated to PXD to attach PXD hits, see :ref:`SVD to PXD CKF<tracking_svd2pxd_ckf>`
 
        .. note::
 
           PXD hits are not available on HLT. At the end of the tracking chain on HLT we have the\
           :ref:`PXD Region Of Interest Finding<tracking_pxdDataReduction>`, that consists of extrapolating\
           the tracks on the PXD sensors and defining regions in which we expect to find the hit.\
           Only fired pixels inside these regions reach Event Builder 2.
 
    #. after all the tracks from the IP are found, we look for special classes of tracks,\
    in particular we search for displaced vertices to reconstruct K-short, Lambda and\
    photon-conversions, see :ref:`V0 Finding<tracking_v0Finding>`.
 
    #. If the reconstruction uses PXD, we finally look for tracks with a wrong charge,\
    flip and refit them to fix the charge, see :ref:`Flip&Refit<trk_flipNrefit>`.
 
    :param path: the path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components.
    :param pruneTracks: if true, delete all hits except the first and the last in the found tracks.
    :param skipGeometryAdding: (advanced flag) the tracking modules need the geometry module and will add it,
        if it is not already present in the path. In a setup with multiple (conditional) paths however, it can not
        determine, if the geometry is already loaded. This flag can be used o just turn off the geometry adding at
        all (but you will have to add it on your own then).
    :param skipHitPreparerAdding: (advanced flag) if true, do not add the hit preparation (esp. VXD cluster creation
        modules. This is useful if they have been added before already.
    :param mcTrackFinding: if true, use the MC track finders instead of the realistic ones.
    :param reco_tracks: name of the StoreArray where the reco tracks should be stored
    :param prune_temporary_tracks: if false, store all information of the single CDC and VXD tracks before merging.
        If true, prune them.
    :param fit_tracks: if false, the track fitting and the TrackCreator module will not be executed
    :param with_cdc_cellular_automaton: If true, in the CDC track finding the cellular automaton algorithm will be used too,
        after the global algorithm (Legendre).
    :param use_second_cdc_hits: if true, the second hit information will be used in the CDC track finding.
    :param trackFitHypotheses: which pdg hypotheses to fit. Defaults to [211, 321, 2212].
    :param svd_standalone_mode: Which SVD standalone tracking is used.
           Options are "VXDTF2", "SVDHough", "VXDTF2_and_SVDHough", and "SVDHough_and_VXDTF2".
           Defaults to "VXDTF2"
    :param use_svd_to_cdc_ckf: if true, add SVD to CDC CKF module.
    :param use_ecl_to_cdc_ckf: if true, add ECL to CDC CKF module.
    :param add_cdcTrack_QI: if true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found CDC standalone tracks
    :param add_vxdTrack_QI: if true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found VXDTF2 tracks
        (ATTENTION: Standard triplet QI of VXDTF2 is replaced in this case
        -> setting this option to 'True' will have some influence on the final track collection)
    :param add_recoTrack_QI: if true, add the MVA track quality estimation
        to the path that sets the quality indicator property of all found reco tracks
        (CDC QI is needed as input.)
    :param pxd_filtering_offline: If True, PXD data reduction (ROI filtering) is applied during the track reconstruction.
        The reconstructed SVD/CDC tracks are used to define the ROIs and reject all PXD clusters outside of these.
    :param create_intercepts_for_pxd_ckf: If True, the PXDROIFinder is added to the path to create PXDIntercepts to be used
        for hit filtering when creating the CKF relations. This independent of the offline PXD digit filtering which is
        steered by 'pxd_filtering_offline'. This can be applied for both data and MC.
    :param append_full_grid_cdc_eventt0: If True, the module FullGridChi2TrackTimeExtractor is added to the path
                                      and provides the CDC temporary EventT0.
    :param v0_finding: if false, the V0Finder module is not executed
    :param flip_recoTrack: if true, add the recoTracks flipping function in the postfilter (only if PXD is present)
    :param skip_full_grid_cdc_eventt0_if_svd_time_present: if true, and if also append_full_grid_cdc_eventt0 is true, the
        FullGridChi2TrackTimeExtractor is only executed in the events where no SVD-based EventT0 is found. If false, but
        append_full_grid_cdc_eventt0 is true, FullGridChi2TrackTimeExtractor will be executed in each event regardless of
        SVD EventT0 being present. Has no effect if append_full_grid_cdc_eventt0 is false. Default: true
    :param inverted_tracking: If true, start tracking with SVD standalone track finding, followed by ToCDCCKF,
        the CDC standalone tracking, a CKF-based merger to merge the standalone RecoTracks, and finally the
        CDCToSVDSpacePointCKF to add SVD hits to all CDC tracks that don't have SVD hits attached to them.
        ATTENTION: The inverted tracking chain is neither optimised nor guaranteed to be bug free.
        One known issue is a reduced hit efficiency when using the full chain.
        Please remove this comment once the inverted tracking has been optimised and is assumed to be bug-free.
    :param use_cat_finder: if True, it runs the CDC AI Track Finder (CATFinder) as CDC track finding algorithm
        instead of the default one.
    """
 
    add_prefilter_tracking_reconstruction(
        path,
        components=components,
        skipGeometryAdding=skipGeometryAdding,
        mcTrackFinding=mcTrackFinding,
        trackFitHypotheses=trackFitHypotheses,
        reco_tracks=reco_tracks,
        prune_temporary_tracks=prune_temporary_tracks,
        fit_tracks=fit_tracks,
        with_cdc_cellular_automaton=with_cdc_cellular_automaton,
        use_second_cdc_hits=use_second_cdc_hits,
        skipHitPreparerAdding=skipHitPreparerAdding,
        svd_standalone_mode=svd_standalone_mode,
        use_svd_to_cdc_ckf=use_svd_to_cdc_ckf,
        use_ecl_to_cdc_ckf=use_ecl_to_cdc_ckf,
        add_cdcTrack_QI=add_cdcTrack_QI,
        add_vxdTrack_QI=add_vxdTrack_QI,
        add_recoTrack_QI=add_recoTrack_QI,
        pxd_filtering_offline=pxd_filtering_offline,
        create_intercepts_for_pxd_ckf=create_intercepts_for_pxd_ckf,
        append_full_grid_cdc_eventt0=append_full_grid_cdc_eventt0,
        skip_full_grid_cdc_eventt0_if_svd_time_present=skip_full_grid_cdc_eventt0_if_svd_time_present,
        inverted_tracking=inverted_tracking,
        use_cat_finder=use_cat_finder)
 
    add_postfilter_tracking_reconstruction(path,
                                           components=components,
                                           pruneTracks=pruneTracks,
                                           fit_tracks=fit_tracks,
                                           trackFitHypotheses=trackFitHypotheses,
                                           reco_tracks=reco_tracks,
                                           use_second_cdc_hits=use_second_cdc_hits,
                                           prune_temporary_tracks=prune_temporary_tracks,
                                           v0_finding=v0_finding,
                                           flip_recoTrack=flip_recoTrack,
                                           mcTrackFinding=mcTrackFinding)
 
 
def add_prefilter_tracking_reconstruction(path, components=None, skipGeometryAdding=False,
                                          mcTrackFinding=False, trackFitHypotheses=None, reco_tracks="RecoTracks",
                                          stopOnSuccessfulTrackFit=True,
                                          prune_temporary_tracks=True, fit_tracks=True,
                                          with_cdc_cellular_automaton=False,
                                          use_second_cdc_hits=False, skipHitPreparerAdding=False,
                                          svd_standalone_mode="VXDTF2",
                                          use_svd_to_cdc_ckf=True, svd_ckf_mode="SVD_after", use_ecl_to_cdc_ckf=False,
                                          add_cdcTrack_QI=True, add_vxdTrack_QI=False, add_recoTrack_QI=True,
                                          pxd_filtering_offline=False,
                                          create_intercepts_for_pxd_ckf=False,
                                          append_full_grid_cdc_eventt0=True,
                                          skip_full_grid_cdc_eventt0_if_svd_time_present=True,
                                          inverted_tracking=False,
                                          use_cat_finder=False):
    """
    This function adds the tracking reconstruction modules required to calculate HLT filter decision
    to a path. By default, track fitting stops when a successful fit is found among trackFitHypotheses.
 
    :param path: The path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components.
    :param skipGeometryAdding: Advances flag: The tracking modules need the geometry module and will add it,
        if it is not already present in the path. In a setup with multiple (conditional) paths however, it can not
        determine, if the geometry is already loaded. This flag can be used o just turn off the geometry adding at
        all (but you will have to add it on your own then).
    :param skipHitPreparerAdding: Advanced flag: do not add the hit preparation (esp. VXD cluster creation
        modules. This is useful if they have been added before already.
    :param mcTrackFinding: Use the MC track finders instead of the realistic ones.
    :param reco_tracks: Name of the StoreArray where the reco tracks should be stored
    :param prune_temporary_tracks: If false, store all information of the single CDC and VXD tracks before merging.
        If true, prune them.
    :param fit_tracks: If false, the track fitting and the TrackCreator module will not be executed
    :param with_cdc_cellular_automaton: If true, in the CDC track finding the cellular automaton algorithm will be used too,
        after the global algorithm (Legendre).
    :param use_second_cdc_hits: If true, the second hit information will be used in the CDC track finding.
    :param trackFitHypotheses: Which pdg hypotheses to fit. Defaults to [211, 321, 2212].
    :param stopOnSuccessfulTrackFit: If true (default), the TrackCreator will stop when a fit is successful
        among the listed "trackFitHypotheses". Otherwise, all listed hypotheses are attempted.
    :param svd_standalone_mode: Which SVD standalone tracking is used.
           Options are "VXDTF2", "SVDHough", "VXDTF2_and_SVDHough", and "SVDHough_and_VXDTF2".
           Defaults to "VXDTF2"
    :param use_svd_to_cdc_ckf: if true, add SVD to CDC CKF module.
    :param svd_ckf_mode: how to apply the CKF (with or without SVD standalone tracking). Defaults to "SVD_after".
    :param use_ecl_to_cdc_ckf: if true, add ECL to CDC CKF module.
    :param add_cdcTrack_QI: If true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found CDC standalone tracks
    :param add_vxdTrack_QI: If true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found VXDTF2 tracks
        (ATTENTION: Standard triplet QI of VXDTF2 is replaced in this case
        -> setting this option to 'True' will have some influence on the final track collection)
    :param add_recoTrack_QI: If true, add the MVA track quality estimation
        to the path that sets the quality indicator property of all found reco tracks
        (CDC QI is needed as input.)
    :param pxd_filtering_offline: If True, PXD data reduction (ROI filtering) is applied during the track reconstruction.
        The reconstructed SVD/CDC tracks are used to define the ROIs and reject all PXD clusters outside of these.
    :param create_intercepts_for_pxd_ckf: If True, the PXDROIFinder is added to the path to create PXDIntercepts to be used
        for hit filtering when creating the CKF relations. This independent of the offline PXD digit filtering which is
        steered by 'pxd_filtering_offline'. This can be applied for both data and MC.
    :param append_full_grid_cdc_eventt0: If True, the module FullGridChi2TrackTimeExtractor is added to the path
                                      and provides the CDC temporary EventT0.
    :param skip_full_grid_cdc_eventt0_if_svd_time_present: if true, and if also append_full_grid_cdc_eventt0 is true, the
        FullGridChi2TrackTimeExtractor is only executed in the events where no SVD-based EventT0 is found. If false, but
        append_full_grid_cdc_eventt0 is true, FullGridChi2TrackTimeExtractor will be executed in each event regardless of
        SVD EventT0 being present. Has no effect if append_full_grid_cdc_eventt0 is false. Default: true
    :param inverted_tracking: If true, start tracking with SVD standalone track finding, followed by ToCDCCKF,
        the CDC standalone tracking, a CKF-based merger to merge the standalone RecoTracks, and finally the
        CDCToSVDSpacePointCKF to add SVD hits to all CDC tracks that don't have SVD hits attached to them.
        ATTENTION: The inverted tracking chain is neither optimised nor guaranteed to be bug free.
        One known issue is a reduced hit efficiency when using the full chain.
        Please remove this comment once the inverted tracking has been optimised and is assumed to be bug-free.
    :param use_cat_finder: if True, it runs the CDC AI Track Finder (CATFinder) as CDC track finding algorithm
        instead of the default one.
    """
 
    if not is_any_detector_present(["SVD", "CDC"], components):
        return
 
    if (add_cdcTrack_QI or add_vxdTrack_QI or add_recoTrack_QI) and not fit_tracks:
        b2.B2ERROR("MVA track qualiy indicator requires `fit_tracks` to be enabled. Turning all off.")
        add_cdcTrack_QI = False
        add_vxdTrack_QI = False
        add_recoTrack_QI = False
 
    if add_recoTrack_QI and not add_cdcTrack_QI:
        b2.B2ERROR("RecoTrack qualiy indicator requires CDC QI as input. Turning it all of.")
        add_cdcTrack_QI = False
        add_recoTrack_QI = False
 
    if not skipGeometryAdding:
        add_geometry_modules(path, components=components)
 
    if not skipHitPreparerAdding:
        add_hit_preparation_modules(path,
                                    components=components,
                                    pxd_filtering_offline=pxd_filtering_offline,
                                    create_intercepts_for_pxd_ckf=create_intercepts_for_pxd_ckf)
 
    # Material effects for all track extrapolations
    if 'SetupGenfitExtrapolation' not in path:
        path.add_module('SetupGenfitExtrapolation',
                        energyLossBrems=False, noiseBrems=False)
 
    if mcTrackFinding:
        add_mc_track_finding(path, components=components, reco_tracks=reco_tracks,
                             use_second_cdc_hits=use_second_cdc_hits)
    else:
        add_track_finding(path, components=components, reco_tracks=reco_tracks,
                          prune_temporary_tracks=prune_temporary_tracks,
                          with_cdc_cellular_automaton=with_cdc_cellular_automaton,
                          use_second_cdc_hits=use_second_cdc_hits,
                          svd_standalone_mode=svd_standalone_mode,
                          use_svd_to_cdc_ckf=use_svd_to_cdc_ckf,
                          svd_ckf_mode=svd_ckf_mode,
                          use_ecl_to_cdc_ckf=use_ecl_to_cdc_ckf,
                          add_cdcTrack_QI=add_cdcTrack_QI,
                          add_vxdTrack_QI=add_vxdTrack_QI,
                          pxd_filtering_offline=pxd_filtering_offline,
                          create_intercepts_for_pxd_ckf=create_intercepts_for_pxd_ckf,
                          inverted_tracking=inverted_tracking,
                          use_cat_finder=use_cat_finder)
 
    # Only run the track time extraction on the full reconstruction chain for now. Later, we may
    # consider to do the CDC-hit based method already during the fast reconstruction stage
    add_time_extraction(path, append_full_grid_cdc_eventt0, components=components,
                        skip_full_grid_cdc_eventt0_if_svd_time_present=skip_full_grid_cdc_eventt0_if_svd_time_present)
 
    if fit_tracks:
        add_prefilter_track_fit_and_track_creator(path, components=components,
                                                  trackFitHypotheses=trackFitHypotheses,
                                                  reco_tracks=reco_tracks,
                                                  stopOnSuccessfulTrackFit=stopOnSuccessfulTrackFit,
                                                  add_mva_quality_indicator=add_recoTrack_QI)
    # estimate the track time
    path.add_module('TrackTimeEstimator')
 
 
def add_postfilter_tracking_reconstruction(path, components=None, pruneTracks=False, reco_tracks="RecoTracks",
                                           fit_tracks=True, trackFitHypotheses=None,
                                           use_second_cdc_hits=False, prune_temporary_tracks=True, v0_finding=True,
                                           flip_recoTrack=True, mcTrackFinding=False, kink_finding=True):
    """
    This function adds the tracking reconstruction modules not required to calculate HLT filter
    decision to a path.
 
    :param path: The path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components.
    :param pruneTracks: Delete all hits except the first and the last in the found tracks.
    :param reco_tracks: Name of the StoreArray where the reco tracks should be stored
    :param use_second_cdc_hits: If true, the second hit information will be used in the CDC track finding.
    :param fit_tracks: If false, the final track fitting and the TrackCreator module will not be executed
    :param trackFitHypotheses: Which pdg hypotheses to fit. Defaults to [211, 321, 2212].
    :param prune_temporary_tracks: If false, store all information of the single CDC and VXD tracks before merging.
        If true, prune them.
    :param v0_finding: If false, the V0 module will not be executed
    :param flip_recoTrack: if true, add the recoTracks flipping function in the postfilter (only if PXD is part of
        the ``components``). This flag is automatically set to false on HLT and ExpressReco.
    :param mcTrackFinding: Use the MC track finders instead of the realistic ones.
    :param kink_finding: if true, add the ``KinkFinder`` module to the path. This flag is automatically set to false
        on HLT and ExpressReco.
    """
 
    # do not add any new modules if no tracking detectors are in the components
    if components and not is_any_detector_present(["SVD", "CDC"], components):
        return
 
    flip_and_refit_temporary_RecoTracks = "RecoTracks_flipped"
    v0finder_temporary_RecoTracks = "CopiedRecoTracks"
    kinkfinder_temporary_RecoTracks = "RecoTracksKinkTmp"
    temporary_reco_track_list = []
 
    if fit_tracks:
        add_postfilter_track_fit_and_track_creator(path,
                                                   trackFitHypotheses=trackFitHypotheses,
                                                   reco_tracks=reco_tracks)
 
    # flip & refit to fix the charge of some tracks
    if flip_recoTrack and not mcTrackFinding and is_detector_present("PXD", components):
        add_flipping_of_recoTracks(path, reco_tracks="RecoTracks", reco_tracks_flipped=flip_and_refit_temporary_RecoTracks)
        temporary_reco_track_list.append(flip_and_refit_temporary_RecoTracks)
 
    # V0 finding
    if v0_finding:
        path.add_module('V0Finder', RecoTracks=reco_tracks, v0FitterMode=1, CopiedRecoTracks=v0finder_temporary_RecoTracks)
        temporary_reco_track_list.append(v0finder_temporary_RecoTracks)
 
    # Kink finding
    if kink_finding:
        path.add_module('KinkFinder', RecoTracks=reco_tracks, CopiedRecoTracks=kinkfinder_temporary_RecoTracks)
        temporary_reco_track_list.append(kinkfinder_temporary_RecoTracks)
 
    add_mc_matcher(path, components=components, reco_tracks=reco_tracks,
                   use_second_cdc_hits=use_second_cdc_hits)
 
    # prune
    if pruneTracks:
        add_prune_tracks(path, components=components, reco_tracks=reco_tracks)
 
    if prune_temporary_tracks or pruneTracks:
        path.add_module("PruneRecoHits")
 
    if prune_temporary_tracks:
        for temporary_reco_tracks in temporary_reco_track_list:
            path.add_module(
                'PruneRecoTracks',
                storeArrayName=temporary_reco_tracks).set_name(
                "PruneRecoTracks " +
                temporary_reco_tracks)
 
 
def add_time_extraction(path, append_full_grid_cdc_eventt0=False, components=None,
                        skip_full_grid_cdc_eventt0_if_svd_time_present=True):
    """
    Add time extraction components via tracking
 
    :param path: The path to add the tracking reconstruction modules to
    :param append_full_grid_cdc_eventt0: If True, the module FullGridChi2TrackTimeExtractor is added to the path
                                      and provides the CDC temporary EventT0.
    :param components: the list of geometry components in use or None for all components.
    :param skip_full_grid_cdc_eventt0_if_svd_time_present: if true, and if also append_full_grid_cdc_eventt0 is true, the
        FullGridChi2TrackTimeExtractor is only executed in the events where no SVD-based EventT0 is found. If false, but
        append_full_grid_cdc_eventt0 is true, FullGridChi2TrackTimeExtractor will be executed in each event regardless of
        SVD EventT0 being present. Has no effect if append_full_grid_cdc_eventt0 is false. Default: true
    """
 
    # Always run SVD EventT0 estimation first so that the CDC based method can check whether an SVD based EventT0 exists
    if is_detector_present("SVD", components):
        path.add_module("SVDEventT0Estimator")
 
    if is_detector_present("CDC", components) and append_full_grid_cdc_eventt0:
        path.add_module("FullGridChi2TrackTimeExtractor",
                        skipIfSVDEventT0Present=skip_full_grid_cdc_eventt0_if_svd_time_present)
 
 
def add_cr_tracking_reconstruction(path, components=None, prune_tracks=False,
                                   skip_geometry_adding=False, event_time_extraction=True,
                                   merge_tracks=True, use_second_cdc_hits=False):
    """
    This function adds the reconstruction modules for cr tracking to a path.
 
    :param path: The path to which to add the tracking reconstruction modules
 
    :param components: the list of geometry components in use or None for all components.
    :param prune_tracks: Delete all hits except the first and the last in the found tracks.
 
    :param skip_geometry_adding: Advanced flag: The tracking modules need the geometry module and will add it,
        if it is not already present in the path. In a setup with multiple (conditional) paths however, it cannot
        determine if the geometry is already loaded. This flag can be used to just turn off the geometry adding
        (but you will have to add it on your own).
    :param event_time_extraction: extract the event time
    :param merge_tracks: The upper and lower half of the tracks should be merged together in one track
    :param use_second_cdc_hits: If true, the second hit information will be used in the CDC track finding.
 
    """
 
    # Set the run for cosmics data
    b2.declare_cosmics()
 
    # make sure CDC is used
    if not is_detector_present("CDC", components):
        return
 
    if not skip_geometry_adding:
        add_geometry_modules(path, components)
 
    add_hit_preparation_modules(path, components=components, create_intercepts_for_pxd_ckf=False)
 
    # Material effects for all track extrapolations
    if 'SetupGenfitExtrapolation' not in path:
        path.add_module('SetupGenfitExtrapolation',
                        energyLossBrems=False, noiseBrems=False)
 
    # track finding
    add_cr_track_finding(path, reco_tracks="RecoTracks", components=components,
                         merge_tracks=merge_tracks, use_second_cdc_hits=use_second_cdc_hits)
 
    # track fitting
    # if tracks were merged, use the unmerged collection for time extraction
    add_cr_track_fit_and_track_creator(path, components=components, prune_tracks=prune_tracks,
                                       event_timing_extraction=event_time_extraction)
 
    if merge_tracks:
        # Do also fit the not merged tracks
        add_cr_track_fit_and_track_creator(path, components=components, prune_tracks=prune_tracks,
                                           event_timing_extraction=False,
                                           reco_tracks="NonMergedRecoTracks", tracks="NonMergedTracks")
 
 
def add_mc_tracking_reconstruction(path, components=None, pruneTracks=False, use_second_cdc_hits=False):
    """
    This function adds the standard reconstruction modules for MC tracking
    to a path.
 
    :param path: The path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components.
    :param pruneTracks: Delete all hits expect the first and the last from the found tracks.
    :param use_second_cdc_hits: If true, the second hit information will be used in the CDC track finding.
    """
    add_tracking_reconstruction(path,
                                components=components,
                                pruneTracks=pruneTracks,
                                mcTrackFinding=True,
                                use_second_cdc_hits=use_second_cdc_hits)
 
 
def add_track_finding(path, components=None, reco_tracks="RecoTracks",
                      prune_temporary_tracks=True, with_cdc_cellular_automaton=False, use_second_cdc_hits=False,
                      use_mc_truth=False, svd_ckf_mode="SVD_after", add_both_directions=True,
                      svd_standalone_mode="VXDTF2",
                      use_svd_to_cdc_ckf=True, use_ecl_to_cdc_ckf=False,
                      add_cdcTrack_QI=True, add_vxdTrack_QI=False,
                      pxd_filtering_offline=False, use_HLT_ROIs=False,
                      create_intercepts_for_pxd_ckf=False,
                      inverted_tracking=False, use_cat_finder=False):
    """
    Add the track finding chain to the path. Depending on the parameters, different tracking chains can be defined and attached.
    :param path: The path to add the tracking reconstruction modules to
    :param reco_tracks: The store array name where to output all tracks
    :param use_mc_truth: Use the truth information in the CKF modules
    :param svd_ckf_mode: how to apply the CKF (with or without SVD standalone tracking). Defaults to "SVD_after".
    :param add_both_directions: Curlers may be found in the wrong orientation by the CDC track finder, so try to
           extrapolate also in the other direction.
    :param svd_standalone_mode: Which SVD standalone tracking is used.
           Options are "VXDTF2", "SVDHough", "VXDTF2_and_SVDHough", and "SVDHough_and_VXDTF2".
           Defaults to "VXDTF2"
    :param with_cdc_cellular_automaton: if true, in the CDC track finding the cellular automaton algorithm will be used too,
        after the global algorithm (Legendre)
    :param use_second_cdc_hits: whether to use the secondary CDC hit during CDC track finding or not
    :param components: the list of geometry components in use or None for all components.
    :param prune_temporary_tracks: If false, store all information of the single CDC and VXD tracks before merging.
        If true, prune them.
    :param use_svd_to_cdc_ckf: if true, add SVD to CDC CKF module.
    :param use_ecl_to_cdc_ckf: if true, add ECL to CDC CKF module.
    :param add_cdcTrack_QI: If true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found CDC standalone tracks
    :param add_vxdTrack_QI: If true, add the MVA track quality estimation
        to the path that sets the quality indicator property of the found VXDTF2 tracks
        (ATTENTION: Standard triplet QI of VXDTF2 is replaced in this case
        -> setting this option to 'True' will have some influence on the final track collection)
    :param pxd_filtering_offline: If True, PXD data reduction (ROI filtering) is applied during the track reconstruction.
        The reconstructed SVD/CDC tracks are used to define the ROIs and reject all PXD clusters outside of these.
    :param use_HLT_ROIs: Don't calculate the ROIs here but use the ones from the HLT (does obviously not work for simulation)
    :param create_intercepts_for_pxd_ckf: If True, the PXDROIFinder is added to the path to create PXDIntercepts to be used
        for hit filtering when creating the CKF relations. This independent of the offline PXD digit filtering which is
        steered by 'pxd_filtering_offline'. This can be applied for both data and MC.
    :param inverted_tracking: If true, start tracking with SVD standalone track finding, followed by ToCDCCKF,
        the CDC standalone tracking, a CKF-based merger to merge the standalone RecoTracks, and finally the
        CDCToSVDSpacePointCKF to add SVD hits to all CDC tracks that don't have SVD hits attached to them.
        ATTENTION: The inverted tracking chain is neither optimised nor guaranteed to be bug free.
        One known issue is a reduced hit efficiency when using the full chain.
        Please remove this comment once the inverted tracking has been optimised and is assumed to be bug-free.
    :param use_cat_finder: if True, it runs the CDC AI Track Finder (CATFinder) as CDC track finding algorithm
        instead of the default one.
    """
    if not is_any_detector_present(["SVD", "CDC"], components):
        return
 
    if use_ecl_to_cdc_ckf and not is_detector_present("CDC", components):
        b2.B2WARNING("ECL CKF cannot be used without CDC. Turning it off.")
        use_ecl_to_cdc_ckf = False
 
    if use_ecl_to_cdc_ckf and not is_detector_present("ECL", components):
        b2.B2ERROR("ECL CKF cannot be used without ECL. Turning it off.")
        use_ecl_to_cdc_ckf = False
 
    # register EventTrackingInfo
    if 'RegisterEventLevelTrackingInfo' not in path:
        path.add_module('RegisterEventLevelTrackingInfo')
 
    # output tracks
    cdc_reco_tracks = "CDCRecoTracks"
    svd_cdc_reco_tracks = "SVDCDCRecoTracks"
    ecl_reco_tracks = "ECLRecoTracks"
    combined_ecl_reco_tracks = "combinedECLRecoTracks"
 
    # temporary collections
    svd_reco_tracks = "SVDRecoTracks"
    pxd_reco_tracks = "PXDRecoTracks"
 
    # collections that will be pruned
    temporary_reco_track_list = []
 
    # the name of the most recent track collection
    latest_reco_tracks = None
 
    if not is_detector_present("PXD", components):
        if use_ecl_to_cdc_ckf and is_detector_present("CDC", components):
            combined_ecl_reco_tracks = reco_tracks
        elif (not use_ecl_to_cdc_ckf) and is_detector_present("SVD", components):
            svd_cdc_reco_tracks = reco_tracks
        elif (not use_ecl_to_cdc_ckf) and (not is_detector_present("SVD", components)) and is_detector_present("CDC", components):
            cdc_reco_tracks = reco_tracks
 
    # Default tracking with CDC first, followed by SVD tracking
    if not inverted_tracking:
        latest_reco_tracks, tmp_reco_track_list = \
            add_default_cdc_svd_tracking_chain(path,
                                               components=components,
                                               svd_reco_tracks=svd_reco_tracks,
                                               cdc_reco_tracks=cdc_reco_tracks,
                                               output_reco_tracks=svd_cdc_reco_tracks,
                                               with_cdc_cellular_automaton=with_cdc_cellular_automaton,
                                               use_second_cdc_hits=use_second_cdc_hits,
                                               add_cdcTrack_QI=add_cdcTrack_QI,
                                               use_mc_truth=use_mc_truth,
                                               svd_ckf_mode=svd_ckf_mode,
                                               add_both_directions=add_both_directions,
                                               use_svd_to_cdc_ckf=use_svd_to_cdc_ckf,
                                               svd_standalone_mode=svd_standalone_mode,
                                               add_vxdTrack_QI=add_vxdTrack_QI,
                                               prune_temporary_tracks=prune_temporary_tracks,
                                               use_cat_finder=use_cat_finder)
 
        temporary_reco_track_list.extend(tmp_reco_track_list)
    else:
        # add the inverted tracking chain with SVD standalone tracking executed first
        # ATTENTION: The inverted tracking chain is neither optimised nor guaranteed to be bug free.
        # One known issue is a reduced hit efficiency when using the full chain.
        # Please remove this comment once the inverted tracking has been optimised and is assumed to be bug-free.
        latest_reco_tracks, tmp_reco_track_list = \
            add_inverted_svd_cdc_tracking_chain(path,
                                                components=components,
                                                svd_reco_tracks=svd_reco_tracks,
                                                cdc_reco_tracks=cdc_reco_tracks,
                                                svd_cdc_reco_tracks=svd_cdc_reco_tracks,
                                                with_cdc_cellular_automaton=with_cdc_cellular_automaton,
                                                use_second_cdc_hits=use_second_cdc_hits,
                                                add_cdcTrack_QI=add_cdcTrack_QI,
                                                use_mc_truth=use_mc_truth,
                                                svd_ckf_mode=svd_ckf_mode,
                                                add_both_directions=add_both_directions,
                                                use_svd_to_cdc_ckf=use_svd_to_cdc_ckf,
                                                svd_standalone_mode=svd_standalone_mode,
                                                add_vxdTrack_QI=add_vxdTrack_QI,
                                                prune_temporary_tracks=prune_temporary_tracks)
 
        temporary_reco_track_list.extend(tmp_reco_track_list)
 
    if use_ecl_to_cdc_ckf and is_detector_present("CDC", components):
        add_eclcdc_track_finding(path, components=components, output_reco_tracks=ecl_reco_tracks,
                                 prune_temporary_tracks=prune_temporary_tracks)
 
        # TODO: add another merging step? (SVD track found by vxdtf2, and CDC track found by ECL CKF)?
 
        path.add_module("RecoTrackStoreArrayCombiner",
                        Temp1RecoTracksStoreArrayName=latest_reco_tracks,
                        Temp2RecoTracksStoreArrayName=ecl_reco_tracks,
                        recoTracksStoreArrayName=combined_ecl_reco_tracks)
        temporary_reco_track_list.append(ecl_reco_tracks)
        temporary_reco_track_list.append(combined_ecl_reco_tracks)
        latest_reco_tracks = combined_ecl_reco_tracks
 
    if is_detector_present("PXD", components):
        """
        In case we want to use offline PXD hit filtering ('pxd_filtering_offline == True'), we can decide to either use ROIs
        created by HLT ('use_HLT_ROIs == True') or to create ROIs on the fly ('use_HLT_ROIs == False').
        In addition, we can also just run the ROI finder to create PXDIntercepts ('create_intercepts_for_pxd_ckf == True')
        that can be used in the ToPXDCKF relation filters to reduce the number of relations that are created. In this case
        there is no need to apply the ROI filtering.
        """
        if pxd_filtering_offline or create_intercepts_for_pxd_ckf:
            roiName = "ROIs"
            intercepts_name = "PXDIntercepts"
            if not use_HLT_ROIs or create_intercepts_for_pxd_ckf:
                path.add_module("DAFRecoFitter", recoTracksStoreArrayName=latest_reco_tracks).set_name(
                    f"DAFRecoFitter {latest_reco_tracks}")
 
                roiName = "ROIs_offline"
                intercepts_name = "CKF" + intercepts_name
                add_roiFinder(path,
                              reco_tracks=latest_reco_tracks,
                              intercepts_name=intercepts_name,
                              roiName=roiName)
 
        if pxd_filtering_offline:
            pxd_digifilter = b2.register_module('PXDdigiFilter')
            pxd_digifilter.param('ROIidsName', roiName)
            pxd_digifilter.param('PXDDigitsName', 'PXDDigits')
            pxd_digifilter.param('PXDDigitsInsideROIName', 'PXDDigits')
            pxd_digifilter.param('overrideDB', True)
            pxd_digifilter.param('usePXDDataReduction', True)
            path.add_module(pxd_digifilter)
 
        if pxd_filtering_offline or create_intercepts_for_pxd_ckf:
            add_pxd_reconstruction(path)
 
        add_pxd_track_finding(path, components=components, input_reco_tracks=latest_reco_tracks,
                              use_mc_truth=use_mc_truth, output_reco_tracks=reco_tracks,
                              temporary_reco_tracks=pxd_reco_tracks,
                              add_both_directions=add_both_directions)
        temporary_reco_track_list.append(pxd_reco_tracks)
 
    if prune_temporary_tracks:
        for temporary_reco_track_name in temporary_reco_track_list:
            if temporary_reco_track_name != reco_tracks:
                path.add_module(
                    'PruneRecoTracks',
                    storeArrayName=temporary_reco_track_name).set_name(
                    "PruneRecoTracks " +
                    temporary_reco_track_name)
 
 
def add_cr_track_finding(path, reco_tracks="RecoTracks", components=None,
                         merge_tracks=True, use_second_cdc_hits=False):
 
    # register EventTrackingInfo
    if 'RegisterEventLevelTrackingInfo' not in path:
        path.add_module('RegisterEventLevelTrackingInfo')
 
    if not is_detector_present("CDC", components):
        b2.B2FATAL("CDC must be in components")
 
    reco_tracks_from_track_finding = reco_tracks
    if merge_tracks:
        reco_tracks_from_track_finding = "NonMergedRecoTracks"
 
    cdc_reco_tracks = "CDCRecoTracks"
    if not is_any_detector_present(["PXD", "SVD"], components):
        cdc_reco_tracks = reco_tracks_from_track_finding
 
    svd_cdc_reco_tracks = "SVDCDCRecoTracks"
    if not is_detector_present("PXD", components):
        svd_cdc_reco_tracks = reco_tracks_from_track_finding
 
    full_reco_tracks = reco_tracks_from_track_finding
 
    # CDC track finding with default settings
    add_cdc_cr_track_finding(path, merge_tracks=False, use_second_cdc_hits=use_second_cdc_hits,
                             output_reco_tracks=cdc_reco_tracks)
 
    latest_reco_tracks = cdc_reco_tracks
 
    if is_detector_present("SVD", components):
        add_svd_track_finding(path, components=components, input_reco_tracks=latest_reco_tracks,
                              output_reco_tracks=svd_cdc_reco_tracks,
                              svd_ckf_mode="cosmics", add_both_directions=True, svd_standalone_mode="VXDTF2")
        latest_reco_tracks = svd_cdc_reco_tracks
 
    if is_detector_present("PXD", components):
        add_pxd_cr_track_finding(path, components=components, input_reco_tracks=latest_reco_tracks,
                                 output_reco_tracks=full_reco_tracks, add_both_directions=True)
 
    if merge_tracks:
        # merge the tracks together
        path.add_module("CosmicsTrackMerger", inputRecoTracks=reco_tracks_from_track_finding,
                        outputRecoTracks=reco_tracks)
 
 
def add_mc_track_finding(path, components=None, reco_tracks="RecoTracks", use_second_cdc_hits=False):
    """
    Add the MC based TrackFinder to the path.
 
    :param path: The path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components.
    :param reco_tracks: Name of the StoreArray where the reco tracks should be stored
    :param use_second_cdc_hits: If true, the second hit information will be used in the CDC track finding.
    """
    if is_any_detector_present(["PXD", "SVD", "CDC"], components):
        # find MCTracks in CDC, SVD and PXD (or a subset of it)
        path.add_module('TrackFinderMCTruthRecoTracks',
                        RecoTracksStoreArrayName=reco_tracks,
                        UseSecondCDCHits=use_second_cdc_hits,
                        UsePXDHits=is_detector_present("PXD", components),
                        UseSVDHits=is_detector_present("SVD", components),
                        UseCDCHits=is_detector_present("CDC", components))
 
 
def add_tracking_for_PXDDataReduction_simulation(path, components, svd_cluster='__ROIsvdClusters'):
    """
    This function adds the standard reconstruction modules for tracking to be used for the simulation of PXD data
    reduction to a path.
 
    :param path: The path to add the tracking reconstruction modules to
    :param components: the list of geometry components in use or None for all components, always exclude the PXD.
    """
 
    if not is_detector_present("SVD", components):
        return
 
    # Material effects
    if 'SetupGenfitExtrapolation' not in path:
        material_effects = b2.register_module('SetupGenfitExtrapolation')
        material_effects.set_name(
            'SetupGenfitExtrapolationForPXDDataReduction')
        path.add_module(material_effects)
 
    # SET StoreArray names
    svd_reco_tracks = "__ROIsvdRecoTracks"
 
    # SVD ONLY TRACK FINDING
    add_svd_standalone_tracking(path, components=['SVD'], reco_tracks=svd_reco_tracks, suffix="__ROI",
                                svd_clusters=svd_cluster)
 
    # TRACK FITTING
    dafRecoFitter = b2.register_module("DAFRecoFitter")
    dafRecoFitter.set_name("SVD-only DAFRecoFitter")
    dafRecoFitter.param('recoTracksStoreArrayName', svd_reco_tracks)
    dafRecoFitter.param('svdHitsStoreArrayName', svd_cluster)
    path.add_module(dafRecoFitter)
 
 
def add_roiFinder(path, reco_tracks="RecoTracks", intercepts_name="PXDIntercepts", roiName="ROIs"):
    """
    Add the ROI finding to the path creating ROIs out of reco tracks by extrapolating them to the PXD volume.
    :param path: Where to add the module to.
    :param reco_tracks: Which tracks to use in the extrapolation step.
    :param roiName: Name of the produced/stored ROIs.
    """
    path.add_module('PXDROIFinder', recoTrackListName=reco_tracks,
                    PXDInterceptListName=intercepts_name, ROIListName=roiName)
 
 
def add_roi_payload_assembler(path, ignore_hlt_decision):
    path.add_module('ROIPayloadAssembler',
                    ROIListName='ROIs', ROIpayloadName='ROIpayload',
                    SendAllDownscaler=0, SendROIsDownscaler=1,
                    AcceptAll=ignore_hlt_decision, NoRejectFlag=False)
 
 
def add_vxd_standalone_cosmics_finder(
        path,
        reco_tracks="RecoTracks",
        pxd_spacepoints_name="PXDSpacePoints",
        svd_spacepoints_name="SVDSpacePoints",
        quality_cut=0.0001,
        min_sps=3,
        max_rejected_sps=5):
    """
    Convenience function for adding VXD standalone cosmics track finding for B = 0 Tesla
    to the path.
 
    The result is a StoreArray with name @param reco_tracks containing one or zero reco tracks per event.
    This track candidates have an arbitrary but large momentum seed in the direction of the fitted line.
    The position and momentum seed is obtained using a principal component analysis method.
 
    :param path: basf2 path
    :param reco_tracks: Name of the output RecoTracks; defaults to RecoTracks.
    :param spacepoints_name: name of store array containing the spacepoints; defaults to SpacePoints
    :param quality_cut: Cut on the chi squared value of the line fit; candidates with values above the cut will be
                        rejected; defaults to 0.0001
    :param min_sps: Minimal number of SpacePoints required to build a track candidate; defaults to 3;
    :param max_rejected_sps: Maximal number of retries to refit a track after the worst spacepoint was removed;
                             defaults to 5;
    """
 
    # register EventTrackingInfo
    if 'RegisterEventLevelTrackingInfo' not in path:
        path.add_module('RegisterEventLevelTrackingInfo')
 
    if "PXDSpacePointCreator" not in [m.name() for m in path.modules()]:
        path.add_module('PXDSpacePointCreator', SpacePoints=pxd_spacepoints_name)
 
    # SVDSpacePointCreator is applied in function add_svd_reconstruction
 
    track_finder = b2.register_module('TrackFinderVXDCosmicsStandalone')
    track_finder.param('SpacePointTrackCandArrayName', "")
    track_finder.param('SpacePoints', [pxd_spacepoints_name, svd_spacepoints_name])
    track_finder.param('QualityCut', quality_cut)
    track_finder.param('MinSPs', min_sps)
    track_finder.param('MaxRejectedSPs', max_rejected_sps)
    path.add_module(track_finder)
 
    converter = b2.register_module('SPTC2RTConverter')
    converter.param('recoTracksStoreArrayName', reco_tracks)
    path.add_module(converter)