L1MuDTTrack.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//--------------------------------------------------
#ifndef L1MUDT_TRACK_H
#define L1MUDT_TRACK_H

//---------------
// C++ Headers --
//---------------

#include <iosfwd>
#include <string>
#include <vector>

//----------------------
// Base Class Headers --
//----------------------

#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuRegionalCand.h"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

#include <FWCore/Framework/interface/ESHandle.h>
#include <FWCore/Framework/interface/EventSetup.h>
#include "L1Trigger/DTTrackFinder/src/L1MuDTTrackAssParam.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTAddressArray.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTTrackSegPhi.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTTrackSegEta.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTSecProcId.h"


//              ---------------------
//              -- Class Interface --
//              ---------------------

class L1MuDTTrack : public L1MuRegionalCand {

  public:

    L1MuDTTrack();

    L1MuDTTrack(const L1MuDTSecProcId&);
   
    L1MuDTTrack(const L1MuDTTrack&);

    ~L1MuDTTrack() override;

    void reset() override;

    inline std::string name() const { return m_name; }

    inline unsigned int pt() const { return pt_packed(); }

    inline unsigned int phi() const { return phi_packed(); }

    inline unsigned int eta() const { return eta_packed(); }
    
    inline bool fineEtaBit() const { return isFineHalo(); }
    
    inline int charge() const { return chargeValue(); }
    
    inline TrackClass tc() const { return m_tc; }

    inline bool empty() const override { return m_empty; }
    
    inline const L1MuDTSecProcId& spid() const { return m_spid; }
    
    inline L1MuDTAddressArray address() const { return m_addArray; }
    
    inline int address(int stat) const { return m_addArray.station(stat); }
    
    inline int numberOfTSphi() const { return m_tsphiList.size(); }
    
    inline int numberOfTSeta() const { return m_tsetaList.size(); }
    
    const std::vector<L1MuDTTrackSegPhi>& getTSphi() const { return m_tsphiList; }

    const L1MuDTTrackSegPhi& getStartTSphi() const;
    
    const L1MuDTTrackSegPhi& getEndTSphi() const;

    const std::vector<L1MuDTTrackSegEta>& getTSeta() const { return m_tsetaList; }
    
    const L1MuDTTrackSegEta& getStartTSeta() const;
    
    const L1MuDTTrackSegEta& getEndTSeta() const;

    inline void enable() { m_empty = false; setType(0); }
    
    inline void disable() { m_empty = true; }
       
    inline void setName(std::string name) { m_name = name; }
        
    inline void setTC(TrackClass tc) { m_tc = tc; }
    
    inline void setPhi(int phi) { setPhiPacked(phi); }
    
    void setEta(int eta);
    
    inline void setFineEtaBit() { setFineHalo(true); }
    
    inline void setPt(int pt) { setPtPacked(pt); }
    
    inline void setCharge(int charge) { setChargeValue(charge); setChargeValid(true); }
    
    inline void setQuality(unsigned int quality) { setQualityPacked(quality); }
    
    inline void setAddresses(const L1MuDTAddressArray& addr) { m_addArray = addr; }
    
    void setTSphi(const std::vector<const L1MuDTTrackSegPhi*>& tsList);

    void setTSeta(const std::vector<const L1MuDTTrackSegEta*>& tsList);
 
    unsigned int triggerScale(float value, const edm::EventSetup& c) const;

    L1MuDTTrack& operator=(const L1MuDTTrack&);

    bool operator==(const L1MuDTTrack&) const;
    
    bool operator!=(const L1MuDTTrack&) const;

    void print() const override;
  
    friend std::ostream& operator<<(std::ostream&, const L1MuDTTrack&);

    static bool rank( const L1MuDTTrack* first, const L1MuDTTrack* second ) {
      unsigned short int rank_f = 0;  // rank of first
      unsigned short int rank_s = 0;  // rank of second
      if ( first )  rank_f = 10 * first->pt()  + first->quality(); 
      if ( second ) rank_s = 10 * second->pt() + second->quality(); 
      return rank_f > rank_s;
    }

  private:

    L1MuDTSecProcId  m_spid;      // which SP found the track 
    std::string      m_name;
    bool             m_empty;      
    TrackClass       m_tc;

    L1MuDTAddressArray         m_addArray;
    std::vector<L1MuDTTrackSegPhi>  m_tsphiList;
    std::vector<L1MuDTTrackSegEta>  m_tsetaList;

};
  
#endif