ValidationAndOptimisationTask Class Reference

Inheritance diagram for ValidationAndOptimisationTask:

Collaboration diagram for ValidationAndOptimisationTask:

Public Member Functions
def	output (self)
def	requires (self)
def	create_optimisation_and_validation_path (self)
def	create_path (self)

Static Public Attributes
b2luigi	experiment_number = b2luigi.IntParameter()
	Experiment number of the conditions database, e.g.
b2luigi	n_events_training = b2luigi.IntParameter()
	Number of events to generate for the training data set.
b2luigi	fast_bdt_option_state_filter
	FastBDT option to use to train the StateFilters.
b2luigi	fast_bdt_option_result_filter
	FastBDT option to use to train the Result Filter.
b2luigi	n_events_testing = b2luigi.IntParameter()
	Number of events to generate for the testing, validation, and optimisation data set.
b2luigi	state_filter_cut = b2luigi.FloatParameter()
	Value of the cut on the MVA classifier output for accepting a state during CKF tracking.
b2luigi	use_n_best_states = b2luigi.IntParameter()
	How many states should be kept at maximum in the combinatorial part of the CKF tree search.
b2luigi	result_filter_cut = b2luigi.FloatParameter()
	Value of the cut on the MVA classifier output for a result candidate.
b2luigi	use_n_best_results = b2luigi.IntParameter()
	How many results should be kept at maximum to search for overlaps.

Detailed Description

Validate the performance of the trained filters by trying various combinations of FastBDT options, as well as cut values for
the states, the number of best candidates kept after each filter, and similar for the result filter.

Definition at line 799 of file combined_to_pxd_ckf_mva_training.py.

Member Function Documentation

create_optimisation_and_validation_path()

def create_optimisation_and_validation_path

(

self

)

Create a path to validate the trained filters.

Definition at line 872 of file combined_to_pxd_ckf_mva_training.py.

    def create_optimisation_and_validation_path(self):
        """
        Create a path to validate the trained filters.
        """
        path = basf2.create_path()
 
        # get all the file names from the list of input files that are meant for optimisation / validation
        file_list = [fname for sublist in self.get_input_file_names().values()
                     for fname in sublist if "generated_mc_N" in fname and "optimisation" in fname and fname.endswith(".root")]
        path.add_module("RootInput", inputFileNames=file_list)
 
        path.add_module("Gearbox")
        path.add_module("Geometry")
        path.add_module("SetupGenfitExtrapolation")
 
        add_hit_preparation_modules(path, components=["SVD", "PXD"])
 
        add_track_finding(path, reco_tracks="CDCSVDRecoTracks", components=["CDC", "SVD"], prune_temporary_tracks=False)
 
        path.add_module("DAFRecoFitter", recoTracksStoreArrayName="CDCSVDRecoTracks")
 
        fbdt_state_filter_string = create_fbdt_option_string(self.fast_bdt_option_state_filter)
        fbdt_result_filter_string = create_fbdt_option_string(self.fast_bdt_option_result_filter)
        path.add_module("ToPXDCKF",
                        inputRecoTrackStoreArrayName="CDCSVDRecoTracks",
                        outputRecoTrackStoreArrayName="PXDRecoTracks",
                        outputRelationRecoTrackStoreArrayName="CDCSVDRecoTracks",
 
                        relationCheckForDirection="backward",
                        reverseSeed=False,
                        writeOutDirection="backward",
 
                        firstHighFilter="mva_with_direction_check",
                        firstHighFilterParameters={
                            "identifier": self.get_input_file_names(
                                f"trk_ToPXDStateFilter_1{fbdt_state_filter_string}.xml")[0],
                            "cut": self.state_filter_cut,
                            "direction": "backward"},
                        firstHighUseNStates=self.use_n_best_states,
 
                        advanceHighFilter="advance",
                        advanceHighFilterParameters={"direction": "backward"},
 
                        secondHighFilter="mva",
                        secondHighFilterParameters={
                            "identifier": self.get_input_file_names(
                                f"trk_ToPXDStateFilter_2{fbdt_state_filter_string}.xml")[0],
                            "cut": self.state_filter_cut},
                        secondHighUseNStates=self.use_n_best_states,
 
                        updateHighFilter="fit",
 
                        thirdHighFilter="mva",
                        thirdHighFilterParameters={
                            "identifier": self.get_input_file_names(
                                f"trk_ToPXDStateFilter_3{fbdt_state_filter_string}.xml")[0],
                            "cut": self.state_filter_cut},
                        thirdHighUseNStates=self.use_n_best_states,
 
                        filter="mva",
                        filterParameters={
                            "identifier": self.get_input_file_names(
                                f"trk_ToPXDResultFilter{fbdt_result_filter_string}.xml")[0],
                            "cut": self.result_filter_cut},
                        useBestNInSeed=self.use_n_best_results,
 
                        exportTracks=True,
                        enableOverlapResolving=True)
 
        path.add_module('RelatedTracksCombiner',
                        VXDRecoTracksStoreArrayName="PXDRecoTracks",
                        CDCRecoTracksStoreArrayName="CDCSVDRecoTracks",
                        recoTracksStoreArrayName="RecoTracks")
 
        path.add_module('TrackFinderMCTruthRecoTracks',
                        RecoTracksStoreArrayName="MCRecoTracks",
                        WhichParticles=[],
                        UsePXDHits=True,
                        UseSVDHits=True,
                        UseCDCHits=True)
 
        path.add_module("MCRecoTracksMatcher", UsePXDHits=True, UseSVDHits=True, UseCDCHits=True,
                        mcRecoTracksStoreArrayName="MCRecoTracks",
                        prRecoTracksStoreArrayName="RecoTracks")
 
        path.add_module(
            CombinedTrackingValidationModule(
                output_file_name=self.get_output_file_name(
                    f"to_pxd_ckf_validation{fbdt_state_filter_string}_{fbdt_result_filter_string}.root"),
                reco_tracks_name="RecoTracks",
                mc_reco_tracks_name="MCRecoTracks",
                name="",
                contact="",
                expert_level=200))
 
        return path
 

create_path()

def create_path

(

self

)

Create basf2 path to process with event generation and simulation.

Definition at line 969 of file combined_to_pxd_ckf_mva_training.py.

    def create_path(self):
        """
        Create basf2 path to process with event generation and simulation.
        """
        return self.create_optimisation_and_validation_path()
 
 

output()

def output

(

self

)

Generate list of output files that the task should produce.
The task is considered finished if and only if the outputs all exist.

Definition at line 831 of file combined_to_pxd_ckf_mva_training.py.

    def output(self):
        """
        Generate list of output files that the task should produce.
        The task is considered finished if and only if the outputs all exist.
        """
        fbdt_state_filter_string = create_fbdt_option_string(self.fast_bdt_option_state_filter)
        fbdt_result_filter_string = create_fbdt_option_string(self.fast_bdt_option_result_filter)
        yield self.add_to_output(
            f"to_pxd_ckf_validation{fbdt_state_filter_string}_{fbdt_result_filter_string}.root")
 

requires()

def requires

(

self

)

This task requires trained result filters, trained state filters, and that an independent data set for validation was
created using the SplitMergeSimTask with the random seed optimisation.

Definition at line 841 of file combined_to_pxd_ckf_mva_training.py.

    def requires(self):
        """
        This task requires trained result filters, trained state filters, and that an independent data set for validation was
        created using the SplitMergeSimTask with the random seed optimisation.
        """
        fbdt_state_filter_string = create_fbdt_option_string(self.fast_bdt_option_state_filter)
        yield CKFResultFilterTeacherTask(
            result_filter_records_name=f"filter_records{fbdt_state_filter_string}.root",
            experiment_number=self.experiment_number,
            n_events=self.n_events_training,
            fast_bdt_option_state_filter=self.fast_bdt_option_state_filter,
            fast_bdt_option_result_filter=self.fast_bdt_option_result_filter,
            random_seed='training'
        )
        yield SplitNMergeSimTask(
            bkgfiles_dir=MainTask.bkgfiles_by_exp[self.experiment_number],
            experiment_number=self.experiment_number,
            n_events=self.n_events_testing,
            random_seed="optimisation",
        )
        filter_numbers = [1, 2, 3]
        for filter_number in filter_numbers:
            yield self.clone(
                CKFStateFilterTeacherTask,
                experiment_number=self.experiment_number,
                n_events=self.n_events_training,
                random_seed="training",
                filter_number=filter_number,
                fast_bdt_option_state_filter=self.fast_bdt_option_state_filter
            )
 

Member Data Documentation

experiment_number

b2luigi experiment_number = b2luigi.IntParameter()

static

Experiment number of the conditions database, e.g.

defines simulation geometry.

Definition at line 805 of file combined_to_pxd_ckf_mva_training.py.

fast_bdt_option_result_filter

b2luigi fast_bdt_option_result_filter

static

Initial value:

=  b2luigi.ListParameter(
        # ## 
 
 
    )

FastBDT option to use to train the Result Filter.

Definition at line 815 of file combined_to_pxd_ckf_mva_training.py.

fast_bdt_option_state_filter

b2luigi fast_bdt_option_state_filter

static

Initial value:

=  b2luigi.ListParameter(
        # ## 
 
 
    )

FastBDT option to use to train the StateFilters.

Definition at line 809 of file combined_to_pxd_ckf_mva_training.py.

n_events_testing

b2luigi n_events_testing = b2luigi.IntParameter()

static

Number of events to generate for the testing, validation, and optimisation data set.

Definition at line 821 of file combined_to_pxd_ckf_mva_training.py.

n_events_training

b2luigi n_events_training = b2luigi.IntParameter()

static

Number of events to generate for the training data set.

Definition at line 807 of file combined_to_pxd_ckf_mva_training.py.

result_filter_cut

b2luigi result_filter_cut = b2luigi.FloatParameter()

static

Value of the cut on the MVA classifier output for a result candidate.

Definition at line 827 of file combined_to_pxd_ckf_mva_training.py.

state_filter_cut

b2luigi state_filter_cut = b2luigi.FloatParameter()

static

Value of the cut on the MVA classifier output for accepting a state during CKF tracking.

Definition at line 823 of file combined_to_pxd_ckf_mva_training.py.

use_n_best_results

b2luigi use_n_best_results = b2luigi.IntParameter()

static

How many results should be kept at maximum to search for overlaps.

Definition at line 829 of file combined_to_pxd_ckf_mva_training.py.

use_n_best_states

b2luigi use_n_best_states = b2luigi.IntParameter()

static

How many states should be kept at maximum in the combinatorial part of the CKF tree search.

Definition at line 825 of file combined_to_pxd_ckf_mva_training.py.

---

The documentation for this class was generated from the following file:

• tracking/scripts/ckf_training/to_pxd/combined_to_pxd_ckf_mva_training.py