EMTFTrack.h

Go to the documentation of this file.

// Class for muon tracks in EMTF - AWB 04.01.16
// Mostly copied from L1Trigger/L1TMuonEndCap/interface/MuonInternalTrack.h

#ifndef DataFormats_L1TMuon_EMTFTrack_h
#define DataFormats_L1TMuon_EMTFTrack_h

#include <cstdint>
#include <vector>

#include "DataFormats/L1TMuon/interface/EMTFHit.h"
#include "DataFormats/L1TMuon/interface/EMTFRoad.h"
#include "DataFormats/L1TMuon/interface/EMTF/SP.h"

namespace l1t {

  struct EMTFPtLUT {
    uint64_t address;
    uint16_t mode;
    uint16_t theta;
    uint16_t st1_ring2;
    uint16_t eta;
    uint16_t delta_ph[6];  // index: 0=12, 1=13, 2=14, 3=23, 4=24, 5=34
    uint16_t delta_th[6];  // ^
    uint16_t sign_ph[6];   // ^
    uint16_t sign_th[6];   // ^
    uint16_t cpattern[4];  // index: 0=ME1, 1=ME2, 2=ME3, 3=ME4
    uint16_t fr[4];        // ^
    uint16_t bt_vi[5];     // index: 0=ME1sub1, 1=ME1sub2, 2=ME2, 3=ME3, 4=ME4
    uint16_t bt_hi[5];     // ^
    uint16_t bt_ci[5];     // ^
    uint16_t bt_si[5];     // ^
  };

  class EMTFTrack {
  public:
    EMTFTrack()
        : _PtLUT(),
          endcap(-99),
          sector(-99),
          sector_idx(-99),
          mode(-99),
          mode_CSC(0),
          mode_RPC(0),
          mode_neighbor(0),
          mode_inv(-99),
          rank(-99),
          winner(-99),
          charge(-99),
          bx(-99),
          first_bx(-99),
          second_bx(-99),
          pt(-99),
          pt_XML(-99),
          zone(-99),
          ph_num(-99),
          ph_q(-99),
          theta_fp(-99),
          theta(-99),
          eta(-99),
          phi_fp(-99),
          phi_loc(-99),
          phi_glob(-999),
          gmt_pt(-99),
          gmt_phi(-999),
          gmt_eta(-999),
          gmt_quality(-99),
          gmt_charge(-99),
          gmt_charge_valid(-99),
          track_num(-99),
          numHits(-99){};

    virtual ~EMTFTrack(){};

    void ImportSP(const emtf::SP _SP, int _sector);
    // void ImportPtLUT( int _mode, unsigned long _address );

    void clear_Hits() {
      _Hits.clear();
      numHits = 0;
      mode_CSC = 0;
      mode_RPC = 0;
      mode_neighbor = 0;
    }

    void push_Hit(const EMTFHit& hit) {
      _Hits.push_back(hit);
      numHits = _Hits.size();
      if (hit.Is_CSC())
        mode_CSC |= (1 << (4 - hit.Station()));
      if (hit.Is_RPC())
        mode_RPC |= (1 << (4 - hit.Station()));
      if (hit.Neighbor())
        mode_neighbor |= (1 << (4 - hit.Station()));
    }

    void set_Hits(const EMTFHitCollection& hits) {
      clear_Hits();
      for (const auto& hit : hits)
        push_Hit(hit);
    }

    void clear_HitIdx() { _HitIdx.clear(); }
    void push_HitIdx(unsigned int bits) { _HitIdx.push_back(bits); }
    void set_HitIdx(const std::vector<unsigned int>& bits) { _HitIdx = bits; }

    int NumHits() const { return numHits; }
    EMTFHitCollection Hits() const { return _Hits; }
    std::vector<unsigned int> HitIdx() const { return _HitIdx; }

    void set_Road(const EMTFRoad& bits) { _Road = bits; }
    void set_RoadIdx(unsigned int bits) { _RoadIdx = bits; }
    EMTFRoad Road() const { return _Road; }
    unsigned int RoadIdx() const { return _RoadIdx; }

    void set_PtLUT(EMTFPtLUT bits) { _PtLUT = bits; }
    EMTFPtLUT PtLUT() const { return _PtLUT; }

    void set_endcap(int bits) { endcap = bits; }
    void set_sector(int bits) { sector = bits; }
    void set_sector_idx(int bits) { sector_idx = bits; }
    void set_mode(int bits) { mode = bits; }
    void set_mode_inv(int bits) { mode_inv = bits; }
    void set_rank(int bits) { rank = bits; }
    void set_winner(int bits) { winner = bits; }
    void set_charge(int bits) { charge = bits; }
    void set_bx(int bits) { bx = bits; }
    void set_first_bx(int bits) { first_bx = bits; }
    void set_second_bx(int bits) { second_bx = bits; }
    void set_pt(float val) { pt = val; }
    void set_pt_XML(float val) { pt_XML = val; }
    void set_zone(int bits) { zone = bits; }
    void set_ph_num(int bits) { ph_num = bits; }
    void set_ph_q(int bits) { ph_q = bits; }
    void set_theta_fp(int bits) { theta_fp = bits; }
    void set_theta(float val) { theta = val; }
    void set_eta(float val) { eta = val; }
    void set_phi_fp(int bits) { phi_fp = bits; }
    void set_phi_loc(float val) { phi_loc = val; }
    void set_phi_glob(float val) { phi_glob = val; }
    void set_gmt_pt(int bits) { gmt_pt = bits; }
    void set_gmt_phi(int bits) { gmt_phi = bits; }
    void set_gmt_eta(int bits) { gmt_eta = bits; }
    void set_gmt_quality(int bits) { gmt_quality = bits; }
    void set_gmt_charge(int bits) { gmt_charge = bits; }
    void set_gmt_charge_valid(int bits) { gmt_charge_valid = bits; }
    void set_track_num(int bits) { track_num = bits; }

    int Endcap() const { return endcap; }
    int Sector() const { return sector; }
    int Sector_idx() const { return sector_idx; }
    int Mode() const { return mode; }
    int Mode_CSC() const { return mode_CSC; }
    int Mode_RPC() const { return mode_RPC; }
    int Mode_neighbor() const { return mode_neighbor; }
    int Mode_inv() const { return mode_inv; }
    int Rank() const { return rank; }
    int Winner() const { return winner; }
    int Charge() const { return charge; }
    int BX() const { return bx; }
    int First_BX() const { return first_bx; }
    int Second_BX() const { return second_bx; }
    float Pt() const { return pt; }
    float Pt_XML() const { return pt_XML; }
    int Zone() const { return zone; }
    int Ph_num() const { return ph_num; }
    int Ph_q() const { return ph_q; }
    int Theta_fp() const { return theta_fp; }
    float Theta() const { return theta; }
    float Eta() const { return eta; }
    int Phi_fp() const { return phi_fp; }
    float Phi_loc() const { return phi_loc; }
    float Phi_glob() const { return phi_glob; }
    int GMT_pt() const { return gmt_pt; }
    int GMT_phi() const { return gmt_phi; }
    int GMT_eta() const { return gmt_eta; }
    int GMT_quality() const { return gmt_quality; }
    int GMT_charge() const { return gmt_charge; }
    int GMT_charge_valid() const { return gmt_charge_valid; }
    int Track_num() const { return track_num; }

  private:
    EMTFHitCollection _Hits;
    std::vector<unsigned int> _HitIdx;

    EMTFRoad _Road;
    unsigned int _RoadIdx;

    EMTFPtLUT _PtLUT;

    int endcap;         //    +/-1.  For ME+ and ME-.
    int sector;         //  1 -  6.
    int sector_idx;     //  0 - 11.  0 - 5 for ME+, 6 - 11 for ME-.
    int mode;           //  0 - 15.
    int mode_CSC;       //  0 - 15, CSC-only
    int mode_RPC;       //  0 - 15, RPC-only
    int mode_neighbor;  // 0 - 15, only neighbor hits
    int mode_inv;       // 15 -  0.
    int rank;           //  0 - 127  (Range? - AWB 03.03.17)
    int winner;         //  0 -  2.  (Range? - AWB 03.03.17)
    int charge;         //    +/-1.  For physical charge (reversed from GMT convention)
    int bx;             // -3 - +3.
    int first_bx;       // -3 - +3.
    int second_bx;      // -3 - +3.
    float pt;           //  0 - 255
    float pt_XML;       //  0 - 999
    int zone;           //  0 -  3.
    int ph_num;
    int ph_q;
    int theta_fp;    //  0 - 127
    float theta;     //  0 - 90.
    float eta;       //  +/-2.5.
    int phi_fp;      // 0 - 4920
    float phi_loc;   // -22 - 60  (Range? - AWB 03.03.17)
    float phi_glob;  //  +/-180.
    int gmt_pt;
    int gmt_phi;
    int gmt_eta;
    int gmt_quality;
    int gmt_charge;
    int gmt_charge_valid;
    int track_num;  //  0 - ??.  (Range? - AWB 03.03.17)
    int numHits;    //  1 -  4.

  };  // End of class EMTFTrack

  // Define a vector of EMTFTrack
  typedef std::vector<EMTFTrack> EMTFTrackCollection;

}  // End of namespace l1t

#endif /* define DataFormats_L1TMuon_EMTFTrack_h */