SingleHitTrack.cc

Go to the documentation of this file.

#include "L1Trigger/L1TMuonEndCap/interface/SingleHitTrack.h"

void SingleHitTrack::configure(
    int verbose, int endcap, int sector, int bx,
    int maxTracks,
    bool useSingleHits
) {
  verbose_ = verbose;
  endcap_  = endcap;
  sector_  = sector;
  bx_      = bx;

  maxTracks_ = maxTracks;

  useSingleHits_ = useSingleHits;
}

void SingleHitTrack::process(
    const EMTFHitCollection& conv_hits,
    EMTFTrackCollection& best_tracks
) const {

  if (conv_hits.empty())
    return;

  if (!useSingleHits_)
    return;

  if (int(best_tracks.size()) >= maxTracks_)
    return;

  // New collection to contain single-hit tracks
  EMTFTrackCollection one_hit_trks;

  // Loop over [subsector, CSC ID] pairs in order: [2,3], [2,2], [2,1], [1,3], [1,2], [1,1]
  for (int sub_ID = 5; sub_ID >= 0; sub_ID--) {
    int subsector = 1 + (sub_ID / 3);
    int CSC_ID    = 1 + (sub_ID % 3);

    // Loop over all the hits in a given BX
    for (const auto & conv_hits_it : conv_hits) {

      // Require subsector and CSC ID to match
      if (conv_hits_it.Subsector() != subsector || conv_hits_it.CSC_ID() != CSC_ID)
    continue;

      // Only consider CSC LCTs
      if (conv_hits_it.Is_CSC() != 1)
    continue;
      
      // Only consider hits in station 1, ring 1
      if (conv_hits_it.Station() != 1 || (conv_hits_it.Ring() % 3) != 1)
    continue;
      
      // Only consider hits in the same sector (not neighbor hits)
      if ( (conv_hits_it.Endcap() == 1) != (endcap_ == 1) || conv_hits_it.Sector() != sector_ )
    continue;

      // Check if a hit has already been used in a track
      bool already_used = false;

      // Loop over existing multi-hit tracks
      for (const auto & best_tracks_it : best_tracks) {

    // Only consider tracks with a hit in station 1
    if (best_tracks_it.Mode() < 8)
      continue;
    
    // Check if hit in track is identical
    // "Duplicate" hits (with same strip but different wire) are considered identical
    // const EMTFHit& conv_hit_i = *conv_hits_it;
    const EMTFHit& conv_hit_j = best_tracks_it.Hits().front();
    
    if (
        (conv_hits_it.Subsystem()  == conv_hit_j.Subsystem()) &&
        (conv_hits_it.PC_station() == conv_hit_j.PC_station()) &&
        (conv_hits_it.PC_chamber() == conv_hit_j.PC_chamber()) &&
        ((conv_hits_it.Ring() % 3) == (conv_hit_j.Ring() % 3)) &&  // because of ME1/1
        (conv_hits_it.Strip()      == conv_hit_j.Strip()) &&
        // (conv_hits_it.Wire()       == conv_hit_j.Wire()) &&
        (conv_hits_it.BX()         == conv_hit_j.BX()) &&
        true
        ) {
      already_used = true;
      break;
    }
      } // End loop: for (const auto & best_tracks_it : best_tracks)

      // Only use hits that have not been used in a track
      if (already_used)
    continue;
      
      int zone = -1;
      int zone_code = conv_hits_it.Zone_code();
      if      (zone_code & 0b1000) zone = 4;
      else if (zone_code & 0b0100) zone = 3;
      else if (zone_code & 0b0010) zone = 2;
      else if (zone_code & 0b0001) zone = 1;
      else {
    edm::LogError("L1T") << "EMTF SingleHitTrack.cc - bizzare case where zone_code = " << zone_code; return;
      }

      EMTFTrack new_trk;
      new_trk.push_Hit ( conv_hits_it );
      
      EMTFPtLUT empty_LUT = {};
      new_trk.set_PtLUT ( empty_LUT );
      
      new_trk.set_endcap       ( conv_hits_it.Endcap()     );
      new_trk.set_sector       ( conv_hits_it.Sector()     );
      new_trk.set_sector_idx   ( conv_hits_it.Sector_idx() );
      new_trk.set_mode         ( 1 ); // Set "mode" to 1
      new_trk.set_mode_inv     ( 0 );
      new_trk.set_rank         ( 0b0100000 );  // Station 1 hit, straightness 0 (see "rank" in AngleCalculation.cc)
      new_trk.set_winner       ( maxTracks_ - 1 );  // Always set to the last / lowest track
      new_trk.set_bx           ( bx_ );
      new_trk.set_first_bx     ( bx_ );
      new_trk.set_second_bx    ( bx_ );
      new_trk.set_zone         ( zone );
      new_trk.set_ph_num       ( conv_hits_it.Zone_hit() );
      new_trk.set_ph_q         ( 0b010000 );  // Original "quality_code" from PatternRecognition.cc
      new_trk.set_theta_fp     ( conv_hits_it.Theta_fp() );
      new_trk.set_theta        ( conv_hits_it.Theta() );
      new_trk.set_eta          ( conv_hits_it.Eta() );
      new_trk.set_phi_fp       ( conv_hits_it.Phi_fp() );
      new_trk.set_phi_loc      ( conv_hits_it.Phi_loc() );
      new_trk.set_phi_glob     ( conv_hits_it.Phi_glob() );
      new_trk.set_track_num    ( maxTracks_ - 1 );
      
      one_hit_trks.push_back( new_trk );
      
      if (int(best_tracks.size()) + int(one_hit_trks.size()) >= maxTracks_)
    break;
    
      // Firmware only sends one single-hit track per sector
      if (!one_hit_trks.empty()) 
    break;

    } // End loop:  for (const auto & conv_hits_it : conv_hits)

    if (!one_hit_trks.empty()) 
      break;

  } // End loop: for (int sub_ID = 5; sub_ID > 0; sub_ID--) {


  best_tracks.insert(best_tracks.end(), one_hit_trks.begin(), one_hit_trks.end());
}