MuonTriggerPrimitive.h

Go to the documentation of this file.

#ifndef __L1TMuon_TriggerPrimitive_h__
#define __L1TMuon_TriggerPrimitive_h__
//
// Class: L1TMuon::TriggerPrimitive
//
// Info: This class implements a unifying layer between DT, CSC and RPC
//       trigger primitives (TPs) such that TPs from different subsystems
//       can be queried for their position and orientation information
//       in a consistent way amongst all subsystems.
//
// Note: Not all input data types are persistable, so we make local
//       copies of all data from various digi types.
//
//       At the end of the day this should represent the output of some
//       common sector receiver module.
//
// Author: L. Gray (FNAL)
//

#include <cstdint>
#include <vector>
#include <iostream>

//DetId
#include "DataFormats/DetId/interface/DetId.h"
//Global point (created on the fly)
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"

// DT digi types
class DTChamberId;
class L1MuDTChambPhDigi;
class L1MuDTChambThDigi;

// CSC digi types
class CSCCorrelatedLCTDigi;
class CSCDetId;

// RPC digi types
class RPCDigi;
class RPCDetId;

// CPPF digi types
namespace l1t {
  class CPPFDigi;
}

// GEM digi types
class GEMPadDigi;
class GEMDetId;

// ME0 digi types
class ME0PadDigi;
class ME0DetId;

namespace L1TMuon {

  class TriggerPrimitive {
  public:
    // define the subsystems that we have available
    enum subsystem_type { kDT, kCSC, kRPC, kGEM, kNSubsystems };

    // define the data we save locally from each subsystem type
    // variables in these structs keep their colloquial meaning
    // within a subsystem
    // for RPCs you have to unroll the digi-link and raw det-id
    struct RPCData {
      RPCData()
          : strip(0),
            strip_low(0),
            strip_hi(0),
            phi_int(0),
            theta_int(0),
            emtf_sector(0),
            layer(0),
            bx(0),
            valid(0),
            time(0.),
            isCPPF(false) {}
      uint16_t strip;
      uint16_t strip_low;    // for use in clustering
      uint16_t strip_hi;     // for use in clustering
      uint16_t phi_int;      // for CPPFDigis in EMTF
      uint16_t theta_int;    // for CPPFDigis in EMTF
      uint16_t emtf_sector;  // for CPPFDigis in EMTF
      uint16_t layer;
      int16_t bx;
      uint16_t valid;
      double time;  // why double?
      bool isCPPF;
    };

    struct CSCData {
      CSCData()
          : trknmb(0),
            valid(0),
            quality(0),
            keywire(0),
            strip(0),
            pattern(0),
            bend(0),
            bx(0),
            mpclink(0),
            bx0(0),
            syncErr(0),
            cscID(0),
            alct_quality(0),
            clct_quality(0) {}
      uint16_t trknmb;
      uint16_t valid;
      uint16_t quality;
      uint16_t keywire;
      uint16_t strip;
      uint16_t pattern;
      uint16_t bend;
      uint16_t bx;
      uint16_t mpclink;
      uint16_t bx0;
      uint16_t syncErr;
      uint16_t cscID;

      // Extra info for ALCT (wires) and CLCT (strips)
      uint16_t alct_quality;
      uint16_t clct_quality;
    };

    struct DTData {
      DTData()
          : bx(0),
            wheel(0),
            sector(0),
            station(0),
            radialAngle(0),
            bendingAngle(0),
            qualityCode(0),
            Ts2TagCode(0),
            BxCntCode(0),
            theta_bti_group(0),
            segment_number(0),
            theta_code(0),
            theta_quality(0) {}
      // from ChambPhDigi (corresponds to a TRACO)
      // this gives us directly the phi
      int bx;            // relative? bx number
      int wheel;         // wheel number -3,-2,-1,1,2,3
      int sector;        // 1-12 in DT speak (these correspond to CSC sub-sectors)
      int station;       // 1-4 radially outwards
      int radialAngle;   // packed phi in a sector
      int bendingAngle;  // angle of segment relative to chamber
      int qualityCode;   // need to decode
      int Ts2TagCode;    // ??
      int BxCntCode;     // ????
      // from ChambThDigi (corresponds to a BTI)
      // we have to root out the eta manually
      // theta super layer == SL 1
      // station four has no theta super-layer
      // bti_idx == -1 means there was no theta trigger for this segment
      int theta_bti_group;
      int segment_number;  // position(i)
      int theta_code;
      int theta_quality;
    };

    struct GEMData {
      GEMData() : pad(0), pad_low(0), pad_hi(0), bx(0), bend(0), isME0(false) {}
      uint16_t pad;
      uint16_t pad_low;  // for use in clustering
      uint16_t pad_hi;   // for use in clustering
      int16_t bx;
      int16_t bend;
      bool isME0;
    };

    //Persistency
    TriggerPrimitive() : _subsystem(kNSubsystems) {}

    //DT
    TriggerPrimitive(const DTChamberId&, const L1MuDTChambPhDigi&, const int segment_number);
    TriggerPrimitive(const DTChamberId&, const L1MuDTChambThDigi&, const int segment_number);
    TriggerPrimitive(const DTChamberId&, const L1MuDTChambPhDigi&, const L1MuDTChambThDigi&, const int theta_bti_group);
    //CSC
    TriggerPrimitive(const CSCDetId&, const CSCCorrelatedLCTDigi&);
    //RPC
    TriggerPrimitive(const RPCDetId& detid, const RPCDigi& digi);
    TriggerPrimitive(const RPCDetId& detid,  // keep this version for backward compatibility
                     const unsigned strip,
                     const unsigned layer,
                     const int bx);
    TriggerPrimitive(const RPCDetId& detid,  // constructor from CPPFDigi
                     const l1t::CPPFDigi& digi);

    // GEM
    TriggerPrimitive(const GEMDetId& detid, const GEMPadDigi& digi);
    TriggerPrimitive(const ME0DetId& detid, const ME0PadDigi& digi);

    //copy
    TriggerPrimitive(const TriggerPrimitive&);

    TriggerPrimitive& operator=(const TriggerPrimitive& tp);
    bool operator==(const TriggerPrimitive& tp) const;

    // return the subsystem we belong to
    const subsystem_type subsystem() const { return _subsystem; }

    const double getCMSGlobalEta() const { return _eta; }
    void setCMSGlobalEta(const double eta) { _eta = eta; }
    const double getCMSGlobalPhi() const { return _phi; }
    void setCMSGlobalPhi(const double phi) { _phi = phi; }
    const double getCMSGlobalRho() const { return _rho; }
    void setCMSGlobalRho(const double rho) { _rho = rho; }

    const GlobalPoint getCMSGlobalPoint() const {
      double theta = 2. * atan(exp(-_eta));
      return GlobalPoint(GlobalPoint::Cylindrical(_rho, _phi, _rho / tan(theta)));
    };

    // this is the relative bending angle with respect to the
    // current phi position.
    // The total angle of the track is phi + bendAngle
    void setThetaBend(const double theta) { _theta = theta; }
    double getThetaBend() const { return _theta; }

    template <typename IDType>
    IDType detId() const {
      return IDType(_id);
    }

    // accessors to raw subsystem data
    void setDTData(const DTData& dt) { _dt = dt; }
    void setCSCData(const CSCData& csc) { _csc = csc; }
    void setRPCData(const RPCData& rpc) { _rpc = rpc; }
    void setGEMData(const GEMData& gem) { _gem = gem; }

    const DTData getDTData() const { return _dt; }
    const CSCData getCSCData() const { return _csc; }
    const RPCData getRPCData() const { return _rpc; }
    const GEMData getGEMData() const { return _gem; }

    DTData& accessDTData() { return _dt; }
    CSCData& accessCSCData() { return _csc; }
    RPCData& accessRPCData() { return _rpc; }
    GEMData& accessGEMData() { return _gem; }

    // consistent accessors to common information
    const int getBX() const;
    const int getStrip() const;
    const int getWire() const;
    const int getPattern() const;
    const DetId rawId() const { return _id; };

    const unsigned getGlobalSector() const { return _globalsector; }
    const unsigned getSubSector() const { return _subsector; }

    void print(std::ostream&) const;

  private:
    // Translate to 'global' position information at the level of 60
    // degree sectors. Use CSC sectors as a template
    template <typename IDType>
    void calculateGlobalSector(const IDType& chid, unsigned& globalsector, unsigned& subsector) {
      // Not sure if this is ever going to get implemented
      globalsector = 0;
      subsector = 0;
    }

    DTData _dt;
    CSCData _csc;
    RPCData _rpc;
    GEMData _gem;

    DetId _id;

    subsystem_type _subsystem;

    unsigned _globalsector;   // [1,6] in 60 degree sectors
    unsigned _subsector;      // [1,2] in 30 degree partitions of a sector
    double _eta, _phi, _rho;  // global pseudorapidity, phi, rho
    double _theta;            // bend angle with respect to ray from (0,0,0)
  };

}  // namespace L1TMuon

#endif