CSCUpgradeMotherboard.h

Go to the documentation of this file.

#ifndef L1Trigger_CSCTriggerPrimitives_CSCUpgradeMotherboard_h
#define L1Trigger_CSCTriggerPrimitives_CSCUpgradeMotherboard_h

#include "L1Trigger/CSCTriggerPrimitives/interface/CSCMotherboard.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCUpgradeAnodeLCTProcessor.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/CSCUpgradeCathodeLCTProcessor.h"
#include "L1Trigger/CSCTriggerPrimitives/interface/LCTContainer.h"

// generic container type
namespace {

  // first: raw detid, second: digi
  template <class T>
  using match = std::pair<unsigned int, T>;

  // vector of template above
  template <class T>
  using matches = std::vector<std::pair<unsigned int, T> >;

  // first: BX number, second: vector of template above
  template <class T>
  using matchesBX = std::map<int, std::vector<std::pair<unsigned int, T> > >;

}  // namespace

class CSCUpgradeMotherboard : public CSCMotherboard {
public:
  // standard constructor
  CSCUpgradeMotherboard(unsigned endcap,
                        unsigned station,
                        unsigned sector,
                        unsigned subsector,
                        unsigned chamber,
                        const edm::ParameterSet& conf);

  //Default constructor for testing
  CSCUpgradeMotherboard();

  ~CSCUpgradeMotherboard() override;

  // Empty the LCT container
  void clear();

  // Compare two matches of type <ID,DIGI>
  // The template is match<GEMPadDigi> or match<GEMCoPadDigi>
  template <class S>
  bool compare(const S& p, const S& q) const;

  // Get the common matches of type <ID,DIGI>. Could be more than 1
  // The template is matches<GEMPadDigi> or matches<GEMCoPadDigi>
  template <class S>
  void intersection(const S& d1, const S& d2, S& result) const;

  static bool sortLCTsByQuality(const CSCCorrelatedLCTDigi&, const CSCCorrelatedLCTDigi&);
  static bool sortLCTsByGEMDphi(const CSCCorrelatedLCTDigi&, const CSCCorrelatedLCTDigi&);
  // generic sorting function
  // provide an LCT collection and a sorting function
  void sortLCTs(std::vector<CSCCorrelatedLCTDigi>& lcts,
                bool (*sorter)(const CSCCorrelatedLCTDigi&, const CSCCorrelatedLCTDigi&)) const;

  enum CSCPart getCSCPart(int keystrip) const;

  // functions to setup geometry and LUTs
  void setupGeometry();
  void debugLUTs();

  // run TMB with GEM pad clusters as input
  void run(const CSCWireDigiCollection* wiredc, const CSCComparatorDigiCollection* compdc) override;

  /* readout the two best LCTs in this CSC */
  std::vector<CSCCorrelatedLCTDigi> readoutLCTs() const override;

protected:
  void correlateLCTs(const CSCALCTDigi& bestALCT,
                     const CSCALCTDigi& secondALCT,
                     const CSCCLCTDigi& bestCLCT,
                     const CSCCLCTDigi& secondCLCT,
                     CSCCorrelatedLCTDigi& lct1,
                     CSCCorrelatedLCTDigi& lct2) const;

  Parity theParity;

  void setPrefIndex();

  LCTContainer allLCTs;

  std::unique_ptr<CSCUpgradeMotherboardLUTGenerator> generator_;

  int pref[CSCConstants::MAX_LCT_TBINS];

  bool match_earliest_alct_only;
  bool match_earliest_clct_only;

  /* type of algorithm to sort the stubs */
  unsigned int tmb_cross_bx_algo;

  unsigned int max_lcts;

  // debug gem matching
  bool debug_matching;

  // check look-up-tables
  bool debug_luts;
};

template <class S>
bool CSCUpgradeMotherboard::compare(const S& p, const S& q) const {
  return (p.first == q.first) and (p.second == q.second);
}

template <class S>
void CSCUpgradeMotherboard::intersection(const S& d1, const S& d2, S& result) const {
  for (const auto& p : d1) {
    for (const auto& q : d2) {
      if (compare(p, q)) {
        result.push_back(p);
      }
    }
  }
}

#endif