L1TMuonOverlapParams.h

Go to the documentation of this file.

#ifndef L1TMTFOverlapParams_h
#define L1TMTFOverlapParams_h
 
#include <memory>
#include <iostream>
#include <vector>
#include <cmath>
 
#include "CondFormats/Serialization/interface/Serializable.h"
#include "CondFormats/L1TObjects/interface/LUT.h"
 
class L1TMuonOverlapParams {
public:
  class Node {
  public:
    std::string type_;
    unsigned version_;
    l1t::LUT LUT_;
    std::vector<double> dparams_;
    std::vector<unsigned> uparams_;
    std::vector<int> iparams_;
    std::vector<std::string> sparams_;
    Node() {
      type_ = "unspecified";
      version_ = 0;
    }
    COND_SERIALIZABLE;
  };
 
  class LayerMapNode {
  public:
    unsigned int hwNumber;
 
    unsigned int logicNumber;
 
    bool bendingLayer;
 
    unsigned int connectedToLayer;
 
    LayerMapNode(void) : hwNumber(0), logicNumber(0), bendingLayer(false), connectedToLayer(0) {}
 
    COND_SERIALIZABLE;
  };
 
  class RefLayerMapNode {
  public:
    unsigned int refLayer;
 
    unsigned int logicNumber;
 
    RefLayerMapNode(void) : refLayer(0), logicNumber(0) {}
 
    COND_SERIALIZABLE;
  };
 
  class RefHitNode {
  public:
    unsigned int iInput;
    int iPhiMin, iPhiMax;
    unsigned int iRefHit;
    unsigned int iRefLayer;
    unsigned int iRegion;
 
    RefHitNode(void) : iInput(0), iPhiMin(0), iPhiMax(0), iRefHit(0), iRefLayer(0), iRegion(0) {}
 
    COND_SERIALIZABLE;
  };
 
  class LayerInputNode {
  public:
    unsigned int iFirstInput;
    unsigned int iLayer;
    unsigned int nInputs;
 
    LayerInputNode(void) : iFirstInput(0), iLayer(0), nInputs(0) {}
 
    COND_SERIALIZABLE;
  };
 
  enum { Version = 1 };
 
  // DO NOT ADD ENTRIES ANYWHERE BUT DIRECTLY BEFORE "NUM_OMTFPARAMNODES"
  enum {
    CHARGE = 0,
    ETA = 1,
    PT = 2,
    PDF = 3,
    MEANDISTPHI = 4,
    GENERAL = 5,
    SECTORS_START = 6,
    SECTORS_END = 7,
    NUM_OMTFPARAMNODES = 8
  };
 
  // General configuration parameters indexes
  enum {
    GENERAL_ADDRBITS = 0,
    GENERAL_VALBITS = 1,
    GENERAL_HITSPERLAYER = 2,
    GENERAL_PHIBITS = 3,
    GENERAL_PHIBINS = 4,
    GENERAL_NREFHITS = 5,
    GENERAL_NTESTREFHITS = 6,
    GENERAL_NPROCESSORS = 7,
    GENERAL_NLOGIC_REGIONS = 8,
    GENERAL_NINPUTS = 9,
    GENERAL_NLAYERS = 10,
    GENERAL_NREFLAYERS = 11,
    GENERAL_NGOLDENPATTERNS = 12,
    GENERAL_NCONFIG = 13
  };
 
  L1TMuonOverlapParams() {
    fwVersion_ = Version;
    pnodes_.resize(NUM_OMTFPARAMNODES);
  }
  ~L1TMuonOverlapParams() {}
 
  // Firmware version
  unsigned fwVersion() const { return fwVersion_; }
  void setFwVersion(unsigned fwVersion) { fwVersion_ = fwVersion; }
 
  const std::vector<int> *generalParams() const { return &pnodes_[GENERAL].iparams_; }
  void setGeneralParams(const std::vector<int> &paramsVec) {
    pnodes_[GENERAL].type_ = "INT";
    pnodes_[GENERAL].iparams_ = paramsVec;
  }
 
  int nPdfAddrBits() const { return pnodes_[GENERAL].iparams_[GENERAL_ADDRBITS]; };
 
  int nPdfValBits() const { return pnodes_[GENERAL].iparams_[GENERAL_VALBITS]; };
 
  int nHitsPerLayer() const { return pnodes_[GENERAL].iparams_[GENERAL_HITSPERLAYER]; };
 
  int nPhiBits() const { return pnodes_[GENERAL].iparams_[GENERAL_PHIBITS]; };
 
  int nPhiBins() const { return pnodes_[GENERAL].iparams_[GENERAL_PHIBINS]; };
 
  int nRefHits() const { return pnodes_[GENERAL].iparams_[GENERAL_NREFHITS]; };
 
  int nTestRefHits() const { return pnodes_[GENERAL].iparams_[GENERAL_NTESTREFHITS]; };
 
  int nProcessors() const { return pnodes_[GENERAL].iparams_[GENERAL_NPROCESSORS]; };
 
  int nLogicRegions() const { return pnodes_[GENERAL].iparams_[GENERAL_NLOGIC_REGIONS]; };
 
  int nInputs() const { return pnodes_[GENERAL].iparams_[GENERAL_NINPUTS]; };
 
  int nLayers() const { return pnodes_[GENERAL].iparams_[GENERAL_NLAYERS]; };
 
  int nRefLayers() const { return pnodes_[GENERAL].iparams_[GENERAL_NREFLAYERS]; };
 
  int nGoldenPatterns() const { return pnodes_[GENERAL].iparams_[GENERAL_NGOLDENPATTERNS]; };
 
  void setLayerMap(const std::vector<LayerMapNode> &aVector) { layerMap_ = aVector; }
 
  void setRefLayerMap(const std::vector<RefLayerMapNode> &aVector) { refLayerMap_ = aVector; }
 
  void setRefHitMap(const std::vector<RefHitNode> &aVector) { refHitMap_ = aVector; };
 
  void setGlobalPhiStartMap(const std::vector<int> &aVector) { globalPhiStart_ = aVector; };
 
  void setLayerInputMap(const std::vector<LayerInputNode> &aVector) { layerInputMap_ = aVector; };
 
  void setConnectedSectorsStart(const std::vector<int> &aVector) {
    pnodes_[SECTORS_START].type_ = "INT";
    pnodes_[SECTORS_START].iparams_ = aVector;
  };
 
  void setConnectedSectorsEnd(const std::vector<int> &aVector) {
    pnodes_[SECTORS_END].type_ = "INT";
    pnodes_[SECTORS_END].iparams_ = aVector;
  };
 
  const std::vector<LayerMapNode> *layerMap() const { return &layerMap_; };
 
  const std::vector<RefLayerMapNode> *refLayerMap() const { return &refLayerMap_; };
 
  const std::vector<RefHitNode> *refHitMap() const { return &refHitMap_; };
 
  const std::vector<int> *globalPhiStartMap() const { return &globalPhiStart_; };
 
  const std::vector<LayerInputNode> *layerInputMap() const { return &layerInputMap_; };
 
  const std::vector<int> *connectedSectorsStart() const { return &pnodes_[SECTORS_START].iparams_; };
 
  const std::vector<int> *connectedSectorsEnd() const { return &pnodes_[SECTORS_END].iparams_; };
 
  const l1t::LUT *chargeLUT() const { return &pnodes_[CHARGE].LUT_; }
  const l1t::LUT *etaLUT() const { return &pnodes_[ETA].LUT_; }
  const l1t::LUT *ptLUT() const { return &pnodes_[PT].LUT_; }
  const l1t::LUT *pdfLUT() const { return &pnodes_[PDF].LUT_; }
  const l1t::LUT *meanDistPhiLUT() const { return &pnodes_[MEANDISTPHI].LUT_; }
 
  void setChargeLUT(const l1t::LUT &lut) {
    pnodes_[CHARGE].type_ = "LUT";
    pnodes_[CHARGE].LUT_ = lut;
  }
  void setEtaLUT(const l1t::LUT &lut) {
    pnodes_[ETA].type_ = "LUT";
    pnodes_[ETA].LUT_ = lut;
  }
  void setPtLUT(const l1t::LUT &lut) {
    pnodes_[PT].type_ = "LUT";
    pnodes_[PT].LUT_ = lut;
  }
  void setPdfLUT(const l1t::LUT &lut) {
    pnodes_[PDF].type_ = "LUT";
    pnodes_[PDF].LUT_ = lut;
  }
  void setMeanDistPhiLUT(const l1t::LUT &lut) {
    pnodes_[MEANDISTPHI].type_ = "LUT";
    pnodes_[MEANDISTPHI].LUT_ = lut;
  }
 
private:
  unsigned fwVersion_;
 
  std::vector<Node> pnodes_;
 
  std::vector<LayerMapNode> layerMap_;
 
  std::vector<RefLayerMapNode> refLayerMap_;
 
  std::vector<RefHitNode> refHitMap_;
 
  std::vector<int> globalPhiStart_;
 
  std::vector<LayerInputNode> layerInputMap_;
 
  COND_SERIALIZABLE;
};
#endif