From 28d9dda9f5ed6015e4abe9a03cf4f5a9a9cfe458 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Mon, 4 Jul 2022 17:30:29 +0200 Subject: [PATCH 01/18] added qop to long tracks view --- .../python/AllenConf/calo_reconstruction.py | 10 ++--- .../python/AllenConf/muon_reconstruction.py | 2 + .../secondary_vertex_reconstruction.py | 2 +- .../SciFi/consolidate/src/ConsolidateSciFi.cu | 6 +++ .../include/TrackDigitSelectiveMatching.cuh | 7 ++- .../tools/src/TrackDigitSelectiveMatching.cu | 44 ++++++++++--------- .../common/include/ParticleTypes.cuh | 16 ++++--- .../ParKalman/include/PackageKalman.cuh | 11 +---- .../ParKalman/include/ParKalmanFilter.cuh | 2 + .../ParKalman/include/ParKalmanVeloOnly.cuh | 2 +- device/kalman/ParKalman/src/KalmanPVIPChi2.cu | 18 ++++---- device/kalman/ParKalman/src/PackageTracks.cu | 36 +++++---------- .../kalman/ParKalman/src/ParKalmanFilter.cu | 6 ++- .../kalman/ParKalman/src/ParKalmanVeloOnly.cu | 22 +++++----- device/muon/is_muon/include/IsMuon.cuh | 4 +- device/muon/is_muon/src/IsMuon.cu | 16 ++++--- .../muon/muon_filter/include/MuonFilter.cuh | 2 + device/muon/muon_filter/src/MuonFilter.cu | 5 ++- .../include/MuonFeaturesExtraction.cuh | 2 + .../src/MuonFeaturesExtraction.cu | 6 ++- .../vertex_fitter/src/FilterMFTracks.cu | 2 +- 21 files changed, 116 insertions(+), 105 deletions(-) diff --git a/configuration/python/AllenConf/calo_reconstruction.py b/configuration/python/AllenConf/calo_reconstruction.py index 7d8e1e02331..6c1a0eea6cf 100755 --- a/configuration/python/AllenConf/calo_reconstruction.py +++ b/configuration/python/AllenConf/calo_reconstruction.py @@ -55,14 +55,10 @@ def make_track_matching(decoded_calo, velo_tracks, velo_states, forward_tracks, name="track_digit_selective_matching", host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_offsets_forward_tracks_t=forward_tracks[ - "dev_offsets_forward_tracks"], - dev_offsets_scifi_track_hit_number_t=forward_tracks[ - "dev_offsets_scifi_track_hit_number"], - dev_scifi_qop_t=forward_tracks["dev_scifi_qop"], - dev_scifi_track_ut_indices_t=forward_tracks[ - "dev_scifi_track_ut_indices"], dev_scifi_states_t=forward_tracks["dev_scifi_states"], + dev_scifi_tracks_view_t=forward_tracks["dev_scifi_tracks_view"], + dev_long_tracks_view_t=forward_tracks[ + "dev_multi_event_long_tracks_view"], dev_ecal_digits_t=decoded_calo["dev_ecal_digits"], dev_ecal_digits_offsets_t=decoded_calo["dev_ecal_digits_offsets"], dev_number_of_events_t=number_of_events["dev_number_of_events"]) diff --git a/configuration/python/AllenConf/muon_reconstruction.py b/configuration/python/AllenConf/muon_reconstruction.py index 5c602d319d6..c5fcad69fd9 100644 --- a/configuration/python/AllenConf/muon_reconstruction.py +++ b/configuration/python/AllenConf/muon_reconstruction.py @@ -114,6 +114,8 @@ def is_muon(decoded_muon, forward_tracks): host_number_of_reconstructed_scifi_tracks, dev_scifi_tracks_view_t=dev_scifi_tracks_view, dev_scifi_states_t=dev_scifi_states, + dev_long_tracks_view_t=forward_tracks[ + "dev_multi_event_long_tracks_view"], dev_station_ocurrences_offset_t=decoded_muon[ "dev_station_ocurrences_offset"], dev_muon_hits_t=decoded_muon["dev_muon_hits"]) diff --git a/configuration/python/AllenConf/secondary_vertex_reconstruction.py b/configuration/python/AllenConf/secondary_vertex_reconstruction.py index caeb5155cda..e436375ee93 100644 --- a/configuration/python/AllenConf/secondary_vertex_reconstruction.py +++ b/configuration/python/AllenConf/secondary_vertex_reconstruction.py @@ -42,7 +42,7 @@ def make_kalman_velo_only(forward_tracks, dev_number_of_events_t=number_of_events["dev_number_of_events"], host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_scifi_tracks_view_t=forward_tracks[ + dev_long_tracks_view_t=forward_tracks[ "dev_multi_event_long_tracks_view"], dev_offsets_forward_tracks_t=forward_tracks[ "dev_offsets_forward_tracks"], diff --git a/device/SciFi/consolidate/src/ConsolidateSciFi.cu b/device/SciFi/consolidate/src/ConsolidateSciFi.cu index 6a39a659572..04bdd0e850b 100644 --- a/device/SciFi/consolidate/src/ConsolidateSciFi.cu +++ b/device/SciFi/consolidate/src/ConsolidateSciFi.cu @@ -251,6 +251,7 @@ __device__ void scifi_consolidate_tracks_impl( number_of_events}; const unsigned number_of_tracks_event = scifi_tracks.number_of_tracks(event_number); const unsigned event_offset = scifi_hit_count.event_offset(); + float* tracks_qop = parameters.dev_scifi_qop + parameters.dev_atomics_scifi[event_number]; // Loop over tracks. for (unsigned i = threadIdx.x; i < number_of_tracks_event; i += blockDim.x) { @@ -308,9 +309,14 @@ __device__ void scifi_consolidate_tracks_impl( const auto txO = velo_state.tx(); const auto tyO = velo_state.ty(); + //QoP for scifi tracks scifi_tracks.qop(i) = qop_calculation(dev_looking_forward_constants, magSign, z0, x0, y0, xVelo, yVelo, zVelo, txO, tyO, tx, ty); + //QoP for long tracks + tracks_qop[i] = + qop_calculation(dev_looking_forward_constants, magSign, z0, x0, y0, xVelo, yVelo, zVelo, txO, tyO, tx, ty); + // Populate arrays populate(track, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { consolidated_hits.x0(i) = scifi_hits.x0(event_offset + hit_index); diff --git a/device/calo/tools/include/TrackDigitSelectiveMatching.cuh b/device/calo/tools/include/TrackDigitSelectiveMatching.cuh index bcd1340c5ae..1d186717165 100644 --- a/device/calo/tools/include/TrackDigitSelectiveMatching.cuh +++ b/device/calo/tools/include/TrackDigitSelectiveMatching.cuh @@ -8,6 +8,7 @@ #include "SciFiConsolidated.cuh" #include "CaloGeometry.cuh" #include "CaloDigit.cuh" +#include "ParticleTypes.cuh" namespace track_digit_selective_matching { struct Parameters { @@ -15,11 +16,9 @@ namespace track_digit_selective_matching { MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; // SciFi tracks - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; - DEVICE_INPUT(dev_offsets_scifi_track_hit_number_t, unsigned) dev_scifi_track_hit_number; - DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; - DEVICE_INPUT(dev_scifi_track_ut_indices_t, unsigned) dev_scifi_track_ut_indices; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; + DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; // Calo digits DEVICE_INPUT(dev_ecal_digits_t, CaloDigit) dev_ecal_digits; DEVICE_INPUT(dev_ecal_digits_offsets_t, unsigned) dev_ecal_digits_offsets; diff --git a/device/calo/tools/src/TrackDigitSelectiveMatching.cu b/device/calo/tools/src/TrackDigitSelectiveMatching.cu index 89cd7ac0c7c..5b1e9b5587a 100644 --- a/device/calo/tools/src/TrackDigitSelectiveMatching.cu +++ b/device/calo/tools/src/TrackDigitSelectiveMatching.cu @@ -45,26 +45,28 @@ __global__ void track_digit_selective_matching::track_digit_selective_matching( const unsigned number_of_events = parameters.dev_number_of_events[0]; const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + // Long tracks. + const auto long_tracks = parameters.dev_long_tracks_view->container(event_number); - // Create SciFi tracks - SciFi::Consolidated::ConstTracks scifi_tracks {parameters.dev_atomics_scifi, - parameters.dev_scifi_track_hit_number, - parameters.dev_scifi_qop, - parameters.dev_scifi_states, - parameters.dev_scifi_track_ut_indices, - event_number, - number_of_events}; + const unsigned n_long_tracks = long_tracks.size(); + const unsigned event_offset = long_tracks.offset(); + + // SciFi tracks + const auto scifi_tracks_view = parameters.dev_scifi_tracks_view[event_number]; + const auto scifi_states = parameters.dev_scifi_states + scifi_tracks_view.offset(); // Get ECAL digits auto ecal_geometry = CaloGeometry(raw_ecal_geometry); const unsigned digits_offset = parameters.dev_ecal_digits_offsets[event_number]; auto const* digits = parameters.dev_ecal_digits + digits_offset; - // Loop over the SciFi tracks in parallel - for (unsigned track_index = threadIdx.x; track_index < scifi_tracks.number_of_tracks(event_number); - track_index += blockDim.x) { + // Loop over the long tracks in parallel + for (unsigned track_index = threadIdx.x; track_index < n_long_tracks; track_index += blockDim.x) { + const auto long_track = long_tracks.track(track_index); + const auto scifi_track = long_track.track_segment(); + const auto scifi_track_id = scifi_track.track_index(); // SciFi state - const auto& scifi_state = scifi_tracks.states(track_index); + const auto& scifi_state = scifi_states[scifi_track_id]; // Get z positions of intersection of the track and front, showermax and back planes float z_front = ecal_geometry.getZFromTrackToCaloplaneIntersection(scifi_state, 0); @@ -100,13 +102,15 @@ __global__ void track_digit_selective_matching::track_digit_selective_matching( sum_cell_E, digit_indices); - parameters.dev_matched_ecal_energy[track_index + scifi_tracks.tracks_offset(event_number)] = sum_cell_E; - parameters.dev_matched_ecal_digits[track_index + scifi_tracks.tracks_offset(event_number)] = digit_indices; - parameters.dev_matched_ecal_digits_size[track_index + scifi_tracks.tracks_offset(event_number)] = N_matched_digits; - parameters.dev_track_inEcalAcc[track_index + scifi_tracks.tracks_offset(event_number)] = inAcc; - parameters.dev_track_Eop[track_index + scifi_tracks.tracks_offset(event_number)] = - sum_cell_E * fabsf(scifi_tracks.qop(track_index)); - parameters.dev_track_isElectron[track_index + scifi_tracks.tracks_offset(event_number)] = - parameters.dev_track_Eop[track_index + scifi_tracks.tracks_offset(event_number)] > 0.7f; + parameters.dev_matched_ecal_energy[track_index + event_offset] = sum_cell_E; + parameters.dev_matched_ecal_digits[track_index + event_offset] = digit_indices; + parameters.dev_matched_ecal_digits_size[track_index + event_offset] = N_matched_digits; + parameters.dev_track_inEcalAcc[track_index + event_offset] = inAcc; + parameters.dev_track_Eop[track_index + event_offset] = + // sum_cell_E * fabsf(scifi_tracks.qop(track_index)); + sum_cell_E * fabsf(long_track.qop()); + // Bit shift by 1 so this can be combined with the muon ID to create a single lepton ID object. + parameters.dev_track_isElectron[track_index + event_offset] = + (parameters.dev_track_Eop[track_index + event_offset] > 0.7f) << 1; } } diff --git a/device/event_model/common/include/ParticleTypes.cuh b/device/event_model/common/include/ParticleTypes.cuh index 1ff88dc0ff1..f61380d00d7 100644 --- a/device/event_model/common/include/ParticleTypes.cuh +++ b/device/event_model/common/include/ParticleTypes.cuh @@ -60,6 +60,7 @@ namespace Allen { const Allen::Views::Velo::Consolidated::Track* m_velo_segment = nullptr; const Allen::Views::UT::Consolidated::Track* m_ut_segment = nullptr; const Allen::Views::SciFi::Consolidated::Track* m_scifi_segment = nullptr; + const float* m_qop = nullptr; public: Track() = default; @@ -67,10 +68,12 @@ namespace Allen { __host__ __device__ Track( const Allen::Views::Velo::Consolidated::Track* velo_segment, const Allen::Views::UT::Consolidated::Track* ut_segment, - const Allen::Views::SciFi::Consolidated::Track* scifi_segment) : + const Allen::Views::SciFi::Consolidated::Track* scifi_segment, + const float* qop) : m_velo_segment(velo_segment), - m_ut_segment(ut_segment), m_scifi_segment(scifi_segment) + m_ut_segment(ut_segment), m_scifi_segment(scifi_segment), m_qop(qop) {} + __host__ __device__ float qop() const { return *m_qop; } enum struct segment { velo, ut, scifi }; @@ -154,11 +157,10 @@ namespace Allen { __host__ __device__ LongTrack( const Allen::Views::Velo::Consolidated::Track* velo_segment, const Allen::Views::UT::Consolidated::Track* ut_segment, - const Allen::Views::SciFi::Consolidated::Track* scifi_segment) : - Track {velo_segment, ut_segment, scifi_segment} + const Allen::Views::SciFi::Consolidated::Track* scifi_segment, + const float* qop) : + Track {velo_segment, ut_segment, scifi_segment, qop} {} - - __host__ __device__ float qop() const { return m_scifi_segment->qop(); } }; struct LongTracks : ILHCbIDContainer { @@ -189,6 +191,8 @@ namespace Allen { __host__ __device__ unsigned size() const { return m_size; } + __host__ __device__ float qop(const unsigned index) const { return m_track[index].qop(); } + __host__ __device__ const LongTrack& track(const unsigned index) const { return id_sequence_impl(index); } __host__ __device__ unsigned offset() const { return m_offset; } diff --git a/device/kalman/ParKalman/include/PackageKalman.cuh b/device/kalman/ParKalman/include/PackageKalman.cuh index dd7c77e1a79..a6fae77bb9a 100644 --- a/device/kalman/ParKalman/include/PackageKalman.cuh +++ b/device/kalman/ParKalman/include/PackageKalman.cuh @@ -14,22 +14,15 @@ #include "States.cuh" #include "SciFiDefinitions.cuh" #include "AlgorithmTypes.cuh" +#include "ParticleTypes.cuh" namespace package_kalman_tracks { struct Parameters { HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; HOST_INPUT(host_number_of_reconstructed_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_atomics_velo_t, unsigned) dev_atomics_velo; DEVICE_INPUT(dev_velo_track_hit_number_t, unsigned) dev_velo_track_hit_number; - DEVICE_INPUT(dev_atomics_ut_t, unsigned) dev_atomics_ut; - DEVICE_INPUT(dev_ut_track_hit_number_t, unsigned) dev_ut_track_hit_number; - DEVICE_INPUT(dev_ut_qop_t, float) dev_ut_qop; - DEVICE_INPUT(dev_ut_track_velo_indices_t, unsigned) dev_ut_track_velo_indices; - DEVICE_INPUT(dev_atomics_scifi_t, unsigned) dev_atomics_scifi; - DEVICE_INPUT(dev_scifi_track_hit_number_t, unsigned) dev_scifi_track_hit_number; - DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; - DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; - DEVICE_INPUT(dev_scifi_track_ut_indices_t, unsigned) dev_scifi_track_ut_indices; DEVICE_INPUT(dev_velo_kalman_beamline_states_t, char) dev_velo_kalman_beamline_states; DEVICE_INPUT(dev_is_muon_t, bool) dev_is_muon; DEVICE_OUTPUT(dev_kf_tracks_t, ParKalmanFilter::FittedTrack) dev_kf_tracks; diff --git a/device/kalman/ParKalman/include/ParKalmanFilter.cuh b/device/kalman/ParKalman/include/ParKalmanFilter.cuh index 19b562ae596..7504fddef08 100644 --- a/device/kalman/ParKalman/include/ParKalmanFilter.cuh +++ b/device/kalman/ParKalman/include/ParKalmanFilter.cuh @@ -17,6 +17,7 @@ #include "SciFiDefinitions.cuh" #include "AlgorithmTypes.cuh" +#include "ParticleTypes.cuh" namespace ParKalmanFilter { @@ -125,6 +126,7 @@ namespace kalman_filter { DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; DEVICE_INPUT(dev_scifi_track_ut_indices_t, unsigned) dev_scifi_track_ut_indices; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_OUTPUT(dev_kf_tracks_t, ParKalmanFilter::FittedTrack) dev_kf_tracks; PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; }; diff --git a/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh b/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh index 8295be8f9ba..566de3cf527 100644 --- a/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh +++ b/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh @@ -89,7 +89,7 @@ namespace kalman_velo_only { HOST_INPUT(host_number_of_reconstructed_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; - DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_scifi_tracks_view; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_multi_final_vertices_t, PV::Vertex) dev_multi_final_vertices; DEVICE_INPUT(dev_number_of_multi_final_vertices_t, unsigned) dev_number_of_multi_final_vertices; diff --git a/device/kalman/ParKalman/src/KalmanPVIPChi2.cu b/device/kalman/ParKalman/src/KalmanPVIPChi2.cu index d5e123662a2..264f79728ea 100644 --- a/device/kalman/ParKalman/src/KalmanPVIPChi2.cu +++ b/device/kalman/ParKalman/src/KalmanPVIPChi2.cu @@ -81,27 +81,25 @@ __global__ void kalman_velo_only::kalman_pv_ipchi2(kalman_velo_only::Parameters { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - const auto event_scifi_tracks = parameters.dev_scifi_tracks_view->container(event_number); + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_number); const auto kalman_states_view = parameters.dev_kalman_states_view[event_number]; - const unsigned total_number_of_scifi_tracks = parameters.dev_scifi_tracks_view->number_of_contained_objects(); + const unsigned total_number_of_long_tracks = parameters.dev_long_tracks_view->number_of_contained_objects(); // The total track-PV association table. - Associate::Consolidated::Table kalman_pv_ipchi2 {parameters.dev_kalman_pv_ipchi2, total_number_of_scifi_tracks}; - parameters.dev_kalman_pv_tables[event_number] = Allen::Views::Physics::PVTable {parameters.dev_kalman_pv_ipchi2, - event_scifi_tracks.offset(), - total_number_of_scifi_tracks, - event_scifi_tracks.size()}; + Associate::Consolidated::Table kalman_pv_ipchi2 {parameters.dev_kalman_pv_ipchi2, total_number_of_long_tracks}; + parameters.dev_kalman_pv_tables[event_number] = Allen::Views::Physics::PVTable { + parameters.dev_kalman_pv_ipchi2, event_long_tracks.offset(), total_number_of_long_tracks, event_long_tracks.size()}; // Kalman-fitted tracks for this event. - ParKalmanFilter::FittedTrack* event_tracks = parameters.dev_kf_tracks + event_scifi_tracks.offset(); - const bool* event_is_muon = parameters.dev_is_muon + event_scifi_tracks.offset(); + ParKalmanFilter::FittedTrack* event_tracks = parameters.dev_kf_tracks + event_long_tracks.offset(); + const bool* event_is_muon = parameters.dev_is_muon + event_long_tracks.offset(); Allen::device::span vertices {parameters.dev_multi_final_vertices + event_number * PV::max_number_vertices, *(parameters.dev_number_of_multi_final_vertices + event_number)}; // The track <-> PV association table for this event. Associate::Consolidated::EventTable pv_table = - kalman_pv_ipchi2.event_table(event_scifi_tracks.offset(), event_scifi_tracks.size()); + kalman_pv_ipchi2.event_table(event_long_tracks.offset(), event_long_tracks.size()); // Perform the association for this event. associate_and_muon_id(event_tracks, kalman_states_view, event_is_muon, vertices, pv_table); diff --git a/device/kalman/ParKalman/src/PackageTracks.cu b/device/kalman/ParKalman/src/PackageTracks.cu index ca9056554bb..211aaadc5c2 100644 --- a/device/kalman/ParKalman/src/PackageTracks.cu +++ b/device/kalman/ParKalman/src/PackageTracks.cu @@ -30,37 +30,23 @@ __global__ void package_kalman_tracks::package_kalman_tracks(package_kalman_trac const unsigned number_of_events = gridDim.x; const unsigned event_number = blockIdx.x; + // Long tracks. + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_number); + const unsigned n_long_tracks = parameters.dev_long_tracks_view->number_of_contained_objects(); + // Create velo tracks. Velo::Consolidated::ConstTracks velo_tracks { parameters.dev_atomics_velo, parameters.dev_velo_track_hit_number, event_number, number_of_events}; - // Create UT tracks. - UT::Consolidated::ConstExtendedTracks ut_tracks {parameters.dev_atomics_ut, - parameters.dev_ut_track_hit_number, - parameters.dev_ut_qop, - parameters.dev_ut_track_velo_indices, - event_number, - number_of_events}; - - // Create SciFi tracks. - SciFi::Consolidated::ConstTracks scifi_tracks {parameters.dev_atomics_scifi, - parameters.dev_scifi_track_hit_number, - parameters.dev_scifi_qop, - parameters.dev_scifi_states, - parameters.dev_scifi_track_ut_indices, - event_number, - number_of_events}; - - const unsigned n_scifi_tracks = scifi_tracks.number_of_tracks(event_number); - for (unsigned i_scifi_track = threadIdx.x; i_scifi_track < n_scifi_tracks; i_scifi_track += blockDim.x) { + for (unsigned i_long_track = threadIdx.x; i_long_track < n_long_tracks; i_long_track += blockDim.x) { // Prepare fit input. - const int i_ut_track = scifi_tracks.ut_track(i_scifi_track); - const int i_velo_track = ut_tracks.velo_track(i_ut_track); + const auto long_track = event_long_tracks.track(i_long_track); + const auto velo_track = long_track.track_segment(); Velo::Consolidated::ConstStates kalmanvelo_states {parameters.dev_velo_kalman_beamline_states, velo_tracks.total_number_of_tracks()}; - parameters.dev_kf_tracks[scifi_tracks.tracks_offset(event_number) + i_scifi_track] = ParKalmanFilter::FittedTrack { - kalmanvelo_states.get_kalman_state(velo_tracks.tracks_offset(event_number) + i_velo_track), - scifi_tracks.qop(i_scifi_track), - parameters.dev_is_muon[scifi_tracks.tracks_offset(event_number) + i_scifi_track]}; + parameters.dev_kf_tracks[event_long_tracks.offset() + i_long_track] = ParKalmanFilter::FittedTrack { + kalmanvelo_states.get_kalman_state(velo_tracks.tracks_offset(event_number) + velo_track.track_index()), + long_track.qop(), + parameters.dev_is_muon[event_long_tracks.offset() + i_long_track]}; } } \ No newline at end of file diff --git a/device/kalman/ParKalman/src/ParKalmanFilter.cu b/device/kalman/ParKalman/src/ParKalmanFilter.cu index f799ff06222..f62254757e7 100644 --- a/device/kalman/ParKalman/src/ParKalmanFilter.cu +++ b/device/kalman/ParKalman/src/ParKalmanFilter.cu @@ -240,6 +240,9 @@ __global__ void kalman_filter::kalman_filter( event_number, number_of_events}; + // Long tracks. + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_number); + const SciFi::SciFiGeometry scifi_geometry {dev_scifi_geometry}; // Loop over SciFi tracks and get associated UT and VELO tracks. @@ -256,7 +259,8 @@ __global__ void kalman_filter::kalman_filter( const int i_velo_track = ut_tracks.velo_track(i_ut_track); Velo::Consolidated::ConstHits velo_hits = velo_tracks.get_hits(parameters.dev_velo_track_hits, i_velo_track); const unsigned n_velo_hits = velo_tracks.number_of_hits(i_velo_track); - const KalmanFloat init_qop = (KalmanFloat) scifi_tracks.qop(i_scifi_track); + const auto long_track = event_long_tracks.track(i_scifi_track); + const KalmanFloat init_qop = (KalmanFloat) long_track.qop(); fit( velo_hits, n_velo_hits, diff --git a/device/kalman/ParKalman/src/ParKalmanVeloOnly.cu b/device/kalman/ParKalman/src/ParKalmanVeloOnly.cu index d1e2b43f733..ffc802db340 100644 --- a/device/kalman/ParKalman/src/ParKalmanVeloOnly.cu +++ b/device/kalman/ParKalman/src/ParKalmanVeloOnly.cu @@ -530,26 +530,24 @@ __global__ void kalman_velo_only::kalman_velo_only(kalman_velo_only::Parameters const unsigned event_number = parameters.dev_event_list[blockIdx.x]; const unsigned number_of_events = parameters.dev_number_of_events[0]; - // Forward tracks. - const auto event_scifi_tracks = parameters.dev_scifi_tracks_view->container(event_number); - const unsigned total_number_of_tracks = parameters.dev_scifi_tracks_view->number_of_contained_objects(); + // Long tracks. + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_number); + const unsigned total_number_of_tracks = parameters.dev_long_tracks_view->number_of_contained_objects(); parameters.dev_kalman_states_view[event_number] = Allen::Views::Physics::KalmanStates { parameters.dev_kalman_fit_results, parameters.dev_atomics_scifi, event_number, number_of_events}; // TODO: It'd be nice not to need the total number of tracks here. Velo::Consolidated::States kalman_states {parameters.dev_kalman_fit_results, total_number_of_tracks}; - // Loop over SciFi tracks and get associated UT and VELO tracks. - const unsigned n_scifi_tracks = event_scifi_tracks.size(); - for (unsigned i_scifi_track = threadIdx.x; i_scifi_track < n_scifi_tracks; i_scifi_track += blockDim.x) { - const auto scifi_track = event_scifi_tracks.track(i_scifi_track); - const auto velo_track = scifi_track.track_segment(); - const KalmanFloat init_qop = (KalmanFloat) scifi_track.qop(); + const unsigned n_long_tracks = event_long_tracks.size(); + for (unsigned i_long_track = threadIdx.x; i_long_track < n_long_tracks; i_long_track += blockDim.x) { + const auto long_track = event_long_tracks.track(i_long_track); + const auto velo_track = long_track.track_segment(); + const KalmanFloat init_qop = (KalmanFloat) long_track.qop(); ParKalmanFilter::FittedTrack kalman_track; - simplified_fit(velo_track, init_qop, kalman_track); - set_fit_result(event_scifi_tracks.offset() + i_scifi_track, kalman_track, kalman_states); - parameters.dev_kf_tracks[event_scifi_tracks.offset() + i_scifi_track] = kalman_track; + set_fit_result(event_long_tracks.offset() + i_long_track, kalman_track, kalman_states); + parameters.dev_kf_tracks[event_long_tracks.offset() + i_long_track] = kalman_track; } } diff --git a/device/muon/is_muon/include/IsMuon.cuh b/device/muon/is_muon/include/IsMuon.cuh index 1994922e1e9..c1327ea48d6 100644 --- a/device/muon/is_muon/include/IsMuon.cuh +++ b/device/muon/is_muon/include/IsMuon.cuh @@ -7,6 +7,7 @@ #include "MuonDefinitions.cuh" #include "States.cuh" #include "SciFiConsolidated.cuh" +#include "ParticleTypes.cuh" namespace is_muon { struct Parameters { @@ -15,6 +16,7 @@ namespace is_muon { MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; DEVICE_INPUT(dev_station_ocurrences_offset_t, unsigned) dev_station_ocurrences_offset; DEVICE_INPUT(dev_muon_hits_t, char) dev_muon_hits; @@ -43,4 +45,4 @@ namespace is_muon { private: Property m_block_dim_x {this, 128}; }; -} // namespace is_muon \ No newline at end of file +} // namespace is_muon diff --git a/device/muon/is_muon/src/IsMuon.cu b/device/muon/is_muon/src/IsMuon.cu index 9dd5d4ba3ac..fcbc800d02d 100644 --- a/device/muon/is_muon/src/IsMuon.cu +++ b/device/muon/is_muon/src/IsMuon.cu @@ -103,18 +103,24 @@ __global__ void is_muon::is_muon( const auto station_ocurrences_offset = parameters.dev_station_ocurrences_offset + event_number * Muon::Constants::n_stations; + // Long tracks. + const auto long_tracks = parameters.dev_long_tracks_view->container(event_number); + + // SciFi tracks and states const auto scifi_tracks_view = parameters.dev_scifi_tracks_view[event_number]; const auto scifi_states = parameters.dev_scifi_states + scifi_tracks_view.offset(); const auto muon_hits = Muon::ConstHits {parameters.dev_muon_hits, muon_total_number_of_hits}; - const unsigned number_of_tracks_event = scifi_tracks_view.size(); - const unsigned event_offset = scifi_tracks_view.offset(); + const unsigned number_of_tracks_event = long_tracks.size(); + const unsigned event_offset = long_tracks.offset(); for (unsigned track_id = threadIdx.x; track_id < number_of_tracks_event; track_id += blockDim.x) { - const auto scifi_track = scifi_tracks_view.track(track_id); - const float momentum = 1.f / fabsf(scifi_track.qop()); - const auto& state = scifi_states[track_id]; + const auto long_track = long_tracks.track(track_id); + const auto scifi_track = long_track.track_segment(); + const auto scifi_track_id = scifi_track.track_index(); + const float momentum = 1.f / fabsf(long_tracks.qop(track_id)); + const auto& state = scifi_states[scifi_track_id]; if (momentum < dev_muon_momentum_cuts[0]) { continue; diff --git a/device/muon/muon_filter/include/MuonFilter.cuh b/device/muon/muon_filter/include/MuonFilter.cuh index f492c9818ed..34086c67bdf 100644 --- a/device/muon/muon_filter/include/MuonFilter.cuh +++ b/device/muon/muon_filter/include/MuonFilter.cuh @@ -12,6 +12,7 @@ #include "VeloConsolidated.cuh" #include "UTConsolidated.cuh" #include "SystemOfUnits.h" +#include "ParticleTypes.cuh" namespace MuonFilter { struct Parameters { @@ -30,6 +31,7 @@ namespace MuonFilter { DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; DEVICE_INPUT(dev_scifi_track_ut_indices_t, unsigned) dev_scifi_track_ut_indices; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_is_muon_t, bool) dev_is_muon; DEVICE_INPUT(dev_kalman_pv_ipchi2_t, char) dev_kalman_pv_ipchi2; DEVICE_OUTPUT(dev_mf_decisions_t, unsigned) dev_mf_decisions; diff --git a/device/muon/muon_filter/src/MuonFilter.cu b/device/muon/muon_filter/src/MuonFilter.cu index ad08e3e9470..a45a625c154 100644 --- a/device/muon/muon_filter/src/MuonFilter.cu +++ b/device/muon/muon_filter/src/MuonFilter.cu @@ -42,6 +42,9 @@ __global__ void MuonFilter::muon_filter(MuonFilter::Parameters parameters) const unsigned number_of_events = gridDim.x; const unsigned i_event = blockIdx.x; + // Long tracks. + const auto long_tracks = parameters.dev_long_tracks_view->container(i_event); + Velo::Consolidated::ConstTracks velo_tracks { parameters.dev_atomics_velo, parameters.dev_velo_track_hit_number, i_event, number_of_events}; @@ -79,7 +82,7 @@ __global__ void MuonFilter::muon_filter(MuonFilter::Parameters parameters) auto i_ut_track = scifi_tracks.ut_track(i_scifi_track); auto i_velo_track = ut_tracks.velo_track(i_ut_track); unsigned i_velo_state = velo_tracks.tracks_offset(i_event) + i_velo_track; - const float p = 1.f / fabsf(scifi_tracks.qop(i_scifi_track)); + const float p = 1.f / fabsf(long_tracks.qop(i_scifi_track)); const float tx2 = velo_states.tx(i_velo_state) * velo_states.tx(i_velo_state); const float ty2 = velo_states.ty(i_velo_state) * velo_states.ty(i_velo_state); const float pT = p * sqrtf((tx2 + ty2) / (1.f + tx2 + ty2)); diff --git a/device/muon/preprocessing/include/MuonFeaturesExtraction.cuh b/device/muon/preprocessing/include/MuonFeaturesExtraction.cuh index c9fa6608d01..4464167e3ae 100644 --- a/device/muon/preprocessing/include/MuonFeaturesExtraction.cuh +++ b/device/muon/preprocessing/include/MuonFeaturesExtraction.cuh @@ -7,6 +7,7 @@ #include "MuonDefinitions.cuh" #include "States.cuh" #include "SciFiConsolidated.cuh" +#include "ParticleTypes.cuh" enum offset { DTS = 0, @@ -26,6 +27,7 @@ namespace muon_catboost_features_extraction { DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; DEVICE_INPUT(dev_scifi_track_ut_indices_t, unsigned) dev_scifi_track_ut_indices; DEVICE_INPUT(dev_station_ocurrences_offset_t, unsigned) dev_station_ocurrences_offset; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_muon_hits_t, char) dev_muon_hits; MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; diff --git a/device/muon/preprocessing/src/MuonFeaturesExtraction.cu b/device/muon/preprocessing/src/MuonFeaturesExtraction.cu index 4f411e50f15..9eb5848fad1 100644 --- a/device/muon/preprocessing/src/MuonFeaturesExtraction.cu +++ b/device/muon/preprocessing/src/MuonFeaturesExtraction.cu @@ -33,6 +33,8 @@ __global__ void muon_catboost_features_extraction::muon_catboost_features_extrac const unsigned number_of_events = parameters.dev_number_of_events[0]; const unsigned event_id = parameters.dev_event_list[blockIdx.x]; const unsigned station_id = blockIdx.y; + // Long tracks. + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_id); SciFi::Consolidated::ConstTracks scifi_tracks {parameters.dev_atomics_scifi, parameters.dev_scifi_track_hit_number, @@ -55,6 +57,8 @@ __global__ void muon_catboost_features_extraction::muon_catboost_features_extrac float min_dist = 1e10; int index_of_closest_hit = -1; + const auto long_track = event_long_tracks.track(track_id); + const int number_of_hits = station_ocurrences_offset[station_id + 1] - station_ocurrences_offset[station_id]; const float station_z = muon_hits.z(muon_event_offset); const float station_z0 = muon_hits.z(0); @@ -84,7 +88,7 @@ __global__ void muon_catboost_features_extraction::muon_catboost_features_extrac const unsigned tracks_features_offset = (event_offset + track_id) * Muon::Constants::n_catboost_features; if (index_of_closest_hit > -1) { - const float common_factor = Muon::Constants::MSFACTOR * fabsf(scifi_tracks.qop(track_id)); + const float common_factor = Muon::Constants::MSFACTOR * fabsf(long_track.qop()); const int idx = muon_event_offset + index_of_closest_hit; diff --git a/device/vertex_fit/vertex_fitter/src/FilterMFTracks.cu b/device/vertex_fit/vertex_fitter/src/FilterMFTracks.cu index a6eacfa7d33..75d9590e854 100644 --- a/device/vertex_fit/vertex_fitter/src/FilterMFTracks.cu +++ b/device/vertex_fit/vertex_fitter/src/FilterMFTracks.cu @@ -81,4 +81,4 @@ __global__ void FilterMFTracks::filter_mf_tracks(FilterMFTracks::Parameters para event_svs_mf_idx[vertex_idx] = j_track; } } -} \ No newline at end of file +} -- GitLab From 34a06f054442adb36c1da292782299b85bcc1301 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Tue, 5 Jul 2022 15:14:26 +0200 Subject: [PATCH 02/18] seeding implementation --- checker/tracking/include/PrepareTracks.h | 16 + checker/tracking/include/TrackChecker.h | 8 +- .../tracking/include/TrackCheckerCategories.h | 355 +++++++++++++- checker/tracking/src/PrepareTracks.cpp | 80 ++++ .../python/AllenConf/scifi_reconstruction.py | 124 ++++- configuration/python/AllenConf/validators.py | 64 ++- .../python/AllenSequences/seeding.py | 12 + .../AllenSequences/seeding_validation.py | 23 + .../python/AllenSequences/seeding_xz.py | 14 + .../AllenSequences/seeding_xz_validation.py | 16 + device/SciFi/CMakeLists.txt | 9 +- .../include/ConsolidateSciFiSeeding.cuh | 68 +++ .../include/ConsolidateSciFiSeedingXZ.cuh | 47 ++ .../include/SeedingCopyTrackHitNumber.cuh | 40 ++ .../include/SeedingCopyTrackXZHitNumber.cuh | 40 ++ .../src/ConsolidateSciFiSeeding.cu | 190 ++++++++ .../src/ConsolidateSciFiSeedingXZ.cu | 38 ++ .../src/SeedingCopyTrackHitNumber.cu | 50 ++ .../src/SeedingCopyTrackXZHitNumber.cu | 51 ++ .../include/hybrid_seeding_case.cuh | 129 +++++ .../include/hybrid_seeding_helpers.cuh | 151 ++++++ .../include/seed_confirmTracks.cuh | 69 +++ .../SciFi/hybridseeding/include/seed_xz.cuh | 65 +++ .../hybridseeding/src/seed_confirmTracks.cu | 301 ++++++++++++ device/SciFi/hybridseeding/src/seed_xz.cu | 450 ++++++++++++++++++ .../SciFi/include/SciFiConsolidated.cuh | 141 +++++- .../SciFi/include/SciFiDefinitions.cuh | 20 +- .../SciFi/include/SciFiEventModel.cuh | 41 ++ .../common/include/ConsolidatedTypes.cuh | 74 +++ .../common/include/CopyTrackParameters.cuh | 20 + host/event_model/MC/include/CheckerTypes.h | 2 + host/event_model/MC/src/MCParticle.cpp | 12 + .../validators/include/HostSeedingValidator.h | 42 ++ .../include/HostSeedingXZValidator.h | 41 ++ host/validators/src/HostSeedingValidator.cpp | 34 ++ .../validators/src/HostSeedingXZValidator.cpp | 31 ++ 36 files changed, 2859 insertions(+), 9 deletions(-) create mode 100644 configuration/python/AllenSequences/seeding.py create mode 100644 configuration/python/AllenSequences/seeding_validation.py create mode 100644 configuration/python/AllenSequences/seeding_xz.py create mode 100644 configuration/python/AllenSequences/seeding_xz_validation.py create mode 100644 device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeeding.cuh create mode 100644 device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh create mode 100644 device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackHitNumber.cuh create mode 100644 device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackXZHitNumber.cuh create mode 100644 device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu create mode 100644 device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu create mode 100644 device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackHitNumber.cu create mode 100644 device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackXZHitNumber.cu create mode 100644 device/SciFi/hybridseeding/include/hybrid_seeding_case.cuh create mode 100644 device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh create mode 100644 device/SciFi/hybridseeding/include/seed_confirmTracks.cuh create mode 100644 device/SciFi/hybridseeding/include/seed_xz.cuh create mode 100644 device/SciFi/hybridseeding/src/seed_confirmTracks.cu create mode 100644 device/SciFi/hybridseeding/src/seed_xz.cu create mode 100644 host/validators/include/HostSeedingValidator.h create mode 100644 host/validators/include/HostSeedingXZValidator.h create mode 100644 host/validators/src/HostSeedingValidator.cpp create mode 100644 host/validators/src/HostSeedingXZValidator.cpp diff --git a/checker/tracking/include/PrepareTracks.h b/checker/tracking/include/PrepareTracks.h index 7b855d2260e..c5578869a74 100644 --- a/checker/tracking/include/PrepareTracks.h +++ b/checker/tracking/include/PrepareTracks.h @@ -40,6 +40,22 @@ std::vector prepareUTTracks( gsl::span ut_qop, gsl::span event_list); +std::vector prepareSeedingTracks( + const unsigned number_of_events, + gsl::span scifi_seed_atomics, + gsl::span scifi_seed_hit_number, + gsl::span scifi_seed_hits, + gsl::span scifi_seeds, + gsl::span seeding_states, + gsl::span event_list); + +std::vector prepareSeedingTracksXZ( + const unsigned number_of_events, + gsl::span scifi_seed_atomics, + gsl::span scifi_seed_hit_number, + gsl::span scifi_seeds, + gsl::span event_list); + /** * @brief Read forward tracks from binary files */ diff --git a/checker/tracking/include/TrackChecker.h b/checker/tracking/include/TrackChecker.h index b054021727f..1b7c7c0a497 100644 --- a/checker/tracking/include/TrackChecker.h +++ b/checker/tracking/include/TrackChecker.h @@ -84,7 +84,7 @@ public: (100.0 * static_cast(m_nghosts)) / (static_cast(m_ntracks))); } - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v || std::is_same_v ) { std::printf( "%-50s: %9lu/%9lu %6.2f%% ghosts\n", "for P>3GeV,Pt>0.5GeV", @@ -288,6 +288,8 @@ public: subdetector_counter = id_counter.second.n_ut; else if constexpr (std::is_same_v) subdetector_counter = id_counter.second.n_scifi; + else if constexpr (std::is_same_v) + subdetector_counter = id_counter.second.n_scifi; const float weight = ((float) counter_sum) / ((float) n_meas); const MCAssociator::TrackWithWeight track_weight = {i_track, weight, subdetector_counter}; assoc_table[(mc_assoc.m_mcps[id_counter.first]).key].push_back(track_weight); @@ -409,7 +411,7 @@ public: } // fill histogram of momentum resolution if ( - (std::is_same_v || + (std::is_same_v || std::is_same_v || std::is_same_v) &&mcp.hasVelo && mcp.hasUT && mcp.hasSciFi) { m_histos->fillMomentumResolutionHisto(mcp, track.p, track.qop); @@ -506,4 +508,6 @@ public: using TrackCheckerVelo = TrackChecker; using TrackCheckerVeloUT = TrackChecker; using TrackCheckerLong = TrackChecker; +using TrackCheckerSeeding = TrackChecker; +using TrackCheckerSeedingXZ = TrackChecker; using TrackCheckerMuon = TrackChecker; diff --git a/checker/tracking/include/TrackCheckerCategories.h b/checker/tracking/include/TrackCheckerCategories.h index bde18c70ef0..e3e1813d0cc 100644 --- a/checker/tracking/include/TrackCheckerCategories.h +++ b/checker/tracking/include/TrackCheckerCategories.h @@ -4,7 +4,7 @@ #pragma once #include - +#include #include "TrackChecker.h" #include "CheckerTypes.h" @@ -735,6 +735,28 @@ namespace Categories { [](MCParticles::const_reference& mcp) { return mcp.isLong && !mcp.isElectron() && mcp.fromBeautyDecay && mcp.p > 5e3f && mcp.pt > 1e3f && mcp.inEta2_5(); + TrackEffReport({ + "11_noVelo_UT", + [](MCParticles::const_reference& mcp) { + return !mcp.hasVelo && mcp.hasUT && mcp.hasSciFi && mcp.isElectron() && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "12_noVelo_UT_P>5GeV", + [](MCParticles::const_reference& mcp) { + return !mcp.hasVelo && mcp.hasUT && mcp.hasSciFi && mcp.isElectron() && mcp.inEta2_5() && mcp.p > 5e3f; + }, + }), + TrackEffReport({ + "13_long_PT>2GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "14_long_from_B_PT>2GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); }, }), @@ -1006,6 +1028,336 @@ namespace Categories { })}}; } + template<> + inline std::vector make_track_eff_report_vector() + { + constexpr float pi = static_cast(M_PI); + constexpr auto base = [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5(); + }; + return std::vector {{ + // define which categories to monitor + TrackEffReport({ + "00_P>3Gev_Pt>0.5", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && mcp.pt > 500.f; + }, + }), + TrackEffReport({ + "01_long", + [](MCParticles::const_reference& mcp) { return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5(); }, + }), + TrackEffReport({ + "---1. phi quadrant", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5() && mcp.phi > 0 && mcp.phi < pi / 2.f; + }, + }), + TrackEffReport({ + "---2. phi quadrant", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5() && mcp.phi > pi / 2.f && mcp.phi < pi; + }, + }), + TrackEffReport({ + "---3. phi quadrant", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5() && mcp.phi > -pi && mcp.phi < -pi / 2.f; + }, + }), + TrackEffReport({ + "---4. phi quadrant", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5() && mcp.phi > -pi / 2.f && mcp.phi < 0.f; + }, + }), + TrackEffReport({ + "---eta < 2.5, small x, large y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.eta < 2.5f && + ((mcp.phi > pi / 3.f && mcp.phi < 2.f * pi / 3.f) || + (mcp.phi > -2.f * pi / 3.f && mcp.phi < -pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta < 2.5, large x, small y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.eta < 2.5f && + ((mcp.phi > 2.f * pi / 3.f) || (mcp.phi < -2.f * pi / 3.f) || + (mcp.phi > -pi / 3.f && mcp.phi < pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta > 2.5, small x, large y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.eta > 2.5f && + ((mcp.phi > pi / 3.f && mcp.phi < 2 * pi / 3.f) || (mcp.phi > -2 * pi / 3.f && mcp.phi < -pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta > 2.5, large x, small y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.eta > 2.5f && + ((mcp.phi > 2 * pi / 3.f) || (mcp.phi < -2 * pi / 3.f) || (mcp.phi > -pi / 3.f && mcp.phi < pi / 3.f)); + }, + }), + TrackEffReport({ + "02_long_P>5GeV", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.p > 5e3f; }, + }), + TrackEffReport({ + "02_long_P>5GeV, eta > 4", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.p > 5e3f && mcp.eta > 4.f; }, + }), + TrackEffReport({ + "---eta < 2.5, small x, large y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.p > 5e3f && mcp.eta < 2.5f && + ((mcp.phi > pi / 3.f && mcp.phi < 2.f * pi / 3.f) || + (mcp.phi > -2.f * pi / 3.f && mcp.phi < -pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta < 2.5, large x, small y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.p > 5e3f && mcp.eta < 2.5f && + ((mcp.phi > 2 * pi / 3.f) || (mcp.phi < -2 * pi / 3.f) || (mcp.phi > -pi / 3.f && mcp.phi < pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta > 2.5, small x, large y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.p > 5e3f && mcp.eta > 2.5f && + ((mcp.phi > pi / 3.f && mcp.phi < 2.f * pi / 3.f) || + (mcp.phi > -2.f * pi / 3.f && mcp.phi < -pi / 3.f)); + }, + }), + TrackEffReport({ + "---eta > 2.5, large x, small y ", + [&base](MCParticles::const_reference& mcp) { + return base(mcp) && mcp.p > 5e3f && mcp.eta > 2.5f && + ((mcp.phi > 2.f * pi / 3.f) || (mcp.phi < -2.f * pi / 3.f) || + (mcp.phi > -pi / 3.f && mcp.phi < pi / 3.f)); + }, + }), + TrackEffReport({ + "03_long_P>3GeV", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.p > 3e3f; }, + }), + TrackEffReport({ + "04_long_P>0.5GeV", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.p > 5e2f; }, + }), + TrackEffReport({ + "05_long_from_B", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.fromBeautyDecay; }, + }), + TrackEffReport({ + "06_long_from_B_P>5GeV", + [&base](MCParticles::const_reference& mcp) { return base(mcp) && mcp.fromBeautyDecay && mcp.p > 5e3f; }, + }), + TrackEffReport({ + "07_long_from_B_P>3GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.p > 3e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "08_UT+SciFi", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && !mcp.isElectron() && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "09_UT+SciFi_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && !mcp.isElectron() && mcp.p > 5e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "10_UT+SciFi_P>3GeV", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && !mcp.isElectron() && mcp.p > 3e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "11_UT+SciFi_fromStrange", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && mcp.fromStrangeDecay && !mcp.isElectron() && + mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "12_UT+SciFi_fromStrange_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && mcp.fromStrangeDecay && mcp.p > 5e3f && + !mcp.isElectron() && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "13_UT+SciFi_fromStrange_P>3GeV", + [](MCParticles::const_reference& mcp) { + return mcp.hasUT && mcp.hasSciFi && !mcp.hasVelo && mcp.fromStrangeDecay && mcp.p > 3e3f && + !mcp.isElectron() && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "14_long_electrons", + [](MCParticles::const_reference& mcp) { return mcp.isLong && mcp.isElectron() && mcp.inEta2_5(); }, + }), + TrackEffReport({ + "15_long_electrons_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.isElectron() && mcp.p > 5e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "16_long_electrons_P>3GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.isElectron() && mcp.p > 3e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "17_long_fromB_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.isElectron() && mcp.fromBeautyDecay && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "18_long_fromB_electrons_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.isElectron() && mcp.fromBeautyDecay && mcp.p > 5e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "19_long_PT>2GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "20_long_from_B_PT>2GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); + }, + }), + + }}; + } + + template<> + inline std::vector make_histo_category_vector() + { + return std::vector { + {// define which categories to create histograms for + HistoCategory({ + "Long_eta25_electrons", + [](MCParticles::const_reference& mcp) { return mcp.isLong && mcp.isElectron() && mcp.inEta2_5(); }, + }), + HistoCategory({ + "LongFromB_eta25_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && mcp.isElectron() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongFromD_eta25_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && mcp.isElectron() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongStrange_eta25_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromStrangeDecay && mcp.isElectron() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongStrange_eta25_muons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromStrangeDecay && mcp.isMuon() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongFromD_eta25_p_gt_3_pt_gt_0p5_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.5e3f; + }, + }), + HistoCategory({ + "LongFromD_eta25_p_gt_3_pt_gt_0p3_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.3e3f; + }, + }), + HistoCategory({ + "LongFromB_eta25_p_gt_3_pt_gt_0p5_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.5e3f; + }, + }), + HistoCategory({ + "LongFromB_eta25_p_gt_3_pt_gt_0p3_electrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.3e3f; + }, + }), + HistoCategory({ + "Long_eta25_notElectrons", + [](MCParticles::const_reference& mcp) { return mcp.isLong && !mcp.isElectron() && mcp.inEta2_5(); }, + }), + HistoCategory({ + "LongFromB_eta25_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongFromD_eta25_p_gt_3_pt_gt_0p5_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && !mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.5e3f; + }, + }), + HistoCategory({ + "LongFromD_eta25_p_gt_3_pt_gt_0p3_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && !mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.3e3f; + }, + }), + HistoCategory({ + "LongFromB_eta25_p_gt_3_pt_gt_0p5_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.5e3f; + }, + }), + HistoCategory({ + "LongFromB_eta25_p_gt_3_pt_gt_0p3_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.inEta2_5() && mcp.p > 3e3f && + mcp.pt > 0.3e3f; + }, + }), + HistoCategory({ + "LongFromD_eta25_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromCharmDecay && !mcp.isElectron() && mcp.inEta2_5(); + }, + }), + HistoCategory({ + "LongStrange_eta25_notElectrons", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && mcp.fromStrangeDecay && !mcp.isElectron() && mcp.inEta2_5(); + }, + })}}; + } + template<> inline std::vector make_track_eff_report_vector() { @@ -1017,4 +1369,5 @@ namespace Categories { { return std::vector {}; } + } // namespace Categories diff --git a/checker/tracking/src/PrepareTracks.cpp b/checker/tracking/src/PrepareTracks.cpp index add4a4bc75c..5452c26b24c 100644 --- a/checker/tracking/src/PrepareTracks.cpp +++ b/checker/tracking/src/PrepareTracks.cpp @@ -119,6 +119,86 @@ std::vector prepareUTTracks( return checker_tracks; } +std::vector prepareSeedingTracks( + const unsigned number_of_events, + gsl::span scifi_seed_atomics, + gsl::span scifi_seed_hit_number, + gsl::span scifi_seed_hits, // FIXME: can be removed? + gsl::span scifi_seeds, // FIXME + gsl::span seeding_states, + gsl::span event_list) +{ + /* Tracks to be checked, save in format for checker */ + std::vector checker_tracks(event_list.size()); + for (unsigned i_event = 0; i_event < event_list.size(); i_event++) { + const auto event_number = event_list[i_event]; + + // Tracks of this event + auto& tracks = checker_tracks[i_event]; + SciFi::Consolidated::ConstSeeds scifi_seeds_consolidated { + scifi_seed_atomics.data(), scifi_seed_hit_number.data(), seeding_states.data(), event_number, number_of_events}; + + const SciFi::Seeding::Track* event_scifi_seeds = scifi_seeds.data() + event_number * SciFi::Constants::Nmax_seeds; + const unsigned number_of_tracks_event = scifi_seeds_consolidated.number_of_tracks(event_number); // FIXME + for (unsigned i_track = 0; i_track < number_of_tracks_event; i_track++) { + Checker::Track t; + + const SciFi::Seeding::Track& track = event_scifi_seeds[i_track]; + + const float tx = track.bx; + const float ty = track.by; + const float slope2 = tx * tx + ty * ty; + + const float rho = std::sqrt(slope2); + const float z = 1.0f; + + t.eta = eta_from_rho_z(rho, z); + + const auto scifi_lhcb_ids = scifi_seeds_consolidated.get_lhcbids_for_track(scifi_seed_hits.data(), i_track); + for (const auto id : scifi_lhcb_ids) { + t.addId(id); + } + tracks.push_back(t); + } // tracks + checker_tracks.emplace_back(tracks); + } + return checker_tracks; +} + +std::vector prepareSeedingTracksXZ( + const unsigned number_of_events, + gsl::span scifi_seed_atomics, + gsl::span scifi_seed_hit_number, + gsl::span scifi_seeds, // FIXME + gsl::span event_list) +{ + /* Tracks to be checked, save in format for checker */ + + std::vector checker_tracks(event_list.size()); + for (unsigned i_event = 0; i_event < event_list.size(); i_event++) { + const auto event_number = event_list[i_event]; + + // Tracks of this event + auto& tracks = checker_tracks[i_event]; + SciFi::Consolidated::ConstSeedsXZ scifi_tracks_consolidated { + scifi_seed_atomics.data(), scifi_seed_hit_number.data(), event_number, number_of_events}; + + const SciFi::Seeding::TrackXZ* event_scifi_seeds = + scifi_seeds.data() + event_number * SciFi::Constants::Nmax_seed_xz; // FIXME + const unsigned number_of_tracks_event = scifi_tracks_consolidated.number_of_tracks(event_number); // FIXME + for (unsigned i_track = 0; i_track < number_of_tracks_event; i_track++) { + Checker::Track t; + const SciFi::Seeding::TrackXZ& track = event_scifi_seeds[i_track]; + for (int i_hit = 0; i_hit != track.number_of_hits; i_hit++) { // FIXME + t.addId(track.ids[i_hit]); + } + tracks.push_back(t); + } // tracks + checker_tracks.emplace_back(tracks); + } + return checker_tracks; +} + std::vector read_forward_tracks(const char* events, const unsigned* event_offsets, const int n_events) { diff --git a/configuration/python/AllenConf/scifi_reconstruction.py b/configuration/python/AllenConf/scifi_reconstruction.py index 301b41c740d..0a38b248523 100644 --- a/configuration/python/AllenConf/scifi_reconstruction.py +++ b/configuration/python/AllenConf/scifi_reconstruction.py @@ -6,7 +6,8 @@ from AllenAlgorithms.algorithms import ( scifi_pre_decode_t, scifi_raw_bank_decoder_t, ut_select_velo_tracks_t, lf_search_initial_windows_t, lf_triplet_seeding_t, lf_create_tracks_t, lf_quality_filter_length_t, lf_quality_filter_t, - scifi_copy_track_hit_number_t, scifi_consolidate_tracks_t, get_type_id_t) + scifi_copy_track_hit_number_t, scifi_consolidate_tracks_t, get_type_id_t, + seed_xz_t, seed_confirmTracks_t, seeding_copy_track_hit_number_t, seed_confirmTracks_consolidate_t) from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm from PyConf.tonic import configurable @@ -60,6 +61,10 @@ def decode_scifi(): host_raw_bank_version_t=scifi_banks.host_raw_bank_version_t) return { + "dev_scifi_hit_counts": + scifi_calculate_cluster_count.dev_scifi_hit_count_t, + "host_number_of_scifi_hits": + prefix_sum_scifi_hits.host_total_sum_holder_t, "dev_scifi_hits": scifi_raw_bank_decoder.dev_scifi_hits_t, "dev_scifi_hit_offsets": prefix_sum_scifi_hits.dev_output_buffer_t, "host_number_of_scifi_hits": @@ -337,6 +342,109 @@ def make_forward_tracks(decoded_scifi, input_tracks, with_ut=True): scifi_consolidate_tracks.dev_scifi_hits_view_t } +@configurable +def make_seeding_XZ_tracks(decoded_scifi): + number_of_events = initialize_number_of_events() + + seed_xz_tracks = make_algorithm( + seed_xz_t, + name="seed_xz", + host_number_of_events_t=number_of_events["host_number_of_events"], + host_scifi_hit_count_t=decoded_scifi["host_number_of_scifi_hits"], + dev_number_of_events_t=number_of_events["dev_number_of_events"], + dev_scifi_hits_t=decoded_scifi["dev_scifi_hits"], + dev_scifi_hit_count_t=decoded_scifi["dev_scifi_hit_offsets"]) + + return { + "seed_xz_tracks": + seed_xz_tracks.dev_seeding_tracksXZ_t, + "seed_xz_tracks_part0": + seed_xz_tracks.dev_seeding_number_of_tracksXZ_part0_t, + "seed_xz_tracks_part1": + seed_xz_tracks.dev_seeding_number_of_tracksXZ_part1_t, + "seed_xz_number_of_tracks": + seed_xz_tracks.dev_seeding_number_of_tracksXZ_t + } + + +@configurable +def make_seeding_tracks(decoded_scifi, xz_tracks): + number_of_events = initialize_number_of_events() + + seed_tracks = make_algorithm( + seed_confirmTracks_t, + name="seed_confirmTracks", + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_number_of_events_t=number_of_events["dev_number_of_events"], + dev_scifi_hits_t=decoded_scifi["dev_scifi_hits"], + dev_scifi_hit_count_t=decoded_scifi["dev_scifi_hit_offsets"], + dev_seeding_tracksXZ_t=xz_tracks["seed_xz_tracks"], + dev_seeding_number_of_tracksXZ_part0_t=xz_tracks[ + "seed_xz_tracks_part0"], + dev_seeding_number_of_tracksXZ_part1_t=xz_tracks[ + "seed_xz_tracks_part1"], + ) + + prefix_sum_seeding_tracks = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_seeding_track", + dev_input_buffer_t=seed_tracks.dev_seeding_confirmTracks_atomics_t) + + seeding_copy_track_hit_number = make_algorithm( + seeding_copy_track_hit_number_t, + name="seeding_copy_track_hit_number", + host_number_of_events_t=number_of_events["host_number_of_events"], + host_number_of_reconstructed_seeding_tracks_t=prefix_sum_seeding_tracks + .host_total_sum_holder_t, + dev_seeding_tracks_t=seed_tracks.dev_seeding_tracks_t, + dev_seeding_atomics_t=prefix_sum_seeding_tracks.dev_output_buffer_t, + dev_event_list_t=number_of_events["dev_number_of_events"]) + + prefix_sum_seeding_track_hit_number = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_seeding_track_hit_number", + dev_input_buffer_t=seeding_copy_track_hit_number. + dev_seeding_track_hit_number_t) + + seed_confirmTracks_consolidate = make_algorithm( + seed_confirmTracks_consolidate_t, + name="scifi_consolidate_seeds", + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_number_of_events_t=number_of_events["dev_number_of_events"], + host_accumulated_number_of_hits_in_scifi_tracks_t= + prefix_sum_seeding_track_hit_number.host_total_sum_holder_t, + host_number_of_reconstructed_seeding_tracks_t=prefix_sum_seeding_tracks + .host_total_sum_holder_t, + dev_scifi_hits_t=decoded_scifi["dev_scifi_hits"], + dev_scifi_hit_offsets_t=decoded_scifi["dev_scifi_hit_offsets"], + dev_offsets_seeding_tracks_t=prefix_sum_seeding_tracks. + dev_output_buffer_t, + dev_offsets_seeding_hit_number_t=prefix_sum_seeding_track_hit_number. + dev_output_buffer_t, + dev_seeding_tracks_t=seed_tracks.dev_seeding_tracks_t) + + return { + "seed_tracks": + seed_tracks.dev_seeding_tracks_t, + "seed_atomics": + seed_tracks.dev_seeding_confirmTracks_atomics_t, + "dev_seeding_track_hits": + seed_confirmTracks_consolidate.dev_seeding_track_hits_t, + "dev_seeding_states": + seed_confirmTracks_consolidate.dev_seeding_states_t, + "host_number_of_reconstructed_seeding_tracks": + prefix_sum_seeding_tracks.host_total_sum_holder_t, + "dev_offsets_scifi_seeds": + prefix_sum_seeding_tracks.dev_output_buffer_t, + "dev_offsets_scifi_seed_hit_number": + prefix_sum_seeding_track_hit_number.dev_output_buffer_t, + "dev_scifi_tracks_view": + seed_confirmTracks_consolidate.dev_scifi_tracks_view_t, + "dev_scifi_track_view": + seed_confirmTracks_consolidate.dev_scifi_track_view_t, + "dev_scifi_hits_view": + seed_confirmTracks_consolidate.dev_scifi_hits_view_t + } def forward_tracking(): from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks @@ -350,3 +458,17 @@ def forward_tracking(): forward_tracks = make_forward_tracks(decoded_scifi, ut_tracks) alg = forward_tracks["dev_scifi_track_hits"].producer return alg + +def seeding_xz(): + decoded_scifi = decode_scifi() + seeding_tracks = make_seeding_XZ_tracks(decoded_scifi) + alg = seeding_tracks["seed_xz_tracks"] + return alg + + +def seeding(): + decoded_scifi = decode_scifi() + seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) + seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) + alg = seeding_tracks["seed_tracks"] + return alg diff --git a/configuration/python/AllenConf/validators.py b/configuration/python/AllenConf/validators.py index 9058bb075d7..61f9b323473 100644 --- a/configuration/python/AllenConf/validators.py +++ b/configuration/python/AllenConf/validators.py @@ -5,10 +5,14 @@ from AllenAlgorithms.algorithms import ( mc_data_provider_t, host_velo_validator_t, host_velo_ut_validator_t, long_track_validator_t, muon_validator_t, host_pv_validator_t, host_rate_validator_t, host_routingbits_validator_t, kalman_validator_t, + host_seeding_XZ_validator_t, host_seeding_validator_t, host_data_provider_t, host_sel_report_validator_t) from AllenConf.utils import initialize_number_of_events -from AllenConf.persistency import make_dec_reporter, make_gather_selections, make_routingbits_writer, rb_map from AllenCore.generator import make_algorithm +from AllenConf.persistency import make_dec_reporter, make_gather_selections, make_routingbits_writer, rb_map +from AllenAlgorithms.algorithms import ( + host_prefix_sum_t, seeding_copy_trackXZ_hit_number_t) +from AllenConf.scifi_reconstruction import decode_scifi, make_seeding_XZ_tracks def mc_data_provider(): @@ -93,6 +97,64 @@ def long_validation(long_tracks, name="long_validator"): "dev_multi_event_long_tracks_view"], dev_offsets_long_tracks_t=long_tracks["dev_offsets_forward_tracks"]) +def seeding_xz_validation(name="seed_xz_validator"): + mc_events = mc_data_provider() + decoded_scifi = decode_scifi() + seeding_tracks = make_seeding_XZ_tracks(decoded_scifi) + + number_of_events = initialize_number_of_events() + + prefix_sum_tracksXZ = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_scifi_trackXZ", + dev_input_buffer_t=seeding_tracks["seed_xz_number_of_tracks"]) + + seeding_copy_trackXZ_hit_number = make_algorithm( + seeding_copy_trackXZ_hit_number_t, + name="seeding_copy_trackXZ_hit_number", + host_number_of_events_t=number_of_events["host_number_of_events"], + host_number_of_reconstructed_seeding_tracksXZ_t=prefix_sum_tracksXZ. + host_total_sum_holder_t, + dev_seeding_tracksXZ_t=seeding_tracks["seed_xz_tracks"], + dev_seeding_xz_atomics_t=prefix_sum_tracksXZ.dev_output_buffer_t, + dev_event_list_t=number_of_events["dev_number_of_events"]) + + prefix_sum_trackXZ_hit_number = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_trackXZ_hit_number", + dev_input_buffer_t=seeding_copy_trackXZ_hit_number. + dev_seeding_trackXZ_hit_number_t) + + return make_algorithm( + host_seeding_XZ_validator_t, + name=name, + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_offsets_scifi_seedsXZ_t=prefix_sum_tracksXZ.dev_output_buffer_t, + dev_scifi_hits_t=decoded_scifi["dev_scifi_hits"], + dev_offsets_scifi_seedXZ_hit_number_t=prefix_sum_trackXZ_hit_number. + dev_output_buffer_t, + dev_scifi_seedsXZ_t=seeding_tracks["seed_xz_tracks"], + host_mc_events_t=mc_events.host_mc_events_t) + + +def seeding_validation(seeding_tracks, name="seed_validator"): + mc_events = mc_data_provider() + #decoded_scifi = decode_scifi("v6") + #seeding_tracks = make_seeding_tracks(decoded_scifi) + + number_of_events = initialize_number_of_events() + + return make_algorithm( + host_seeding_validator_t, + name=name, + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_offsets_scifi_seeds_t=seeding_tracks["dev_offsets_scifi_seeds"], + dev_scifi_hits_t=seeding_tracks["dev_seeding_track_hits"], + dev_offsets_scifi_seed_hit_number_t=seeding_tracks[ + "dev_offsets_scifi_seed_hit_number"], + dev_scifi_seeds_t=seeding_tracks["seed_tracks"], + dev_seeding_states_t=seeding_tracks["dev_seeding_states"], + host_mc_events_t=mc_events.host_mc_events_t) def muon_validation(muonID, name="muon_validator"): mc_events = mc_data_provider() diff --git a/configuration/python/AllenSequences/seeding.py b/configuration/python/AllenSequences/seeding.py new file mode 100644 index 00000000000..67f08e78e63 --- /dev/null +++ b/configuration/python/AllenSequences/seeding.py @@ -0,0 +1,12 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import seeding +from AllenConf.utils import gec +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +seeding_sequence = CompositeNode( + "Seeding", [gec("gec"), seeding()], NodeLogic.LAZY_AND, force_order=True) + +generate(seeding_sequence) diff --git a/configuration/python/AllenSequences/seeding_validation.py b/configuration/python/AllenSequences/seeding_validation.py new file mode 100644 index 00000000000..c6285591040 --- /dev/null +++ b/configuration/python/AllenSequences/seeding_validation.py @@ -0,0 +1,23 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import decode_scifi, seeding_xz, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.hlt1_reconstruction import make_composite_node_with_gec +from AllenConf.validators import seeding_validation, seeding_xz_validation +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +decoded_scifi = decode_scifi() +seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) +seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) +seed = seeding_validation(seeding_tracks) +seed_xz = seeding_xz_validation() +seeding_sequence = CompositeNode( + "Validators", [ + make_composite_node_with_gec("seedingXZValidation", seed_xz), + make_composite_node_with_gec("seedingValidation", seed) + ], + NodeLogic.NONLAZY_AND, + force_order=True) + +generate(seeding_sequence) diff --git a/configuration/python/AllenSequences/seeding_xz.py b/configuration/python/AllenSequences/seeding_xz.py new file mode 100644 index 00000000000..794e3238234 --- /dev/null +++ b/configuration/python/AllenSequences/seeding_xz.py @@ -0,0 +1,14 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import seeding_xz +from AllenConf.utils import gec +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +seeding_sequence = CompositeNode( + "Seeding_XZ", [gec("gec"), seeding_xz()], + NodeLogic.LAZY_AND, + force_order=True) + +generate(seeding_sequence) diff --git a/configuration/python/AllenSequences/seeding_xz_validation.py b/configuration/python/AllenSequences/seeding_xz_validation.py new file mode 100644 index 00000000000..d159bf21f77 --- /dev/null +++ b/configuration/python/AllenSequences/seeding_xz_validation.py @@ -0,0 +1,16 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import decode_scifi, seeding_xz, make_seeding_XZ_tracks +from AllenConf.validators import seeding_xz_validation +from AllenConf.utils import gec +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +seed_xz = seeding_xz_validation() +seeding_sequence = CompositeNode( + "SeedingXZValidation", [gec("gec"), seed_xz], + NodeLogic.LAZY_AND, + force_order=True) + +generate(seeding_sequence) diff --git a/device/SciFi/CMakeLists.txt b/device/SciFi/CMakeLists.txt index aeddcedfded..88b94292fbb 100644 --- a/device/SciFi/CMakeLists.txt +++ b/device/SciFi/CMakeLists.txt @@ -4,16 +4,23 @@ file(GLOB scifi_preprocessing "preprocessing/src/*cu") file(GLOB scifi_looking_forward "looking_forward/src/*cu") file(GLOB scifi_consolidate "consolidate/src/*cu") +file(GLOB scifi_hybridseeding "hybridseeding/src/*cu") +file(GLOB scifi_hybridseeding_consolidate "hybridseeding/consolidate/src/*cu") allen_add_device_library(SciFi STATIC ${scifi_preprocessing} ${scifi_looking_forward} - ${scifi_consolidate}) + ${scifi_consolidate} + ${scifi_hybridseeding} + ${scifi_hybridseeding_consolidate} +) target_link_libraries(SciFi PRIVATE Backend HostEventModel EventModel Utils) target_include_directories(SciFi PUBLIC $ $ + $ + $ $ $) diff --git a/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeeding.cuh b/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeeding.cuh new file mode 100644 index 00000000000..540ba7bd60c --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeeding.cuh @@ -0,0 +1,68 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "SciFiDefinitions.cuh" +#include "SciFiConsolidated.cuh" +#include "SciFiEventModel.cuh" +#include "AlgorithmTypes.cuh" + +namespace seed_confirmTracks_consolidate { + struct Parameters { + HOST_INPUT(host_number_of_reconstructed_seeding_tracks_t, unsigned) host_number_of_reconstructed_seeding_tracks; + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + HOST_INPUT(host_accumulated_number_of_hits_in_scifi_tracks_t, unsigned) + host_accumulated_number_of_hits_in_scifi_tracks; + MASK_INPUT(dev_event_list_t) dev_event_list; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_hit_offsets_t, unsigned) dev_scifi_hit_count; + DEVICE_INPUT(dev_offsets_seeding_tracks_t, unsigned) dev_atomics_scifi; // fishy + DEVICE_INPUT(dev_offsets_seeding_hit_number_t, unsigned) dev_seeding_hit_number; // fishy + DEVICE_INPUT(dev_seeding_tracks_t, SciFi::Seeding::Track) dev_seeding_tracks; + DEVICE_OUTPUT(dev_seeding_qop_t, float) dev_seeding_qop; + DEVICE_OUTPUT(dev_seeding_states_t, MiniState) dev_seeding_states; + DEVICE_OUTPUT(dev_seeding_track_hits_t, char) dev_seeding_track_hits; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_scifi_hits_view_t, + DEPENDENCIES(dev_seeding_track_hits_t), + Allen::Views::SciFi::Consolidated::Hits) + dev_scifi_hits_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_scifi_track_view_t, + DEPENDENCIES(dev_scifi_hits_view_t), + Allen::Views::SciFi::Consolidated::Track) + dev_scifi_track_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_scifi_tracks_view_t, + DEPENDENCIES(dev_scifi_track_view_t), + Allen::Views::SciFi::Consolidated::Tracks) + dev_scifi_tracks_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_scifi_multi_event_tracks_view_t, + DEPENDENCIES(dev_scifi_tracks_view_t), + Allen::Views::SciFi::Consolidated::MultiEventTracks) + dev_scifi_multi_event_tracks_view; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void seed_confirmTracks_consolidate(Parameters, const float* dev_magnet_polarity); + + struct seed_confirmTracks_consolidate_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{256, 1, 1}}}; + }; +} // namespace seed_confirmTracks_consolidate diff --git a/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh b/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh new file mode 100644 index 00000000000..2dacfdfd849 --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh @@ -0,0 +1,47 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "SciFiDefinitions.cuh" +#include "SciFiEventModel.cuh" +#include "AlgorithmTypes.cuh" + +namespace seed_xz_consolidate { + struct Parameters { + HOST_INPUT(host_accumulated_number_of_scifi_hits_t, unsigned) host_accumulated_number_of_scifi_hits; + HOST_INPUT(host_number_of_reconstructed_seeding_tracksXZ_t, unsigned) host_number_of_reconstructed_seeding_tracksXZ; + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + HOST_INPUT(host_accumulated_number_of_hits_in_scifi_tracksXZ_t, unsigned) + host_accumulated_number_of_hits_in_scifi_tracksXZ; + DEVICE_INPUT(dev_event_list_t, unsigned) dev_event_list; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_hit_count_t, unsigned) dev_scifi_hit_count; + DEVICE_INPUT(dev_offsets_seeding_tracksXZ_t, unsigned) dev_atomics_scifi; // fishy + DEVICE_INPUT(dev_offsets_seeding_XZ_hit_number_t, unsigned) dev_scifi_seed_XZ_hit_number; // fishy + DEVICE_INPUT(dev_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) dev_seeding_tracksXZ; + + // DEVICE_OUTPUT(dev_seeding_qop_t, float) dev_seeding_qop; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void seed_xz_consolidate(Parameters); + + struct seed_xz_consolidate_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{256, 1, 1}}}; + }; +} // namespace seed_xz_consolidate diff --git a/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackHitNumber.cuh b/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackHitNumber.cuh new file mode 100644 index 00000000000..8b7403f3f07 --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackHitNumber.cuh @@ -0,0 +1,40 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "SciFiEventModel.cuh" +#include "SciFiDefinitions.cuh" +#include "AlgorithmTypes.cuh" + +namespace seeding_copy_track_hit_number { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; // input from event model + HOST_INPUT(host_number_of_reconstructed_seeding_tracks_t, unsigned) + host_number_of_reconstructed_seeding_tracks; // input from prefix sum + DEVICE_INPUT(dev_seeding_tracks_t, SciFi::Seeding::Track) dev_seeding_tracks; // input from seed_confirmTracks + DEVICE_INPUT(dev_seeding_atomics_t, unsigned) dev_seeding_atomics; // input from seed_confirmTracks + + DEVICE_OUTPUT(dev_seeding_track_hit_number_t, unsigned) dev_seeding_track_hit_number; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void seeding_copy_track_hit_number(Parameters); + + struct seeding_copy_track_hit_number_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{512, 1, 1}}}; + }; +} // namespace seeding_copy_track_hit_number diff --git a/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackXZHitNumber.cuh b/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackXZHitNumber.cuh new file mode 100644 index 00000000000..f87a9e6a108 --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/include/SeedingCopyTrackXZHitNumber.cuh @@ -0,0 +1,40 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "SciFiEventModel.cuh" +#include "SciFiDefinitions.cuh" +#include "AlgorithmTypes.cuh" + +namespace seeding_copy_trackXZ_hit_number { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; // input from event model + HOST_INPUT(host_number_of_reconstructed_seeding_tracksXZ_t, unsigned) + host_number_of_reconstructed_seeding_trackXZs; // input from prefix sum + DEVICE_INPUT(dev_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) dev_seeding_tracksXZ; // input from seed_xz + DEVICE_INPUT(dev_seeding_xz_atomics_t, unsigned) dev_seeding_xz_atomics; // input from seed_xz + DEVICE_INPUT(dev_event_list_t, unsigned) dev_event_list; + DEVICE_OUTPUT(dev_seeding_trackXZ_hit_number_t, unsigned) dev_seeding_trackXZ_hit_number; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void seeding_copy_trackXZ_hit_number(Parameters); + + struct seeding_copy_trackXZ_hit_number_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{512, 1, 1}}}; + }; +} // namespace seeding_copy_trackXZ_hit_number diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu new file mode 100644 index 00000000000..ebbe985624c --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -0,0 +1,190 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "ConsolidateSciFiSeeding.cuh" +#include "hybrid_seeding_helpers.cuh" +INSTANTIATE_ALGORITHM(seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t); + +__global__ void create_scifi_views(seed_confirmTracks_consolidate::Parameters parameters) +{ + const unsigned number_of_events = parameters.dev_number_of_events[0]; + const unsigned event_number = blockIdx.x; + + const auto event_tracks_offset = parameters.dev_atomics_scifi[event_number]; + const auto event_number_of_tracks = parameters.dev_atomics_scifi[event_number + 1] - event_tracks_offset; + for (unsigned track_index = threadIdx.x; track_index < event_number_of_tracks; track_index += blockDim.x) { + new (parameters.dev_scifi_track_view + event_tracks_offset + track_index) + Allen::Views::SciFi::Consolidated::Track {parameters.dev_scifi_hits_view, + parameters.dev_seeding_qop, + parameters.dev_atomics_scifi, + parameters.dev_seeding_hit_number, + track_index, + event_number}; + } + + if (threadIdx.x == 0) { + new (parameters.dev_scifi_hits_view + event_number) + Allen::Views::SciFi::Consolidated::Hits {parameters.dev_seeding_track_hits, + parameters.dev_atomics_scifi, + parameters.dev_seeding_hit_number, + event_number, + number_of_events}; + + new (parameters.dev_scifi_tracks_view + event_number) Allen::Views::SciFi::Consolidated::Tracks { + parameters.dev_scifi_track_view, parameters.dev_atomics_scifi, event_number}; + } + + if (blockIdx.x == 0 && threadIdx.x == 0) { + new (parameters.dev_scifi_multi_event_tracks_view) + Allen::Views::SciFi::Consolidated::MultiEventTracks {parameters.dev_scifi_tracks_view, number_of_events}; + } +} + +void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size( + arguments, first(arguments) * sizeof(SciFi::Hit)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, 1); +} + + +//=========================================================================================== +// Calculate momentum, given T state only, adapted from +// https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Tr/TrackTools/src/FastMomentumEstimate.cpp +//=========================================================================================== +__device__ float qop_seeding_calculation( + const float magSign, + const MiniState seeding_state, + bool tCubicFit) +{ + const float tx = seeding_state.tx; + const float ty = seeding_state.ty; + const float x = seeding_state.x; + const float z = seeding_state.z; + + const float m_paramsTParab[4] = {-6.30991, -4.83533, -12.9192, 4.23025e-08}; + const float m_paramsTCubic[4] = {-6.34025, -4.85287, -12.4491, 4.25461e-08}; + + float qop = 0.f; + const auto x0 = x - tx * z; + const auto& params = ( tCubicFit ? m_paramsTCubic : m_paramsTParab ); + const auto p = params[0] + params[1] * tx * tx + params[2] * ty * ty + params[3] * x0 * x0; + + const auto scale_factor = 1. * magSign; //is there a way to get the scale_factor from the constants? + const float denom = p * scale_factor * 1e6 * ( -1 ); + + if ( std::abs( scale_factor ) < 1e-6 ) { + qop = 0.01 / Gaudi::Units::GeV; + } else { + qop = x0 / denom; + } + return qop; +} + + +void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const +{ + initialize(arguments, 0, context); + initialize(arguments, 0, context); + + global_function(seed_confirmTracks_consolidate)( + dim3(size(arguments)), property(), context)(arguments, constants.dev_magnet_polarity.data()); + + global_function(create_scifi_views)(first(arguments), 256, context)(arguments); +} + +template +__device__ void populate(const SciFi::Seeding::Track& track, const F& assign) +{ + for (int i = 0; i < track.number_of_hits; i++) { + const auto hit_index = track.hits[i]; + assign(i, hit_index); + } +} + +__global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( + seed_confirmTracks_consolidate::Parameters parameters, + const float* dev_magnet_polarity) +{ + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + const unsigned number_of_events = parameters.dev_number_of_events[0]; + + const unsigned total_number_of_hits = parameters.dev_scifi_hit_count[number_of_events]; + const SciFi::Seeding::Track* event_scifi_seeds = + parameters.dev_seeding_tracks + event_number * SciFi::Constants::Nmax_seeds; + + const unsigned total_number_of_scifi_hits = + parameters.dev_scifi_hit_count[number_of_events * SciFi::Constants::n_mat_groups_and_mats]; + + SciFi::ConstHits scifi_hits {parameters.dev_scifi_hits, total_number_of_scifi_hits}; + SciFi::ConstHitCount scifi_hit_count {parameters.dev_scifi_hit_count, event_number}; + + // Create consolidated SoAs. + SciFi::Consolidated::Tracks scifi_seeds {parameters.dev_atomics_scifi, + parameters.dev_seeding_hit_number, + parameters.dev_seeding_qop, + parameters.dev_seeding_states, + nullptr, + event_number, + number_of_events}; + const unsigned number_of_tracks_event = scifi_seeds.number_of_tracks(event_number); + const unsigned event_offset = scifi_hit_count.event_offset(); + float* tracks_qop = parameters.dev_seeding_qop + parameters.dev_atomics_scifi[event_number]; + + // Loop over tracks. + for (unsigned i = threadIdx.x; i < number_of_tracks_event; i += blockDim.x) { + + const SciFi::Seeding::Track& scifiseed = event_scifi_seeds[i]; + + const auto dz = SciFi::Constants::ZEndT - hybrid_seeding::z_ref; + + const MiniState seeding_state {scifiseed.xFromDz(dz), + scifiseed.yFromDz(dz), + SciFi::Constants::ZEndT, + scifiseed.xSlopeFromDz(dz), + scifiseed.ySlope()}; + + scifi_seeds.states(i) = seeding_state; + + const auto magSign = dev_magnet_polarity[0]; + scifi_seeds.qop(i) = + qop_seeding_calculation(magSign, seeding_state, true); + + auto consolidated_hits = scifi_seeds.get_hits(parameters.dev_seeding_track_hits, i); + + // Populate arrays + populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + consolidated_hits.x0(i) = scifi_hits.x0(hit_index); + }); + + populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + consolidated_hits.z0(i) = scifi_hits.z0(hit_index); + }); + + populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + consolidated_hits.endPointY(i) = scifi_hits.endPointY(hit_index); + }); + + populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + consolidated_hits.channel(i) = scifi_hits.channel(hit_index); + }); + + populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + consolidated_hits.assembled_datatype(i) = scifi_hits.assembled_datatype(hit_index); + }); + } +} diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu new file mode 100644 index 00000000000..16dec58f9b2 --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu @@ -0,0 +1,38 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "ConsolidateSciFiSeedingXZ.cuh" + +INSTANTIATE_ALGORITHM(seed_xz_consolidate::seed_xz_consolidate_t); + +void seed_xz_consolidate::seed_xz_consolidate_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + // set_size(arguments, first(arguments)); +} + +void seed_xz_consolidate::seed_xz_consolidate_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const +{ + global_function(seed_xz_consolidate)(dim3(size(arguments)), property(), context)( + arguments); +} + +__global__ void seed_xz_consolidate::seed_xz_consolidate(seed_xz_consolidate::Parameters parameters) +{ + const unsigned number_of_events = parameters.dev_number_of_events[0]; + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + + const unsigned total_number_of_hits = parameters.dev_scifi_hit_count[number_of_events]; + const SciFi::Seeding::TrackXZ* event_scifi_tracksXZ = + parameters.dev_seeding_tracksXZ + event_number * SciFi::Constants::Nmax_seed_xz; + SciFi::ConstHits scifi_hits {parameters.dev_scifi_hits, total_number_of_hits}; + // SciFi::Consolidated::Tracks +} diff --git a/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackHitNumber.cu b/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackHitNumber.cu new file mode 100644 index 00000000000..3a37ddbe3ff --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackHitNumber.cu @@ -0,0 +1,50 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "SeedingCopyTrackHitNumber.cuh" + +INSTANTIATE_ALGORITHM(seeding_copy_track_hit_number::seeding_copy_track_hit_number_t); + +void seeding_copy_track_hit_number::seeding_copy_track_hit_number_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size( + arguments, + first( + arguments)); // number of reconstructed tracks comes from prefix sum here +} + +void seeding_copy_track_hit_number::seeding_copy_track_hit_number_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const +{ + global_function(seeding_copy_track_hit_number)( + dim3(first(arguments)), property(), context)(arguments); +} + +/** + * @brief Copies SciFi seeding track hit numbers on a consecutive container + */ +__global__ void seeding_copy_track_hit_number::seeding_copy_track_hit_number( + seeding_copy_track_hit_number::Parameters parameters) +{ + const auto event_number = blockIdx.x; + const auto event_tracks = parameters.dev_seeding_tracks + event_number * SciFi::Constants::Nmax_seeds; + const auto accumulated_tracks = parameters.dev_seeding_atomics[event_number]; // FISHY + const auto number_of_tracks = + parameters.dev_seeding_atomics[event_number + 1] - parameters.dev_seeding_atomics[event_number]; + + // Pointer to seeding_track_hit_number of current event. + unsigned* seeding_track_hit_number = parameters.dev_seeding_track_hit_number + accumulated_tracks; + + // Loop over tracks. + for (unsigned element = threadIdx.x; element < number_of_tracks; element += blockDim.x) { + seeding_track_hit_number[element] = event_tracks[element].number_of_hits; + } +} diff --git a/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackXZHitNumber.cu b/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackXZHitNumber.cu new file mode 100644 index 00000000000..1cfde5ab0d9 --- /dev/null +++ b/device/SciFi/hybridseeding/consolidate/src/SeedingCopyTrackXZHitNumber.cu @@ -0,0 +1,51 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "SeedingCopyTrackXZHitNumber.cuh" + +INSTANTIATE_ALGORITHM(seeding_copy_trackXZ_hit_number::seeding_copy_trackXZ_hit_number_t); + +void seeding_copy_trackXZ_hit_number::seeding_copy_trackXZ_hit_number_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size( + arguments, + first( + arguments)); // number of reconstructed tracksXZ comes from prefix sum here +} + +void seeding_copy_trackXZ_hit_number::seeding_copy_trackXZ_hit_number_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const +{ + global_function(seeding_copy_trackXZ_hit_number)( + dim3(size(arguments)), property(), context)(arguments); +} + +/** + * @brief Copies SciFi seeding trackXZ hit numbers on a consecutive container + */ +__global__ void seeding_copy_trackXZ_hit_number::seeding_copy_trackXZ_hit_number( + seeding_copy_trackXZ_hit_number::Parameters parameters) +{ + // FIXME: right now we do not take into account the fact that XZ tracks are stored in [part 0 part 1] + const auto event_number = blockIdx.x; + const auto event_tracksXZ = parameters.dev_seeding_tracksXZ + event_number * SciFi::Constants::Nmax_seed_xz; // FIXME + const auto accumulated_tracksXZ = parameters.dev_seeding_xz_atomics[event_number]; // FISHY + const auto number_of_tracksXZ = + parameters.dev_seeding_xz_atomics[event_number + 1] - parameters.dev_seeding_xz_atomics[event_number]; // FISHY + + // Pointer to seeding_trackXZ_hit_number of current event. + unsigned* seeding_trackXZ_hit_number = parameters.dev_seeding_trackXZ_hit_number + accumulated_tracksXZ; + + // Loop over tracksXZ. + for (unsigned element = threadIdx.x; element < number_of_tracksXZ; ++element) { + seeding_trackXZ_hit_number[element] = event_tracksXZ[element].number_of_hits; + } +} diff --git a/device/SciFi/hybridseeding/include/hybrid_seeding_case.cuh b/device/SciFi/hybridseeding/include/hybrid_seeding_case.cuh new file mode 100644 index 00000000000..237e287f110 --- /dev/null +++ b/device/SciFi/hybridseeding/include/hybrid_seeding_case.cuh @@ -0,0 +1,129 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#pragma once +#include "hybrid_seeding_helpers.cuh" + +/* + Defines all the numbers which make up a Case +*/ + +namespace hybrid_seeding { + class Case { + public: + // The three parameters that truely define a case, apart from tolerances + unsigned int iFirst; + unsigned int iMiddle; + unsigned int iLast; + unsigned int iRem[3]; + // Topology + float t1_z; + float t2_z; + + float dz[6]; + float dz2[6]; + + float invZf; + // Corrections + float twoHitScale; + float txCorr; + float xRefCorr; + float invZlZf; + // Kinematics + float invPTerms_1; // should be configurable + float invPTerms_2; // should be configurable + // Two-hit + // float alphaCorr_0;//should be configurable + // float alphaCorr_1;//should be configurable + float tol2Hit; + float alphaCorr; + // Three hit + float delSeedCorr; + float delSeedCorr2; + float threeHit0; // Should be configurable + float threeHit1; // Should be configurable + + // Remaining + float tolRem; // should be configurable + + // Fit x + float startingFitMatrix[6]; + float scoreOffset; + + __device__ Case( + unsigned int _iFirst, + unsigned int _iMiddle, + unsigned int _iLast, + unsigned int _iremainT1, + unsigned int _iremainT2, + unsigned int _iremainT3, + float _pMin, + float _scoreOffset) + { + iFirst = _iFirst; + iMiddle = _iMiddle; + iLast = _iLast; + iRem[0] = _iremainT1; + iRem[1] = _iremainT2; + iRem[2] = _iremainT3; + float pMin = _pMin; + // Topological information + // FIXME: this should access the geometry & options of first/last layers + t1_z = seed_xz::geomInfo::z[iFirst]; + t2_z = seed_xz::geomInfo::z[iMiddle]; + float t3_z = seed_xz::geomInfo::z[iLast]; + float t1_rem_z = seed_xz::geomInfo::z[iRem[0]]; + float t2_rem_z = seed_xz::geomInfo::z[iRem[1]]; + float t3_rem_z = seed_xz::geomInfo::z[iRem[2]]; + invZf = 1.f / (t1_z); + invZlZf = 1.f / (t3_z - t1_z); + dz[0] = t1_z - hybrid_seeding::z_ref; + dz[1] = t3_z - hybrid_seeding::z_ref; + dz[2] = t2_z - hybrid_seeding::z_ref; + dz[3] = t1_rem_z - hybrid_seeding::z_ref; + dz[4] = t2_rem_z - hybrid_seeding::z_ref; + dz[5] = t3_rem_z - hybrid_seeding::z_ref; + + for (auto i = 0; i < 6; i++) + dz2[i] = dz[i] * dz[i] * (1.f + hybrid_seeding::dRatio * dz[i]); + + // Corrections + txCorr = dz[0] + dz[1] + hybrid_seeding::dRatio * (dz[1] * dz[1] + dz[0] * dz[0] + dz[0] * dz[1]); + xRefCorr = dz[0] * (dz[0] - txCorr + hybrid_seeding::dRatio * dz[0] * dz[0]); + // Kinematics + invPTerms_1 = 1.6322e-07f; // FIXME + invPTerms_2 = -5.0217e-12f; // FIXME + float alphaCorr_0 = 2.180e06f; + float alphaCorr_1 = -1073.f; + // Two-hit calculations + float kDelta = t1_z / (t3_z - t1_z); //---LoH: x0 = kDelta * DeltaInf + float delta = invPTerms_1 * invPTerms_1 + (4.f * invPTerms_2 / pMin); //--LoH: discriminant of the polynomial + tol2Hit = (1.f / kDelta) * (-invPTerms_1 + std::sqrt(delta)) / 2.f / invPTerms_2; + alphaCorr = (alphaCorr_0 / kDelta) / (pMin - alphaCorr_1); + twoHitScale = (t3_z + alphaCorr) / t1_z; + // Three-hit calculations + delSeedCorr = 1.f / ((((t2_z - t1_z) * invZlZf) * (dz2[1] - dz2[0])) + (dz2[0] - dz2[2])); + threeHit0 = 1.82e-06f / delSeedCorr; + threeHit1 = 2.49e-02f / delSeedCorr; + + // Remaining + tolRem = 0.5f; + + // Fit matrix caching + startingFitMatrix[0] = 3.f; + startingFitMatrix[1] = dz[0] + dz[2] + dz[1]; + startingFitMatrix[2] = dz2[0] + dz2[2] + dz2[1]; + startingFitMatrix[3] = dz[0] * dz[0] + dz[2] * dz[2] + dz[1] * dz[1]; + startingFitMatrix[4] = dz[0] * dz2[0] + dz[2] * dz2[2] + dz[1] * dz2[1]; + startingFitMatrix[5] = dz2[0] * dz2[0] + dz2[2] * dz2[2] + dz2[1] * dz2[1]; + scoreOffset = _scoreOffset; + }; + }; +} // namespace hybrid_seeding diff --git a/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh new file mode 100644 index 00000000000..8dbf7472431 --- /dev/null +++ b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh @@ -0,0 +1,151 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#pragma once + +#include +#include "States.cuh" +#include "SciFiEventModel.cuh" + +namespace hybrid_seeding { + constexpr float z_ref = 8520.f; + constexpr float dRatio = -0.00028f; + + template + __device__ int binary_search_leftmost_unrolled(const T* array, const unsigned array_size, const T& needle) + { + int low = 0; + int size = array_size; + + // Unroll 9 time to cover arrays of size max 512 +#pragma unroll + for (int step = 0; step < 9; step++) { + int half = size / 2; + low += (array[low + half] < needle) * (size - half); + size = half; + } // while (size > 0); + + return low; + } + +} // namespace hybrid_seeding + +namespace seed_xz { + namespace geomInfo { + __device__ constexpr int nLayers = 6; + __device__ constexpr float z[nLayers] = {7826.106f, 8035.9048f, 8508.1064f, 8717.9043f, 9193.1064f, 9402.9043f}; + }; // namespace geomInfo + // Structure + struct TwoHitCombination { + float tx; + float xProj; + float xRef; + float invP; + float minPara; + float maxPara; + }; + + struct multiHitCombination { + int idx[SciFi::Constants::n_xzlayers] = {0}; + float ax; + float bx; + float cx; + float delta_x[6] = {0.f}; + }; + + inline int intIndex(int part, int event_number) { return part + SciFi::Constants::n_parts * event_number; }; + inline int trackIndex(int part, int event_number) { return event_number * SciFi::Constants::Nmax_seed_xz; }; +} // namespace seed_xz + +namespace seed_uv { + namespace geomInfo { + constexpr unsigned int nLayers = 6; + constexpr float angle = 0.086; // FIXME + constexpr float yCenter = 2.f; // FIXME + constexpr float yEdge = -2700.f; // FIXME + __device__ constexpr float z[nLayers] = + {8577.8691f, 7895.9189f, 9333.041, 8648.1543f, 9262.9824f, 7966.1035f}; // FIXME + __device__ constexpr float uv[nLayers] = {1., 1., -1., -1., 1., -1.}; // 1 for u, -1 for v //FIXME + __device__ constexpr float dz[nLayers] = {z[0] - hybrid_seeding::z_ref, + z[1] - hybrid_seeding::z_ref, + z[2] - hybrid_seeding::z_ref, + z[3] - hybrid_seeding::z_ref, + z[4] - hybrid_seeding::z_ref, + z[5] - hybrid_seeding::z_ref}; + __device__ constexpr float dz2[nLayers] = {dz[0] * dz[0] * (1.f + hybrid_seeding::dRatio * dz[0]), + dz[1] * dz[1] * (1.f + hybrid_seeding::dRatio * dz[1]), + dz[2] * dz[2] * (1.f + hybrid_seeding::dRatio * dz[2]), + dz[3] * dz[3] * (1.f + hybrid_seeding::dRatio * dz[3]), + dz[4] * dz[4] * (1.f + hybrid_seeding::dRatio * dz[4]), + dz[5] * dz[5] * (1.f + hybrid_seeding::dRatio * dz[5])}; + __device__ constexpr float dxDy[nLayers] = + {angle * uv[0], angle* uv[1], angle* uv[2], angle* uv[3], angle* uv[4], angle* uv[5]}; + } // namespace geomInfo + + struct multiHitCombination { + int number_of_hits {1}; + int idx[SciFi::Constants::n_uvlayers] = {SciFi::Constants::INVALID_IDX}; + float y[SciFi::Constants::n_uvlayers] = {0}; + float ay; + float by; + float chi2; + float p; + float qop; + float x, z; + }; + inline int trackIndex(int event_number) { return event_number * SciFi::Constants::Nmax_seeds; }; // FIXME +} // namespace seed_uv + +namespace seeding { + inline __device__ int searchBin(const float needle, const float* hits, int nhits) + { + int low = 0; + int size = nhits; + + do { + int half = size / 2; + low += (hits[low + half] <= needle) * (size - half); + size = half; + } while (size > 0); + + return low - (low > 0 && std::fabs(hits[low] - needle) >= std::fabs(hits[low - 1] - needle)); + } + inline __device__ int searchBin(const float needle, const float* hits, int startpos, int nhits) + { + int low = startpos; + int size = nhits; + + do { + int half = size / 2; + low += (hits[low + half] <= needle) * (size - half); + size = half; + } while (size > 0); + + return low - (low > 0 && std::fabs(hits[low] - needle) >= std::fabs(hits[low - 1] - needle)); + } + + struct HitCache { + inline __device__ float& hit(unsigned layer, unsigned hit) { return data[start[layer] + hit]; } + inline __device__ float* layer(unsigned layer) { return &data[start[layer]]; } + float* data; // in shared or global + unsigned start[6]; // in registers + unsigned size[6]; // in registers + }; + + struct Triplet { + static constexpr unsigned maxTriplets = 3000; + __device__ Triplet(unsigned indices) : indices(indices) {} + __device__ Triplet(int idx0, int idx1, int idx2) : indices((idx2 << 20) | (idx1 << 10) | idx0) {} + __device__ int idx0() { return indices & 1023; } + __device__ int idx1() { return (indices >> 10) & 1023; } + __device__ int idx2() { return (indices >> 20) & 1023; } + unsigned indices; + }; +} // namespace seeding diff --git a/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh b/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh new file mode 100644 index 00000000000..6bfd8286593 --- /dev/null +++ b/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh @@ -0,0 +1,69 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#pragma once + +#include "SciFiEventModel.cuh" +#include "SciFiDefinitions.cuh" +#include "AlgorithmTypes.cuh" +#include "hybrid_seeding_case.cuh" +#include "hybrid_seeding_helpers.cuh" +/** + * @brief Seeding in SciFI 1st statge with x_z layers + * @detail first implementation of seeding starting with x_z layers to fit under HLT1 timing budget. + */ + +namespace seed_confirmTracks { + struct Parameters { + HOST_INPUT(host_number_of_events_t, uint) host_number_of_events; + + HOST_OUTPUT(host_seeding_number_of_tracks_t, unsigned) host_seeding_number_of_tracks; + HOST_OUTPUT(host_seeding_tracks_t, SciFi::Seeding::Track) host_seeding_tracks; + + // event number and hits input + MASK_INPUT(dev_event_list_t) dev_event_list; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_hit_count_t, uint) dev_scifi_hit_count; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + + // XZ inputs + DEVICE_INPUT(dev_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) dev_seeding_tracksXZ; + DEVICE_INPUT(dev_seeding_number_of_tracksXZ_part0_t, unsigned) dev_seeding_number_of_tracksXZ_part0; + DEVICE_INPUT(dev_seeding_number_of_tracksXZ_part1_t, unsigned) dev_seeding_number_of_tracksXZ_part1; + + DEVICE_OUTPUT(dev_hits_working_mem_t, float) dev_hits_working_mem; + DEVICE_OUTPUT(dev_count_hits_working_mem_t, unsigned) dev_count_hits_working_mem; + + // Outputs + DEVICE_OUTPUT(dev_seeding_tracks_t, SciFi::Seeding::Track) dev_seeding_tracks; + DEVICE_OUTPUT(dev_seeding_number_of_tracks_t, unsigned) dev_seeding_number_of_tracks; + DEVICE_OUTPUT(dev_seeding_confirmTracks_atomics_t, unsigned) dev_seeding_confirmTracks_atomics; + }; + + __device__ int findHit(const float tolRem, float predPos, int startPos, int nHits, float* coords); + __global__ void seed_confirmTracks(Parameters); + __device__ bool fitYZ(seed_uv::multiHitCombination& multiHitComb); + + struct seed_confirmTracks_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const; + }; + +} // namespace seed_confirmTracks diff --git a/device/SciFi/hybridseeding/include/seed_xz.cuh b/device/SciFi/hybridseeding/include/seed_xz.cuh new file mode 100644 index 00000000000..3f6a6d8b05b --- /dev/null +++ b/device/SciFi/hybridseeding/include/seed_xz.cuh @@ -0,0 +1,65 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#pragma once + +#include "SciFiEventModel.cuh" +#include "SciFiDefinitions.cuh" +#include "AlgorithmTypes.cuh" +#include "hybrid_seeding_helpers.cuh" +#include "hybrid_seeding_case.cuh" + +/** + * @brief Seeding in SciFI 1st stage with x_z layers + * @detail first implementation of seeding starting with x_z layers to fit under HLT1 timing budget. + */ + +namespace seed_xz { + __device__ static constexpr unsigned int maxNHits = 300; // FIXME + + struct Parameters { + HOST_INPUT(host_number_of_events_t, uint) host_number_of_events; + HOST_INPUT(host_scifi_hit_count_t, unsigned) host_scifi_hit_count; + HOST_OUTPUT(host_seeding_number_of_tracksXZ_t, unsigned) host_seeding_number_of_tracksXZ; + HOST_OUTPUT(host_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) host_seeding_tracksXZ; + + MASK_INPUT(dev_event_list_t) dev_event_list; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_hit_count_t, uint) dev_scifi_hit_count; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + + DEVICE_OUTPUT(dev_hits_working_mem_t, float) dev_hits_working_mem; + DEVICE_OUTPUT(dev_count_hits_working_mem_t, unsigned) dev_count_hits_working_mem; + DEVICE_OUTPUT(dev_triplets_t, uint) dev_triplets; + + DEVICE_OUTPUT(dev_seeding_number_of_tracksXZ_t, uint) dev_seeding_number_of_tracksXZ; + DEVICE_OUTPUT(dev_seeding_number_of_tracksXZ_part0_t, uint) dev_seeding_number_of_tracksXZ_part0; + DEVICE_OUTPUT(dev_seeding_number_of_tracksXZ_part1_t, uint) dev_seeding_number_of_tracksXZ_part1; + + DEVICE_OUTPUT(dev_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) dev_seeding_tracksXZ; + }; + + __global__ void seed_xz(Parameters); + + struct seed_xz_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const; + }; +} // namespace seed_xz diff --git a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu new file mode 100644 index 00000000000..988a3d1d0a5 --- /dev/null +++ b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu @@ -0,0 +1,301 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#include "BinarySearch.cuh" +#include "memory_optim.cuh" + +#include "seed_confirmTracks.cuh" + +#include "hybrid_seeding_helpers.cuh" +#include "hybrid_seeding_case.cuh" +/** + * @brief Seeding in SciFi confirming xz segments + * @detail first implementation of seeding starting with x_z layers to fit under HLT1 timing budget. + */ +INSTANTIATE_ALGORITHM(seed_confirmTracks::seed_confirmTracks_t); +void seed_confirmTracks::seed_confirmTracks_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + int sizeTracks = first(arguments) * SciFi::Constants::Nmax_seeds; + int sizeInts = first(arguments); + // host outputs + set_size(arguments, sizeTracks); + set_size(arguments, sizeInts); + + // working memory + set_size(arguments, size(arguments) / sizeof(SciFi::ConstHits)); + set_size(arguments, 1); + + // device outputs + set_size(arguments, sizeInts); + set_size(arguments, sizeTracks); + set_size(arguments, sizeInts); +} + +void seed_confirmTracks::seed_confirmTracks_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const +{ + initialize( + arguments, 0, context); // This is only needed because of the prefix sum, should be removed + initialize(arguments, 0, context); + global_function(seed_confirmTracks)(dim3(size(arguments)), dim3(128), context)(arguments); + + // copy(arguments, context); //FIXME +} + +__device__ int seed_confirmTracks::findHit(const float tolRem, float predPos, int startPos, int nHits, float* coords) +{ + auto minIdx = seeding::searchBin(predPos, coords, startPos, nHits); + if (std::fabs(coords[minIdx] - predPos) > tolRem) return SciFi::Constants::INVALID_IDX; + return minIdx; +} + +__global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) +{ + /* + Reconstructs full tracks from XZ candidates. + Parallelised over tracks : + */ + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + const unsigned number_of_events = parameters.dev_number_of_events[0]; + + // SciFi hits + const uint total_number_of_hits = + parameters.dev_scifi_hit_count[number_of_events * SciFi::Constants::n_mat_groups_and_mats]; + SciFi::ConstHitCount scifi_hit_count {parameters.dev_scifi_hit_count, event_number}; + SciFi::ConstHits scifi_hits {parameters.dev_scifi_hits, total_number_of_hits}; + + int shiftCaseTracks = 0; + for (unsigned int part = 0; part < SciFi::Constants::n_parts; part++) { + __shared__ int nTracksPerPart; + if (threadIdx.x == 0) nTracksPerPart = 0; + + // Define geometry factors + const auto nLayers = seed_uv::geomInfo::nLayers; + // 0 2 4 6 8 10 12 14 16 18 20 22 + // 1 5 0 3 4 2 + unsigned int uvCodes[nLayers] = {10 + part, 2 + part, 20 + part, 12 + part, 18 + part, 4 + part}; // FIXME + + // Storing hits + static constexpr unsigned int maxNHits = 300; // FIXME + __shared__ float hits_shared[nLayers * maxNHits]; + seeding::HitCache hits; + unsigned zone_offset[6]; + // Load the hits in shared: + unsigned totalHits = 0; + for (int iLayer = 0; iLayer < nLayers; iLayer++) { + hits.size[iLayer] = scifi_hit_count.zone_number_of_hits(uvCodes[iLayer]); + totalHits += hits.size[iLayer]; + } + + shared_or_global( + totalHits, + nLayers * maxNHits, + hits_shared, + parameters.dev_hits_working_mem, + parameters.dev_count_hits_working_mem, + [&](float* ptr) { + hits.data = ptr; + + hits.start[0] = 0; + for (int iLayer = 0; iLayer < nLayers; iLayer++) { + if (iLayer > 0) hits.start[iLayer] = hits.start[iLayer - 1] + hits.size[iLayer - 1]; + zone_offset[iLayer] = scifi_hit_count.zone_offset(uvCodes[iLayer]); + for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + hits.hit(iLayer, iHit) = scifi_hits.x0(zone_offset[iLayer] + iHit); + } + } + __syncthreads(); + float partSign = (part == 1) * 2.f - 1.f; + float yCenter = seed_uv::geomInfo::yCenter * partSign; + float yEdge = seed_uv::geomInfo::yEdge * partSign; + float dxMin[nLayers], dxMax[nLayers]; + for (int iLayer = 0; iLayer != nLayers; iLayer++) { + float dxCenter = yCenter * seed_uv::geomInfo::dxDy[iLayer]; + float dxEdge = yEdge * seed_uv::geomInfo::dxDy[iLayer]; + dxMin[iLayer] = min(dxCenter, dxEdge); + dxMax[iLayer] = max(dxCenter, dxEdge); + } + // We can fully parallelise over tracks (they are only weakly ordered) + const auto xTracks = parameters.dev_seeding_tracksXZ; + int shiftTrack = + (part == 0) ? + 0 : + parameters + .dev_seeding_number_of_tracksXZ_part0[event_number]; // FIXME: LC: we can probably find an easier solution + int startTrack = event_number * SciFi::Constants::Nmax_seed_xz + shiftTrack; + int endTrack = (part == 0) ? parameters.dev_seeding_number_of_tracksXZ_part0[event_number] : + parameters.dev_seeding_number_of_tracksXZ_part1[event_number]; + endTrack += startTrack; + for (int iTrack = startTrack + threadIdx.x; iTrack < endTrack; iTrack += blockDim.x) { + constexpr int TUNING_NHITS = 10; // FIXME + constexpr float TUNING_TOLCHI2 = 100.f; // FIXME + constexpr float TUNING_TOL = 2.f; // FIXME + const auto xTrack = xTracks[iTrack]; + const int nTarget = TUNING_NHITS - xTrack.number_of_hits; + // Calculate the predicted x(z) position of the track in all U/V layers + float xPred[nLayers]; + for (unsigned int iLayer = 0; iLayer < nLayers; iLayer++) { + xPred[iLayer] = + xTrack.ax + xTrack.bx * seed_uv::geomInfo::dz[iLayer] + xTrack.cx * seed_uv::geomInfo::dz2[iLayer]; + } + // Collect hits in the first layer and parallelise over them as well. There are up to few tens of them + float bestChi2Ndof = TUNING_TOLCHI2; + seed_uv::multiHitCombination bestHitComb; + // For each hit in first layer and tolerance, look for hit combinations that match that hypothesis + int minXPredIdx[nLayers], nIdx[nLayers]; + for (auto iLayer = 0; iLayer < nLayers; iLayer++) { + auto minXPred = xPred[iLayer] + dxMin[iLayer]; + auto maxXPred = xPred[iLayer] + dxMax[iLayer]; + minXPredIdx[iLayer] = + hybrid_seeding::binary_search_leftmost_unrolled(hits.layer(iLayer), hits.size[iLayer], minXPred); + auto maxXPredIdx = + hybrid_seeding::binary_search_leftmost_unrolled(hits.layer(iLayer), hits.size[iLayer], maxXPred); + nIdx[iLayer] = maxXPredIdx - minXPredIdx[iLayer]; + if (maxXPredIdx != hits.size[iLayer]) nIdx[iLayer]++; + } + // First loop + for (int iHitFirst = minXPredIdx[0]; iHitFirst < minXPredIdx[0] + nIdx[0]; iHitFirst++) { + seed_uv::multiHitCombination hitComb; + // We now have a tY hypothesis. We look in all 5 remaining layers for hits close to expected position + // this is basically the same thing as looking for the first hit, but with tY in a smaller interval + hitComb.idx[0] = iHitFirst; + hitComb.y[0] = (xPred[0] - hits.hit(0, iHitFirst)) / seed_uv::geomInfo::dxDy[0]; + float ty = hitComb.y[0] / (seed_uv::geomInfo::z[0]); + for (unsigned int iRemaining = 1; iRemaining < nLayers; iRemaining++) { + // Check if we can even find enough hits + if (hitComb.number_of_hits + (nLayers - iRemaining) < nTarget) break; + float xMeasPred = + xPred[iRemaining] - ty * seed_uv::geomInfo::dxDy[iRemaining] * seed_uv::geomInfo::z[iRemaining]; + hitComb.idx[iRemaining] = + findHit(TUNING_TOL, xMeasPred, minXPredIdx[iRemaining], nIdx[iRemaining], hits.layer(iRemaining)); + if (hitComb.idx[iRemaining] != SciFi::Constants::INVALID_IDX) { + hitComb.y[iRemaining] = (xPred[iRemaining] - hits.hit(iRemaining, hitComb.idx[iRemaining])) / + seed_uv::geomInfo::dxDy[iRemaining]; + // refine ty: + ty = (ty + hitComb.y[iRemaining] / seed_uv::geomInfo::z[iRemaining]) * 0.5f; + ++hitComb.number_of_hits; + } + } + if (xTrack.number_of_hits + hitComb.number_of_hits < TUNING_NHITS) continue; + if (hitComb.number_of_hits < bestHitComb.number_of_hits) continue; + auto fitY = fitYZ(hitComb); + if (hitComb.number_of_hits == bestHitComb.number_of_hits && hitComb.chi2 > bestChi2Ndof) continue; + bestChi2Ndof = hitComb.chi2; + bestHitComb = hitComb; + } + // Second loop + for (int iHitFirst = minXPredIdx[1]; iHitFirst < minXPredIdx[1] + nIdx[1]; iHitFirst++) { + seed_uv::multiHitCombination hitComb; + // We now have a tY hypothesis. We look in all 5 remaining layers for hits close to expected position + // this is basically the same thing as looking for the first hit, but with tY in a smaller interval + hitComb.idx[0] = SciFi::Constants::INVALID_IDX; + hitComb.idx[1] = iHitFirst; + hitComb.y[1] = (xPred[1] - hits.hit(1, iHitFirst)) / seed_uv::geomInfo::dxDy[1]; + float ty = hitComb.y[1] / (seed_uv::geomInfo::z[1]); + for (unsigned int iRemaining = 2; iRemaining < nLayers; iRemaining++) { + // Check if we can even find enough hits + if (hitComb.number_of_hits + (nLayers - iRemaining) < nTarget) break; + float xMeasPred = + xPred[iRemaining] - ty * seed_uv::geomInfo::dxDy[iRemaining] * seed_uv::geomInfo::z[iRemaining]; + hitComb.idx[iRemaining] = + findHit(TUNING_TOL, xMeasPred, minXPredIdx[iRemaining], nIdx[iRemaining], hits.layer(iRemaining)); + if (hitComb.idx[iRemaining] != SciFi::Constants::INVALID_IDX) { + hitComb.y[iRemaining] = (xPred[iRemaining] - hits.hit(iRemaining, hitComb.idx[iRemaining])) / + seed_uv::geomInfo::dxDy[iRemaining]; + // refine ty: + ty = (ty + hitComb.y[iRemaining] / seed_uv::geomInfo::z[iRemaining]) * 0.5f; + ++hitComb.number_of_hits; + } + } + if (xTrack.number_of_hits + hitComb.number_of_hits < TUNING_NHITS) continue; + auto fitY = fitYZ(hitComb); + if (hitComb.number_of_hits < bestHitComb.number_of_hits) continue; + if (hitComb.number_of_hits == bestHitComb.number_of_hits && hitComb.chi2 > bestChi2Ndof) continue; + bestChi2Ndof = hitComb.chi2; + bestHitComb = hitComb; + } + + if (xTrack.number_of_hits + bestHitComb.number_of_hits < TUNING_NHITS) continue; + // We have found at least one combination that matches the XZ track. Build the full track. + SciFi::Seeding::Track fullTrack; + for (auto iHit = 0; iHit < xTrack.number_of_hits; iHit++) { + fullTrack.hits[iHit] = xTrack.hits[iHit]; + } + auto iHit = 0; + for (auto iLayer = 0; iLayer < nLayers; iLayer++) { + if (bestHitComb.idx[iLayer] == SciFi::Constants::INVALID_IDX) continue; + fullTrack.hits[xTrack.number_of_hits + iHit] = + scifi_hit_count.zone_offset(uvCodes[iLayer]) + bestHitComb.idx[iLayer]; + iHit++; + } + + fullTrack.number_of_hits = xTrack.number_of_hits + bestHitComb.number_of_hits; + fullTrack.ay = bestHitComb.ay; + fullTrack.by = bestHitComb.by; + fullTrack.ax = xTrack.ax; + fullTrack.bx = xTrack.bx; + fullTrack.cx = xTrack.cx; + auto startIndex = SciFi::Constants::Nmax_seeds * event_number + shiftCaseTracks; + auto idx = atomicAdd(&nTracksPerPart, 1); + if (idx >= SciFi::Constants::Nmax_seeds_per_part) break; + parameters.dev_seeding_tracks[startIndex + idx] = fullTrack; + } + __syncthreads(); + shiftCaseTracks += min(nTracksPerPart, SciFi::Constants::Nmax_seeds_per_part); + __syncthreads(); + }); + } // end the loop on parts + if (threadIdx.x == 0) { + parameters.dev_seeding_number_of_tracks[event_number] = shiftCaseTracks; + parameters.dev_seeding_confirmTracks_atomics[event_number] = shiftCaseTracks; + } +} + +__device__ bool seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHitComb) +{ + float m00 = multiHitComb.number_of_hits; + float m01 = 0.f; + float m11 = 0.f; + float r0 = 0.f; + float r1 = 0.f; + float ay = 0.f; + float by = 0.f; + // initialize matrix + for (int i = 0; i < seed_uv::geomInfo::nLayers; i++) { + if (multiHitComb.idx[i] == SciFi::Constants::INVALID_IDX) continue; + m01 += seed_uv::geomInfo::dz[i]; + m11 += seed_uv::geomInfo::dz[i] * seed_uv::geomInfo::dz[i]; + r0 += multiHitComb.y[i]; + r1 += multiHitComb.y[i] * seed_uv::geomInfo::dz[i]; + } + // calculate the determinants and apply Cramer's rule + float detM = m00 * m11 - m01 * m01; // never 0, no need to test + ay += (r0 * m11 - r1 * m01) / detM; + by += (r1 * m00 - r0 * m01) / detM; + float score = 0.f; + for (int i = 0; i < seed_uv::geomInfo::nLayers; i++) { + if (multiHitComb.idx[i] == SciFi::Constants::INVALID_IDX) continue; + float hit_chi2 = (multiHitComb.y[i] - (ay + by * seed_uv::geomInfo::dz[i])); + hit_chi2 *= hit_chi2; + score += hit_chi2; + } + multiHitComb.ay = ay; + multiHitComb.by = by; + multiHitComb.chi2 = score; + return true; +} diff --git a/device/SciFi/hybridseeding/src/seed_xz.cu b/device/SciFi/hybridseeding/src/seed_xz.cu new file mode 100644 index 00000000000..e61e776a2f4 --- /dev/null +++ b/device/SciFi/hybridseeding/src/seed_xz.cu @@ -0,0 +1,450 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#include "seed_xz.cuh" +#include "BinarySearch.cuh" +#include "hybrid_seeding_helpers.cuh" +#include "hybrid_seeding_case.cuh" +#include "memory_optim.cuh" + +/** + * @brief Seeding in SciFi 1st stage with x_z layers + * @detail first implementation of seeding starting with x_z layers to fit under HLT1 timing budget. + */ + +namespace { + // For a given pair of hits, one in the first layer, the other in the second layer, calculate interesting paramaters. + __device__ seed_xz::TwoHitCombination + makeTwoHitCombination(const hybrid_seeding::Case& currentCase, const float firstHit, const float lastHit) + { + seed_xz::TwoHitCombination hitComb; + hitComb.tx = (lastHit - firstHit) * currentCase.invZlZf; //-LoH: average slope + hitComb.xRef = firstHit - currentCase.dz[0] * hitComb.tx; //-LoH: position at z=zRef + hitComb.xProj = firstHit - hitComb.tx * currentCase.t1_z; //-LoH: extrapolated position at z=0. Used only for 1/p + // calculation. Could be changed for 1 fewer terms + float q = copysignf(1.f, -hitComb.xProj); + hitComb.xProj *= -q; // now absolute value + // SPEEDUP: is the quadratic term really needed considering our momentum? + // SPEEDUP: use x0 rather than invP (frees a register) + hitComb.invP = hitComb.xProj * (currentCase.invPTerms_1 + currentCase.invPTerms_2 * hitComb.xProj); + hitComb.xProj = hitComb.xRef + currentCase.dz[2] * hitComb.tx; // xProj is now the projected x on T2x1 + + // FIXME: This tuning should be improved + hitComb.maxPara = hitComb.xProj - q * (currentCase.threeHit0 + hitComb.invP * currentCase.threeHit1); + hitComb.minPara = hitComb.xProj - q * (-2.f * currentCase.threeHit0 + hitComb.invP * (currentCase.threeHit1)); + if (q > 0.f) { + float temp = hitComb.minPara; + hitComb.minPara = hitComb.maxPara; + hitComb.maxPara = temp; + } + return hitComb; + } + + __device__ int findRemainingHit(const float tolRem, float& predPos, int nHits, float* hits) + { + auto minIdx = seeding::searchBin(predPos, hits, nHits); + predPos -= hits[minIdx]; + if (std::fabs(predPos) > tolRem) return SciFi::Constants::INVALID_IDX; + return minIdx; + } + + __device__ SciFi::Seeding::TrackXZ make_trackXZ( + SciFi::ConstHits& scifi_hits, + unsigned int* zone_offset, + const seed_xz::multiHitCombination& multiHitComb, + float chi2ndof) + { + int n_hits = 0; + SciFi::Seeding::TrackXZ track; + track.chi2 = chi2ndof; + + for (int iLayer = 0; iLayer < 6; iLayer++) { + track.idx[iLayer] = multiHitComb.idx[iLayer]; + if (multiHitComb.idx[iLayer] == SciFi::Constants::INVALID_IDX) continue; + auto hit_idx = zone_offset[iLayer] + multiHitComb.idx[iLayer]; + track.ids[n_hits] = scifi_hits.id(hit_idx); + track.hits[n_hits++] = hit_idx; + } + track.number_of_hits = n_hits; + track.ax = multiHitComb.ax; + track.bx = multiHitComb.bx; + track.cx = multiHitComb.cx; + + return track; + } + + // SPEEDUP: in reality, there are only 4 possible LHS matrices, so we could precalculate them, most of the detMi and + // detM + __device__ float fitXZ(const hybrid_seeding::Case& currentCase, seed_xz::multiHitCombination& hitComb) + { + const unsigned int layers[6] = {currentCase.iFirst, + currentCase.iLast, + currentCase.iMiddle, + currentCase.iRem[0], + currentCase.iRem[1], + currentCase.iRem[2]}; + + float rhs[3] = {0.f}; + float lhs[6]; + for (auto i = 0; i < 6; i++) + lhs[i] = currentCase.startingFitMatrix[i]; + for (auto i = 3; i < 6; i++) { + if (hitComb.idx[layers[i]] == SciFi::Constants::INVALID_IDX) { + continue; + } + lhs[0]++; + lhs[1] += currentCase.dz[i]; + lhs[2] += currentCase.dz2[i]; + lhs[3] += currentCase.dz[i] * currentCase.dz[i]; + lhs[4] += currentCase.dz2[i] * currentCase.dz[i]; + lhs[5] += currentCase.dz2[i] * currentCase.dz2[i]; + rhs[0] -= hitComb.delta_x[i]; + rhs[1] -= hitComb.delta_x[i] * currentCase.dz[i]; + rhs[2] -= hitComb.delta_x[i] * currentCase.dz2[i]; + } + // Fit x + // SPEEDUP: if we have enough registers, we could cache these + // There are only 4 possible detM, which is why there is no detM != 0 test + // SPEEDUP: if we have enough registers, we could at least calculate only once some common terms + // e.g + // float term_3544 = lhs[3] * lhs[5] - lhs[4] * lhs[4] (used 2 times) + // float term_2415 = lhs[4] * lhs[2] - lhs[5] * lhs[1] (used 3 times) + // float term_1423 = lhs[1] * lhs[4] - lhs[2] * lhs[3] (used 3 times) + // float term_1204 = lhs[1] * lhs[2] - lhs[0] * lhs[4] (used 2 times) + float detM = lhs[0] * (lhs[3] * lhs[5] - lhs[4] * lhs[4]) + lhs[1] * (lhs[4] * lhs[2] - lhs[5] * lhs[1]) + + lhs[2] * (lhs[1] * lhs[4] - lhs[2] * lhs[3]); + float detM0 = rhs[0] * (lhs[3] * lhs[5] - lhs[4] * lhs[4]) + rhs[1] * (lhs[4] * lhs[2] - lhs[5] * lhs[1]) + + rhs[2] * (lhs[1] * lhs[4] - lhs[2] * lhs[3]); + float detM1 = rhs[0] * (lhs[2] * lhs[4] - lhs[1] * lhs[5]) + rhs[1] * (lhs[0] * lhs[5] - lhs[2] * lhs[2]) + + rhs[2] * (lhs[1] * lhs[2] - lhs[0] * lhs[4]); + float detM2 = rhs[0] * (lhs[1] * lhs[4] - lhs[2] * lhs[3]) + rhs[1] * (lhs[1] * lhs[2] - lhs[0] * lhs[4]) + + rhs[2] * (lhs[0] * lhs[3] - lhs[1] * lhs[1]); + hitComb.ax += detM0 / detM; + hitComb.bx += detM1 / detM; + hitComb.cx += detM2 / detM; + // TODO: Refit? + float score = 0.f; + for (unsigned i = 0; i < 3; i++) { // SPEEDUP: the division by detM is probably useless + float err = (detM0 + detM1 * currentCase.dz[i] + detM2 * currentCase.dz2[i]) / detM; + score += err * err; + } + for (unsigned i = 3; i < 6; i++) { // SPEEDUP: the division by detM is probably useless + if (hitComb.idx[layers[i]] == SciFi::Constants::INVALID_IDX) continue; + float err = hitComb.delta_x[i] + (detM0 + detM1 * currentCase.dz[i] + detM2 * currentCase.dz2[i]) / detM; + score += err * err; + } + // Make track + // FIXME: Hack to make clone selection systematically prefer tracks with more hits + if (lhs[0] == 5) score *= 10.f; + score += currentCase.scoreOffset; // if 2 tracks using the same hits have the same chi2, privilagiate the first case + return score; + } + + template + __device__ void makeTriplets( + unsigned* triplets, + unsigned& nTriplets, + const hybrid_seeding::Case& currentCase, + seeding::HitCache& hits, + const unsigned int* layers) + { + + [[maybe_unused]] unsigned maxTripletPerFirstHit = seeding::Triplet::maxTriplets / hits.size[layers[0]]; + (void) maxTripletPerFirstHit; // TODO: remove if [[maybe_unused]] decides to work someday.. + + for (int firstHitIdx = threadIdx.x; firstHitIdx < hits.size[layers[0]]; firstHitIdx += blockDim.x) { + float xFirst = hits.hit(layers[0], firstHitIdx); + float maxXl = xFirst * currentCase.twoHitScale + currentCase.tol2Hit; + float minXl = maxXl - 2.f * currentCase.tol2Hit; + + [[maybe_unused]] int nCandidates = 0; + (void) nCandidates; // TODO: remove if [[maybe_unused]] decides to work someday.. + + // SPEEDUP: cache last layer first hit + auto startSecond = + hybrid_seeding::binary_search_leftmost_unrolled(hits.layer(layers[1]), hits.size[layers[1]], minXl); + for (auto secondHitIdx = startSecond; secondHitIdx < hits.size[layers[1]]; secondHitIdx++) { + float xLast = hits.hit(layers[1], secondHitIdx); + if (xLast > maxXl) break; + auto twoHitComb = makeTwoHitCombination(currentCase, xFirst, xLast); // New parameters + // Look for parabola hits and update bounds + // BENCHMARK EFFICIENCY: make a second loop in T2x2 + auto startThird = hybrid_seeding::binary_search_leftmost_unrolled( + hits.layer(layers[2]), hits.size[layers[2]], twoHitComb.minPara); + for (auto thirdHitIdx = startThird; thirdHitIdx < hits.size[layers[2]]; thirdHitIdx++) { + auto xMiddle = hits.hit(layers[2], thirdHitIdx); + // FIXME: adding 1.f to tolerances increases efficiencies by 1.2% + if (xMiddle > twoHitComb.maxPara) break; + + if constexpr (limitTriplets) { + if (nCandidates >= maxTripletPerFirstHit) break; + nCandidates++; + } + + auto idx = atomicAdd(&nTriplets, 1); + if (idx >= seeding::Triplet::maxTriplets) break; + triplets[idx] = seeding::Triplet(firstHitIdx, secondHitIdx, thirdHitIdx).indices; + } // third hit + } // second hit + } // first hit + } +} // namespace + +INSTANTIATE_ALGORITHM(seed_xz::seed_xz_t); + +void seed_xz::seed_xz_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size(arguments, first(arguments)); + set_size(arguments, 1); + set_size(arguments, first(arguments) * seeding::Triplet::maxTriplets); + // Real output + set_size( + arguments, first(arguments) * SciFi::Constants::Nmax_seed_xz); + set_size(arguments, first(arguments)); + set_size( + arguments, first(arguments) * SciFi::Constants::Nmax_seed_xz); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); +} + +void seed_xz::seed_xz_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const +{ + initialize( + arguments, 0, context); // This is only needed because of the prefix sum, should be removed + initialize(arguments, 0, context); + global_function(seed_xz)(dim3(size(arguments)), dim3(128), context)(arguments); +} + +__global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) +{ + const unsigned number_of_events = parameters.dev_number_of_events[0]; + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + + // SciFi hits + const uint total_number_of_hits = + parameters.dev_scifi_hit_count[number_of_events * SciFi::Constants::n_mat_groups_and_mats]; + SciFi::ConstHitCount scifi_hit_count {parameters.dev_scifi_hit_count, event_number}; + SciFi::ConstHits scifi_hits {parameters.dev_scifi_hits, total_number_of_hits}; + + // Output tracks (global memory) + SciFi::Seeding::TrackXZ* reconstructed_tracksXZ_global = + parameters.dev_seeding_tracksXZ + event_number * SciFi::Constants::Nmax_seed_xz; + + unsigned* triplets = parameters.dev_triplets + event_number * seeding::Triplet::maxTriplets; + + // Shared between parts + unsigned nReconstructedTracks = 0; + hybrid_seeding::Case Case0(0, 2, 4, 1, 3, 5, 3000.f, 0); + hybrid_seeding::Case Case1(1, 3, 5, 0, 2, 4, 3000.f, 0.01f); + + for (unsigned int part = 0; part < SciFi::Constants::n_parts; part++) { + __shared__ int nTracksPart; + if (threadIdx.x == 0) nTracksPart = 0; + + // What space do we need to work with ? + unsigned maxSeeds = SciFi::Constants::Nmax_seed_xz - nReconstructedTracks; + + // Define the hits + __shared__ float hits_shared[6 * maxNHits]; + seeding::HitCache hits; + unsigned zone_offset[6]; + + // Encoding goes as: + // 0 2 4 6 8 10 12 14 16 18 20 22 + // 0 1 2 3 4 5 + unsigned int xLayers[6] = {0 + part, 6 + part, 8 + part, 14 + part, 16 + part, 22 + part}; + + // Load the hits in shared: + unsigned totalHits = 0; + for (int iLayer = 0; iLayer < 6; iLayer++) { + hits.size[iLayer] = scifi_hit_count.zone_number_of_hits(xLayers[iLayer]); + totalHits += hits.size[iLayer]; + } + // If hits don't fit in shared, use global instead + shared_or_global( + totalHits, + 6 * maxNHits, + hits_shared, + parameters.dev_hits_working_mem, + parameters.dev_count_hits_working_mem, + [&](float* ptr) { + hits.data = ptr; + + hits.start[0] = 0; + for (int iLayer = 0; iLayer < 6; iLayer++) { + if (iLayer > 0) hits.start[iLayer] = hits.start[iLayer - 1] + hits.size[iLayer - 1]; + zone_offset[iLayer] = scifi_hit_count.zone_offset(xLayers[iLayer]); + for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + hits.hit(iLayer, iHit) = scifi_hits.x0(zone_offset[iLayer] + iHit); + } + } + __syncthreads(); + + for (auto currentCase : {Case0, Case1}) { + const unsigned int layers[6] = {currentCase.iFirst, + currentCase.iLast, + currentCase.iMiddle, + currentCase.iRem[0], + currentCase.iRem[1], + currentCase.iRem[2]}; + + __shared__ unsigned nTriplets; + __syncthreads(); + if (threadIdx.x == 0) { + nTriplets = 0; + } + __syncthreads(); + + // Main loop + makeTriplets(triplets, nTriplets, currentCase, hits, layers); + __syncthreads(); + + // if the event is too big, redo the triplets with a limit per first hit + if (nTriplets > seeding::Triplet::maxTriplets) { + __syncthreads(); + if (threadIdx.x == 0) nTriplets = 0; + __syncthreads(); + + makeTriplets(triplets, nTriplets, currentCase, hits, layers); + __syncthreads(); + } + + for (int tripletIdx = threadIdx.x; tripletIdx < nTriplets; tripletIdx += blockDim.x) { + seeding::Triplet triplet {triplets[tripletIdx]}; + int firstHitIdx = triplet.idx0(); + int secondHitIdx = triplet.idx1(); + int thirdHitIdx = triplet.idx2(); + float xFirst = hits.hit(layers[0], firstHitIdx); + float xLast = hits.hit(layers[1], secondHitIdx); + float xMiddle = hits.hit(layers[2], thirdHitIdx); + auto twoHitComb = makeTwoHitCombination(currentCase, xFirst, xLast); + + seed_xz::multiHitCombination multiHitComb; + // -LoH: the curvature is proportional to the error on the 3rd hit projection: + multiHitComb.cx = (twoHitComb.xProj - xMiddle) * currentCase.delSeedCorr; + // -LoH: the slope parameter is close to the average slope, up to curvature correction: + multiHitComb.bx = twoHitComb.tx - multiHitComb.cx * currentCase.txCorr; + // -LoH: the intersect of the track with z=zRef plane is close to 2hit intersect, up to curvature + multiHitComb.ax = twoHitComb.xRef - multiHitComb.cx * currentCase.xRefCorr; + multiHitComb.delta_x[3] = + multiHitComb.ax + currentCase.dz[3] * multiHitComb.bx + currentCase.dz2[3] * multiHitComb.cx; + multiHitComb.delta_x[4] = + multiHitComb.ax + currentCase.dz[4] * multiHitComb.bx + currentCase.dz2[4] * multiHitComb.cx; + + // Find the remainings + multiHitComb.idx[layers[3]] = findRemainingHit( + currentCase.tolRem, multiHitComb.delta_x[3], hits.size[layers[3]], hits.layer(layers[3])); + multiHitComb.idx[layers[4]] = findRemainingHit( + currentCase.tolRem, multiHitComb.delta_x[4], hits.size[layers[4]], hits.layer(layers[4])); + + // Early stopping: at least 5 hits + if ( + multiHitComb.idx[layers[3]] == SciFi::Constants::INVALID_IDX && + multiHitComb.idx[layers[4]] == SciFi::Constants::INVALID_IDX) + continue; + multiHitComb.delta_x[5] = + multiHitComb.ax + currentCase.dz[5] * multiHitComb.bx + currentCase.dz2[5] * multiHitComb.cx; + + // T3x2 is responsible for most ghosts: +8% ghosts and +7% efficiency considering it. + multiHitComb.idx[layers[5]] = findRemainingHit( + currentCase.tolRem, multiHitComb.delta_x[5], hits.size[layers[5]], hits.layer(layers[5])); + + // Early stopping: at least 5 hits + if ( + multiHitComb.idx[layers[5]] == SciFi::Constants::INVALID_IDX && + (multiHitComb.idx[layers[3]] == SciFi::Constants::INVALID_IDX || + multiHitComb.idx[layers[4]] == SciFi::Constants::INVALID_IDX)) + continue; + + // Make the multi hit combination and precalculate fit matrix + multiHitComb.idx[layers[0]] = firstHitIdx; + multiHitComb.idx[layers[1]] = secondHitIdx; + multiHitComb.idx[layers[2]] = thirdHitIdx; + auto score = fitXZ(currentCase, multiHitComb); + + auto idx = atomicAdd(&nTracksPart, 1); + if (idx >= maxSeeds) break; + + reconstructed_tracksXZ_global[nReconstructedTracks + idx] = make_trackXZ( + scifi_hits, zone_offset, multiHitComb, score); // FIXME: inside the track model, score = chi2ndof + } // Closes first layer + __syncthreads(); + + if (threadIdx.x == 0 && nTracksPart > maxSeeds) { + nTracksPart = 0; // is not deterministic so drop the new tracks + // TODO: could be improved by only dropping the current case (since it's most likely to happen in case1) + } + __syncthreads(); + + if (nTracksPart >= maxSeeds) break; + } // Closes cases + + // Clone removal + for (int iLayer = 0; iLayer != 6; iLayer++) { + for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + hits.hit(iLayer, iHit) = 100000.f; + } + } + __syncthreads(); + for (int i = threadIdx.x; i < nTracksPart; i += blockDim.x) { + auto& track = reconstructed_tracksXZ_global[nReconstructedTracks + i]; + for (int iLayer = 0; iLayer < 6; iLayer++) { + auto hit = track.idx[iLayer]; + if (hit == SciFi::Constants::INVALID_IDX) continue; + atomicMin((int*) &hits.hit(iLayer, hit), __float_as_int(track.chi2 * 1000 + track.cx)); + } + } + __shared__ int nFilteredTracks; + if (threadIdx.x == 0) nFilteredTracks = 0; + __syncthreads(); + + for (int i = 0; i < nTracksPart; i += blockDim.x) { + int nHits = 0; + SciFi::Seeding::TrackXZ track; + if (i + threadIdx.x < nTracksPart) { + track = reconstructed_tracksXZ_global[nReconstructedTracks + i + threadIdx.x]; + for (int iLayer = 0; iLayer < 6; iLayer++) { + auto hit = track.idx[iLayer]; + if (hit == SciFi::Constants::INVALID_IDX) continue; + nHits += fabs(hits.hit(iLayer, hit) - (track.chi2 * 1000 + track.cx)) < 0.01f; + } + } + __syncthreads(); + if (nHits > 3) { + auto idx = atomicAdd(&nFilteredTracks, 1); + reconstructed_tracksXZ_global[nReconstructedTracks + idx] = track; + } + __syncthreads(); + } + __syncthreads(); + + // Finalise + // Write reconstructed tracks from all cases to device parameters for reconstructed XZ tracks + if (part == 0) { + parameters.dev_seeding_number_of_tracksXZ_part0[event_number] = nFilteredTracks; + } + else { + parameters.dev_seeding_number_of_tracksXZ_part1[event_number] = nFilteredTracks; + } + nReconstructedTracks += nFilteredTracks; + }); + } // end loop on parts + parameters.dev_seeding_number_of_tracksXZ[event_number] = nReconstructedTracks; +} diff --git a/device/event_model/SciFi/include/SciFiConsolidated.cuh b/device/event_model/SciFi/include/SciFiConsolidated.cuh index ada191437a5..3fd1a286777 100644 --- a/device/event_model/SciFi/include/SciFiConsolidated.cuh +++ b/device/event_model/SciFi/include/SciFiConsolidated.cuh @@ -243,7 +243,7 @@ namespace SciFi { __host__ __device__ float qop(const unsigned index) const { return m_qop[index]; } __host__ __device__ float& qop(const unsigned index) { return m_qop[index]; } - + __host__ __device__ MiniState states(const unsigned index) const { return m_states[index]; } __host__ __device__ MiniState& states(const unsigned index) { return m_states[index]; } @@ -287,9 +287,146 @@ namespace SciFi { } return ids; } - }; // namespace Consolidated + + }; // struct Tracks typedef const Tracks_t ConstTracks; typedef Tracks_t Tracks; + + //--------------------------------------------------------- + // Struct for holding consolidated SciFi seed information. + //--------------------------------------------------------- + template + struct Seeds_t : public ::Consolidated::Tracks { + private: + typename ForwardType::t* m_states; + + public: + __host__ __device__ Seeds_t( + const unsigned* atomics_base_pointer, + const unsigned* track_hit_number_base_pointer, + typename ForwardType::t* states_base_pointer, + const unsigned current_event_number, + const unsigned number_of_events) : + ::Consolidated::Tracks( + atomics_base_pointer, + track_hit_number_base_pointer, + current_event_number, + number_of_events), + m_states(states_base_pointer + tracks_offset(current_event_number)) + {} + + __host__ __device__ MiniState states(const unsigned index) const { return m_states[index]; } + + __host__ __device__ MiniState& states(const unsigned index) { return m_states[index]; } + + __host__ __device__ Hits get_hits(char* hits_base_pointer, const unsigned track_number) const + { + return Hits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + } + + __host__ __device__ ConstHits get_hits(const char* hits_base_pointer, const unsigned track_number) const + { + return ConstHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + } + + __host__ __device__ ExtendedHits get_hits( + char* hits_base_pointer, + const unsigned track_number, + const SciFiGeometry* geom, + const float* inv_clus_res) const + { + return ExtendedHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits, inv_clus_res, geom}; + } + + __host__ __device__ ConstExtendedHits get_hits( + const char* hits_base_pointer, + const unsigned track_number, + const SciFiGeometry* geom, + const float* inv_clus_res) const + { + return ConstExtendedHits { + hits_base_pointer, track_offset(track_number), m_total_number_of_hits, inv_clus_res, geom}; + } + + __host__ std::vector get_lhcbids_for_track(const char* hits_base_pointer, const unsigned track_number) + const + { + std::vector ids; + const auto hits = ConstHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + for (unsigned i = 0; i < number_of_hits(track_number); ++i) { + ids.push_back(hits.id(i)); + } + return ids; + } + + }; // struct Seeds + + typedef const Seeds_t ConstSeeds; + typedef Seeds_t Seeds; + + //--------------------------------------------------------- + // Struct for holding consolidated SciFi seedXZ information. + //--------------------------------------------------------- + template + struct SeedsXZ_t : public ::Consolidated::Tracks { + + public: + __host__ __device__ SeedsXZ_t( + const unsigned* atomics_base_pointer, + const unsigned* track_hit_number_base_pointer, + const unsigned current_event_number, + const unsigned number_of_events) : + ::Consolidated::Tracks( + atomics_base_pointer, + track_hit_number_base_pointer, + current_event_number, + number_of_events) + {} + + __host__ __device__ Hits get_hits(char* hits_base_pointer, const unsigned track_number) const + { + return Hits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + } + + __host__ __device__ ConstHits get_hits(const char* hits_base_pointer, const unsigned track_number) const + { + return ConstHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + } + + __host__ __device__ ExtendedHits get_hits( + char* hits_base_pointer, + const unsigned track_number, + const SciFiGeometry* geom, + const float* inv_clus_res) const + { + return ExtendedHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits, inv_clus_res, geom}; + } + + __host__ __device__ ConstExtendedHits get_hits( + const char* hits_base_pointer, + const unsigned track_number, + const SciFiGeometry* geom, + const float* inv_clus_res) const + { + return ConstExtendedHits { + hits_base_pointer, track_offset(track_number), m_total_number_of_hits, inv_clus_res, geom}; + } + + __host__ std::vector get_lhcbids_for_track(const char* hits_base_pointer, const unsigned track_number) + const + { + std::vector ids; + const auto hits = ConstHits {hits_base_pointer, track_offset(track_number), m_total_number_of_hits}; + for (unsigned i = 0; i < number_of_hits(track_number); ++i) { + ids.push_back(hits.id(i)); + } + return ids; + } + + }; // struct SeedsXZ + + typedef const SeedsXZ_t ConstSeedsXZ; + typedef SeedsXZ_t SeedsXZ; } // namespace Consolidated } // end namespace SciFi diff --git a/device/event_model/SciFi/include/SciFiDefinitions.cuh b/device/event_model/SciFi/include/SciFiDefinitions.cuh index 46abdda6819..6f31616ae8c 100644 --- a/device/event_model/SciFi/include/SciFiDefinitions.cuh +++ b/device/event_model/SciFi/include/SciFiDefinitions.cuh @@ -19,6 +19,9 @@ namespace SciFi { // need 3 arrays (size: number_of_events) for copy_and_prefix_sum_scifi_t static constexpr int num_atomics = 3; + // need 1 arrays (size: number_of_events) for seeding, right? + static constexpr int num_seeding_atomics = 1; + namespace Constants { // Detector description // There are three stations with four layers each @@ -26,7 +29,13 @@ namespace SciFi { static constexpr unsigned n_layers_per_station = 4; static constexpr unsigned n_zones = 24; static constexpr unsigned n_layers = 12; + static constexpr unsigned n_xzlayers = 6; + static constexpr unsigned n_uvlayers = 6; static constexpr unsigned n_mats = 1024; + static constexpr unsigned n_parts = 2; + static constexpr unsigned max_num_seed_tracks = 6000; // FIXME + static constexpr int INVALID_IDX = -1; // FIXME + static constexpr int INVALID_ID = 0; // FIXME /** * The following constants are based on the number of modules per quarter. @@ -59,7 +68,10 @@ namespace SciFi { // FIXME_GEOMETRY_HARDCODING // todo: use dzdy defined in geometry, read by mat static constexpr float dzdy = 0.003601f; - static constexpr float ZEndT = 9410.f * Gaudi::Units::mm; // FIXME_GEOMETRY_HARDCODING + static constexpr float dRatio = -0.00028f; + static constexpr float ZBegT = 7500.f * Gaudi::Units::mm; // FIXME_GEOMETRY_HARDCODING + static constexpr float ZEndT = 9410.f * Gaudi::Units::mm; // FIXME_GEOMETRY_HARDCODING + static constexpr float z_mid_t = 8520.f * Gaudi::Units::mm; // FIXME_GEOMETRY_HARDCODING // Looking Forward static constexpr int max_track_size = n_layers; @@ -69,6 +81,12 @@ namespace SciFi { // This constant is for the HostBuffer reserve method, when validating static constexpr int max_tracks = 1000; + + // Constants for SciFi seeding + static constexpr int Nmax_seed_xz_per_part = 300; + static constexpr int Nmax_seed_xz = n_parts * Nmax_seed_xz_per_part; + static constexpr int Nmax_seeds_per_part = 100; + static constexpr int Nmax_seeds = n_parts * Nmax_seeds_per_part; } // namespace Constants namespace SciFiRawBankParams { // from SciFi/SciFiDAQ/src/SciFiRawBankParams.h diff --git a/device/event_model/SciFi/include/SciFiEventModel.cuh b/device/event_model/SciFi/include/SciFiEventModel.cuh index b334a763494..e843e1f6ac6 100644 --- a/device/event_model/SciFi/include/SciFiEventModel.cuh +++ b/device/event_model/SciFi/include/SciFiEventModel.cuh @@ -520,4 +520,45 @@ namespace SciFi { std::size_t n_matched_total = 0; float p = 0.f, pt = 0.f, rho = 0.f; }; + namespace Seeding { + struct TrackXZ { + int number_of_hits; + unsigned int ids[6]; + int idx[6]; + unsigned int hits[6]; + float chi2; + float ax; + float bx; + float cx; + }; + + struct Track { + int number_of_hits = 0; + // unsigned int ids[SciFi::Constants::n_layers] = {SciFi::Constants::INVALID_ID}; + unsigned int hits[SciFi::Constants::n_layers] = {SciFi::Constants::INVALID_ID}; + float ax; + float bx; + float cx; + float ay; + float by; + + __host__ __device__ float x(float z) const + { + const float dz = z - SciFi::Constants::z_mid_t; + return ax + dz * (bx + dz * cx * (1.f + SciFi::Constants::dRatio * dz)); + } + __host__ __device__ float y(float z) const { return (ay + by * (z - SciFi::Constants::z_mid_t)); } + + __host__ __device__ float xFromDz(float dz) const + { + return ax + dz * (bx + dz * cx * (1.f + SciFi::Constants::dRatio * dz)); + } + __host__ __device__ float yFromDz(float dz) const { return ay + by * dz; } + __host__ __device__ float xSlopeFromDz(float dz) const + { + return bx + 2.f * dz * cx + 3.f * dz * dz * cx * SciFi::Constants::dRatio; + } + __host__ __device__ float ySlope() const { return by; } + }; + } // namespace Seeding } // namespace SciFi diff --git a/device/event_model/common/include/ConsolidatedTypes.cuh b/device/event_model/common/include/ConsolidatedTypes.cuh index fc157e3c3e7..37dac0612c1 100644 --- a/device/event_model/common/include/ConsolidatedTypes.cuh +++ b/device/event_model/common/include/ConsolidatedTypes.cuh @@ -50,6 +50,47 @@ namespace Consolidated { __device__ __host__ unsigned total_number_of_tracks() const { return m_total_number_of_tracks; } }; + // base_pointer contains first: an array with the number of seeds in every event + // second: an array with offsets to the seeds for every event + struct SeedsDescription { + // Prefix sum of all Velo seed sizes + const unsigned* m_event_seeds_offsets; + const unsigned m_total_number_of_seeds; + +#ifdef ALLEN_DEBUG + // The datatype m_number_of_events is only used in asserts, which are + // only available in DEBUG mode + const unsigned m_number_of_events; + + __device__ __host__ SeedsDescription(const unsigned* event_seeds_offsets, const unsigned number_of_events) : + m_event_seeds_offsets(event_seeds_offsets), m_total_number_of_seeds(event_seeds_offsets[number_of_events]), + m_number_of_events(number_of_events) + {} +#else + __device__ __host__ SeedsDescription(const unsigned* event_seeds_offsets, const unsigned number_of_events) : + m_event_seeds_offsets(event_seeds_offsets), m_total_number_of_seeds(event_seeds_offsets[number_of_events]) + {} +#endif + + __device__ __host__ unsigned seeds_offset(const unsigned event_number) const + { +#ifdef ALLEN_DEBUG + assert(event_number <= m_number_of_events); +#endif + return m_event_seeds_offsets[event_number]; + } + + __device__ __host__ unsigned number_of_seeds(const unsigned event_number) const + { +#ifdef ALLEN_DEBUG + assert(event_number < m_number_of_events); +#endif + return m_event_seeds_offsets[event_number + 1] - m_event_seeds_offsets[event_number]; + } + + __device__ __host__ unsigned total_number_of_seeds() const { return m_total_number_of_seeds; } + }; + // atomics_base_pointer size needed: 2 * number_of_events struct Tracks : public TracksDescription { const unsigned* m_offsets_track_number_of_hits; @@ -80,4 +121,37 @@ namespace Consolidated { __device__ __host__ unsigned total_number_of_hits() const { return m_total_number_of_hits; } }; + struct Seeds : public SeedsDescription { + const unsigned* m_offsets_seed_number_of_hits; + const unsigned m_total_number_of_hits; + + __device__ __host__ Seeds( + const unsigned* event_seeds_offsets, + const unsigned* seed_hit_number_base_pointer, + const unsigned current_event_number, + const unsigned number_of_events) : + SeedsDescription(event_seeds_offsets, number_of_events), + m_offsets_seed_number_of_hits(seed_hit_number_base_pointer + event_seeds_offsets[current_event_number]), + m_total_number_of_hits(*(seed_hit_number_base_pointer + event_seeds_offsets[number_of_events])) + {} + + __device__ __host__ unsigned seed_offset(const unsigned seed_number) const + { + // std::cout << "LoH: Asserting seed offset" << std::endl; + assert(seed_number <= m_total_number_of_seeds); + // std::cout << "LoH: Asserted seed offset" << std::endl; + return m_offsets_seed_number_of_hits[seed_number]; + } + + __device__ __host__ unsigned number_of_hits(const unsigned seed_number) const + { + // std::cout << "LoH: Asserting number of hits" << std::endl; + assert(seed_number < m_total_number_of_seeds); + // std::cout << "LoH: Asserted number of hits" << std::endl; + return m_offsets_seed_number_of_hits[seed_number + 1] - m_offsets_seed_number_of_hits[seed_number]; + } + + __device__ __host__ unsigned total_number_of_hits() const { return m_total_number_of_hits; } + }; + } // namespace Consolidated diff --git a/device/event_model/common/include/CopyTrackParameters.cuh b/device/event_model/common/include/CopyTrackParameters.cuh index 1dd9b200307..94c4071c014 100644 --- a/device/event_model/common/include/CopyTrackParameters.cuh +++ b/device/event_model/common/include/CopyTrackParameters.cuh @@ -216,6 +216,26 @@ __device__ __host__ inline float eta_from_rho(const float rho) return z + 22756.f; } +__device__ __host__ inline float eta_from_rho_z(const float rho, const float z) +{ + if (rho > 0.f) { + + // value to control Taylor expansion of sqrt + // constant value from std::pow(std::numeric_limits::epsilon(), static_cast(-.25)); + constexpr float big_z_scaled = 53.817371f; + float z_scaled = z / rho; + if (std::fabs(z_scaled) < big_z_scaled) { + return std::log(z_scaled + std::sqrt(z_scaled * z_scaled + 1.f)); + } + else { + // apply correction using first order Taylor expansion of sqrt + return z > 0.f ? std::log(2.f * z_scaled + 0.5f / z_scaled) : -std::log(-2.f * z_scaled); + } + } + // case vector has rho = 0 + return z + 22756.f; +} + __device__ inline void prepare_kalman_tracks( const unsigned number_of_tracks, const unsigned number_of_vertices, diff --git a/host/event_model/MC/include/CheckerTypes.h b/host/event_model/MC/include/CheckerTypes.h index a6e6c9a4b2e..6ba2b07213f 100644 --- a/host/event_model/MC/include/CheckerTypes.h +++ b/host/event_model/MC/include/CheckerTypes.h @@ -35,6 +35,8 @@ namespace Checker { }; struct SciFi { }; + struct SciFiSeeding { + }; struct Muon { }; diff --git a/host/event_model/MC/src/MCParticle.cpp b/host/event_model/MC/src/MCParticle.cpp index dbaa2a1942f..0ca7b534697 100644 --- a/host/event_model/MC/src/MCParticle.cpp +++ b/host/event_model/MC/src/MCParticle.cpp @@ -22,6 +22,12 @@ uint32_t get_num_hits(const MCParticle& mc_particle return mc_particle.scifi_num_hits; } +template<> +uint32_t get_num_hits(const MCParticle& mc_particle) +{ + return mc_particle.scifi_num_hits; +} + template<> uint32_t get_num_hits_subdetector(const MCParticle& mc_particle) { @@ -39,3 +45,9 @@ uint32_t get_num_hits_subdetector(const MCParticle& { return mc_particle.scifi_num_hits; } + +template<> +uint32_t get_num_hits_subdetector(const MCParticle& mc_particle) +{ + return mc_particle.scifi_num_hits; +} \ No newline at end of file diff --git a/host/validators/include/HostSeedingValidator.h b/host/validators/include/HostSeedingValidator.h new file mode 100644 index 00000000000..c1dd164e41d --- /dev/null +++ b/host/validators/include/HostSeedingValidator.h @@ -0,0 +1,42 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "BackendCommon.h" +#include "AlgorithmTypes.cuh" +#include "States.cuh" +#include "SciFiEventModel.cuh" + +namespace host_seeding_validator { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_seeds_t, SciFi::Seeding::Track) dev_scifi_seeds; + DEVICE_INPUT(dev_offsets_scifi_seeds_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_scifi_seed_hit_number_t, unsigned) dev_scifi_seed_hit_number; + DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; + MASK_INPUT(dev_event_list_t) dev_event_list; + HOST_INPUT(host_mc_events_t, const MCEvents*) host_mc_events; + PROPERTY(root_output_filename_t, "root_output_filename", "root output filename", std::string); + }; + + struct host_seeding_validator_t : public ValidationAlgorithm, Parameters { + inline void set_arguments_size( + ArgumentReferences, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const + {} + + void operator()( + const ArgumentReferences&, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context&) const; + + private: + Property m_root_output_filename {this, "PrCheckerPlots.root"}; + }; +} // namespace host_seeding_validator diff --git a/host/validators/include/HostSeedingXZValidator.h b/host/validators/include/HostSeedingXZValidator.h new file mode 100644 index 00000000000..040c7eee671 --- /dev/null +++ b/host/validators/include/HostSeedingXZValidator.h @@ -0,0 +1,41 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "BackendCommon.h" +#include "AlgorithmTypes.cuh" +#include "States.cuh" +#include "SciFiEventModel.cuh" + +namespace host_seeding_XZ_validator { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_seedsXZ_t, SciFi::Seeding::TrackXZ) dev_scifi_seedsXZ; + DEVICE_INPUT(dev_offsets_scifi_seedsXZ_t, unsigned) dev_atomics_scifi; // FIXME + DEVICE_INPUT(dev_offsets_scifi_seedXZ_hit_number_t, unsigned) dev_scifi_seedXZ_hit_number; + MASK_INPUT(dev_event_list_t) dev_event_list; + HOST_INPUT(host_mc_events_t, const MCEvents*) host_mc_events; + PROPERTY(root_output_filename_t, "root_output_filename", "root output filename", std::string); + }; + + struct host_seeding_XZ_validator_t : public ValidationAlgorithm, Parameters { + inline void set_arguments_size( + ArgumentReferences, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const + {} + + void operator()( + const ArgumentReferences&, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context&) const; + + private: + Property m_root_output_filename {this, "PrCheckerPlots.root"}; + }; +} // namespace host_seeding_XZ_validator diff --git a/host/validators/src/HostSeedingValidator.cpp b/host/validators/src/HostSeedingValidator.cpp new file mode 100644 index 00000000000..f5d93f8a2dc --- /dev/null +++ b/host/validators/src/HostSeedingValidator.cpp @@ -0,0 +1,34 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "HostSeedingValidator.h" +#include "PrepareTracks.h" + +INSTANTIATE_ALGORITHM(host_seeding_validator::host_seeding_validator_t); +void host_seeding_validator::host_seeding_validator_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants&, + HostBuffers&, + const Allen::Context&) const +{ + const auto scifi_seed_atomics = make_vector(arguments); + const auto scifi_seed_hit_number = make_vector(arguments); + const auto scifi_seed_hits = make_vector(arguments); + const auto scifi_seeds = make_vector(arguments); + const auto seeding_states = make_vector(arguments); + const auto event_list = make_vector(arguments); + + auto tracks = prepareSeedingTracks( + first(arguments), + scifi_seed_atomics, + scifi_seed_hit_number, + scifi_seed_hits, + scifi_seeds, + seeding_states, + event_list); + + auto& checker = + runtime_options.checker_invoker->checker(name(), property()); + checker.accumulate(*first(arguments), tracks, event_list); // FIXME +} diff --git a/host/validators/src/HostSeedingXZValidator.cpp b/host/validators/src/HostSeedingXZValidator.cpp new file mode 100644 index 00000000000..f6381445954 --- /dev/null +++ b/host/validators/src/HostSeedingXZValidator.cpp @@ -0,0 +1,31 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "HostSeedingXZValidator.h" +#include "PrepareTracks.h" + +INSTANTIATE_ALGORITHM(host_seeding_XZ_validator::host_seeding_XZ_validator_t); +void host_seeding_XZ_validator::host_seeding_XZ_validator_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants&, + HostBuffers&, + const Allen::Context&) const +{ + const auto scifi_seedXZ_atomics = make_vector(arguments); + const auto scifi_seedXZ_hit_number = make_vector(arguments); + const auto scifi_seedsXZ = make_vector(arguments); + const auto event_list = make_vector(arguments); + + auto tracks = prepareSeedingTracksXZ( + first(arguments), + scifi_seedXZ_atomics, + scifi_seedXZ_hit_number, + scifi_seedsXZ, + event_list); + + auto& checker = + runtime_options.checker_invoker->checker(name(), property()); + + checker.accumulate(*first(arguments), tracks, event_list); // FIXME +} -- GitLab From 875bf773e45980700788edb2d6d8abeab0dcc5b9 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Sat, 9 Jul 2022 17:30:00 +0200 Subject: [PATCH 03/18] track matching algorithm + renaming of forward tracks to long tracks --- backend/include/CPUBackend.h | 35 +++ configuration/python/AllenConf/HLT1.py | 82 +++--- .../python/AllenConf/calo_reconstruction.py | 20 +- .../AllenConf/hlt1_calibration_lines.py | 14 +- .../python/AllenConf/hlt1_charm_lines.py | 6 +- .../python/AllenConf/hlt1_electron_lines.py | 20 +- .../AllenConf/hlt1_inclusive_hadron_lines.py | 10 +- .../python/AllenConf/hlt1_muon_lines.py | 22 +- .../python/AllenConf/hlt1_reconstruction.py | 98 ++++++- .../python/AllenConf/hlt1_smog2_lines.py | 4 +- .../AllenConf/matching_reconstruction.py | 144 ++++++++++ .../python/AllenConf/muon_reconstruction.py | 18 +- configuration/python/AllenConf/persistency.py | 2 +- .../python/AllenConf/scifi_reconstruction.py | 10 +- .../secondary_vertex_reconstruction.py | 33 ++- configuration/python/AllenConf/validators.py | 44 ++- .../AllenSequences/hlt1_complex_validation.py | 12 +- .../python/AllenSequences/hlt1_pp_matching.py | 8 + .../hlt1_pp_matching_validation.py | 8 + .../AllenSequences/trackmatching_veloscifi.py | 14 + .../trackmatching_veloscifi_validation.py | 36 +++ configuration/sequences/hlt1_pp_matching.py | 8 + .../sequences/hlt1_pp_matching_validation.py | 8 + .../sequences/trackmatching_veloscifi.py | 14 + .../trackmatching_veloscifi_validation.py | 37 +++ device/CMakeLists.txt | 1 + .../consolidate/include/ConsolidateSciFi.cuh | 2 +- .../include/SciFiCopyTrackHitNumber.cuh | 2 +- .../src/ConsolidateSciFiSeeding.cu | 10 +- .../tools/include/MomentumBremCorrection.cuh | 6 +- .../calo/tools/src/MomentumBremCorrection.cu | 10 +- .../SciFi/include/SciFiEventModel.cuh | 10 + .../include/MakeLongTrackParticles.cuh | 2 +- .../ParKalman/include/ParKalmanVeloOnly.cuh | 2 +- .../muon/muon_filter/include/MuonFilter.cuh | 2 +- .../Hlt1/include/DeviceLineTraverser.cuh | 22 +- device/track_matching/CMakeLists.txt | 19 ++ .../include/ConsolidateMatchedTracks.cuh | 85 ++++++ .../include/MatchingCopyTrackHitNumber.cuh | 42 +++ .../src/ConsolidateMatchedTracks.cu | 96 +++++++ .../src/MatchingCopyTrackHitNumber.cu | 52 ++++ .../match/include/TrackMatchingConstants.cuh | 43 +++ .../match/include/TrackMatchingHelpers.cuh | 32 +++ .../match/include/TrackMatchingVELOSciFi.cuh | 63 ++++ .../match/src/TrackMatchingVELOSciFi.cu | 235 +++++++++++++++ .../vertex_fitter/include/FilterMFTracks.cuh | 2 +- host/validators/include/HostVeloScifiDump.h | 55 ++++ host/validators/src/HostVeloScifiDump.cpp | 272 ++++++++++++++++++ stream/CMakeLists.txt | 1 + stream/sequence/include/Constants.cuh | 9 + stream/sequence/src/Constants.cpp | 10 + 51 files changed, 1624 insertions(+), 168 deletions(-) create mode 100644 configuration/python/AllenConf/matching_reconstruction.py create mode 100644 configuration/python/AllenSequences/hlt1_pp_matching.py create mode 100644 configuration/python/AllenSequences/hlt1_pp_matching_validation.py create mode 100644 configuration/python/AllenSequences/trackmatching_veloscifi.py create mode 100644 configuration/python/AllenSequences/trackmatching_veloscifi_validation.py create mode 100644 configuration/sequences/hlt1_pp_matching.py create mode 100644 configuration/sequences/hlt1_pp_matching_validation.py create mode 100644 configuration/sequences/trackmatching_veloscifi.py create mode 100644 configuration/sequences/trackmatching_veloscifi_validation.py create mode 100644 device/track_matching/CMakeLists.txt create mode 100644 device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh create mode 100644 device/track_matching/consolidate/include/MatchingCopyTrackHitNumber.cuh create mode 100644 device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu create mode 100644 device/track_matching/consolidate/src/MatchingCopyTrackHitNumber.cu create mode 100644 device/track_matching/match/include/TrackMatchingConstants.cuh create mode 100644 device/track_matching/match/include/TrackMatchingHelpers.cuh create mode 100644 device/track_matching/match/include/TrackMatchingVELOSciFi.cuh create mode 100644 device/track_matching/match/src/TrackMatchingVELOSciFi.cu create mode 100644 host/validators/include/HostVeloScifiDump.h create mode 100644 host/validators/src/HostVeloScifiDump.cpp diff --git a/backend/include/CPUBackend.h b/backend/include/CPUBackend.h index 7c57cbb99cb..8c46aaf0f32 100644 --- a/backend/include/CPUBackend.h +++ b/backend/include/CPUBackend.h @@ -122,6 +122,41 @@ inline unsigned int atomicInc(unsigned int* address, unsigned int val) return old; } +template +inline T atomicMin(T* address, T val) +{ + const int old = *address; + *address = std::min(old, val); + return old; +} + +template +inline T atomicMax(T* address, T val) +{ + const T old = *address; + *address = std::max(old, val); + return old; +} + +inline float __int_as_float(int a) +{ + union { + int i; + float f; + } u; + u.i = a; + return u.f; +} +inline int __float_as_int(float a) +{ + union { + int i; + float f; + } u; + u.f = a; + return u.i; +} + uint16_t __float2half(const float f); float __half2float(const uint16_t h); diff --git a/configuration/python/AllenConf/HLT1.py b/configuration/python/AllenConf/HLT1.py index a6439c1739b..7d9acd10aba 100644 --- a/configuration/python/AllenConf/HLT1.py +++ b/configuration/python/AllenConf/HLT1.py @@ -3,7 +3,7 @@ ############################################################################### from AllenConf.utils import line_maker, make_gec, make_checkPV, make_lowmult from AllenConf.odin import make_bxtype, odin_error_filter -from AllenConf.hlt1_reconstruction import hlt1_reconstruction, validator_node +from AllenConf.hlt1_reconstruction import hlt1_reconstruction, hlt1_reconstruction_matching, validator_node, validator_node_matching from AllenConf.hlt1_inclusive_hadron_lines import make_track_mva_line, make_two_track_mva_line, make_kstopipi_line, make_two_track_line_ks from AllenConf.hlt1_charm_lines import make_d2kk_line, make_d2pipi_line, make_two_track_mva_charm_xsec_line from AllenConf.hlt1_calibration_lines import make_d2kpi_line, make_passthrough_line, make_rich_1_line, make_rich_2_line, make_displaced_dimuon_mass_line, make_di_muon_mass_align_line @@ -22,69 +22,69 @@ from PyConf.tonic import configurable from AllenConf.lumi_reconstruction import lumi_reconstruction -def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, +def default_physics_lines(velo_tracks, long_tracks, long_track_particles, secondary_vertices, calo_matching_objects): lines = [] lines.append( line_maker( make_two_track_mva_charm_xsec_line( - forward_tracks, + long_tracks, secondary_vertices, name="Hlt1TwoTrackMVACharmXSec"))) lines.append( line_maker( make_kstopipi_line( - forward_tracks, secondary_vertices, name="Hlt1KsToPiPi"))) + long_tracks, secondary_vertices, name="Hlt1KsToPiPi"))) lines.append( line_maker( make_track_mva_line( - forward_tracks, long_track_particles, name="Hlt1TrackMVA"))) + long_tracks, long_track_particles, name="Hlt1TrackMVA"))) lines.append( line_maker( make_two_track_mva_line( - forward_tracks, secondary_vertices, name="Hlt1TwoTrackMVA"))) + long_tracks, secondary_vertices, name="Hlt1TwoTrackMVA"))) lines.append( line_maker( make_two_track_line_ks( - forward_tracks, secondary_vertices, name="Hlt1TwoTrackKs"))) + long_tracks, secondary_vertices, name="Hlt1TwoTrackKs"))) lines.append( line_maker( make_single_high_pt_muon_line( - forward_tracks, + long_tracks, long_track_particles, name="Hlt1SingleHighPtMuon"))) lines.append( line_maker( make_single_high_pt_muon_no_muid_line( - forward_tracks, + long_tracks, long_track_particles, name="Hlt1SingleHighPtMuonNoMuID"))) lines.append( line_maker( make_low_pt_muon_line( - forward_tracks, long_track_particles, name="Hlt1LowPtMuon"))) + long_tracks, long_track_particles, name="Hlt1LowPtMuon"))) lines.append( line_maker( make_d2kk_line( - forward_tracks, secondary_vertices, name="Hlt1D2KK"))) + long_tracks, secondary_vertices, name="Hlt1D2KK"))) lines.append( line_maker( make_d2kpi_line( - forward_tracks, secondary_vertices, name="Hlt1D2KPi"))) + long_tracks, secondary_vertices, name="Hlt1D2KPi"))) lines.append( line_maker( make_d2pipi_line( - forward_tracks, secondary_vertices, name="Hlt1D2PiPi"))) + long_tracks, secondary_vertices, name="Hlt1D2PiPi"))) lines.append( line_maker( make_di_muon_mass_line( - forward_tracks, secondary_vertices, + long_tracks, secondary_vertices, name="Hlt1DiMuonHighMass"))) lines.append( line_maker( make_di_muon_mass_line( - forward_tracks, + long_tracks, secondary_vertices, name="Hlt1DiMuonLowMass", minHighMassTrackPt=500., @@ -96,15 +96,15 @@ def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_di_muon_soft_line( - forward_tracks, secondary_vertices, name="Hlt1DiMuonSoft"))) + long_tracks, secondary_vertices, name="Hlt1DiMuonSoft"))) lines.append( line_maker( make_low_pt_di_muon_line( - forward_tracks, secondary_vertices, name="Hlt1LowPtDiMuon"))) + long_tracks, secondary_vertices, name="Hlt1LowPtDiMuon"))) lines.append( line_maker( make_track_muon_mva_line( - forward_tracks, long_track_particles, + long_tracks, long_track_particles, name="Hlt1TrackMuonMVA"))) lines.append( @@ -127,21 +127,21 @@ def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_track_electron_mva_line( - forward_tracks, + long_tracks, long_track_particles, calo_matching_objects, name="Hlt1TrackElectronMVA"))) lines.append( line_maker( make_single_high_pt_electron_line( - forward_tracks, + long_tracks, long_track_particles, calo_matching_objects, name="Hlt1SingleHighPtElectron"))) lines.append( line_maker( make_displaced_dielectron_line( - forward_tracks, + long_tracks, secondary_vertices, calo_matching_objects, name="Hlt1DisplacedDielectron"))) @@ -158,7 +158,7 @@ def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_lowmass_noip_dielectron_line( - forward_tracks, + long_tracks, secondary_vertices, calo_matching_objects, minMass=limits[0], @@ -176,7 +176,7 @@ def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_lowmass_noip_dielectron_line( - forward_tracks, + long_tracks, secondary_vertices, calo_matching_objects, is_same_sign=True, @@ -198,7 +198,7 @@ def default_physics_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_displaced_leptons_line( - forward_tracks, + long_tracks, long_track_particles, calo_matching_objects, name="Hlt1DisplacedLeptons"))) @@ -232,7 +232,7 @@ def event_monitoring_lines(with_lumi, lumiline_name): return lines -def alignment_monitoring_lines(velo_tracks, forward_tracks, +def alignment_monitoring_lines(velo_tracks, long_tracks, long_track_particles, velo_states, secondary_vertices): @@ -243,13 +243,13 @@ def alignment_monitoring_lines(velo_tracks, forward_tracks, lines.append( line_maker( make_rich_1_line( - forward_tracks, + long_tracks, long_track_particles, name="Hlt1RICH1Alignment"))) lines.append( line_maker( make_rich_2_line( - forward_tracks, + long_tracks, long_track_particles, name="Hlt1RICH2Alignment"))) lines.append( @@ -280,7 +280,7 @@ def alignment_monitoring_lines(velo_tracks, forward_tracks, return lines -def default_smog2_lines(velo_tracks, forward_tracks, long_track_particles, +def default_smog2_lines(velo_tracks, long_tracks, long_track_particles, secondary_vertices): lines = [] @@ -319,7 +319,7 @@ def default_smog2_lines(velo_tracks, forward_tracks, long_track_particles, lines.append( line_maker( make_SMOG2_singletrack_line( - forward_tracks, + long_tracks, long_track_particles, name="Hlt1_SMOG2_SingleTrack"))) @@ -333,10 +333,14 @@ def setup_hlt1_node(withMCChecking=False, with_ut=True, with_lumi=True, with_odin_filter=True, - with_calo=True): + with_calo=True, + matching=False): # Reconstruct objects needed as input for selection lines - reconstructed_objects = hlt1_reconstruction( - add_electron_id=with_calo, with_ut=with_ut) + if not matching: + reconstructed_objects = hlt1_reconstruction( + add_electron_id=with_calo, with_ut=with_ut) + else: + reconstructed_objects = hlt1_reconstruction_matching() gec = [make_gec()] if EnableGEC else [] odin_err_filter = [odin_error_filter("odin_error_filter") @@ -346,7 +350,7 @@ def setup_hlt1_node(withMCChecking=False, with line_maker.bind(prefilter=prefilters): physics_lines = default_physics_lines( reconstructed_objects["velo_tracks"], - reconstructed_objects["forward_tracks"], + reconstructed_objects["long_tracks"], reconstructed_objects["long_track_particles"], reconstructed_objects["secondary_vertices"], reconstructed_objects["calo_matching_objects"] @@ -366,7 +370,7 @@ def setup_hlt1_node(withMCChecking=False, with line_maker.bind(prefilter=prefilters): monitoring_lines += alignment_monitoring_lines( reconstructed_objects["velo_tracks"], - reconstructed_objects["forward_tracks"], + reconstructed_objects["long_tracks"], reconstructed_objects["long_track_particles"], reconstructed_objects["velo_states"], reconstructed_objects["secondary_vertices"]) @@ -437,7 +441,7 @@ def setup_hlt1_node(withMCChecking=False, SMOG2_lines += default_smog2_lines( reconstructed_objects["velo_tracks"], - reconstructed_objects["forward_tracks"], + reconstructed_objects["long_tracks"], reconstructed_objects["long_track_particles"], reconstructed_objects["secondary_vertices"]) @@ -455,7 +459,7 @@ def setup_hlt1_node(withMCChecking=False, make_routingbits_writer(lines=line_algorithms), *make_sel_report_writer( lines=line_algorithms, - forward_tracks=reconstructed_objects["long_track_particles"], + long_tracks=reconstructed_objects["long_track_particles"], secondary_vertices=reconstructed_objects["secondary_vertices"]) ["algorithms"], ], @@ -491,8 +495,12 @@ def setup_hlt1_node(withMCChecking=False, if not withMCChecking: return hlt1_node else: - validation_node = validator_node(reconstructed_objects, + if not matching: + validation_node = validator_node(reconstructed_objects, line_algorithms, with_ut) + else: + validation_node = validator_node_matching(reconstructed_objects, + line_algorithms) node = CompositeNode( "AllenWithValidators", [hlt1_node, validation_node], diff --git a/configuration/python/AllenConf/calo_reconstruction.py b/configuration/python/AllenConf/calo_reconstruction.py index 6c1a0eea6cf..bbfe00aacc2 100755 --- a/configuration/python/AllenConf/calo_reconstruction.py +++ b/configuration/python/AllenConf/calo_reconstruction.py @@ -46,18 +46,18 @@ def decode_calo(): } -def make_track_matching(decoded_calo, velo_tracks, velo_states, forward_tracks, - kalman_velo_only): +def make_track_matching(decoded_calo, velo_tracks, velo_states, + long_tracks, kalman_velo_only): number_of_events = initialize_number_of_events() track_digit_selective_matching = make_algorithm( track_digit_selective_matching_t, name="track_digit_selective_matching", - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_scifi_states_t=forward_tracks["dev_scifi_states"], - dev_scifi_tracks_view_t=forward_tracks["dev_scifi_tracks_view"], - dev_long_tracks_view_t=forward_tracks[ + dev_scifi_states_t=long_tracks["dev_scifi_states"], + dev_scifi_tracks_view_t=long_tracks["dev_scifi_tracks_view"], + dev_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], dev_ecal_digits_t=decoded_calo["dev_ecal_digits"], dev_ecal_digits_offsets_t=decoded_calo["dev_ecal_digits_offsets"], @@ -81,14 +81,14 @@ def make_track_matching(decoded_calo, velo_tracks, velo_states, forward_tracks, momentum_brem_correction = make_algorithm( momentum_brem_correction_t, name="momentum_brem_correction", - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_kf_tracks_t=kalman_velo_only["dev_kf_tracks"], dev_velo_tracks_offsets_t=velo_tracks["dev_offsets_all_velo_tracks"], - dev_scifi_tracks_view_t=forward_tracks[ + dev_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], - dev_offsets_forward_tracks_t=forward_tracks[ - "dev_offsets_forward_tracks"], + dev_offsets_long_tracks_t=long_tracks[ + "dev_offsets_long_tracks"], dev_brem_E_t=brem_recovery.dev_brem_E_t, dev_brem_ET_t=brem_recovery.dev_brem_ET_t) diff --git a/configuration/python/AllenConf/hlt1_calibration_lines.py b/configuration/python/AllenConf/hlt1_calibration_lines.py index 9f43d149039..2e9f0b3eb2d 100644 --- a/configuration/python/AllenConf/hlt1_calibration_lines.py +++ b/configuration/python/AllenConf/hlt1_calibration_lines.py @@ -13,7 +13,7 @@ from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm -def make_d2kpi_line(forward_tracks, +def make_d2kpi_line(long_tracks, secondary_vertices, name="Hlt1D2KPi", pre_scaler_hash_string=None, @@ -50,7 +50,7 @@ def make_passthrough_line(name="Hlt1Passthrough", def make_rich_line(line_type, - forward_tracks, + long_tracks, long_track_particles, name, pre_scaler, @@ -63,7 +63,7 @@ def make_rich_line(line_type, line_type, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], @@ -73,26 +73,26 @@ def make_rich_line(line_type, post_scaler_hash_string=post_scaler_hash_string or name + '_post') -def make_rich_1_line(forward_tracks, +def make_rich_1_line(long_tracks, long_track_particles, name="Hlt1RICH1Alignment", pre_scaler=1.0, post_scaler=1.0, pre_scaler_hash_string=None, post_scaler_hash_string=None): - return make_rich_line(rich_1_line_t, forward_tracks, long_track_particles, + return make_rich_line(rich_1_line_t, long_tracks, long_track_particles, name, pre_scaler, post_scaler, pre_scaler_hash_string, post_scaler_hash_string) -def make_rich_2_line(forward_tracks, +def make_rich_2_line(long_tracks, long_track_particles, name="Hlt1RICH2Alignment", pre_scaler=1.0, post_scaler=1.0, pre_scaler_hash_string=None, post_scaler_hash_string=None): - return make_rich_line(rich_2_line_t, forward_tracks, long_track_particles, + return make_rich_line(rich_2_line_t, long_tracks, long_track_particles, name, pre_scaler, post_scaler, pre_scaler_hash_string, post_scaler_hash_string) diff --git a/configuration/python/AllenConf/hlt1_charm_lines.py b/configuration/python/AllenConf/hlt1_charm_lines.py index 7642f28c32b..7153aa87fcd 100644 --- a/configuration/python/AllenConf/hlt1_charm_lines.py +++ b/configuration/python/AllenConf/hlt1_charm_lines.py @@ -8,7 +8,7 @@ from AllenConf.utils import initialize_number_of_events, mep_layout from AllenCore.generator import make_algorithm -def make_d2kk_line(forward_tracks, +def make_d2kk_line(long_tracks, secondary_vertices, name="Hlt1D2KK", pre_scaler_hash_string=None, @@ -26,7 +26,7 @@ def make_d2kk_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + '_post') -def make_d2pipi_line(forward_tracks, +def make_d2pipi_line(long_tracks, secondary_vertices, name="Hlt1D2PiPi", pre_scaler_hash_string=None, @@ -44,7 +44,7 @@ def make_d2pipi_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + '_post') -def make_two_ks_line(forward_tracks, +def make_two_ks_line(long_tracks, secondary_vertices, name="Hlt1TwoKs", pre_scaler_hash_string=None, diff --git a/configuration/python/AllenConf/hlt1_electron_lines.py b/configuration/python/AllenConf/hlt1_electron_lines.py index 6d7ef440e58..fbc46df2492 100644 --- a/configuration/python/AllenConf/hlt1_electron_lines.py +++ b/configuration/python/AllenConf/hlt1_electron_lines.py @@ -10,7 +10,7 @@ from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm -def make_track_electron_mva_line(forward_tracks, +def make_track_electron_mva_line(long_tracks, long_track_particles, calo, name="Hlt1TrackElectronMVA", @@ -22,7 +22,7 @@ def make_track_electron_mva_line(forward_tracks, track_electron_mva_line_t, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], @@ -32,7 +32,7 @@ def make_track_electron_mva_line(forward_tracks, dev_brem_corrected_pt_t=calo["dev_brem_corrected_pt"]) -def make_single_high_pt_electron_line(forward_tracks, +def make_single_high_pt_electron_line(long_tracks, long_track_particles, calo, name="Hlt1SingleHighPtElectron", @@ -46,7 +46,7 @@ def make_single_high_pt_electron_line(forward_tracks, host_number_of_events_t=number_of_events["host_number_of_events"], pre_scaler_hash_string=pre_scaler_hash_string or name + '_pre', post_scaler_hash_string=post_scaler_hash_string or name + '_post', - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], @@ -54,7 +54,7 @@ def make_single_high_pt_electron_line(forward_tracks, dev_brem_corrected_pt_t=calo["dev_brem_corrected_pt"]) -def make_displaced_dielectron_line(forward_tracks, +def make_displaced_dielectron_line(long_tracks, secondary_vertices, calo, name="Hlt1DisplacedDielectron", @@ -71,12 +71,12 @@ def make_displaced_dielectron_line(forward_tracks, "dev_multi_event_composites"], pre_scaler_hash_string=pre_scaler_hash_string or name + '_pre', post_scaler_hash_string=post_scaler_hash_string or name + '_post', - dev_track_offsets_t=forward_tracks["dev_offsets_forward_tracks"], + dev_track_offsets_t=long_tracks["dev_offsets_long_tracks"], dev_track_isElectron_t=calo["dev_track_isElectron"], dev_brem_corrected_pt_t=calo["dev_brem_corrected_pt"]) -def make_displaced_leptons_line(forward_tracks, +def make_displaced_leptons_line(long_tracks, long_track_particles, calo, name="Hlt1DisplacedLeptons", @@ -117,7 +117,7 @@ def make_single_high_et_line(velo_tracks, def make_lowmass_noip_dielectron_line( - forward_tracks, + long_tracks, secondary_vertices, calo, minMass, @@ -139,7 +139,7 @@ def make_lowmass_noip_dielectron_line( name="prompt_vertex_evaluator", dev_consolidated_svs_t=secondary_vertices["dev_consolidated_svs"], dev_sv_offsets_t=secondary_vertices["dev_sv_offsets"], - dev_track_offsets_t=forward_tracks["dev_offsets_forward_tracks"], + dev_track_offsets_t=long_tracks["dev_offsets_long_tracks"], dev_brem_corrected_pt_t=calo["dev_brem_corrected_pt"], host_number_of_svs_t=secondary_vertices["host_number_of_svs"], MinIPChi2Threshold=minIPChi2Threshold, @@ -151,7 +151,7 @@ def make_lowmass_noip_dielectron_line( lowmass_noip_dielectron_line_t, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - dev_track_offsets_t=forward_tracks["dev_offsets_forward_tracks"], + dev_track_offsets_t=long_tracks["dev_offsets_long_tracks"], dev_track_isElectron_t=calo["dev_track_isElectron"], dev_brem_corrected_pt_t=calo["dev_brem_corrected_pt"], host_number_of_svs_t=secondary_vertices["host_number_of_svs"], diff --git a/configuration/python/AllenConf/hlt1_inclusive_hadron_lines.py b/configuration/python/AllenConf/hlt1_inclusive_hadron_lines.py index fda234d1001..b4f2fa393fc 100644 --- a/configuration/python/AllenConf/hlt1_inclusive_hadron_lines.py +++ b/configuration/python/AllenConf/hlt1_inclusive_hadron_lines.py @@ -8,7 +8,7 @@ from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm -def make_kstopipi_line(forward_tracks, +def make_kstopipi_line(long_tracks, secondary_vertices, pre_scaler_hash_string=None, post_scaler_hash_string=None, @@ -26,7 +26,7 @@ def make_kstopipi_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + "_post") -def make_track_mva_line(forward_tracks, +def make_track_mva_line(long_tracks, long_track_particles, pre_scaler_hash_string=None, post_scaler_hash_string=None, @@ -37,7 +37,7 @@ def make_track_mva_line(forward_tracks, track_mva_line_t, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], @@ -45,7 +45,7 @@ def make_track_mva_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + "_post") -def make_two_track_mva_line(forward_tracks, +def make_two_track_mva_line(long_tracks, secondary_vertices, pre_scaler_hash_string=None, post_scaler_hash_string=None, @@ -72,7 +72,7 @@ def make_two_track_mva_line(forward_tracks, dev_two_track_mva_evaluation_t) -def make_two_track_line_ks(forward_tracks, +def make_two_track_line_ks(long_tracks, secondary_vertices, pre_scaler_hash_string=None, post_scaler_hash_string=None, diff --git a/configuration/python/AllenConf/hlt1_muon_lines.py b/configuration/python/AllenConf/hlt1_muon_lines.py index c669e6382ec..a84aa1c9169 100644 --- a/configuration/python/AllenConf/hlt1_muon_lines.py +++ b/configuration/python/AllenConf/hlt1_muon_lines.py @@ -9,7 +9,7 @@ from AllenConf.utils import initialize_number_of_events, mep_layout from AllenCore.generator import make_algorithm -def make_single_high_pt_muon_line(forward_tracks, +def make_single_high_pt_muon_line(long_tracks, long_track_particles, name="Hlt1SingleHighPtMuon", pre_scaler_hash_string=None, @@ -22,13 +22,13 @@ def make_single_high_pt_muon_line(forward_tracks, host_number_of_events_t=number_of_events["host_number_of_events"], pre_scaler_hash_string=pre_scaler_hash_string or name + "_pre", post_scaler_hash_string=post_scaler_hash_string or name + "_post", - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"]) -def make_single_high_pt_muon_no_muid_line(forward_tracks, +def make_single_high_pt_muon_no_muid_line(long_tracks, long_track_particles, name="Hlt1SingleHighPtMuonNoMuID", pre_scaler_hash_string=None, @@ -41,13 +41,13 @@ def make_single_high_pt_muon_no_muid_line(forward_tracks, host_number_of_events_t=number_of_events["host_number_of_events"], pre_scaler_hash_string=pre_scaler_hash_string or name + "_pre", post_scaler_hash_string=post_scaler_hash_string or name + "_post", - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"]) -def make_low_pt_muon_line(forward_tracks, +def make_low_pt_muon_line(long_tracks, long_track_particles, name="Hlt1LowPtMuon", pre_scaler_hash_string=None, @@ -60,13 +60,13 @@ def make_low_pt_muon_line(forward_tracks, host_number_of_events_t=number_of_events["host_number_of_events"], pre_scaler_hash_string=pre_scaler_hash_string or name + "_pre", post_scaler_hash_string=post_scaler_hash_string or name + "_post", - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"]) -def make_di_muon_mass_line(forward_tracks, +def make_di_muon_mass_line(long_tracks, secondary_vertices, pre_scaler_hash_string=None, post_scaler_hash_string=None, @@ -96,7 +96,7 @@ def make_di_muon_mass_line(forward_tracks, minIPChi2=minIPChi2) -def make_di_muon_soft_line(forward_tracks, +def make_di_muon_soft_line(long_tracks, secondary_vertices, name="Hlt1DiMuonSoft", pre_scaler_hash_string=None, @@ -114,7 +114,7 @@ def make_di_muon_soft_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + "_post") -def make_low_pt_di_muon_line(forward_tracks, +def make_low_pt_di_muon_line(long_tracks, secondary_vertices, name="Hlt1LowPtDiMuon", pre_scaler_hash_string=None, @@ -132,7 +132,7 @@ def make_low_pt_di_muon_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + "_post") -def make_track_muon_mva_line(forward_tracks, +def make_track_muon_mva_line(long_tracks, long_track_particles, name="Hlt1TrackMuonMVA", pre_scaler_hash_string=None, @@ -143,7 +143,7 @@ def make_track_muon_mva_line(forward_tracks, track_muon_mva_line_t, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], diff --git a/configuration/python/AllenConf/hlt1_reconstruction.py b/configuration/python/AllenConf/hlt1_reconstruction.py index 13f9b6d0ef9..3bc69f59fff 100755 --- a/configuration/python/AllenConf/hlt1_reconstruction.py +++ b/configuration/python/AllenConf/hlt1_reconstruction.py @@ -3,14 +3,15 @@ ############################################################################### from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter from AllenConf.ut_reconstruction import decode_ut, make_ut_tracks -from AllenConf.scifi_reconstruction import decode_scifi, make_forward_tracks +from AllenConf.scifi_reconstruction import decode_scifi, make_long_tracks, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.matching_reconstruction import make_velo_scifi_matches from AllenConf.muon_reconstruction import decode_muon, is_muon from AllenConf.calo_reconstruction import decode_calo, make_track_matching, make_ecal_clusters from AllenConf.primary_vertex_reconstruction import make_pvs from AllenConf.secondary_vertex_reconstruction import make_kalman_velo_only, make_basic_particles, fit_secondary_vertices from AllenConf.validators import ( - velo_validation, veloUT_validation, long_validation, muon_validation, - pv_validation, rate_validation, kalman_validation, selreport_validation) + velo_validation, veloUT_validation, seeding_validation, long_validation, muon_validation, + pv_validation, kalman_validation, selreport_validation) from PyConf.control_flow import NodeLogic, CompositeNode from PyConf.tonic import configurable from AllenConf.persistency import make_gather_selections, make_sel_report_writer @@ -29,16 +30,16 @@ def hlt1_reconstruction(add_electron_id=True, with_ut=True): else: input_tracks = velo_tracks decoded_scifi = decode_scifi() - forward_tracks = make_forward_tracks( + long_tracks = make_forward_tracks( decoded_scifi, input_tracks, with_ut=with_ut) decoded_muon = decode_muon() - muonID = is_muon(decoded_muon, forward_tracks) - kalman_velo_only = make_kalman_velo_only(forward_tracks, pvs, muonID) + muonID = is_muon(decoded_muon, long_tracks) + kalman_velo_only = make_kalman_velo_only(long_tracks, pvs, muonID) decoded_calo = decode_calo() ecal_clusters = make_ecal_clusters(decoded_calo) calo_matching_objects = make_track_matching(decoded_calo, velo_tracks, - velo_states, forward_tracks, + velo_states,long_tracks, kalman_velo_only) if add_electron_id: @@ -47,14 +48,57 @@ def hlt1_reconstruction(add_electron_id=True, with_ut=True): else: long_track_particles = make_basic_particles(kalman_velo_only, muonID) secondary_vertices = fit_secondary_vertices( - forward_tracks, pvs, kalman_velo_only, long_track_particles) + long_tracks, pvs, kalman_velo_only, long_track_particles) return { "velo_tracks": velo_tracks, "velo_states": velo_states, "decoded_calo": decoded_calo, "pvs": pvs, - "ut_tracks": input_tracks, - "forward_tracks": forward_tracks, + "ut_tracks": ut_tracks, + "long_tracks": long_tracks, + "muonID": muonID, + "kalman_velo_only": kalman_velo_only, + "long_track_particles": long_track_particles, + "secondary_vertices": secondary_vertices, + "calo_matching_objects": calo_matching_objects, + "ecal_clusters": ecal_clusters + } + + +def hlt1_reconstruction_matching(add_electron_id=True): + decoded_velo = decode_velo() + velo_tracks = make_velo_tracks(decoded_velo) + velo_states = run_velo_kalman_filter(velo_tracks) + pvs = make_pvs(velo_tracks) + decoded_scifi = decode_scifi() + seed_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) + seed_tracks = make_seeding_tracks(decoded_scifi, seed_xz_tracks) + matched_tracks = make_velo_scifi_matches(velo_tracks, velo_states, + seed_tracks) + decoded_muon = decode_muon() + muonID = is_muon(decoded_muon, matched_tracks) + kalman_velo_only = make_kalman_velo_only(matched_tracks, pvs, muonID) + decoded_calo = decode_calo() + ecal_clusters = make_ecal_clusters(decoded_calo) + + calo_matching_objects = make_track_matching( + decoded_calo, velo_tracks, velo_states, matched_tracks, + kalman_velo_only) + + if add_electron_id: + long_track_particles = make_basic_particles(kalman_velo_only, muonID, + calo_matching_objects) + else: + long_track_particles = make_basic_particles(kalman_velo_only, muonID) + secondary_vertices = fit_secondary_vertices( + matched_tracks, pvs, kalman_velo_only, long_track_particles) + + return { + "velo_tracks": velo_tracks, + "velo_states": velo_states, + "pvs": pvs, + "seeding_tracks": seed_tracks, + "long_tracks": matched_tracks, "muonID": muonID, "kalman_velo_only": kalman_velo_only, "long_track_particles": long_track_particles, @@ -135,3 +179,37 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): ], NodeLogic.NONLAZY_AND, force_order=False) + +def validator_node_matching(reconstructed_objects, + line_algorithms): + return CompositeNode( + "Validators", + [ + make_composite_node_with_gec( + "velo_validation", + velo_validation(reconstructed_objects["velo_tracks"])), + make_composite_node_with_gec( + "pv_validation", pv_validation(reconstructed_objects["pvs"])), + make_composite_node_with_gec( + "seeding_validation", + seeding_validation(reconstructed_objects["seeding_tracks"])), + make_composite_node_with_gec( + "long_validation", + long_validation(reconstructed_objects["long_tracks"])), + make_composite_node_with_gec( + "muon_validation", + muon_validation(reconstructed_objects["muonID"])), + make_composite_node_with_gec( + "kalman_validation", + kalman_validation(reconstructed_objects["kalman_velo_only"])), + selreport_validation( + make_sel_report_writer( + lines=line_algorithms, + long_tracks=reconstructed_objects["long_tracks"], + secondary_vertices=reconstructed_objects[ + "secondary_vertices"]), + make_gather_selections(lines=line_algorithms), + ) + ], + NodeLogic.NONLAZY_AND, + force_order=False) \ No newline at end of file diff --git a/configuration/python/AllenConf/hlt1_smog2_lines.py b/configuration/python/AllenConf/hlt1_smog2_lines.py index 16902988b78..9a391982c13 100644 --- a/configuration/python/AllenConf/hlt1_smog2_lines.py +++ b/configuration/python/AllenConf/hlt1_smog2_lines.py @@ -75,7 +75,7 @@ def make_SMOG2_ditrack_line(secondary_vertices, minTrackPt=minTrackPt) -def make_SMOG2_singletrack_line(forward_tracks, +def make_SMOG2_singletrack_line(long_tracks, long_track_particles, pre_scaler_hash_string=None, post_scaler_hash_string=None, @@ -87,7 +87,7 @@ def make_SMOG2_singletrack_line(forward_tracks, SMOG2_singletrack_line_t, name=name, host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_particle_container_t=long_track_particles[ "dev_multi_event_basic_particles"], diff --git a/configuration/python/AllenConf/matching_reconstruction.py b/configuration/python/AllenConf/matching_reconstruction.py new file mode 100644 index 00000000000..c2e7c406d0e --- /dev/null +++ b/configuration/python/AllenConf/matching_reconstruction.py @@ -0,0 +1,144 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenAlgorithms.algorithms import host_prefix_sum_t, track_matching_veloSciFi_t, matching_copy_track_hit_number_t, matching_consolidate_tracks_t, ut_select_velo_tracks_t +from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter +from AllenConf.scifi_reconstruction import decode_scifi, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.utils import initialize_number_of_events +from AllenCore.generator import make_algorithm + + +def make_velo_scifi_matches(velo_tracks, velo_kalman_filter, seeding_tracks): + number_of_events = initialize_number_of_events() + + ut_select_velo_tracks = make_algorithm( + ut_select_velo_tracks_t, + name="ut_select_velo_tracks", + host_number_of_events_t=number_of_events["host_number_of_events"], + host_number_of_reconstructed_velo_tracks_t=velo_tracks[ + "host_number_of_reconstructed_velo_tracks"], + dev_velo_tracks_view_t=velo_tracks["dev_velo_tracks_view"], + dev_velo_states_view_t=velo_kalman_filter[ + "dev_velo_kalman_beamline_states_view"], + dev_accepted_velo_tracks_t=velo_tracks["dev_accepted_velo_tracks"]) + + matched_tracks = make_algorithm( + track_matching_veloSciFi_t, + name="track_matching_veloSciFi", + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_number_of_events_t=number_of_events["dev_number_of_events"], + host_number_of_reconstructed_velo_tracks_t=velo_tracks[ + "host_number_of_reconstructed_velo_tracks"], + dev_velo_tracks_view_t=velo_tracks["dev_velo_tracks_view"], + dev_velo_states_view_t=velo_kalman_filter[ + "dev_velo_kalman_endvelo_states_view"], + dev_seeding_confirmTracks_atomics_t=seeding_tracks["seed_atomics"], + dev_scifi_track_seeds_t=seeding_tracks["seed_tracks"], + dev_offsets_all_seeding_tracks_t=seeding_tracks[ + "dev_offsets_scifi_seeds"], + dev_seeding_track_hits_t=seeding_tracks["dev_seeding_track_hits"], + dev_offsets_scifi_seed_hit_number_t=seeding_tracks[ + "dev_offsets_scifi_seed_hit_number"], + dev_seeding_states_t=seeding_tracks["dev_seeding_states"], + dev_ut_number_of_selected_velo_tracks_t=ut_select_velo_tracks. + dev_ut_number_of_selected_velo_tracks_t, + dev_ut_selected_velo_tracks_t=ut_select_velo_tracks. + dev_ut_selected_velo_tracks_t) + + prefix_sum_matched_tracks = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_matched_tracks", + dev_input_buffer_t=matched_tracks.dev_atomics_matched_tracks_t) + + matching_copy_track_hit_number = make_algorithm( + matching_copy_track_hit_number_t, + name="matching_copy_track_hit_number", + host_number_of_events_t=number_of_events["host_number_of_events"], + host_number_of_reconstructed_matched_tracks_t=prefix_sum_matched_tracks + .host_total_sum_holder_t, + dev_matched_tracks_t=matched_tracks.dev_matched_tracks_t, + dev_offsets_matched_tracks_t=prefix_sum_matched_tracks. + dev_output_buffer_t, + dev_event_list_t=number_of_events["dev_number_of_events"]) + + prefix_sum_matched_track_hit_number = make_algorithm( + host_prefix_sum_t, + name="prefix_sum_matched_track_hit_number", + dev_input_buffer_t=matching_copy_track_hit_number. + dev_matched_track_hit_number_t) + + matching_consolidate_tracks = make_algorithm( + matching_consolidate_tracks_t, + name="matching_consolidate_tracks", + host_number_of_events_t=number_of_events["host_number_of_events"], + dev_number_of_events_t=number_of_events["dev_number_of_events"], + dev_offsets_seeding_hit_number_t=seeding_tracks[ + "dev_offsets_scifi_seed_hit_number"], + dev_seeding_states_t=seeding_tracks["dev_seeding_states"], + dev_offsets_seeding_tracks_t=seeding_tracks["dev_offsets_scifi_seeds"], + host_accumulated_number_of_hits_in_matched_tracks_t= + prefix_sum_matched_track_hit_number.host_total_sum_holder_t, + host_number_of_reconstructed_matched_tracks_t=prefix_sum_matched_tracks + .host_total_sum_holder_t, + dev_offsets_matched_tracks_t=prefix_sum_matched_tracks. + dev_output_buffer_t, + dev_offsets_matched_hit_number_t=prefix_sum_matched_track_hit_number. + dev_output_buffer_t, + dev_matched_tracks_t=matched_tracks.dev_matched_tracks_t, + dev_scifi_tracks_view_t=seeding_tracks["dev_scifi_tracks_view"], + dev_velo_tracks_view_t=velo_tracks["dev_velo_tracks_view"], + dev_velo_states_view_t=velo_kalman_filter[ + "dev_velo_kalman_endvelo_states_view"]) + + return { + "velo_tracks": + velo_tracks, + "velo_kalman_filter": + velo_kalman_filter, + "seeding_tracks": + seeding_tracks, + "matched_tracks": + matched_tracks.dev_matched_tracks_t, + "matched_atomics": + matched_tracks.dev_atomics_matched_tracks_t, + "dev_scifi_track_hits": + matching_consolidate_tracks.dev_matched_track_hits_t, + "dev_scifi_states": + seeding_tracks["dev_seeding_states"], + "dev_scifi_track_ut_indices": + matching_consolidate_tracks.dev_matched_track_velo_indices_t, + "host_number_of_reconstructed_scifi_tracks": + prefix_sum_matched_tracks.host_total_sum_holder_t, + "dev_offsets_long_tracks": + prefix_sum_matched_tracks. + dev_output_buffer_t, #naming convention same as in forward so that hlt1 sequence works + "dev_offsets_scifi_track_hit_number": + prefix_sum_matched_track_hit_number.dev_output_buffer_t, + "dev_scifi_tracks_view": + seeding_tracks["dev_scifi_tracks_view"], + "dev_multi_event_long_tracks_view": + matching_consolidate_tracks.dev_multi_event_long_tracks_view_t, + "dev_multi_event_long_tracks_ptr": + matching_consolidate_tracks.dev_multi_event_long_tracks_ptr_t, + # Needed for long track particle dependencies. + "dev_scifi_track_view": + seeding_tracks["dev_scifi_track_view"], + "dev_scifi_hits_view": + seeding_tracks["dev_scifi_hits_view"], + "dev_ut_number_of_selected_velo_tracks": + ut_select_velo_tracks.dev_ut_number_of_selected_velo_tracks_t, + "dev_ut_selected_velo_tracks": + ut_select_velo_tracks.dev_ut_selected_velo_tracks_t + } + + +def velo_scifi_matching(): + decoded_velo = decode_velo() + velo_tracks = make_velo_tracks(decoded_velo) + velo_kalman_filter = run_velo_kalman_filter(velo_tracks) + decoded_scifi = decode_scifi() + seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) + seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) + matched_tracks = make_velo_scifi_matches(velo_tracks, velo_kalman_filter, + seeding_tracks) + return matched_tracks["matched_tracks"] diff --git a/configuration/python/AllenConf/muon_reconstruction.py b/configuration/python/AllenConf/muon_reconstruction.py index c5fcad69fd9..ad3e03e716a 100644 --- a/configuration/python/AllenConf/muon_reconstruction.py +++ b/configuration/python/AllenConf/muon_reconstruction.py @@ -95,15 +95,15 @@ def decode_muon(): } -def is_muon(decoded_muon, forward_tracks): +def is_muon(decoded_muon, long_tracks): number_of_events = initialize_number_of_events() host_number_of_events = number_of_events["host_number_of_events"] dev_number_of_events = number_of_events["dev_number_of_events"] - host_number_of_reconstructed_scifi_tracks = forward_tracks[ + host_number_of_reconstructed_scifi_tracks = long_tracks[ "host_number_of_reconstructed_scifi_tracks"] - dev_scifi_tracks_view = forward_tracks["dev_scifi_tracks_view"] - dev_scifi_states = forward_tracks["dev_scifi_states"] + dev_scifi_tracks_view = long_tracks["dev_scifi_tracks_view"] + dev_scifi_states = long_tracks["dev_scifi_states"] is_muon = make_algorithm( is_muon_t, @@ -114,14 +114,14 @@ def is_muon(decoded_muon, forward_tracks): host_number_of_reconstructed_scifi_tracks, dev_scifi_tracks_view_t=dev_scifi_tracks_view, dev_scifi_states_t=dev_scifi_states, - dev_long_tracks_view_t=forward_tracks[ + dev_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], dev_station_ocurrences_offset_t=decoded_muon[ "dev_station_ocurrences_offset"], dev_muon_hits_t=decoded_muon["dev_muon_hits"]) return { - "forward_tracks": forward_tracks, + "long_tracks": long_tracks, "dev_is_muon": is_muon.dev_is_muon_t, "dev_lepton_id": is_muon.dev_lepton_id_t } @@ -130,15 +130,15 @@ def is_muon(decoded_muon, forward_tracks): def muon_id(): from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks from AllenConf.ut_reconstruction import decode_ut, make_ut_tracks - from AllenConf.scifi_reconstruction import decode_scifi, make_forward_tracks + from AllenConf.scifi_reconstruction import decode_scifi, make_long_tracks decoded_velo = decode_velo() velo_tracks = make_velo_tracks(decoded_velo) decoded_ut = decode_ut() ut_tracks = make_ut_tracks(decoded_ut, velo_tracks) decoded_scifi = decode_scifi() - forward_tracks = make_forward_tracks(decoded_scifi, ut_tracks) + long_tracks = make_long_tracks(decoded_scifi, ut_tracks) decoded_muon = decode_muon() - muonID = is_muon(decoded_muon, forward_tracks) + muonID = is_muon(decoded_muon, long_tracks) alg = muonID["dev_is_muon"].producer return alg diff --git a/configuration/python/AllenConf/persistency.py b/configuration/python/AllenConf/persistency.py index 511e533d2fe..220331fb1f1 100644 --- a/configuration/python/AllenConf/persistency.py +++ b/configuration/python/AllenConf/persistency.py @@ -140,7 +140,7 @@ def make_global_decision(lines): dev_dec_reports_t=dec_reporter.dev_dec_reports_t) -def make_sel_report_writer(lines, forward_tracks, secondary_vertices): +def make_sel_report_writer(lines, long_tracks, secondary_vertices): gather_selections = make_gather_selections(lines) dec_reporter = make_dec_reporter(lines) number_of_events = initialize_number_of_events() diff --git a/configuration/python/AllenConf/scifi_reconstruction.py b/configuration/python/AllenConf/scifi_reconstruction.py index 0a38b248523..3074f0f1a45 100644 --- a/configuration/python/AllenConf/scifi_reconstruction.py +++ b/configuration/python/AllenConf/scifi_reconstruction.py @@ -276,7 +276,7 @@ def make_forward_tracks(decoded_scifi, input_tracks, with_ut=True): host_total_sum_holder_t, dev_offsets_input_tracks_t=dev_offsets_input_tracks, dev_scifi_tracks_t=lf_quality_filter.dev_scifi_tracks_t, - dev_offsets_forward_tracks_t=prefix_sum_forward_tracks. + dev_offsets_long_tracks_t=prefix_sum_forward_tracks. dev_output_buffer_t) prefix_sum_scifi_track_hit_number = make_algorithm( @@ -323,7 +323,7 @@ def make_forward_tracks(decoded_scifi, input_tracks, with_ut=True): scifi_consolidate_tracks.dev_scifi_track_ut_indices_t, "host_number_of_reconstructed_scifi_tracks": prefix_sum_forward_tracks.host_total_sum_holder_t, - "dev_offsets_forward_tracks": + "dev_offsets_long_tracks": prefix_sum_forward_tracks.dev_output_buffer_t, "dev_offsets_scifi_track_hit_number": prefix_sum_scifi_track_hit_number.dev_output_buffer_t, @@ -432,6 +432,8 @@ def make_seeding_tracks(decoded_scifi, xz_tracks): seed_confirmTracks_consolidate.dev_seeding_track_hits_t, "dev_seeding_states": seed_confirmTracks_consolidate.dev_seeding_states_t, + "dev_seeding_qop": + seed_confirmTracks_consolidate.dev_seeding_qop_t, "host_number_of_reconstructed_seeding_tracks": prefix_sum_seeding_tracks.host_total_sum_holder_t, "dev_offsets_scifi_seeds": @@ -455,8 +457,8 @@ def forward_tracking(): decoded_ut = decode_ut() ut_tracks = make_ut_tracks(decoded_ut, velo_tracks) decoded_scifi = decode_scifi() - forward_tracks = make_forward_tracks(decoded_scifi, ut_tracks) - alg = forward_tracks["dev_scifi_track_hits"].producer + long_tracks = make_long_tracks(decoded_scifi, ut_tracks) + alg = long_tracks["dev_scifi_track_hits"].producer return alg def seeding_xz(): diff --git a/configuration/python/AllenConf/secondary_vertex_reconstruction.py b/configuration/python/AllenConf/secondary_vertex_reconstruction.py index e436375ee93..234ee662ec0 100644 --- a/configuration/python/AllenConf/secondary_vertex_reconstruction.py +++ b/configuration/python/AllenConf/secondary_vertex_reconstruction.py @@ -10,12 +10,12 @@ from AllenConf.velo_reconstruction import run_velo_kalman_filter from AllenCore.generator import make_algorithm -def make_kalman_velo_only(forward_tracks, +def make_kalman_velo_only(long_tracks, pvs, is_muon_result, is_electron_result=None): number_of_events = initialize_number_of_events() - velo_tracks = forward_tracks["velo_tracks"] + velo_tracks = long_tracks["velo_tracks"] velo_states = run_velo_kalman_filter(velo_tracks) velo_pv_ip = make_algorithm( @@ -40,12 +40,12 @@ def make_kalman_velo_only(forward_tracks, name="kalman_velo_only", host_number_of_events_t=number_of_events["host_number_of_events"], dev_number_of_events_t=number_of_events["dev_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_long_tracks_view_t=forward_tracks[ + dev_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], - dev_offsets_forward_tracks_t=forward_tracks[ - "dev_offsets_forward_tracks"], + dev_offsets_long_tracks_t=long_tracks[ + "dev_offsets_long_tracks"], dev_multi_final_vertices_t=pvs["dev_multi_final_vertices"], dev_number_of_multi_final_vertices_t=pvs[ "dev_number_of_multi_final_vertices"], @@ -53,7 +53,7 @@ def make_kalman_velo_only(forward_tracks, ) return { - "forward_tracks": forward_tracks, + "long_tracks": long_tracks, "pvs": pvs, "dev_kf_tracks": kalman_velo_only.dev_kf_tracks_t, "dev_kalman_pv_ipchi2": kalman_velo_only.dev_kalman_pv_ipchi2_t, @@ -67,7 +67,7 @@ def make_basic_particles(kalman_velo_only, is_muon_result, is_electron_result=None): number_of_events = initialize_number_of_events() - forward_tracks = kalman_velo_only["forward_tracks"] + long_tracks = kalman_velo_only["long_tracks"] pvs = kalman_velo_only["pvs"] if is_electron_result is not None: @@ -76,9 +76,9 @@ def make_basic_particles(kalman_velo_only, name="make_lepton_id", host_number_of_events_t=number_of_events["host_number_of_events"], dev_number_of_events_t=number_of_events["dev_number_of_events"], - host_number_of_scifi_tracks_t=forward_tracks[ + host_number_of_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_scifi_tracks_view_t=forward_tracks["dev_scifi_tracks_view"], + dev_scifi_tracks_view_t=long_tracks["dev_scifi_tracks_view"], dev_is_muon_t=is_muon_result["dev_is_muon"], dev_is_electron_t=is_electron_result["dev_track_isElectron"]) lepton_id = make_lepton_id.dev_lepton_id_t @@ -90,12 +90,12 @@ def make_basic_particles(kalman_velo_only, name="make_long_track_particles", host_number_of_events_t=number_of_events["host_number_of_events"], dev_number_of_events_t=number_of_events["dev_number_of_events"], - host_number_of_reconstructed_scifi_tracks_t=forward_tracks[ + host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_multi_event_long_tracks_t=forward_tracks[ + dev_multi_event_long_tracks_t=long_tracks[ "dev_multi_event_long_tracks_ptr"], - dev_offsets_forward_tracks_t=forward_tracks[ - "dev_offsets_forward_tracks"], + dev_offsets_long_tracks_t=long_tracks[ + "dev_offsets_long_tracks"], dev_kalman_states_view_t=kalman_velo_only["dev_kalman_states_view"], dev_kalman_pv_tables_t=kalman_velo_only["dev_kalman_pv_tables"], dev_multi_final_vertices_t=pvs["dev_multi_final_vertices"], @@ -108,16 +108,15 @@ def make_basic_particles(kalman_velo_only, } -def fit_secondary_vertices(forward_tracks, pvs, kalman_velo_only, +def fit_secondary_vertices(long_tracks, pvs, kalman_velo_only, long_track_particles): number_of_events = initialize_number_of_events() - velo_tracks = forward_tracks["velo_tracks"] filter_tracks = make_algorithm( filter_tracks_t, name="filter_tracks", host_number_of_events_t=number_of_events["host_number_of_events"], - host_number_of_tracks_t=forward_tracks[ + host_number_of_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], dev_number_of_events_t=number_of_events["dev_number_of_events"], dev_long_track_particles_t=long_track_particles[ diff --git a/configuration/python/AllenConf/validators.py b/configuration/python/AllenConf/validators.py index 61f9b323473..1b3852cb8d2 100644 --- a/configuration/python/AllenConf/validators.py +++ b/configuration/python/AllenConf/validators.py @@ -5,7 +5,7 @@ from AllenAlgorithms.algorithms import ( mc_data_provider_t, host_velo_validator_t, host_velo_ut_validator_t, long_track_validator_t, muon_validator_t, host_pv_validator_t, host_rate_validator_t, host_routingbits_validator_t, kalman_validator_t, - host_seeding_XZ_validator_t, host_seeding_validator_t, + host_seeding_XZ_validator_t, host_seeding_validator_t, host_veloscifi_dump_t, host_data_provider_t, host_sel_report_validator_t) from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm @@ -95,7 +95,7 @@ def long_validation(long_tracks, name="long_validator"): "dev_velo_kalman_endvelo_states_view"], dev_multi_event_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], - dev_offsets_long_tracks_t=long_tracks["dev_offsets_forward_tracks"]) + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"]) def seeding_xz_validation(name="seed_xz_validator"): mc_events = mc_data_provider() @@ -156,11 +156,43 @@ def seeding_validation(seeding_tracks, name="seed_validator"): dev_seeding_states_t=seeding_tracks["dev_seeding_states"], host_mc_events_t=mc_events.host_mc_events_t) +def velo_scifi_dump(matched_tracks, name="veloscifi_dump"): + mc_events = mc_data_provider() + + velo_tracks = matched_tracks["velo_tracks"] + velo_kalman_filter = matched_tracks["velo_kalman_filter"] + seeding_tracks = matched_tracks["seeding_tracks"] + + number_of_events = initialize_number_of_events() + + return make_algorithm( + host_veloscifi_dump_t, + name=name, + host_number_of_events_t=number_of_events["host_number_of_events"], + host_mc_events_t=mc_events.host_mc_events_t, + dev_offsets_all_velo_tracks_t=velo_tracks[ + "dev_offsets_all_velo_tracks"], + dev_offsets_velo_track_hit_number_t=velo_tracks[ + "dev_offsets_velo_track_hit_number"], + dev_velo_track_hits_t=velo_tracks["dev_velo_track_hits"], + dev_velo_kalman_states_t=velo_kalman_filter[ + "dev_velo_kalman_endvelo_states"], + dev_ut_number_of_selected_velo_tracks_t=matched_tracks[ + "dev_ut_number_of_selected_velo_tracks"], + dev_ut_selected_velo_tracks_t=matched_tracks[ + "dev_ut_selected_velo_tracks"], + dev_offsets_scifi_seeds_t=seeding_tracks["dev_offsets_scifi_seeds"], + dev_scifi_hits_t=seeding_tracks["dev_seeding_track_hits"], + dev_offsets_scifi_seed_hit_number_t=seeding_tracks[ + "dev_offsets_scifi_seed_hit_number"], + dev_scifi_seeds_t=seeding_tracks["seed_tracks"], + dev_seeding_states_t=seeding_tracks["dev_seeding_states"]) + def muon_validation(muonID, name="muon_validator"): mc_events = mc_data_provider() number_of_events = initialize_number_of_events() - long_tracks = muonID["forward_tracks"] + long_tracks = muonID["long_tracks"] velo_kalman_filter = long_tracks["velo_kalman_filter"] return make_algorithm( @@ -174,7 +206,7 @@ def muon_validation(muonID, name="muon_validator"): "dev_velo_kalman_endvelo_states_view"], dev_multi_event_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], - dev_offsets_long_tracks_t=long_tracks["dev_offsets_forward_tracks"], + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"], dev_is_muon_t=muonID["dev_is_muon"]) @@ -227,7 +259,7 @@ def kalman_validation(kalman_velo_only, name="kalman_validator"): number_of_events = initialize_number_of_events() mc_events = mc_data_provider() - long_tracks = kalman_velo_only["forward_tracks"] + long_tracks = kalman_velo_only["long_tracks"] velo_kalman_filter = long_tracks["velo_kalman_filter"] pvs = kalman_velo_only["pvs"] @@ -243,7 +275,7 @@ def kalman_validation(kalman_velo_only, name="kalman_validator"): dev_multi_event_long_tracks_view_t=long_tracks[ "dev_multi_event_long_tracks_view"], dev_kf_tracks_t=kalman_velo_only["dev_kf_tracks"], - dev_offsets_long_tracks_t=long_tracks["dev_offsets_forward_tracks"], + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"], dev_multi_final_vertices_t=pvs["dev_multi_final_vertices"], dev_number_of_multi_final_vertices_t=pvs[ "dev_number_of_multi_final_vertices"]) diff --git a/configuration/python/AllenSequences/hlt1_complex_validation.py b/configuration/python/AllenSequences/hlt1_complex_validation.py index 66f803460db..4ce57e43ce9 100644 --- a/configuration/python/AllenSequences/hlt1_complex_validation.py +++ b/configuration/python/AllenSequences/hlt1_complex_validation.py @@ -25,25 +25,25 @@ with line_maker.bind(prefilter=gec): lines.append( line_maker( make_track_mva_line( - restricted_hlt1_reconstruction["forward_tracks"], + restricted_hlt1_reconstruction["long_tracks"], restricted_hlt1_reconstruction["long_track_particles"], name="Hlt1TrackMVA_Restricted"))) lines.append( line_maker( make_two_track_mva_line( - restricted_hlt1_reconstruction["forward_tracks"], + restricted_hlt1_reconstruction["long_tracks"], restricted_hlt1_reconstruction["secondary_vertices"], name="Hlt1TwoTrackMVA_Restricted"))) lines.append( line_maker( make_track_mva_line( - non_restricted_hlt1_reconstruction["forward_tracks"], + non_restricted_hlt1_reconstruction["long_tracks"], non_restricted_hlt1_reconstruction["long_track_particles"], name="Hlt1TrackMVA_Non_Restricted"))) lines.append( line_maker( make_two_track_mva_line( - non_restricted_hlt1_reconstruction["forward_tracks"], + non_restricted_hlt1_reconstruction["long_tracks"], non_restricted_hlt1_reconstruction["secondary_vertices"], name="Hlt1TwoTrackMVA_Non_Restricted"))) @@ -80,12 +80,12 @@ validators_leaf = CompositeNode( "non-restricted_veloUT_validator")), make_composite_node_with_gec( "restricted_long_validator", - long_validation(restricted_hlt1_reconstruction["forward_tracks"], + long_validation(restricted_hlt1_reconstruction["long_tracks"], "restricted_long_validator")), make_composite_node_with_gec( "non-restricted_long_validator", long_validation( - non_restricted_hlt1_reconstruction["forward_tracks"], + non_restricted_hlt1_reconstruction["long_tracks"], "non-restricted_long_validator")), make_composite_node_with_gec( "restricted_muon_validation", diff --git a/configuration/python/AllenSequences/hlt1_pp_matching.py b/configuration/python/AllenSequences/hlt1_pp_matching.py new file mode 100644 index 00000000000..fdc6e7ed7a3 --- /dev/null +++ b/configuration/python/AllenSequences/hlt1_pp_matching.py @@ -0,0 +1,8 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.HLT1 import setup_hlt1_node +from AllenCore.generator import generate + +hlt1_node = setup_hlt1_node(matching=True) +generate(hlt1_node) diff --git a/configuration/python/AllenSequences/hlt1_pp_matching_validation.py b/configuration/python/AllenSequences/hlt1_pp_matching_validation.py new file mode 100644 index 00000000000..8671769471f --- /dev/null +++ b/configuration/python/AllenSequences/hlt1_pp_matching_validation.py @@ -0,0 +1,8 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.HLT1 import setup_hlt1_node +from AllenCore.generator import generate + +hlt1_node = setup_hlt1_node(withMCChecking=True, matching=True) +generate(hlt1_node) diff --git a/configuration/python/AllenSequences/trackmatching_veloscifi.py b/configuration/python/AllenSequences/trackmatching_veloscifi.py new file mode 100644 index 00000000000..3971b2cbb52 --- /dev/null +++ b/configuration/python/AllenSequences/trackmatching_veloscifi.py @@ -0,0 +1,14 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.matching_reconstruction import velo_scifi_matching +from AllenConf.utils import gec +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +velo_scifi_matching_sequence = CompositeNode( + "Matching", [gec("gec"), velo_scifi_matching()], + NodeLogic.LAZY_AND, + force_order=True) + +generate(velo_scifi_matching_sequence) diff --git a/configuration/python/AllenSequences/trackmatching_veloscifi_validation.py b/configuration/python/AllenSequences/trackmatching_veloscifi_validation.py new file mode 100644 index 00000000000..5cacc506021 --- /dev/null +++ b/configuration/python/AllenSequences/trackmatching_veloscifi_validation.py @@ -0,0 +1,36 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import decode_scifi, seeding_xz, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.matching_reconstruction import make_velo_scifi_matches +from AllenConf.hlt1_reconstruction import make_composite_node_with_gec +from AllenConf.validators import velo_validation, seeding_validation, seeding_xz_validation, long_validation, velo_scifi_dump +from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +decoded_velo = decode_velo() +velo_tracks = make_velo_tracks(decoded_velo) +velo_states = run_velo_kalman_filter(velo_tracks) +velo = velo_validation(velo_tracks) +decoded_scifi = decode_scifi() +seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) +seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) +seed = seeding_validation(seeding_tracks) +seed_xz = seeding_xz_validation() +matched_tracks = make_velo_scifi_matches(velo_tracks, velo_states, + seeding_tracks) +velo_scifi = long_validation(matched_tracks) +velo_scifi_matching_sequence = CompositeNode( + "Validators", [ + make_composite_node_with_gec("veloValidation", velo), + make_composite_node_with_gec("veloSciFiDump", + velo_scifi_dump(matched_tracks)), + make_composite_node_with_gec("seedingXZValidation", seed_xz), + make_composite_node_with_gec("seedingValidation", seed), + make_composite_node_with_gec("veloSciFiValidation", velo_scifi) + ], + NodeLogic.NONLAZY_AND, + force_order=True) + +generate(velo_scifi_matching_sequence) diff --git a/configuration/sequences/hlt1_pp_matching.py b/configuration/sequences/hlt1_pp_matching.py new file mode 100644 index 00000000000..fdc6e7ed7a3 --- /dev/null +++ b/configuration/sequences/hlt1_pp_matching.py @@ -0,0 +1,8 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.HLT1 import setup_hlt1_node +from AllenCore.generator import generate + +hlt1_node = setup_hlt1_node(matching=True) +generate(hlt1_node) diff --git a/configuration/sequences/hlt1_pp_matching_validation.py b/configuration/sequences/hlt1_pp_matching_validation.py new file mode 100644 index 00000000000..8671769471f --- /dev/null +++ b/configuration/sequences/hlt1_pp_matching_validation.py @@ -0,0 +1,8 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.HLT1 import setup_hlt1_node +from AllenCore.generator import generate + +hlt1_node = setup_hlt1_node(withMCChecking=True, matching=True) +generate(hlt1_node) diff --git a/configuration/sequences/trackmatching_veloscifi.py b/configuration/sequences/trackmatching_veloscifi.py new file mode 100644 index 00000000000..fe81357becc --- /dev/null +++ b/configuration/sequences/trackmatching_veloscifi.py @@ -0,0 +1,14 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.matching_reconstruction import velo_scifi_matching +from AllenConf.utils import gec +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +velo_scifi_matching_sequence = CompositeNode( + "Seeding", [gec("gec"), velo_scifi_matching()], + NodeLogic.LAZY_AND, + force_order=True) + +generate(velo_scifi_matching_sequence) diff --git a/configuration/sequences/trackmatching_veloscifi_validation.py b/configuration/sequences/trackmatching_veloscifi_validation.py new file mode 100644 index 00000000000..9cdc9d03bfa --- /dev/null +++ b/configuration/sequences/trackmatching_veloscifi_validation.py @@ -0,0 +1,37 @@ +############################################################################### +# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # +############################################################################### +from AllenConf.scifi_reconstruction import decode_scifi, seeding_xz, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.matching_reconstruction import make_velo_scifi_matches +from AllenConf.hlt1_reconstruction import make_composite_node_with_gec +from AllenConf.validators import velo_validation, seeding_validation, seeding_xz_validation, long_validation, velo_scifi_dump, long_parameters_for_validation +from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter +from PyConf.control_flow import NodeLogic, CompositeNode +from AllenCore.generator import generate + +decoded_velo = decode_velo() +velo_tracks = make_velo_tracks(decoded_velo) +velo_states = run_velo_kalman_filter(velo_tracks) +velo = velo_validation(velo_tracks) +decoded_scifi = decode_scifi() +seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) +seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) +seed = seeding_validation(seeding_tracks) +seed_xz = seeding_xz_validation() +matched_tracks = make_velo_scifi_matches(velo_tracks, velo_states, + seeding_tracks) +copied_parameters = long_parameters_for_validation(matched_tracks) +velo_scifi = long_validation(matched_tracks, copied_parameters) +velo_scifi_matching_sequence = CompositeNode( + "Validators", [ + make_composite_node_with_gec("veloValidation", velo), + make_composite_node_with_gec("veloSciFiDump", + velo_scifi_dump(matched_tracks)), + make_composite_node_with_gec("seedingXZValidation", seed_xz), + make_composite_node_with_gec("seedingValidation", seed), + make_composite_node_with_gec("veloSciFiValidation", velo_scifi) + ], + NodeLogic.NONLAZY_AND, + force_order=True) + +generate(velo_scifi_matching_sequence) diff --git a/device/CMakeLists.txt b/device/CMakeLists.txt index 3f26be40673..b47489364f5 100644 --- a/device/CMakeLists.txt +++ b/device/CMakeLists.txt @@ -9,6 +9,7 @@ add_subdirectory(PV/beamlinePV) add_subdirectory(associate) add_subdirectory(UT) add_subdirectory(SciFi) +add_subdirectory(track_matching) add_subdirectory(calo) add_subdirectory(muon) add_subdirectory(kalman) diff --git a/device/SciFi/consolidate/include/ConsolidateSciFi.cuh b/device/SciFi/consolidate/include/ConsolidateSciFi.cuh index fd8beba6600..28eee9cac06 100644 --- a/device/SciFi/consolidate/include/ConsolidateSciFi.cuh +++ b/device/SciFi/consolidate/include/ConsolidateSciFi.cuh @@ -25,7 +25,7 @@ namespace scifi_consolidate_tracks { DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; DEVICE_INPUT(dev_scifi_hit_offsets_t, unsigned) dev_scifi_hit_count; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_offsets_scifi_track_hit_number_t, unsigned) dev_scifi_track_hit_number; DEVICE_INPUT(dev_scifi_tracks_t, SciFi::TrackHits) dev_scifi_tracks; DEVICE_INPUT(dev_scifi_lf_parametrization_consolidate_t, float) dev_scifi_lf_parametrization_consolidate; diff --git a/device/SciFi/consolidate/include/SciFiCopyTrackHitNumber.cuh b/device/SciFi/consolidate/include/SciFiCopyTrackHitNumber.cuh index ea87b023be2..c0c28153d55 100644 --- a/device/SciFi/consolidate/include/SciFiCopyTrackHitNumber.cuh +++ b/device/SciFi/consolidate/include/SciFiCopyTrackHitNumber.cuh @@ -16,7 +16,7 @@ namespace scifi_copy_track_hit_number { HOST_INPUT(host_number_of_reconstructed_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; DEVICE_INPUT(dev_offsets_input_tracks_t, unsigned) dev_atomics_input; DEVICE_INPUT(dev_scifi_tracks_t, SciFi::TrackHits) dev_scifi_tracks; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_OUTPUT(dev_scifi_track_hit_number_t, unsigned) dev_scifi_track_hit_number; PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; }; diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index ebbe985624c..1336ea2f677 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -134,11 +134,11 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( SciFi::ConstHitCount scifi_hit_count {parameters.dev_scifi_hit_count, event_number}; // Create consolidated SoAs. - SciFi::Consolidated::Tracks scifi_seeds {parameters.dev_atomics_scifi, + SciFi::Consolidated::Seeds scifi_seeds {parameters.dev_atomics_scifi, parameters.dev_seeding_hit_number, - parameters.dev_seeding_qop, + //parameters.dev_seeding_qop, parameters.dev_seeding_states, - nullptr, + //nullptr, event_number, number_of_events}; const unsigned number_of_tracks_event = scifi_seeds.number_of_tracks(event_number); @@ -161,8 +161,8 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( scifi_seeds.states(i) = seeding_state; const auto magSign = dev_magnet_polarity[0]; - scifi_seeds.qop(i) = - qop_seeding_calculation(magSign, seeding_state, true); + //scifi_seeds.qop(i) = + // qop_seeding_calculation(magSign, seeding_state, true); auto consolidated_hits = scifi_seeds.get_hits(parameters.dev_seeding_track_hits, i); diff --git a/device/calo/tools/include/MomentumBremCorrection.cuh b/device/calo/tools/include/MomentumBremCorrection.cuh index d0ab98e9ed1..059a33e3c30 100644 --- a/device/calo/tools/include/MomentumBremCorrection.cuh +++ b/device/calo/tools/include/MomentumBremCorrection.cuh @@ -12,11 +12,11 @@ namespace momentum_brem_correction { HOST_INPUT(host_number_of_reconstructed_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_kf_tracks_t, ParKalmanFilter::FittedTrack) dev_kf_tracks; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_track_offsets; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_track_offsets; // Velo tracks DEVICE_INPUT(dev_velo_tracks_offsets_t, unsigned) dev_velo_tracks_offsets; - // SciFi tracks - DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_scifi_tracks_view; + // Long tracks + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; // Calo DEVICE_INPUT(dev_brem_E_t, float) dev_brem_E; DEVICE_INPUT(dev_brem_ET_t, float) dev_brem_ET; diff --git a/device/calo/tools/src/MomentumBremCorrection.cu b/device/calo/tools/src/MomentumBremCorrection.cu index 20663bf873e..463e5321d61 100644 --- a/device/calo/tools/src/MomentumBremCorrection.cu +++ b/device/calo/tools/src/MomentumBremCorrection.cu @@ -33,20 +33,20 @@ __global__ void momentum_brem_correction::momentum_brem_correction(momentum_brem { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - const auto event_scifi_tracks = parameters.dev_scifi_tracks_view->container(event_number); + const auto event_long_tracks = parameters.dev_long_tracks_view->container(event_number); // Kalman fitted tracks. const ParKalmanFilter::FittedTrack* event_tracks = parameters.dev_kf_tracks + parameters.dev_track_offsets[event_number]; - const unsigned n_scifi_tracks = event_scifi_tracks.size(); + const unsigned n_long_tracks = event_long_tracks.size(); // Loop over tracks. - for (unsigned i_track = threadIdx.x; i_track < n_scifi_tracks; i_track += blockDim.x) { + for (unsigned i_track = threadIdx.x; i_track < n_long_tracks; i_track += blockDim.x) { const auto track = event_tracks[i_track]; - const auto scifi_track = event_scifi_tracks.track(i_track); - const auto velo_track = scifi_track.track_segment(); + const auto long_track = event_long_tracks.track(i_track); + const auto velo_track = long_track.track_segment(); const auto velo_track_index_with_offset = velo_track.track_index() + parameters.dev_velo_tracks_offsets[event_number]; diff --git a/device/event_model/SciFi/include/SciFiEventModel.cuh b/device/event_model/SciFi/include/SciFiEventModel.cuh index e843e1f6ac6..452adcaf559 100644 --- a/device/event_model/SciFi/include/SciFiEventModel.cuh +++ b/device/event_model/SciFi/include/SciFiEventModel.cuh @@ -561,4 +561,14 @@ namespace SciFi { __host__ __device__ float ySlope() const { return by; } }; } // namespace Seeding + + struct MatchedTrack { + uint16_t velo_track_index; + uint16_t scifi_track_index; + int number_of_hits_velo = 0; + int number_of_hits_ut = 0; + int number_of_hits_scifi = 0; + float chi2_matching; + float qop; + }; } // namespace SciFi diff --git a/device/kalman/ParKalman/include/MakeLongTrackParticles.cuh b/device/kalman/ParKalman/include/MakeLongTrackParticles.cuh index 09a2bb297c6..279dbb1c292 100644 --- a/device/kalman/ParKalman/include/MakeLongTrackParticles.cuh +++ b/device/kalman/ParKalman/include/MakeLongTrackParticles.cuh @@ -21,7 +21,7 @@ namespace make_long_track_particles { HOST_INPUT(host_number_of_reconstructed_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_lepton_id_t, uint8_t) dev_lepton_id; DEVICE_INPUT(dev_multi_final_vertices_t, PV::Vertex) dev_multi_final_vertices; DEVICE_INPUT(dev_kalman_states_view_t, Allen::Views::Physics::KalmanStates) dev_kalman_states_view; diff --git a/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh b/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh index 566de3cf527..f4de1a71d18 100644 --- a/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh +++ b/device/kalman/ParKalman/include/ParKalmanVeloOnly.cuh @@ -90,7 +90,7 @@ namespace kalman_velo_only { MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_multi_final_vertices_t, PV::Vertex) dev_multi_final_vertices; DEVICE_INPUT(dev_number_of_multi_final_vertices_t, unsigned) dev_number_of_multi_final_vertices; DEVICE_INPUT(dev_is_muon_t, bool) dev_is_muon; diff --git a/device/muon/muon_filter/include/MuonFilter.cuh b/device/muon/muon_filter/include/MuonFilter.cuh index 34086c67bdf..ff65707d095 100644 --- a/device/muon/muon_filter/include/MuonFilter.cuh +++ b/device/muon/muon_filter/include/MuonFilter.cuh @@ -26,7 +26,7 @@ namespace MuonFilter { DEVICE_INPUT(dev_offsets_ut_track_hit_number_t, unsigned) dev_ut_track_hit_number; DEVICE_INPUT(dev_ut_qop_t, float) dev_ut_qop; DEVICE_INPUT(dev_ut_track_velo_indices_t, unsigned) dev_ut_track_velo_indices; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_offsets_scifi_track_hit_number, unsigned) dev_scifi_track_hit_number; DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; diff --git a/device/selections/Hlt1/include/DeviceLineTraverser.cuh b/device/selections/Hlt1/include/DeviceLineTraverser.cuh index 3b201cfbdcd..c57aaefb21d 100644 --- a/device/selections/Hlt1/include/DeviceLineTraverser.cuh +++ b/device/selections/Hlt1/include/DeviceLineTraverser.cuh @@ -182,7 +182,7 @@ namespace Hlt1 { __device__ constexpr static void traverse( bool* dev_sel_results, const unsigned* dev_sel_results_offsets, - const unsigned* dev_offsets_forward_tracks, + const unsigned* dev_offsets_long_tracks, const unsigned* dev_sv_offsets, const ParKalmanFilter::FittedTrack* event_tracks, const VertexFit::TrackMVAVertex* event_vertices, @@ -192,7 +192,7 @@ namespace Hlt1 { const unsigned number_of_tracks_in_event, const unsigned number_of_vertices_in_event) { - bool* decisions = dev_sel_results + dev_sel_results_offsets[I] + dev_offsets_forward_tracks[event_number]; + bool* decisions = dev_sel_results + dev_sel_results_offsets[I] + dev_offsets_long_tracks[event_number]; for (unsigned i = threadIdx.x; i < number_of_tracks_in_event; i += blockDim.x) { decisions[i] = T::function(event_tracks[i]); @@ -201,7 +201,7 @@ namespace Hlt1 { TraverseImpl, std::index_sequence>::traverse( dev_sel_results, dev_sel_results_offsets, - dev_offsets_forward_tracks, + dev_offsets_long_tracks, dev_sv_offsets, event_tracks, event_vertices, @@ -221,7 +221,7 @@ namespace Hlt1 { __device__ constexpr static void traverse( bool* dev_sel_results, const unsigned* dev_sel_results_offsets, - const unsigned* dev_offsets_forward_tracks, + const unsigned* dev_offsets_long_tracks, const unsigned* dev_sv_offsets, const ParKalmanFilter::FittedTrack* event_tracks, const VertexFit::TrackMVAVertex* event_vertices, @@ -240,7 +240,7 @@ namespace Hlt1 { TraverseImpl, std::index_sequence>::traverse( dev_sel_results, dev_sel_results_offsets, - dev_offsets_forward_tracks, + dev_offsets_long_tracks, dev_sv_offsets, event_tracks, event_vertices, @@ -260,7 +260,7 @@ namespace Hlt1 { __device__ constexpr static void traverse( bool* dev_sel_results, const unsigned* dev_sel_results_offsets, - const unsigned* dev_offsets_forward_tracks, + const unsigned* dev_offsets_long_tracks, const unsigned* dev_sv_offsets, const ParKalmanFilter::FittedTrack* event_tracks, const VertexFit::TrackMVAVertex* event_vertices, @@ -279,7 +279,7 @@ namespace Hlt1 { TraverseImpl, std::index_sequence>::traverse( dev_sel_results, dev_sel_results_offsets, - dev_offsets_forward_tracks, + dev_offsets_long_tracks, dev_sv_offsets, event_tracks, event_vertices, @@ -299,7 +299,7 @@ namespace Hlt1 { __device__ constexpr static void traverse( bool* dev_sel_results, const unsigned* dev_sel_results_offsets, - const unsigned* dev_offsets_forward_tracks, + const unsigned* dev_offsets_long_tracks, const unsigned* dev_sv_offsets, const ParKalmanFilter::FittedTrack* event_tracks, const VertexFit::TrackMVAVertex* event_vertices, @@ -313,7 +313,7 @@ namespace Hlt1 { TraverseImpl, std::index_sequence>::traverse( dev_sel_results, dev_sel_results_offsets, - dev_offsets_forward_tracks, + dev_offsets_long_tracks, dev_sv_offsets, event_tracks, event_vertices, @@ -330,7 +330,7 @@ namespace Hlt1 { __device__ constexpr static void traverse( bool* dev_sel_results, const unsigned* dev_sel_results_offsets, - const unsigned* dev_offsets_forward_tracks, + const unsigned* dev_offsets_long_tracks, const unsigned* dev_sv_offsets, const ParKalmanFilter::FittedTrack* event_tracks, const VertexFit::TrackMVAVertex* event_vertices, @@ -343,7 +343,7 @@ namespace Hlt1 { TraverseImpl::value>>::traverse( dev_sel_results, dev_sel_results_offsets, - dev_offsets_forward_tracks, + dev_offsets_long_tracks, dev_sv_offsets, event_tracks, event_vertices, diff --git a/device/track_matching/CMakeLists.txt b/device/track_matching/CMakeLists.txt new file mode 100644 index 00000000000..995a081d498 --- /dev/null +++ b/device/track_matching/CMakeLists.txt @@ -0,0 +1,19 @@ +############################################################################### +# (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration # +############################################################################### +file(GLOB matching_match "match/src/*cu") +file(GLOB matching_consolidate "consolidate/src/*cu") + +allen_add_device_library(track_matching STATIC + ${matching_match} + ${matching_consolidate} +) + +target_link_libraries(track_matching PRIVATE Backend HostEventModel EventModel Utils) + +target_include_directories(track_matching PUBLIC + $ + $) + +target_include_directories(WrapperInterface INTERFACE + $) diff --git a/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh new file mode 100644 index 00000000000..7d5a0d5da5d --- /dev/null +++ b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh @@ -0,0 +1,85 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "States.cuh" +#include "ParticleTypes.cuh" +#include "UTDefinitions.cuh" +#include "SciFiDefinitions.cuh" +#include "UTEventModel.cuh" +#include "SciFiEventModel.cuh" +#include "UTConsolidated.cuh" +#include "SciFiConsolidated.cuh" +#include "TrackMatchingConstants.cuh" +#include "AlgorithmTypes.cuh" + +namespace matching_consolidate_tracks { + struct Parameters { + HOST_INPUT(host_number_of_reconstructed_matched_tracks_t, unsigned) host_number_of_reconstructed_matched_tracks; + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + HOST_INPUT(host_accumulated_number_of_hits_in_matched_tracks_t, unsigned) + host_accumulated_number_of_hits_in_matched_tracks; + MASK_INPUT(dev_event_list_t) dev_event_list; + DEVICE_INPUT(dev_velo_states_view_t, Allen::Views::Physics::KalmanStates) dev_velo_states_view; + DEVICE_INPUT(dev_velo_tracks_view_t, Allen::Views::Velo::Consolidated::Tracks) dev_velo_tracks_view; + DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + DEVICE_INPUT(dev_offsets_seeding_tracks_t, unsigned) dev_atomics_scifi; // fishy + DEVICE_INPUT(dev_offsets_seeding_hit_number_t, unsigned) dev_seeding_hit_number; // fishy + DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; + DEVICE_INPUT(dev_offsets_matched_tracks_t, unsigned) dev_atomics_matched; + DEVICE_INPUT(dev_offsets_matched_hit_number_t, unsigned) dev_matched_track_hit_number; // fishy + DEVICE_INPUT(dev_matched_tracks_t, SciFi::MatchedTrack) dev_matched_tracks; + DEVICE_OUTPUT(dev_matched_track_hits_t, char) dev_matched_track_hits; + DEVICE_OUTPUT(dev_matched_qop_t, float) dev_matched_qop; + DEVICE_OUTPUT(dev_matched_track_velo_indices_t, unsigned) dev_matched_track_velo_indices; + DEVICE_OUTPUT(dev_matched_track_scifi_indices_t, unsigned) dev_matched_track_scifi_indices; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_long_track_view_t, + DEPENDENCIES( + dev_scifi_tracks_view_t, + dev_velo_tracks_view_t, + dev_matched_qop_t, + dev_matched_track_velo_indices_t, + dev_matched_track_scifi_indices_t), + Allen::Views::Physics::LongTrack) + dev_long_track_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_long_tracks_view_t, + DEPENDENCIES(dev_long_track_view_t), + Allen::Views::Physics::LongTracks) + dev_long_tracks_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_multi_event_long_tracks_view_t, + DEPENDENCIES(dev_long_tracks_view_t), + Allen::Views::Physics::MultiEventLongTracks) + dev_multi_event_long_tracks_view; + DEVICE_OUTPUT_WITH_DEPENDENCIES( + dev_multi_event_long_tracks_ptr_t, + DEPENDENCIES(dev_multi_event_long_tracks_view_t), + Allen::Views::Physics::MultiEventLongTracks*) + dev_multi_event_long_tracks_ptr; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + + __global__ void matching_consolidate_tracks(Parameters); + + struct matching_consolidate_tracks_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{256, 1, 1}}}; + }; +} // namespace matching_consolidate_tracks diff --git a/device/track_matching/consolidate/include/MatchingCopyTrackHitNumber.cuh b/device/track_matching/consolidate/include/MatchingCopyTrackHitNumber.cuh new file mode 100644 index 00000000000..43bb043e623 --- /dev/null +++ b/device/track_matching/consolidate/include/MatchingCopyTrackHitNumber.cuh @@ -0,0 +1,42 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "VeloEventModel.cuh" +#include "UTDefinitions.cuh" +#include "SciFiDefinitions.cuh" +#include "SciFiEventModel.cuh" +#include "TrackMatchingConstants.cuh" +#include "AlgorithmTypes.cuh" + +namespace matching_copy_track_hit_number { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + HOST_INPUT(host_number_of_reconstructed_matched_tracks_t, unsigned) host_number_of_reconstructed_matched_tracks; + DEVICE_INPUT(dev_matched_tracks_t, SciFi::MatchedTrack) dev_matched_tracks; + DEVICE_INPUT(dev_offsets_matched_tracks_t, unsigned) dev_atomics_matched; + + DEVICE_OUTPUT(dev_matched_track_hit_number_t, unsigned) dev_matched_track_hit_number; + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void matching_copy_track_hit_number(Parameters); + + struct matching_copy_track_hit_number_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{512, 1, 1}}}; + }; +} // namespace matching_copy_track_hit_number diff --git a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu new file mode 100644 index 00000000000..f963411bfc0 --- /dev/null +++ b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu @@ -0,0 +1,96 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "ConsolidateMatchedTracks.cuh" + +INSTANTIATE_ALGORITHM(matching_consolidate_tracks::matching_consolidate_tracks_t); + +__global__ void create_matched_views(matching_consolidate_tracks::Parameters parameters) +{ + const unsigned number_of_events = parameters.dev_number_of_events[0]; + const unsigned event_number = blockIdx.x; + + const auto event_tracks_offset = parameters.dev_atomics_matched[event_number]; + const auto event_number_of_tracks = parameters.dev_atomics_matched[event_number + 1] - event_tracks_offset; + for (unsigned track_index = threadIdx.x; track_index < event_number_of_tracks; track_index += blockDim.x) { + const auto velo_track_index = parameters.dev_matched_track_velo_indices + event_tracks_offset + track_index; + const auto scifi_track_index = parameters.dev_matched_track_scifi_indices + event_tracks_offset + track_index; + const auto* velo_track = ¶meters.dev_velo_tracks_view[event_number].track(*velo_track_index); + const auto* scifi_track = ¶meters.dev_scifi_tracks_view[event_number].track(*scifi_track_index); + new (parameters.dev_long_track_view + event_tracks_offset + track_index) Allen::Views::Physics::LongTrack { + velo_track, nullptr, scifi_track, parameters.dev_matched_qop + event_tracks_offset + track_index}; + } + if (threadIdx.x == 0) { + new (parameters.dev_long_tracks_view + event_number) + Allen::Views::Physics::LongTracks {parameters.dev_long_track_view, parameters.dev_atomics_matched, event_number}; + } + if (blockIdx.x == 0 && threadIdx.x == 0) { + new (parameters.dev_multi_event_long_tracks_view) + Allen::Views::Physics::MultiEventLongTracks {parameters.dev_long_tracks_view, number_of_events}; + parameters.dev_multi_event_long_tracks_ptr[0] = parameters.dev_multi_event_long_tracks_view.get(); + } +} + +void matching_consolidate_tracks::matching_consolidate_tracks_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + + set_size( + arguments, first(arguments) * sizeof(SciFi::Hit)); + set_size(arguments, first(arguments)); + set_size( + arguments, first(arguments)); + set_size( + arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, first(arguments)); + set_size(arguments, 1); + set_size(arguments, 1); +} + +void matching_consolidate_tracks::matching_consolidate_tracks_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions& runtime_options, + const Constants& constants, + HostBuffers& host_buffers, + const Allen::Context& context) const +{ + global_function(matching_consolidate_tracks)( + dim3(size(arguments)), property(), context)(arguments); + + global_function(create_matched_views)(first(arguments), 256, context)(arguments); + +} + +__global__ void matching_consolidate_tracks::matching_consolidate_tracks( + matching_consolidate_tracks::Parameters parameters) +{ + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + const unsigned number_of_events = parameters.dev_number_of_events[0]; + + const SciFi::MatchedTrack* event_matched_tracks = + parameters.dev_matched_tracks + event_number * TrackMatchingConsts::max_num_tracks; + + SciFi::Consolidated::ConstSeeds scifi_seeds {parameters.dev_atomics_scifi, + parameters.dev_seeding_hit_number, + parameters.dev_seeding_states, + event_number, + number_of_events}; + + float* tracks_qop = parameters.dev_matched_qop + parameters.dev_atomics_matched[event_number]; + unsigned int* tracks_velo_indices = + parameters.dev_matched_track_velo_indices + parameters.dev_atomics_matched[event_number]; + unsigned int* tracks_scifi_indices = + parameters.dev_matched_track_scifi_indices + parameters.dev_atomics_matched[event_number]; + const unsigned number_of_tracks_event = + parameters.dev_atomics_matched[event_number + 1] - parameters.dev_atomics_matched[event_number]; + for (unsigned i = threadIdx.x; i < number_of_tracks_event; i += blockDim.x) { + const SciFi::MatchedTrack& track = event_matched_tracks[i]; + tracks_qop[i] = track.qop; + tracks_velo_indices[i] = track.velo_track_index; + tracks_scifi_indices[i] = track.scifi_track_index; + } +} diff --git a/device/track_matching/consolidate/src/MatchingCopyTrackHitNumber.cu b/device/track_matching/consolidate/src/MatchingCopyTrackHitNumber.cu new file mode 100644 index 00000000000..1d5091d4076 --- /dev/null +++ b/device/track_matching/consolidate/src/MatchingCopyTrackHitNumber.cu @@ -0,0 +1,52 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "MatchingCopyTrackHitNumber.cuh" + +INSTANTIATE_ALGORITHM(matching_copy_track_hit_number::matching_copy_track_hit_number_t); + +void matching_copy_track_hit_number::matching_copy_track_hit_number_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size(arguments, first(arguments)); +} + +void matching_copy_track_hit_number::matching_copy_track_hit_number_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context& context) const +{ + global_function(matching_copy_track_hit_number)( + dim3(first(arguments)), property(), context)(arguments); +} + +/** + * @brief Copies UT track hit numbers on a consecutive container + */ +__global__ void matching_copy_track_hit_number::matching_copy_track_hit_number( + matching_copy_track_hit_number::Parameters parameters) +{ + // const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + const auto event_number = blockIdx.x; + const auto event_tracks = parameters.dev_matched_tracks + event_number * TrackMatchingConsts::max_num_tracks; + const auto accumulated_tracks = parameters.dev_atomics_matched[event_number]; + const auto number_of_tracks = + parameters.dev_atomics_matched[event_number + 1] - parameters.dev_atomics_matched[event_number]; + + // Pointer to ut_track_hit_number of current event. + unsigned* matched_track_hit_number = parameters.dev_matched_track_hit_number + accumulated_tracks; + + // debug_cout << "in copy matched track hit number, event: " << event_number << " number of tracks: " << + // number_of_tracks << std::endl; + // Loop over tracks. + for (unsigned element = threadIdx.x; element < number_of_tracks; element += blockDim.x) { + matched_track_hit_number[element] = event_tracks[element].number_of_hits_velo + + // event_tracks[element].number_of_hits_ut + + event_tracks[element].number_of_hits_scifi; + } +} diff --git a/device/track_matching/match/include/TrackMatchingConstants.cuh b/device/track_matching/match/include/TrackMatchingConstants.cuh new file mode 100644 index 00000000000..345690ee4dd --- /dev/null +++ b/device/track_matching/match/include/TrackMatchingConstants.cuh @@ -0,0 +1,43 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "SystemOfUnits.h" + +#include + +namespace TrackMatchingConsts { + static constexpr unsigned max_num_tracks = 1000; // to do: what is the best / safest value here? + + constexpr float z_match = 5240.0f; // FIXME_GEOMETRY_HARDCODING + constexpr float zMatchY = 10000.f; // in mm + + constexpr float dxTol = 8.f; // in mm // to scan + constexpr float dxTolSlope = 80.f; // in mm // to scan + + constexpr float dyTol = 6.f; // in mm // to scan + constexpr float dyTolSlope = 300.f; // in mm // to scan + constexpr float fastYTol = 250.f; // to scan + // The main cut values + // constexpr float maxChi2 = 15.f; // to scan + constexpr float maxChi2 = 2.5f; // to scan + constexpr float minNN = 0.25f; // not used so far + + // Magnetic parametrization from Velo + SciFi tracks + struct MagnetParametrization { + float zMagnetParamsMatch[5] {5287.6f, -7.98878f, 317.683f, 0.0119379f, -1418.42f}; + float bendYParams[2] {-347.801f, -42663.6f}; + }; + + //// Magnetic parametrization from UT + SciFi tracks - KstMuMu sample + // struct MagnetParametrization { + // float zMagnetParamsMatch[5] {5364.11f, -9.73763f, 281.102f, 0.0157596f, -1537.99f}; + // float bendYParams[2] { -613.43f, -40937.7f}; + //}; + // Magnetic parametrization from UT + SciFi tracks - BsPhiPhi sample + // struct MagnetParametrization { + // float zMagnetParamsMatch[5] {5365.01f, -13.0937f, 284.524f, 0.015503f, -1525.71f }; + // float bendYParams[2] { -510.472, -56929.7}; + //}; +} // namespace TrackMatchingConsts diff --git a/device/track_matching/match/include/TrackMatchingHelpers.cuh b/device/track_matching/match/include/TrackMatchingHelpers.cuh new file mode 100644 index 00000000000..fe3b11af2ae --- /dev/null +++ b/device/track_matching/match/include/TrackMatchingHelpers.cuh @@ -0,0 +1,32 @@ +/*****************************************************************************\ +* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration * +* * +* This software is distributed under the terms of the Apache License * +* version 2 (Apache-2.0), copied verbatim in the file "COPYING". * +* * +* In applying this licence, CERN does not waive the privileges and immunities * +* granted to it by virtue of its status as an Intergovernmental Organization * +* or submit itself to any jurisdiction. * +\*****************************************************************************/ +#pragma once + +#include +#include "States.cuh" + +namespace track_matching { + + struct Match { + int ivelo; + float chi2; + }; + + struct MatchingResult { + float dSlopeX; + float dSlopeY; + float distX; + float distY; + float zForX; + float chi2; + }; + +}; // namespace track_matching \ No newline at end of file diff --git a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh new file mode 100644 index 00000000000..3e8b551a550 --- /dev/null +++ b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh @@ -0,0 +1,63 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "VeloEventModel.cuh" +#include "VeloDefinitions.cuh" +#include "UTEventModel.cuh" +#include "SciFiEventModel.cuh" +#include "SciFiConsolidated.cuh" +#include "TrackMatchingConstants.cuh" +#include "AlgorithmTypes.cuh" + +namespace track_matching_veloSciFi { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + HOST_INPUT(host_number_of_reconstructed_velo_tracks_t, unsigned) host_number_of_reconstructed_velo_tracks; + DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; + MASK_INPUT(dev_event_list_t) dev_event_list; + + DEVICE_INPUT(dev_seeding_confirmTracks_atomics_t, unsigned) dev_atomics_scifi; + + DEVICE_INPUT(dev_offsets_all_seeding_tracks_t, unsigned) dev_atomics_seeding; + DEVICE_INPUT(dev_offsets_scifi_seed_hit_number_t, unsigned) dev_seeding_hit_number; + DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; + DEVICE_INPUT(dev_seeding_track_hits_t, char) dev_seeding_track_hits; + + DEVICE_INPUT(dev_scifi_track_seeds_t, SciFi::Seeding::Track) dev_scifi_track_seeds; + + DEVICE_INPUT(dev_velo_tracks_view_t, Allen::Views::Velo::Consolidated::Tracks) dev_velo_tracks_view; + DEVICE_INPUT(dev_velo_states_view_t, Allen::Views::Velo::Consolidated::States) dev_velo_states_view; + + DEVICE_INPUT(dev_ut_number_of_selected_velo_tracks_t, unsigned) dev_ut_number_of_selected_velo_tracks; + DEVICE_INPUT(dev_ut_selected_velo_tracks_t, unsigned) dev_ut_selected_velo_tracks; + + DEVICE_OUTPUT(dev_atomics_matched_tracks_t, unsigned) dev_atomics_matched_tracks; + DEVICE_OUTPUT(dev_matched_tracks_t, SciFi::MatchedTrack) dev_matched_tracks; + + PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; + }; + __global__ void track_matching_veloSciFi( + Parameters, + const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization); + + struct track_matching_veloSciFi_t : public DeviceAlgorithm, Parameters { + void set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const; + + void operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const; + + private: + Property m_block_dim {this, {{32, 1, 1}}}; + }; + +} // namespace track_matching_veloSciFi diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu new file mode 100644 index 00000000000..f2209746390 --- /dev/null +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -0,0 +1,235 @@ +/*****************************************************************************\ +* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "TrackMatchingVELOSciFi.cuh" +#include "TrackMatchingHelpers.cuh" + +INSTANTIATE_ALGORITHM(track_matching_veloSciFi::track_matching_veloSciFi_t); + +void track_matching_veloSciFi::track_matching_veloSciFi_t::set_arguments_size( + ArgumentReferences arguments, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const +{ + set_size(arguments, first(arguments) * TrackMatchingConsts::max_num_tracks); + set_size(arguments, first(arguments)); +} + +void track_matching_veloSciFi::track_matching_veloSciFi_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants& constants, + HostBuffers&, + const Allen::Context& context) const +{ + initialize( + arguments, 0, context); // This is only needed because of the prefix sum, should be removed + + global_function(track_matching_veloSciFi)(dim3(size(arguments)), dim3(128), context)( + arguments, constants.dev_magnet_parametrization); +} + +// inspired from https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Pr/PrAlgorithms/src/PrMatchNN.cpp +__device__ track_matching::MatchingResult getChi2Match( + const MiniState velo_state, + const MiniState scifi_state, + track_matching_veloSciFi::Parameters parameters, + const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) +{ + + const float xpos_velo = velo_state.x, ypos_velo = velo_state.y, zpos_velo = velo_state.z, tx_velo = velo_state.tx, + ty_velo = velo_state.ty; + const float xpos_scifi = scifi_state.x, ypos_scifi = scifi_state.y, zpos_scifi = scifi_state.z, + tx_scifi = scifi_state.tx, ty_scifi = scifi_state.ty; + + const float dSlopeX = tx_velo - tx_scifi; + if (std::abs(dSlopeX) > 1.5f) + return {9999., 9999., 9999., 9999., 9999., 9999.}; // matching the UT/SciFi slopes in X (bending -> large tolerance) + + const float dSlopeY = ty_velo - ty_scifi; + if (std::abs(dSlopeY) > 0.02f) + return {9999.f, 9999.f, 9999.f, 9999.f, 9999.f, 9999.f}; // matching the UT/SciFi slopes in Y (no bending) + + const float zForX = dev_magnet_parametrization->zMagnetParamsMatch[0] + + dev_magnet_parametrization->zMagnetParamsMatch[1] * std::abs(dSlopeX) + + dev_magnet_parametrization->zMagnetParamsMatch[2] * dSlopeX * dSlopeX + + dev_magnet_parametrization->zMagnetParamsMatch[3] * std::abs(xpos_scifi) + + dev_magnet_parametrization->zMagnetParamsMatch[4] * tx_velo * tx_velo; + const float dxTol2 = TrackMatchingConsts::dxTol * TrackMatchingConsts::dxTol; + const float dxTolSlope2 = TrackMatchingConsts::dxTolSlope * TrackMatchingConsts::dxTolSlope; + const float xV = xpos_velo + (zForX - zpos_velo) * tx_velo; + // -- This is the function that calculates the 'bending' in y-direction + // -- The parametrisation can be derived with the MatchFitParams package + const float yV = (ypos_velo + (TrackMatchingConsts::zMatchY - zpos_velo) * ty_velo) * 1.02f; + //+ ty_velo * ( dev_magnet_parametrization->bendYParams[0] * dSlopeX * dSlopeX + // + dev_magnet_parametrization->bendYParams[1] * dSlopeY * dSlopeY ); + + const float xS = xpos_scifi + (zForX - zpos_scifi) * tx_scifi; + const float yS = ypos_scifi + (TrackMatchingConsts::zMatchY - zpos_scifi) * ty_scifi; + + const float distX = xS - xV; + if (std::abs(distX) > 20.f) return {9999.f, 9999.f, 9999.f, 9999.f, 9999.f, 9999.f}; // to scan + const float distY = yS - yV; + if (std::abs(distY) > 150.f) return {9999.f, 9999.f, 9999.f, 9999.f, 9999.f, 9999.f}; // to scan + + const float tx2_velo = tx_velo * tx_velo; + const float ty2_velo = ty_velo * ty_velo; + const float teta2 = tx2_velo + ty2_velo; + const float tolX = dxTol2 + dSlopeX * dSlopeX * dxTolSlope2; + const float tolY = TrackMatchingConsts::dyTol * TrackMatchingConsts::dyTol + + teta2 * TrackMatchingConsts::dyTolSlope * TrackMatchingConsts::dyTolSlope; + const float fdX = 0.8f; + const float fdY = 0.2f; // Reduced the importance of dY info until y issue is fixed + const float fdty = 1.5f; + + float chi2 = (tolX != 0.f and tolY != 0.f ? fdX * distX * distX / tolX + fdY * distY * distY / tolY : 9999.f); + // float chi2 = ( tolX != 0 and tolY != 0 ? distX * distX / tolX : 9999. ); + + chi2 += fdty * dSlopeY * dSlopeY * 10000.f * 0.0625f; + chi2 += dSlopeX * dSlopeX * 10.f; + + return {dSlopeX, dSlopeY, distX, distY, zForX, chi2}; +} + +// https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Tr/TrackTools/src/FastMomentumEstimate.cpp#L142 +__device__ float computeQoverP(const float txV, const float tyV, const float txT) +{ + const float txT2 = txT * txT; + const float txT4 = txT2 * txT2; + const float txV2 = txV * txV; + const float tyV2 = tyV * tyV; + const float tyV4 = tyV2 * tyV2; + const float coef = + 1.21352f + 0.626691f * txT2 - 0.202483f * txT4 + 0.426262f * txT * txV + 2.47057f * tyV2 - 13.2917f * tyV4; + + const float proj = sqrt((1.f + txV2 + tyV2) / (1.f + txV2)); + const float scaleFactor = 1.f; // FIXME magnet sign + + return (txV - txT) / (coef * 1000.f * proj * scaleFactor); +} + +__global__ void track_matching_veloSciFi::track_matching_veloSciFi( + track_matching_veloSciFi::Parameters parameters, + const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) +{ + const unsigned event_number = parameters.dev_event_list[blockIdx.x]; + const unsigned number_of_events = parameters.dev_number_of_events[0]; + + // Velo views + const auto velo_tracks = parameters.dev_velo_tracks_view[event_number]; + const auto velo_states = parameters.dev_velo_states_view[event_number]; + + const unsigned event_velo_seeds_offset = velo_tracks.offset(); + const unsigned number_of_velo_seeds = velo_states.size(); + + // filtered velo tracks + const auto ut_number_of_selected_tracks = parameters.dev_ut_number_of_selected_velo_tracks[event_number]; + const auto ut_selected_velo_tracks = parameters.dev_ut_selected_velo_tracks + event_velo_seeds_offset; + + // consolidated scifi seeds + SciFi::Consolidated::ConstSeeds scifi_seeds {parameters.dev_atomics_seeding, + parameters.dev_seeding_hit_number, + parameters.dev_seeding_states, + event_number, + number_of_events}; + + const unsigned event_scifi_seeds_offset = scifi_seeds.tracks_offset(event_number); + const auto number_of_scifi_seeds = parameters.dev_atomics_scifi[event_number]; + const auto scifiSeeds = parameters.dev_scifi_track_seeds + event_number * SciFi::Constants::Nmax_seeds; + + unsigned* n_matched_tracks_event = parameters.dev_atomics_matched_tracks + event_number; + + SciFi::MatchedTrack* matched_tracks_event = + parameters.dev_matched_tracks + event_number * TrackMatchingConsts::max_num_tracks; + + __shared__ unsigned int n_matched; + + // Reset values + if (threadIdx.x == 0) { + *n_matched_tracks_event = 0; + n_matched = 0; + }; + __syncthreads(); + + for (unsigned i = threadIdx.x; i < number_of_scifi_seeds; i += blockDim.x) { + const auto scifi_state = scifi_seeds.states(i); + auto& scifiseed = scifiSeeds[i]; + + track_matching::Match BestMatch = {-9999, 1000.f}; + + // Loop over filtered velo tracks + for (unsigned ivelo = 0; ivelo < ut_number_of_selected_tracks; ivelo++) { + + const auto velo_track_index = ut_selected_velo_tracks[ivelo]; + const auto velo_track = velo_tracks.track(velo_track_index); + const auto endvelo_state = velo_states.state(velo_track_index); + auto matchingInfo = getChi2Match(endvelo_state, scifi_state, parameters, dev_magnet_parametrization); + if (matchingInfo.chi2 < BestMatch.chi2) { + BestMatch = {static_cast(velo_track_index), matchingInfo.chi2}; + } + } + + if ((BestMatch.chi2 > TrackMatchingConsts::maxChi2) || (n_matched >= TrackMatchingConsts::max_num_tracks)) continue; + + // Save the result + auto idx = atomicAdd(&n_matched, 1); + auto& matched_track = matched_tracks_event[idx]; + + matched_track.velo_track_index = BestMatch.ivelo; + matched_track.scifi_track_index = i; + + matched_track.number_of_hits_velo = velo_tracks.track(BestMatch.ivelo).number_of_hits(); + matched_track.number_of_hits_scifi = scifiseed.number_of_hits; + matched_track.chi2_matching = BestMatch.chi2; + + const auto endvelo_state = velo_states.state(BestMatch.ivelo); + matched_track.qop = computeQoverP(endvelo_state.tx(), endvelo_state.ty(), scifi_state.tx); + } + __syncthreads(); + + // clone killing + __shared__ bool clone_label[TrackMatchingConsts::max_num_tracks]; + for (unsigned i = threadIdx.x; i < n_matched; i += blockDim.x) { + clone_label[i] = false; + } + __syncthreads(); + + for (unsigned n_track_1 = threadIdx.x; n_track_1 < n_matched; n_track_1 += blockDim.x) { + if (clone_label[n_track_1] == true) continue; + + auto& track_1 = matched_tracks_event[n_track_1]; + + for (unsigned n_track_2 = n_track_1 + 1; n_track_2 < n_matched; n_track_2 += 1) { + auto& track_2 = matched_tracks_event[n_track_2]; + + int shared_seeds = 0; + if (track_1.velo_track_index == track_2.velo_track_index) { + shared_seeds += 1; + }; + + if (shared_seeds >= 1) { + // if ( fabs(track_1.chi2 - track_2.chi2) < 0.1 ) continue; + + if (track_1.chi2_matching <= track_2.chi2_matching) { + clone_label[n_track_2] = true; + } + else { + clone_label[n_track_1] = true; + break; + }; + }; + }; + }; + __syncthreads(); + + for (unsigned i = threadIdx.x; i < n_matched; i += blockDim.x) { + auto track = matched_tracks_event[i]; + __syncthreads(); + if (clone_label[i] != true) { + unsigned idx = atomicAdd(n_matched_tracks_event, 1u); + matched_tracks_event[idx] = track; + } + __syncthreads(); + }; +} diff --git a/device/vertex_fit/vertex_fitter/include/FilterMFTracks.cuh b/device/vertex_fit/vertex_fitter/include/FilterMFTracks.cuh index 114d783f820..d87d2f98e78 100644 --- a/device/vertex_fit/vertex_fitter/include/FilterMFTracks.cuh +++ b/device/vertex_fit/vertex_fitter/include/FilterMFTracks.cuh @@ -18,7 +18,7 @@ namespace FilterMFTracks { HOST_INPUT(host_selected_events_mf_t, unsigned) host_selected_events_mf; DEVICE_INPUT(dev_kf_tracks_t, ParKalmanFilter::FittedTrack) dev_kf_tracks; DEVICE_INPUT(dev_mf_tracks_t, ParKalmanFilter::FittedTrack) dev_mf_tracks; - DEVICE_INPUT(dev_offsets_forward_tracks_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_long_tracks_t, unsigned) dev_atomics_scifi; DEVICE_INPUT(dev_offsets_scifi_track_hit_number, unsigned) dev_scifi_track_hit_number; DEVICE_INPUT(dev_scifi_qop_t, float) dev_scifi_qop; DEVICE_INPUT(dev_scifi_states_t, MiniState) dev_scifi_states; diff --git a/host/validators/include/HostVeloScifiDump.h b/host/validators/include/HostVeloScifiDump.h new file mode 100644 index 00000000000..c825af38201 --- /dev/null +++ b/host/validators/include/HostVeloScifiDump.h @@ -0,0 +1,55 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#pragma once + +#include "BackendCommon.h" +#include "AlgorithmTypes.cuh" +#include "States.cuh" +#include "ParKalmanFittedTrack.cuh" +#include "SciFiEventModel.cuh" +#include "VeloConsolidated.cuh" +#include "UTConsolidated.cuh" +#include "SciFiConsolidated.cuh" + +namespace host_veloscifi_dump { + struct Parameters { + HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; + MASK_INPUT(dev_event_list_t) dev_event_list; + + DEVICE_INPUT(dev_offsets_all_velo_tracks_t, unsigned) dev_offsets_all_velo_tracks; + DEVICE_INPUT(dev_offsets_velo_track_hit_number_t, unsigned) dev_offsets_velo_track_hit_number; + DEVICE_INPUT(dev_velo_track_hits_t, char) dev_velo_track_hits; + DEVICE_INPUT(dev_velo_kalman_states_t, char) dev_velo_kalman_states; + DEVICE_INPUT(dev_ut_number_of_selected_velo_tracks_t, unsigned) dev_ut_number_of_selected_velo_tracks; + DEVICE_INPUT(dev_ut_selected_velo_tracks_t, unsigned) dev_ut_selected_velo_tracks; + + DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; + DEVICE_INPUT(dev_scifi_seeds_t, SciFi::Seeding::Track) dev_scifi_seeds; + DEVICE_INPUT(dev_offsets_scifi_seeds_t, unsigned) dev_atomics_scifi; + DEVICE_INPUT(dev_offsets_scifi_seed_hit_number_t, unsigned) dev_scifi_seed_hit_number; + DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; + + HOST_INPUT(host_mc_events_t, const MCEvents*) host_mc_events; + PROPERTY(dump_output_filename_t, "dump_output_filename", "dump output filename", std::string); + }; + + struct host_veloscifi_dump_t : public ValidationAlgorithm, Parameters { + inline void set_arguments_size( + ArgumentReferences, + const RuntimeOptions&, + const Constants&, + const HostBuffers&) const + {} + + void operator()( + const ArgumentReferences&, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context&) const; + + private: + Property m_dump_output_filename {this, "veloscifimatch.json"}; + }; +} // namespace host_veloscifi_dump diff --git a/host/validators/src/HostVeloScifiDump.cpp b/host/validators/src/HostVeloScifiDump.cpp new file mode 100644 index 00000000000..12ee4158a41 --- /dev/null +++ b/host/validators/src/HostVeloScifiDump.cpp @@ -0,0 +1,272 @@ +/*****************************************************************************\ +* (c) Copyright 2020 CERN for the benefit of the LHCb Collaboration * +\*****************************************************************************/ +#include "HostVeloScifiDump.h" +#include "KalmanChecker.h" + +INSTANTIATE_ALGORITHM(host_veloscifi_dump::host_veloscifi_dump_t) + +namespace { + template + std::tuple match_track_to_MCPs( + const MCAssociator& mc_assoc, + const Checker::Tracks& tracks, + const int i_track, + std::unordered_map>& assoc_table) + { + const auto& track = tracks[i_track]; + + // Note: This code is based heavily on + // https://gitlab.cern.ch/lhcb/Rec/blob/master/Pr/PrMCTools/src/PrTrackAssociator.cpp + // + // check LHCbIDs for MC association + Checker::TruthCounter total_counter; + std::unordered_map truth_counters; + int n_meas = 0; + int n_hits_missing = 0; // FIXME + const auto nhits = track.total_number_of_hits; + for (unsigned ihit=0; ihitsecond].n_velo++; + } + } + else if (lhcb_id::is_ut(id)) { + n_meas++; + total_counter.n_ut++; + const auto it_vec = mc_assoc.find_ids(id); + for (const auto& it : it_vec) { + truth_counters[it->second].n_ut++; + } + } + else if (lhcb_id::is_scifi(id)) { + n_meas++; + total_counter.n_scifi++; + const auto it_vec = mc_assoc.find_ids(id); + for (const auto& it : it_vec) { + truth_counters[it->second].n_scifi++; + } + } + else { + debug_cout << "ID not matched to any subdetector " << std::hex << id << std::dec << std::endl; + } + } + // if (n_hits_missing != 0){std::cout << "This track has missing hits: " << n_hits_missing << std::endl;} + + // If the Track has total # Velo hits > 2 AND total # SciFi hits > 2, combine matching of mother and daughter + // particles + if ((total_counter.n_velo > 2) && (total_counter.n_scifi > 2)) { + for (auto& id_counter_1 : truth_counters) { + if ((id_counter_1.second).n_scifi == 0) continue; + const int mother_key = (mc_assoc.m_mcps[id_counter_1.first]).motherKey; + for (auto& id_counter_2 : truth_counters) { + if (&id_counter_1 == &id_counter_2) continue; + const int key = (mc_assoc.m_mcps[id_counter_2.first]).key; + if (key == mother_key) { + if ((id_counter_2.second).n_velo == 0) continue; + // debug_cout << "\t Particle with key " << key << " and PID " << (mc_assoc.m_mcps[id_counter_1.first]).pid + // << " is daughter of particle with PID " << (mc_assoc.m_mcps[id_counter_2.first]).pid << std::endl; + + //== Daughter hits are added to mother. + (id_counter_2.second).n_velo += (id_counter_1.second).n_velo; + (id_counter_2.second).n_ut += (id_counter_1.second).n_ut; + (id_counter_2.second).n_scifi += (id_counter_1.second).n_scifi; + if ((id_counter_2.second).n_velo > total_counter.n_velo) + (id_counter_2.second).n_velo = total_counter.n_velo; + if ((id_counter_2.second).n_ut > total_counter.n_ut) (id_counter_2.second).n_ut = total_counter.n_ut; + if ((id_counter_2.second).n_scifi > total_counter.n_scifi) + (id_counter_2.second).n_scifi = total_counter.n_scifi; + + //== Mother hits overwrite Daughter hits + (id_counter_1.second).n_velo = (id_counter_2.second).n_velo; + (id_counter_1.second).n_ut = (id_counter_2.second).n_ut; + (id_counter_1.second).n_scifi = (id_counter_2.second).n_scifi; + } + } + } + } + + bool match = false; + auto track_best_matched_MCP = mc_assoc.m_mcps.cend(); + + float max_weight = 1e9f; + for (const auto& id_counter : truth_counters) { + bool velo_ok = true; + bool scifi_ok = true; + + if (total_counter.n_velo > 2) { + const auto weight = id_counter.second.n_velo / ((float) total_counter.n_velo); + velo_ok = weight >= 0.7f; + } + if (total_counter.n_scifi > 2) { + const auto weight = id_counter.second.n_scifi / ((float) total_counter.n_scifi); + scifi_ok = weight >= 0.7f; + } + const bool ut_ok = + (id_counter.second.n_ut + 2 > total_counter.n_ut) || (total_counter.n_velo > 2 && total_counter.n_scifi > 2); + const auto counter_sum = id_counter.second.n_velo + id_counter.second.n_ut + id_counter.second.n_scifi; + // Decision + if (velo_ok && ut_ok && scifi_ok && n_meas > 0) { + // debug_cout << "\t Matched track " << i_track << " to MCP " << (mc_assoc.m_mcps[id_counter.first]).key << + // std::endl; + // save matched hits per subdetector + // -> needed for hit efficiency + int subdetector_counter = 0; + if constexpr (std::is_same_v) + subdetector_counter = id_counter.second.n_velo; + else if constexpr (std::is_same_v) + subdetector_counter = id_counter.second.n_ut; + else if constexpr (std::is_same_v) + subdetector_counter = id_counter.second.n_scifi; + else if constexpr (std::is_same_v) + subdetector_counter = id_counter.second.n_scifi; + const float weight = ((float) counter_sum) / ((float) n_meas); + const MCAssociator::TrackWithWeight track_weight = {i_track, weight, subdetector_counter}; + assoc_table[(mc_assoc.m_mcps[id_counter.first]).key].push_back(track_weight); + match = true; + + if (weight < max_weight) { + max_weight = weight; + track_best_matched_MCP = mc_assoc.m_mcps.begin() + id_counter.first; + } + } + } + + return {match, track_best_matched_MCP}; + } +} // namespace + +void host_veloscifi_dump::host_veloscifi_dump_t::operator()( + const ArgumentReferences& arguments, + const RuntimeOptions&, + const Constants&, + HostBuffers&, + const Allen::Context&) const +{ + const auto number_of_events = first(arguments); + const auto event_list = make_vector(arguments); + + const auto offsets_all_velo_tracks = make_vector(arguments); + const auto offsets_velo_track_hit_number = make_vector(arguments); + const auto velo_track_hits = make_vector(arguments); + const auto velo_states_base = make_vector(arguments); + const auto number_of_selected_velo = make_vector(arguments); + const auto selected_velo_tracks = make_vector(arguments); + + const auto scifi_seed_atomics = make_vector(arguments); + const auto scifi_seed_hit_number = make_vector(arguments); + const auto scifi_seed_hits = make_vector(arguments); + const auto scifi_seeds = make_vector(arguments); + const auto seeding_states_base = make_vector(arguments); + + const auto mc_events = *first(arguments); + + std::ofstream jsonfile; + jsonfile.open(property()); + + // Loop over events. + jsonfile << "[" << std::endl; + for (unsigned i_evlist = 0; i_evlist < event_list.size(); i_evlist++) { + jsonfile << "{" << std::endl; + const auto i_event = event_list[i_evlist]; + + // Velo tracks + Velo::Consolidated::ConstTracks velo_tracks { + offsets_all_velo_tracks.data(), offsets_velo_track_hit_number.data(), i_event, number_of_events}; + const unsigned event_velo_tracks_offset = velo_tracks.tracks_offset(i_event); + Velo::Consolidated::ConstStates velo_states {velo_states_base.data(), velo_tracks.total_number_of_tracks()}; + + // Scifi tracks + SciFi::Consolidated::ConstSeeds scifi_tracks_consolidated { + scifi_seed_atomics.data(), scifi_seed_hit_number.data(), seeding_states_base.data(), i_event, number_of_events}; + const SciFi::Seeding::Track* event_scifi_seeds = scifi_seeds.data() + i_event * SciFi::Constants::Nmax_seeds; + const unsigned number_of_tracks_scifi = scifi_tracks_consolidated.number_of_tracks(i_event); + + // Checker tracks + Checker::Tracks velo_checker; + velo_checker.reserve(number_of_selected_velo[i_event]); + Checker::Tracks scifi_checker; + scifi_checker.reserve(number_of_tracks_scifi); + + // Loop over velo tracks + jsonfile << " \"velo\":[\n"; + for (unsigned i_selected = 0; i_selected < number_of_selected_velo[i_event]; i_selected++) { + unsigned i_track = selected_velo_tracks[event_velo_tracks_offset + i_selected]; + + Checker::Track& t = velo_checker.emplace_back(); + const unsigned velo_track_number_of_hits = velo_tracks.number_of_hits(i_track); + Velo::Consolidated::ConstHits track_hits_velo = velo_tracks.get_hits(velo_track_hits.data(), i_track); + for (unsigned i_hit = 0; i_hit < velo_track_number_of_hits; ++i_hit) { + t.addId(track_hits_velo.id(i_hit)); + } + + const auto endvelo_state = velo_states.get(event_velo_tracks_offset + i_track); + auto tx = endvelo_state.tx; + auto ty = endvelo_state.ty; + auto x = endvelo_state.x; + auto y = endvelo_state.y; + auto z = endvelo_state.z; + + jsonfile << " {\"tx\":" << tx << ", \"ty\":" << ty << ", \"x\":" << x << ", \"y\":" << y << ", \"z\":" << z + << "},\n"; + } // velo tracks + if (number_of_selected_velo[i_event] > 0) jsonfile.seekp(-2, jsonfile.cur); + jsonfile << "\n ],\n"; + + // Loop over seeding tracks + jsonfile << " \"scifi\":[\n"; + for (unsigned i_track = 0; i_track < number_of_tracks_scifi; i_track++) { + const SciFi::Seeding::Track& track = event_scifi_seeds[i_track]; + Checker::Track& t = scifi_checker.emplace_back(); + const auto scifi_lhcb_ids = scifi_tracks_consolidated.get_lhcbids_for_track(scifi_seed_hits.data(), i_track); + for (const auto id : scifi_lhcb_ids) { + t.addId(id); + } + + jsonfile << " {\"ax\":" << track.ax << ", \"bx\":" << track.bx << ", \"cx\":" << track.cx + << ", \"ay\":" << track.ay << ", \"by\":" << track.by << "},\n"; + } // scifi tracks + if (number_of_tracks_scifi > 0) jsonfile.seekp(-2, jsonfile.cur); + jsonfile << "\n ],\n"; + + // Matchs + const auto& mc_event = mc_events[i_event]; + MCAssociator mc_assoc {mc_event.m_mcps}; + std::unordered_map> assoc_table; + + jsonfile << " \"matches\":[\n"; + int num_matches = 0; + for (unsigned i_velo = 0; i_velo < number_of_selected_velo[i_event]; i_velo++) { + auto [match, velo_MCP] = + match_track_to_MCPs(mc_assoc, velo_checker, i_velo, assoc_table); + if (!match) continue; + + for (unsigned i_scifi = 0; i_scifi < number_of_tracks_scifi; i_scifi++) { + auto [match, scifi_MCP] = + match_track_to_MCPs(mc_assoc, scifi_checker, i_scifi, assoc_table); + if (!match) continue; + + if (velo_MCP == scifi_MCP) { + jsonfile << " {\"velo\":" << i_velo << ", \"seed\":" << i_scifi + << ", \"qop\": " << (scifi_MCP->charge / scifi_MCP->p) << "},\n"; + num_matches++; + } + } + } // matches + if (num_matches > 0) jsonfile.seekp(-2, jsonfile.cur); + jsonfile << "\n ]\n"; + jsonfile << "},\n"; + } // events + jsonfile.seekp(-2, jsonfile.cur); + jsonfile << "\n]" << std::endl; + + jsonfile.close(); +} diff --git a/stream/CMakeLists.txt b/stream/CMakeLists.txt index d2e99e19882..4321af2d2a2 100644 --- a/stream/CMakeLists.txt +++ b/stream/CMakeLists.txt @@ -25,6 +25,7 @@ target_link_libraries(Stream HostPrefixSum HostRoutingBits UT + track_matching Kalman VertexFitter SciFi diff --git a/stream/sequence/include/Constants.cuh b/stream/sequence/include/Constants.cuh index e4e30e5fd9a..78f05ab8334 100644 --- a/stream/sequence/include/Constants.cuh +++ b/stream/sequence/include/Constants.cuh @@ -32,6 +32,9 @@ namespace MatchUpstreamMuon { struct MuonChambers; struct SearchWindows; } // namespace MatchUpstreamMuon +namespace TrackMatchingConsts { + struct MagnetParametrization; +} /** * @brief Struct intended as a singleton with constants defined on GPU. @@ -83,6 +86,9 @@ struct Constants { // Looking forward LookingForward::Constants* host_looking_forward_constants; + // Track matching + TrackMatchingConsts::MagnetParametrization* host_magnet_parametrization; + // Calo std::vector host_ecal_geometry; char* dev_ecal_geometry = nullptr; @@ -121,6 +127,9 @@ struct Constants { LookingForward::Constants* dev_looking_forward_constants = nullptr; + // TrackMaching + TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization = nullptr; + // Kalman filter ParKalmanFilter::KalmanParametrizations* dev_kalman_params = nullptr; diff --git a/stream/sequence/src/Constants.cpp b/stream/sequence/src/Constants.cpp index 7ab015cca9f..d752d9e9d2d 100644 --- a/stream/sequence/src/Constants.cpp +++ b/stream/sequence/src/Constants.cpp @@ -7,6 +7,7 @@ #include "ClusteringDefinitions.cuh" #include "KalmanParametrizations.cuh" #include "LookingForwardConstants.cuh" +#include "TrackMatchingConstants.cuh" #include "MuonDefinitions.cuh" #include "MuonGeometry.cuh" #include "MuonTables.cuh" @@ -16,6 +17,7 @@ void Constants::reserve_constants() Allen::malloc((void**) &dev_inv_clus_res, host_inv_clus_res.size() * sizeof(float)); Allen::malloc((void**) &dev_kalman_params, sizeof(ParKalmanFilter::KalmanParametrizations)); Allen::malloc((void**) &dev_looking_forward_constants, sizeof(LookingForward::Constants)); + Allen::malloc((void**) &dev_magnet_parametrization, sizeof(TrackMatchingConsts::MagnetParametrization)); Allen::malloc((void**) &dev_muon_foi, sizeof(Muon::Constants::FieldOfInterest)); Allen::malloc((void**) &dev_muon_momentum_cuts, 3 * sizeof(float)); Allen::malloc((void**) &dev_muonmatch_search_muon_chambers, sizeof(MatchUpstreamMuon::MuonChambers)); @@ -49,6 +51,14 @@ void Constants::initialize_constants( sizeof(LookingForward::Constants), Allen::memcpyHostToDevice); + // Track matching constants + host_magnet_parametrization = new TrackMatchingConsts::MagnetParametrization {}; + Allen::memcpy( + dev_magnet_parametrization, + host_magnet_parametrization, + sizeof(TrackMatchingConsts::MagnetParametrization), + Allen::memcpyHostToDevice); + // Muon constants Muon::Constants::FieldOfInterest host_muon_foi; std::copy_n( -- GitLab From 9f2bda243ace756ffa70d9a6f5879facdc53a116 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Sat, 9 Jul 2022 17:32:03 +0200 Subject: [PATCH 04/18] Added prefer-shared runtime option --- configuration/sequences/hlt1_pp_matching.py | 8 ---- .../sequences/hlt1_pp_matching_validation.py | 8 ---- .../sequences/trackmatching_veloscifi.py | 14 ------- .../trackmatching_veloscifi_validation.py | 37 ------------------- main/include/AllenThreads.h | 3 +- main/src/Allen.cpp | 7 +++- main/src/AllenThreads.cpp | 9 ++++- main/src/ProgramOptions.cpp | 3 +- 8 files changed, 18 insertions(+), 71 deletions(-) delete mode 100644 configuration/sequences/hlt1_pp_matching.py delete mode 100644 configuration/sequences/hlt1_pp_matching_validation.py delete mode 100644 configuration/sequences/trackmatching_veloscifi.py delete mode 100644 configuration/sequences/trackmatching_veloscifi_validation.py diff --git a/configuration/sequences/hlt1_pp_matching.py b/configuration/sequences/hlt1_pp_matching.py deleted file mode 100644 index fdc6e7ed7a3..00000000000 --- a/configuration/sequences/hlt1_pp_matching.py +++ /dev/null @@ -1,8 +0,0 @@ -############################################################################### -# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # -############################################################################### -from AllenConf.HLT1 import setup_hlt1_node -from AllenCore.generator import generate - -hlt1_node = setup_hlt1_node(matching=True) -generate(hlt1_node) diff --git a/configuration/sequences/hlt1_pp_matching_validation.py b/configuration/sequences/hlt1_pp_matching_validation.py deleted file mode 100644 index 8671769471f..00000000000 --- a/configuration/sequences/hlt1_pp_matching_validation.py +++ /dev/null @@ -1,8 +0,0 @@ -############################################################################### -# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # -############################################################################### -from AllenConf.HLT1 import setup_hlt1_node -from AllenCore.generator import generate - -hlt1_node = setup_hlt1_node(withMCChecking=True, matching=True) -generate(hlt1_node) diff --git a/configuration/sequences/trackmatching_veloscifi.py b/configuration/sequences/trackmatching_veloscifi.py deleted file mode 100644 index fe81357becc..00000000000 --- a/configuration/sequences/trackmatching_veloscifi.py +++ /dev/null @@ -1,14 +0,0 @@ -############################################################################### -# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # -############################################################################### -from AllenConf.matching_reconstruction import velo_scifi_matching -from AllenConf.utils import gec -from PyConf.control_flow import NodeLogic, CompositeNode -from AllenCore.generator import generate - -velo_scifi_matching_sequence = CompositeNode( - "Seeding", [gec("gec"), velo_scifi_matching()], - NodeLogic.LAZY_AND, - force_order=True) - -generate(velo_scifi_matching_sequence) diff --git a/configuration/sequences/trackmatching_veloscifi_validation.py b/configuration/sequences/trackmatching_veloscifi_validation.py deleted file mode 100644 index 9cdc9d03bfa..00000000000 --- a/configuration/sequences/trackmatching_veloscifi_validation.py +++ /dev/null @@ -1,37 +0,0 @@ -############################################################################### -# (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration # -############################################################################### -from AllenConf.scifi_reconstruction import decode_scifi, seeding_xz, make_seeding_XZ_tracks, make_seeding_tracks -from AllenConf.matching_reconstruction import make_velo_scifi_matches -from AllenConf.hlt1_reconstruction import make_composite_node_with_gec -from AllenConf.validators import velo_validation, seeding_validation, seeding_xz_validation, long_validation, velo_scifi_dump, long_parameters_for_validation -from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter -from PyConf.control_flow import NodeLogic, CompositeNode -from AllenCore.generator import generate - -decoded_velo = decode_velo() -velo_tracks = make_velo_tracks(decoded_velo) -velo_states = run_velo_kalman_filter(velo_tracks) -velo = velo_validation(velo_tracks) -decoded_scifi = decode_scifi() -seeding_xz_tracks = make_seeding_XZ_tracks(decoded_scifi) -seeding_tracks = make_seeding_tracks(decoded_scifi, seeding_xz_tracks) -seed = seeding_validation(seeding_tracks) -seed_xz = seeding_xz_validation() -matched_tracks = make_velo_scifi_matches(velo_tracks, velo_states, - seeding_tracks) -copied_parameters = long_parameters_for_validation(matched_tracks) -velo_scifi = long_validation(matched_tracks, copied_parameters) -velo_scifi_matching_sequence = CompositeNode( - "Validators", [ - make_composite_node_with_gec("veloValidation", velo), - make_composite_node_with_gec("veloSciFiDump", - velo_scifi_dump(matched_tracks)), - make_composite_node_with_gec("seedingXZValidation", seed_xz), - make_composite_node_with_gec("seedingValidation", seed), - make_composite_node_with_gec("veloSciFiValidation", velo_scifi) - ], - NodeLogic.NONLAZY_AND, - force_order=True) - -generate(velo_scifi_matching_sequence) diff --git a/main/include/AllenThreads.h b/main/include/AllenThreads.h index ab6432bc0c2..464b78be7ec 100644 --- a/main/include/AllenThreads.h +++ b/main/include/AllenThreads.h @@ -37,7 +37,8 @@ void run_stream( ROOTService* root_service, unsigned n_reps, bool mep_layout, - uint inject_mem_fail); + uint inject_mem_fail, + bool prefer_shared); void run_monitoring(const size_t mon_id, IZeroMQSvc* zmqSvc, MonitorManager* monitor_manager, unsigned i_monitor); diff --git a/main/src/Allen.cpp b/main/src/Allen.cpp index 88f404b6fee..d0447e62662 100644 --- a/main/src/Allen.cpp +++ b/main/src/Allen.cpp @@ -111,6 +111,7 @@ int allen( uint mon_save_period = 0; std::string mon_filename; bool disable_run_changes = 0; + bool prefer_shared = false; size_t const n_write = output_handler != nullptr ? output_handler->n_threads() : 1; size_t const n_io = n_input + n_write; @@ -195,6 +196,9 @@ int allen( else if (flag_in(flag, {"register-monitoring-counters"})) { register_monitoring_counters = atoi(arg.c_str()); } + else if (flag_in(flag, {"prefer-shared"})) { + prefer_shared = atoi(arg.c_str()); + } } // Set verbosity level @@ -383,7 +387,8 @@ int allen( root_service.get(), io_conf.number_of_repetitions, input_provider->layout() == IInputProvider::Layout::MEP, - inject_mem_fail}; + inject_mem_fail, + prefer_shared}; }; // Lambda with the execution of the input thread that polls the diff --git a/main/src/AllenThreads.cpp b/main/src/AllenThreads.cpp index 196607986a3..dd21ce01dec 100644 --- a/main/src/AllenThreads.cpp +++ b/main/src/AllenThreads.cpp @@ -246,10 +246,17 @@ void run_stream( ROOTService* root_service, unsigned n_reps, bool mep_layout, - uint inject_mem_fail) + uint inject_mem_fail, + bool prefer_shared) { Allen::set_device(device_id, stream_id); +#if defined(TARGET_DEVICE_CUDA) + if (prefer_shared) { + cudaCheck(cudaDeviceSetCacheConfig(cudaFuncCachePreferShared)); + } +#endif + zmq::socket_t control = make_control(thread_id, zmqSvc); zmq::pollitem_t items[] = { diff --git a/main/src/ProgramOptions.cpp b/main/src/ProgramOptions.cpp index dac0bf2b57a..b5f55fc77f4 100644 --- a/main/src/ProgramOptions.cpp +++ b/main/src/ProgramOptions.cpp @@ -62,7 +62,8 @@ std::vector allen_program_options() {{"monitoring-save-period"}, "Number of seconds between writes of the monitoring histograms (0: off)", "0"}, {{"disable-run-changes"}, "Ignore signals to update non-event data with each run change", "1"}, {{"enable-monitoring-printing"}, "Enables printing monitoring information", "0"}, - {{"register-monitoring-counters"}, "Registers monitoring counters", "1"}}; + {{"register-monitoring-counters"}, "Registers monitoring counters", "1"}, + {{"prefer-shared"}, "Configure the device to use more shared than L1 (0: false)", "0"}}; } void print_call_options(const std::map& options, const std::string& device_name) -- GitLab From fb3f274790a824f906cefd08cc5e736c9093bc1a Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Wed, 13 Jul 2022 15:40:02 +0200 Subject: [PATCH 05/18] use Allen::SciFi::View in matching --- .../python/AllenConf/hlt1_reconstruction.py | 2 +- .../AllenConf/matching_reconstruction.py | 12 +---------- .../python/AllenConf/muon_reconstruction.py | 4 ++-- .../python/AllenConf/scifi_reconstruction.py | 4 ++-- .../src/ConsolidateSciFiSeeding.cu | 6 ++---- .../include/ConsolidateMatchedTracks.cuh | 3 --- .../src/ConsolidateMatchedTracks.cu | 6 ------ .../match/include/TrackMatchingVELOSciFi.cuh | 8 +------- .../match/src/TrackMatchingVELOSciFi.cu | 20 ++++++++----------- 9 files changed, 17 insertions(+), 48 deletions(-) diff --git a/configuration/python/AllenConf/hlt1_reconstruction.py b/configuration/python/AllenConf/hlt1_reconstruction.py index 3bc69f59fff..df6e80636fe 100755 --- a/configuration/python/AllenConf/hlt1_reconstruction.py +++ b/configuration/python/AllenConf/hlt1_reconstruction.py @@ -3,7 +3,7 @@ ############################################################################### from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks, run_velo_kalman_filter from AllenConf.ut_reconstruction import decode_ut, make_ut_tracks -from AllenConf.scifi_reconstruction import decode_scifi, make_long_tracks, make_seeding_XZ_tracks, make_seeding_tracks +from AllenConf.scifi_reconstruction import decode_scifi, make_forward_tracks, make_seeding_XZ_tracks, make_seeding_tracks from AllenConf.matching_reconstruction import make_velo_scifi_matches from AllenConf.muon_reconstruction import decode_muon, is_muon from AllenConf.calo_reconstruction import decode_calo, make_track_matching, make_ecal_clusters diff --git a/configuration/python/AllenConf/matching_reconstruction.py b/configuration/python/AllenConf/matching_reconstruction.py index c2e7c406d0e..aeabc71c73a 100644 --- a/configuration/python/AllenConf/matching_reconstruction.py +++ b/configuration/python/AllenConf/matching_reconstruction.py @@ -32,13 +32,7 @@ def make_velo_scifi_matches(velo_tracks, velo_kalman_filter, seeding_tracks): dev_velo_tracks_view_t=velo_tracks["dev_velo_tracks_view"], dev_velo_states_view_t=velo_kalman_filter[ "dev_velo_kalman_endvelo_states_view"], - dev_seeding_confirmTracks_atomics_t=seeding_tracks["seed_atomics"], - dev_scifi_track_seeds_t=seeding_tracks["seed_tracks"], - dev_offsets_all_seeding_tracks_t=seeding_tracks[ - "dev_offsets_scifi_seeds"], - dev_seeding_track_hits_t=seeding_tracks["dev_seeding_track_hits"], - dev_offsets_scifi_seed_hit_number_t=seeding_tracks[ - "dev_offsets_scifi_seed_hit_number"], + dev_scifi_tracks_view_t=seeding_tracks["dev_scifi_tracks_view"], dev_seeding_states_t=seeding_tracks["dev_seeding_states"], dev_ut_number_of_selected_velo_tracks_t=ut_select_velo_tracks. dev_ut_number_of_selected_velo_tracks_t, @@ -72,10 +66,6 @@ def make_velo_scifi_matches(velo_tracks, velo_kalman_filter, seeding_tracks): name="matching_consolidate_tracks", host_number_of_events_t=number_of_events["host_number_of_events"], dev_number_of_events_t=number_of_events["dev_number_of_events"], - dev_offsets_seeding_hit_number_t=seeding_tracks[ - "dev_offsets_scifi_seed_hit_number"], - dev_seeding_states_t=seeding_tracks["dev_seeding_states"], - dev_offsets_seeding_tracks_t=seeding_tracks["dev_offsets_scifi_seeds"], host_accumulated_number_of_hits_in_matched_tracks_t= prefix_sum_matched_track_hit_number.host_total_sum_holder_t, host_number_of_reconstructed_matched_tracks_t=prefix_sum_matched_tracks diff --git a/configuration/python/AllenConf/muon_reconstruction.py b/configuration/python/AllenConf/muon_reconstruction.py index ad3e03e716a..8e31270879d 100644 --- a/configuration/python/AllenConf/muon_reconstruction.py +++ b/configuration/python/AllenConf/muon_reconstruction.py @@ -130,14 +130,14 @@ def is_muon(decoded_muon, long_tracks): def muon_id(): from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks from AllenConf.ut_reconstruction import decode_ut, make_ut_tracks - from AllenConf.scifi_reconstruction import decode_scifi, make_long_tracks + from AllenConf.scifi_reconstruction import decode_scifi, make_forward_tracks decoded_velo = decode_velo() velo_tracks = make_velo_tracks(decoded_velo) decoded_ut = decode_ut() ut_tracks = make_ut_tracks(decoded_ut, velo_tracks) decoded_scifi = decode_scifi() - long_tracks = make_long_tracks(decoded_scifi, ut_tracks) + long_tracks = make_forward_tracks(decoded_scifi, ut_tracks) decoded_muon = decode_muon() muonID = is_muon(decoded_muon, long_tracks) alg = muonID["dev_is_muon"].producer diff --git a/configuration/python/AllenConf/scifi_reconstruction.py b/configuration/python/AllenConf/scifi_reconstruction.py index 3074f0f1a45..d17e65306c4 100644 --- a/configuration/python/AllenConf/scifi_reconstruction.py +++ b/configuration/python/AllenConf/scifi_reconstruction.py @@ -296,7 +296,7 @@ def make_forward_tracks(decoded_scifi, input_tracks, with_ut=True): host_total_sum_holder_t, dev_scifi_hits_t=decoded_scifi["dev_scifi_hits"], dev_scifi_hit_offsets_t=decoded_scifi["dev_scifi_hit_offsets"], - dev_offsets_forward_tracks_t=prefix_sum_forward_tracks. + dev_offsets_long_tracks_t=prefix_sum_forward_tracks. dev_output_buffer_t, dev_offsets_scifi_track_hit_number_t=prefix_sum_scifi_track_hit_number. dev_output_buffer_t, @@ -457,7 +457,7 @@ def forward_tracking(): decoded_ut = decode_ut() ut_tracks = make_ut_tracks(decoded_ut, velo_tracks) decoded_scifi = decode_scifi() - long_tracks = make_long_tracks(decoded_scifi, ut_tracks) + long_tracks = make_forward_tracks(decoded_scifi, ut_tracks) alg = long_tracks["dev_scifi_track_hits"].producer return alg diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index 1336ea2f677..f0554da86db 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -136,9 +136,7 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( // Create consolidated SoAs. SciFi::Consolidated::Seeds scifi_seeds {parameters.dev_atomics_scifi, parameters.dev_seeding_hit_number, - //parameters.dev_seeding_qop, parameters.dev_seeding_states, - //nullptr, event_number, number_of_events}; const unsigned number_of_tracks_event = scifi_seeds.number_of_tracks(event_number); @@ -161,8 +159,8 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( scifi_seeds.states(i) = seeding_state; const auto magSign = dev_magnet_polarity[0]; - //scifi_seeds.qop(i) = - // qop_seeding_calculation(magSign, seeding_state, true); + tracks_qop[i] = + qop_seeding_calculation(magSign, seeding_state, true); auto consolidated_hits = scifi_seeds.get_hits(parameters.dev_seeding_track_hits, i); diff --git a/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh index 7d5a0d5da5d..d305527b411 100644 --- a/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh +++ b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh @@ -25,9 +25,6 @@ namespace matching_consolidate_tracks { DEVICE_INPUT(dev_velo_tracks_view_t, Allen::Views::Velo::Consolidated::Tracks) dev_velo_tracks_view; DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; - DEVICE_INPUT(dev_offsets_seeding_tracks_t, unsigned) dev_atomics_scifi; // fishy - DEVICE_INPUT(dev_offsets_seeding_hit_number_t, unsigned) dev_seeding_hit_number; // fishy - DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; DEVICE_INPUT(dev_offsets_matched_tracks_t, unsigned) dev_atomics_matched; DEVICE_INPUT(dev_offsets_matched_hit_number_t, unsigned) dev_matched_track_hit_number; // fishy DEVICE_INPUT(dev_matched_tracks_t, SciFi::MatchedTrack) dev_matched_tracks; diff --git a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu index f963411bfc0..defd7dbb5d7 100644 --- a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu +++ b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu @@ -74,12 +74,6 @@ __global__ void matching_consolidate_tracks::matching_consolidate_tracks( const SciFi::MatchedTrack* event_matched_tracks = parameters.dev_matched_tracks + event_number * TrackMatchingConsts::max_num_tracks; - SciFi::Consolidated::ConstSeeds scifi_seeds {parameters.dev_atomics_scifi, - parameters.dev_seeding_hit_number, - parameters.dev_seeding_states, - event_number, - number_of_events}; - float* tracks_qop = parameters.dev_matched_qop + parameters.dev_atomics_matched[event_number]; unsigned int* tracks_velo_indices = parameters.dev_matched_track_velo_indices + parameters.dev_atomics_matched[event_number]; diff --git a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh index 3e8b551a550..2efd2202fa6 100644 --- a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh +++ b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh @@ -18,14 +18,8 @@ namespace track_matching_veloSciFi { DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; MASK_INPUT(dev_event_list_t) dev_event_list; - DEVICE_INPUT(dev_seeding_confirmTracks_atomics_t, unsigned) dev_atomics_scifi; - - DEVICE_INPUT(dev_offsets_all_seeding_tracks_t, unsigned) dev_atomics_seeding; - DEVICE_INPUT(dev_offsets_scifi_seed_hit_number_t, unsigned) dev_seeding_hit_number; DEVICE_INPUT(dev_seeding_states_t, MiniState) dev_seeding_states; - DEVICE_INPUT(dev_seeding_track_hits_t, char) dev_seeding_track_hits; - - DEVICE_INPUT(dev_scifi_track_seeds_t, SciFi::Seeding::Track) dev_scifi_track_seeds; + DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; DEVICE_INPUT(dev_velo_tracks_view_t, Allen::Views::Velo::Consolidated::Tracks) dev_velo_tracks_view; DEVICE_INPUT(dev_velo_states_view_t, Allen::Views::Velo::Consolidated::States) dev_velo_states_view; diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index f2209746390..9059067bbcb 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -127,16 +127,12 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( const auto ut_number_of_selected_tracks = parameters.dev_ut_number_of_selected_velo_tracks[event_number]; const auto ut_selected_velo_tracks = parameters.dev_ut_selected_velo_tracks + event_velo_seeds_offset; - // consolidated scifi seeds - SciFi::Consolidated::ConstSeeds scifi_seeds {parameters.dev_atomics_seeding, - parameters.dev_seeding_hit_number, - parameters.dev_seeding_states, - event_number, - number_of_events}; + // SciFi seed views + const auto scifi_seeds = parameters.dev_scifi_tracks_view[event_number]; - const unsigned event_scifi_seeds_offset = scifi_seeds.tracks_offset(event_number); - const auto number_of_scifi_seeds = parameters.dev_atomics_scifi[event_number]; - const auto scifiSeeds = parameters.dev_scifi_track_seeds + event_number * SciFi::Constants::Nmax_seeds; + const unsigned event_scifi_seeds_offset = scifi_seeds.offset(); + const auto number_of_scifi_seeds = scifi_seeds.size(); + const auto scifi_states = parameters.dev_seeding_states + event_scifi_seeds_offset; unsigned* n_matched_tracks_event = parameters.dev_atomics_matched_tracks + event_number; @@ -153,8 +149,8 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( __syncthreads(); for (unsigned i = threadIdx.x; i < number_of_scifi_seeds; i += blockDim.x) { - const auto scifi_state = scifi_seeds.states(i); - auto& scifiseed = scifiSeeds[i]; + const auto scifi_state = scifi_states[i]; + auto& scifiseed = scifi_seeds.track(i); track_matching::Match BestMatch = {-9999, 1000.f}; @@ -180,7 +176,7 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( matched_track.scifi_track_index = i; matched_track.number_of_hits_velo = velo_tracks.track(BestMatch.ivelo).number_of_hits(); - matched_track.number_of_hits_scifi = scifiseed.number_of_hits; + matched_track.number_of_hits_scifi = scifiseed.number_of_scifi_hits(); matched_track.chi2_matching = BestMatch.chi2; const auto endvelo_state = velo_states.state(BestMatch.ivelo); -- GitLab From 747f040cc94d74e27adb361054bab88cbe19b2cc Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Wed, 13 Jul 2022 16:40:38 +0200 Subject: [PATCH 06/18] added gitlab ci test --- checker/tracking/include/TrackChecker.h | 3 +- configuration/python/AllenConf/HLT1.py | 33 ++++++--------- .../python/AllenConf/calo_reconstruction.py | 7 ++-- .../python/AllenConf/hlt1_reconstruction.py | 24 +++++------ .../python/AllenConf/muon_reconstruction.py | 3 +- .../python/AllenConf/scifi_reconstruction.py | 3 ++ .../secondary_vertex_reconstruction.py | 9 ++-- configuration/python/AllenConf/validators.py | 5 ++- .../AllenSequences/hlt1_complex_validation.py | 5 +-- .../SciFi/consolidate/src/ConsolidateSciFi.cu | 4 +- .../src/ConsolidateSciFiSeeding.cu | 42 +++++++++---------- .../SciFi/include/SciFiConsolidated.cuh | 2 +- .../SciFi/include/SciFiEventModel.cuh | 2 +- .../Hlt1/include/DeviceLineTraverser.cuh | 20 +++++---- .../src/ConsolidateMatchedTracks.cu | 1 - .../match/src/TrackMatchingVELOSciFi.cu | 3 +- host/validators/src/HostVeloScifiDump.cpp | 2 +- scripts/ci/config/common-run.yaml | 30 ++++++++----- 18 files changed, 101 insertions(+), 97 deletions(-) diff --git a/checker/tracking/include/TrackChecker.h b/checker/tracking/include/TrackChecker.h index 1b7c7c0a497..7ac426a5034 100644 --- a/checker/tracking/include/TrackChecker.h +++ b/checker/tracking/include/TrackChecker.h @@ -84,7 +84,8 @@ public: (100.0 * static_cast(m_nghosts)) / (static_cast(m_ntracks))); } - if constexpr (std::is_same_v || std::is_same_v ) { + if constexpr ( + std::is_same_v || std::is_same_v) { std::printf( "%-50s: %9lu/%9lu %6.2f%% ghosts\n", "for P>3GeV,Pt>0.5GeV", diff --git a/configuration/python/AllenConf/HLT1.py b/configuration/python/AllenConf/HLT1.py index 7d9acd10aba..8ebfc71e796 100644 --- a/configuration/python/AllenConf/HLT1.py +++ b/configuration/python/AllenConf/HLT1.py @@ -51,8 +51,7 @@ def default_physics_lines(velo_tracks, long_tracks, long_track_particles, lines.append( line_maker( make_single_high_pt_muon_line( - long_tracks, - long_track_particles, + long_tracks, long_track_particles, name="Hlt1SingleHighPtMuon"))) lines.append( line_maker( @@ -66,12 +65,11 @@ def default_physics_lines(velo_tracks, long_tracks, long_track_particles, long_tracks, long_track_particles, name="Hlt1LowPtMuon"))) lines.append( line_maker( - make_d2kk_line( - long_tracks, secondary_vertices, name="Hlt1D2KK"))) + make_d2kk_line(long_tracks, secondary_vertices, name="Hlt1D2KK"))) lines.append( line_maker( - make_d2kpi_line( - long_tracks, secondary_vertices, name="Hlt1D2KPi"))) + make_d2kpi_line(long_tracks, secondary_vertices, + name="Hlt1D2KPi"))) lines.append( line_maker( make_d2pipi_line( @@ -79,8 +77,7 @@ def default_physics_lines(velo_tracks, long_tracks, long_track_particles, lines.append( line_maker( make_di_muon_mass_line( - long_tracks, secondary_vertices, - name="Hlt1DiMuonHighMass"))) + long_tracks, secondary_vertices, name="Hlt1DiMuonHighMass"))) lines.append( line_maker( make_di_muon_mass_line( @@ -109,11 +106,11 @@ def default_physics_lines(velo_tracks, long_tracks, long_track_particles, lines.append( line_maker( - make_di_muon_no_ip_line(forward_tracks, secondary_vertices))) + make_di_muon_no_ip_line(long_tracks, secondary_vertices))) lines.append( line_maker( make_di_muon_no_ip_line( - forward_tracks, + long_tracks, secondary_vertices, name="Hlt1DiMuonNoIP_ss", pre_scaler_hash_string="di_muon_no_ip_ss_line_pre", @@ -243,15 +240,11 @@ def alignment_monitoring_lines(velo_tracks, long_tracks, lines.append( line_maker( make_rich_1_line( - long_tracks, - long_track_particles, - name="Hlt1RICH1Alignment"))) + long_tracks, long_track_particles, name="Hlt1RICH1Alignment"))) lines.append( line_maker( make_rich_2_line( - long_tracks, - long_track_particles, - name="Hlt1RICH2Alignment"))) + long_tracks, long_track_particles, name="Hlt1RICH2Alignment"))) lines.append( line_maker( make_beam_gas_line( @@ -262,18 +255,18 @@ def alignment_monitoring_lines(velo_tracks, long_tracks, lines.append( line_maker( make_d2kpi_line( - forward_tracks, secondary_vertices, + long_tracks, secondary_vertices, name="Hlt1D2KPiAlignment"))) lines.append( line_maker( make_di_muon_mass_align_line( - forward_tracks, + long_tracks, secondary_vertices, name="Hlt1DiMuonHighMassAlignment"))) lines.append( line_maker( make_displaced_dimuon_mass_line( - forward_tracks, + long_tracks, secondary_vertices, name="Hlt1DisplacedDiMuonAlignment"))) @@ -500,7 +493,7 @@ def setup_hlt1_node(withMCChecking=False, line_algorithms, with_ut) else: validation_node = validator_node_matching(reconstructed_objects, - line_algorithms) + line_algorithms) node = CompositeNode( "AllenWithValidators", [hlt1_node, validation_node], diff --git a/configuration/python/AllenConf/calo_reconstruction.py b/configuration/python/AllenConf/calo_reconstruction.py index bbfe00aacc2..5e16a3254dc 100755 --- a/configuration/python/AllenConf/calo_reconstruction.py +++ b/configuration/python/AllenConf/calo_reconstruction.py @@ -46,8 +46,8 @@ def decode_calo(): } -def make_track_matching(decoded_calo, velo_tracks, velo_states, - long_tracks, kalman_velo_only): +def make_track_matching(decoded_calo, velo_tracks, velo_states, long_tracks, + kalman_velo_only): number_of_events = initialize_number_of_events() track_digit_selective_matching = make_algorithm( @@ -57,8 +57,7 @@ def make_track_matching(decoded_calo, velo_tracks, velo_states, "host_number_of_reconstructed_scifi_tracks"], dev_scifi_states_t=long_tracks["dev_scifi_states"], dev_scifi_tracks_view_t=long_tracks["dev_scifi_tracks_view"], - dev_long_tracks_view_t=long_tracks[ - "dev_multi_event_long_tracks_view"], + dev_long_tracks_view_t=long_tracks["dev_multi_event_long_tracks_view"], dev_ecal_digits_t=decoded_calo["dev_ecal_digits"], dev_ecal_digits_offsets_t=decoded_calo["dev_ecal_digits_offsets"], dev_number_of_events_t=number_of_events["dev_number_of_events"]) diff --git a/configuration/python/AllenConf/hlt1_reconstruction.py b/configuration/python/AllenConf/hlt1_reconstruction.py index df6e80636fe..cf531e88a12 100755 --- a/configuration/python/AllenConf/hlt1_reconstruction.py +++ b/configuration/python/AllenConf/hlt1_reconstruction.py @@ -10,8 +10,8 @@ from AllenConf.calo_reconstruction import decode_calo, make_track_matching, make from AllenConf.primary_vertex_reconstruction import make_pvs from AllenConf.secondary_vertex_reconstruction import make_kalman_velo_only, make_basic_particles, fit_secondary_vertices from AllenConf.validators import ( - velo_validation, veloUT_validation, seeding_validation, long_validation, muon_validation, - pv_validation, kalman_validation, selreport_validation) + velo_validation, veloUT_validation, seeding_validation, long_validation, + muon_validation, pv_validation, kalman_validation, selreport_validation) from PyConf.control_flow import NodeLogic, CompositeNode from PyConf.tonic import configurable from AllenConf.persistency import make_gather_selections, make_sel_report_writer @@ -81,9 +81,9 @@ def hlt1_reconstruction_matching(add_electron_id=True): decoded_calo = decode_calo() ecal_clusters = make_ecal_clusters(decoded_calo) - calo_matching_objects = make_track_matching( - decoded_calo, velo_tracks, velo_states, matched_tracks, - kalman_velo_only) + calo_matching_objects = make_track_matching(decoded_calo, velo_tracks, + velo_states, matched_tracks, + kalman_velo_only) if add_electron_id: long_track_particles = make_basic_particles(kalman_velo_only, muonID, @@ -125,7 +125,7 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): veloUT_validation(reconstructed_objects["ut_tracks"])), make_composite_node_with_gec( "long_validation", - long_validation(reconstructed_objects["forward_tracks"])), + long_validation(reconstructed_objects["long_tracks"])), make_composite_node_with_gec( "muon_validation", muon_validation(reconstructed_objects["muonID"])), @@ -139,7 +139,7 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): selreport_validation( make_sel_report_writer( lines=line_algorithms, - forward_tracks=reconstructed_objects[ + long_tracks=reconstructed_objects[ "long_track_particles"], secondary_vertices=reconstructed_objects[ "secondary_vertices"]), @@ -156,7 +156,7 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): velo_validation(reconstructed_objects["velo_tracks"])), make_composite_node_with_gec( "long_validation", - long_validation(reconstructed_objects["forward_tracks"])), + long_validation(reconstructed_objects["long_tracks"])), make_composite_node_with_gec( "muon_validation", muon_validation(reconstructed_objects["muonID"])), @@ -170,7 +170,7 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): selreport_validation( make_sel_report_writer( lines=line_algorithms, - forward_tracks=reconstructed_objects[ + long_tracks=reconstructed_objects[ "long_track_particles"], secondary_vertices=reconstructed_objects[ "secondary_vertices"]), @@ -180,11 +180,9 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): NodeLogic.NONLAZY_AND, force_order=False) -def validator_node_matching(reconstructed_objects, - line_algorithms): +def validator_node_matching(reconstructed_objects, line_algorithms): return CompositeNode( - "Validators", - [ + "Validators", [ make_composite_node_with_gec( "velo_validation", velo_validation(reconstructed_objects["velo_tracks"])), diff --git a/configuration/python/AllenConf/muon_reconstruction.py b/configuration/python/AllenConf/muon_reconstruction.py index 8e31270879d..415908d46f9 100644 --- a/configuration/python/AllenConf/muon_reconstruction.py +++ b/configuration/python/AllenConf/muon_reconstruction.py @@ -114,8 +114,7 @@ def is_muon(decoded_muon, long_tracks): host_number_of_reconstructed_scifi_tracks, dev_scifi_tracks_view_t=dev_scifi_tracks_view, dev_scifi_states_t=dev_scifi_states, - dev_long_tracks_view_t=long_tracks[ - "dev_multi_event_long_tracks_view"], + dev_long_tracks_view_t=long_tracks["dev_multi_event_long_tracks_view"], dev_station_ocurrences_offset_t=decoded_muon[ "dev_station_ocurrences_offset"], dev_muon_hits_t=decoded_muon["dev_muon_hits"]) diff --git a/configuration/python/AllenConf/scifi_reconstruction.py b/configuration/python/AllenConf/scifi_reconstruction.py index d17e65306c4..0fde94aa4b2 100644 --- a/configuration/python/AllenConf/scifi_reconstruction.py +++ b/configuration/python/AllenConf/scifi_reconstruction.py @@ -342,6 +342,7 @@ def make_forward_tracks(decoded_scifi, input_tracks, with_ut=True): scifi_consolidate_tracks.dev_scifi_hits_view_t } + @configurable def make_seeding_XZ_tracks(decoded_scifi): number_of_events = initialize_number_of_events() @@ -448,6 +449,7 @@ def make_seeding_tracks(decoded_scifi, xz_tracks): seed_confirmTracks_consolidate.dev_scifi_hits_view_t } + def forward_tracking(): from AllenConf.velo_reconstruction import decode_velo, make_velo_tracks from AllenConf.ut_reconstruction import decode_ut, make_ut_tracks @@ -461,6 +463,7 @@ def forward_tracking(): alg = long_tracks["dev_scifi_track_hits"].producer return alg + def seeding_xz(): decoded_scifi = decode_scifi() seeding_tracks = make_seeding_XZ_tracks(decoded_scifi) diff --git a/configuration/python/AllenConf/secondary_vertex_reconstruction.py b/configuration/python/AllenConf/secondary_vertex_reconstruction.py index 234ee662ec0..6bb63a61f7b 100644 --- a/configuration/python/AllenConf/secondary_vertex_reconstruction.py +++ b/configuration/python/AllenConf/secondary_vertex_reconstruction.py @@ -42,10 +42,8 @@ def make_kalman_velo_only(long_tracks, dev_number_of_events_t=number_of_events["dev_number_of_events"], host_number_of_reconstructed_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_long_tracks_view_t=long_tracks[ - "dev_multi_event_long_tracks_view"], - dev_offsets_long_tracks_t=long_tracks[ - "dev_offsets_long_tracks"], + dev_long_tracks_view_t=long_tracks["dev_multi_event_long_tracks_view"], + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"], dev_multi_final_vertices_t=pvs["dev_multi_final_vertices"], dev_number_of_multi_final_vertices_t=pvs[ "dev_number_of_multi_final_vertices"], @@ -94,8 +92,7 @@ def make_basic_particles(kalman_velo_only, "host_number_of_reconstructed_scifi_tracks"], dev_multi_event_long_tracks_t=long_tracks[ "dev_multi_event_long_tracks_ptr"], - dev_offsets_long_tracks_t=long_tracks[ - "dev_offsets_long_tracks"], + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"], dev_kalman_states_view_t=kalman_velo_only["dev_kalman_states_view"], dev_kalman_pv_tables_t=kalman_velo_only["dev_kalman_pv_tables"], dev_multi_final_vertices_t=pvs["dev_multi_final_vertices"], diff --git a/configuration/python/AllenConf/validators.py b/configuration/python/AllenConf/validators.py index 1b3852cb8d2..97bcdae679f 100644 --- a/configuration/python/AllenConf/validators.py +++ b/configuration/python/AllenConf/validators.py @@ -97,6 +97,7 @@ def long_validation(long_tracks, name="long_validator"): "dev_multi_event_long_tracks_view"], dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"]) + def seeding_xz_validation(name="seed_xz_validator"): mc_events = mc_data_provider() decoded_scifi = decode_scifi() @@ -156,6 +157,7 @@ def seeding_validation(seeding_tracks, name="seed_validator"): dev_seeding_states_t=seeding_tracks["dev_seeding_states"], host_mc_events_t=mc_events.host_mc_events_t) + def velo_scifi_dump(matched_tracks, name="veloscifi_dump"): mc_events = mc_data_provider() @@ -187,7 +189,8 @@ def velo_scifi_dump(matched_tracks, name="veloscifi_dump"): "dev_offsets_scifi_seed_hit_number"], dev_scifi_seeds_t=seeding_tracks["seed_tracks"], dev_seeding_states_t=seeding_tracks["dev_seeding_states"]) - + + def muon_validation(muonID, name="muon_validator"): mc_events = mc_data_provider() number_of_events = initialize_number_of_events() diff --git a/configuration/python/AllenSequences/hlt1_complex_validation.py b/configuration/python/AllenSequences/hlt1_complex_validation.py index 4ce57e43ce9..3fc72d73758 100644 --- a/configuration/python/AllenSequences/hlt1_complex_validation.py +++ b/configuration/python/AllenSequences/hlt1_complex_validation.py @@ -84,9 +84,8 @@ validators_leaf = CompositeNode( "restricted_long_validator")), make_composite_node_with_gec( "non-restricted_long_validator", - long_validation( - non_restricted_hlt1_reconstruction["long_tracks"], - "non-restricted_long_validator")), + long_validation(non_restricted_hlt1_reconstruction["long_tracks"], + "non-restricted_long_validator")), make_composite_node_with_gec( "restricted_muon_validation", muon_validation(restricted_hlt1_reconstruction["muonID"], diff --git a/device/SciFi/consolidate/src/ConsolidateSciFi.cu b/device/SciFi/consolidate/src/ConsolidateSciFi.cu index 04bdd0e850b..e5137b49118 100644 --- a/device/SciFi/consolidate/src/ConsolidateSciFi.cu +++ b/device/SciFi/consolidate/src/ConsolidateSciFi.cu @@ -309,11 +309,11 @@ __device__ void scifi_consolidate_tracks_impl( const auto txO = velo_state.tx(); const auto tyO = velo_state.ty(); - //QoP for scifi tracks + // QoP for scifi tracks scifi_tracks.qop(i) = qop_calculation(dev_looking_forward_constants, magSign, z0, x0, y0, xVelo, yVelo, zVelo, txO, tyO, tx, ty); - //QoP for long tracks + // QoP for long tracks tracks_qop[i] = qop_calculation(dev_looking_forward_constants, magSign, z0, x0, y0, xVelo, yVelo, zVelo, txO, tyO, tx, ty); diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index f0554da86db..66b0cacb2f2 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -56,41 +56,37 @@ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::set_argum set_size(arguments, 1); } - //=========================================================================================== -// Calculate momentum, given T state only, adapted from +// Calculate momentum, given T state only, adapted from // https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Tr/TrackTools/src/FastMomentumEstimate.cpp //=========================================================================================== -__device__ float qop_seeding_calculation( - const float magSign, - const MiniState seeding_state, - bool tCubicFit) +__device__ float qop_seeding_calculation(const float magSign, const MiniState seeding_state, bool tCubicFit) { const float tx = seeding_state.tx; const float ty = seeding_state.ty; - const float x = seeding_state.x; - const float z = seeding_state.z; + const float x = seeding_state.x; + const float z = seeding_state.z; const float m_paramsTParab[4] = {-6.30991, -4.83533, -12.9192, 4.23025e-08}; const float m_paramsTCubic[4] = {-6.34025, -4.85287, -12.4491, 4.25461e-08}; float qop = 0.f; const auto x0 = x - tx * z; - const auto& params = ( tCubicFit ? m_paramsTCubic : m_paramsTParab ); + const auto& params = (tCubicFit ? m_paramsTCubic : m_paramsTParab); const auto p = params[0] + params[1] * tx * tx + params[2] * ty * ty + params[3] * x0 * x0; - const auto scale_factor = 1. * magSign; //is there a way to get the scale_factor from the constants? - const float denom = p * scale_factor * 1e6 * ( -1 ); + const auto scale_factor = 1. * magSign; // is there a way to get the scale_factor from the constants? + const float denom = p * scale_factor * 1e6 * (-1); - if ( std::abs( scale_factor ) < 1e-6 ) { - qop = 0.01 / Gaudi::Units::GeV; - } else { - qop = x0 / denom; + if (std::abs(scale_factor) < 1e-6) { + qop = 0.01 / Gaudi::Units::GeV; + } + else { + qop = x0 / denom; } return qop; } - void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator()( const ArgumentReferences& arguments, const RuntimeOptions& runtime_options, @@ -102,7 +98,8 @@ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator( initialize(arguments, 0, context); global_function(seed_confirmTracks_consolidate)( - dim3(size(arguments)), property(), context)(arguments, constants.dev_magnet_polarity.data()); + dim3(size(arguments)), property(), context)( + arguments, constants.dev_magnet_polarity.data()); global_function(create_scifi_views)(first(arguments), 256, context)(arguments); } @@ -135,10 +132,10 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( // Create consolidated SoAs. SciFi::Consolidated::Seeds scifi_seeds {parameters.dev_atomics_scifi, - parameters.dev_seeding_hit_number, - parameters.dev_seeding_states, - event_number, - number_of_events}; + parameters.dev_seeding_hit_number, + parameters.dev_seeding_states, + event_number, + number_of_events}; const unsigned number_of_tracks_event = scifi_seeds.number_of_tracks(event_number); const unsigned event_offset = scifi_hit_count.event_offset(); float* tracks_qop = parameters.dev_seeding_qop + parameters.dev_atomics_scifi[event_number]; @@ -159,8 +156,7 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( scifi_seeds.states(i) = seeding_state; const auto magSign = dev_magnet_polarity[0]; - tracks_qop[i] = - qop_seeding_calculation(magSign, seeding_state, true); + tracks_qop[i] = qop_seeding_calculation(magSign, seeding_state, true); auto consolidated_hits = scifi_seeds.get_hits(parameters.dev_seeding_track_hits, i); diff --git a/device/event_model/SciFi/include/SciFiConsolidated.cuh b/device/event_model/SciFi/include/SciFiConsolidated.cuh index 3fd1a286777..944265f25bc 100644 --- a/device/event_model/SciFi/include/SciFiConsolidated.cuh +++ b/device/event_model/SciFi/include/SciFiConsolidated.cuh @@ -243,7 +243,7 @@ namespace SciFi { __host__ __device__ float qop(const unsigned index) const { return m_qop[index]; } __host__ __device__ float& qop(const unsigned index) { return m_qop[index]; } - + __host__ __device__ MiniState states(const unsigned index) const { return m_states[index]; } __host__ __device__ MiniState& states(const unsigned index) { return m_states[index]; } diff --git a/device/event_model/SciFi/include/SciFiEventModel.cuh b/device/event_model/SciFi/include/SciFiEventModel.cuh index 452adcaf559..4befb6210fb 100644 --- a/device/event_model/SciFi/include/SciFiEventModel.cuh +++ b/device/event_model/SciFi/include/SciFiEventModel.cuh @@ -561,7 +561,7 @@ namespace SciFi { __host__ __device__ float ySlope() const { return by; } }; } // namespace Seeding - + struct MatchedTrack { uint16_t velo_track_index; uint16_t scifi_track_index; diff --git a/device/selections/Hlt1/include/DeviceLineTraverser.cuh b/device/selections/Hlt1/include/DeviceLineTraverser.cuh index c57aaefb21d..c65f7b1a702 100644 --- a/device/selections/Hlt1/include/DeviceLineTraverser.cuh +++ b/device/selections/Hlt1/include/DeviceLineTraverser.cuh @@ -13,7 +13,8 @@ namespace Hlt1 { template struct DeviceTraverseLinesImpl, U, std::index_sequence<>, void> { template - __device__ constexpr static void traverse(const F&) {} + __device__ constexpr static void traverse(const F&) + {} }; // If the line inherits from U, execute the lambda with the index of the line @@ -62,7 +63,8 @@ namespace Hlt1 { template struct DeviceTraverseLinesNamesImpl, U, std::index_sequence<>, void> { template - __device__ constexpr static void traverse(const F&) {} + __device__ constexpr static void traverse(const F&) + {} }; // If the line inherits from U, execute the lambda with the index of the line @@ -111,7 +113,8 @@ namespace Hlt1 { template struct DeviceTraverseLinesScaleFactorsImpl, U, std::index_sequence<>, void> { template - __device__ constexpr static void traverse(const F&) {} + __device__ constexpr static void traverse(const F&) + {} }; // If the line inherits from U, execute the lambda with the index of the line @@ -120,12 +123,13 @@ namespace Hlt1 { std::tuple, U, std::index_sequence, - typename std::enable_if::value>::type> {\ + typename std::enable_if::value>::type> { template __device__ constexpr static void traverse(const F& lambda_fn) { lambda_fn(I, T::scale_factor); - DeviceTraverseLinesScaleFactorsImpl, U, std::index_sequence>::traverse(lambda_fn); + DeviceTraverseLinesScaleFactorsImpl, U, std::index_sequence>::traverse( + lambda_fn); } }; @@ -139,7 +143,8 @@ namespace Hlt1 { template __device__ constexpr static void traverse(const F& lambda_fn) { - DeviceTraverseLinesScaleFactorsImpl, U, std::index_sequence>::traverse(lambda_fn); + DeviceTraverseLinesScaleFactorsImpl, U, std::index_sequence>::traverse( + lambda_fn); } }; @@ -149,7 +154,8 @@ namespace Hlt1 { template __device__ constexpr static void traverse(const F& lambda_fn) { - DeviceTraverseLinesScaleFactorsImpl::value>>::traverse(lambda_fn); + DeviceTraverseLinesScaleFactorsImpl::value>>::traverse( + lambda_fn); } }; diff --git a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu index defd7dbb5d7..e83b3e14ae3 100644 --- a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu +++ b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu @@ -62,7 +62,6 @@ void matching_consolidate_tracks::matching_consolidate_tracks_t::operator()( dim3(size(arguments)), property(), context)(arguments); global_function(create_matched_views)(first(arguments), 256, context)(arguments); - } __global__ void matching_consolidate_tracks::matching_consolidate_tracks( diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index 9059067bbcb..5b67be3402c 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -12,7 +12,8 @@ void track_matching_veloSciFi::track_matching_veloSciFi_t::set_arguments_size( const Constants&, const HostBuffers&) const { - set_size(arguments, first(arguments) * TrackMatchingConsts::max_num_tracks); + set_size( + arguments, first(arguments) * TrackMatchingConsts::max_num_tracks); set_size(arguments, first(arguments)); } diff --git a/host/validators/src/HostVeloScifiDump.cpp b/host/validators/src/HostVeloScifiDump.cpp index 12ee4158a41..1a61299c28d 100644 --- a/host/validators/src/HostVeloScifiDump.cpp +++ b/host/validators/src/HostVeloScifiDump.cpp @@ -25,7 +25,7 @@ namespace { int n_meas = 0; int n_hits_missing = 0; // FIXME const auto nhits = track.total_number_of_hits; - for (unsigned ihit=0; ihit Date: Wed, 13 Jul 2022 18:08:07 +0200 Subject: [PATCH 07/18] adapted to forward without UT and replaced make_vector with make_host_buffer --- .../tracking/include/TrackCheckerCategories.h | 2 ++ .../SciFi/consolidate/src/ConsolidateSciFi.cu | 10 +++++-- .../src/ConsolidateSciFiSeeding.cu | 2 -- .../hybridseeding/src/seed_confirmTracks.cu | 3 --- device/SciFi/hybridseeding/src/seed_xz.cu | 3 --- .../match/src/TrackMatchingVELOSciFi.cu | 3 --- host/validators/src/HostSeedingValidator.cpp | 14 +++++----- .../validators/src/HostSeedingXZValidator.cpp | 10 +++---- host/validators/src/HostVeloScifiDump.cpp | 26 +++++++++---------- 9 files changed, 35 insertions(+), 38 deletions(-) diff --git a/checker/tracking/include/TrackCheckerCategories.h b/checker/tracking/include/TrackCheckerCategories.h index e3e1813d0cc..364b4301d4f 100644 --- a/checker/tracking/include/TrackCheckerCategories.h +++ b/checker/tracking/include/TrackCheckerCategories.h @@ -735,6 +735,8 @@ namespace Categories { [](MCParticles::const_reference& mcp) { return mcp.isLong && !mcp.isElectron() && mcp.fromBeautyDecay && mcp.p > 5e3f && mcp.pt > 1e3f && mcp.inEta2_5(); + }, + }), TrackEffReport({ "11_noVelo_UT", [](MCParticles::const_reference& mcp) { diff --git a/device/SciFi/consolidate/src/ConsolidateSciFi.cu b/device/SciFi/consolidate/src/ConsolidateSciFi.cu index e5137b49118..588aa92a4a3 100644 --- a/device/SciFi/consolidate/src/ConsolidateSciFi.cu +++ b/device/SciFi/consolidate/src/ConsolidateSciFi.cu @@ -29,7 +29,10 @@ __device__ void create_scifi_views_impl(const scifi_consolidate_tracks::Paramete track_index, event_number}; new (parameters.dev_long_track_view + event_tracks_offset + track_index) Allen::Views::Physics::LongTrack { - velo_track, ut_track, parameters.dev_scifi_track_view + event_tracks_offset + track_index}; + velo_track, + ut_track, + parameters.dev_scifi_track_view + event_tracks_offset + track_index, + parameters.dev_scifi_qop + event_tracks_offset + track_index}; } else { @@ -43,7 +46,10 @@ __device__ void create_scifi_views_impl(const scifi_consolidate_tracks::Paramete track_index, event_number}; new (parameters.dev_long_track_view + event_tracks_offset + track_index) Allen::Views::Physics::LongTrack { - velo_track, nullptr, parameters.dev_scifi_track_view + event_tracks_offset + track_index}; + velo_track, + nullptr, + parameters.dev_scifi_track_view + event_tracks_offset + track_index, + parameters.dev_scifi_qop + event_tracks_offset + track_index}; } } diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index 66b0cacb2f2..c1983ec4173 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -94,8 +94,6 @@ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator( HostBuffers& host_buffers, const Allen::Context& context) const { - initialize(arguments, 0, context); - initialize(arguments, 0, context); global_function(seed_confirmTracks_consolidate)( dim3(size(arguments)), property(), context)( diff --git a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu index 988a3d1d0a5..de2abde74df 100644 --- a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu +++ b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu @@ -49,9 +49,6 @@ void seed_confirmTracks::seed_confirmTracks_t::operator()( HostBuffers&, const Allen::Context& context) const { - initialize( - arguments, 0, context); // This is only needed because of the prefix sum, should be removed - initialize(arguments, 0, context); global_function(seed_confirmTracks)(dim3(size(arguments)), dim3(128), context)(arguments); // copy(arguments, context); //FIXME diff --git a/device/SciFi/hybridseeding/src/seed_xz.cu b/device/SciFi/hybridseeding/src/seed_xz.cu index e61e776a2f4..ee608168a96 100644 --- a/device/SciFi/hybridseeding/src/seed_xz.cu +++ b/device/SciFi/hybridseeding/src/seed_xz.cu @@ -226,9 +226,6 @@ void seed_xz::seed_xz_t::operator()( HostBuffers&, const Allen::Context& context) const { - initialize( - arguments, 0, context); // This is only needed because of the prefix sum, should be removed - initialize(arguments, 0, context); global_function(seed_xz)(dim3(size(arguments)), dim3(128), context)(arguments); } diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index 5b67be3402c..44baed56817 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -24,9 +24,6 @@ void track_matching_veloSciFi::track_matching_veloSciFi_t::operator()( HostBuffers&, const Allen::Context& context) const { - initialize( - arguments, 0, context); // This is only needed because of the prefix sum, should be removed - global_function(track_matching_veloSciFi)(dim3(size(arguments)), dim3(128), context)( arguments, constants.dev_magnet_parametrization); } diff --git a/host/validators/src/HostSeedingValidator.cpp b/host/validators/src/HostSeedingValidator.cpp index f5d93f8a2dc..e72c096ea9e 100644 --- a/host/validators/src/HostSeedingValidator.cpp +++ b/host/validators/src/HostSeedingValidator.cpp @@ -10,14 +10,14 @@ void host_seeding_validator::host_seeding_validator_t::operator()( const RuntimeOptions& runtime_options, const Constants&, HostBuffers&, - const Allen::Context&) const + const Allen::Context& context) const { - const auto scifi_seed_atomics = make_vector(arguments); - const auto scifi_seed_hit_number = make_vector(arguments); - const auto scifi_seed_hits = make_vector(arguments); - const auto scifi_seeds = make_vector(arguments); - const auto seeding_states = make_vector(arguments); - const auto event_list = make_vector(arguments); + const auto scifi_seed_atomics = make_host_buffer(arguments, context); + const auto scifi_seed_hit_number = make_host_buffer(arguments, context); + const auto scifi_seed_hits = make_host_buffer(arguments, context); + const auto scifi_seeds = make_host_buffer(arguments, context); + const auto seeding_states = make_host_buffer(arguments, context); + const auto event_list = make_host_buffer(arguments, context); auto tracks = prepareSeedingTracks( first(arguments), diff --git a/host/validators/src/HostSeedingXZValidator.cpp b/host/validators/src/HostSeedingXZValidator.cpp index f6381445954..a860490d4e6 100644 --- a/host/validators/src/HostSeedingXZValidator.cpp +++ b/host/validators/src/HostSeedingXZValidator.cpp @@ -10,12 +10,12 @@ void host_seeding_XZ_validator::host_seeding_XZ_validator_t::operator()( const RuntimeOptions& runtime_options, const Constants&, HostBuffers&, - const Allen::Context&) const + const Allen::Context& context) const { - const auto scifi_seedXZ_atomics = make_vector(arguments); - const auto scifi_seedXZ_hit_number = make_vector(arguments); - const auto scifi_seedsXZ = make_vector(arguments); - const auto event_list = make_vector(arguments); + const auto scifi_seedXZ_atomics = make_host_buffer(arguments, context); + const auto scifi_seedXZ_hit_number = make_host_buffer(arguments, context); + const auto scifi_seedsXZ = make_host_buffer(arguments, context); + const auto event_list = make_host_buffer(arguments, context); auto tracks = prepareSeedingTracksXZ( first(arguments), diff --git a/host/validators/src/HostVeloScifiDump.cpp b/host/validators/src/HostVeloScifiDump.cpp index 1a61299c28d..733ebfc9097 100644 --- a/host/validators/src/HostVeloScifiDump.cpp +++ b/host/validators/src/HostVeloScifiDump.cpp @@ -149,23 +149,23 @@ void host_veloscifi_dump::host_veloscifi_dump_t::operator()( const RuntimeOptions&, const Constants&, HostBuffers&, - const Allen::Context&) const + const Allen::Context& context) const { const auto number_of_events = first(arguments); - const auto event_list = make_vector(arguments); + const auto event_list = make_host_buffer(arguments, context); - const auto offsets_all_velo_tracks = make_vector(arguments); - const auto offsets_velo_track_hit_number = make_vector(arguments); - const auto velo_track_hits = make_vector(arguments); - const auto velo_states_base = make_vector(arguments); - const auto number_of_selected_velo = make_vector(arguments); - const auto selected_velo_tracks = make_vector(arguments); + const auto offsets_all_velo_tracks = make_host_buffer(arguments, context); + const auto offsets_velo_track_hit_number = make_host_buffer(arguments, context); + const auto velo_track_hits = make_host_buffer(arguments, context); + const auto velo_states_base = make_host_buffer(arguments, context); + const auto number_of_selected_velo = make_host_buffer(arguments, context); + const auto selected_velo_tracks = make_host_buffer(arguments, context); - const auto scifi_seed_atomics = make_vector(arguments); - const auto scifi_seed_hit_number = make_vector(arguments); - const auto scifi_seed_hits = make_vector(arguments); - const auto scifi_seeds = make_vector(arguments); - const auto seeding_states_base = make_vector(arguments); + const auto scifi_seed_atomics = make_host_buffer(arguments, context); + const auto scifi_seed_hit_number = make_host_buffer(arguments, context); + const auto scifi_seed_hits = make_host_buffer(arguments, context); + const auto scifi_seeds = make_host_buffer(arguments, context); + const auto seeding_states_base = make_host_buffer(arguments, context); const auto mc_events = *first(arguments); -- GitLab From 8f2ea688c5356cb60b75f3f6cc76551cdf453370 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Thu, 28 Jul 2022 11:38:30 +0200 Subject: [PATCH 08/18] rebased to new velo decoding --- configuration/python/AllenConf/HLT1.py | 2 +- .../python/AllenConf/calo_reconstruction.py | 6 ++---- .../python/AllenConf/hlt1_reconstruction.py | 10 +++++----- .../python/AllenConf/scifi_reconstruction.py | 9 ++++++--- .../SciFi/consolidate/src/ConsolidateSciFi.cu | 20 +++++++++---------- .../src/ConsolidateSciFiSeeding.cu | 2 ++ .../hybridseeding/src/seed_confirmTracks.cu | 5 +++-- device/SciFi/hybridseeding/src/seed_xz.cu | 3 +++ .../include/ConsolidateMatchedTracks.cuh | 2 +- .../match/include/TrackMatchingVELOSciFi.cuh | 2 +- .../match/src/TrackMatchingVELOSciFi.cu | 2 ++ 11 files changed, 36 insertions(+), 27 deletions(-) diff --git a/configuration/python/AllenConf/HLT1.py b/configuration/python/AllenConf/HLT1.py index 8ebfc71e796..e264bc09c36 100644 --- a/configuration/python/AllenConf/HLT1.py +++ b/configuration/python/AllenConf/HLT1.py @@ -490,7 +490,7 @@ def setup_hlt1_node(withMCChecking=False, else: if not matching: validation_node = validator_node(reconstructed_objects, - line_algorithms, with_ut) + line_algorithms, with_ut) else: validation_node = validator_node_matching(reconstructed_objects, line_algorithms) diff --git a/configuration/python/AllenConf/calo_reconstruction.py b/configuration/python/AllenConf/calo_reconstruction.py index 5e16a3254dc..e233bc0c133 100755 --- a/configuration/python/AllenConf/calo_reconstruction.py +++ b/configuration/python/AllenConf/calo_reconstruction.py @@ -84,10 +84,8 @@ def make_track_matching(decoded_calo, velo_tracks, velo_states, long_tracks, "host_number_of_reconstructed_scifi_tracks"], dev_kf_tracks_t=kalman_velo_only["dev_kf_tracks"], dev_velo_tracks_offsets_t=velo_tracks["dev_offsets_all_velo_tracks"], - dev_long_tracks_view_t=long_tracks[ - "dev_multi_event_long_tracks_view"], - dev_offsets_long_tracks_t=long_tracks[ - "dev_offsets_long_tracks"], + dev_long_tracks_view_t=long_tracks["dev_multi_event_long_tracks_view"], + dev_offsets_long_tracks_t=long_tracks["dev_offsets_long_tracks"], dev_brem_E_t=brem_recovery.dev_brem_E_t, dev_brem_ET_t=brem_recovery.dev_brem_ET_t) diff --git a/configuration/python/AllenConf/hlt1_reconstruction.py b/configuration/python/AllenConf/hlt1_reconstruction.py index cf531e88a12..e590b3d2959 100755 --- a/configuration/python/AllenConf/hlt1_reconstruction.py +++ b/configuration/python/AllenConf/hlt1_reconstruction.py @@ -38,9 +38,8 @@ def hlt1_reconstruction(add_electron_id=True, with_ut=True): decoded_calo = decode_calo() ecal_clusters = make_ecal_clusters(decoded_calo) - calo_matching_objects = make_track_matching(decoded_calo, velo_tracks, - velo_states,long_tracks, - kalman_velo_only) + calo_matching_objects = make_track_matching( + decoded_calo, velo_tracks, velo_states, long_tracks, kalman_velo_only) if add_electron_id: long_track_particles = make_basic_particles(kalman_velo_only, muonID, @@ -54,7 +53,7 @@ def hlt1_reconstruction(add_electron_id=True, with_ut=True): "velo_states": velo_states, "decoded_calo": decoded_calo, "pvs": pvs, - "ut_tracks": ut_tracks, + "ut_tracks": input_tracks, "long_tracks": long_tracks, "muonID": muonID, "kalman_velo_only": kalman_velo_only, @@ -180,6 +179,7 @@ def validator_node(reconstructed_objects, line_algorithms, with_ut): NodeLogic.NONLAZY_AND, force_order=False) + def validator_node_matching(reconstructed_objects, line_algorithms): return CompositeNode( "Validators", [ @@ -210,4 +210,4 @@ def validator_node_matching(reconstructed_objects, line_algorithms): ) ], NodeLogic.NONLAZY_AND, - force_order=False) \ No newline at end of file + force_order=False) diff --git a/configuration/python/AllenConf/scifi_reconstruction.py b/configuration/python/AllenConf/scifi_reconstruction.py index 0fde94aa4b2..7f2199ecc85 100644 --- a/configuration/python/AllenConf/scifi_reconstruction.py +++ b/configuration/python/AllenConf/scifi_reconstruction.py @@ -7,7 +7,8 @@ from AllenAlgorithms.algorithms import ( lf_search_initial_windows_t, lf_triplet_seeding_t, lf_create_tracks_t, lf_quality_filter_length_t, lf_quality_filter_t, scifi_copy_track_hit_number_t, scifi_consolidate_tracks_t, get_type_id_t, - seed_xz_t, seed_confirmTracks_t, seeding_copy_track_hit_number_t, seed_confirmTracks_consolidate_t) + seed_xz_t, seed_confirmTracks_t, seeding_copy_track_hit_number_t, + seed_confirmTracks_consolidate_t) from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm from PyConf.tonic import configurable @@ -65,8 +66,10 @@ def decode_scifi(): scifi_calculate_cluster_count.dev_scifi_hit_count_t, "host_number_of_scifi_hits": prefix_sum_scifi_hits.host_total_sum_holder_t, - "dev_scifi_hits": scifi_raw_bank_decoder.dev_scifi_hits_t, - "dev_scifi_hit_offsets": prefix_sum_scifi_hits.dev_output_buffer_t, + "dev_scifi_hits": + scifi_raw_bank_decoder.dev_scifi_hits_t, + "dev_scifi_hit_offsets": + prefix_sum_scifi_hits.dev_output_buffer_t, "host_number_of_scifi_hits": prefix_sum_scifi_hits.host_total_sum_holder_t } diff --git a/device/SciFi/consolidate/src/ConsolidateSciFi.cu b/device/SciFi/consolidate/src/ConsolidateSciFi.cu index 588aa92a4a3..842d7e27e80 100644 --- a/device/SciFi/consolidate/src/ConsolidateSciFi.cu +++ b/device/SciFi/consolidate/src/ConsolidateSciFi.cu @@ -28,11 +28,11 @@ __device__ void create_scifi_views_impl(const scifi_consolidate_tracks::Paramete parameters.dev_scifi_track_hit_number, track_index, event_number}; - new (parameters.dev_long_track_view + event_tracks_offset + track_index) Allen::Views::Physics::LongTrack { - velo_track, - ut_track, - parameters.dev_scifi_track_view + event_tracks_offset + track_index, - parameters.dev_scifi_qop + event_tracks_offset + track_index}; + new (parameters.dev_long_track_view + event_tracks_offset + track_index) + Allen::Views::Physics::LongTrack {velo_track, + ut_track, + parameters.dev_scifi_track_view + event_tracks_offset + track_index, + parameters.dev_scifi_qop + event_tracks_offset + track_index}; } else { @@ -45,11 +45,11 @@ __device__ void create_scifi_views_impl(const scifi_consolidate_tracks::Paramete parameters.dev_scifi_track_hit_number, track_index, event_number}; - new (parameters.dev_long_track_view + event_tracks_offset + track_index) Allen::Views::Physics::LongTrack { - velo_track, - nullptr, - parameters.dev_scifi_track_view + event_tracks_offset + track_index, - parameters.dev_scifi_qop + event_tracks_offset + track_index}; + new (parameters.dev_long_track_view + event_tracks_offset + track_index) + Allen::Views::Physics::LongTrack {velo_track, + nullptr, + parameters.dev_scifi_track_view + event_tracks_offset + track_index, + parameters.dev_scifi_qop + event_tracks_offset + track_index}; } } diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index c1983ec4173..fb3b0fc24e6 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -94,6 +94,8 @@ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator( HostBuffers& host_buffers, const Allen::Context& context) const { + Allen::memset_async(arguments, 0, context); + Allen::memset_async(arguments, 0, context); global_function(seed_confirmTracks_consolidate)( dim3(size(arguments)), property(), context)( diff --git a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu index de2abde74df..7492d816217 100644 --- a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu +++ b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu @@ -49,9 +49,10 @@ void seed_confirmTracks::seed_confirmTracks_t::operator()( HostBuffers&, const Allen::Context& context) const { - global_function(seed_confirmTracks)(dim3(size(arguments)), dim3(128), context)(arguments); + Allen::memset_async(arguments, 0, context); + Allen::memset_async(arguments, 0, context); - // copy(arguments, context); //FIXME + global_function(seed_confirmTracks)(dim3(size(arguments)), dim3(128), context)(arguments); } __device__ int seed_confirmTracks::findHit(const float tolRem, float predPos, int startPos, int nHits, float* coords) diff --git a/device/SciFi/hybridseeding/src/seed_xz.cu b/device/SciFi/hybridseeding/src/seed_xz.cu index ee608168a96..beba53837b2 100644 --- a/device/SciFi/hybridseeding/src/seed_xz.cu +++ b/device/SciFi/hybridseeding/src/seed_xz.cu @@ -226,6 +226,9 @@ void seed_xz::seed_xz_t::operator()( HostBuffers&, const Allen::Context& context) const { + Allen::memset_async(arguments, 0, context); + Allen::memset_async(arguments, 0, context); + global_function(seed_xz)(dim3(size(arguments)), dim3(128), context)(arguments); } diff --git a/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh index d305527b411..82719a5c6c6 100644 --- a/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh +++ b/device/track_matching/consolidate/include/ConsolidateMatchedTracks.cuh @@ -55,7 +55,7 @@ namespace matching_consolidate_tracks { DEVICE_OUTPUT_WITH_DEPENDENCIES( dev_multi_event_long_tracks_ptr_t, DEPENDENCIES(dev_multi_event_long_tracks_view_t), - Allen::Views::Physics::MultiEventLongTracks*) + Allen::IMultiEventContainer*) dev_multi_event_long_tracks_ptr; PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; }; diff --git a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh index 2efd2202fa6..53c829c3655 100644 --- a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh +++ b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh @@ -22,7 +22,7 @@ namespace track_matching_veloSciFi { DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; DEVICE_INPUT(dev_velo_tracks_view_t, Allen::Views::Velo::Consolidated::Tracks) dev_velo_tracks_view; - DEVICE_INPUT(dev_velo_states_view_t, Allen::Views::Velo::Consolidated::States) dev_velo_states_view; + DEVICE_INPUT(dev_velo_states_view_t, Allen::Views::Physics::KalmanStates) dev_velo_states_view; DEVICE_INPUT(dev_ut_number_of_selected_velo_tracks_t, unsigned) dev_ut_number_of_selected_velo_tracks; DEVICE_INPUT(dev_ut_selected_velo_tracks_t, unsigned) dev_ut_selected_velo_tracks; diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index 44baed56817..11e2fecf29d 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -24,6 +24,8 @@ void track_matching_veloSciFi::track_matching_veloSciFi_t::operator()( HostBuffers&, const Allen::Context& context) const { + Allen::memset_async(arguments, 0, context); + global_function(track_matching_veloSciFi)(dim3(size(arguments)), dim3(128), context)( arguments, constants.dev_magnet_parametrization); } -- GitLab From 8b6cf2c993966cc266ed671a2d4be0437e7e6b44 Mon Sep 17 00:00:00 2001 From: Arthur Hennequin Date: Fri, 29 Jul 2022 14:08:16 +0200 Subject: [PATCH 09/18] Make seed_confirmTracks deterministic --- device/event_model/SciFi/include/SciFiDefinitions.cuh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/device/event_model/SciFi/include/SciFiDefinitions.cuh b/device/event_model/SciFi/include/SciFiDefinitions.cuh index 6f31616ae8c..6efb04a1586 100644 --- a/device/event_model/SciFi/include/SciFiDefinitions.cuh +++ b/device/event_model/SciFi/include/SciFiDefinitions.cuh @@ -85,7 +85,7 @@ namespace SciFi { // Constants for SciFi seeding static constexpr int Nmax_seed_xz_per_part = 300; static constexpr int Nmax_seed_xz = n_parts * Nmax_seed_xz_per_part; - static constexpr int Nmax_seeds_per_part = 100; + static constexpr int Nmax_seeds_per_part = Nmax_seed_xz_per_part; static constexpr int Nmax_seeds = n_parts * Nmax_seeds_per_part; } // namespace Constants -- GitLab From ab7a1defa76d8143aa34c495d612fc7694306db5 Mon Sep 17 00:00:00 2001 From: Lorenzo Pica Date: Mon, 1 Aug 2022 17:00:20 +0200 Subject: [PATCH 10/18] Added long_strange categories to validators --- .../tracking/include/TrackCheckerCategories.h | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/checker/tracking/include/TrackCheckerCategories.h b/checker/tracking/include/TrackCheckerCategories.h index 364b4301d4f..a5b462e0622 100644 --- a/checker/tracking/include/TrackCheckerCategories.h +++ b/checker/tracking/include/TrackCheckerCategories.h @@ -761,6 +761,19 @@ namespace Categories { return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); }, }), + TrackEffReport({ + "15_long_strange_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.fromStrangeDecay && mcp.p > 5e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "16_long_strange_P>5GeV_PT>500MeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.fromStrangeDecay && mcp.p > 5e3f && mcp.inEta2_5() && + mcp.pt > 5e2f; + }, + }), /* TrackEffReport({ */ /* "Long", */ @@ -1243,7 +1256,19 @@ namespace Categories { return mcp.isLong && mcp.fromBeautyDecay && !mcp.isElectron() && mcp.pt > 2e3f && mcp.inEta2_5(); }, }), - + TrackEffReport({ + "21_long_strange_P>5GeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.fromStrangeDecay && mcp.p > 5e3f && mcp.inEta2_5(); + }, + }), + TrackEffReport({ + "22_long_strange_P>5GeV_PT>500MeV", + [](MCParticles::const_reference& mcp) { + return mcp.isLong && !mcp.isElectron() && mcp.fromStrangeDecay && mcp.p > 5e3f && mcp.inEta2_5() && + mcp.pt > 5e2f; + }, + }), }}; } -- GitLab From bf07b53fbe628a71abfde7913c1559ccfbad85b0 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Wed, 3 Aug 2022 21:33:56 +0200 Subject: [PATCH 11/18] fixed GaudiAllen wrapper matching include --- device/track_matching/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/device/track_matching/CMakeLists.txt b/device/track_matching/CMakeLists.txt index 995a081d498..b50c673a0bc 100644 --- a/device/track_matching/CMakeLists.txt +++ b/device/track_matching/CMakeLists.txt @@ -16,4 +16,5 @@ target_include_directories(track_matching PUBLIC $) target_include_directories(WrapperInterface INTERFACE + $ $) -- GitLab From 3da74f48a93466d18fc5e855101c68b7550b181a Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Mon, 8 Aug 2022 19:19:07 +0200 Subject: [PATCH 12/18] replaced scifi view to long track view in MakeLeptonID --- .../python/AllenConf/secondary_vertex_reconstruction.py | 3 ++- device/kalman/ParKalman/include/MakeLeptonID.cuh | 3 ++- device/kalman/ParKalman/src/MakeLeptonID.cu | 7 ++++--- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/configuration/python/AllenConf/secondary_vertex_reconstruction.py b/configuration/python/AllenConf/secondary_vertex_reconstruction.py index 6bb63a61f7b..8c4a75dd859 100644 --- a/configuration/python/AllenConf/secondary_vertex_reconstruction.py +++ b/configuration/python/AllenConf/secondary_vertex_reconstruction.py @@ -76,7 +76,8 @@ def make_basic_particles(kalman_velo_only, dev_number_of_events_t=number_of_events["dev_number_of_events"], host_number_of_scifi_tracks_t=long_tracks[ "host_number_of_reconstructed_scifi_tracks"], - dev_scifi_tracks_view_t=long_tracks["dev_scifi_tracks_view"], + dev_long_tracks_view_t=long_tracks[ + "dev_multi_event_long_tracks_view"], dev_is_muon_t=is_muon_result["dev_is_muon"], dev_is_electron_t=is_electron_result["dev_track_isElectron"]) lepton_id = make_lepton_id.dev_lepton_id_t diff --git a/device/kalman/ParKalman/include/MakeLeptonID.cuh b/device/kalman/ParKalman/include/MakeLeptonID.cuh index d60ea7f31f1..8c2f6f653d8 100644 --- a/device/kalman/ParKalman/include/MakeLeptonID.cuh +++ b/device/kalman/ParKalman/include/MakeLeptonID.cuh @@ -12,6 +12,7 @@ #include "SciFiConsolidated.cuh" #include "AlgorithmTypes.cuh" +#include "ParticleTypes.cuh" namespace make_lepton_id { struct Parameters { @@ -19,7 +20,7 @@ namespace make_lepton_id { HOST_INPUT(host_number_of_scifi_tracks_t, unsigned) host_number_of_reconstructed_scifi_tracks; MASK_INPUT(dev_event_list_t) dev_event_list; DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; - DEVICE_INPUT(dev_scifi_tracks_view_t, Allen::Views::SciFi::Consolidated::Tracks) dev_scifi_tracks_view; + DEVICE_INPUT(dev_long_tracks_view_t, Allen::Views::Physics::MultiEventLongTracks) dev_long_tracks_view; DEVICE_INPUT(dev_is_muon_t, bool) dev_is_muon; DEVICE_INPUT(dev_is_electron_t, bool) dev_is_electron; DEVICE_OUTPUT(dev_lepton_id_t, uint8_t) dev_lepton_id; diff --git a/device/kalman/ParKalman/src/MakeLeptonID.cu b/device/kalman/ParKalman/src/MakeLeptonID.cu index 4a626a2ccca..38e37a55234 100644 --- a/device/kalman/ParKalman/src/MakeLeptonID.cu +++ b/device/kalman/ParKalman/src/MakeLeptonID.cu @@ -35,9 +35,10 @@ void make_lepton_id::make_lepton_id_t::operator()( __global__ void make_lepton_id::make_lepton_id(make_lepton_id::Parameters parameters) { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - const auto scifi_tracks = parameters.dev_scifi_tracks_view[event_number]; - const unsigned offset = scifi_tracks.offset(); - const unsigned n_tracks = scifi_tracks.size(); + // Long tracks. + const auto long_tracks = parameters.dev_long_tracks_view->container(event_number); + const unsigned n_tracks = long_tracks.size(); + const unsigned offset = long_tracks.offset(); const auto* event_is_muon = parameters.dev_is_muon + offset; const auto* event_is_electron = parameters.dev_is_electron + offset; auto* event_lepton_id = parameters.dev_lepton_id + offset; -- GitLab From 160ddf305a00b8d942182a50cc02b48666d8a3b6 Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Tue, 9 Aug 2022 19:31:10 +0200 Subject: [PATCH 13/18] fixed warnings --- .../include/ConsolidateSciFiSeedingXZ.cuh | 47 ------------------- .../src/ConsolidateSciFiSeeding.cu | 26 +++++----- .../src/ConsolidateSciFiSeedingXZ.cu | 38 --------------- .../include/hybrid_seeding_helpers.cuh | 16 ++++--- .../include/seed_confirmTracks.cuh | 2 +- .../hybridseeding/src/seed_confirmTracks.cu | 31 ++++++------ device/SciFi/hybridseeding/src/seed_xz.cu | 24 +++++----- .../tools/src/TrackDigitSelectiveMatching.cu | 3 +- .../src/ConsolidateMatchedTracks.cu | 7 ++- .../match/src/TrackMatchingVELOSciFi.cu | 7 +-- main/src/AllenThreads.cpp | 2 +- 11 files changed, 57 insertions(+), 146 deletions(-) delete mode 100644 device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh delete mode 100644 device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu diff --git a/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh b/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh deleted file mode 100644 index 2dacfdfd849..00000000000 --- a/device/SciFi/hybridseeding/consolidate/include/ConsolidateSciFiSeedingXZ.cuh +++ /dev/null @@ -1,47 +0,0 @@ -/*****************************************************************************\ -* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * -\*****************************************************************************/ -#pragma once - -#include "SciFiDefinitions.cuh" -#include "SciFiEventModel.cuh" -#include "AlgorithmTypes.cuh" - -namespace seed_xz_consolidate { - struct Parameters { - HOST_INPUT(host_accumulated_number_of_scifi_hits_t, unsigned) host_accumulated_number_of_scifi_hits; - HOST_INPUT(host_number_of_reconstructed_seeding_tracksXZ_t, unsigned) host_number_of_reconstructed_seeding_tracksXZ; - HOST_INPUT(host_number_of_events_t, unsigned) host_number_of_events; - HOST_INPUT(host_accumulated_number_of_hits_in_scifi_tracksXZ_t, unsigned) - host_accumulated_number_of_hits_in_scifi_tracksXZ; - DEVICE_INPUT(dev_event_list_t, unsigned) dev_event_list; - DEVICE_INPUT(dev_number_of_events_t, unsigned) dev_number_of_events; - DEVICE_INPUT(dev_scifi_hits_t, char) dev_scifi_hits; - DEVICE_INPUT(dev_scifi_hit_count_t, unsigned) dev_scifi_hit_count; - DEVICE_INPUT(dev_offsets_seeding_tracksXZ_t, unsigned) dev_atomics_scifi; // fishy - DEVICE_INPUT(dev_offsets_seeding_XZ_hit_number_t, unsigned) dev_scifi_seed_XZ_hit_number; // fishy - DEVICE_INPUT(dev_seeding_tracksXZ_t, SciFi::Seeding::TrackXZ) dev_seeding_tracksXZ; - - // DEVICE_OUTPUT(dev_seeding_qop_t, float) dev_seeding_qop; - PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim; - }; - __global__ void seed_xz_consolidate(Parameters); - - struct seed_xz_consolidate_t : public DeviceAlgorithm, Parameters { - void set_arguments_size( - ArgumentReferences arguments, - const RuntimeOptions&, - const Constants&, - const HostBuffers&) const; - - void operator()( - const ArgumentReferences& arguments, - const RuntimeOptions& runtime_options, - const Constants& constants, - HostBuffers& host_buffers, - const Allen::Context& context) const; - - private: - Property m_block_dim {this, {{256, 1, 1}}}; - }; -} // namespace seed_xz_consolidate diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index fb3b0fc24e6..1ce5a7f2113 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -71,15 +71,15 @@ __device__ float qop_seeding_calculation(const float magSign, const MiniState se const float m_paramsTCubic[4] = {-6.34025, -4.85287, -12.4491, 4.25461e-08}; float qop = 0.f; - const auto x0 = x - tx * z; + const float x0 = x - tx * z; const auto& params = (tCubicFit ? m_paramsTCubic : m_paramsTParab); const auto p = params[0] + params[1] * tx * tx + params[2] * ty * ty + params[3] * x0 * x0; - const auto scale_factor = 1. * magSign; // is there a way to get the scale_factor from the constants? - const float denom = p * scale_factor * 1e6 * (-1); + const float scale_factor = 1.f * magSign; // is there a way to get the scale_factor from the constants? + const float denom = p * scale_factor * powf(10, 6) * (-1.f); - if (std::abs(scale_factor) < 1e-6) { - qop = 0.01 / Gaudi::Units::GeV; + if (std::fabs(scale_factor) < powf(10, -6)) { + qop = 0.01f / Gaudi::Units::GeV; } else { qop = x0 / denom; @@ -89,9 +89,9 @@ __device__ float qop_seeding_calculation(const float magSign, const MiniState se void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate_t::operator()( const ArgumentReferences& arguments, - const RuntimeOptions& runtime_options, + const RuntimeOptions&, const Constants& constants, - HostBuffers& host_buffers, + HostBuffers&, const Allen::Context& context) const { Allen::memset_async(arguments, 0, context); @@ -120,7 +120,6 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( const unsigned event_number = parameters.dev_event_list[blockIdx.x]; const unsigned number_of_events = parameters.dev_number_of_events[0]; - const unsigned total_number_of_hits = parameters.dev_scifi_hit_count[number_of_events]; const SciFi::Seeding::Track* event_scifi_seeds = parameters.dev_seeding_tracks + event_number * SciFi::Constants::Nmax_seeds; @@ -137,7 +136,6 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( event_number, number_of_events}; const unsigned number_of_tracks_event = scifi_seeds.number_of_tracks(event_number); - const unsigned event_offset = scifi_hit_count.event_offset(); float* tracks_qop = parameters.dev_seeding_qop + parameters.dev_atomics_scifi[event_number]; // Loop over tracks. @@ -161,23 +159,23 @@ __global__ void seed_confirmTracks_consolidate::seed_confirmTracks_consolidate( auto consolidated_hits = scifi_seeds.get_hits(parameters.dev_seeding_track_hits, i); // Populate arrays - populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + populate(scifiseed, [&consolidated_hits, &scifi_hits](const unsigned i, const unsigned hit_index) { consolidated_hits.x0(i) = scifi_hits.x0(hit_index); }); - populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + populate(scifiseed, [&consolidated_hits, &scifi_hits](const unsigned i, const unsigned hit_index) { consolidated_hits.z0(i) = scifi_hits.z0(hit_index); }); - populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + populate(scifiseed, [&consolidated_hits, &scifi_hits](const unsigned i, const unsigned hit_index) { consolidated_hits.endPointY(i) = scifi_hits.endPointY(hit_index); }); - populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + populate(scifiseed, [&consolidated_hits, &scifi_hits](const unsigned i, const unsigned hit_index) { consolidated_hits.channel(i) = scifi_hits.channel(hit_index); }); - populate(scifiseed, [&consolidated_hits, &scifi_hits, &event_offset](const unsigned i, const unsigned hit_index) { + populate(scifiseed, [&consolidated_hits, &scifi_hits](const unsigned i, const unsigned hit_index) { consolidated_hits.assembled_datatype(i) = scifi_hits.assembled_datatype(hit_index); }); } diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu deleted file mode 100644 index 16dec58f9b2..00000000000 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeedingXZ.cu +++ /dev/null @@ -1,38 +0,0 @@ -/*****************************************************************************\ -* (c) Copyright 2018-2020 CERN for the benefit of the LHCb Collaboration * -\*****************************************************************************/ -#include "ConsolidateSciFiSeedingXZ.cuh" - -INSTANTIATE_ALGORITHM(seed_xz_consolidate::seed_xz_consolidate_t); - -void seed_xz_consolidate::seed_xz_consolidate_t::set_arguments_size( - ArgumentReferences arguments, - const RuntimeOptions&, - const Constants&, - const HostBuffers&) const -{ - // set_size(arguments, first(arguments)); -} - -void seed_xz_consolidate::seed_xz_consolidate_t::operator()( - const ArgumentReferences& arguments, - const RuntimeOptions& runtime_options, - const Constants& constants, - HostBuffers& host_buffers, - const Allen::Context& context) const -{ - global_function(seed_xz_consolidate)(dim3(size(arguments)), property(), context)( - arguments); -} - -__global__ void seed_xz_consolidate::seed_xz_consolidate(seed_xz_consolidate::Parameters parameters) -{ - const unsigned number_of_events = parameters.dev_number_of_events[0]; - const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - - const unsigned total_number_of_hits = parameters.dev_scifi_hit_count[number_of_events]; - const SciFi::Seeding::TrackXZ* event_scifi_tracksXZ = - parameters.dev_seeding_tracksXZ + event_number * SciFi::Constants::Nmax_seed_xz; - SciFi::ConstHits scifi_hits {parameters.dev_scifi_hits, total_number_of_hits}; - // SciFi::Consolidated::Tracks -} diff --git a/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh index 8dbf7472431..903f426765f 100644 --- a/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh +++ b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh @@ -19,15 +19,19 @@ namespace hybrid_seeding { constexpr float dRatio = -0.00028f; template - __device__ int binary_search_leftmost_unrolled(const T* array, const unsigned array_size, const T& needle) + __device__ unsigned int binary_search_leftmost_unrolled(const T* array, const unsigned array_size, const T& needle) { - int low = 0; - int size = array_size; + unsigned int low = 0; + unsigned int size = array_size; // Unroll 9 time to cover arrays of size max 512 +#if defined(__clang__) #pragma unroll - for (int step = 0; step < 9; step++) { - int half = size / 2; +#elif defined(__GNUC__) +#pragma GCC unroll 9 +#endif + for (unsigned int step = 0; step < 9; step++) { + unsigned int half = size / 2; low += (array[low + half] < needle) * (size - half); size = half; } // while (size > 0); @@ -61,7 +65,7 @@ namespace seed_xz { }; inline int intIndex(int part, int event_number) { return part + SciFi::Constants::n_parts * event_number; }; - inline int trackIndex(int part, int event_number) { return event_number * SciFi::Constants::Nmax_seed_xz; }; + inline int trackIndex(int event_number) { return event_number * SciFi::Constants::Nmax_seed_xz; }; } // namespace seed_xz namespace seed_uv { diff --git a/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh b/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh index 6bfd8286593..9c7b4c32c72 100644 --- a/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh +++ b/device/SciFi/hybridseeding/include/seed_confirmTracks.cuh @@ -49,7 +49,7 @@ namespace seed_confirmTracks { __device__ int findHit(const float tolRem, float predPos, int startPos, int nHits, float* coords); __global__ void seed_confirmTracks(Parameters); - __device__ bool fitYZ(seed_uv::multiHitCombination& multiHitComb); + __device__ void fitYZ(seed_uv::multiHitCombination& multiHitComb); struct seed_confirmTracks_t : public DeviceAlgorithm, Parameters { void set_arguments_size( diff --git a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu index 7492d816217..c880fb4b5a3 100644 --- a/device/SciFi/hybridseeding/src/seed_confirmTracks.cu +++ b/device/SciFi/hybridseeding/src/seed_confirmTracks.cu @@ -45,7 +45,7 @@ void seed_confirmTracks::seed_confirmTracks_t::set_arguments_size( void seed_confirmTracks::seed_confirmTracks_t::operator()( const ArgumentReferences& arguments, const RuntimeOptions&, - const Constants& constants, + const Constants&, HostBuffers&, const Allen::Context& context) const { @@ -95,7 +95,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) unsigned zone_offset[6]; // Load the hits in shared: unsigned totalHits = 0; - for (int iLayer = 0; iLayer < nLayers; iLayer++) { + for (unsigned int iLayer = 0; iLayer < nLayers; iLayer++) { hits.size[iLayer] = scifi_hit_count.zone_number_of_hits(uvCodes[iLayer]); totalHits += hits.size[iLayer]; } @@ -110,10 +110,10 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) hits.data = ptr; hits.start[0] = 0; - for (int iLayer = 0; iLayer < nLayers; iLayer++) { + for (unsigned int iLayer = 0; iLayer < nLayers; iLayer++) { if (iLayer > 0) hits.start[iLayer] = hits.start[iLayer - 1] + hits.size[iLayer - 1]; zone_offset[iLayer] = scifi_hit_count.zone_offset(uvCodes[iLayer]); - for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + for (unsigned int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { hits.hit(iLayer, iHit) = scifi_hits.x0(zone_offset[iLayer] + iHit); } } @@ -144,7 +144,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) constexpr float TUNING_TOLCHI2 = 100.f; // FIXME constexpr float TUNING_TOL = 2.f; // FIXME const auto xTrack = xTracks[iTrack]; - const int nTarget = TUNING_NHITS - xTrack.number_of_hits; + const unsigned int nTarget = TUNING_NHITS - xTrack.number_of_hits; // Calculate the predicted x(z) position of the track in all U/V layers float xPred[nLayers]; for (unsigned int iLayer = 0; iLayer < nLayers; iLayer++) { @@ -155,8 +155,8 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) float bestChi2Ndof = TUNING_TOLCHI2; seed_uv::multiHitCombination bestHitComb; // For each hit in first layer and tolerance, look for hit combinations that match that hypothesis - int minXPredIdx[nLayers], nIdx[nLayers]; - for (auto iLayer = 0; iLayer < nLayers; iLayer++) { + unsigned int minXPredIdx[nLayers], nIdx[nLayers]; + for (unsigned int iLayer = 0; iLayer < nLayers; iLayer++) { auto minXPred = xPred[iLayer] + dxMin[iLayer]; auto maxXPred = xPred[iLayer] + dxMax[iLayer]; minXPredIdx[iLayer] = @@ -167,7 +167,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) if (maxXPredIdx != hits.size[iLayer]) nIdx[iLayer]++; } // First loop - for (int iHitFirst = minXPredIdx[0]; iHitFirst < minXPredIdx[0] + nIdx[0]; iHitFirst++) { + for (unsigned int iHitFirst = minXPredIdx[0]; iHitFirst < minXPredIdx[0] + nIdx[0]; iHitFirst++) { seed_uv::multiHitCombination hitComb; // We now have a tY hypothesis. We look in all 5 remaining layers for hits close to expected position // this is basically the same thing as looking for the first hit, but with tY in a smaller interval @@ -191,13 +191,13 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) } if (xTrack.number_of_hits + hitComb.number_of_hits < TUNING_NHITS) continue; if (hitComb.number_of_hits < bestHitComb.number_of_hits) continue; - auto fitY = fitYZ(hitComb); + fitYZ(hitComb); if (hitComb.number_of_hits == bestHitComb.number_of_hits && hitComb.chi2 > bestChi2Ndof) continue; bestChi2Ndof = hitComb.chi2; bestHitComb = hitComb; } // Second loop - for (int iHitFirst = minXPredIdx[1]; iHitFirst < minXPredIdx[1] + nIdx[1]; iHitFirst++) { + for (unsigned int iHitFirst = minXPredIdx[1]; iHitFirst < minXPredIdx[1] + nIdx[1]; iHitFirst++) { seed_uv::multiHitCombination hitComb; // We now have a tY hypothesis. We look in all 5 remaining layers for hits close to expected position // this is basically the same thing as looking for the first hit, but with tY in a smaller interval @@ -221,7 +221,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) } } if (xTrack.number_of_hits + hitComb.number_of_hits < TUNING_NHITS) continue; - auto fitY = fitYZ(hitComb); + fitYZ(hitComb); if (hitComb.number_of_hits < bestHitComb.number_of_hits) continue; if (hitComb.number_of_hits == bestHitComb.number_of_hits && hitComb.chi2 > bestChi2Ndof) continue; bestChi2Ndof = hitComb.chi2; @@ -235,7 +235,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) fullTrack.hits[iHit] = xTrack.hits[iHit]; } auto iHit = 0; - for (auto iLayer = 0; iLayer < nLayers; iLayer++) { + for (unsigned iLayer = 0; iLayer < nLayers; iLayer++) { if (bestHitComb.idx[iLayer] == SciFi::Constants::INVALID_IDX) continue; fullTrack.hits[xTrack.number_of_hits + iHit] = scifi_hit_count.zone_offset(uvCodes[iLayer]) + bestHitComb.idx[iLayer]; @@ -264,7 +264,7 @@ __global__ void seed_confirmTracks::seed_confirmTracks(Parameters parameters) } } -__device__ bool seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHitComb) +__device__ void seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHitComb) { float m00 = multiHitComb.number_of_hits; float m01 = 0.f; @@ -274,7 +274,7 @@ __device__ bool seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHit float ay = 0.f; float by = 0.f; // initialize matrix - for (int i = 0; i < seed_uv::geomInfo::nLayers; i++) { + for (unsigned int i = 0; i < seed_uv::geomInfo::nLayers; i++) { if (multiHitComb.idx[i] == SciFi::Constants::INVALID_IDX) continue; m01 += seed_uv::geomInfo::dz[i]; m11 += seed_uv::geomInfo::dz[i] * seed_uv::geomInfo::dz[i]; @@ -286,7 +286,7 @@ __device__ bool seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHit ay += (r0 * m11 - r1 * m01) / detM; by += (r1 * m00 - r0 * m01) / detM; float score = 0.f; - for (int i = 0; i < seed_uv::geomInfo::nLayers; i++) { + for (unsigned int i = 0; i < seed_uv::geomInfo::nLayers; i++) { if (multiHitComb.idx[i] == SciFi::Constants::INVALID_IDX) continue; float hit_chi2 = (multiHitComb.y[i] - (ay + by * seed_uv::geomInfo::dz[i])); hit_chi2 *= hit_chi2; @@ -295,5 +295,4 @@ __device__ bool seed_confirmTracks::fitYZ(seed_uv::multiHitCombination& multiHit multiHitComb.ay = ay; multiHitComb.by = by; multiHitComb.chi2 = score; - return true; } diff --git a/device/SciFi/hybridseeding/src/seed_xz.cu b/device/SciFi/hybridseeding/src/seed_xz.cu index beba53837b2..d7879532b08 100644 --- a/device/SciFi/hybridseeding/src/seed_xz.cu +++ b/device/SciFi/hybridseeding/src/seed_xz.cu @@ -159,12 +159,12 @@ namespace { [[maybe_unused]] unsigned maxTripletPerFirstHit = seeding::Triplet::maxTriplets / hits.size[layers[0]]; (void) maxTripletPerFirstHit; // TODO: remove if [[maybe_unused]] decides to work someday.. - for (int firstHitIdx = threadIdx.x; firstHitIdx < hits.size[layers[0]]; firstHitIdx += blockDim.x) { + for (unsigned int firstHitIdx = threadIdx.x; firstHitIdx < hits.size[layers[0]]; firstHitIdx += blockDim.x) { float xFirst = hits.hit(layers[0], firstHitIdx); float maxXl = xFirst * currentCase.twoHitScale + currentCase.tol2Hit; float minXl = maxXl - 2.f * currentCase.tol2Hit; - [[maybe_unused]] int nCandidates = 0; + [[maybe_unused]] unsigned nCandidates = 0; (void) nCandidates; // TODO: remove if [[maybe_unused]] decides to work someday.. // SPEEDUP: cache last layer first hit @@ -222,7 +222,7 @@ void seed_xz::seed_xz_t::set_arguments_size( void seed_xz::seed_xz_t::operator()( const ArgumentReferences& arguments, const RuntimeOptions&, - const Constants& constants, + const Constants&, HostBuffers&, const Allen::Context& context) const { @@ -255,7 +255,7 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) hybrid_seeding::Case Case1(1, 3, 5, 0, 2, 4, 3000.f, 0.01f); for (unsigned int part = 0; part < SciFi::Constants::n_parts; part++) { - __shared__ int nTracksPart; + __shared__ unsigned nTracksPart; if (threadIdx.x == 0) nTracksPart = 0; // What space do we need to work with ? @@ -291,7 +291,7 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) for (int iLayer = 0; iLayer < 6; iLayer++) { if (iLayer > 0) hits.start[iLayer] = hits.start[iLayer - 1] + hits.size[iLayer - 1]; zone_offset[iLayer] = scifi_hit_count.zone_offset(xLayers[iLayer]); - for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + for (unsigned int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { hits.hit(iLayer, iHit) = scifi_hits.x0(zone_offset[iLayer] + iHit); } } @@ -326,7 +326,7 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) __syncthreads(); } - for (int tripletIdx = threadIdx.x; tripletIdx < nTriplets; tripletIdx += blockDim.x) { + for (unsigned int tripletIdx = threadIdx.x; tripletIdx < nTriplets; tripletIdx += blockDim.x) { seeding::Triplet triplet {triplets[tripletIdx]}; int firstHitIdx = triplet.idx0(); int secondHitIdx = triplet.idx1(); @@ -379,7 +379,7 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) multiHitComb.idx[layers[2]] = thirdHitIdx; auto score = fitXZ(currentCase, multiHitComb); - auto idx = atomicAdd(&nTracksPart, 1); + unsigned idx = atomicAdd(&nTracksPart, 1); if (idx >= maxSeeds) break; reconstructed_tracksXZ_global[nReconstructedTracks + idx] = make_trackXZ( @@ -398,24 +398,24 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) // Clone removal for (int iLayer = 0; iLayer != 6; iLayer++) { - for (int iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { + for (unsigned iHit = threadIdx.x; iHit < hits.size[iLayer]; iHit += blockDim.x) { hits.hit(iLayer, iHit) = 100000.f; } } __syncthreads(); - for (int i = threadIdx.x; i < nTracksPart; i += blockDim.x) { + for (unsigned int i = threadIdx.x; i < nTracksPart; i += blockDim.x) { auto& track = reconstructed_tracksXZ_global[nReconstructedTracks + i]; for (int iLayer = 0; iLayer < 6; iLayer++) { auto hit = track.idx[iLayer]; if (hit == SciFi::Constants::INVALID_IDX) continue; - atomicMin((int*) &hits.hit(iLayer, hit), __float_as_int(track.chi2 * 1000 + track.cx)); + atomicMin((int*) &hits.hit(iLayer, hit), __float_as_int(track.chi2 * 1000.f + track.cx)); } } __shared__ int nFilteredTracks; if (threadIdx.x == 0) nFilteredTracks = 0; __syncthreads(); - for (int i = 0; i < nTracksPart; i += blockDim.x) { + for (unsigned int i = 0; i < nTracksPart; i += blockDim.x) { int nHits = 0; SciFi::Seeding::TrackXZ track; if (i + threadIdx.x < nTracksPart) { @@ -423,7 +423,7 @@ __global__ void seed_xz::seed_xz(seed_xz::Parameters parameters) for (int iLayer = 0; iLayer < 6; iLayer++) { auto hit = track.idx[iLayer]; if (hit == SciFi::Constants::INVALID_IDX) continue; - nHits += fabs(hits.hit(iLayer, hit) - (track.chi2 * 1000 + track.cx)) < 0.01f; + nHits += std::fabs(hits.hit(iLayer, hit) - (track.chi2 * 1000.f + track.cx)) < 0.01f; } } __syncthreads(); diff --git a/device/calo/tools/src/TrackDigitSelectiveMatching.cu b/device/calo/tools/src/TrackDigitSelectiveMatching.cu index 5b1e9b5587a..3ef906373f5 100644 --- a/device/calo/tools/src/TrackDigitSelectiveMatching.cu +++ b/device/calo/tools/src/TrackDigitSelectiveMatching.cu @@ -43,7 +43,6 @@ __global__ void track_digit_selective_matching::track_digit_selective_matching( const char* raw_ecal_geometry) { - const unsigned number_of_events = parameters.dev_number_of_events[0]; const unsigned event_number = parameters.dev_event_list[blockIdx.x]; // Long tracks. const auto long_tracks = parameters.dev_long_tracks_view->container(event_number); @@ -111,6 +110,6 @@ __global__ void track_digit_selective_matching::track_digit_selective_matching( sum_cell_E * fabsf(long_track.qop()); // Bit shift by 1 so this can be combined with the muon ID to create a single lepton ID object. parameters.dev_track_isElectron[track_index + event_offset] = - (parameters.dev_track_Eop[track_index + event_offset] > 0.7f) << 1; + (parameters.dev_track_Eop[track_index + event_offset] > 0.7f); } } diff --git a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu index e83b3e14ae3..4b76229b820 100644 --- a/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu +++ b/device/track_matching/consolidate/src/ConsolidateMatchedTracks.cu @@ -53,9 +53,9 @@ void matching_consolidate_tracks::matching_consolidate_tracks_t::set_arguments_s void matching_consolidate_tracks::matching_consolidate_tracks_t::operator()( const ArgumentReferences& arguments, - const RuntimeOptions& runtime_options, - const Constants& constants, - HostBuffers& host_buffers, + const RuntimeOptions&, + const Constants&, + HostBuffers&, const Allen::Context& context) const { global_function(matching_consolidate_tracks)( @@ -68,7 +68,6 @@ __global__ void matching_consolidate_tracks::matching_consolidate_tracks( matching_consolidate_tracks::Parameters parameters) { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - const unsigned number_of_events = parameters.dev_number_of_events[0]; const SciFi::MatchedTrack* event_matched_tracks = parameters.dev_matched_tracks + event_number * TrackMatchingConsts::max_num_tracks; diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index 11e2fecf29d..e6fd5e718a5 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -34,7 +34,7 @@ void track_matching_veloSciFi::track_matching_veloSciFi_t::operator()( __device__ track_matching::MatchingResult getChi2Match( const MiniState velo_state, const MiniState scifi_state, - track_matching_veloSciFi::Parameters parameters, + track_matching_veloSciFi::Parameters, const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) { @@ -103,7 +103,7 @@ __device__ float computeQoverP(const float txV, const float tyV, const float txT const float coef = 1.21352f + 0.626691f * txT2 - 0.202483f * txT4 + 0.426262f * txT * txV + 2.47057f * tyV2 - 13.2917f * tyV4; - const float proj = sqrt((1.f + txV2 + tyV2) / (1.f + txV2)); + const float proj = sqrtf((1.f + txV2 + tyV2) / (1.f + txV2)); const float scaleFactor = 1.f; // FIXME magnet sign return (txV - txT) / (coef * 1000.f * proj * scaleFactor); @@ -114,14 +114,12 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; - const unsigned number_of_events = parameters.dev_number_of_events[0]; // Velo views const auto velo_tracks = parameters.dev_velo_tracks_view[event_number]; const auto velo_states = parameters.dev_velo_states_view[event_number]; const unsigned event_velo_seeds_offset = velo_tracks.offset(); - const unsigned number_of_velo_seeds = velo_states.size(); // filtered velo tracks const auto ut_number_of_selected_tracks = parameters.dev_ut_number_of_selected_velo_tracks[event_number]; @@ -158,7 +156,6 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( for (unsigned ivelo = 0; ivelo < ut_number_of_selected_tracks; ivelo++) { const auto velo_track_index = ut_selected_velo_tracks[ivelo]; - const auto velo_track = velo_tracks.track(velo_track_index); const auto endvelo_state = velo_states.state(velo_track_index); auto matchingInfo = getChi2Match(endvelo_state, scifi_state, parameters, dev_magnet_parametrization); if (matchingInfo.chi2 < BestMatch.chi2) { diff --git a/main/src/AllenThreads.cpp b/main/src/AllenThreads.cpp index dd21ce01dec..575baee1203 100644 --- a/main/src/AllenThreads.cpp +++ b/main/src/AllenThreads.cpp @@ -247,7 +247,7 @@ void run_stream( unsigned n_reps, bool mep_layout, uint inject_mem_fail, - bool prefer_shared) + [[maybe_unused]] bool prefer_shared) { Allen::set_device(device_id, stream_id); -- GitLab From 13d5885083426856fc4bd1099c069f32ad7ed2a7 Mon Sep 17 00:00:00 2001 From: Kate Richardson Date: Tue, 16 Aug 2022 12:34:51 +0200 Subject: [PATCH 14/18] matching qop with magSign and warning fixes --- configuration/python/AllenConf/validators.py | 8 ++++---- .../consolidate/src/ConsolidateSciFiSeeding.cu | 4 ++-- .../include/hybrid_seeding_helpers.cuh | 2 +- .../calo/tools/src/TrackDigitSelectiveMatching.cu | 7 ++----- .../match/include/TrackMatchingVELOSciFi.cuh | 1 + .../match/src/TrackMatchingVELOSciFi.cu | 14 ++++++++------ 6 files changed, 18 insertions(+), 18 deletions(-) diff --git a/configuration/python/AllenConf/validators.py b/configuration/python/AllenConf/validators.py index 97bcdae679f..82fedde9d1e 100644 --- a/configuration/python/AllenConf/validators.py +++ b/configuration/python/AllenConf/validators.py @@ -5,13 +5,13 @@ from AllenAlgorithms.algorithms import ( mc_data_provider_t, host_velo_validator_t, host_velo_ut_validator_t, long_track_validator_t, muon_validator_t, host_pv_validator_t, host_rate_validator_t, host_routingbits_validator_t, kalman_validator_t, - host_seeding_XZ_validator_t, host_seeding_validator_t, host_veloscifi_dump_t, - host_data_provider_t, host_sel_report_validator_t) + host_seeding_XZ_validator_t, host_seeding_validator_t, + host_veloscifi_dump_t, host_data_provider_t, host_sel_report_validator_t) from AllenConf.utils import initialize_number_of_events from AllenCore.generator import make_algorithm from AllenConf.persistency import make_dec_reporter, make_gather_selections, make_routingbits_writer, rb_map -from AllenAlgorithms.algorithms import ( - host_prefix_sum_t, seeding_copy_trackXZ_hit_number_t) +from AllenAlgorithms.algorithms import (host_prefix_sum_t, + seeding_copy_trackXZ_hit_number_t) from AllenConf.scifi_reconstruction import decode_scifi, make_seeding_XZ_tracks diff --git a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu index 1ce5a7f2113..5a6ed44c117 100644 --- a/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu +++ b/device/SciFi/hybridseeding/consolidate/src/ConsolidateSciFiSeeding.cu @@ -76,9 +76,9 @@ __device__ float qop_seeding_calculation(const float magSign, const MiniState se const auto p = params[0] + params[1] * tx * tx + params[2] * ty * ty + params[3] * x0 * x0; const float scale_factor = 1.f * magSign; // is there a way to get the scale_factor from the constants? - const float denom = p * scale_factor * powf(10, 6) * (-1.f); + const float denom = p * scale_factor * 1e6f * (-1.f); - if (std::fabs(scale_factor) < powf(10, -6)) { + if (std::fabs(scale_factor) < 1e-6f) { qop = 0.01f / Gaudi::Units::GeV; } else { diff --git a/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh index 903f426765f..4698cdb873b 100644 --- a/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh +++ b/device/SciFi/hybridseeding/include/hybrid_seeding_helpers.cuh @@ -25,7 +25,7 @@ namespace hybrid_seeding { unsigned int size = array_size; // Unroll 9 time to cover arrays of size max 512 -#if defined(__clang__) +#if defined(__clang__) or defined(__NVCC__) #pragma unroll #elif defined(__GNUC__) #pragma GCC unroll 9 diff --git a/device/calo/tools/src/TrackDigitSelectiveMatching.cu b/device/calo/tools/src/TrackDigitSelectiveMatching.cu index 3ef906373f5..985a860576a 100644 --- a/device/calo/tools/src/TrackDigitSelectiveMatching.cu +++ b/device/calo/tools/src/TrackDigitSelectiveMatching.cu @@ -105,11 +105,8 @@ __global__ void track_digit_selective_matching::track_digit_selective_matching( parameters.dev_matched_ecal_digits[track_index + event_offset] = digit_indices; parameters.dev_matched_ecal_digits_size[track_index + event_offset] = N_matched_digits; parameters.dev_track_inEcalAcc[track_index + event_offset] = inAcc; - parameters.dev_track_Eop[track_index + event_offset] = - // sum_cell_E * fabsf(scifi_tracks.qop(track_index)); - sum_cell_E * fabsf(long_track.qop()); - // Bit shift by 1 so this can be combined with the muon ID to create a single lepton ID object. + parameters.dev_track_Eop[track_index + event_offset] = sum_cell_E * fabsf(long_track.qop()); parameters.dev_track_isElectron[track_index + event_offset] = - (parameters.dev_track_Eop[track_index + event_offset] > 0.7f); + parameters.dev_track_Eop[track_index + event_offset] > 0.7f; } } diff --git a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh index 53c829c3655..79cf3f90a10 100644 --- a/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh +++ b/device/track_matching/match/include/TrackMatchingVELOSciFi.cuh @@ -34,6 +34,7 @@ namespace track_matching_veloSciFi { }; __global__ void track_matching_veloSciFi( Parameters, + const float* dev_magnet_polarity, const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization); struct track_matching_veloSciFi_t : public DeviceAlgorithm, Parameters { diff --git a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu index e6fd5e718a5..74e328f6de9 100644 --- a/device/track_matching/match/src/TrackMatchingVELOSciFi.cu +++ b/device/track_matching/match/src/TrackMatchingVELOSciFi.cu @@ -27,14 +27,13 @@ void track_matching_veloSciFi::track_matching_veloSciFi_t::operator()( Allen::memset_async(arguments, 0, context); global_function(track_matching_veloSciFi)(dim3(size(arguments)), dim3(128), context)( - arguments, constants.dev_magnet_parametrization); + arguments, constants.dev_magnet_polarity.data(), constants.dev_magnet_parametrization); } // inspired from https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Pr/PrAlgorithms/src/PrMatchNN.cpp __device__ track_matching::MatchingResult getChi2Match( const MiniState velo_state, const MiniState scifi_state, - track_matching_veloSciFi::Parameters, const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) { @@ -93,7 +92,7 @@ __device__ track_matching::MatchingResult getChi2Match( } // https://gitlab.cern.ch/lhcb/Rec/-/blob/master/Tr/TrackTools/src/FastMomentumEstimate.cpp#L142 -__device__ float computeQoverP(const float txV, const float tyV, const float txT) +__device__ float computeQoverP(const float txV, const float tyV, const float txT, const float magSign) { const float txT2 = txT * txT; const float txT4 = txT2 * txT2; @@ -104,13 +103,14 @@ __device__ float computeQoverP(const float txV, const float tyV, const float txT 1.21352f + 0.626691f * txT2 - 0.202483f * txT4 + 0.426262f * txT * txV + 2.47057f * tyV2 - 13.2917f * tyV4; const float proj = sqrtf((1.f + txV2 + tyV2) / (1.f + txV2)); - const float scaleFactor = 1.f; // FIXME magnet sign + const float scaleFactor = 1.f * magSign; return (txV - txT) / (coef * 1000.f * proj * scaleFactor); } __global__ void track_matching_veloSciFi::track_matching_veloSciFi( track_matching_veloSciFi::Parameters parameters, + const float* dev_magnet_polarity, const TrackMatchingConsts::MagnetParametrization* dev_magnet_parametrization) { const unsigned event_number = parameters.dev_event_list[blockIdx.x]; @@ -157,7 +157,7 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( const auto velo_track_index = ut_selected_velo_tracks[ivelo]; const auto endvelo_state = velo_states.state(velo_track_index); - auto matchingInfo = getChi2Match(endvelo_state, scifi_state, parameters, dev_magnet_parametrization); + auto matchingInfo = getChi2Match(endvelo_state, scifi_state, dev_magnet_parametrization); if (matchingInfo.chi2 < BestMatch.chi2) { BestMatch = {static_cast(velo_track_index), matchingInfo.chi2}; } @@ -177,7 +177,9 @@ __global__ void track_matching_veloSciFi::track_matching_veloSciFi( matched_track.chi2_matching = BestMatch.chi2; const auto endvelo_state = velo_states.state(BestMatch.ivelo); - matched_track.qop = computeQoverP(endvelo_state.tx(), endvelo_state.ty(), scifi_state.tx); + + const auto magSign = dev_magnet_polarity[0]; + matched_track.qop = computeQoverP(endvelo_state.tx(), endvelo_state.ty(), scifi_state.tx, magSign); } __syncthreads(); -- GitLab From c02bd0ce78c5cef19f6c92d09297459f79ff36ab Mon Sep 17 00:00:00 2001 From: Arthur Hennequin Date: Thu, 18 Aug 2022 10:23:01 +0200 Subject: [PATCH 15/18] Update references --- ...r_v1_hlt1_pp_matching_validation_a5000.txt | 217 ++++++++++++++++++ ...1_hlt1_pp_matching_validation_epyc7502.txt | 217 ++++++++++++++++++ ...p_matching_validation_geforcertx2080ti.txt | 217 ++++++++++++++++++ ..._pp_matching_validation_geforcertx3090.txt | 217 ++++++++++++++++++ ...inacluster_v1_hlt1_pp_validation_a5000.txt | 6 + ...cluster_v1_hlt1_pp_validation_epyc7502.txt | 6 + ...v1_hlt1_pp_validation_geforcertx2080ti.txt | 6 + ...r_v1_hlt1_pp_validation_geforcertx3090.txt | 8 +- 8 files changed, 893 insertions(+), 1 deletion(-) create mode 100644 test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt create mode 100644 test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt create mode 100644 test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt create mode 100644 test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt new file mode 100644 index 00000000000..d785a59af82 --- /dev/null +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt @@ -0,0 +1,217 @@ +velo_validator validation: +TrackChecker output : 2219/ 257248 0.86% ghosts +01_velo : 108923/ 110735 98.36% ( 98.41%), 2339 ( 2.10%) clones, pur 99.68%, hit eff 96.70% +02_long : 62459/ 62831 99.41% ( 99.45%), 984 ( 1.55%) clones, pur 99.78%, hit eff 97.76% +03_long_P>5GeV : 39426/ 39563 99.65% ( 99.66%), 517 ( 1.29%) clones, pur 99.81%, hit eff 98.29% +04_long_strange : 2833/ 2892 97.96% ( 98.44%), 43 ( 1.50%) clones, pur 99.40%, hit eff 97.34% +05_long_strange_P>5GeV : 1318/ 1341 98.28% ( 98.61%), 10 ( 0.75%) clones, pur 99.31%, hit eff 98.63% +06_long_fromB : 3904/ 3937 99.16% ( 99.34%), 53 ( 1.34%) clones, pur 99.67%, hit eff 97.87% +07_long_fromB_P>5GeV : 3236/ 3252 99.51% ( 99.53%), 36 ( 1.10%) clones, pur 99.71%, hit eff 98.26% +08_long_electrons : 4604/ 4744 97.05% ( 96.96%), 138 ( 2.91%) clones, pur 98.02%, hit eff 96.68% +09_long_fromB_electrons : 182/ 190 95.79% ( 96.06%), 11 ( 5.70%) clones, pur 98.10%, hit eff 96.62% +10_long_fromB_electrons_P>5GeV : 122/ 126 96.83% ( 97.44%), 9 ( 6.87%) clones, pur 98.61%, hit eff 97.12% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.928 ( 4821/ 5194) +Isolated : 0.964 ( 2597/ 2694) +Close : 0.890 ( 2224/ 2500) +False rate : 0.014 ( 69/ 4890) +Real false rate : 0.014 ( 69/ 4890) +Clones : 0.000 ( 0/ 4821) + + +seed_validator validation: +TrackChecker output : 10213/ 89087 11.46% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 22443/ 24958 89.92% ( 90.77%), 4 ( 0.02%) clones, pur 98.93%, hit eff 96.30% +01_long : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +---1. phi quadrant : 11824/ 15521 76.18% ( 76.93%), 5 ( 0.04%) clones, pur 99.00%, hit eff 95.94% +---2. phi quadrant : 11989/ 15853 75.63% ( 76.68%), 3 ( 0.03%) clones, pur 99.00%, hit eff 95.95% +---3. phi quadrant : 12018/ 15850 75.82% ( 76.24%), 2 ( 0.02%) clones, pur 98.94%, hit eff 95.90% +---4. phi quadrant : 12014/ 15606 76.98% ( 77.73%), 3 ( 0.02%) clones, pur 98.97%, hit eff 95.96% +---eta < 2.5, small x, large y : 585/ 2162 27.06% ( 25.09%), 0 ( 0.00%) clones, pur 97.76%, hit eff 94.89% +---eta < 2.5, large x, small y : 1990/ 4318 46.09% ( 45.52%), 0 ( 0.00%) clones, pur 98.76%, hit eff 94.98% +---eta > 2.5, small x, large y : 16619/ 20365 81.61% ( 82.44%), 7 ( 0.04%) clones, pur 99.01%, hit eff 96.14% +---eta > 2.5, large x, small y : 28652/ 35986 79.62% ( 80.39%), 6 ( 0.02%) clones, pur 98.99%, hit eff 95.91% +02_long_P>5GeV : 36616/ 39563 92.55% ( 93.46%), 6 ( 0.02%) clones, pur 98.99%, hit eff 96.57% +02_long_P>5GeV, eta > 4 : 15411/ 16931 91.02% ( 92.31%), 0 ( 0.00%) clones, pur 98.84%, hit eff 96.58% +---eta < 2.5, small x, large y : 349/ 483 72.26% ( 72.67%), 0 ( 0.00%) clones, pur 98.32%, hit eff 96.63% +---eta < 2.5, large x, small y : 1020/ 1076 94.80% ( 94.70%), 0 ( 0.00%) clones, pur 99.28%, hit eff 96.32% +---eta > 2.5, small x, large y : 13102/ 14024 93.43% ( 94.49%), 4 ( 0.03%) clones, pur 99.01%, hit eff 96.60% +---eta > 2.5, large x, small y : 22145/ 23980 92.35% ( 93.23%), 2 ( 0.01%) clones, pur 98.98%, hit eff 96.57% +03_long_P>3GeV : 47831/ 52954 90.33% ( 91.13%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +04_long_P>0.5GeV : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +05_long_from_B : 3418/ 3937 86.82% ( 87.02%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +06_long_from_B_P>5GeV : 3058/ 3252 94.03% ( 94.01%), 0 ( 0.00%) clones, pur 99.07%, hit eff 96.90% +07_long_from_B_P>3GeV : 3418/ 3690 92.63% ( 92.27%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +08_UT+SciFi : 4874/ 8025 60.74% ( 60.50%), 1 ( 0.02%) clones, pur 98.78%, hit eff 94.92% +09_UT+SciFi_P>5GeV : 3014/ 3258 92.51% ( 92.98%), 1 ( 0.03%) clones, pur 98.90%, hit eff 96.14% +10_UT+SciFi_P>3GeV : 4834/ 5504 87.83% ( 88.36%), 1 ( 0.02%) clones, pur 98.79%, hit eff 94.97% +11_UT+SciFi_fromStrange : 1976/ 2779 71.10% ( 69.10%), 0 ( 0.00%) clones, pur 99.08%, hit eff 95.68% +12_UT+SciFi_fromStrange_P>5GeV : 1415/ 1530 92.48% ( 91.81%), 0 ( 0.00%) clones, pur 99.06%, hit eff 96.36% +13_UT+SciFi_fromStrange_P>3GeV : 1970/ 2177 90.49% ( 90.24%), 0 ( 0.00%) clones, pur 99.09%, hit eff 95.69% +14_long_electrons : 2399/ 4744 50.57% ( 50.79%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +15_long_electrons_P>5GeV : 1758/ 2357 74.59% ( 74.92%), 1 ( 0.06%) clones, pur 99.14%, hit eff 96.14% +16_long_electrons_P>3GeV : 2399/ 3767 63.68% ( 64.36%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +17_long_fromB_electrons : 115/ 190 60.53% ( 61.64%), 0 ( 0.00%) clones, pur 99.33%, hit eff 96.20% +18_long_fromB_electrons_P>5GeV : 98/ 126 77.78% ( 80.29%), 0 ( 0.00%) clones, pur 99.38%, hit eff 96.61% +19_long_PT>2GeV : 1760/ 1897 92.78% ( 92.95%), 0 ( 0.00%) clones, pur 99.11%, hit eff 97.07% +20_long_from_B_PT>2GeV : 820/ 877 93.50% ( 93.49%), 0 ( 0.00%) clones, pur 99.12%, hit eff 97.01% +21_long_strange_P>5GeV : 1262/ 1341 94.11% ( 93.91%), 0 ( 0.00%) clones, pur 98.95%, hit eff 96.70% +22_long_strange_P>5GeV_PT>500MeV : 440/ 466 94.42% ( 94.25%), 0 ( 0.00%) clones, pur 98.68%, hit eff 96.24% + + +long_validator validation: +TrackChecker output : 5078/ 52023 9.76% ghosts +for P>3GeV,Pt>0.5GeV : 1225/ 22963 5.33% ghosts +01_long : 43914/ 62831 69.89% ( 70.96%), 1 ( 0.00%) clones, pur 99.49%, hit eff 96.25% +02_long_P>5GeV : 34521/ 39563 87.26% ( 88.47%), 1 ( 0.00%) clones, pur 99.50%, hit eff 96.81% +03_long_strange : 1681/ 2892 58.13% ( 57.82%), 0 ( 0.00%) clones, pur 99.43%, hit eff 96.18% +04_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +05_long_fromB : 3260/ 3937 82.80% ( 83.23%), 0 ( 0.00%) clones, pur 99.48%, hit eff 96.82% +06_long_fromB_P>5GeV : 2957/ 3252 90.93% ( 90.96%), 0 ( 0.00%) clones, pur 99.49%, hit eff 97.09% +07_long_electrons : 1672/ 4744 35.24% ( 36.20%), 0 ( 0.00%) clones, pur 98.99%, hit eff 95.82% +08_long_electrons_P>5GeV : 1273/ 2357 54.01% ( 55.54%), 0 ( 0.00%) clones, pur 99.04%, hit eff 96.37% +09_long_fromB_electrons : 96/ 190 50.53% ( 53.98%), 0 ( 0.00%) clones, pur 99.29%, hit eff 96.14% +10_long_fromB_electrons_P>5GeV : 85/ 126 67.46% ( 70.99%), 0 ( 0.00%) clones, pur 99.27%, hit eff 96.48% +long_P>5GeV_AND_Pt>1GeV : 7060/ 7884 89.55% ( 90.36%), 1 ( 0.01%) clones, pur 99.51%, hit eff 97.05% +long_fromB_P>5GeV_AND_Pt>1GeV : 1846/ 2026 91.12% ( 90.61%), 0 ( 0.00%) clones, pur 99.54%, hit eff 97.41% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1715/ 1897 90.41% ( 90.76%), 1 ( 0.06%) clones, pur 99.50%, hit eff 97.32% +14_long_from_B_PT>2GeV : 800/ 877 91.22% ( 91.12%), 0 ( 0.00%) clones, pur 99.45%, hit eff 97.28% +15_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +16_long_strange_P>5GeV_PT>500MeV : 416/ 466 89.27% ( 89.76%), 0 ( 0.00%) clones, pur 99.17%, hit eff 96.61% + + +muon_validator validation: +Muon fraction in all MCPs: 12755/ 941546 0.01% +Muon fraction in MCPs to which a track(s) was matched: 571/ 54394 0.01% +Correctly identified muons with isMuon: 520/ 571 91.07% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 99/ 110 90.00% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 7318/ 53823 13.60% +Ghost tracks identified as muon with isMuon: 963/ 5078 18.96% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 567/ 1000, (17010.00 +/- 470.06) kHz +Hlt1KsToPiPi: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1TrackMVA: 185/ 1000, ( 5550.00 +/- 368.37) kHz +Hlt1TwoTrackMVA: 438/ 1000, (13140.00 +/- 470.68) kHz +Hlt1TwoTrackKs: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtMuon: 251/ 1000, ( 7530.00 +/- 411.34) kHz +Hlt1D2KK: 20/ 1000, ( 600.00 +/- 132.82) kHz +Hlt1D2KPi: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1D2PiPi: 21/ 1000, ( 630.00 +/- 136.03) kHz +Hlt1DiMuonHighMass: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- 221.75) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz +Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz +Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz +Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 567 1466 +Hlt1KsToPiPi: 41 43 +Hlt1TrackMVA: 185 267 +Hlt1TwoTrackMVA: 438 1212 +Hlt1TwoTrackKs: 4 4 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 2 2 +Hlt1LowPtMuon: 251 327 +Hlt1D2KK: 20 22 +Hlt1D2KPi: 26 27 +Hlt1D2PiPi: 21 21 +Hlt1DiMuonHighMass: 16 18 +Hlt1DiMuonLowMass: 58 68 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 170 276 +Hlt1TrackMuonMVA: 11 11 +Hlt1TrackElectronMVA: 33 36 +Hlt1SingleHighPtElectron: 9 9 +Hlt1DisplacedDielectron: 12 13 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 29 0 +Hlt1SingleHighEt: 0 0 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 887 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 1 0 +Hlt1RICH1Alignment: 1 1 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 + +Total decisions: 3826 +Total tracks: 3357 +Total SVs: 2611 +Total hits: 69259 +Total stdinfo: 41126 + diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt new file mode 100644 index 00000000000..2fefcfe44af --- /dev/null +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt @@ -0,0 +1,217 @@ +velo_validator validation: +TrackChecker output : 2191/ 257219 0.85% ghosts +01_velo : 108919/ 110735 98.36% ( 98.41%), 2320 ( 2.09%) clones, pur 99.68%, hit eff 96.72% +02_long : 62453/ 62831 99.40% ( 99.44%), 974 ( 1.54%) clones, pur 99.79%, hit eff 97.77% +03_long_P>5GeV : 39425/ 39563 99.65% ( 99.66%), 516 ( 1.29%) clones, pur 99.82%, hit eff 98.29% +04_long_strange : 2833/ 2892 97.96% ( 98.44%), 43 ( 1.50%) clones, pur 99.40%, hit eff 97.31% +05_long_strange_P>5GeV : 1318/ 1341 98.28% ( 98.60%), 10 ( 0.75%) clones, pur 99.31%, hit eff 98.60% +06_long_fromB : 3903/ 3937 99.14% ( 99.33%), 54 ( 1.36%) clones, pur 99.69%, hit eff 97.87% +07_long_fromB_P>5GeV : 3236/ 3252 99.51% ( 99.53%), 37 ( 1.13%) clones, pur 99.73%, hit eff 98.26% +08_long_electrons : 4605/ 4744 97.07% ( 97.02%), 140 ( 2.95%) clones, pur 98.08%, hit eff 96.68% +09_long_fromB_electrons : 182/ 190 95.79% ( 96.06%), 11 ( 5.70%) clones, pur 98.13%, hit eff 96.53% +10_long_fromB_electrons_P>5GeV : 122/ 126 96.83% ( 97.44%), 9 ( 6.87%) clones, pur 98.56%, hit eff 97.06% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.929 ( 4827/ 5194) +Isolated : 0.965 ( 2599/ 2694) +Close : 0.891 ( 2228/ 2500) +False rate : 0.013 ( 65/ 4892) +Real false rate : 0.013 ( 65/ 4892) +Clones : 0.000 ( 0/ 4827) + + +seed_validator validation: +TrackChecker output : 10212/ 89085 11.46% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 22443/ 24958 89.92% ( 90.77%), 4 ( 0.02%) clones, pur 98.93%, hit eff 96.30% +01_long : 47846/ 62831 76.15% ( 76.93%), 12 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +---1. phi quadrant : 11824/ 15521 76.18% ( 76.93%), 5 ( 0.04%) clones, pur 99.00%, hit eff 95.94% +---2. phi quadrant : 11989/ 15853 75.63% ( 76.68%), 3 ( 0.03%) clones, pur 99.00%, hit eff 95.95% +---3. phi quadrant : 12018/ 15850 75.82% ( 76.24%), 2 ( 0.02%) clones, pur 98.94%, hit eff 95.90% +---4. phi quadrant : 12014/ 15606 76.98% ( 77.73%), 2 ( 0.02%) clones, pur 98.97%, hit eff 95.97% +---eta < 2.5, small x, large y : 585/ 2162 27.06% ( 25.09%), 0 ( 0.00%) clones, pur 97.76%, hit eff 94.89% +---eta < 2.5, large x, small y : 1990/ 4318 46.09% ( 45.52%), 0 ( 0.00%) clones, pur 98.76%, hit eff 94.98% +---eta > 2.5, small x, large y : 16619/ 20365 81.61% ( 82.44%), 6 ( 0.04%) clones, pur 99.02%, hit eff 96.15% +---eta > 2.5, large x, small y : 28652/ 35986 79.62% ( 80.39%), 6 ( 0.02%) clones, pur 98.99%, hit eff 95.91% +02_long_P>5GeV : 36616/ 39563 92.55% ( 93.46%), 6 ( 0.02%) clones, pur 98.99%, hit eff 96.57% +02_long_P>5GeV, eta > 4 : 15411/ 16931 91.02% ( 92.31%), 0 ( 0.00%) clones, pur 98.84%, hit eff 96.58% +---eta < 2.5, small x, large y : 349/ 483 72.26% ( 72.67%), 0 ( 0.00%) clones, pur 98.32%, hit eff 96.63% +---eta < 2.5, large x, small y : 1020/ 1076 94.80% ( 94.70%), 0 ( 0.00%) clones, pur 99.28%, hit eff 96.32% +---eta > 2.5, small x, large y : 13102/ 14024 93.43% ( 94.49%), 4 ( 0.03%) clones, pur 99.01%, hit eff 96.60% +---eta > 2.5, large x, small y : 22145/ 23980 92.35% ( 93.23%), 2 ( 0.01%) clones, pur 98.98%, hit eff 96.57% +03_long_P>3GeV : 47831/ 52954 90.33% ( 91.13%), 12 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +04_long_P>0.5GeV : 47846/ 62831 76.15% ( 76.93%), 12 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +05_long_from_B : 3418/ 3937 86.82% ( 87.02%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +06_long_from_B_P>5GeV : 3058/ 3252 94.03% ( 94.01%), 0 ( 0.00%) clones, pur 99.07%, hit eff 96.90% +07_long_from_B_P>3GeV : 3418/ 3690 92.63% ( 92.27%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +08_UT+SciFi : 4874/ 8025 60.74% ( 60.50%), 1 ( 0.02%) clones, pur 98.78%, hit eff 94.92% +09_UT+SciFi_P>5GeV : 3014/ 3258 92.51% ( 92.98%), 1 ( 0.03%) clones, pur 98.90%, hit eff 96.14% +10_UT+SciFi_P>3GeV : 4834/ 5504 87.83% ( 88.36%), 1 ( 0.02%) clones, pur 98.79%, hit eff 94.97% +11_UT+SciFi_fromStrange : 1976/ 2779 71.10% ( 69.10%), 0 ( 0.00%) clones, pur 99.08%, hit eff 95.68% +12_UT+SciFi_fromStrange_P>5GeV : 1415/ 1530 92.48% ( 91.81%), 0 ( 0.00%) clones, pur 99.06%, hit eff 96.36% +13_UT+SciFi_fromStrange_P>3GeV : 1970/ 2177 90.49% ( 90.24%), 0 ( 0.00%) clones, pur 99.09%, hit eff 95.69% +14_long_electrons : 2399/ 4744 50.57% ( 50.79%), 1 ( 0.04%) clones, pur 99.04%, hit eff 95.49% +15_long_electrons_P>5GeV : 1758/ 2357 74.59% ( 74.92%), 1 ( 0.06%) clones, pur 99.14%, hit eff 96.14% +16_long_electrons_P>3GeV : 2399/ 3767 63.68% ( 64.36%), 1 ( 0.04%) clones, pur 99.04%, hit eff 95.49% +17_long_fromB_electrons : 115/ 190 60.53% ( 61.64%), 0 ( 0.00%) clones, pur 99.33%, hit eff 96.20% +18_long_fromB_electrons_P>5GeV : 98/ 126 77.78% ( 80.29%), 0 ( 0.00%) clones, pur 99.38%, hit eff 96.61% +19_long_PT>2GeV : 1760/ 1897 92.78% ( 92.95%), 0 ( 0.00%) clones, pur 99.11%, hit eff 97.07% +20_long_from_B_PT>2GeV : 820/ 877 93.50% ( 93.49%), 0 ( 0.00%) clones, pur 99.12%, hit eff 97.01% +21_long_strange_P>5GeV : 1262/ 1341 94.11% ( 93.91%), 0 ( 0.00%) clones, pur 98.95%, hit eff 96.70% +22_long_strange_P>5GeV_PT>500MeV : 440/ 466 94.42% ( 94.25%), 0 ( 0.00%) clones, pur 98.68%, hit eff 96.24% + + +long_validator validation: +TrackChecker output : 5052/ 52053 9.71% ghosts +for P>3GeV,Pt>0.5GeV : 1218/ 22959 5.31% ghosts +01_long : 43950/ 62831 69.95% ( 71.00%), 1 ( 0.00%) clones, pur 99.49%, hit eff 96.24% +02_long_P>5GeV : 34550/ 39563 87.33% ( 88.53%), 1 ( 0.00%) clones, pur 99.50%, hit eff 96.81% +03_long_strange : 1691/ 2892 58.47% ( 57.99%), 0 ( 0.00%) clones, pur 99.42%, hit eff 96.19% +04_long_strange_P>5GeV : 1149/ 1341 85.68% ( 86.35%), 0 ( 0.00%) clones, pur 99.36%, hit eff 96.97% +05_long_fromB : 3260/ 3937 82.80% ( 83.21%), 0 ( 0.00%) clones, pur 99.49%, hit eff 96.82% +06_long_fromB_P>5GeV : 2959/ 3252 90.99% ( 91.01%), 0 ( 0.00%) clones, pur 99.49%, hit eff 97.09% +07_long_electrons : 1686/ 4744 35.54% ( 36.50%), 0 ( 0.00%) clones, pur 99.02%, hit eff 95.82% +08_long_electrons_P>5GeV : 1282/ 2357 54.39% ( 55.84%), 0 ( 0.00%) clones, pur 99.06%, hit eff 96.39% +09_long_fromB_electrons : 97/ 190 51.05% ( 54.33%), 0 ( 0.00%) clones, pur 99.29%, hit eff 96.18% +10_long_fromB_electrons_P>5GeV : 86/ 126 68.25% ( 71.47%), 0 ( 0.00%) clones, pur 99.28%, hit eff 96.52% +long_P>5GeV_AND_Pt>1GeV : 7059/ 7884 89.54% ( 90.36%), 1 ( 0.01%) clones, pur 99.52%, hit eff 97.05% +long_fromB_P>5GeV_AND_Pt>1GeV : 1847/ 2026 91.16% ( 90.67%), 0 ( 0.00%) clones, pur 99.55%, hit eff 97.41% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1714/ 1897 90.35% ( 90.79%), 1 ( 0.06%) clones, pur 99.52%, hit eff 97.32% +14_long_from_B_PT>2GeV : 800/ 877 91.22% ( 91.15%), 0 ( 0.00%) clones, pur 99.46%, hit eff 97.28% +15_long_strange_P>5GeV : 1149/ 1341 85.68% ( 86.35%), 0 ( 0.00%) clones, pur 99.36%, hit eff 96.97% +16_long_strange_P>5GeV_PT>500MeV : 420/ 466 90.13% ( 90.33%), 0 ( 0.00%) clones, pur 99.16%, hit eff 96.62% + + +muon_validator validation: +Muon fraction in all MCPs: 12755/ 941546 0.01% +Muon fraction in MCPs to which a track(s) was matched: 575/ 54464 0.01% +Correctly identified muons with isMuon: 524/ 575 91.13% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 99/ 110 90.00% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 7341/ 53889 13.62% +Ghost tracks identified as muon with isMuon: 964/ 5052 19.08% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 571/ 1000, (17130.00 +/- 469.53) kHz +Hlt1KsToPiPi: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1TrackMVA: 184/ 1000, ( 5520.00 +/- 367.60) kHz +Hlt1TwoTrackMVA: 441/ 1000, (13230.00 +/- 471.03) kHz +Hlt1TwoTrackKs: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowPtMuon: 253/ 1000, ( 7590.00 +/- 412.42) kHz +Hlt1D2KK: 19/ 1000, ( 570.00 +/- 129.52) kHz +Hlt1D2KPi: 25/ 1000, ( 750.00 +/- 148.11) kHz +Hlt1D2PiPi: 22/ 1000, ( 660.00 +/- 139.16) kHz +Hlt1DiMuonHighMass: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DiMuonLowMass: 57/ 1000, ( 1710.00 +/- 219.95) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 173/ 1000, ( 5190.00 +/- 358.84) kHz +Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1TrackElectronMVA: 34/ 1000, ( 1020.00 +/- 171.93) kHz +Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz +Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 32/ 1000, ( 960.00 +/- 166.97) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 31/ 1000, ( 930.00 +/- 164.42) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 571 1446 +Hlt1KsToPiPi: 41 43 +Hlt1TrackMVA: 184 272 +Hlt1TwoTrackMVA: 441 1252 +Hlt1TwoTrackKs: 4 4 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 1 1 +Hlt1LowPtMuon: 253 330 +Hlt1D2KK: 19 21 +Hlt1D2KPi: 25 26 +Hlt1D2PiPi: 22 22 +Hlt1DiMuonHighMass: 16 17 +Hlt1DiMuonLowMass: 57 70 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 173 277 +Hlt1TrackMuonMVA: 11 11 +Hlt1TrackElectronMVA: 34 37 +Hlt1SingleHighPtElectron: 9 9 +Hlt1DisplacedDielectron: 12 13 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 3 3 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 32 0 +Hlt1SingleHighEt: 0 0 +Hlt1DiMuonNoIP: 31 36 +Hlt1DiMuonNoIP_ss: 3 4 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 887 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 1 0 +Hlt1RICH1Alignment: 1 1 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 + +Total decisions: 3840 +Total tracks: 3391 +Total SVs: 2630 +Total hits: 69736 +Total stdinfo: 41488 + diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt new file mode 100644 index 00000000000..d785a59af82 --- /dev/null +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt @@ -0,0 +1,217 @@ +velo_validator validation: +TrackChecker output : 2219/ 257248 0.86% ghosts +01_velo : 108923/ 110735 98.36% ( 98.41%), 2339 ( 2.10%) clones, pur 99.68%, hit eff 96.70% +02_long : 62459/ 62831 99.41% ( 99.45%), 984 ( 1.55%) clones, pur 99.78%, hit eff 97.76% +03_long_P>5GeV : 39426/ 39563 99.65% ( 99.66%), 517 ( 1.29%) clones, pur 99.81%, hit eff 98.29% +04_long_strange : 2833/ 2892 97.96% ( 98.44%), 43 ( 1.50%) clones, pur 99.40%, hit eff 97.34% +05_long_strange_P>5GeV : 1318/ 1341 98.28% ( 98.61%), 10 ( 0.75%) clones, pur 99.31%, hit eff 98.63% +06_long_fromB : 3904/ 3937 99.16% ( 99.34%), 53 ( 1.34%) clones, pur 99.67%, hit eff 97.87% +07_long_fromB_P>5GeV : 3236/ 3252 99.51% ( 99.53%), 36 ( 1.10%) clones, pur 99.71%, hit eff 98.26% +08_long_electrons : 4604/ 4744 97.05% ( 96.96%), 138 ( 2.91%) clones, pur 98.02%, hit eff 96.68% +09_long_fromB_electrons : 182/ 190 95.79% ( 96.06%), 11 ( 5.70%) clones, pur 98.10%, hit eff 96.62% +10_long_fromB_electrons_P>5GeV : 122/ 126 96.83% ( 97.44%), 9 ( 6.87%) clones, pur 98.61%, hit eff 97.12% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.928 ( 4821/ 5194) +Isolated : 0.964 ( 2597/ 2694) +Close : 0.890 ( 2224/ 2500) +False rate : 0.014 ( 69/ 4890) +Real false rate : 0.014 ( 69/ 4890) +Clones : 0.000 ( 0/ 4821) + + +seed_validator validation: +TrackChecker output : 10213/ 89087 11.46% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 22443/ 24958 89.92% ( 90.77%), 4 ( 0.02%) clones, pur 98.93%, hit eff 96.30% +01_long : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +---1. phi quadrant : 11824/ 15521 76.18% ( 76.93%), 5 ( 0.04%) clones, pur 99.00%, hit eff 95.94% +---2. phi quadrant : 11989/ 15853 75.63% ( 76.68%), 3 ( 0.03%) clones, pur 99.00%, hit eff 95.95% +---3. phi quadrant : 12018/ 15850 75.82% ( 76.24%), 2 ( 0.02%) clones, pur 98.94%, hit eff 95.90% +---4. phi quadrant : 12014/ 15606 76.98% ( 77.73%), 3 ( 0.02%) clones, pur 98.97%, hit eff 95.96% +---eta < 2.5, small x, large y : 585/ 2162 27.06% ( 25.09%), 0 ( 0.00%) clones, pur 97.76%, hit eff 94.89% +---eta < 2.5, large x, small y : 1990/ 4318 46.09% ( 45.52%), 0 ( 0.00%) clones, pur 98.76%, hit eff 94.98% +---eta > 2.5, small x, large y : 16619/ 20365 81.61% ( 82.44%), 7 ( 0.04%) clones, pur 99.01%, hit eff 96.14% +---eta > 2.5, large x, small y : 28652/ 35986 79.62% ( 80.39%), 6 ( 0.02%) clones, pur 98.99%, hit eff 95.91% +02_long_P>5GeV : 36616/ 39563 92.55% ( 93.46%), 6 ( 0.02%) clones, pur 98.99%, hit eff 96.57% +02_long_P>5GeV, eta > 4 : 15411/ 16931 91.02% ( 92.31%), 0 ( 0.00%) clones, pur 98.84%, hit eff 96.58% +---eta < 2.5, small x, large y : 349/ 483 72.26% ( 72.67%), 0 ( 0.00%) clones, pur 98.32%, hit eff 96.63% +---eta < 2.5, large x, small y : 1020/ 1076 94.80% ( 94.70%), 0 ( 0.00%) clones, pur 99.28%, hit eff 96.32% +---eta > 2.5, small x, large y : 13102/ 14024 93.43% ( 94.49%), 4 ( 0.03%) clones, pur 99.01%, hit eff 96.60% +---eta > 2.5, large x, small y : 22145/ 23980 92.35% ( 93.23%), 2 ( 0.01%) clones, pur 98.98%, hit eff 96.57% +03_long_P>3GeV : 47831/ 52954 90.33% ( 91.13%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +04_long_P>0.5GeV : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +05_long_from_B : 3418/ 3937 86.82% ( 87.02%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +06_long_from_B_P>5GeV : 3058/ 3252 94.03% ( 94.01%), 0 ( 0.00%) clones, pur 99.07%, hit eff 96.90% +07_long_from_B_P>3GeV : 3418/ 3690 92.63% ( 92.27%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +08_UT+SciFi : 4874/ 8025 60.74% ( 60.50%), 1 ( 0.02%) clones, pur 98.78%, hit eff 94.92% +09_UT+SciFi_P>5GeV : 3014/ 3258 92.51% ( 92.98%), 1 ( 0.03%) clones, pur 98.90%, hit eff 96.14% +10_UT+SciFi_P>3GeV : 4834/ 5504 87.83% ( 88.36%), 1 ( 0.02%) clones, pur 98.79%, hit eff 94.97% +11_UT+SciFi_fromStrange : 1976/ 2779 71.10% ( 69.10%), 0 ( 0.00%) clones, pur 99.08%, hit eff 95.68% +12_UT+SciFi_fromStrange_P>5GeV : 1415/ 1530 92.48% ( 91.81%), 0 ( 0.00%) clones, pur 99.06%, hit eff 96.36% +13_UT+SciFi_fromStrange_P>3GeV : 1970/ 2177 90.49% ( 90.24%), 0 ( 0.00%) clones, pur 99.09%, hit eff 95.69% +14_long_electrons : 2399/ 4744 50.57% ( 50.79%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +15_long_electrons_P>5GeV : 1758/ 2357 74.59% ( 74.92%), 1 ( 0.06%) clones, pur 99.14%, hit eff 96.14% +16_long_electrons_P>3GeV : 2399/ 3767 63.68% ( 64.36%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +17_long_fromB_electrons : 115/ 190 60.53% ( 61.64%), 0 ( 0.00%) clones, pur 99.33%, hit eff 96.20% +18_long_fromB_electrons_P>5GeV : 98/ 126 77.78% ( 80.29%), 0 ( 0.00%) clones, pur 99.38%, hit eff 96.61% +19_long_PT>2GeV : 1760/ 1897 92.78% ( 92.95%), 0 ( 0.00%) clones, pur 99.11%, hit eff 97.07% +20_long_from_B_PT>2GeV : 820/ 877 93.50% ( 93.49%), 0 ( 0.00%) clones, pur 99.12%, hit eff 97.01% +21_long_strange_P>5GeV : 1262/ 1341 94.11% ( 93.91%), 0 ( 0.00%) clones, pur 98.95%, hit eff 96.70% +22_long_strange_P>5GeV_PT>500MeV : 440/ 466 94.42% ( 94.25%), 0 ( 0.00%) clones, pur 98.68%, hit eff 96.24% + + +long_validator validation: +TrackChecker output : 5078/ 52023 9.76% ghosts +for P>3GeV,Pt>0.5GeV : 1225/ 22963 5.33% ghosts +01_long : 43914/ 62831 69.89% ( 70.96%), 1 ( 0.00%) clones, pur 99.49%, hit eff 96.25% +02_long_P>5GeV : 34521/ 39563 87.26% ( 88.47%), 1 ( 0.00%) clones, pur 99.50%, hit eff 96.81% +03_long_strange : 1681/ 2892 58.13% ( 57.82%), 0 ( 0.00%) clones, pur 99.43%, hit eff 96.18% +04_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +05_long_fromB : 3260/ 3937 82.80% ( 83.23%), 0 ( 0.00%) clones, pur 99.48%, hit eff 96.82% +06_long_fromB_P>5GeV : 2957/ 3252 90.93% ( 90.96%), 0 ( 0.00%) clones, pur 99.49%, hit eff 97.09% +07_long_electrons : 1672/ 4744 35.24% ( 36.20%), 0 ( 0.00%) clones, pur 98.99%, hit eff 95.82% +08_long_electrons_P>5GeV : 1273/ 2357 54.01% ( 55.54%), 0 ( 0.00%) clones, pur 99.04%, hit eff 96.37% +09_long_fromB_electrons : 96/ 190 50.53% ( 53.98%), 0 ( 0.00%) clones, pur 99.29%, hit eff 96.14% +10_long_fromB_electrons_P>5GeV : 85/ 126 67.46% ( 70.99%), 0 ( 0.00%) clones, pur 99.27%, hit eff 96.48% +long_P>5GeV_AND_Pt>1GeV : 7060/ 7884 89.55% ( 90.36%), 1 ( 0.01%) clones, pur 99.51%, hit eff 97.05% +long_fromB_P>5GeV_AND_Pt>1GeV : 1846/ 2026 91.12% ( 90.61%), 0 ( 0.00%) clones, pur 99.54%, hit eff 97.41% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1715/ 1897 90.41% ( 90.76%), 1 ( 0.06%) clones, pur 99.50%, hit eff 97.32% +14_long_from_B_PT>2GeV : 800/ 877 91.22% ( 91.12%), 0 ( 0.00%) clones, pur 99.45%, hit eff 97.28% +15_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +16_long_strange_P>5GeV_PT>500MeV : 416/ 466 89.27% ( 89.76%), 0 ( 0.00%) clones, pur 99.17%, hit eff 96.61% + + +muon_validator validation: +Muon fraction in all MCPs: 12755/ 941546 0.01% +Muon fraction in MCPs to which a track(s) was matched: 571/ 54394 0.01% +Correctly identified muons with isMuon: 520/ 571 91.07% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 99/ 110 90.00% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 7318/ 53823 13.60% +Ghost tracks identified as muon with isMuon: 963/ 5078 18.96% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 567/ 1000, (17010.00 +/- 470.06) kHz +Hlt1KsToPiPi: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1TrackMVA: 185/ 1000, ( 5550.00 +/- 368.37) kHz +Hlt1TwoTrackMVA: 438/ 1000, (13140.00 +/- 470.68) kHz +Hlt1TwoTrackKs: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtMuon: 251/ 1000, ( 7530.00 +/- 411.34) kHz +Hlt1D2KK: 20/ 1000, ( 600.00 +/- 132.82) kHz +Hlt1D2KPi: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1D2PiPi: 21/ 1000, ( 630.00 +/- 136.03) kHz +Hlt1DiMuonHighMass: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- 221.75) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz +Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz +Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz +Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 567 1466 +Hlt1KsToPiPi: 41 43 +Hlt1TrackMVA: 185 267 +Hlt1TwoTrackMVA: 438 1212 +Hlt1TwoTrackKs: 4 4 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 2 2 +Hlt1LowPtMuon: 251 327 +Hlt1D2KK: 20 22 +Hlt1D2KPi: 26 27 +Hlt1D2PiPi: 21 21 +Hlt1DiMuonHighMass: 16 18 +Hlt1DiMuonLowMass: 58 68 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 170 276 +Hlt1TrackMuonMVA: 11 11 +Hlt1TrackElectronMVA: 33 36 +Hlt1SingleHighPtElectron: 9 9 +Hlt1DisplacedDielectron: 12 13 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 29 0 +Hlt1SingleHighEt: 0 0 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 887 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 1 0 +Hlt1RICH1Alignment: 1 1 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 + +Total decisions: 3826 +Total tracks: 3357 +Total SVs: 2611 +Total hits: 69259 +Total stdinfo: 41126 + diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt new file mode 100644 index 00000000000..d785a59af82 --- /dev/null +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt @@ -0,0 +1,217 @@ +velo_validator validation: +TrackChecker output : 2219/ 257248 0.86% ghosts +01_velo : 108923/ 110735 98.36% ( 98.41%), 2339 ( 2.10%) clones, pur 99.68%, hit eff 96.70% +02_long : 62459/ 62831 99.41% ( 99.45%), 984 ( 1.55%) clones, pur 99.78%, hit eff 97.76% +03_long_P>5GeV : 39426/ 39563 99.65% ( 99.66%), 517 ( 1.29%) clones, pur 99.81%, hit eff 98.29% +04_long_strange : 2833/ 2892 97.96% ( 98.44%), 43 ( 1.50%) clones, pur 99.40%, hit eff 97.34% +05_long_strange_P>5GeV : 1318/ 1341 98.28% ( 98.61%), 10 ( 0.75%) clones, pur 99.31%, hit eff 98.63% +06_long_fromB : 3904/ 3937 99.16% ( 99.34%), 53 ( 1.34%) clones, pur 99.67%, hit eff 97.87% +07_long_fromB_P>5GeV : 3236/ 3252 99.51% ( 99.53%), 36 ( 1.10%) clones, pur 99.71%, hit eff 98.26% +08_long_electrons : 4604/ 4744 97.05% ( 96.96%), 138 ( 2.91%) clones, pur 98.02%, hit eff 96.68% +09_long_fromB_electrons : 182/ 190 95.79% ( 96.06%), 11 ( 5.70%) clones, pur 98.10%, hit eff 96.62% +10_long_fromB_electrons_P>5GeV : 122/ 126 96.83% ( 97.44%), 9 ( 6.87%) clones, pur 98.61%, hit eff 97.12% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.928 ( 4821/ 5194) +Isolated : 0.964 ( 2597/ 2694) +Close : 0.890 ( 2224/ 2500) +False rate : 0.014 ( 69/ 4890) +Real false rate : 0.014 ( 69/ 4890) +Clones : 0.000 ( 0/ 4821) + + +seed_validator validation: +TrackChecker output : 10213/ 89087 11.46% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 22443/ 24958 89.92% ( 90.77%), 4 ( 0.02%) clones, pur 98.93%, hit eff 96.30% +01_long : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +---1. phi quadrant : 11824/ 15521 76.18% ( 76.93%), 5 ( 0.04%) clones, pur 99.00%, hit eff 95.94% +---2. phi quadrant : 11989/ 15853 75.63% ( 76.68%), 3 ( 0.03%) clones, pur 99.00%, hit eff 95.95% +---3. phi quadrant : 12018/ 15850 75.82% ( 76.24%), 2 ( 0.02%) clones, pur 98.94%, hit eff 95.90% +---4. phi quadrant : 12014/ 15606 76.98% ( 77.73%), 3 ( 0.02%) clones, pur 98.97%, hit eff 95.96% +---eta < 2.5, small x, large y : 585/ 2162 27.06% ( 25.09%), 0 ( 0.00%) clones, pur 97.76%, hit eff 94.89% +---eta < 2.5, large x, small y : 1990/ 4318 46.09% ( 45.52%), 0 ( 0.00%) clones, pur 98.76%, hit eff 94.98% +---eta > 2.5, small x, large y : 16619/ 20365 81.61% ( 82.44%), 7 ( 0.04%) clones, pur 99.01%, hit eff 96.14% +---eta > 2.5, large x, small y : 28652/ 35986 79.62% ( 80.39%), 6 ( 0.02%) clones, pur 98.99%, hit eff 95.91% +02_long_P>5GeV : 36616/ 39563 92.55% ( 93.46%), 6 ( 0.02%) clones, pur 98.99%, hit eff 96.57% +02_long_P>5GeV, eta > 4 : 15411/ 16931 91.02% ( 92.31%), 0 ( 0.00%) clones, pur 98.84%, hit eff 96.58% +---eta < 2.5, small x, large y : 349/ 483 72.26% ( 72.67%), 0 ( 0.00%) clones, pur 98.32%, hit eff 96.63% +---eta < 2.5, large x, small y : 1020/ 1076 94.80% ( 94.70%), 0 ( 0.00%) clones, pur 99.28%, hit eff 96.32% +---eta > 2.5, small x, large y : 13102/ 14024 93.43% ( 94.49%), 4 ( 0.03%) clones, pur 99.01%, hit eff 96.60% +---eta > 2.5, large x, small y : 22145/ 23980 92.35% ( 93.23%), 2 ( 0.01%) clones, pur 98.98%, hit eff 96.57% +03_long_P>3GeV : 47831/ 52954 90.33% ( 91.13%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +04_long_P>0.5GeV : 47846/ 62831 76.15% ( 76.93%), 13 ( 0.03%) clones, pur 98.98%, hit eff 95.94% +05_long_from_B : 3418/ 3937 86.82% ( 87.02%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +06_long_from_B_P>5GeV : 3058/ 3252 94.03% ( 94.01%), 0 ( 0.00%) clones, pur 99.07%, hit eff 96.90% +07_long_from_B_P>3GeV : 3418/ 3690 92.63% ( 92.27%), 0 ( 0.00%) clones, pur 99.09%, hit eff 96.61% +08_UT+SciFi : 4874/ 8025 60.74% ( 60.50%), 1 ( 0.02%) clones, pur 98.78%, hit eff 94.92% +09_UT+SciFi_P>5GeV : 3014/ 3258 92.51% ( 92.98%), 1 ( 0.03%) clones, pur 98.90%, hit eff 96.14% +10_UT+SciFi_P>3GeV : 4834/ 5504 87.83% ( 88.36%), 1 ( 0.02%) clones, pur 98.79%, hit eff 94.97% +11_UT+SciFi_fromStrange : 1976/ 2779 71.10% ( 69.10%), 0 ( 0.00%) clones, pur 99.08%, hit eff 95.68% +12_UT+SciFi_fromStrange_P>5GeV : 1415/ 1530 92.48% ( 91.81%), 0 ( 0.00%) clones, pur 99.06%, hit eff 96.36% +13_UT+SciFi_fromStrange_P>3GeV : 1970/ 2177 90.49% ( 90.24%), 0 ( 0.00%) clones, pur 99.09%, hit eff 95.69% +14_long_electrons : 2399/ 4744 50.57% ( 50.79%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +15_long_electrons_P>5GeV : 1758/ 2357 74.59% ( 74.92%), 1 ( 0.06%) clones, pur 99.14%, hit eff 96.14% +16_long_electrons_P>3GeV : 2399/ 3767 63.68% ( 64.36%), 1 ( 0.04%) clones, pur 99.05%, hit eff 95.50% +17_long_fromB_electrons : 115/ 190 60.53% ( 61.64%), 0 ( 0.00%) clones, pur 99.33%, hit eff 96.20% +18_long_fromB_electrons_P>5GeV : 98/ 126 77.78% ( 80.29%), 0 ( 0.00%) clones, pur 99.38%, hit eff 96.61% +19_long_PT>2GeV : 1760/ 1897 92.78% ( 92.95%), 0 ( 0.00%) clones, pur 99.11%, hit eff 97.07% +20_long_from_B_PT>2GeV : 820/ 877 93.50% ( 93.49%), 0 ( 0.00%) clones, pur 99.12%, hit eff 97.01% +21_long_strange_P>5GeV : 1262/ 1341 94.11% ( 93.91%), 0 ( 0.00%) clones, pur 98.95%, hit eff 96.70% +22_long_strange_P>5GeV_PT>500MeV : 440/ 466 94.42% ( 94.25%), 0 ( 0.00%) clones, pur 98.68%, hit eff 96.24% + + +long_validator validation: +TrackChecker output : 5078/ 52023 9.76% ghosts +for P>3GeV,Pt>0.5GeV : 1225/ 22963 5.33% ghosts +01_long : 43914/ 62831 69.89% ( 70.96%), 1 ( 0.00%) clones, pur 99.49%, hit eff 96.25% +02_long_P>5GeV : 34521/ 39563 87.26% ( 88.47%), 1 ( 0.00%) clones, pur 99.50%, hit eff 96.81% +03_long_strange : 1681/ 2892 58.13% ( 57.82%), 0 ( 0.00%) clones, pur 99.43%, hit eff 96.18% +04_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +05_long_fromB : 3260/ 3937 82.80% ( 83.23%), 0 ( 0.00%) clones, pur 99.48%, hit eff 96.82% +06_long_fromB_P>5GeV : 2957/ 3252 90.93% ( 90.96%), 0 ( 0.00%) clones, pur 99.49%, hit eff 97.09% +07_long_electrons : 1672/ 4744 35.24% ( 36.20%), 0 ( 0.00%) clones, pur 98.99%, hit eff 95.82% +08_long_electrons_P>5GeV : 1273/ 2357 54.01% ( 55.54%), 0 ( 0.00%) clones, pur 99.04%, hit eff 96.37% +09_long_fromB_electrons : 96/ 190 50.53% ( 53.98%), 0 ( 0.00%) clones, pur 99.29%, hit eff 96.14% +10_long_fromB_electrons_P>5GeV : 85/ 126 67.46% ( 70.99%), 0 ( 0.00%) clones, pur 99.27%, hit eff 96.48% +long_P>5GeV_AND_Pt>1GeV : 7060/ 7884 89.55% ( 90.36%), 1 ( 0.01%) clones, pur 99.51%, hit eff 97.05% +long_fromB_P>5GeV_AND_Pt>1GeV : 1846/ 2026 91.12% ( 90.61%), 0 ( 0.00%) clones, pur 99.54%, hit eff 97.41% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1715/ 1897 90.41% ( 90.76%), 1 ( 0.06%) clones, pur 99.50%, hit eff 97.32% +14_long_from_B_PT>2GeV : 800/ 877 91.22% ( 91.12%), 0 ( 0.00%) clones, pur 99.45%, hit eff 97.28% +15_long_strange_P>5GeV : 1141/ 1341 85.09% ( 85.96%), 0 ( 0.00%) clones, pur 99.37%, hit eff 96.96% +16_long_strange_P>5GeV_PT>500MeV : 416/ 466 89.27% ( 89.76%), 0 ( 0.00%) clones, pur 99.17%, hit eff 96.61% + + +muon_validator validation: +Muon fraction in all MCPs: 12755/ 941546 0.01% +Muon fraction in MCPs to which a track(s) was matched: 571/ 54394 0.01% +Correctly identified muons with isMuon: 520/ 571 91.07% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 99/ 110 90.00% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 7318/ 53823 13.60% +Ghost tracks identified as muon with isMuon: 963/ 5078 18.96% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 567/ 1000, (17010.00 +/- 470.06) kHz +Hlt1KsToPiPi: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1TrackMVA: 185/ 1000, ( 5550.00 +/- 368.37) kHz +Hlt1TwoTrackMVA: 438/ 1000, (13140.00 +/- 470.68) kHz +Hlt1TwoTrackKs: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtMuon: 251/ 1000, ( 7530.00 +/- 411.34) kHz +Hlt1D2KK: 20/ 1000, ( 600.00 +/- 132.82) kHz +Hlt1D2KPi: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1D2PiPi: 21/ 1000, ( 630.00 +/- 136.03) kHz +Hlt1DiMuonHighMass: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- 221.75) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz +Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz +Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz +Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 567 1466 +Hlt1KsToPiPi: 41 43 +Hlt1TrackMVA: 185 267 +Hlt1TwoTrackMVA: 438 1212 +Hlt1TwoTrackKs: 4 4 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 2 2 +Hlt1LowPtMuon: 251 327 +Hlt1D2KK: 20 22 +Hlt1D2KPi: 26 27 +Hlt1D2PiPi: 21 21 +Hlt1DiMuonHighMass: 16 18 +Hlt1DiMuonLowMass: 58 68 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 170 276 +Hlt1TrackMuonMVA: 11 11 +Hlt1TrackElectronMVA: 33 36 +Hlt1SingleHighPtElectron: 9 9 +Hlt1DisplacedDielectron: 12 13 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 29 0 +Hlt1SingleHighEt: 0 0 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 887 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 1 0 +Hlt1RICH1Alignment: 1 1 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 + +Total decisions: 3826 +Total tracks: 3357 +Total SVs: 2611 +Total hits: 69259 +Total stdinfo: 41126 + diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_a5000.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_a5000.txt index fba0aca581b..c5ddb7a6561 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_a5000.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_a5000.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_epyc7502.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_epyc7502.txt index e9989572944..99e126d8059 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_epyc7502.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_epyc7502.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 886/ 21795 4.07% 10_long_fromB_electrons_P>5GeV : 61/ 126 48.41% ( 54.81%), 3 ( 4.69%) clones, pur 97.96%, hit eff 94.21% long_P>5GeV_AND_Pt>1GeV : 6774/ 7884 85.92% ( 86.96%), 68 ( 0.99%) clones, pur 99.09%, hit eff 96.27% long_fromB_P>5GeV_AND_Pt>1GeV : 1790/ 2026 88.35% ( 88.10%), 22 ( 1.21%) clones, pur 99.13%, hit eff 96.78% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1697/ 1897 89.46% ( 90.23%), 18 ( 1.05%) clones, pur 99.13%, hit eff 96.76% +14_long_from_B_PT>2GeV : 787/ 877 89.74% ( 88.96%), 11 ( 1.38%) clones, pur 99.09%, hit eff 96.81% +15_long_strange_P>5GeV : 713/ 1341 53.17% ( 53.95%), 3 ( 0.42%) clones, pur 98.55%, hit eff 95.60% +16_long_strange_P>5GeV_PT>500MeV : 378/ 466 81.12% ( 81.87%), 2 ( 0.53%) clones, pur 98.53%, hit eff 95.22% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt index fba0aca581b..c5ddb7a6561 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt index fba0aca581b..de49c49bc2d 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% muon_validator validation: @@ -191,5 +197,5 @@ Total decisions: 3541 Total tracks: 2681 Total SVs: 2210 Total hits: 66438 -Total stdinfo: 33829 +Total stdinfo: 33799 -- GitLab From 3f65293e6a1e111e9b6dfea70495bc2d61f90c1b Mon Sep 17 00:00:00 2001 From: Kate Richardson Date: Tue, 23 Aug 2022 00:45:32 +0200 Subject: [PATCH 16/18] fixes after rebasing --- configuration/python/AllenConf/HLT1.py | 14 +++++--------- .../python/AllenConf/hlt1_calibration_lines.py | 4 ++-- configuration/python/AllenConf/hlt1_muon_lines.py | 2 +- 3 files changed, 8 insertions(+), 12 deletions(-) diff --git a/configuration/python/AllenConf/HLT1.py b/configuration/python/AllenConf/HLT1.py index e264bc09c36..cf38352a1d2 100644 --- a/configuration/python/AllenConf/HLT1.py +++ b/configuration/python/AllenConf/HLT1.py @@ -101,12 +101,10 @@ def default_physics_lines(velo_tracks, long_tracks, long_track_particles, lines.append( line_maker( make_track_muon_mva_line( - long_tracks, long_track_particles, - name="Hlt1TrackMuonMVA"))) + long_tracks, long_track_particles, name="Hlt1TrackMuonMVA"))) lines.append( - line_maker( - make_di_muon_no_ip_line(long_tracks, secondary_vertices))) + line_maker(make_di_muon_no_ip_line(long_tracks, secondary_vertices))) lines.append( line_maker( make_di_muon_no_ip_line( @@ -229,9 +227,8 @@ def event_monitoring_lines(with_lumi, lumiline_name): return lines -def alignment_monitoring_lines(velo_tracks, long_tracks, - long_track_particles, velo_states, - secondary_vertices): +def alignment_monitoring_lines(velo_tracks, long_tracks, long_track_particles, + velo_states, secondary_vertices): lines = [] lines.append( @@ -255,8 +252,7 @@ def alignment_monitoring_lines(velo_tracks, long_tracks, lines.append( line_maker( make_d2kpi_line( - long_tracks, secondary_vertices, - name="Hlt1D2KPiAlignment"))) + long_tracks, secondary_vertices, name="Hlt1D2KPiAlignment"))) lines.append( line_maker( make_di_muon_mass_align_line( diff --git a/configuration/python/AllenConf/hlt1_calibration_lines.py b/configuration/python/AllenConf/hlt1_calibration_lines.py index 2e9f0b3eb2d..ab89cbcedba 100644 --- a/configuration/python/AllenConf/hlt1_calibration_lines.py +++ b/configuration/python/AllenConf/hlt1_calibration_lines.py @@ -97,7 +97,7 @@ def make_rich_2_line(long_tracks, pre_scaler_hash_string, post_scaler_hash_string) -def make_displaced_dimuon_mass_line(forward_tracks, +def make_displaced_dimuon_mass_line(long_tracks, secondary_vertices, name="Hlt1DisplacedDiMuonAlignment", pre_scaler=1.0, @@ -120,7 +120,7 @@ def make_displaced_dimuon_mass_line(forward_tracks, post_scaler_hash_string=post_scaler_hash_string or name + '_post') -def make_di_muon_mass_align_line(forward_tracks, +def make_di_muon_mass_align_line(long_tracks, secondary_vertices, pre_scaler=1.0, post_scaler=1.0, diff --git a/configuration/python/AllenConf/hlt1_muon_lines.py b/configuration/python/AllenConf/hlt1_muon_lines.py index a84aa1c9169..576e6d98fcf 100644 --- a/configuration/python/AllenConf/hlt1_muon_lines.py +++ b/configuration/python/AllenConf/hlt1_muon_lines.py @@ -151,7 +151,7 @@ def make_track_muon_mva_line(long_tracks, post_scaler_hash_string=post_scaler_hash_string or name + "_post") -def make_di_muon_no_ip_line(forward_tracks, +def make_di_muon_no_ip_line(long_tracks, secondary_vertices, pre_scaler_hash_string="di_muon_no_ip_line_pre", post_scaler_hash_string="di_muon_no_ip_line_post", -- GitLab From 2d866655c1812434a57e89030023230f7e56a17b Mon Sep 17 00:00:00 2001 From: Christina Agapopoulou Date: Wed, 24 Aug 2022 10:51:00 +0200 Subject: [PATCH 17/18] replaced [[maybe_unused]] with _unused --- device/SciFi/hybridseeding/src/seed_xz.cu | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/device/SciFi/hybridseeding/src/seed_xz.cu b/device/SciFi/hybridseeding/src/seed_xz.cu index d7879532b08..47b7baa3af6 100644 --- a/device/SciFi/hybridseeding/src/seed_xz.cu +++ b/device/SciFi/hybridseeding/src/seed_xz.cu @@ -156,17 +156,16 @@ namespace { const unsigned int* layers) { - [[maybe_unused]] unsigned maxTripletPerFirstHit = seeding::Triplet::maxTriplets / hits.size[layers[0]]; - (void) maxTripletPerFirstHit; // TODO: remove if [[maybe_unused]] decides to work someday.. + unsigned maxTripletPerFirstHit = seeding::Triplet::maxTriplets / hits.size[layers[0]]; + _unused(maxTripletPerFirstHit); for (unsigned int firstHitIdx = threadIdx.x; firstHitIdx < hits.size[layers[0]]; firstHitIdx += blockDim.x) { float xFirst = hits.hit(layers[0], firstHitIdx); float maxXl = xFirst * currentCase.twoHitScale + currentCase.tol2Hit; float minXl = maxXl - 2.f * currentCase.tol2Hit; - [[maybe_unused]] unsigned nCandidates = 0; - (void) nCandidates; // TODO: remove if [[maybe_unused]] decides to work someday.. - + unsigned nCandidates = 0; + _unused(nCandidates); // SPEEDUP: cache last layer first hit auto startSecond = hybrid_seeding::binary_search_leftmost_unrolled(hits.layer(layers[1]), hits.size[layers[1]], minXl); -- GitLab From 2275ab0da5b260d1f06aeaee8ce7a7bdd2a0d6a8 Mon Sep 17 00:00:00 2001 From: cagapopo Date: Fri, 26 Aug 2022 12:53:34 +0200 Subject: [PATCH 18/18] updated references --- ...ster_v1_hlt1_pp_SMOG2_validation_a5000.txt | 5 + ...r_v1_hlt1_pp_SMOG2_validation_epyc7502.txt | 5 + ...1_pp_SMOG2_validation_geforcertx2080ti.txt | 5 + ...lt1_pp_SMOG2_validation_geforcertx3090.txt | 5 + ...r_v1_hlt1_pp_matching_validation_a5000.txt | 209 ++++++++++++++++ ...1_hlt1_pp_matching_validation_epyc7502.txt | 209 ++++++++++++++++ ...p_matching_validation_geforcertx2080ti.txt | 209 ++++++++++++++++ ..._pp_matching_validation_geforcertx3090.txt | 209 ++++++++++++++++ ...inacluster_v1_hlt1_pp_validation_a5000.txt | 5 + ...cluster_v1_hlt1_pp_validation_epyc7502.txt | 5 + ...v1_hlt1_pp_validation_geforcertx2080ti.txt | 5 + ...r_v1_hlt1_pp_validation_geforcertx3090.txt | 5 + ...iMD_1k_hlt1_pp_veloSP_validation_a5000.txt | 6 + ..._1k_hlt1_pp_veloSP_validation_epyc7502.txt | 6 + ..._pp_veloSP_validation_geforcertx2080ti.txt | 6 + ...t1_pp_veloSP_validation_geforcertx3090.txt | 6 + ...r_v1_hlt1_pp_matching_validation_a5000.txt | 225 ++++++++++++++++++ ...1_hlt1_pp_matching_validation_epyc7502.txt | 225 ++++++++++++++++++ ...p_matching_validation_geforcertx2080ti.txt | 225 ++++++++++++++++++ ..._pp_matching_validation_geforcertx3090.txt | 225 ++++++++++++++++++ ...ster_v1_hlt1_pp_no_ut_validation_a5000.txt | 6 + ...r_v1_hlt1_pp_no_ut_validation_epyc7502.txt | 6 + ...1_pp_no_ut_validation_geforcertx2080ti.txt | 6 + ...lt1_pp_no_ut_validation_geforcertx3090.txt | 6 + ...inacluster_v1_hlt1_pp_validation_a5000.txt | 6 + ...cluster_v1_hlt1_pp_validation_epyc7502.txt | 6 + ...v1_hlt1_pp_validation_geforcertx2080ti.txt | 6 + ...r_v1_hlt1_pp_validation_geforcertx3090.txt | 6 + ...uster_v1_hlt1_complex_validation_a5000.txt | 12 + ...er_v1_hlt1_complex_validation_epyc7502.txt | 12 + ...t1_complex_validation_geforcertx2080ti.txt | 12 + ...hlt1_complex_validation_geforcertx3090.txt | 12 + ...r_v1_hlt1_pp_matching_validation_a5000.txt | 20 +- ...1_hlt1_pp_matching_validation_epyc7502.txt | 20 +- ...p_matching_validation_geforcertx2080ti.txt | 20 +- ..._pp_matching_validation_geforcertx3090.txt | 20 +- ...ster_v1_hlt1_pp_no_ut_validation_a5000.txt | 6 + ...r_v1_hlt1_pp_no_ut_validation_epyc7502.txt | 6 + ...1_pp_no_ut_validation_geforcertx2080ti.txt | 6 + ...lt1_pp_no_ut_validation_geforcertx3090.txt | 6 + ...r_v1_hlt1_pp_validation_geforcertx3090.txt | 2 +- ..._000_v1_hlt1_pp_SMOG2_validation_a5000.txt | 6 + ...0_v1_hlt1_pp_SMOG2_validation_epyc7502.txt | 6 + ...1_pp_SMOG2_validation_geforcertx2080ti.txt | 6 + ...lt1_pp_SMOG2_validation_geforcertx3090.txt | 6 + 45 files changed, 2001 insertions(+), 25 deletions(-) create mode 100644 test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt create mode 100644 test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt create mode 100644 test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt create mode 100644 test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt create mode 100644 test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt create mode 100644 test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt create mode 100644 test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt create mode 100644 test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_a5000.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_a5000.txt index ef1325cfde0..1263fb89c2b 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_a5000.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_a5000.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_epyc7502.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_epyc7502.txt index c4ec54cbe15..c4530cee1b4 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_epyc7502.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_epyc7502.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 7/ 1317 0.53% 07_long_electrons : 51/ 596 8.56% ( 9.44%), 1 ( 1.92%) clones, pur 99.36%, hit eff 99.84% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.25%), 1 ( 2.04%) clones, pur 99.32%, hit eff 99.83% long_P>5GeV_AND_Pt>1GeV : 210/ 220 95.45% ( 96.55%), 5 ( 2.33%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 55/ 116 47.41% ( 48.09%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt index ef1325cfde0..1263fb89c2b 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt index ef1325cfde0..1263fb89c2b 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt new file mode 100644 index 00000000000..9b45bd2b10e --- /dev/null +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt @@ -0,0 +1,209 @@ +velo_validator validation: +TrackChecker output : 94/ 13749 0.68% ghosts +01_velo : 7660/ 7805 98.14% ( 98.12%), 248 ( 3.14%) clones, pur 99.60%, hit eff 95.77% +02_long : 4466/ 4511 99.00% ( 98.92%), 123 ( 2.68%) clones, pur 99.74%, hit eff 96.55% +03_long_P>5GeV : 2925/ 2941 99.46% ( 99.35%), 70 ( 2.34%) clones, pur 99.81%, hit eff 97.16% +04_long_strange : 214/ 218 98.17% ( 98.02%), 6 ( 2.73%) clones, pur 99.58%, hit eff 95.93% +05_long_strange_P>5GeV : 113/ 116 97.41% ( 96.88%), 1 ( 0.88%) clones, pur 99.93%, hit eff 97.60% +08_long_electrons : 583/ 596 97.82% ( 98.16%), 23 ( 3.80%) clones, pur 98.31%, hit eff 95.94% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 1.025 ( 727/ 709) +Isolated : 1.025 ( 727/ 709) +Close : 0.000 ( 0/ 0) +False rate : 0.010 ( 7/ 734) +Real false rate : 0.010 ( 7/ 734) +Clones : 0.001 ( 1/ 727) + + +seed_validator validation: +TrackChecker output : 24/ 6951 0.35% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 1282/ 1386 92.50% ( 92.93%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.64% +01_long : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +---1. phi quadrant : 960/ 1175 81.70% ( 82.14%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.43% +---2. phi quadrant : 910/ 1135 80.18% ( 80.27%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.51% +---3. phi quadrant : 882/ 1116 79.03% ( 78.34%), 0 ( 0.00%) clones, pur 99.81%, hit eff 99.49% +---4. phi quadrant : 862/ 1085 79.45% ( 80.79%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.48% +---eta < 2.5, small x, large y : 7/ 81 8.64% ( 8.44%), 0 ( 0.00%) clones, pur 100.00%, hit eff 98.81% +---eta < 2.5, large x, small y : 46/ 152 30.26% ( 30.00%), 0 ( 0.00%) clones, pur 99.78%, hit eff 99.46% +---eta > 2.5, small x, large y : 1338/ 1599 83.68% ( 83.92%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.54% +---eta > 2.5, large x, small y : 2223/ 2679 82.98% ( 82.56%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.44% +02_long_P>5GeV : 2809/ 2941 95.51% ( 96.06%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.59% +02_long_P>5GeV, eta > 4 : 1526/ 1617 94.37% ( 95.47%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.63% +---eta < 2.5, small x, large y : 3/ 3 100.00% (100.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +---eta < 2.5, large x, small y : 14/ 15 93.33% ( 93.33%), 0 ( 0.00%) clones, pur 99.29%, hit eff 99.40% +---eta > 2.5, small x, large y : 1068/ 1102 96.91% ( 97.51%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.69% +---eta > 2.5, large x, small y : 1724/ 1821 94.67% ( 95.60%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.53% +03_long_P>3GeV : 3612/ 3885 92.97% ( 93.62%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.49% +04_long_P>0.5GeV : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +08_UT+SciFi : 400/ 696 57.47% ( 53.56%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.14% +09_UT+SciFi_P>5GeV : 242/ 255 94.90% ( 93.88%), 0 ( 0.00%) clones, pur 99.89%, hit eff 99.45% +10_UT+SciFi_P>3GeV : 397/ 456 87.06% ( 85.52%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.19% +11_UT+SciFi_fromStrange : 96/ 124 77.42% ( 77.81%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.30% +12_UT+SciFi_fromStrange_P>5GeV : 70/ 72 97.22% ( 96.77%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.51% +13_UT+SciFi_fromStrange_P>3GeV : 95/ 102 93.14% ( 91.25%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.38% +14_long_electrons : 318/ 596 53.36% ( 51.46%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +15_long_electrons_P>5GeV : 251/ 336 74.70% ( 74.40%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.11% +16_long_electrons_P>3GeV : 318/ 506 62.85% ( 60.17%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +19_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +21_long_strange_P>5GeV : 110/ 116 94.83% ( 95.83%), 0 ( 0.00%) clones, pur 99.77%, hit eff 99.61% +22_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.59%, hit eff 99.24% + + +long_validator validation: +TrackChecker output : 166/ 4017 4.13% ghosts +for P>3GeV,Pt>0.5GeV : 7/ 1238 0.57% ghosts +01_long : 3393/ 4511 75.22% ( 74.86%), 0 ( 0.00%) clones, pur 99.92%, hit eff 99.57% +02_long_P>5GeV : 2708/ 2941 92.08% ( 92.97%), 0 ( 0.00%) clones, pur 99.94%, hit eff 99.66% +03_long_strange : 148/ 218 67.89% ( 68.59%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.71% +04_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +07_long_electrons : 226/ 596 37.92% ( 37.63%), 0 ( 0.00%) clones, pur 99.28%, hit eff 99.22% +08_long_electrons_P>5GeV : 183/ 336 54.46% ( 55.82%), 0 ( 0.00%) clones, pur 99.20%, hit eff 99.18% +long_P>5GeV_AND_Pt>1GeV : 205/ 220 93.18% ( 93.68%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.92% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +15_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +16_long_strange_P>5GeV_PT>500MeV : 21/ 23 91.30% ( 91.30%), 0 ( 0.00%) clones, pur 99.70%, hit eff 99.21% + + +muon_validator validation: +Muon fraction in all MCPs: 917/ 68484 0.01% +Muon fraction in MCPs to which a track(s) was matched: 41/ 4538 0.01% +Correctly identified muons with isMuon: 40/ 41 97.56% +Correctly identified muons from strange decays with isMuon: 0/ 0 -nan% +Correctly identified muons from B decays with isMuon: 0/ 0 -nan% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 147/ 4497 3.27% +Ghost tracks identified as muon with isMuon: 8/ 166 4.82% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 15/ 1000, ( 450.00 +/- 115.31) kHz +Hlt1KsToPiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackKs: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuonNoMuID: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KK: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2PiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonLowMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMuonMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP_ss: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackElectronMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtElectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDielectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 15 25 +Hlt1KsToPiPi: 0 0 +Hlt1TrackMVA: 0 0 +Hlt1TwoTrackMVA: 0 0 +Hlt1TwoTrackKs: 0 0 +Hlt1SingleHighPtMuon: 0 0 +Hlt1SingleHighPtMuonNoMuID: 0 0 +Hlt1LowPtMuon: 0 0 +Hlt1D2KK: 0 0 +Hlt1D2KPi: 0 0 +Hlt1D2PiPi: 0 0 +Hlt1DiMuonHighMass: 0 0 +Hlt1DiMuonLowMass: 0 0 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 0 0 +Hlt1TrackMuonMVA: 0 0 +Hlt1DiMuonNoIP: 0 0 +Hlt1DiMuonNoIP_ss: 0 0 +Hlt1TrackElectronMVA: 0 0 +Hlt1SingleHighPtElectron: 0 0 +Hlt1DisplacedDielectron: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 0 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 1000 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 2 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 0 0 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 0 0 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 0 0 + +Total decisions: 2019 +Total tracks: 37 +Total SVs: 25 +Total hits: 663 +Total stdinfo: 2415 + diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt new file mode 100644 index 00000000000..30b34d868c7 --- /dev/null +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt @@ -0,0 +1,209 @@ +velo_validator validation: +TrackChecker output : 90/ 13752 0.65% ghosts +01_velo : 7660/ 7805 98.14% ( 98.16%), 247 ( 3.12%) clones, pur 99.61%, hit eff 95.81% +02_long : 4466/ 4511 99.00% ( 98.92%), 123 ( 2.68%) clones, pur 99.75%, hit eff 96.55% +03_long_P>5GeV : 2925/ 2941 99.46% ( 99.35%), 70 ( 2.34%) clones, pur 99.81%, hit eff 97.16% +04_long_strange : 214/ 218 98.17% ( 98.02%), 6 ( 2.73%) clones, pur 99.58%, hit eff 95.93% +05_long_strange_P>5GeV : 113/ 116 97.41% ( 96.88%), 1 ( 0.88%) clones, pur 99.93%, hit eff 97.60% +08_long_electrons : 583/ 596 97.82% ( 98.11%), 21 ( 3.48%) clones, pur 98.35%, hit eff 96.22% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 1.027 ( 728/ 709) +Isolated : 1.027 ( 728/ 709) +Close : 0.000 ( 0/ 0) +False rate : 0.010 ( 7/ 735) +Real false rate : 0.010 ( 7/ 735) +Clones : 0.000 ( 0/ 728) + + +seed_validator validation: +TrackChecker output : 24/ 6951 0.35% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 1282/ 1386 92.50% ( 92.93%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.64% +01_long : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +---1. phi quadrant : 960/ 1175 81.70% ( 82.14%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.43% +---2. phi quadrant : 910/ 1135 80.18% ( 80.27%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.51% +---3. phi quadrant : 882/ 1116 79.03% ( 78.34%), 0 ( 0.00%) clones, pur 99.81%, hit eff 99.49% +---4. phi quadrant : 862/ 1085 79.45% ( 80.79%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.48% +---eta < 2.5, small x, large y : 7/ 81 8.64% ( 8.44%), 0 ( 0.00%) clones, pur 100.00%, hit eff 98.81% +---eta < 2.5, large x, small y : 46/ 152 30.26% ( 30.00%), 0 ( 0.00%) clones, pur 99.78%, hit eff 99.46% +---eta > 2.5, small x, large y : 1338/ 1599 83.68% ( 83.92%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.54% +---eta > 2.5, large x, small y : 2223/ 2679 82.98% ( 82.56%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.44% +02_long_P>5GeV : 2809/ 2941 95.51% ( 96.06%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.59% +02_long_P>5GeV, eta > 4 : 1526/ 1617 94.37% ( 95.47%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.63% +---eta < 2.5, small x, large y : 3/ 3 100.00% (100.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +---eta < 2.5, large x, small y : 14/ 15 93.33% ( 93.33%), 0 ( 0.00%) clones, pur 99.29%, hit eff 99.40% +---eta > 2.5, small x, large y : 1068/ 1102 96.91% ( 97.51%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.69% +---eta > 2.5, large x, small y : 1724/ 1821 94.67% ( 95.60%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.53% +03_long_P>3GeV : 3612/ 3885 92.97% ( 93.62%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.49% +04_long_P>0.5GeV : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +08_UT+SciFi : 400/ 696 57.47% ( 53.56%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.14% +09_UT+SciFi_P>5GeV : 242/ 255 94.90% ( 93.88%), 0 ( 0.00%) clones, pur 99.89%, hit eff 99.45% +10_UT+SciFi_P>3GeV : 397/ 456 87.06% ( 85.52%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.19% +11_UT+SciFi_fromStrange : 96/ 124 77.42% ( 77.81%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.30% +12_UT+SciFi_fromStrange_P>5GeV : 70/ 72 97.22% ( 96.77%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.51% +13_UT+SciFi_fromStrange_P>3GeV : 95/ 102 93.14% ( 91.25%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.38% +14_long_electrons : 318/ 596 53.36% ( 51.46%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +15_long_electrons_P>5GeV : 251/ 336 74.70% ( 74.40%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.11% +16_long_electrons_P>3GeV : 318/ 506 62.85% ( 60.17%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +19_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +21_long_strange_P>5GeV : 110/ 116 94.83% ( 95.83%), 0 ( 0.00%) clones, pur 99.77%, hit eff 99.61% +22_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.59%, hit eff 99.24% + + +long_validator validation: +TrackChecker output : 167/ 4015 4.16% ghosts +for P>3GeV,Pt>0.5GeV : 7/ 1237 0.57% ghosts +01_long : 3390/ 4511 75.15% ( 74.78%), 0 ( 0.00%) clones, pur 99.92%, hit eff 99.57% +02_long_P>5GeV : 2707/ 2941 92.04% ( 92.93%), 0 ( 0.00%) clones, pur 99.94%, hit eff 99.67% +03_long_strange : 148/ 218 67.89% ( 68.59%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.71% +04_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +07_long_electrons : 226/ 596 37.92% ( 37.58%), 0 ( 0.00%) clones, pur 99.30%, hit eff 99.22% +08_long_electrons_P>5GeV : 184/ 336 54.76% ( 56.04%), 0 ( 0.00%) clones, pur 99.24%, hit eff 99.18% +long_P>5GeV_AND_Pt>1GeV : 205/ 220 93.18% ( 93.68%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.92% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +15_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +16_long_strange_P>5GeV_PT>500MeV : 21/ 23 91.30% ( 91.30%), 0 ( 0.00%) clones, pur 99.70%, hit eff 99.21% + + +muon_validator validation: +Muon fraction in all MCPs: 917/ 68484 0.01% +Muon fraction in MCPs to which a track(s) was matched: 41/ 4533 0.01% +Correctly identified muons with isMuon: 40/ 41 97.56% +Correctly identified muons from strange decays with isMuon: 0/ 0 -nan% +Correctly identified muons from B decays with isMuon: 0/ 0 -nan% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 147/ 4492 3.27% +Ghost tracks identified as muon with isMuon: 8/ 167 4.79% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 15/ 1000, ( 450.00 +/- 115.31) kHz +Hlt1KsToPiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackKs: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuonNoMuID: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KK: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2PiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonLowMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMuonMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP_ss: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackElectronMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtElectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDielectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 15 27 +Hlt1KsToPiPi: 0 0 +Hlt1TrackMVA: 0 0 +Hlt1TwoTrackMVA: 0 0 +Hlt1TwoTrackKs: 0 0 +Hlt1SingleHighPtMuon: 0 0 +Hlt1SingleHighPtMuonNoMuID: 0 0 +Hlt1LowPtMuon: 0 0 +Hlt1D2KK: 0 0 +Hlt1D2KPi: 0 0 +Hlt1D2PiPi: 0 0 +Hlt1DiMuonHighMass: 0 0 +Hlt1DiMuonLowMass: 0 0 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 0 0 +Hlt1TrackMuonMVA: 0 0 +Hlt1DiMuonNoIP: 0 0 +Hlt1DiMuonNoIP_ss: 0 0 +Hlt1TrackElectronMVA: 0 0 +Hlt1SingleHighPtElectron: 0 0 +Hlt1DisplacedDielectron: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 0 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 1000 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 2 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 0 0 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 0 0 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 0 0 + +Total decisions: 2019 +Total tracks: 38 +Total SVs: 27 +Total hits: 678 +Total stdinfo: 2431 + diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt new file mode 100644 index 00000000000..9b45bd2b10e --- /dev/null +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt @@ -0,0 +1,209 @@ +velo_validator validation: +TrackChecker output : 94/ 13749 0.68% ghosts +01_velo : 7660/ 7805 98.14% ( 98.12%), 248 ( 3.14%) clones, pur 99.60%, hit eff 95.77% +02_long : 4466/ 4511 99.00% ( 98.92%), 123 ( 2.68%) clones, pur 99.74%, hit eff 96.55% +03_long_P>5GeV : 2925/ 2941 99.46% ( 99.35%), 70 ( 2.34%) clones, pur 99.81%, hit eff 97.16% +04_long_strange : 214/ 218 98.17% ( 98.02%), 6 ( 2.73%) clones, pur 99.58%, hit eff 95.93% +05_long_strange_P>5GeV : 113/ 116 97.41% ( 96.88%), 1 ( 0.88%) clones, pur 99.93%, hit eff 97.60% +08_long_electrons : 583/ 596 97.82% ( 98.16%), 23 ( 3.80%) clones, pur 98.31%, hit eff 95.94% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 1.025 ( 727/ 709) +Isolated : 1.025 ( 727/ 709) +Close : 0.000 ( 0/ 0) +False rate : 0.010 ( 7/ 734) +Real false rate : 0.010 ( 7/ 734) +Clones : 0.001 ( 1/ 727) + + +seed_validator validation: +TrackChecker output : 24/ 6951 0.35% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 1282/ 1386 92.50% ( 92.93%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.64% +01_long : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +---1. phi quadrant : 960/ 1175 81.70% ( 82.14%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.43% +---2. phi quadrant : 910/ 1135 80.18% ( 80.27%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.51% +---3. phi quadrant : 882/ 1116 79.03% ( 78.34%), 0 ( 0.00%) clones, pur 99.81%, hit eff 99.49% +---4. phi quadrant : 862/ 1085 79.45% ( 80.79%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.48% +---eta < 2.5, small x, large y : 7/ 81 8.64% ( 8.44%), 0 ( 0.00%) clones, pur 100.00%, hit eff 98.81% +---eta < 2.5, large x, small y : 46/ 152 30.26% ( 30.00%), 0 ( 0.00%) clones, pur 99.78%, hit eff 99.46% +---eta > 2.5, small x, large y : 1338/ 1599 83.68% ( 83.92%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.54% +---eta > 2.5, large x, small y : 2223/ 2679 82.98% ( 82.56%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.44% +02_long_P>5GeV : 2809/ 2941 95.51% ( 96.06%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.59% +02_long_P>5GeV, eta > 4 : 1526/ 1617 94.37% ( 95.47%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.63% +---eta < 2.5, small x, large y : 3/ 3 100.00% (100.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +---eta < 2.5, large x, small y : 14/ 15 93.33% ( 93.33%), 0 ( 0.00%) clones, pur 99.29%, hit eff 99.40% +---eta > 2.5, small x, large y : 1068/ 1102 96.91% ( 97.51%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.69% +---eta > 2.5, large x, small y : 1724/ 1821 94.67% ( 95.60%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.53% +03_long_P>3GeV : 3612/ 3885 92.97% ( 93.62%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.49% +04_long_P>0.5GeV : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +08_UT+SciFi : 400/ 696 57.47% ( 53.56%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.14% +09_UT+SciFi_P>5GeV : 242/ 255 94.90% ( 93.88%), 0 ( 0.00%) clones, pur 99.89%, hit eff 99.45% +10_UT+SciFi_P>3GeV : 397/ 456 87.06% ( 85.52%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.19% +11_UT+SciFi_fromStrange : 96/ 124 77.42% ( 77.81%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.30% +12_UT+SciFi_fromStrange_P>5GeV : 70/ 72 97.22% ( 96.77%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.51% +13_UT+SciFi_fromStrange_P>3GeV : 95/ 102 93.14% ( 91.25%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.38% +14_long_electrons : 318/ 596 53.36% ( 51.46%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +15_long_electrons_P>5GeV : 251/ 336 74.70% ( 74.40%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.11% +16_long_electrons_P>3GeV : 318/ 506 62.85% ( 60.17%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +19_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +21_long_strange_P>5GeV : 110/ 116 94.83% ( 95.83%), 0 ( 0.00%) clones, pur 99.77%, hit eff 99.61% +22_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.59%, hit eff 99.24% + + +long_validator validation: +TrackChecker output : 166/ 4017 4.13% ghosts +for P>3GeV,Pt>0.5GeV : 7/ 1238 0.57% ghosts +01_long : 3393/ 4511 75.22% ( 74.86%), 0 ( 0.00%) clones, pur 99.92%, hit eff 99.57% +02_long_P>5GeV : 2708/ 2941 92.08% ( 92.97%), 0 ( 0.00%) clones, pur 99.94%, hit eff 99.66% +03_long_strange : 148/ 218 67.89% ( 68.59%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.71% +04_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +07_long_electrons : 226/ 596 37.92% ( 37.63%), 0 ( 0.00%) clones, pur 99.28%, hit eff 99.22% +08_long_electrons_P>5GeV : 183/ 336 54.46% ( 55.82%), 0 ( 0.00%) clones, pur 99.20%, hit eff 99.18% +long_P>5GeV_AND_Pt>1GeV : 205/ 220 93.18% ( 93.68%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.92% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +15_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +16_long_strange_P>5GeV_PT>500MeV : 21/ 23 91.30% ( 91.30%), 0 ( 0.00%) clones, pur 99.70%, hit eff 99.21% + + +muon_validator validation: +Muon fraction in all MCPs: 917/ 68484 0.01% +Muon fraction in MCPs to which a track(s) was matched: 41/ 4538 0.01% +Correctly identified muons with isMuon: 40/ 41 97.56% +Correctly identified muons from strange decays with isMuon: 0/ 0 -nan% +Correctly identified muons from B decays with isMuon: 0/ 0 -nan% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 147/ 4497 3.27% +Ghost tracks identified as muon with isMuon: 8/ 166 4.82% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 15/ 1000, ( 450.00 +/- 115.31) kHz +Hlt1KsToPiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackKs: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuonNoMuID: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KK: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2PiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonLowMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMuonMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP_ss: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackElectronMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtElectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDielectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 15 25 +Hlt1KsToPiPi: 0 0 +Hlt1TrackMVA: 0 0 +Hlt1TwoTrackMVA: 0 0 +Hlt1TwoTrackKs: 0 0 +Hlt1SingleHighPtMuon: 0 0 +Hlt1SingleHighPtMuonNoMuID: 0 0 +Hlt1LowPtMuon: 0 0 +Hlt1D2KK: 0 0 +Hlt1D2KPi: 0 0 +Hlt1D2PiPi: 0 0 +Hlt1DiMuonHighMass: 0 0 +Hlt1DiMuonLowMass: 0 0 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 0 0 +Hlt1TrackMuonMVA: 0 0 +Hlt1DiMuonNoIP: 0 0 +Hlt1DiMuonNoIP_ss: 0 0 +Hlt1TrackElectronMVA: 0 0 +Hlt1SingleHighPtElectron: 0 0 +Hlt1DisplacedDielectron: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 0 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 1000 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 2 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 0 0 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 0 0 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 0 0 + +Total decisions: 2019 +Total tracks: 37 +Total SVs: 25 +Total hits: 663 +Total stdinfo: 2415 + diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt new file mode 100644 index 00000000000..9b45bd2b10e --- /dev/null +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt @@ -0,0 +1,209 @@ +velo_validator validation: +TrackChecker output : 94/ 13749 0.68% ghosts +01_velo : 7660/ 7805 98.14% ( 98.12%), 248 ( 3.14%) clones, pur 99.60%, hit eff 95.77% +02_long : 4466/ 4511 99.00% ( 98.92%), 123 ( 2.68%) clones, pur 99.74%, hit eff 96.55% +03_long_P>5GeV : 2925/ 2941 99.46% ( 99.35%), 70 ( 2.34%) clones, pur 99.81%, hit eff 97.16% +04_long_strange : 214/ 218 98.17% ( 98.02%), 6 ( 2.73%) clones, pur 99.58%, hit eff 95.93% +05_long_strange_P>5GeV : 113/ 116 97.41% ( 96.88%), 1 ( 0.88%) clones, pur 99.93%, hit eff 97.60% +08_long_electrons : 583/ 596 97.82% ( 98.16%), 23 ( 3.80%) clones, pur 98.31%, hit eff 95.94% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 1.025 ( 727/ 709) +Isolated : 1.025 ( 727/ 709) +Close : 0.000 ( 0/ 0) +False rate : 0.010 ( 7/ 734) +Real false rate : 0.010 ( 7/ 734) +Clones : 0.001 ( 1/ 727) + + +seed_validator validation: +TrackChecker output : 24/ 6951 0.35% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 1282/ 1386 92.50% ( 92.93%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.64% +01_long : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +---1. phi quadrant : 960/ 1175 81.70% ( 82.14%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.43% +---2. phi quadrant : 910/ 1135 80.18% ( 80.27%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.51% +---3. phi quadrant : 882/ 1116 79.03% ( 78.34%), 0 ( 0.00%) clones, pur 99.81%, hit eff 99.49% +---4. phi quadrant : 862/ 1085 79.45% ( 80.79%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.48% +---eta < 2.5, small x, large y : 7/ 81 8.64% ( 8.44%), 0 ( 0.00%) clones, pur 100.00%, hit eff 98.81% +---eta < 2.5, large x, small y : 46/ 152 30.26% ( 30.00%), 0 ( 0.00%) clones, pur 99.78%, hit eff 99.46% +---eta > 2.5, small x, large y : 1338/ 1599 83.68% ( 83.92%), 0 ( 0.00%) clones, pur 99.85%, hit eff 99.54% +---eta > 2.5, large x, small y : 2223/ 2679 82.98% ( 82.56%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.44% +02_long_P>5GeV : 2809/ 2941 95.51% ( 96.06%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.59% +02_long_P>5GeV, eta > 4 : 1526/ 1617 94.37% ( 95.47%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.63% +---eta < 2.5, small x, large y : 3/ 3 100.00% (100.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +---eta < 2.5, large x, small y : 14/ 15 93.33% ( 93.33%), 0 ( 0.00%) clones, pur 99.29%, hit eff 99.40% +---eta > 2.5, small x, large y : 1068/ 1102 96.91% ( 97.51%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.69% +---eta > 2.5, large x, small y : 1724/ 1821 94.67% ( 95.60%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.53% +03_long_P>3GeV : 3612/ 3885 92.97% ( 93.62%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.49% +04_long_P>0.5GeV : 3614/ 4511 80.12% ( 79.78%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.48% +08_UT+SciFi : 400/ 696 57.47% ( 53.56%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.14% +09_UT+SciFi_P>5GeV : 242/ 255 94.90% ( 93.88%), 0 ( 0.00%) clones, pur 99.89%, hit eff 99.45% +10_UT+SciFi_P>3GeV : 397/ 456 87.06% ( 85.52%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.19% +11_UT+SciFi_fromStrange : 96/ 124 77.42% ( 77.81%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.30% +12_UT+SciFi_fromStrange_P>5GeV : 70/ 72 97.22% ( 96.77%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.51% +13_UT+SciFi_fromStrange_P>3GeV : 95/ 102 93.14% ( 91.25%), 0 ( 0.00%) clones, pur 99.90%, hit eff 99.38% +14_long_electrons : 318/ 596 53.36% ( 51.46%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +15_long_electrons_P>5GeV : 251/ 336 74.70% ( 74.40%), 0 ( 0.00%) clones, pur 99.82%, hit eff 99.11% +16_long_electrons_P>3GeV : 318/ 506 62.85% ( 60.17%), 0 ( 0.00%) clones, pur 99.86%, hit eff 99.16% +19_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +21_long_strange_P>5GeV : 110/ 116 94.83% ( 95.83%), 0 ( 0.00%) clones, pur 99.77%, hit eff 99.61% +22_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.59%, hit eff 99.24% + + +long_validator validation: +TrackChecker output : 166/ 4017 4.13% ghosts +for P>3GeV,Pt>0.5GeV : 7/ 1238 0.57% ghosts +01_long : 3393/ 4511 75.22% ( 74.86%), 0 ( 0.00%) clones, pur 99.92%, hit eff 99.57% +02_long_P>5GeV : 2708/ 2941 92.08% ( 92.97%), 0 ( 0.00%) clones, pur 99.94%, hit eff 99.66% +03_long_strange : 148/ 218 67.89% ( 68.59%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.71% +04_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +07_long_electrons : 226/ 596 37.92% ( 37.63%), 0 ( 0.00%) clones, pur 99.28%, hit eff 99.22% +08_long_electrons_P>5GeV : 183/ 336 54.46% ( 55.82%), 0 ( 0.00%) clones, pur 99.20%, hit eff 99.18% +long_P>5GeV_AND_Pt>1GeV : 205/ 220 93.18% ( 93.68%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.92% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 7/ 8 87.50% ( 87.50%), 0 ( 0.00%) clones, pur 100.00%, hit eff 100.00% +15_long_strange_P>5GeV : 104/ 116 89.66% ( 90.62%), 0 ( 0.00%) clones, pur 99.91%, hit eff 99.68% +16_long_strange_P>5GeV_PT>500MeV : 21/ 23 91.30% ( 91.30%), 0 ( 0.00%) clones, pur 99.70%, hit eff 99.21% + + +muon_validator validation: +Muon fraction in all MCPs: 917/ 68484 0.01% +Muon fraction in MCPs to which a track(s) was matched: 41/ 4538 0.01% +Correctly identified muons with isMuon: 40/ 41 97.56% +Correctly identified muons from strange decays with isMuon: 0/ 0 -nan% +Correctly identified muons from B decays with isMuon: 0/ 0 -nan% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 147/ 4497 3.27% +Ghost tracks identified as muon with isMuon: 8/ 166 4.82% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 15/ 1000, ( 450.00 +/- 115.31) kHz +Hlt1KsToPiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TwoTrackKs: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtMuonNoMuID: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KK: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2PiPi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonLowMass: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowPtDiMuon: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackMuonMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonNoIP_ss: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1TrackElectronMVA: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighPtElectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDielectron: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 15 25 +Hlt1KsToPiPi: 0 0 +Hlt1TrackMVA: 0 0 +Hlt1TwoTrackMVA: 0 0 +Hlt1TwoTrackKs: 0 0 +Hlt1SingleHighPtMuon: 0 0 +Hlt1SingleHighPtMuonNoMuID: 0 0 +Hlt1LowPtMuon: 0 0 +Hlt1D2KK: 0 0 +Hlt1D2KPi: 0 0 +Hlt1D2PiPi: 0 0 +Hlt1DiMuonHighMass: 0 0 +Hlt1DiMuonLowMass: 0 0 +Hlt1DiMuonSoft: 0 0 +Hlt1LowPtDiMuon: 0 0 +Hlt1TrackMuonMVA: 0 0 +Hlt1DiMuonNoIP: 0 0 +Hlt1DiMuonNoIP_ss: 0 0 +Hlt1TrackElectronMVA: 0 0 +Hlt1SingleHighPtElectron: 0 0 +Hlt1DisplacedDielectron: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 0 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 1000 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 2 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 0 0 +Hlt1RICH2Alignment: 0 0 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 0 0 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 0 0 + +Total decisions: 2019 +Total tracks: 37 +Total SVs: 25 +Total hits: 663 +Total stdinfo: 2415 + diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_a5000.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_a5000.txt index 56dce9f7f29..f94da8c9fcf 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_a5000.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_a5000.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_epyc7502.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_epyc7502.txt index b7cba9da867..d178b0a308d 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_epyc7502.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_epyc7502.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 7/ 1317 0.53% 07_long_electrons : 51/ 596 8.56% ( 9.44%), 1 ( 1.92%) clones, pur 99.36%, hit eff 99.84% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.25%), 1 ( 2.04%) clones, pur 99.32%, hit eff 99.83% long_P>5GeV_AND_Pt>1GeV : 210/ 220 95.45% ( 96.55%), 5 ( 2.33%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 55/ 116 47.41% ( 48.09%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt index 56dce9f7f29..f94da8c9fcf 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt index 56dce9f7f29..f94da8c9fcf 100644 --- a/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt +++ b/test/reference/SMOG2_pHe_5k_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt @@ -45,6 +45,11 @@ for P>3GeV,Pt>0.5GeV : 8/ 1315 0.61% 07_long_electrons : 51/ 596 8.56% ( 9.21%), 1 ( 1.92%) clones, pur 99.45%, hit eff 99.68% 08_long_electrons_P>5GeV : 48/ 336 14.29% ( 14.03%), 1 ( 2.04%) clones, pur 99.42%, hit eff 99.66% long_P>5GeV_AND_Pt>1GeV : 209/ 220 95.00% ( 95.98%), 5 ( 2.34%) clones, pur 99.85%, hit eff 99.96% +11_noVelo_UT : 0/ 608 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 260 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 8/ 8 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.31%, hit eff 100.00% +15_long_strange_P>5GeV : 54/ 116 46.55% ( 47.05%), 0 ( 0.00%) clones, pur 99.95%, hit eff 99.83% +16_long_strange_P>5GeV_PT>500MeV : 22/ 23 95.65% ( 95.65%), 0 ( 0.00%) clones, pur 99.87%, hit eff 99.17% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_a5000.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_a5000.txt index d2c012d5f3b..60e1318bf9c 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_a5000.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_a5000.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 737/ 30011 2.46% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.96%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13155/ 14488 90.80% ( 91.47%), 106 ( 0.80%) clones, pur 99.55%, hit eff 99.09% long_fromB_P>5GeV_AND_Pt>1GeV : 2122/ 2316 91.62% ( 91.53%), 12 ( 0.56%) clones, pur 99.56%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4007/ 4311 92.95% ( 93.35%), 29 ( 0.72%) clones, pur 99.58%, hit eff 99.19% +14_long_from_B_PT>2GeV : 956/ 1034 92.46% ( 92.53%), 5 ( 0.52%) clones, pur 99.54%, hit eff 99.36% +15_long_strange_P>5GeV : 928/ 1518 61.13% ( 60.07%), 5 ( 0.54%) clones, pur 99.27%, hit eff 98.71% +16_long_strange_P>5GeV_PT>500MeV : 569/ 647 87.94% ( 88.20%), 4 ( 0.70%) clones, pur 99.23%, hit eff 98.71% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_epyc7502.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_epyc7502.txt index d2a7d6060d6..4bc4527a48c 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_epyc7502.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_epyc7502.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 944/ 28969 3.26% 10_long_fromB_electrons_P>5GeV : 76/ 158 48.10% ( 50.00%), 0 ( 0.00%) clones, pur 99.11%, hit eff 98.49% long_P>5GeV_AND_Pt>1GeV : 12677/ 14488 87.50% ( 89.07%), 100 ( 0.78%) clones, pur 99.32%, hit eff 98.43% long_fromB_P>5GeV_AND_Pt>1GeV : 2072/ 2316 89.46% ( 89.45%), 12 ( 0.58%) clones, pur 99.38%, hit eff 98.82% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3886/ 4311 90.14% ( 91.17%), 28 ( 0.72%) clones, pur 99.42%, hit eff 98.76% +14_long_from_B_PT>2GeV : 938/ 1034 90.72% ( 90.40%), 5 ( 0.53%) clones, pur 99.42%, hit eff 99.07% +15_long_strange_P>5GeV : 885/ 1518 58.30% ( 58.09%), 4 ( 0.45%) clones, pur 99.00%, hit eff 97.98% +16_long_strange_P>5GeV_PT>500MeV : 539/ 647 83.31% ( 83.66%), 3 ( 0.55%) clones, pur 99.04%, hit eff 98.22% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx2080ti.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx2080ti.txt index d2c012d5f3b..60e1318bf9c 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx2080ti.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx2080ti.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 737/ 30011 2.46% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.96%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13155/ 14488 90.80% ( 91.47%), 106 ( 0.80%) clones, pur 99.55%, hit eff 99.09% long_fromB_P>5GeV_AND_Pt>1GeV : 2122/ 2316 91.62% ( 91.53%), 12 ( 0.56%) clones, pur 99.56%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4007/ 4311 92.95% ( 93.35%), 29 ( 0.72%) clones, pur 99.58%, hit eff 99.19% +14_long_from_B_PT>2GeV : 956/ 1034 92.46% ( 92.53%), 5 ( 0.52%) clones, pur 99.54%, hit eff 99.36% +15_long_strange_P>5GeV : 928/ 1518 61.13% ( 60.07%), 5 ( 0.54%) clones, pur 99.27%, hit eff 98.71% +16_long_strange_P>5GeV_PT>500MeV : 569/ 647 87.94% ( 88.20%), 4 ( 0.70%) clones, pur 99.23%, hit eff 98.71% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx3090.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx3090.txt index d2c012d5f3b..60e1318bf9c 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx3090.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_1k_hlt1_pp_veloSP_validation_geforcertx3090.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 737/ 30011 2.46% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.96%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13155/ 14488 90.80% ( 91.47%), 106 ( 0.80%) clones, pur 99.55%, hit eff 99.09% long_fromB_P>5GeV_AND_Pt>1GeV : 2122/ 2316 91.62% ( 91.53%), 12 ( 0.56%) clones, pur 99.56%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4007/ 4311 92.95% ( 93.35%), 29 ( 0.72%) clones, pur 99.58%, hit eff 99.19% +14_long_from_B_PT>2GeV : 956/ 1034 92.46% ( 92.53%), 5 ( 0.52%) clones, pur 99.54%, hit eff 99.36% +15_long_strange_P>5GeV : 928/ 1518 61.13% ( 60.07%), 5 ( 0.54%) clones, pur 99.27%, hit eff 98.71% +16_long_strange_P>5GeV_PT>500MeV : 569/ 647 87.94% ( 88.20%), 4 ( 0.70%) clones, pur 99.23%, hit eff 98.71% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt new file mode 100644 index 00000000000..b0ac42b0227 --- /dev/null +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt @@ -0,0 +1,225 @@ +velo_validator validation: +TrackChecker output : 1893/ 233746 0.81% ghosts +01_velo : 99543/ 101231 98.33% ( 98.41%), 1934 ( 1.91%) clones, pur 99.64%, hit eff 96.94% +02_long : 59647/ 60099 99.25% ( 99.28%), 796 ( 1.32%) clones, pur 99.76%, hit eff 97.99% +03_long_P>5GeV : 41627/ 41818 99.54% ( 99.58%), 434 ( 1.03%) clones, pur 99.79%, hit eff 98.48% +04_long_strange : 3111/ 3179 97.86% ( 97.63%), 38 ( 1.21%) clones, pur 99.21%, hit eff 97.47% +05_long_strange_P>5GeV : 1481/ 1518 97.56% ( 97.55%), 14 ( 0.94%) clones, pur 99.01%, hit eff 98.54% +06_long_fromB : 4326/ 4364 99.13% ( 99.36%), 54 ( 1.23%) clones, pur 99.71%, hit eff 97.89% +07_long_fromB_P>5GeV : 3546/ 3568 99.38% ( 99.53%), 31 ( 0.87%) clones, pur 99.77%, hit eff 98.35% +08_long_electrons : 4918/ 5058 97.23% ( 97.36%), 220 ( 4.28%) clones, pur 97.75%, hit eff 96.34% +09_long_fromB_electrons : 240/ 245 97.96% ( 98.65%), 10 ( 4.00%) clones, pur 97.29%, hit eff 96.38% +10_long_fromB_electrons_P>5GeV : 154/ 158 97.47% ( 98.31%), 6 ( 3.75%) clones, pur 97.34%, hit eff 96.97% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.945 ( 4942/ 5230) +Isolated : 0.983 ( 2687/ 2733) +Close : 0.903 ( 2255/ 2497) +False rate : 0.008 ( 42/ 4984) +Real false rate : 0.008 ( 42/ 4984) +Clones : 0.000 ( 0/ 4942) + + +seed_validator validation: +TrackChecker output : 9211/ 88454 10.41% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 28680/ 32005 89.61% ( 90.71%), 2 ( 0.01%) clones, pur 99.25%, hit eff 98.54% +01_long : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +---1. phi quadrant : 11845/ 15124 78.32% ( 79.55%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.48% +---2. phi quadrant : 11874/ 15068 78.80% ( 79.48%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.52% +---3. phi quadrant : 11968/ 15176 78.86% ( 79.59%), 1 ( 0.01%) clones, pur 99.27%, hit eff 98.46% +---4. phi quadrant : 11607/ 14730 78.80% ( 79.52%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.47% +---eta < 2.5, small x, large y : 873/ 2426 35.99% ( 36.74%), 0 ( 0.00%) clones, pur 98.44%, hit eff 97.19% +---eta < 2.5, large x, small y : 2928/ 4886 59.93% ( 59.54%), 0 ( 0.00%) clones, pur 99.23%, hit eff 98.43% +---eta > 2.5, small x, large y : 15538/ 18801 82.64% ( 83.60%), 2 ( 0.01%) clones, pur 99.32%, hit eff 98.56% +---eta > 2.5, large x, small y : 27955/ 33986 82.25% ( 83.08%), 1 ( 0.00%) clones, pur 99.31%, hit eff 98.49% +02_long_P>5GeV : 38439/ 41818 91.92% ( 92.98%), 3 ( 0.01%) clones, pur 99.30%, hit eff 98.59% +02_long_P>5GeV, eta > 4 : 13817/ 15282 90.41% ( 91.79%), 2 ( 0.01%) clones, pur 99.09%, hit eff 98.40% +---eta < 2.5, small x, large y : 621/ 900 69.00% ( 69.33%), 0 ( 0.00%) clones, pur 98.89%, hit eff 98.24% +---eta < 2.5, large x, small y : 1866/ 1982 94.15% ( 94.21%), 0 ( 0.00%) clones, pur 99.59%, hit eff 98.93% +---eta > 2.5, small x, large y : 12948/ 13981 92.61% ( 93.86%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.62% +---eta > 2.5, large x, small y : 23004/ 24955 92.18% ( 93.25%), 1 ( 0.00%) clones, pur 99.29%, hit eff 98.55% +03_long_P>3GeV : 47268/ 52572 89.91% ( 90.83%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +04_long_P>0.5GeV : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +05_long_from_B : 3726/ 4364 85.38% ( 85.99%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +06_long_from_B_P>5GeV : 3319/ 3568 93.02% ( 92.84%), 1 ( 0.03%) clones, pur 99.36%, hit eff 98.75% +07_long_from_B_P>3GeV : 3725/ 4065 91.64% ( 91.49%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +08_UT+SciFi : 5779/ 9192 62.87% ( 62.23%), 0 ( 0.00%) clones, pur 99.14%, hit eff 98.13% +09_UT+SciFi_P>5GeV : 3718/ 4045 91.92% ( 92.84%), 0 ( 0.00%) clones, pur 99.18%, hit eff 98.44% +10_UT+SciFi_P>3GeV : 5738/ 6587 87.11% ( 87.60%), 0 ( 0.00%) clones, pur 99.15%, hit eff 98.16% +11_UT+SciFi_fromStrange : 2327/ 3252 71.56% ( 71.92%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.35% +12_UT+SciFi_fromStrange_P>5GeV : 1687/ 1827 92.34% ( 92.56%), 0 ( 0.00%) clones, pur 99.24%, hit eff 98.47% +13_UT+SciFi_fromStrange_P>3GeV : 2322/ 2606 89.10% ( 89.69%), 0 ( 0.00%) clones, pur 99.27%, hit eff 98.35% +14_long_electrons : 2792/ 5058 55.20% ( 55.01%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +15_long_electrons_P>5GeV : 2184/ 2838 76.96% ( 77.54%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.28% +16_long_electrons_P>3GeV : 2792/ 4161 67.10% ( 67.32%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +17_long_fromB_electrons : 141/ 245 57.55% ( 57.08%), 0 ( 0.00%) clones, pur 99.02%, hit eff 97.66% +18_long_fromB_electrons_P>5GeV : 122/ 158 77.22% ( 76.69%), 0 ( 0.00%) clones, pur 99.34%, hit eff 98.21% +19_long_PT>2GeV : 3916/ 4311 90.84% ( 92.02%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.64% +20_long_from_B_PT>2GeV : 960/ 1034 92.84% ( 93.23%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.68% +21_long_strange_P>5GeV : 1403/ 1518 92.42% ( 92.65%), 0 ( 0.00%) clones, pur 99.47%, hit eff 98.74% +22_long_strange_P>5GeV_PT>500MeV : 591/ 647 91.34% ( 91.36%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.73% + + +long_validator validation: +TrackChecker output : 4296/ 52029 8.26% ghosts +for P>3GeV,Pt>0.5GeV : 1207/ 29847 4.04% ghosts +01_long : 44228/ 60099 73.59% ( 74.71%), 2 ( 0.00%) clones, pur 99.65%, hit eff 98.69% +02_long_P>5GeV : 36779/ 41818 87.95% ( 89.23%), 2 ( 0.01%) clones, pur 99.65%, hit eff 98.77% +03_long_strange : 1879/ 3179 59.11% ( 57.51%), 0 ( 0.00%) clones, pur 99.56%, hit eff 98.71% +04_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +05_long_fromB : 3559/ 4364 81.55% ( 82.52%), 0 ( 0.00%) clones, pur 99.65%, hit eff 98.87% +06_long_fromB_P>5GeV : 3210/ 3568 89.97% ( 89.93%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.93% +07_long_electrons : 1974/ 5058 39.03% ( 39.64%), 1 ( 0.05%) clones, pur 99.09%, hit eff 98.41% +08_long_electrons_P>5GeV : 1601/ 2838 56.41% ( 57.87%), 1 ( 0.06%) clones, pur 99.08%, hit eff 98.44% +09_long_fromB_electrons : 110/ 245 44.90% ( 46.23%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.45% +10_long_fromB_electrons_P>5GeV : 100/ 158 63.29% ( 65.79%), 0 ( 0.00%) clones, pur 99.22%, hit eff 98.38% +long_P>5GeV_AND_Pt>1GeV : 12866/ 14488 88.80% ( 89.90%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.87% +long_fromB_P>5GeV_AND_Pt>1GeV : 2098/ 2316 90.59% ( 90.76%), 0 ( 0.00%) clones, pur 99.63%, hit eff 98.94% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3865/ 4311 89.65% ( 90.93%), 0 ( 0.00%) clones, pur 99.62%, hit eff 98.80% +14_long_from_B_PT>2GeV : 941/ 1034 91.01% ( 91.08%), 0 ( 0.00%) clones, pur 99.60%, hit eff 98.85% +15_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +16_long_strange_P>5GeV_PT>500MeV : 563/ 647 87.02% ( 87.30%), 0 ( 0.00%) clones, pur 99.45%, hit eff 98.81% + + +muon_validator validation: +Muon fraction in all MCPs: 11914/ 879199 0.01% +Muon fraction in MCPs to which a track(s) was matched: 607/ 55879 0.01% +Correctly identified muons with isMuon: 551/ 607 90.77% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 107/ 116 92.24% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 6429/ 55272 11.63% +Ghost tracks identified as muon with isMuon: 770/ 4296 17.92% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 640/ 1000, (19200.00 +/- 455.37) kHz +Hlt1KsToPiPi: 50/ 1000, ( 1500.00 +/- 206.76) kHz +Hlt1TrackMVA: 218/ 1000, ( 6540.00 +/- 391.70) kHz +Hlt1TwoTrackMVA: 475/ 1000, (14250.00 +/- 473.75) kHz +Hlt1TwoTrackKs: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowPtMuon: 285/ 1000, ( 8550.00 +/- 428.25) kHz +Hlt1D2KK: 17/ 1000, ( 510.00 +/- 122.64) kHz +Hlt1D2KPi: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1D2PiPi: 36/ 1000, ( 1080.00 +/- 176.73) kHz +Hlt1DiMuonHighMass: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1DiMuonLowMass: 53/ 1000, ( 1590.00 +/- 212.54) kHz +Hlt1DiMuonSoft: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtDiMuon: 125/ 1000, ( 3750.00 +/- 313.75) kHz +Hlt1TrackMuonMVA: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1DiMuonNoIP: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1DiMuonNoIP_ss: 8/ 1000, ( 240.00 +/- 84.51) kHz +Hlt1TrackElectronMVA: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1SingleHighPtElectron: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DisplacedDielectron: 7/ 1000, ( 210.00 +/- 79.09) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 47/ 1000, ( 1410.00 +/- 200.78) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 926/ 1000, (27780.00 +/- 248.34) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1RICH2Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 2/ 1000, ( 60.00 +/- 42.38) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 640 1755 +Hlt1KsToPiPi: 50 57 +Hlt1TrackMVA: 218 318 +Hlt1TwoTrackMVA: 475 1426 +Hlt1TwoTrackKs: 3 3 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 4 4 +Hlt1LowPtMuon: 285 384 +Hlt1D2KK: 17 19 +Hlt1D2KPi: 35 36 +Hlt1D2PiPi: 36 37 +Hlt1DiMuonHighMass: 29 30 +Hlt1DiMuonLowMass: 53 71 +Hlt1DiMuonSoft: 2 2 +Hlt1LowPtDiMuon: 125 193 +Hlt1TrackMuonMVA: 12 12 +Hlt1DiMuonNoIP: 41 48 +Hlt1DiMuonNoIP_ss: 8 8 +Hlt1TrackElectronMVA: 41 42 +Hlt1SingleHighPtElectron: 16 16 +Hlt1DisplacedDielectron: 7 10 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4 4 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 47 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 926 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 4 5 +Hlt1RICH2Alignment: 1 1 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 35 36 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 2 2 + +Total decisions: 4128 +Total tracks: 3720 +Total SVs: 2938 +Total hits: 75496 +Total stdinfo: 45640 + diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt new file mode 100644 index 00000000000..0d4809c7c13 --- /dev/null +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt @@ -0,0 +1,225 @@ +velo_validator validation: +TrackChecker output : 1872/ 233781 0.80% ghosts +01_velo : 99533/ 101231 98.32% ( 98.40%), 1913 ( 1.89%) clones, pur 99.64%, hit eff 96.97% +02_long : 59645/ 60099 99.24% ( 99.28%), 792 ( 1.31%) clones, pur 99.77%, hit eff 98.00% +03_long_P>5GeV : 41627/ 41818 99.54% ( 99.57%), 430 ( 1.02%) clones, pur 99.79%, hit eff 98.49% +04_long_strange : 3112/ 3179 97.89% ( 97.54%), 37 ( 1.17%) clones, pur 99.20%, hit eff 97.52% +05_long_strange_P>5GeV : 1482/ 1518 97.63% ( 97.44%), 13 ( 0.87%) clones, pur 99.01%, hit eff 98.63% +06_long_fromB : 4326/ 4364 99.13% ( 99.36%), 55 ( 1.26%) clones, pur 99.72%, hit eff 97.88% +07_long_fromB_P>5GeV : 3546/ 3568 99.38% ( 99.53%), 31 ( 0.87%) clones, pur 99.77%, hit eff 98.35% +08_long_electrons : 4923/ 5058 97.33% ( 97.37%), 217 ( 4.22%) clones, pur 97.83%, hit eff 96.46% +09_long_fromB_electrons : 240/ 245 97.96% ( 98.65%), 9 ( 3.61%) clones, pur 97.59%, hit eff 96.68% +10_long_fromB_electrons_P>5GeV : 154/ 158 97.47% ( 98.31%), 5 ( 3.14%) clones, pur 97.58%, hit eff 97.21% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.946 ( 4950/ 5230) +Isolated : 0.984 ( 2689/ 2733) +Close : 0.905 ( 2261/ 2497) +False rate : 0.008 ( 42/ 4992) +Real false rate : 0.008 ( 42/ 4992) +Clones : 0.000 ( 0/ 4950) + + +seed_validator validation: +TrackChecker output : 9212/ 88456 10.41% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 28680/ 32005 89.61% ( 90.71%), 2 ( 0.01%) clones, pur 99.25%, hit eff 98.54% +01_long : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +---1. phi quadrant : 11845/ 15124 78.32% ( 79.55%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.48% +---2. phi quadrant : 11874/ 15068 78.80% ( 79.48%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.52% +---3. phi quadrant : 11968/ 15176 78.86% ( 79.59%), 1 ( 0.01%) clones, pur 99.27%, hit eff 98.46% +---4. phi quadrant : 11607/ 14730 78.80% ( 79.52%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.47% +---eta < 2.5, small x, large y : 873/ 2426 35.99% ( 36.74%), 0 ( 0.00%) clones, pur 98.44%, hit eff 97.19% +---eta < 2.5, large x, small y : 2928/ 4886 59.93% ( 59.54%), 0 ( 0.00%) clones, pur 99.23%, hit eff 98.43% +---eta > 2.5, small x, large y : 15538/ 18801 82.64% ( 83.60%), 2 ( 0.01%) clones, pur 99.32%, hit eff 98.56% +---eta > 2.5, large x, small y : 27955/ 33986 82.25% ( 83.08%), 1 ( 0.00%) clones, pur 99.31%, hit eff 98.49% +02_long_P>5GeV : 38439/ 41818 91.92% ( 92.98%), 3 ( 0.01%) clones, pur 99.30%, hit eff 98.59% +02_long_P>5GeV, eta > 4 : 13817/ 15282 90.41% ( 91.79%), 2 ( 0.01%) clones, pur 99.09%, hit eff 98.40% +---eta < 2.5, small x, large y : 621/ 900 69.00% ( 69.33%), 0 ( 0.00%) clones, pur 98.89%, hit eff 98.24% +---eta < 2.5, large x, small y : 1866/ 1982 94.15% ( 94.21%), 0 ( 0.00%) clones, pur 99.59%, hit eff 98.93% +---eta > 2.5, small x, large y : 12948/ 13981 92.61% ( 93.86%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.62% +---eta > 2.5, large x, small y : 23004/ 24955 92.18% ( 93.25%), 1 ( 0.00%) clones, pur 99.29%, hit eff 98.55% +03_long_P>3GeV : 47268/ 52572 89.91% ( 90.83%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +04_long_P>0.5GeV : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +05_long_from_B : 3726/ 4364 85.38% ( 85.99%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +06_long_from_B_P>5GeV : 3319/ 3568 93.02% ( 92.84%), 1 ( 0.03%) clones, pur 99.36%, hit eff 98.75% +07_long_from_B_P>3GeV : 3725/ 4065 91.64% ( 91.49%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +08_UT+SciFi : 5779/ 9192 62.87% ( 62.23%), 1 ( 0.02%) clones, pur 99.14%, hit eff 98.13% +09_UT+SciFi_P>5GeV : 3718/ 4045 91.92% ( 92.84%), 0 ( 0.00%) clones, pur 99.18%, hit eff 98.44% +10_UT+SciFi_P>3GeV : 5738/ 6587 87.11% ( 87.60%), 1 ( 0.02%) clones, pur 99.15%, hit eff 98.16% +11_UT+SciFi_fromStrange : 2327/ 3252 71.56% ( 71.92%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.35% +12_UT+SciFi_fromStrange_P>5GeV : 1687/ 1827 92.34% ( 92.56%), 0 ( 0.00%) clones, pur 99.24%, hit eff 98.47% +13_UT+SciFi_fromStrange_P>3GeV : 2322/ 2606 89.10% ( 89.69%), 0 ( 0.00%) clones, pur 99.27%, hit eff 98.35% +14_long_electrons : 2792/ 5058 55.20% ( 55.01%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +15_long_electrons_P>5GeV : 2184/ 2838 76.96% ( 77.54%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.28% +16_long_electrons_P>3GeV : 2792/ 4161 67.10% ( 67.32%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +17_long_fromB_electrons : 141/ 245 57.55% ( 57.08%), 0 ( 0.00%) clones, pur 99.02%, hit eff 97.66% +18_long_fromB_electrons_P>5GeV : 122/ 158 77.22% ( 76.69%), 0 ( 0.00%) clones, pur 99.34%, hit eff 98.21% +19_long_PT>2GeV : 3916/ 4311 90.84% ( 92.02%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.64% +20_long_from_B_PT>2GeV : 960/ 1034 92.84% ( 93.23%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.68% +21_long_strange_P>5GeV : 1403/ 1518 92.42% ( 92.65%), 0 ( 0.00%) clones, pur 99.47%, hit eff 98.74% +22_long_strange_P>5GeV_PT>500MeV : 591/ 647 91.34% ( 91.36%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.73% + + +long_validator validation: +TrackChecker output : 4306/ 52081 8.27% ghosts +for P>3GeV,Pt>0.5GeV : 1204/ 29880 4.03% ghosts +01_long : 44274/ 60099 73.67% ( 74.77%), 2 ( 0.00%) clones, pur 99.65%, hit eff 98.69% +02_long_P>5GeV : 36817/ 41818 88.04% ( 89.30%), 2 ( 0.01%) clones, pur 99.65%, hit eff 98.77% +03_long_strange : 1882/ 3179 59.20% ( 57.68%), 0 ( 0.00%) clones, pur 99.57%, hit eff 98.69% +04_long_strange_P>5GeV : 1298/ 1518 85.51% ( 86.23%), 0 ( 0.00%) clones, pur 99.56%, hit eff 98.83% +05_long_fromB : 3563/ 4364 81.65% ( 82.61%), 0 ( 0.00%) clones, pur 99.64%, hit eff 98.85% +06_long_fromB_P>5GeV : 3214/ 3568 90.08% ( 90.02%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.90% +07_long_electrons : 1972/ 5058 38.99% ( 39.52%), 1 ( 0.05%) clones, pur 99.09%, hit eff 98.39% +08_long_electrons_P>5GeV : 1597/ 2838 56.27% ( 57.70%), 1 ( 0.06%) clones, pur 99.08%, hit eff 98.43% +09_long_fromB_electrons : 110/ 245 44.90% ( 46.23%), 0 ( 0.00%) clones, pur 99.21%, hit eff 98.45% +10_long_fromB_electrons_P>5GeV : 100/ 158 63.29% ( 65.79%), 0 ( 0.00%) clones, pur 99.13%, hit eff 98.38% +long_P>5GeV_AND_Pt>1GeV : 12882/ 14488 88.91% ( 89.99%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.87% +long_fromB_P>5GeV_AND_Pt>1GeV : 2101/ 2316 90.72% ( 90.87%), 0 ( 0.00%) clones, pur 99.63%, hit eff 98.92% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3871/ 4311 89.79% ( 91.01%), 0 ( 0.00%) clones, pur 99.62%, hit eff 98.79% +14_long_from_B_PT>2GeV : 944/ 1034 91.30% ( 91.39%), 0 ( 0.00%) clones, pur 99.60%, hit eff 98.83% +15_long_strange_P>5GeV : 1298/ 1518 85.51% ( 86.23%), 0 ( 0.00%) clones, pur 99.56%, hit eff 98.83% +16_long_strange_P>5GeV_PT>500MeV : 567/ 647 87.64% ( 87.64%), 0 ( 0.00%) clones, pur 99.47%, hit eff 98.79% + + +muon_validator validation: +Muon fraction in all MCPs: 11914/ 879199 0.01% +Muon fraction in MCPs to which a track(s) was matched: 604/ 55918 0.01% +Correctly identified muons with isMuon: 548/ 604 90.73% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 108/ 117 92.31% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 6424/ 55314 11.61% +Ghost tracks identified as muon with isMuon: 776/ 4306 18.02% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 640/ 1000, (19200.00 +/- 455.37) kHz +Hlt1KsToPiPi: 50/ 1000, ( 1500.00 +/- 206.76) kHz +Hlt1TrackMVA: 219/ 1000, ( 6570.00 +/- 392.35) kHz +Hlt1TwoTrackMVA: 482/ 1000, (14460.00 +/- 474.03) kHz +Hlt1TwoTrackKs: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 5/ 1000, ( 150.00 +/- 66.91) kHz +Hlt1LowPtMuon: 287/ 1000, ( 8610.00 +/- 429.15) kHz +Hlt1D2KK: 18/ 1000, ( 540.00 +/- 126.13) kHz +Hlt1D2KPi: 38/ 1000, ( 1140.00 +/- 181.38) kHz +Hlt1D2PiPi: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1DiMuonHighMass: 27/ 1000, ( 810.00 +/- 153.77) kHz +Hlt1DiMuonLowMass: 51/ 1000, ( 1530.00 +/- 208.71) kHz +Hlt1DiMuonSoft: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtDiMuon: 125/ 1000, ( 3750.00 +/- 313.75) kHz +Hlt1TrackMuonMVA: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1DiMuonNoIP: 43/ 1000, ( 1290.00 +/- 192.45) kHz +Hlt1DiMuonNoIP_ss: 7/ 1000, ( 210.00 +/- 79.09) kHz +Hlt1TrackElectronMVA: 42/ 1000, ( 1260.00 +/- 190.30) kHz +Hlt1SingleHighPtElectron: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DisplacedDielectron: 7/ 1000, ( 210.00 +/- 79.09) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 47/ 1000, ( 1410.00 +/- 200.78) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 926/ 1000, (27780.00 +/- 248.34) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 5/ 1000, ( 150.00 +/- 66.91) kHz +Hlt1RICH2Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 38/ 1000, ( 1140.00 +/- 181.38) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 2/ 1000, ( 60.00 +/- 42.38) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 640 1768 +Hlt1KsToPiPi: 50 56 +Hlt1TrackMVA: 219 324 +Hlt1TwoTrackMVA: 482 1463 +Hlt1TwoTrackKs: 3 3 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 5 5 +Hlt1LowPtMuon: 287 387 +Hlt1D2KK: 18 20 +Hlt1D2KPi: 38 40 +Hlt1D2PiPi: 35 36 +Hlt1DiMuonHighMass: 27 28 +Hlt1DiMuonLowMass: 51 65 +Hlt1DiMuonSoft: 2 2 +Hlt1LowPtDiMuon: 125 194 +Hlt1TrackMuonMVA: 12 12 +Hlt1DiMuonNoIP: 43 49 +Hlt1DiMuonNoIP_ss: 7 7 +Hlt1TrackElectronMVA: 42 43 +Hlt1SingleHighPtElectron: 16 16 +Hlt1DisplacedDielectron: 7 10 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 3 3 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 47 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 926 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 5 6 +Hlt1RICH2Alignment: 1 1 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 38 40 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 2 2 + +Total decisions: 4141 +Total tracks: 3755 +Total SVs: 2967 +Total hits: 76203 +Total stdinfo: 46049 + diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt new file mode 100644 index 00000000000..b0ac42b0227 --- /dev/null +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt @@ -0,0 +1,225 @@ +velo_validator validation: +TrackChecker output : 1893/ 233746 0.81% ghosts +01_velo : 99543/ 101231 98.33% ( 98.41%), 1934 ( 1.91%) clones, pur 99.64%, hit eff 96.94% +02_long : 59647/ 60099 99.25% ( 99.28%), 796 ( 1.32%) clones, pur 99.76%, hit eff 97.99% +03_long_P>5GeV : 41627/ 41818 99.54% ( 99.58%), 434 ( 1.03%) clones, pur 99.79%, hit eff 98.48% +04_long_strange : 3111/ 3179 97.86% ( 97.63%), 38 ( 1.21%) clones, pur 99.21%, hit eff 97.47% +05_long_strange_P>5GeV : 1481/ 1518 97.56% ( 97.55%), 14 ( 0.94%) clones, pur 99.01%, hit eff 98.54% +06_long_fromB : 4326/ 4364 99.13% ( 99.36%), 54 ( 1.23%) clones, pur 99.71%, hit eff 97.89% +07_long_fromB_P>5GeV : 3546/ 3568 99.38% ( 99.53%), 31 ( 0.87%) clones, pur 99.77%, hit eff 98.35% +08_long_electrons : 4918/ 5058 97.23% ( 97.36%), 220 ( 4.28%) clones, pur 97.75%, hit eff 96.34% +09_long_fromB_electrons : 240/ 245 97.96% ( 98.65%), 10 ( 4.00%) clones, pur 97.29%, hit eff 96.38% +10_long_fromB_electrons_P>5GeV : 154/ 158 97.47% ( 98.31%), 6 ( 3.75%) clones, pur 97.34%, hit eff 96.97% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.945 ( 4942/ 5230) +Isolated : 0.983 ( 2687/ 2733) +Close : 0.903 ( 2255/ 2497) +False rate : 0.008 ( 42/ 4984) +Real false rate : 0.008 ( 42/ 4984) +Clones : 0.000 ( 0/ 4942) + + +seed_validator validation: +TrackChecker output : 9211/ 88454 10.41% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 28680/ 32005 89.61% ( 90.71%), 2 ( 0.01%) clones, pur 99.25%, hit eff 98.54% +01_long : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +---1. phi quadrant : 11845/ 15124 78.32% ( 79.55%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.48% +---2. phi quadrant : 11874/ 15068 78.80% ( 79.48%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.52% +---3. phi quadrant : 11968/ 15176 78.86% ( 79.59%), 1 ( 0.01%) clones, pur 99.27%, hit eff 98.46% +---4. phi quadrant : 11607/ 14730 78.80% ( 79.52%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.47% +---eta < 2.5, small x, large y : 873/ 2426 35.99% ( 36.74%), 0 ( 0.00%) clones, pur 98.44%, hit eff 97.19% +---eta < 2.5, large x, small y : 2928/ 4886 59.93% ( 59.54%), 0 ( 0.00%) clones, pur 99.23%, hit eff 98.43% +---eta > 2.5, small x, large y : 15538/ 18801 82.64% ( 83.60%), 2 ( 0.01%) clones, pur 99.32%, hit eff 98.56% +---eta > 2.5, large x, small y : 27955/ 33986 82.25% ( 83.08%), 1 ( 0.00%) clones, pur 99.31%, hit eff 98.49% +02_long_P>5GeV : 38439/ 41818 91.92% ( 92.98%), 3 ( 0.01%) clones, pur 99.30%, hit eff 98.59% +02_long_P>5GeV, eta > 4 : 13817/ 15282 90.41% ( 91.79%), 2 ( 0.01%) clones, pur 99.09%, hit eff 98.40% +---eta < 2.5, small x, large y : 621/ 900 69.00% ( 69.33%), 0 ( 0.00%) clones, pur 98.89%, hit eff 98.24% +---eta < 2.5, large x, small y : 1866/ 1982 94.15% ( 94.21%), 0 ( 0.00%) clones, pur 99.59%, hit eff 98.93% +---eta > 2.5, small x, large y : 12948/ 13981 92.61% ( 93.86%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.62% +---eta > 2.5, large x, small y : 23004/ 24955 92.18% ( 93.25%), 1 ( 0.00%) clones, pur 99.29%, hit eff 98.55% +03_long_P>3GeV : 47268/ 52572 89.91% ( 90.83%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +04_long_P>0.5GeV : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +05_long_from_B : 3726/ 4364 85.38% ( 85.99%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +06_long_from_B_P>5GeV : 3319/ 3568 93.02% ( 92.84%), 1 ( 0.03%) clones, pur 99.36%, hit eff 98.75% +07_long_from_B_P>3GeV : 3725/ 4065 91.64% ( 91.49%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +08_UT+SciFi : 5779/ 9192 62.87% ( 62.23%), 0 ( 0.00%) clones, pur 99.14%, hit eff 98.13% +09_UT+SciFi_P>5GeV : 3718/ 4045 91.92% ( 92.84%), 0 ( 0.00%) clones, pur 99.18%, hit eff 98.44% +10_UT+SciFi_P>3GeV : 5738/ 6587 87.11% ( 87.60%), 0 ( 0.00%) clones, pur 99.15%, hit eff 98.16% +11_UT+SciFi_fromStrange : 2327/ 3252 71.56% ( 71.92%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.35% +12_UT+SciFi_fromStrange_P>5GeV : 1687/ 1827 92.34% ( 92.56%), 0 ( 0.00%) clones, pur 99.24%, hit eff 98.47% +13_UT+SciFi_fromStrange_P>3GeV : 2322/ 2606 89.10% ( 89.69%), 0 ( 0.00%) clones, pur 99.27%, hit eff 98.35% +14_long_electrons : 2792/ 5058 55.20% ( 55.01%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +15_long_electrons_P>5GeV : 2184/ 2838 76.96% ( 77.54%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.28% +16_long_electrons_P>3GeV : 2792/ 4161 67.10% ( 67.32%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +17_long_fromB_electrons : 141/ 245 57.55% ( 57.08%), 0 ( 0.00%) clones, pur 99.02%, hit eff 97.66% +18_long_fromB_electrons_P>5GeV : 122/ 158 77.22% ( 76.69%), 0 ( 0.00%) clones, pur 99.34%, hit eff 98.21% +19_long_PT>2GeV : 3916/ 4311 90.84% ( 92.02%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.64% +20_long_from_B_PT>2GeV : 960/ 1034 92.84% ( 93.23%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.68% +21_long_strange_P>5GeV : 1403/ 1518 92.42% ( 92.65%), 0 ( 0.00%) clones, pur 99.47%, hit eff 98.74% +22_long_strange_P>5GeV_PT>500MeV : 591/ 647 91.34% ( 91.36%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.73% + + +long_validator validation: +TrackChecker output : 4296/ 52029 8.26% ghosts +for P>3GeV,Pt>0.5GeV : 1207/ 29847 4.04% ghosts +01_long : 44228/ 60099 73.59% ( 74.71%), 2 ( 0.00%) clones, pur 99.65%, hit eff 98.69% +02_long_P>5GeV : 36779/ 41818 87.95% ( 89.23%), 2 ( 0.01%) clones, pur 99.65%, hit eff 98.77% +03_long_strange : 1879/ 3179 59.11% ( 57.51%), 0 ( 0.00%) clones, pur 99.56%, hit eff 98.71% +04_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +05_long_fromB : 3559/ 4364 81.55% ( 82.52%), 0 ( 0.00%) clones, pur 99.65%, hit eff 98.87% +06_long_fromB_P>5GeV : 3210/ 3568 89.97% ( 89.93%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.93% +07_long_electrons : 1974/ 5058 39.03% ( 39.64%), 1 ( 0.05%) clones, pur 99.09%, hit eff 98.41% +08_long_electrons_P>5GeV : 1601/ 2838 56.41% ( 57.87%), 1 ( 0.06%) clones, pur 99.08%, hit eff 98.44% +09_long_fromB_electrons : 110/ 245 44.90% ( 46.23%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.45% +10_long_fromB_electrons_P>5GeV : 100/ 158 63.29% ( 65.79%), 0 ( 0.00%) clones, pur 99.22%, hit eff 98.38% +long_P>5GeV_AND_Pt>1GeV : 12866/ 14488 88.80% ( 89.90%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.87% +long_fromB_P>5GeV_AND_Pt>1GeV : 2098/ 2316 90.59% ( 90.76%), 0 ( 0.00%) clones, pur 99.63%, hit eff 98.94% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3865/ 4311 89.65% ( 90.93%), 0 ( 0.00%) clones, pur 99.62%, hit eff 98.80% +14_long_from_B_PT>2GeV : 941/ 1034 91.01% ( 91.08%), 0 ( 0.00%) clones, pur 99.60%, hit eff 98.85% +15_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +16_long_strange_P>5GeV_PT>500MeV : 563/ 647 87.02% ( 87.30%), 0 ( 0.00%) clones, pur 99.45%, hit eff 98.81% + + +muon_validator validation: +Muon fraction in all MCPs: 11914/ 879199 0.01% +Muon fraction in MCPs to which a track(s) was matched: 607/ 55879 0.01% +Correctly identified muons with isMuon: 551/ 607 90.77% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 107/ 116 92.24% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 6429/ 55272 11.63% +Ghost tracks identified as muon with isMuon: 770/ 4296 17.92% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 640/ 1000, (19200.00 +/- 455.37) kHz +Hlt1KsToPiPi: 50/ 1000, ( 1500.00 +/- 206.76) kHz +Hlt1TrackMVA: 218/ 1000, ( 6540.00 +/- 391.70) kHz +Hlt1TwoTrackMVA: 475/ 1000, (14250.00 +/- 473.75) kHz +Hlt1TwoTrackKs: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowPtMuon: 285/ 1000, ( 8550.00 +/- 428.25) kHz +Hlt1D2KK: 17/ 1000, ( 510.00 +/- 122.64) kHz +Hlt1D2KPi: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1D2PiPi: 36/ 1000, ( 1080.00 +/- 176.73) kHz +Hlt1DiMuonHighMass: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1DiMuonLowMass: 53/ 1000, ( 1590.00 +/- 212.54) kHz +Hlt1DiMuonSoft: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtDiMuon: 125/ 1000, ( 3750.00 +/- 313.75) kHz +Hlt1TrackMuonMVA: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1DiMuonNoIP: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1DiMuonNoIP_ss: 8/ 1000, ( 240.00 +/- 84.51) kHz +Hlt1TrackElectronMVA: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1SingleHighPtElectron: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DisplacedDielectron: 7/ 1000, ( 210.00 +/- 79.09) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 47/ 1000, ( 1410.00 +/- 200.78) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 926/ 1000, (27780.00 +/- 248.34) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1RICH2Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 2/ 1000, ( 60.00 +/- 42.38) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 640 1755 +Hlt1KsToPiPi: 50 57 +Hlt1TrackMVA: 218 318 +Hlt1TwoTrackMVA: 475 1426 +Hlt1TwoTrackKs: 3 3 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 4 4 +Hlt1LowPtMuon: 285 384 +Hlt1D2KK: 17 19 +Hlt1D2KPi: 35 36 +Hlt1D2PiPi: 36 37 +Hlt1DiMuonHighMass: 29 30 +Hlt1DiMuonLowMass: 53 71 +Hlt1DiMuonSoft: 2 2 +Hlt1LowPtDiMuon: 125 193 +Hlt1TrackMuonMVA: 12 12 +Hlt1DiMuonNoIP: 41 48 +Hlt1DiMuonNoIP_ss: 8 8 +Hlt1TrackElectronMVA: 41 42 +Hlt1SingleHighPtElectron: 16 16 +Hlt1DisplacedDielectron: 7 10 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4 4 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 47 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 926 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 4 5 +Hlt1RICH2Alignment: 1 1 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 35 36 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 2 2 + +Total decisions: 4128 +Total tracks: 3720 +Total SVs: 2938 +Total hits: 75496 +Total stdinfo: 45640 + diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt new file mode 100644 index 00000000000..b0ac42b0227 --- /dev/null +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt @@ -0,0 +1,225 @@ +velo_validator validation: +TrackChecker output : 1893/ 233746 0.81% ghosts +01_velo : 99543/ 101231 98.33% ( 98.41%), 1934 ( 1.91%) clones, pur 99.64%, hit eff 96.94% +02_long : 59647/ 60099 99.25% ( 99.28%), 796 ( 1.32%) clones, pur 99.76%, hit eff 97.99% +03_long_P>5GeV : 41627/ 41818 99.54% ( 99.58%), 434 ( 1.03%) clones, pur 99.79%, hit eff 98.48% +04_long_strange : 3111/ 3179 97.86% ( 97.63%), 38 ( 1.21%) clones, pur 99.21%, hit eff 97.47% +05_long_strange_P>5GeV : 1481/ 1518 97.56% ( 97.55%), 14 ( 0.94%) clones, pur 99.01%, hit eff 98.54% +06_long_fromB : 4326/ 4364 99.13% ( 99.36%), 54 ( 1.23%) clones, pur 99.71%, hit eff 97.89% +07_long_fromB_P>5GeV : 3546/ 3568 99.38% ( 99.53%), 31 ( 0.87%) clones, pur 99.77%, hit eff 98.35% +08_long_electrons : 4918/ 5058 97.23% ( 97.36%), 220 ( 4.28%) clones, pur 97.75%, hit eff 96.34% +09_long_fromB_electrons : 240/ 245 97.96% ( 98.65%), 10 ( 4.00%) clones, pur 97.29%, hit eff 96.38% +10_long_fromB_electrons_P>5GeV : 154/ 158 97.47% ( 98.31%), 6 ( 3.75%) clones, pur 97.34%, hit eff 96.97% + + +pv_validator validation: +REC and MC vertices matched by dz distance +MC PV is reconstructible if at least 4 tracks are reconstructed +MC PV is isolated if dz to closest reconstructible MC PV > 10.00 mm +REC and MC vertices matched by dz distance + +All : 0.945 ( 4942/ 5230) +Isolated : 0.983 ( 2687/ 2733) +Close : 0.903 ( 2255/ 2497) +False rate : 0.008 ( 42/ 4984) +Real false rate : 0.008 ( 42/ 4984) +Clones : 0.000 ( 0/ 4942) + + +seed_validator validation: +TrackChecker output : 9211/ 88454 10.41% ghosts +for P>3GeV,Pt>0.5GeV : 0/ 0 -nan% ghosts +00_P>3Gev_Pt>0.5 : 28680/ 32005 89.61% ( 90.71%), 2 ( 0.01%) clones, pur 99.25%, hit eff 98.54% +01_long : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +---1. phi quadrant : 11845/ 15124 78.32% ( 79.55%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.48% +---2. phi quadrant : 11874/ 15068 78.80% ( 79.48%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.52% +---3. phi quadrant : 11968/ 15176 78.86% ( 79.59%), 1 ( 0.01%) clones, pur 99.27%, hit eff 98.46% +---4. phi quadrant : 11607/ 14730 78.80% ( 79.52%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.47% +---eta < 2.5, small x, large y : 873/ 2426 35.99% ( 36.74%), 0 ( 0.00%) clones, pur 98.44%, hit eff 97.19% +---eta < 2.5, large x, small y : 2928/ 4886 59.93% ( 59.54%), 0 ( 0.00%) clones, pur 99.23%, hit eff 98.43% +---eta > 2.5, small x, large y : 15538/ 18801 82.64% ( 83.60%), 2 ( 0.01%) clones, pur 99.32%, hit eff 98.56% +---eta > 2.5, large x, small y : 27955/ 33986 82.25% ( 83.08%), 1 ( 0.00%) clones, pur 99.31%, hit eff 98.49% +02_long_P>5GeV : 38439/ 41818 91.92% ( 92.98%), 3 ( 0.01%) clones, pur 99.30%, hit eff 98.59% +02_long_P>5GeV, eta > 4 : 13817/ 15282 90.41% ( 91.79%), 2 ( 0.01%) clones, pur 99.09%, hit eff 98.40% +---eta < 2.5, small x, large y : 621/ 900 69.00% ( 69.33%), 0 ( 0.00%) clones, pur 98.89%, hit eff 98.24% +---eta < 2.5, large x, small y : 1866/ 1982 94.15% ( 94.21%), 0 ( 0.00%) clones, pur 99.59%, hit eff 98.93% +---eta > 2.5, small x, large y : 12948/ 13981 92.61% ( 93.86%), 2 ( 0.02%) clones, pur 99.29%, hit eff 98.62% +---eta > 2.5, large x, small y : 23004/ 24955 92.18% ( 93.25%), 1 ( 0.00%) clones, pur 99.29%, hit eff 98.55% +03_long_P>3GeV : 47268/ 52572 89.91% ( 90.83%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +04_long_P>0.5GeV : 47294/ 60099 78.69% ( 79.59%), 3 ( 0.01%) clones, pur 99.29%, hit eff 98.48% +05_long_from_B : 3726/ 4364 85.38% ( 85.99%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +06_long_from_B_P>5GeV : 3319/ 3568 93.02% ( 92.84%), 1 ( 0.03%) clones, pur 99.36%, hit eff 98.75% +07_long_from_B_P>3GeV : 3725/ 4065 91.64% ( 91.49%), 1 ( 0.03%) clones, pur 99.33%, hit eff 98.66% +08_UT+SciFi : 5779/ 9192 62.87% ( 62.23%), 0 ( 0.00%) clones, pur 99.14%, hit eff 98.13% +09_UT+SciFi_P>5GeV : 3718/ 4045 91.92% ( 92.84%), 0 ( 0.00%) clones, pur 99.18%, hit eff 98.44% +10_UT+SciFi_P>3GeV : 5738/ 6587 87.11% ( 87.60%), 0 ( 0.00%) clones, pur 99.15%, hit eff 98.16% +11_UT+SciFi_fromStrange : 2327/ 3252 71.56% ( 71.92%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.35% +12_UT+SciFi_fromStrange_P>5GeV : 1687/ 1827 92.34% ( 92.56%), 0 ( 0.00%) clones, pur 99.24%, hit eff 98.47% +13_UT+SciFi_fromStrange_P>3GeV : 2322/ 2606 89.10% ( 89.69%), 0 ( 0.00%) clones, pur 99.27%, hit eff 98.35% +14_long_electrons : 2792/ 5058 55.20% ( 55.01%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +15_long_electrons_P>5GeV : 2184/ 2838 76.96% ( 77.54%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.28% +16_long_electrons_P>3GeV : 2792/ 4161 67.10% ( 67.32%), 0 ( 0.00%) clones, pur 99.35%, hit eff 98.20% +17_long_fromB_electrons : 141/ 245 57.55% ( 57.08%), 0 ( 0.00%) clones, pur 99.02%, hit eff 97.66% +18_long_fromB_electrons_P>5GeV : 122/ 158 77.22% ( 76.69%), 0 ( 0.00%) clones, pur 99.34%, hit eff 98.21% +19_long_PT>2GeV : 3916/ 4311 90.84% ( 92.02%), 0 ( 0.00%) clones, pur 99.26%, hit eff 98.64% +20_long_from_B_PT>2GeV : 960/ 1034 92.84% ( 93.23%), 0 ( 0.00%) clones, pur 99.33%, hit eff 98.68% +21_long_strange_P>5GeV : 1403/ 1518 92.42% ( 92.65%), 0 ( 0.00%) clones, pur 99.47%, hit eff 98.74% +22_long_strange_P>5GeV_PT>500MeV : 591/ 647 91.34% ( 91.36%), 0 ( 0.00%) clones, pur 99.32%, hit eff 98.73% + + +long_validator validation: +TrackChecker output : 4296/ 52029 8.26% ghosts +for P>3GeV,Pt>0.5GeV : 1207/ 29847 4.04% ghosts +01_long : 44228/ 60099 73.59% ( 74.71%), 2 ( 0.00%) clones, pur 99.65%, hit eff 98.69% +02_long_P>5GeV : 36779/ 41818 87.95% ( 89.23%), 2 ( 0.01%) clones, pur 99.65%, hit eff 98.77% +03_long_strange : 1879/ 3179 59.11% ( 57.51%), 0 ( 0.00%) clones, pur 99.56%, hit eff 98.71% +04_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +05_long_fromB : 3559/ 4364 81.55% ( 82.52%), 0 ( 0.00%) clones, pur 99.65%, hit eff 98.87% +06_long_fromB_P>5GeV : 3210/ 3568 89.97% ( 89.93%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.93% +07_long_electrons : 1974/ 5058 39.03% ( 39.64%), 1 ( 0.05%) clones, pur 99.09%, hit eff 98.41% +08_long_electrons_P>5GeV : 1601/ 2838 56.41% ( 57.87%), 1 ( 0.06%) clones, pur 99.08%, hit eff 98.44% +09_long_fromB_electrons : 110/ 245 44.90% ( 46.23%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.45% +10_long_fromB_electrons_P>5GeV : 100/ 158 63.29% ( 65.79%), 0 ( 0.00%) clones, pur 99.22%, hit eff 98.38% +long_P>5GeV_AND_Pt>1GeV : 12866/ 14488 88.80% ( 89.90%), 0 ( 0.00%) clones, pur 99.66%, hit eff 98.87% +long_fromB_P>5GeV_AND_Pt>1GeV : 2098/ 2316 90.59% ( 90.76%), 0 ( 0.00%) clones, pur 99.63%, hit eff 98.94% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3865/ 4311 89.65% ( 90.93%), 0 ( 0.00%) clones, pur 99.62%, hit eff 98.80% +14_long_from_B_PT>2GeV : 941/ 1034 91.01% ( 91.08%), 0 ( 0.00%) clones, pur 99.60%, hit eff 98.85% +15_long_strange_P>5GeV : 1295/ 1518 85.31% ( 86.04%), 0 ( 0.00%) clones, pur 99.55%, hit eff 98.85% +16_long_strange_P>5GeV_PT>500MeV : 563/ 647 87.02% ( 87.30%), 0 ( 0.00%) clones, pur 99.45%, hit eff 98.81% + + +muon_validator validation: +Muon fraction in all MCPs: 11914/ 879199 0.01% +Muon fraction in MCPs to which a track(s) was matched: 607/ 55879 0.01% +Correctly identified muons with isMuon: 551/ 607 90.77% +Correctly identified muons from strange decays with isMuon: 1/ 1 100.00% +Correctly identified muons from B decays with isMuon: 107/ 116 92.24% +Tracks identified as muon with isMuon, but matched to non-muon MCP: 6429/ 55272 11.63% +Ghost tracks identified as muon with isMuon: 770/ 4296 17.92% + + +rate_validator validation: +Hlt1TwoTrackMVACharmXSec: 640/ 1000, (19200.00 +/- 455.37) kHz +Hlt1KsToPiPi: 50/ 1000, ( 1500.00 +/- 206.76) kHz +Hlt1TrackMVA: 218/ 1000, ( 6540.00 +/- 391.70) kHz +Hlt1TwoTrackMVA: 475/ 1000, (14250.00 +/- 473.75) kHz +Hlt1TwoTrackKs: 3/ 1000, ( 90.00 +/- 51.88) kHz +Hlt1SingleHighPtMuon: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1SingleHighPtMuonNoMuID: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowPtMuon: 285/ 1000, ( 8550.00 +/- 428.25) kHz +Hlt1D2KK: 17/ 1000, ( 510.00 +/- 122.64) kHz +Hlt1D2KPi: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1D2PiPi: 36/ 1000, ( 1080.00 +/- 176.73) kHz +Hlt1DiMuonHighMass: 29/ 1000, ( 870.00 +/- 159.20) kHz +Hlt1DiMuonLowMass: 53/ 1000, ( 1590.00 +/- 212.54) kHz +Hlt1DiMuonSoft: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowPtDiMuon: 125/ 1000, ( 3750.00 +/- 313.75) kHz +Hlt1TrackMuonMVA: 12/ 1000, ( 360.00 +/- 103.30) kHz +Hlt1DiMuonNoIP: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1DiMuonNoIP_ss: 8/ 1000, ( 240.00 +/- 84.51) kHz +Hlt1TrackElectronMVA: 41/ 1000, ( 1230.00 +/- 188.11) kHz +Hlt1SingleHighPtElectron: 16/ 1000, ( 480.00 +/- 119.04) kHz +Hlt1DisplacedDielectron: 7/ 1000, ( 210.00 +/- 79.09) kHz +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedLeptons: 47/ 1000, ( 1410.00 +/- 200.78) kHz +Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz +Hlt1GECPassthrough: 926/ 1000, (27780.00 +/- 248.34) kHz +Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamOne: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1VeloMicroBias: 2/ 1000, ( 60.00 +/- 42.38) kHz +Hlt1RICH1Alignment: 4/ 1000, ( 120.00 +/- 59.88) kHz +Hlt1RICH2Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz +Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 35/ 1000, ( 1050.00 +/- 174.35) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 2/ 1000, ( 60.00 +/- 42.38) kHz +Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz + + +selreport_validator validation: + Events Candidates +Hlt1TwoTrackMVACharmXSec: 640 1755 +Hlt1KsToPiPi: 50 57 +Hlt1TrackMVA: 218 318 +Hlt1TwoTrackMVA: 475 1426 +Hlt1TwoTrackKs: 3 3 +Hlt1SingleHighPtMuon: 2 2 +Hlt1SingleHighPtMuonNoMuID: 4 4 +Hlt1LowPtMuon: 285 384 +Hlt1D2KK: 17 19 +Hlt1D2KPi: 35 36 +Hlt1D2PiPi: 36 37 +Hlt1DiMuonHighMass: 29 30 +Hlt1DiMuonLowMass: 53 71 +Hlt1DiMuonSoft: 2 2 +Hlt1LowPtDiMuon: 125 193 +Hlt1TrackMuonMVA: 12 12 +Hlt1DiMuonNoIP: 41 48 +Hlt1DiMuonNoIP_ss: 8 8 +Hlt1TrackElectronMVA: 41 42 +Hlt1SingleHighPtElectron: 16 16 +Hlt1DisplacedDielectron: 7 10 +Hlt1LowMassNoipDielectron_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice1_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_prompt: 1 1 +Hlt1LowMassNoipDielectron_SS_massSlice3_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_prompt: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice4_prompt: 0 0 +Hlt1LowMassNoipDielectron_massSlice1_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice1_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_SS_massSlice2_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice3_displaced: 2 2 +Hlt1LowMassNoipDielectron_SS_massSlice3_displaced: 0 0 +Hlt1LowMassNoipDielectron_massSlice4_displaced: 4 4 +Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 +Hlt1DisplacedLeptons: 47 0 +Hlt1SingleHighEt: 0 0 +Hlt1Passthrough: 1000 0 +Hlt1GECPassthrough: 926 0 +Hlt1NoBeam: 0 0 +Hlt1BeamOne: 0 0 +Hlt1BeamTwo: 0 0 +Hlt1BothBeams: 1 0 +Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 +Hlt1ODINNoBias: 0 0 +Hlt1VeloMicroBias: 2 0 +Hlt1RICH1Alignment: 4 5 +Hlt1RICH2Alignment: 1 1 +Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 35 36 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 2 2 + +Total decisions: 4128 +Total tracks: 3720 +Total SVs: 2938 +Total hits: 75496 +Total stdinfo: 45640 + diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt index 58eff10d133..8b1a111ec6f 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 1076/ 18083 5.95% 10_long_fromB_electrons_P>5GeV : 40/ 158 25.32% ( 26.29%), 2 ( 4.76%) clones, pur 98.40%, hit eff 97.23% long_P>5GeV_AND_Pt>1GeV : 13035/ 14488 89.97% ( 90.44%), 112 ( 0.85%) clones, pur 99.75%, hit eff 99.06% long_fromB_P>5GeV_AND_Pt>1GeV : 2128/ 2316 91.88% ( 91.33%), 16 ( 0.75%) clones, pur 99.75%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4038/ 4311 93.67% ( 93.71%), 29 ( 0.71%) clones, pur 99.77%, hit eff 99.17% +14_long_from_B_PT>2GeV : 970/ 1034 93.81% ( 94.21%), 6 ( 0.61%) clones, pur 99.73%, hit eff 99.36% +15_long_strange_P>5GeV : 221/ 1518 14.56% ( 14.27%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% +16_long_strange_P>5GeV_PT>500MeV : 221/ 647 34.16% ( 34.67%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt index 8cc746f37b9..a1e7a74d49b 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 1023/ 17640 5.80% 10_long_fromB_electrons_P>5GeV : 40/ 158 25.32% ( 26.29%), 2 ( 4.76%) clones, pur 98.28%, hit eff 97.04% long_P>5GeV_AND_Pt>1GeV : 12703/ 14488 87.68% ( 89.02%), 109 ( 0.85%) clones, pur 99.68%, hit eff 98.90% long_fromB_P>5GeV_AND_Pt>1GeV : 2077/ 2316 89.68% ( 89.77%), 16 ( 0.76%) clones, pur 99.68%, hit eff 99.19% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3906/ 4311 90.61% ( 91.92%), 29 ( 0.74%) clones, pur 99.70%, hit eff 98.99% +14_long_from_B_PT>2GeV : 941/ 1034 91.01% ( 91.71%), 6 ( 0.63%) clones, pur 99.68%, hit eff 99.26% +15_long_strange_P>5GeV : 218/ 1518 14.36% ( 13.87%), 2 ( 0.91%) clones, pur 99.59%, hit eff 98.08% +16_long_strange_P>5GeV_PT>500MeV : 218/ 647 33.69% ( 33.92%), 2 ( 0.91%) clones, pur 99.59%, hit eff 98.08% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt index 58eff10d133..8b1a111ec6f 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 1076/ 18083 5.95% 10_long_fromB_electrons_P>5GeV : 40/ 158 25.32% ( 26.29%), 2 ( 4.76%) clones, pur 98.40%, hit eff 97.23% long_P>5GeV_AND_Pt>1GeV : 13035/ 14488 89.97% ( 90.44%), 112 ( 0.85%) clones, pur 99.75%, hit eff 99.06% long_fromB_P>5GeV_AND_Pt>1GeV : 2128/ 2316 91.88% ( 91.33%), 16 ( 0.75%) clones, pur 99.75%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4038/ 4311 93.67% ( 93.71%), 29 ( 0.71%) clones, pur 99.77%, hit eff 99.17% +14_long_from_B_PT>2GeV : 970/ 1034 93.81% ( 94.21%), 6 ( 0.61%) clones, pur 99.73%, hit eff 99.36% +15_long_strange_P>5GeV : 221/ 1518 14.56% ( 14.27%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% +16_long_strange_P>5GeV_PT>500MeV : 221/ 647 34.16% ( 34.67%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt index 58eff10d133..8b1a111ec6f 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 1076/ 18083 5.95% 10_long_fromB_electrons_P>5GeV : 40/ 158 25.32% ( 26.29%), 2 ( 4.76%) clones, pur 98.40%, hit eff 97.23% long_P>5GeV_AND_Pt>1GeV : 13035/ 14488 89.97% ( 90.44%), 112 ( 0.85%) clones, pur 99.75%, hit eff 99.06% long_fromB_P>5GeV_AND_Pt>1GeV : 2128/ 2316 91.88% ( 91.33%), 16 ( 0.75%) clones, pur 99.75%, hit eff 99.34% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4038/ 4311 93.67% ( 93.71%), 29 ( 0.71%) clones, pur 99.77%, hit eff 99.17% +14_long_from_B_PT>2GeV : 970/ 1034 93.81% ( 94.21%), 6 ( 0.61%) clones, pur 99.73%, hit eff 99.36% +15_long_strange_P>5GeV : 221/ 1518 14.56% ( 14.27%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% +16_long_strange_P>5GeV_PT>500MeV : 221/ 647 34.16% ( 34.67%), 2 ( 0.90%) clones, pur 99.58%, hit eff 97.96% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_a5000.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_a5000.txt index feb526dc504..fd524080b93 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_a5000.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_a5000.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 745/ 30036 2.48% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.91%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13152/ 14488 90.78% ( 91.47%), 113 ( 0.85%) clones, pur 99.54%, hit eff 99.08% long_fromB_P>5GeV_AND_Pt>1GeV : 2123/ 2316 91.67% ( 91.63%), 15 ( 0.70%) clones, pur 99.54%, hit eff 99.33% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4010/ 4311 93.02% ( 93.43%), 32 ( 0.79%) clones, pur 99.57%, hit eff 99.19% +14_long_from_B_PT>2GeV : 958/ 1034 92.65% ( 92.75%), 6 ( 0.62%) clones, pur 99.53%, hit eff 99.36% +15_long_strange_P>5GeV : 927/ 1518 61.07% ( 60.09%), 6 ( 0.64%) clones, pur 99.27%, hit eff 98.73% +16_long_strange_P>5GeV_PT>500MeV : 568/ 647 87.79% ( 88.08%), 5 ( 0.87%) clones, pur 99.22%, hit eff 98.74% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_epyc7502.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_epyc7502.txt index b160df75577..38448ed4aec 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_epyc7502.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_epyc7502.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 944/ 28987 3.26% 10_long_fromB_electrons_P>5GeV : 76/ 158 48.10% ( 50.00%), 0 ( 0.00%) clones, pur 99.06%, hit eff 98.49% long_P>5GeV_AND_Pt>1GeV : 12681/ 14488 87.53% ( 89.11%), 106 ( 0.83%) clones, pur 99.31%, hit eff 98.42% long_fromB_P>5GeV_AND_Pt>1GeV : 2070/ 2316 89.38% ( 89.36%), 15 ( 0.72%) clones, pur 99.36%, hit eff 98.82% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 3887/ 4311 90.16% ( 91.20%), 30 ( 0.77%) clones, pur 99.40%, hit eff 98.76% +14_long_from_B_PT>2GeV : 936/ 1034 90.52% ( 90.26%), 6 ( 0.64%) clones, pur 99.41%, hit eff 99.07% +15_long_strange_P>5GeV : 886/ 1518 58.37% ( 58.17%), 5 ( 0.56%) clones, pur 98.98%, hit eff 98.00% +16_long_strange_P>5GeV_PT>500MeV : 541/ 647 83.62% ( 84.02%), 4 ( 0.73%) clones, pur 99.02%, hit eff 98.21% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt index feb526dc504..fd524080b93 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx2080ti.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 745/ 30036 2.48% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.91%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13152/ 14488 90.78% ( 91.47%), 113 ( 0.85%) clones, pur 99.54%, hit eff 99.08% long_fromB_P>5GeV_AND_Pt>1GeV : 2123/ 2316 91.67% ( 91.63%), 15 ( 0.70%) clones, pur 99.54%, hit eff 99.33% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4010/ 4311 93.02% ( 93.43%), 32 ( 0.79%) clones, pur 99.57%, hit eff 99.19% +14_long_from_B_PT>2GeV : 958/ 1034 92.65% ( 92.75%), 6 ( 0.62%) clones, pur 99.53%, hit eff 99.36% +15_long_strange_P>5GeV : 927/ 1518 61.07% ( 60.09%), 6 ( 0.64%) clones, pur 99.27%, hit eff 98.73% +16_long_strange_P>5GeV_PT>500MeV : 568/ 647 87.79% ( 88.08%), 5 ( 0.87%) clones, pur 99.22%, hit eff 98.74% muon_validator validation: diff --git a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt index feb526dc504..fd524080b93 100644 --- a/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt +++ b/test/reference/SciFiv6_upgrade_DC19_01_Bs2PhiPhiMD_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 745/ 30036 2.48% 10_long_fromB_electrons_P>5GeV : 79/ 158 50.00% ( 50.95%), 0 ( 0.00%) clones, pur 98.91%, hit eff 98.02% long_P>5GeV_AND_Pt>1GeV : 13152/ 14488 90.78% ( 91.47%), 113 ( 0.85%) clones, pur 99.54%, hit eff 99.08% long_fromB_P>5GeV_AND_Pt>1GeV : 2123/ 2316 91.67% ( 91.63%), 15 ( 0.70%) clones, pur 99.54%, hit eff 99.33% +11_noVelo_UT : 0/ 7264 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 3326 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 4010/ 4311 93.02% ( 93.43%), 32 ( 0.79%) clones, pur 99.57%, hit eff 99.19% +14_long_from_B_PT>2GeV : 958/ 1034 92.65% ( 92.75%), 6 ( 0.62%) clones, pur 99.53%, hit eff 99.36% +15_long_strange_P>5GeV : 927/ 1518 61.07% ( 60.09%), 6 ( 0.64%) clones, pur 99.27%, hit eff 98.73% +16_long_strange_P>5GeV_PT>500MeV : 568/ 647 87.79% ( 88.08%), 5 ( 0.87%) clones, pur 99.22%, hit eff 98.74% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_a5000.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_a5000.txt index edc6c80dcb9..3ba82b5a4a3 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_a5000.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_a5000.txt @@ -75,6 +75,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% non-restricted_long_validator validation: @@ -92,6 +98,12 @@ for P>3GeV,Pt>0.5GeV : 675/ 22386 3.02% 10_long_fromB_electrons_P>5GeV : 69/ 126 54.76% ( 59.86%), 3 ( 4.17%) clones, pur 98.70%, hit eff 96.49% long_P>5GeV_AND_Pt>1GeV : 6965/ 7884 88.34% ( 89.32%), 68 ( 0.97%) clones, pur 99.34%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1827/ 2026 90.18% ( 89.67%), 19 ( 1.03%) clones, pur 99.33%, hit eff 97.35% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1723/ 1897 90.83% ( 91.31%), 17 ( 0.98%) clones, pur 99.33%, hit eff 97.40% +14_long_from_B_PT>2GeV : 802/ 877 91.45% ( 90.74%), 9 ( 1.11%) clones, pur 99.26%, hit eff 97.41% +15_long_strange_P>5GeV : 935/ 1341 69.72% ( 71.22%), 4 ( 0.43%) clones, pur 98.83%, hit eff 96.28% +16_long_strange_P>5GeV_PT>500MeV : 392/ 466 84.12% ( 85.08%), 2 ( 0.51%) clones, pur 98.78%, hit eff 95.79% restricted_muon_validation validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_epyc7502.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_epyc7502.txt index 78f16ea271f..e53513bdcf7 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_epyc7502.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_epyc7502.txt @@ -75,6 +75,12 @@ for P>3GeV,Pt>0.5GeV : 886/ 21795 4.07% 10_long_fromB_electrons_P>5GeV : 61/ 126 48.41% ( 54.81%), 3 ( 4.69%) clones, pur 97.96%, hit eff 94.21% long_P>5GeV_AND_Pt>1GeV : 6774/ 7884 85.92% ( 86.96%), 68 ( 0.99%) clones, pur 99.09%, hit eff 96.27% long_fromB_P>5GeV_AND_Pt>1GeV : 1790/ 2026 88.35% ( 88.10%), 22 ( 1.21%) clones, pur 99.13%, hit eff 96.78% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1697/ 1897 89.46% ( 90.23%), 18 ( 1.05%) clones, pur 99.13%, hit eff 96.76% +14_long_from_B_PT>2GeV : 787/ 877 89.74% ( 88.96%), 11 ( 1.38%) clones, pur 99.09%, hit eff 96.81% +15_long_strange_P>5GeV : 713/ 1341 53.17% ( 53.95%), 3 ( 0.42%) clones, pur 98.55%, hit eff 95.60% +16_long_strange_P>5GeV_PT>500MeV : 378/ 466 81.12% ( 81.87%), 2 ( 0.53%) clones, pur 98.53%, hit eff 95.22% non-restricted_long_validator validation: @@ -92,6 +98,12 @@ for P>3GeV,Pt>0.5GeV : 887/ 21596 4.11% 10_long_fromB_electrons_P>5GeV : 68/ 126 53.97% ( 58.89%), 3 ( 4.23%) clones, pur 98.35%, hit eff 95.22% long_P>5GeV_AND_Pt>1GeV : 6702/ 7884 85.01% ( 86.19%), 67 ( 0.99%) clones, pur 99.09%, hit eff 96.26% long_fromB_P>5GeV_AND_Pt>1GeV : 1769/ 2026 87.31% ( 87.14%), 21 ( 1.17%) clones, pur 99.13%, hit eff 96.78% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1678/ 1897 88.46% ( 89.09%), 18 ( 1.06%) clones, pur 99.13%, hit eff 96.77% +14_long_from_B_PT>2GeV : 779/ 877 88.83% ( 87.92%), 11 ( 1.39%) clones, pur 99.09%, hit eff 96.80% +15_long_strange_P>5GeV : 893/ 1341 66.59% ( 67.73%), 4 ( 0.45%) clones, pur 98.61%, hit eff 95.67% +16_long_strange_P>5GeV_PT>500MeV : 375/ 466 80.47% ( 81.12%), 2 ( 0.53%) clones, pur 98.58%, hit eff 95.23% restricted_muon_validation validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx2080ti.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx2080ti.txt index edc6c80dcb9..3ba82b5a4a3 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx2080ti.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx2080ti.txt @@ -75,6 +75,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% non-restricted_long_validator validation: @@ -92,6 +98,12 @@ for P>3GeV,Pt>0.5GeV : 675/ 22386 3.02% 10_long_fromB_electrons_P>5GeV : 69/ 126 54.76% ( 59.86%), 3 ( 4.17%) clones, pur 98.70%, hit eff 96.49% long_P>5GeV_AND_Pt>1GeV : 6965/ 7884 88.34% ( 89.32%), 68 ( 0.97%) clones, pur 99.34%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1827/ 2026 90.18% ( 89.67%), 19 ( 1.03%) clones, pur 99.33%, hit eff 97.35% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1723/ 1897 90.83% ( 91.31%), 17 ( 0.98%) clones, pur 99.33%, hit eff 97.40% +14_long_from_B_PT>2GeV : 802/ 877 91.45% ( 90.74%), 9 ( 1.11%) clones, pur 99.26%, hit eff 97.41% +15_long_strange_P>5GeV : 935/ 1341 69.72% ( 71.22%), 4 ( 0.43%) clones, pur 98.83%, hit eff 96.28% +16_long_strange_P>5GeV_PT>500MeV : 392/ 466 84.12% ( 85.08%), 2 ( 0.51%) clones, pur 98.78%, hit eff 95.79% restricted_muon_validation validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx3090.txt index edc6c80dcb9..3ba82b5a4a3 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx3090.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_complex_validation_geforcertx3090.txt @@ -75,6 +75,12 @@ for P>3GeV,Pt>0.5GeV : 657/ 22581 2.91% 10_long_fromB_electrons_P>5GeV : 63/ 126 50.00% ( 56.73%), 3 ( 4.55%) clones, pur 98.54%, hit eff 96.17% long_P>5GeV_AND_Pt>1GeV : 7041/ 7884 89.31% ( 90.22%), 69 ( 0.97%) clones, pur 99.35%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1851/ 2026 91.36% ( 90.75%), 20 ( 1.07%) clones, pur 99.33%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1743/ 1897 91.88% ( 92.40%), 17 ( 0.97%) clones, pur 99.33%, hit eff 97.38% +14_long_from_B_PT>2GeV : 812/ 877 92.59% ( 91.89%), 9 ( 1.10%) clones, pur 99.27%, hit eff 97.42% +15_long_strange_P>5GeV : 741/ 1341 55.26% ( 56.19%), 3 ( 0.40%) clones, pur 98.78%, hit eff 96.19% +16_long_strange_P>5GeV_PT>500MeV : 394/ 466 84.55% ( 85.53%), 2 ( 0.51%) clones, pur 98.77%, hit eff 95.77% non-restricted_long_validator validation: @@ -92,6 +98,12 @@ for P>3GeV,Pt>0.5GeV : 675/ 22386 3.02% 10_long_fromB_electrons_P>5GeV : 69/ 126 54.76% ( 59.86%), 3 ( 4.17%) clones, pur 98.70%, hit eff 96.49% long_P>5GeV_AND_Pt>1GeV : 6965/ 7884 88.34% ( 89.32%), 68 ( 0.97%) clones, pur 99.34%, hit eff 97.02% long_fromB_P>5GeV_AND_Pt>1GeV : 1827/ 2026 90.18% ( 89.67%), 19 ( 1.03%) clones, pur 99.33%, hit eff 97.35% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1723/ 1897 90.83% ( 91.31%), 17 ( 0.98%) clones, pur 99.33%, hit eff 97.40% +14_long_from_B_PT>2GeV : 802/ 877 91.45% ( 90.74%), 9 ( 1.11%) clones, pur 99.26%, hit eff 97.41% +15_long_strange_P>5GeV : 935/ 1341 69.72% ( 71.22%), 4 ( 0.43%) clones, pur 98.83%, hit eff 96.28% +16_long_strange_P>5GeV_PT>500MeV : 392/ 466 84.12% ( 85.08%), 2 ( 0.51%) clones, pur 98.78%, hit eff 95.79% restricted_muon_validation validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt index d785a59af82..7cf5927caca 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_a5000.txt @@ -117,6 +117,8 @@ Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz @@ -138,8 +140,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz -Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz -Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz @@ -147,11 +147,15 @@ Hlt1BeamOne: 0/ 1000, ( 0.00 +/- Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 3/ 1000, ( 90.00 +/- 51.88) kHz Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz @@ -173,6 +177,8 @@ Hlt1DiMuonLowMass: 58 68 Hlt1DiMuonSoft: 0 0 Hlt1LowPtDiMuon: 170 276 Hlt1TrackMuonMVA: 11 11 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 Hlt1TrackElectronMVA: 33 36 Hlt1SingleHighPtElectron: 9 9 Hlt1DisplacedDielectron: 12 13 @@ -194,8 +200,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 Hlt1DisplacedLeptons: 29 0 Hlt1SingleHighEt: 0 0 -Hlt1DiMuonNoIP: 30 37 -Hlt1DiMuonNoIP_ss: 3 4 Hlt1Passthrough: 1000 0 Hlt1GECPassthrough: 887 0 Hlt1NoBeam: 0 0 @@ -203,15 +207,19 @@ Hlt1BeamOne: 0 0 Hlt1BeamTwo: 0 0 Hlt1BothBeams: 1 0 Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 Hlt1ODINNoBias: 0 0 Hlt1VeloMicroBias: 1 0 Hlt1RICH1Alignment: 1 1 Hlt1RICH2Alignment: 0 0 Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 26 27 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 3 3 -Total decisions: 3826 +Total decisions: 3855 Total tracks: 3357 Total SVs: 2611 Total hits: 69259 -Total stdinfo: 41126 +Total stdinfo: 41155 diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt index 2fefcfe44af..37286cd3d08 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_epyc7502.txt @@ -117,6 +117,8 @@ Hlt1DiMuonLowMass: 57/ 1000, ( 1710.00 +/- Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1LowPtDiMuon: 173/ 1000, ( 5190.00 +/- 358.84) kHz Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1DiMuonNoIP: 31/ 1000, ( 930.00 +/- 164.42) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1TrackElectronMVA: 34/ 1000, ( 1020.00 +/- 171.93) kHz Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz @@ -138,8 +140,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 3/ 1000, ( 90.00 +/- Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1DisplacedLeptons: 32/ 1000, ( 960.00 +/- 166.97) kHz Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz -Hlt1DiMuonNoIP: 31/ 1000, ( 930.00 +/- 164.42) kHz -Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz @@ -147,11 +147,15 @@ Hlt1BeamOne: 0/ 1000, ( 0.00 +/- Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 25/ 1000, ( 750.00 +/- 148.11) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 4/ 1000, ( 120.00 +/- 59.88) kHz Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz @@ -173,6 +177,8 @@ Hlt1DiMuonLowMass: 57 70 Hlt1DiMuonSoft: 0 0 Hlt1LowPtDiMuon: 173 277 Hlt1TrackMuonMVA: 11 11 +Hlt1DiMuonNoIP: 31 36 +Hlt1DiMuonNoIP_ss: 3 4 Hlt1TrackElectronMVA: 34 37 Hlt1SingleHighPtElectron: 9 9 Hlt1DisplacedDielectron: 12 13 @@ -194,8 +200,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 3 3 Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 Hlt1DisplacedLeptons: 32 0 Hlt1SingleHighEt: 0 0 -Hlt1DiMuonNoIP: 31 36 -Hlt1DiMuonNoIP_ss: 3 4 Hlt1Passthrough: 1000 0 Hlt1GECPassthrough: 887 0 Hlt1NoBeam: 0 0 @@ -203,15 +207,19 @@ Hlt1BeamOne: 0 0 Hlt1BeamTwo: 0 0 Hlt1BothBeams: 1 0 Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 Hlt1ODINNoBias: 0 0 Hlt1VeloMicroBias: 1 0 Hlt1RICH1Alignment: 1 1 Hlt1RICH2Alignment: 0 0 Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 25 26 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 4 4 -Total decisions: 3840 +Total decisions: 3869 Total tracks: 3391 Total SVs: 2630 Total hits: 69736 -Total stdinfo: 41488 +Total stdinfo: 41517 diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt index d785a59af82..7cf5927caca 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx2080ti.txt @@ -117,6 +117,8 @@ Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz @@ -138,8 +140,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz -Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz -Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz @@ -147,11 +147,15 @@ Hlt1BeamOne: 0/ 1000, ( 0.00 +/- Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 3/ 1000, ( 90.00 +/- 51.88) kHz Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz @@ -173,6 +177,8 @@ Hlt1DiMuonLowMass: 58 68 Hlt1DiMuonSoft: 0 0 Hlt1LowPtDiMuon: 170 276 Hlt1TrackMuonMVA: 11 11 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 Hlt1TrackElectronMVA: 33 36 Hlt1SingleHighPtElectron: 9 9 Hlt1DisplacedDielectron: 12 13 @@ -194,8 +200,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 Hlt1DisplacedLeptons: 29 0 Hlt1SingleHighEt: 0 0 -Hlt1DiMuonNoIP: 30 37 -Hlt1DiMuonNoIP_ss: 3 4 Hlt1Passthrough: 1000 0 Hlt1GECPassthrough: 887 0 Hlt1NoBeam: 0 0 @@ -203,15 +207,19 @@ Hlt1BeamOne: 0 0 Hlt1BeamTwo: 0 0 Hlt1BothBeams: 1 0 Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 Hlt1ODINNoBias: 0 0 Hlt1VeloMicroBias: 1 0 Hlt1RICH1Alignment: 1 1 Hlt1RICH2Alignment: 0 0 Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 26 27 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 3 3 -Total decisions: 3826 +Total decisions: 3855 Total tracks: 3357 Total SVs: 2611 Total hits: 69259 -Total stdinfo: 41126 +Total stdinfo: 41155 diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt index d785a59af82..7cf5927caca 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_matching_validation_geforcertx3090.txt @@ -117,6 +117,8 @@ Hlt1DiMuonLowMass: 58/ 1000, ( 1740.00 +/- Hlt1DiMuonSoft: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1LowPtDiMuon: 170/ 1000, ( 5100.00 +/- 356.36) kHz Hlt1TrackMuonMVA: 11/ 1000, ( 330.00 +/- 98.95) kHz +Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz +Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1TrackElectronMVA: 33/ 1000, ( 990.00 +/- 169.47) kHz Hlt1SingleHighPtElectron: 9/ 1000, ( 270.00 +/- 89.59) kHz Hlt1DisplacedDielectron: 12/ 1000, ( 360.00 +/- 103.30) kHz @@ -138,8 +140,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2/ 1000, ( 60.00 +/- Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1DisplacedLeptons: 29/ 1000, ( 870.00 +/- 159.20) kHz Hlt1SingleHighEt: 0/ 1000, ( 0.00 +/- 0.00) kHz -Hlt1DiMuonNoIP: 30/ 1000, ( 900.00 +/- 161.83) kHz -Hlt1DiMuonNoIP_ss: 3/ 1000, ( 90.00 +/- 51.88) kHz Hlt1Passthrough: 1000/ 1000, (30000.00 +/- 0.00) kHz Hlt1GECPassthrough: 887/ 1000, (26610.00 +/- 300.35) kHz Hlt1NoBeam: 0/ 1000, ( 0.00 +/- 0.00) kHz @@ -147,11 +147,15 @@ Hlt1BeamOne: 0/ 1000, ( 0.00 +/- Hlt1BeamTwo: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BothBeams: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1ODINLumi: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1ODINVeloOpen: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1ODINNoBias: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1VeloMicroBias: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH1Alignment: 1/ 1000, ( 30.00 +/- 29.98) kHz Hlt1RICH2Alignment: 0/ 1000, ( 0.00 +/- 0.00) kHz Hlt1BeamGas: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1D2KPiAlignment: 26/ 1000, ( 780.00 +/- 150.97) kHz +Hlt1DiMuonHighMassAlignment: 0/ 1000, ( 0.00 +/- 0.00) kHz +Hlt1DisplacedDiMuonAlignment: 3/ 1000, ( 90.00 +/- 51.88) kHz Inclusive: 1000/ 1000, (30000.00 +/- 0.00) kHz @@ -173,6 +177,8 @@ Hlt1DiMuonLowMass: 58 68 Hlt1DiMuonSoft: 0 0 Hlt1LowPtDiMuon: 170 276 Hlt1TrackMuonMVA: 11 11 +Hlt1DiMuonNoIP: 30 37 +Hlt1DiMuonNoIP_ss: 3 4 Hlt1TrackElectronMVA: 33 36 Hlt1SingleHighPtElectron: 9 9 Hlt1DisplacedDielectron: 12 13 @@ -194,8 +200,6 @@ Hlt1LowMassNoipDielectron_massSlice4_displaced: 2 2 Hlt1LowMassNoipDielectron_SS_massSlice4_displaced: 0 0 Hlt1DisplacedLeptons: 29 0 Hlt1SingleHighEt: 0 0 -Hlt1DiMuonNoIP: 30 37 -Hlt1DiMuonNoIP_ss: 3 4 Hlt1Passthrough: 1000 0 Hlt1GECPassthrough: 887 0 Hlt1NoBeam: 0 0 @@ -203,15 +207,19 @@ Hlt1BeamOne: 0 0 Hlt1BeamTwo: 0 0 Hlt1BothBeams: 1 0 Hlt1ODINLumi: 0 0 +Hlt1ODINVeloOpen: 0 0 Hlt1ODINNoBias: 0 0 Hlt1VeloMicroBias: 1 0 Hlt1RICH1Alignment: 1 1 Hlt1RICH2Alignment: 0 0 Hlt1BeamGas: 0 0 +Hlt1D2KPiAlignment: 26 27 +Hlt1DiMuonHighMassAlignment: 0 0 +Hlt1DisplacedDiMuonAlignment: 3 3 -Total decisions: 3826 +Total decisions: 3855 Total tracks: 3357 Total SVs: 2611 Total hits: 69259 -Total stdinfo: 41126 +Total stdinfo: 41155 diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt index 61bafbc4a3a..0997b3c811e 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_a5000.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 965/ 10846 8.90% 10_long_fromB_electrons_P>5GeV : 33/ 126 26.19% ( 29.09%), 2 ( 5.71%) clones, pur 99.05%, hit eff 96.12% long_P>5GeV_AND_Pt>1GeV : 7071/ 7884 89.69% ( 90.16%), 70 ( 0.98%) clones, pur 99.59%, hit eff 97.10% long_fromB_P>5GeV_AND_Pt>1GeV : 1862/ 2026 91.91% ( 91.17%), 20 ( 1.06%) clones, pur 99.57%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1785/ 1897 94.10% ( 94.20%), 15 ( 0.83%) clones, pur 99.61%, hit eff 97.40% +14_long_from_B_PT>2GeV : 833/ 877 94.98% ( 94.83%), 8 ( 0.95%) clones, pur 99.55%, hit eff 97.34% +15_long_strange_P>5GeV : 140/ 1341 10.44% ( 10.97%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% +16_long_strange_P>5GeV_PT>500MeV : 140/ 466 30.04% ( 29.51%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt index 722e8d30bb6..668b6b7cd0d 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_epyc7502.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 895/ 10472 8.55% 10_long_fromB_electrons_P>5GeV : 31/ 126 24.60% ( 27.16%), 2 ( 6.06%) clones, pur 99.29%, hit eff 96.62% long_P>5GeV_AND_Pt>1GeV : 6844/ 7884 86.81% ( 88.01%), 71 ( 1.03%) clones, pur 99.53%, hit eff 96.89% long_fromB_P>5GeV_AND_Pt>1GeV : 1808/ 2026 89.24% ( 88.57%), 22 ( 1.20%) clones, pur 99.50%, hit eff 97.14% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1709/ 1897 90.09% ( 90.45%), 15 ( 0.87%) clones, pur 99.53%, hit eff 97.16% +14_long_from_B_PT>2GeV : 804/ 877 91.68% ( 90.77%), 10 ( 1.23%) clones, pur 99.45%, hit eff 97.10% +15_long_strange_P>5GeV : 135/ 1341 10.07% ( 10.54%), 1 ( 0.74%) clones, pur 99.17%, hit eff 95.40% +16_long_strange_P>5GeV_PT>500MeV : 135/ 466 28.97% ( 28.74%), 1 ( 0.74%) clones, pur 99.17%, hit eff 95.40% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt index 61bafbc4a3a..0997b3c811e 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx2080ti.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 965/ 10846 8.90% 10_long_fromB_electrons_P>5GeV : 33/ 126 26.19% ( 29.09%), 2 ( 5.71%) clones, pur 99.05%, hit eff 96.12% long_P>5GeV_AND_Pt>1GeV : 7071/ 7884 89.69% ( 90.16%), 70 ( 0.98%) clones, pur 99.59%, hit eff 97.10% long_fromB_P>5GeV_AND_Pt>1GeV : 1862/ 2026 91.91% ( 91.17%), 20 ( 1.06%) clones, pur 99.57%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1785/ 1897 94.10% ( 94.20%), 15 ( 0.83%) clones, pur 99.61%, hit eff 97.40% +14_long_from_B_PT>2GeV : 833/ 877 94.98% ( 94.83%), 8 ( 0.95%) clones, pur 99.55%, hit eff 97.34% +15_long_strange_P>5GeV : 140/ 1341 10.44% ( 10.97%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% +16_long_strange_P>5GeV_PT>500MeV : 140/ 466 30.04% ( 29.51%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt index 61bafbc4a3a..0997b3c811e 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_no_ut_validation_geforcertx3090.txt @@ -41,6 +41,12 @@ for P>3GeV,Pt>0.5GeV : 965/ 10846 8.90% 10_long_fromB_electrons_P>5GeV : 33/ 126 26.19% ( 29.09%), 2 ( 5.71%) clones, pur 99.05%, hit eff 96.12% long_P>5GeV_AND_Pt>1GeV : 7071/ 7884 89.69% ( 90.16%), 70 ( 0.98%) clones, pur 99.59%, hit eff 97.10% long_fromB_P>5GeV_AND_Pt>1GeV : 1862/ 2026 91.91% ( 91.17%), 20 ( 1.06%) clones, pur 99.57%, hit eff 97.36% +11_noVelo_UT : 0/ 6697 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2668 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1785/ 1897 94.10% ( 94.20%), 15 ( 0.83%) clones, pur 99.61%, hit eff 97.40% +14_long_from_B_PT>2GeV : 833/ 877 94.98% ( 94.83%), 8 ( 0.95%) clones, pur 99.55%, hit eff 97.34% +15_long_strange_P>5GeV : 140/ 1341 10.44% ( 10.97%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% +16_long_strange_P>5GeV_PT>500MeV : 140/ 466 30.04% ( 29.51%), 1 ( 0.71%) clones, pur 99.30%, hit eff 95.42% muon_validator validation: diff --git a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt index de49c49bc2d..c5ddb7a6561 100644 --- a/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt +++ b/test/reference/Upgrade_BsPhiPhi_MD_FTv4_DIGI_retinacluster_v1_hlt1_pp_validation_geforcertx3090.txt @@ -197,5 +197,5 @@ Total decisions: 3541 Total tracks: 2681 Total SVs: 2210 Total hits: 66438 -Total stdinfo: 33799 +Total stdinfo: 33829 diff --git a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_a5000.txt b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_a5000.txt index ad750bf7edb..e8275030dfb 100644 --- a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_a5000.txt +++ b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_a5000.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 456/ 18850 2.42% 10_long_fromB_electrons_P>5GeV : 4/ 5 80.00% ( 80.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 97.92% long_P>5GeV_AND_Pt>1GeV : 5879/ 6583 89.31% ( 90.40%), 41 ( 0.69%) clones, pur 99.47%, hit eff 97.34% long_fromB_P>5GeV_AND_Pt>1GeV : 16/ 16 100.00% (100.00%), 0 ( 0.00%) clones, pur 98.65%, hit eff 98.62% +11_noVelo_UT : 0/ 5489 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2204 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1092/ 1201 90.92% ( 90.34%), 6 ( 0.55%) clones, pur 99.50%, hit eff 97.70% +14_long_from_B_PT>2GeV : 7/ 7 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.81% +15_long_strange_P>5GeV : 775/ 1380 56.16% ( 58.26%), 7 ( 0.90%) clones, pur 99.25%, hit eff 97.08% +16_long_strange_P>5GeV_PT>500MeV : 447/ 526 84.98% ( 85.66%), 3 ( 0.67%) clones, pur 99.25%, hit eff 97.09% muon_validator validation: diff --git a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_epyc7502.txt b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_epyc7502.txt index 8d4d89a6092..22f87518a20 100644 --- a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_epyc7502.txt +++ b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_epyc7502.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 611/ 18326 3.33% 10_long_fromB_electrons_P>5GeV : 3/ 5 60.00% ( 60.00%), 0 ( 0.00%) clones, pur 98.41%, hit eff 94.44% long_P>5GeV_AND_Pt>1GeV : 5680/ 6583 86.28% ( 88.63%), 39 ( 0.68%) clones, pur 99.27%, hit eff 96.76% long_fromB_P>5GeV_AND_Pt>1GeV : 14/ 16 87.50% ( 83.33%), 0 ( 0.00%) clones, pur 98.45%, hit eff 99.02% +11_noVelo_UT : 0/ 5489 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2204 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1059/ 1201 88.18% ( 88.68%), 5 ( 0.47%) clones, pur 99.30%, hit eff 97.16% +14_long_from_B_PT>2GeV : 6/ 7 85.71% ( 75.00%), 0 ( 0.00%) clones, pur 99.17%, hit eff 98.61% +15_long_strange_P>5GeV : 750/ 1380 54.35% ( 56.16%), 7 ( 0.92%) clones, pur 99.08%, hit eff 96.71% +16_long_strange_P>5GeV_PT>500MeV : 431/ 526 81.94% ( 82.71%), 3 ( 0.69%) clones, pur 99.10%, hit eff 96.82% muon_validator validation: diff --git a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt index ad750bf7edb..e8275030dfb 100644 --- a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt +++ b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx2080ti.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 456/ 18850 2.42% 10_long_fromB_electrons_P>5GeV : 4/ 5 80.00% ( 80.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 97.92% long_P>5GeV_AND_Pt>1GeV : 5879/ 6583 89.31% ( 90.40%), 41 ( 0.69%) clones, pur 99.47%, hit eff 97.34% long_fromB_P>5GeV_AND_Pt>1GeV : 16/ 16 100.00% (100.00%), 0 ( 0.00%) clones, pur 98.65%, hit eff 98.62% +11_noVelo_UT : 0/ 5489 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2204 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1092/ 1201 90.92% ( 90.34%), 6 ( 0.55%) clones, pur 99.50%, hit eff 97.70% +14_long_from_B_PT>2GeV : 7/ 7 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.81% +15_long_strange_P>5GeV : 775/ 1380 56.16% ( 58.26%), 7 ( 0.90%) clones, pur 99.25%, hit eff 97.08% +16_long_strange_P>5GeV_PT>500MeV : 447/ 526 84.98% ( 85.66%), 3 ( 0.67%) clones, pur 99.25%, hit eff 97.09% muon_validator validation: diff --git a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt index ad750bf7edb..e8275030dfb 100644 --- a/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt +++ b/test/reference/upgrade_mc_minbias_scifi_v5_retinacluster_000_v1_hlt1_pp_SMOG2_validation_geforcertx3090.txt @@ -58,6 +58,12 @@ for P>3GeV,Pt>0.5GeV : 456/ 18850 2.42% 10_long_fromB_electrons_P>5GeV : 4/ 5 80.00% ( 80.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 97.92% long_P>5GeV_AND_Pt>1GeV : 5879/ 6583 89.31% ( 90.40%), 41 ( 0.69%) clones, pur 99.47%, hit eff 97.34% long_fromB_P>5GeV_AND_Pt>1GeV : 16/ 16 100.00% (100.00%), 0 ( 0.00%) clones, pur 98.65%, hit eff 98.62% +11_noVelo_UT : 0/ 5489 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +12_noVelo_UT_P>5GeV : 0/ 2204 0.00% ( 0.00%), 0 ( 0.00%) clones, pur -nan%, hit eff -nan% +13_long_PT>2GeV : 1092/ 1201 90.92% ( 90.34%), 6 ( 0.55%) clones, pur 99.50%, hit eff 97.70% +14_long_from_B_PT>2GeV : 7/ 7 100.00% (100.00%), 0 ( 0.00%) clones, pur 99.29%, hit eff 98.81% +15_long_strange_P>5GeV : 775/ 1380 56.16% ( 58.26%), 7 ( 0.90%) clones, pur 99.25%, hit eff 97.08% +16_long_strange_P>5GeV_PT>500MeV : 447/ 526 84.98% ( 85.66%), 3 ( 0.67%) clones, pur 99.25%, hit eff 97.09% muon_validator validation: -- GitLab