L1MuBMTrack.h

Go to the documentation of this file.

//-------------------------------------------------
//
//
//--------------------------------------------------
#ifndef L1MUBM_TRACK_H
#define L1MUBM_TRACK_H

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

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

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

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

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

#include <FWCore/Framework/interface/ESHandle.h>
#include <FWCore/Framework/interface/EventSetup.h>
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMTrackAssParam.h"
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMTrackAssParam.h"
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMAddressArray.h"
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMTrackSegPhi.h"
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMTrackSegEta.h"
#include "L1Trigger/L1TMuonBarrel/src/L1MuBMSecProcId.h"

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

//using namespace L1TMuon;

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

class L1MuBMTrack : public l1t::RegionalMuonCand {

  public:

    L1MuBMTrack();

    L1MuBMTrack(const L1MuBMSecProcId&);

    L1MuBMTrack(const L1MuBMTrack&);

    virtual ~L1MuBMTrack();

    void reset();

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

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

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

    inline int eta() const { return hwEta(); }

    inline bool fineEtaBit() const { return hwHF();}

    inline int charge() const { return hwSign(); }

    inline unsigned int quality() const { return hwQual(); }

    inline TrackClass tc() const { return m_tc; }

    inline bool empty() const { return m_empty; }

    inline const L1MuBMSecProcId& spid() const { return m_spid; }

    inline L1MuBMAddressArray address() const { return m_addArray; }

    inline int address(int stat) const { return m_addArray.station(stat); }

    inline int bx() const { return m_bx; }

    inline int numberOfTSphi() const { return m_tsphiList.size(); }

    inline int numberOfTSeta() const { return m_tsetaList.size(); }

    const std::vector<L1MuBMTrackSegPhi>& getTSphi() const { return m_tsphiList; }

    const L1MuBMTrackSegPhi& getStartTSphi() const;

    const L1MuBMTrackSegPhi& getEndTSphi() const;

    const std::vector<L1MuBMTrackSegEta>& getTSeta() const { return m_tsetaList; }

    const L1MuBMTrackSegEta& getStartTSeta() const;

    const L1MuBMTrackSegEta& getEndTSeta() const;

    inline void enable() { m_empty = false; setTFIdentifiers(this->spid().sector(),l1t::tftype::bmtf); };

    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) { setHwPhi(phi); }

    void setEta(int eta);

    inline void setFineEtaBit() { setHwHF(1); }

    inline void setPt(int pt) { setHwPt(pt); }

    inline void setCharge(int charge) { setHwSign(charge);}

    inline void setBx(int bx) { m_bx = bx; }

    inline void setQuality(unsigned int quality) { setHwQual(quality); }

    inline void setAddresses(const L1MuBMAddressArray& addr) { m_addArray = addr; }

    void setTSphi(const std::vector<const L1MuBMTrackSegPhi*>& tsList);

    void setTSeta(const std::vector<const L1MuBMTrackSegEta*>& tsList);

    unsigned int triggerScale(float value, const edm::EventSetup& c) const;

    L1MuBMTrack& operator=(const L1MuBMTrack&);

    bool operator==(const L1MuBMTrack&) const;

    bool operator!=(const L1MuBMTrack&) const;

    void print() const;

    friend std::ostream& operator<<(std::ostream&, const L1MuBMTrack&);

    class Rank : std::binary_function< const L1MuBMTrack*, const L1MuBMTrack*, bool> {
      public :
        bool operator()( const L1MuBMTrack* first, const L1MuBMTrack* second ) const {
         unsigned short int rank_f = 0;  // rank of first
         unsigned short int rank_s = 0;  // rank of second
         if ( first )  rank_f = first->pt()  + 512 * first->quality();
         if ( second ) rank_s = second->pt() + 512 * second->quality();
         return rank_f > rank_s;
       }
    };


  private:

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

    L1MuBMAddressArray         m_addArray;
    std::vector<L1MuBMTrackSegPhi>  m_tsphiList;
    std::vector<L1MuBMTrackSegEta>  m_tsetaList;

};

#endif