d6/d97/EMTFHit_8h_source.html

// Class for input trigger primitives to EMTF - AWB 04.01.16

// Based on L1Trigger/L1TMuon/interface/MuonTriggerPrimitive.h

// In particular, see struct CSCData


#ifndef DataFormats_L1TMuon_EMTFHit_h

#define DataFormats_L1TMuon_EMTFHit_h


#include <cstdint>

#include <vector>


#include "DataFormats/MuonDetId/interface/CSCDetId.h"

#include "DataFormats/MuonDetId/interface/RPCDetId.h"

#include "DataFormats/MuonDetId/interface/GEMDetId.h"

#include "DataFormats/MuonDetId/interface/ME0DetId.h"

#include "DataFormats/MuonDetId/interface/DTChamberId.h"

#include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigi.h"

#include "DataFormats/GEMDigi/interface/GEMPadDigiCluster.h"

#include "DataFormats/L1TMuon/interface/CPPFDigi.h"

#include "DataFormats/L1TMuon/interface/L1TMuonSubsystems.h"


namespace l1t {


  namespace l1tmu = L1TMuon;


  class EMTFHit {

  public:

    EMTFHit()

        : rawDetId(0),

          subsystem(-99),

          endcap(-99),

          station(-99),

          ring(-99),

          sector(-99),

          sector_RPC(-99),

          sector_idx(-99),

          subsector(-99),

          subsector_RPC(-99),

          chamber(-99),

          csc_ID(-99),

          csc_nID(-99),

          roll(-99),

          neighbor(-99),

          mpc_link(-99),

          pc_sector(-99),

          pc_station(-99),

          pc_chamber(-99),

          pc_segment(-99),

          wire(-99),

          strip(-99),

          strip_hi(-99),

          strip_low(-99),

          strip_quart(-99),       // Run 3

          strip_eighth(-99),      // Run 3

          strip_quart_bit(-99),   // Run 3

          strip_eighth_bit(-99),  // Run 3

          track_num(-99),

          quality(-99),

          pattern(-99),

          pattern_run3(-99),  // Run 3

          bend(-99),

          slope(-99),  // Run 3

          valid(-99),

          sync_err(-99),

          layer(-99),  // TODO: verify inclusion for GEM, or better to generalize this class... - JS 06.07.20

          bc0(-99),

          bx(-99),

          stub_num(-99),

          phi_fp(-99),

          theta_fp(-99),

          zone_hit(-99),

          zone_code(-99),

          fs_segment(-99),

          fs_zone_code(-99),

          bt_station(-99),

          bt_segment(-99),

          phi_loc(-99),

          phi_glob(-999),

          theta(-99),

          eta(-99),

          time(-99),

          phi_sim(-999),

          theta_sim(-99),

          eta_sim(-99),

          rho_sim(-99),

          z_sim(-99),

          alct_quality(-99),

          clct_quality(-99){};


    virtual ~EMTFHit(){};


    CSCDetId CreateCSCDetId() const;

    RPCDetId CreateRPCDetId() const;

    GEMDetId CreateGEMDetId() const;

    ME0DetId CreateME0DetId() const;


    // void ImportCSCCorrelatedLCTDigi (const CSCCorrelatedLCTDigi& _digi);

    CSCCorrelatedLCTDigi CreateCSCCorrelatedLCTDigi() const;

    // void ImportRPCDigi (const RPCDigi& _digi);

    // RPCDigi CreateRPCDigi() const;

    // void ImportCPPFDigi (const CPPFDigi& _digi);

    CPPFDigi CreateCPPFDigi() const;

    // void ImportGEMPadDigiCluster (const GEMPadDigiCluster& _digi);  // TODO: implement placeholder when others are implemented

    GEMPadDigiCluster CreateGEMPadDigiCluster() const;


    // void PrintSimulatorHeader() const;

    // void PrintForSimulator() const;


    //void SetCSCDetId   (const CSCDetId& id)                 { csc_DetId         = id;        }

    //void SetRPCDetId   (const RPCDetId& id)                 { rpc_DetId         = id;        }

    //void SetGEMDetId   (const GEMDetId& id)                 { gem_DetId         = id;        }

    //void SetCSCLCTDigi (const CSCCorrelatedLCTDigi& digi)   { csc_LCTDigi       = digi;      }

    //void SetRPCDigi    (const RPCDigi& digi)                { rpc_Digi          = digi;      }

    //void SetCPPFDigi   (const CPPFDigi& digi)               { cppf_Digi         = digi;      }

    //void SetGEMPadDigiCluster (const GEMPadDigiCluster& digi)             { gem_PadClusterDigi       = digi;      }

    void SetCSCDetId(const CSCDetId& id) { rawDetId = id.rawId(); }

    void SetRPCDetId(const RPCDetId& id) { rawDetId = id.rawId(); }

    void SetGEMDetId(const GEMDetId& id) { rawDetId = id.rawId(); }

    void SetME0DetId(const ME0DetId& id) { rawDetId = id.rawId(); }

    void SetDTDetId(const DTChamberId& id) { rawDetId = id.rawId(); }


    //CSCDetId CSC_DetId                          () const { return csc_DetId;    }

    //RPCDetId RPC_DetId                          () const { return rpc_DetId;    }

    //GEMDetId GEM_DetId                          () const { return gem_DetId;    }

    //CSCCorrelatedLCTDigi CSC_LCTDigi            () const { return csc_LCTDigi;  }

    //RPCDigi RPC_Digi                            () const { return rpc_Digi;     }

    //CPPFDigi CPPF_Digi                          () const { return cppf_Digi;    }

    //GEMPadDigiCluster GEM_PadClusterDigi        () const { return gem_PadClusterDigi;  }

    CSCDetId CSC_DetId() const { return CSCDetId(rawDetId); }

    RPCDetId RPC_DetId() const { return RPCDetId(rawDetId); }

    GEMDetId GEM_DetId() const { return GEMDetId(rawDetId); }

    ME0DetId ME0_DetId() const { return ME0DetId(rawDetId); }

    DTChamberId DT_DetId() const { return DTChamberId(rawDetId); }


    void set_subsystem(int bits) { subsystem = bits; }

    void set_endcap(int bits) { endcap = bits; }

    void set_station(int bits) { station = bits; }

    void set_ring(int bits) { ring = bits; }

    void set_sector(int bits) { sector = bits; }

    void set_sector_RPC(int bits) { sector_RPC = bits; }

    void set_sector_idx(int bits) { sector_idx = bits; }

    void set_subsector(int bits) { subsector = bits; }

    void set_subsector_RPC(int bits) { subsector_RPC = bits; }

    void set_chamber(int bits) { chamber = bits; }

    void set_csc_ID(int bits) { csc_ID = bits; }

    void set_csc_nID(int bits) { csc_nID = bits; }

    void set_roll(int bits) { roll = bits; }

    void set_neighbor(int bits) { neighbor = bits; }

    void set_mpc_link(int bits) { mpc_link = bits; }

    void set_pc_sector(int bits) { pc_sector = bits; }

    void set_pc_station(int bits) { pc_station = bits; }

    void set_pc_chamber(int bits) { pc_chamber = bits; }

    void set_pc_segment(int bits) { pc_segment = bits; }

    void set_wire(int bits) { wire = bits; }

    void set_strip(int bits) { strip = bits; }

    void set_strip_hi(int bits) { strip_hi = bits; }

    void set_strip_low(int bits) { strip_low = bits; }

    void set_strip_quart(int bits) { strip_quart = bits; }            // Run 3

    void set_strip_eighth(int bits) { strip_eighth = bits; }          // Run 3

    void set_strip_quart_bit(int bits) { strip_quart_bit = bits; }    // Run 3

    void set_strip_eighth_bit(int bits) { strip_eighth_bit = bits; }  // Run 3

    void set_track_num(int bits) { track_num = bits; }

    void set_quality(int bits) { quality = bits; }

    void set_pattern(int bits) { pattern = bits; }

    void set_pattern_run3(int bits) { pattern_run3 = bits; }  // Run 3

    void set_bend(int bits) { bend = bits; }

    void set_slope(int bits) { slope = bits; }  // Run 3

    void set_valid(int bits) { valid = bits; }

    void set_sync_err(int bits) { sync_err = bits; }

    // GEM specific aliases

    void set_pad(int bits) { set_strip(bits); }

    void set_pad_hi(int bits) { set_strip_hi(bits); }

    void set_pad_low(int bits) { set_strip_low(bits); }

    void set_partition(int bits) { set_roll(bits); }

    void set_layer(int bits) { layer = bits; }

    void set_cluster_size(int bits) { set_quality(bits); }

    void set_cluster_id(int bits) { set_track_num(bits); }

    // END GEM specific

    void set_bc0(int bits) { bc0 = bits; }

    void set_bx(int bits) { bx = bits; }

    void set_stub_num(int bits) { stub_num = bits; }

    void set_phi_fp(int bits) { phi_fp = bits; }

    void set_theta_fp(int bits) { theta_fp = bits; }

    void set_zone_hit(int bits) { zone_hit = bits; }

    void set_zone_code(int bits) { zone_code = bits; }

    void set_fs_segment(int bits) { fs_segment = bits; }

    void set_fs_zone_code(int bits) { fs_zone_code = bits; }

    void set_bt_station(int bits) { bt_station = bits; }

    void set_bt_segment(int bits) { bt_segment = bits; }

    void set_phi_loc(float val) { phi_loc = val; }

    void set_phi_glob(float val) { phi_glob = val; }

    void set_theta(float val) { theta = val; }

    void set_eta(float val) { eta = val; }

    void set_time(float val) { time = val; }

    void set_phi_sim(float val) { phi_sim = val; }

    void set_theta_sim(float val) { theta_sim = val; }

    void set_eta_sim(float val) { eta_sim = val; }

    void set_rho_sim(float val) { rho_sim = val; }

    void set_z_sim(float val) { z_sim = val; }

    void set_alct_quality(int bits) { alct_quality = bits; }

    void set_clct_quality(int bits) { clct_quality = bits; }


    int Subsystem() const { return subsystem; }

    int Endcap() const { return endcap; }

    int Station() const { return station; }

    int Ring() const { return ring; }

    int Sector() const { return sector; }

    int Sector_RPC() const { return sector_RPC; }

    int Sector_idx() const { return sector_idx; }

    int Subsector() const { return subsector; }

    int Subsector_RPC() const { return subsector_RPC; }

    int Chamber() const { return chamber; }

    int CSC_ID() const { return csc_ID; }

    int CSC_nID() const { return csc_nID; }

    int Roll() const { return roll; }

    int Neighbor() const { return neighbor; }

    int MPC_link() const { return mpc_link; }

    int PC_sector() const { return pc_sector; }

    int PC_station() const { return pc_station; }

    int PC_chamber() const { return pc_chamber; }

    int PC_segment() const { return pc_segment; }

    int Wire() const { return wire; }

    int Strip() const { return strip; }

    int Strip_hi() const { return strip_hi; }

    int Strip_low() const { return strip_low; }

    int Strip_quart() const { return strip_quart; }            // Run 3

    int Strip_eighth() const { return strip_eighth; }          // Run 3

    int Strip_quart_bit() const { return strip_quart_bit; }    // Run 3

    int Strip_eighth_bit() const { return strip_eighth_bit; }  // Run 3

    int Track_num() const { return track_num; }

    int Quality() const { return quality; }

    int Pattern() const { return pattern; }

    int Pattern_run3() const { return pattern_run3; }  // Run 3

    int Bend() const { return bend; }

    int Slope() const { return slope; }  // Run 3

    int Valid() const { return valid; }

    int Sync_err() const { return sync_err; }

    // GEM specific aliases for member variables that don't match GEM nomenclature

    /*

     * Each GEM pad is the OR of two neighbouring strips in phi.

     * For GE1/1 (10 degree chambers) this results in a total of 192 pads per eta partition

       * 128 strips per phi sector

       * 3 phi sectors per eta partition

     * For GE2/1 (20 degree chambers) this results in a total of 384 pads per eta partition

       * 128 strips per phi sector

       * 6 phi sectors per eta partition

     */

    int Pad() const { return Strip(); }

    int Pad_hi() const { return Strip_hi(); }

    int Pad_low() const { return Strip_low(); }

    int Partition() const { return Roll(); }

    int Layer() const { return layer; }

    int ClusterSize() const { return Quality(); }

    int ClusterID() const { return Track_num(); }

    // END GEM specific

    int BC0() const { return bc0; }

    int BX() const { return bx; }

    int Stub_num() const { return stub_num; }

    int Phi_fp() const { return phi_fp; }

    int Theta_fp() const { return theta_fp; }

    int Zone_hit() const { return zone_hit; }

    int Zone_code() const { return zone_code; }

    int FS_segment() const { return fs_segment; }

    int FS_zone_code() const { return fs_zone_code; }

    int BT_station() const { return bt_station; }

    int BT_segment() const { return bt_segment; }

    float Phi_loc() const { return phi_loc; }

    float Phi_glob() const { return phi_glob; }

    float Theta() const { return theta; }

    float Eta() const { return eta; }

    float Time() const { return time; }

    float Phi_sim() const { return phi_sim; }

    float Theta_sim() const { return theta_sim; }

    float Eta_sim() const { return eta_sim; }

    float Rho_sim() const { return rho_sim; }

    float Z_sim() const { return z_sim; }

    int ALCT_quality() const { return alct_quality; }

    int CLCT_quality() const { return clct_quality; }


    bool Is_DT() const { return subsystem == l1tmu::kDT; }

    bool Is_CSC() const { return subsystem == l1tmu::kCSC; }

    bool Is_RPC() const { return subsystem == l1tmu::kRPC; }

    bool Is_GEM() const { return subsystem == l1tmu::kGEM; }

    bool Is_ME0() const { return subsystem == l1tmu::kME0; }


  private:

    //CSCDetId csc_DetId;

    //RPCDetId rpc_DetId;

    //GEMDetId gem_DetId;

    //CSCCorrelatedLCTDigi csc_LCTDigi;

    //RPCDigi rpc_Digi;

    //CPPFDigi cppf_Digi;

    //GEMPadDigiCluster gem_PadClusterDigi;


    uint32_t rawDetId;

    int subsystem;

    int endcap;

    int station;

    int ring;

    int sector;

    int sector_RPC;

    int sector_idx;

    int subsector;

    int subsector_RPC;

    int chamber;

    int csc_ID;

    int csc_nID;

    int roll;

    int neighbor;

    int mpc_link;

    int pc_sector;

    int pc_station;

    int pc_chamber;

    int pc_segment;

    int wire;

    int strip;

    int strip_hi;

    int strip_low;

    int strip_quart;

    int strip_eighth;

    int strip_quart_bit;

    int strip_eighth_bit;

    int track_num;

    int quality;

    int pattern;

    int pattern_run3;

    int bend;

    int slope;

    int valid;

    int sync_err;

    // GEM specific

    int layer;

    // END GEM specific

    int bc0;

    int bx;

    int stub_num;

    int phi_fp;

    int theta_fp;

    int zone_hit;

    int zone_code;

    int fs_segment;

    int fs_zone_code;

    int bt_station;

    int bt_segment;

    float phi_loc;

    float phi_glob;

    float theta;

    float eta;

    float time;

    float phi_sim;

    float theta_sim;

    float eta_sim;

    float rho_sim;

    float z_sim;

    int alct_quality;

    int clct_quality;


  };  // End of class EMTFHit


  // Define a vector of EMTFHit

  typedef std::vector<EMTFHit> EMTFHitCollection;


}  // End of namespace l1t


#endif /* define DataFormats_L1TMuon_EMTFHit_h */