CSCSectorReceiverLUT Class Reference

#include <CSCSectorReceiverLUT.h>

Public Member Functions
	CSCSectorReceiverLUT (const CSCSectorReceiverLUT &)
	CSCSectorReceiverLUT (int endcap, int sector, int subsector, int station, const edm::ParameterSet &pset, bool TMB07)
std::string	encodeFileIndex () const
	Helpers. More...
gbletadat	globalEtaME (gbletaadd address, const bool gangedME1a=false) const
gbletadat	globalEtaME (int phi_bend, int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const
gbletadat	globalEtaME (unsigned address, const bool gangedME1a=false) const
gblphidat	globalPhiMB (gblphiadd address, const bool gangedME1a=false) const
gblphidat	globalPhiMB (int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const
gblphidat	globalPhiMB (unsigned address, const bool gangedME1a=false) const
gblphidat	globalPhiME (gblphiadd address, const bool gangedME1a=false) const
gblphidat	globalPhiME (int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const
gblphidat	globalPhiME (unsigned address, const bool gangedME1a=false) const
lclphidat	localPhi (int strip, int pattern, int quality, int lr, const bool gangedME1a=false) const
	Geometry Lookup Tables. More...
lclphidat	localPhi (lclphiadd address, const bool gangedME1a=false) const
lclphidat	localPhi (unsigned address, const bool gangedME1a=false) const
CSCSectorReceiverLUT &	operator= (const CSCSectorReceiverLUT &)
void	setCSCGeometry (const CSCGeometry *g)
	~CSCSectorReceiverLUT ()

Private Member Functions
gbletadat	calcGlobalEtaME (const gbletaadd &address) const
	Global Eta LUT. More...
gblphidat	calcGlobalPhiMB (const gblphidat &me_gphi_data) const
gblphidat	calcGlobalPhiME (const gblphiadd &address) const
	Global Phi LUT. More...
lclphidat	calcLocalPhi (const lclphiadd &address) const
	Local Phi LUT. More...
void	fillLocalPhiLUT ()
double	getGlobalEtaValue (const unsigned &cscid, const unsigned &wire_group, const unsigned &phi_local) const
double	getGlobalPhiValue (const CSCLayer *thelayer, const unsigned &strip, const unsigned &wire_group) const
void	readLUTsFromFile ()

Private Attributes
int	_endcap
int	_sector
int	_station
int	_subsector
const CSCGeometry *	csc_g
bool	isBinary
bool	isTMB07
bool	LUTsFromFile
edm::FileInPath	mb_gbl_phi_file
gblphidat *	mb_global_phi
edm::FileInPath	me_gbl_eta_file
edm::FileInPath	me_gbl_phi_file
gbletadat *	me_global_eta
gblphidat *	me_global_phi
edm::FileInPath	me_lcl_phi_file
bool	useMiniLUTs

Static Private Attributes
static lclphidat *	me_lcl_phi = nullptr
static bool	me_lcl_phi_loaded = false

Detailed Description

Author

Lindsey Gray, Slava Valuev, Jason Mumford

Provides Look Up Table information for use in the SP Core. Partial port from ORCA.

Definition at line 19 of file CSCSectorReceiverLUT.h.

Constructor & Destructor Documentation

CSCSectorReceiverLUT() [1/2]

CSCSectorReceiverLUT::CSCSectorReceiverLUT	(	int	endcap,
		int	sector,
		int	subsector,
		int	station,
		const edm::ParameterSet &	pset,
		bool	TMB07
	)

Definition at line 23 of file CSCSectorReceiverLUT.cc.

    : _endcap(endcap), _sector(sector), _subsector(subsector), _station(station), isTMB07(TMB07) {
  LUTsFromFile = pset.getUntrackedParameter<bool>("ReadLUTs", false);
  useMiniLUTs = pset.getUntrackedParameter<bool>("UseMiniLUTs", true);
  isBinary = pset.getUntrackedParameter<bool>("Binary", false);
 
  me_global_eta = nullptr;
  me_global_phi = nullptr;
  mb_global_phi = nullptr;
  if (LUTsFromFile && !useMiniLUTs) {
    me_lcl_phi_file = pset.getUntrackedParameter<edm::FileInPath>(
        "LocalPhiLUT",
        edm::FileInPath(std::string("L1Trigger/CSCTrackFinder/LUTs/LocalPhiLUT" +
                                    (isBinary ? std::string(".bin") : std::string(".dat")))));
    me_gbl_phi_file = pset.getUntrackedParameter<edm::FileInPath>(
        "GlobalPhiLUTME",
        edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalPhiME") + encodeFileIndex() +
                         (isBinary ? std::string(".bin") : std::string(".dat")))));
    if (station == 1)
      mb_gbl_phi_file = pset.getUntrackedParameter<edm::FileInPath>(
          "GlobalPhiLUTMB",
          edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalPhiMB") + encodeFileIndex() +
                           (isBinary ? std::string(".bin") : std::string(".dat")))));
    me_gbl_eta_file = pset.getUntrackedParameter<edm::FileInPath>(
        "GlobalEtaLUTME",
        edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalEtaME") + encodeFileIndex() +
                         (isBinary ? std::string(".bin") : std::string(".dat")))));
    readLUTsFromFile();
  }
}

References encodeFileIndex(), isBinary, LUTsFromFile, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, me_lcl_phi_file, muonDTDigis_cfi::pset, readLUTsFromFile(), relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and useMiniLUTs.

CSCSectorReceiverLUT() [2/2]

CSCSectorReceiverLUT::CSCSectorReceiverLUT

(

const CSCSectorReceiverLUT &

lut

)

Definition at line 55 of file CSCSectorReceiverLUT.cc.

    : _endcap(lut._endcap),
      _sector(lut._sector),
      _subsector(lut._subsector),
      _station(lut._station),
      me_lcl_phi_file(lut.me_lcl_phi_file),
      me_gbl_phi_file(lut.me_gbl_phi_file),
      mb_gbl_phi_file(lut.mb_gbl_phi_file),
      me_gbl_eta_file(lut.me_gbl_eta_file),
      LUTsFromFile(lut.LUTsFromFile),
      isBinary(lut.isBinary) {
  if (lut.mb_global_phi) {
    mb_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
    memcpy(mb_global_phi, lut.mb_global_phi, (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(gblphidat));
  } else
    mb_global_phi = nullptr;
  if (lut.me_global_phi) {
    me_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
    memcpy(me_global_phi, lut.me_global_phi, (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(gblphidat));
  } else
    me_global_phi = nullptr;
  if (lut.me_global_eta) {
    me_global_eta = new gbletadat[1 << CSCBitWidths::kGlobalEtaAddressWidth];
    memcpy(me_global_eta, lut.me_global_eta, (1 << CSCBitWidths::kGlobalEtaAddressWidth) * sizeof(gbletadat));
  } else
    me_global_eta = nullptr;
}

References CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, mb_global_phi, me_global_eta, and me_global_phi.

~CSCSectorReceiverLUT()

CSCSectorReceiverLUT::~CSCSectorReceiverLUT

(

)

Definition at line 117 of file CSCSectorReceiverLUT.cc.

                                            {
  if (me_lcl_phi_loaded) {
    delete me_lcl_phi;
    me_lcl_phi = nullptr;
    me_lcl_phi_loaded = false;
  }
  if (me_global_eta) {
    delete me_global_eta;
    me_global_eta = nullptr;
  }
  if (me_global_phi) {
    delete me_global_phi;
    me_global_phi = nullptr;
  }
  if (mb_global_phi) {
    delete mb_global_phi;
    mb_global_phi = nullptr;
  }
}

References mb_global_phi, me_global_eta, me_global_phi, me_lcl_phi, and me_lcl_phi_loaded.

Member Function Documentation

calcGlobalEtaME()

gbletadat CSCSectorReceiverLUT::calcGlobalEtaME ( const gbletaadd &  address ) const

private

Global Eta LUT.

Definition at line 654 of file CSCSectorReceiverLUT.cc.

                                                                              {
  gbletadat result;
  double float_eta = getGlobalEtaValue(address.cscid, address.wire_group, address.phi_local);
  unsigned int_eta = 0;
  unsigned bend_global = 0;  // not filled yet... will change when it is.
  const double etaPerBin = (CSCTFConstants::maxEta - CSCTFConstants::minEta) / CSCTFConstants::etaBins;
  const unsigned me12EtaCut = 56;
 
  if ((float_eta < CSCTFConstants::minEta) || (float_eta >= CSCTFConstants::maxEta)) {
    edm::LogWarning("CSCSectorReceiverLUT:OutOfBounds")
        << "CSCSectorReceiverLUT warning: float_eta = " << float_eta << " minEta = " << CSCTFConstants::minEta
        << " maxEta = " << CSCTFConstants::maxEta << "   station " << _station << " sector " << _sector << " chamber "
        << address.cscid << " wire group " << address.wire_group;
 
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of CSC ID, " << float_eta << ", is out of bounds [" << CSCTFConstants::minEta << "-"
        << CSCTFConstants::maxEta << ") +++\n";
 
    //if (float_eta < CSCTFConstants::minEta)
    //result.global_eta = 0;
    //else if (float_eta >= CSCTFConstants::maxEta)
    //result.global_eta = CSCTFConstants::etaBins - 1;
  } else {
    float_eta -= CSCTFConstants::minEta;
    float_eta = float_eta / etaPerBin;
    int_eta = static_cast<unsigned>(float_eta);
    /* Commented until I find out its use.
      // Fine-tune eta boundary between DT and CSC.
      if ((intEta == L1MuCSCSetup::CscEtaStart() && (L1MuCSCSetup::CscEtaStartCorr() > 0.) ) ||
      (intEta == L1MuCSCSetup::CscEtaStart() - 1 && (L1MuCSCSetup::CscEtaStartCorr() < 0.) ) ) {
    bitEta = (thisEta-minEta-L1MuCSCSetup::CscEtaStartCorr())/EtaPerBin;
    intEta = static_cast<int>(bitEta);
      }
      */
    if (_station == 1 && address.cscid >= static_cast<unsigned>(CSCTriggerNumbering::minTriggerCscId()) &&
        address.cscid <= static_cast<unsigned>(CSCTriggerNumbering::maxTriggerCscId())) {
      unsigned ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, address.cscid);
 
      if (ring == 1 && int_eta < me12EtaCut) {
        int_eta = me12EtaCut;
      } else if (ring == 2 && int_eta >= me12EtaCut) {
        int_eta = me12EtaCut - 1;
      }
    }
    result.global_eta = int_eta;
  }
  result.global_bend = bend_global;
 
  return result;
}

References _sector, _station, CSCTFConstants::etaBins, Exception, getGlobalEtaValue(), CSCTFConstants::maxEta, CSCTriggerNumbering::maxTriggerCscId(), CSCTFConstants::minEta, CSCTriggerNumbering::minTriggerCscId(), mps_fire::result, relativeConstraints::ring, and CSCTriggerNumbering::ringFromTriggerLabels().

Referenced by globalEtaME().

calcGlobalPhiMB()

gblphidat CSCSectorReceiverLUT::calcGlobalPhiMB ( const gblphidat &  me_gphi_data ) const

private

Definition at line 489 of file CSCSectorReceiverLUT.cc.

                                                                             {
  gblphidat dtlut;
 
  // The following method was ripped from D. Holmes' LUT conversion program
  // modifications from Darin and GP
  int GlobalPhiMin = (_subsector == 1) ? 0x42 : 0x800;   // (0.999023 : 31 in degrees)
  int GlobalPhiMax = (_subsector == 1) ? 0x7ff : 0xfbd;  // (30.985 : 60.986 in degrees)
  double GlobalPhiShift = (1.0 * GlobalPhiMin + (GlobalPhiMax - GlobalPhiMin) / 2.0);
 
  double dt_out = static_cast<double>(csclut.global_phi) - GlobalPhiShift;
 
  // these numbers are 62 deg / 1 rad (CSC phi scale vs. DT phi scale)
  dt_out = (dt_out / 1982) * 2145;  //CSC phi 62 degrees; DT phi 57.3 degrees
 
  if (dt_out >= 0)  // msb != 1
  {
    dtlut.global_phi = 0x7ff & static_cast<unsigned>(dt_out);
  } else {
    dtlut.global_phi = static_cast<unsigned>(-dt_out);
    dtlut.global_phi = ~dtlut.global_phi;
    dtlut.global_phi |= 0x800;
  }
 
  return dtlut;
}

References _subsector.

Referenced by globalPhiMB().

calcGlobalPhiME()

gblphidat CSCSectorReceiverLUT::calcGlobalPhiME ( const gblphiadd &  address ) const

private

Global Phi LUT.

Definition at line 243 of file CSCSectorReceiverLUT.cc.

                                                                              {
  gblphidat result(0);
  const CSCChamber* thechamber = nullptr;
  const CSCLayer* thelayer = nullptr;
  const CSCLayerGeometry* layergeom = nullptr;
  int cscid = address.cscid;
  unsigned wire_group = address.wire_group;
  unsigned local_phi = address.phi_local;
  const double sectorOffset =
      (CSCTFConstants::SECTOR1_CENT_RAD - CSCTFConstants::SECTOR_RAD / 2.) + (_sector - 1) * M_PI / 3.;
 
  //Number of global phi units per radian.
  constexpr int maxPhiG = 1 << CSCBitWidths::kGlobalPhiDataBitWidth;
  double binPhiG = static_cast<double>(maxPhiG) / CSCTFConstants::SECTOR_RAD;
 
  // We will use these to convert the local phi into radians.
  constexpr unsigned int maxPhiL = 1 << CSCBitWidths::kLocalPhiDataBitWidth;
  const double binPhiL = static_cast<double>(maxPhiL) / (2. * CSCConstants::MAX_NUM_STRIPS);
 
  if (cscid < CSCTriggerNumbering::minTriggerCscId()) {
    edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
        << " warning: cscId " << cscid << " is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
        << CSCTriggerNumbering::maxTriggerCscId() << "]\n";
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of CSC ID, " << cscid << ", is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
        << CSCTriggerNumbering::maxTriggerCscId() << "] +++\n";
  }
 
  if (cscid > CSCTriggerNumbering::maxTriggerCscId()) {
    edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
        << " warning: cscId " << cscid << " is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
        << CSCTriggerNumbering::maxTriggerCscId() << "]\n";
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of CSC ID, " << cscid << ", is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
        << CSCTriggerNumbering::maxTriggerCscId() << "] +++\n";
  }
 
  if (wire_group >= 1 << 5) {
    edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
        << "warning: wire_group" << wire_group << " is out of bounds (1-" << ((1 << 5) - 1) << "]\n";
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of wire_group, " << wire_group << ", is out of bounds (1-" << ((1 << 5) - 1) << "] +++\n";
  }
 
  if (local_phi >= maxPhiL) {
    edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
        << "warning: local_phi" << local_phi << " is out of bounds [0-" << maxPhiL << ")\n";
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of local_phi, " << local_phi << ", is out of bounds [0-, " << maxPhiL << ") +++\n";
  }
 
  try {
    int ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid);
    int chid = CSCTriggerNumbering::chamberFromTriggerLabels(_sector, _subsector, _station, cscid);
    CSCDetId detid(_endcap, _station, ring, chid, 0);
    thechamber = const_cast<const CSCChamber*>(csc_g->chamber(detid));
    if (thechamber) {
      layergeom = thechamber->layer(CSCConstants::KEY_CLCT_LAYER)->geometry();
      thelayer = thechamber->layer(CSCConstants::KEY_CLCT_LAYER);
      const int nStrips = layergeom->numberOfStrips();
      // PhiL is the strip number converted into some units between 0 and
      // 1023.  When we did the conversion in fillLocalPhiTable(), we did
      // not know for which chamber we do it (and, therefore, how many strips
      // it has), and always used the maximum possible number of strips
      // per chamber, MAX_NUM_STRIPS=80.  Now, since we know the chamber id
      // and how many strips the chamber has, we can re-adjust the scale.
      //const double scale = static_cast<double>(CSCConstants::MAX_NUM_STRIPS)/nStrips;
 
      int strip = 0, halfstrip = 0;
 
      halfstrip = static_cast<int>(local_phi / binPhiL);
      strip = halfstrip / 2;
 
      // Find the phi width of the chamber and the position of its "left"
      // (lower phi) edge (both in radians).
      // Phi positions of the centers of the first and of the last strips
      // in the chamber.
      const double phi_f = getGlobalPhiValue(thelayer, 1, wire_group);
      const double phi_l = getGlobalPhiValue(thelayer, nStrips, wire_group);
      // Phi widths of the half-strips at both ends of the chamber;
      // surprisingly, they are not the same.
      const double hsWidth_f = fabs(getGlobalPhiValue(thelayer, 2, wire_group) - phi_f) / 2.;
      const double hsWidth_l = fabs(phi_l - getGlobalPhiValue(thelayer, nStrips - 1, wire_group)) / 2.;
 
      // The "natural" match between the strips and phi values -- when
      // a larger strip number corresponds to a larger phi value, i.e. strips
      // are counted clockwise if we look at them from the inside of the
      // detector -- is reversed for some stations.  At the moment, these
      // are stations 3 and 4 of the 1st endcap, and stations 1 and 2 of
      // the 2nd endcap.  Instead of using
      // if ((theEndcap == 1 && theStation <= 2) ||
      // (theEndcap == 2 && theStation >= 3)),
      // we get the order from the phi values of the first and the last strip
      // in a chamber, just in case the counting scheme changes in the future.
      // Once we know how the strips are counted, we can go from the middle
      // of the strips to their outer edges.
      bool clockwiseOrder;
      double leftEdge, rightEdge;
      if (fabs(phi_f - phi_l) < M_PI) {
        if (phi_f < phi_l)
          clockwiseOrder = true;
        else
          clockwiseOrder = false;
      } else {  // the chamber crosses the phi = pi boundary
        if (phi_f < phi_l)
          clockwiseOrder = false;
        else
          clockwiseOrder = true;
      }
      if (clockwiseOrder) {
        leftEdge = phi_f - hsWidth_f;
        rightEdge = phi_l + hsWidth_l;
      } else {
        leftEdge = phi_l - hsWidth_l;
        rightEdge = phi_f + hsWidth_f;
      }
      if (fabs(phi_f - phi_l) >= M_PI) {
        rightEdge += 2. * M_PI;
      }
      //double chamberWidth = (rightEdge - leftEdge);
 
      // Chamber offset, relative to the edge of the sector.
      //double chamberOffset = leftEdge - sectorOffset;
      //if (chamberOffset < -M_PI) chamberOffset += 2*M_PI;
 
      double temp_phi = 0.0, strip_phi = 0.0, delta_phi = 0.0;
      double distFromHalfStripCenter = 0.0, halfstripWidth = 0.0;
 
      if (strip < nStrips) {
        // Approximate distance from the center of the half-strip to the center
        // of this phil bin, in units of half-strip width.
        distFromHalfStripCenter = (local_phi + 0.5) / binPhiL - halfstrip - 0.5;
        // Half-strip width (in rad), calculated as the half-distance between
        // the adjacent strips.  Since in the current ORCA implementation
        // the half-strip width changes from strip to strip, base the choice
        // of the adjacent strip on the half-strip number.
        if ((halfstrip % 2 == 0 && halfstrip != 0) || halfstrip == 2 * nStrips - 1) {
          halfstripWidth = fabs(getGlobalPhiValue(thelayer, strip + 1, wire_group) -
                                getGlobalPhiValue(thelayer, strip, wire_group)) /
                           2.;
        } else {
          halfstripWidth = fabs(getGlobalPhiValue(thelayer, strip + 1, wire_group) -
                                getGlobalPhiValue(thelayer, strip + 2, wire_group)) /
                           2.;
        }
        // Correction for the strips crossing the 180 degree boundary.
        if (halfstripWidth > M_PI / 2.)
          halfstripWidth = M_PI - halfstripWidth;
        // Phi at the center of the strip.
        strip_phi = getGlobalPhiValue(thelayer, strip + 1, wire_group);
        // Distance between the center of the strip and the phil position.
        delta_phi = halfstripWidth * (((halfstrip % 2) - 0.5) + distFromHalfStripCenter);
        if (clockwiseOrder)
          temp_phi = strip_phi + delta_phi;
        else
          temp_phi = strip_phi - delta_phi;
      } else {
        // PhiL values that do not have corresponding strips (the chamber
        // has less than 80 strips assumed in fillLocalPhi).  It does not
        // really matter what we do with these values; at the moment, just
        // set them to the phis of the edges of the chamber.
        if (clockwiseOrder)
          temp_phi = rightEdge;
        else
          temp_phi = leftEdge;
      }
 
      // Finally, subtract the sector offset and convert to the scale of
      // the global phi.
 
      temp_phi -= sectorOffset;
 
      if (temp_phi < 0.)
        temp_phi += 2. * M_PI;
 
      temp_phi *= binPhiG;
 
      if (temp_phi < 0.) {
        result.global_phi = 0;
      } else if (temp_phi >= maxPhiG) {
        result.global_phi = maxPhiG - 1;
      } else {
        result.global_phi = static_cast<unsigned short>(temp_phi);
      }
 
      LogDebug("CSCSectorReceiverLUT") << "local_phi = " << local_phi << " halfstrip = " << halfstrip
                                       << " strip = " << strip
                                       << " distFromHalfStripCenter = " << distFromHalfStripCenter
                                       << " halfstripWidth = " << halfstripWidth
                                       << " strip phi = " << strip_phi / (M_PI / 180.)
                                       << " temp_phi = " << temp_phi * CSCTFConstants::SECTOR_DEG / maxPhiG
                                       << " global_phi = " << result.global_phi << " "
                                       << result.global_phi * CSCTFConstants::SECTOR_DEG / maxPhiG;
    }
  } catch (edm::Exception& e) {
    edm::LogError("CSCSectorReceiverLUT|getGlobalPhiValue") << e.what();
  }
 
  return result;
}

References _endcap, _sector, _station, _subsector, CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, HLT_FULL_cff::delta_phi, MillePedeFileConverter_cfg::e, Exception, CSCLayer::geometry(), getGlobalPhiValue(), CSCConstants::KEY_CLCT_LAYER, CSCBitWidths::kGlobalPhiDataBitWidth, CSCBitWidths::kLocalPhiDataBitWidth, CSCChamber::layer(), LogDebug, M_PI, CSCConstants::MAX_NUM_STRIPS, CSCTriggerNumbering::maxTriggerCscId(), CSCTriggerNumbering::minTriggerCscId(), me0TriggerPseudoDigis_cff::nStrips, CSCLayerGeometry::numberOfStrips(), mps_fire::result, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), CSCTFConstants::SECTOR1_CENT_RAD, CSCTFConstants::SECTOR_DEG, CSCTFConstants::SECTOR_RAD, and digitizers_cfi::strip.

Referenced by globalPhiME().

calcLocalPhi()

lclphidat CSCSectorReceiverLUT::calcLocalPhi ( const lclphiadd &  address ) const

private

Local Phi LUT.

Local Phi Bend is always zero. Until we start using it.

Definition at line 137 of file CSCSectorReceiverLUT.cc.

                                                                          {
  lclphidat data;
 
  constexpr int maxPhiL = 1 << CSCBitWidths::kLocalPhiDataBitWidth;
  double binPhiL = static_cast<double>(maxPhiL) / (2. * CSCConstants::MAX_NUM_STRIPS);
 
  double patternOffset;
 
  patternOffset = CSCPatternBank::getLegacyPosition((theadd.pattern_type << 3) + theadd.clct_pattern);
 
  // The phiL value stored is for the center of the half-/di-strip.
  if (theadd.strip < 2 * CSCConstants::MAX_NUM_STRIPS)
    if (theadd.pattern_type == 1 || isTMB07)  // if halfstrip (Note: no distrips in TMB 2007 patterns)
      data.phi_local = static_cast<unsigned>((0.5 + theadd.strip + patternOffset) * binPhiL);
    else  // if distrip
      data.phi_local = static_cast<unsigned>((2 + theadd.strip + 4. * patternOffset) * binPhiL);
  else {
    throw cms::Exception("CSCSectorReceiverLUT") << "+++ Value of strip, " << theadd.strip << ", exceeds max allowed, "
                                                 << 2 * CSCConstants::MAX_NUM_STRIPS - 1 << " +++\n";
  }
 
  if (data.phi_local >= maxPhiL) {
    throw cms::Exception("CSCSectorReceiverLUT")
        << "+++ Value of phi_local, " << data.phi_local << ", exceeds max allowed, " << maxPhiL - 1 << " +++\n";
  }
 
  LogDebug("CSCSectorReceiver") << "endcap = " << _endcap << " station = " << _station << " maxPhiL = " << maxPhiL
                                << " binPhiL = " << binPhiL;
  LogDebug("CSCSectorReceiver") << "strip # " << theadd.strip << " hs/ds = " << theadd.pattern_type
                                << " pattern = " << theadd.clct_pattern << " offset = " << patternOffset
                                << " phi_local = " << data.phi_local;
 
  data.phi_bend_local = 0;
 
  return data;  //return LUT result
}

References _endcap, _station, data, Exception, CSCPatternBank::getLegacyPosition(), isTMB07, CSCBitWidths::kLocalPhiDataBitWidth, LogDebug, and CSCConstants::MAX_NUM_STRIPS.

Referenced by localPhi().

encodeFileIndex()

std::string CSCSectorReceiverLUT::encodeFileIndex

(

)

const

Helpers.

Definition at line 751 of file CSCSectorReceiverLUT.cc.

                                                      {
  std::string fileName = "";
  if (_station == 1) {
    if (_subsector == 1)
      fileName += "1a";
    if (_subsector == 2)
      fileName += "1b";
  } else if (_station == 2)
    fileName += "2";
  else if (_station == 3)
    fileName += "3";
  else if (_station == 4)
    fileName += "4";
  fileName += "End";
  if (_endcap == 1)
    fileName += "1";
  else
    fileName += "2";
  fileName += "Sec";
  if (_sector == 1)
    fileName += "1";
  else if (_sector == 2)
    fileName += "2";
  else if (_sector == 3)
    fileName += "3";
  else if (_sector == 4)
    fileName += "4";
  else if (_sector == 5)
    fileName += "5";
  else if (_sector == 6)
    fileName += "6";
  fileName += "LUT";
  return fileName;
}

References _endcap, _sector, _station, _subsector, MillePedeFileConverter_cfg::fileName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CSCSectorReceiverLUT().

fillLocalPhiLUT()

void CSCSectorReceiverLUT::fillLocalPhiLUT ( )

private

Definition at line 175 of file CSCSectorReceiverLUT.cc.

                                           {
  // read data in from a file... Add this later.
}

getGlobalEtaValue()

double CSCSectorReceiverLUT::getGlobalEtaValue ( const unsigned &  cscid, const unsigned &  wire_group, const unsigned &  phi_local  ) const

private

Calculate Eta correction

Definition at line 561 of file CSCSectorReceiverLUT.cc.

                                                                                   {
  double result = 0.0;
  unsigned wire_group = thewire_group;
  int cscid = thecscid;
  unsigned phi_local = thephi_local;
 
  // Flag to be set if one wants to apply phi corrections ONLY in ME1/1.
  // Turn it into a parameter?
  bool me1ir_only = false;
 
  if (cscid < CSCTriggerNumbering::minTriggerCscId() || cscid > CSCTriggerNumbering::maxTriggerCscId()) {
    edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
        << " warning: cscId " << cscid << " is out of bounds [1-" << CSCTriggerNumbering::maxTriggerCscId() << "]\n";
    cscid = CSCTriggerNumbering::maxTriggerCscId();
  }
 
  CSCLayerGeometry* layerGeom = nullptr;
  const unsigned numBins = 1 << 2;  // 4 local phi bins
 
  if (phi_local > numBins - 1) {
    edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
        << "warning: phiL " << phi_local << " is out of bounds [0-" << numBins - 1 << "]\n";
    phi_local = numBins - 1;
  }
  try {
    int ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid);
    int chid = CSCTriggerNumbering::chamberFromTriggerLabels(_sector, _subsector, _station, cscid);
    CSCDetId detid(_endcap, _station, ring, chid, 0);
    const CSCChamber* thechamber = const_cast<const CSCChamber*>(csc_g->chamber(detid));
    if (thechamber) {
      layerGeom = const_cast<CSCLayerGeometry*>(thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->geometry());
      const unsigned nWireGroups = layerGeom->numberOfWireGroups();
 
      // Check wire group numbers; expect them to be counted from 0, as in
      // CorrelatedLCTDigi class.
      if (wire_group >= nWireGroups) {
        edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
            << "warning: wireGroup " << wire_group << " is out of bounds [0-" << nWireGroups << ")\n";
        wire_group = nWireGroups - 1;
      }
      // Convert to [1; nWireGroups] range used in geometry methods.
      wire_group += 1;
 
      // If me1ir_only is set, apply phi corrections only in ME1/1.
      if (me1ir_only && (_station != 1 || CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid) != 1)) {
        result = thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->centerOfWireGroup(wire_group).eta();
      } else {
        const unsigned nStrips = layerGeom->numberOfStrips();
        const unsigned nStripsPerBin = CSCConstants::MAX_NUM_STRIPS / numBins;
        // Check that no strips will be left out.
        if (nStrips % numBins != 0 || CSCConstants::MAX_NUM_STRIPS % numBins != 0)
          edm::LogWarning("CSCSectorReceiverLUT")
              << "getGlobalEtaValue warning: number of strips " << nStrips << " (" << CSCConstants::MAX_NUM_STRIPS
              << ") is not divisible by numBins " << numBins << " Station " << _station << " sector " << _sector
              << " subsector " << _subsector << " cscid " << cscid << "\n";
 
        unsigned maxStripPrevBin = 0, maxStripThisBin = 0;
        unsigned correctionStrip;
        LocalPoint lPoint;
        GlobalPoint gPoint;
        // Bins phi_local and find the the middle strip for each bin.
        maxStripThisBin = nStripsPerBin * (phi_local + 1);
        if (maxStripThisBin <= nStrips) {
          correctionStrip = nStripsPerBin / 2 * (2 * phi_local + 1);
        } else {
          // If the actual number of strips in the chamber is smaller than
          // the number of strips corresponding to the right edge of this phi
          // local bin, we take the middle strip between number of strips
          // at the left edge of the bin and the actual number of strips.
          maxStripPrevBin = nStripsPerBin * phi_local;
          correctionStrip = (nStrips + maxStripPrevBin) / 2;
        }
 
        lPoint = layerGeom->stripWireGroupIntersection(correctionStrip, wire_group);
        gPoint = thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->surface().toGlobal(lPoint);
 
        // end calc of eta correction.
        result = gPoint.eta();
      }
    }
  } catch (cms::Exception& e) {
    LogDebug("CSCSectorReceiver|OutofBoundInput") << e.what();
  }
 
  return std::fabs(result);
}

References _endcap, _sector, _station, _subsector, CSCLayer::centerOfWireGroup(), CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, MillePedeFileConverter_cfg::e, PV3DBase< T, PVType, FrameType >::eta(), CSCLayer::geometry(), CSCConstants::KEY_ALCT_LAYER, CSCChamber::layer(), LogDebug, CSCConstants::MAX_NUM_STRIPS, CSCTriggerNumbering::maxTriggerCscId(), CSCTriggerNumbering::minTriggerCscId(), me0TriggerPseudoDigis_cff::nStrips, CSCLayerGeometry::numberOfStrips(), CSCLayerGeometry::numberOfWireGroups(), mps_fire::result, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), CSCLayerGeometry::stripWireGroupIntersection(), GeomDet::surface(), and Surface::toGlobal().

Referenced by calcGlobalEtaME().

getGlobalPhiValue()

double CSCSectorReceiverLUT::getGlobalPhiValue ( const CSCLayer *  thelayer, const unsigned &  strip, const unsigned &  wire_group  ) const

private

Definition at line 220 of file CSCSectorReceiverLUT.cc.

                                                                                 {
  double result = 0.0;
  //CSCLayerGeometry* thegeom;
  //LocalPoint lp;
  //GlobalPoint gp;
 
  try {
    //thegeom = const_cast<CSCLayerGeometry*>(thelayer->geometry());
    //lp = thegeom->stripWireGroupIntersection(strip, wire_group);
    //gp = thelayer->surface().toGlobal(lp);
    result = thelayer->centerOfStrip(strip).phi();  //gp.phi();
 
    if (result < 0.)
      result += 2. * M_PI;
  } catch (edm::Exception& e) {
    LogDebug("CSCSectorReceiverLUT|getGlobalPhiValue") << e.what();
  }
 
  return result;
}

References CSCLayer::centerOfStrip(), MillePedeFileConverter_cfg::e, LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::phi(), mps_fire::result, and digitizers_cfi::strip.

Referenced by calcGlobalPhiME().

globalEtaME() [1/3]

gbletadat CSCSectorReceiverLUT::globalEtaME	(	gbletaadd	address,
		const bool	gangedME1a = false
	)		const

Definition at line 738 of file CSCSectorReceiverLUT.cc.

                                                                                          {
  gbletadat result;
 
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(
        _endcap, _sector, _station, _subsector, address.toint(), gangedME1a);
  else if (LUTsFromFile)
    result = me_global_eta[address.toint()];
  else
    result = calcGlobalEtaME(address);
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

globalEtaME() [2/3]

gbletadat CSCSectorReceiverLUT::globalEtaME	(	int	phi_bend,
		int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = false
	)		const

Definition at line 705 of file CSCSectorReceiverLUT.cc.

                                                                                             {
  gbletadat result;
  gbletaadd theadd;
 
  theadd.phi_bend = tphi_bend;
  theadd.phi_local = (tphi_local >> (CSCBitWidths::kLocalPhiDataBitWidth - 2)) & 0x3;  // want 2 msb of local phi
  theadd.wire_group = twire_group;
  theadd.cscid = tcscid;
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(
        _endcap, _sector, _station, _subsector, theadd.toint(), gangedME1a);
  else if (LUTsFromFile)
    result = me_global_eta[theadd.toint()];
  else
    result = calcGlobalEtaME(theadd);
 
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, CSCBitWidths::kLocalPhiDataBitWidth, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

Referenced by L1TCSCTF::analyze(), L1Analysis::L1AnalysisCSCTF::SetLCTs(), and L1Analysis::L1AnalysisCSCTF::SetTracks().

globalEtaME() [3/3]

gbletadat CSCSectorReceiverLUT::globalEtaME	(	unsigned	address,
		const bool	gangedME1a = false
	)		const

Definition at line 725 of file CSCSectorReceiverLUT.cc.

                                                                                         {
  gbletadat result;
  gbletaadd theadd(address);
 
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(_endcap, _sector, _station, _subsector, address, gangedME1a);
  else if (LUTsFromFile)
    result = me_global_eta[address];
  else
    result = calcGlobalEtaME(theadd);
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

globalPhiMB() [1/3]

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	gblphiadd	address,
		const bool	gangedME1a = false
	)		const

Definition at line 548 of file CSCSectorReceiverLUT.cc.

                                                                                          {
  gblphidat result;
 
  //if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address.toint());
  //else
  if (LUTsFromFile)
    result = mb_global_phi[address.toint()];
  else
    result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
  return result;
}

References calcGlobalPhiMB(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

globalPhiMB() [2/3]

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = false
	)		const

Definition at line 515 of file CSCSectorReceiverLUT.cc.

                                                                                                                 {
  gblphiadd address;
  gblphidat result;
 
  address.cscid = cscid;
  address.wire_group = ((1 << 5) - 1) & (wire_group >> 2);
  address.phi_local = phi_local;
 
  // comment for now
  //  if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address.toint());
  //else
  if (LUTsFromFile)
    result = mb_global_phi[address.toint()];
  else
    result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
  return result;
}

References calcGlobalPhiMB(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

globalPhiMB() [3/3]

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	unsigned	address,
		const bool	gangedME1a = false
	)		const

Definition at line 534 of file CSCSectorReceiverLUT.cc.

                                                                                         {
  gblphidat result;
  gblphiadd theadd(address);
 
  //if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address);
  //else
  if (LUTsFromFile)
    result = mb_global_phi[theadd.toint()];
  else
    result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
  return result;
}

References calcGlobalPhiMB(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

globalPhiME() [1/3]

gblphidat CSCSectorReceiverLUT::globalPhiME	(	gblphiadd	address,
		const bool	gangedME1a = false
	)		const

Definition at line 475 of file CSCSectorReceiverLUT.cc.

                                                                                          {
  gblphidat result;
 
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(
        _endcap, _sector, _station, _subsector, address.toint(), gangedME1a);
  else if (LUTsFromFile)
    result = me_global_phi[address.toint()];
  else
    result = calcGlobalPhiME(address);
 
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

globalPhiME() [2/3]

gblphidat CSCSectorReceiverLUT::globalPhiME	(	int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = false
	)		const

Definition at line 444 of file CSCSectorReceiverLUT.cc.

                                                                                                                 {
  gblphidat result;
  gblphiadd theadd;
  theadd.phi_local = phi_local;
  theadd.wire_group = ((1 << 5) - 1) & (wire_group >> 2);  // want 2-7 of wg
  theadd.cscid = cscid;
 
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(
        _endcap, _sector, _station, _subsector, theadd.toint(), gangedME1a);
  else if (LUTsFromFile)
    result = me_global_phi[theadd.toint()];
  else
    result = calcGlobalPhiME(theadd);
 
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

Referenced by L1TCSCTF::analyze(), globalPhiMB(), L1Analysis::L1AnalysisCSCTF::SetLCTs(), and L1Analysis::L1AnalysisCSCTF::SetTracks().

globalPhiME() [3/3]

gblphidat CSCSectorReceiverLUT::globalPhiME	(	unsigned	address,
		const bool	gangedME1a = false
	)		const

Definition at line 462 of file CSCSectorReceiverLUT.cc.

                                                                                         {
  gblphidat result;
 
  if (useMiniLUTs && isTMB07)
    result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(_endcap, _sector, _station, _subsector, address, gangedME1a);
  else if (LUTsFromFile)
    result = me_global_phi[address];
  else
    result = calcGlobalPhiME(gblphiadd(address));
 
  return result;
}

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

localPhi() [1/3]

lclphidat CSCSectorReceiverLUT::localPhi	(	int	strip,
		int	pattern,
		int	quality,
		int	lr,
		const bool	gangedME1a = false
	)		const

Geometry Lookup Tables.

Please note, the pattern used below is the 4 bit pattern. ex) digi->getPattern(), NOT digi->getCLCTPattern()

Definition at line 179 of file CSCSectorReceiverLUT.cc.

                                                                                                      {
  lclphiadd theadd;
 
  theadd.strip = strip;
  theadd.clct_pattern = pattern & 0x7;
  theadd.pattern_type = (pattern & 0x8) >> 3;
  theadd.quality = quality;
  theadd.lr = lr;
  theadd.spare = 0;
 
  return localPhi(theadd, gangedME1a);
}

References l1temulator_dqm_sourceclient-live_cfg::gangedME1a, topSingleLeptonDQM_PU_cfi::pattern, quality, and digitizers_cfi::strip.

Referenced by L1TCSCTF::analyze(), L1Analysis::L1AnalysisCSCTF::SetLCTs(), and L1Analysis::L1AnalysisCSCTF::SetTracks().

localPhi() [2/3]

lclphidat CSCSectorReceiverLUT::localPhi	(	lclphiadd	address,
		const bool	gangedME1a = false
	)		const

Definition at line 207 of file CSCSectorReceiverLUT.cc.

                                                                                       {
  lclphidat result;
 
  if (useMiniLUTs && isTMB07) {
    result = CSCSectorReceiverMiniLUT::calcLocalPhiMini(address.toint(), gangedME1a);
  } else if (LUTsFromFile)
    result = me_lcl_phi[address.toint()];
  else
    result = calcLocalPhi(address);
 
  return result;
}

References calcLocalPhi(), CSCSectorReceiverMiniLUT::calcLocalPhiMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_lcl_phi, mps_fire::result, and useMiniLUTs.

localPhi() [3/3]

lclphidat CSCSectorReceiverLUT::localPhi	(	unsigned	address,
		const bool	gangedME1a = false
	)		const

Definition at line 193 of file CSCSectorReceiverLUT.cc.

                                                                                      {
  lclphidat result;
  lclphiadd theadd(address);
 
  if (useMiniLUTs && isTMB07) {
    result = CSCSectorReceiverMiniLUT::calcLocalPhiMini(address, gangedME1a);
  } else if (LUTsFromFile)
    result = me_lcl_phi[address];
  else
    result = calcLocalPhi(theadd);
 
  return result;
}

References calcLocalPhi(), CSCSectorReceiverMiniLUT::calcLocalPhiMini(), l1temulator_dqm_sourceclient-live_cfg::gangedME1a, isTMB07, LUTsFromFile, me_lcl_phi, mps_fire::result, and useMiniLUTs.

operator=()

CSCSectorReceiverLUT & CSCSectorReceiverLUT::operator=

(

const CSCSectorReceiverLUT &

lut

)

Definition at line 83 of file CSCSectorReceiverLUT.cc.

                                                                                     {
  if (this != &lut) {
    _endcap = lut._endcap;
    _sector = lut._sector;
    _subsector = lut._subsector;
    _station = lut._station;
    me_lcl_phi_file = lut.me_lcl_phi_file;
    me_gbl_phi_file = lut.me_gbl_phi_file;
    mb_gbl_phi_file = lut.mb_gbl_phi_file;
    me_gbl_eta_file = lut.me_gbl_eta_file;
    LUTsFromFile = lut.LUTsFromFile;
    isBinary = lut.isBinary;
 
    if (lut.mb_global_phi) {
      mb_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
      memcpy(mb_global_phi, lut.mb_global_phi, (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(gblphidat));
    } else
      mb_global_phi = nullptr;
 
    if (lut.me_global_phi) {
      me_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
      memcpy(me_global_phi, lut.me_global_phi, (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(gblphidat));
    } else
      me_global_phi = nullptr;
 
    if (lut.me_global_eta) {
      me_global_eta = new gbletadat[1 << CSCBitWidths::kGlobalEtaAddressWidth];
      memcpy(me_global_eta, lut.me_global_eta, (1 << CSCBitWidths::kGlobalEtaAddressWidth) * sizeof(gbletadat));
    } else
      me_global_eta = nullptr;
  }
  return *this;
}

References _endcap, _sector, _station, _subsector, isBinary, CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, LUTsFromFile, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, and me_lcl_phi_file.

readLUTsFromFile()

void CSCSectorReceiverLUT::readLUTsFromFile ( )

private

Arrays for holding read in LUT information. MB LUT arrays only initialized in ME1

Definition at line 786 of file CSCSectorReceiverLUT.cc.

                                            {
  if (!me_lcl_phi_loaded) {
    me_lcl_phi = new lclphidat[1 << CSCBitWidths::kLocalPhiAddressWidth];
    std::string fName(me_lcl_phi_file.fullPath());
    std::ifstream LocalPhiLUT;
 
    edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
    if (isBinary) {
      LocalPhiLUT.open(fName.c_str(), std::ios::binary);
      LocalPhiLUT.seekg(0, std::ios::end);
      int length = LocalPhiLUT.tellg();
      if (length == (1 << CSCBitWidths::kLocalPhiAddressWidth) * sizeof(short)) {
        LocalPhiLUT.seekg(0, std::ios::beg);
        LocalPhiLUT.read(reinterpret_cast<char*>(me_lcl_phi), length);
        LocalPhiLUT.close();
      } else
        edm::LogError("CSCSectorReceiverLUT") << "File " << fName << " is incorrect size!";
      LocalPhiLUT.close();
    } else {
      LocalPhiLUT.open(fName.c_str());
      unsigned i = 0;
      unsigned short temp = 0;
      while (!LocalPhiLUT.eof() && i < 1 << CSCBitWidths::kLocalPhiAddressWidth) {
        LocalPhiLUT >> temp;
        me_lcl_phi[i++] = (*reinterpret_cast<lclphidat*>(&temp));
      }
      LocalPhiLUT.close();
    }
  }
  if (!me_global_phi) {
    me_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
    std::string fName = me_gbl_phi_file.fullPath();
    std::ifstream GlobalPhiLUT;
 
    edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
    if (isBinary) {
      GlobalPhiLUT.open(fName.c_str(), std::ios::binary);
      GlobalPhiLUT.seekg(0, std::ios::end);
      int length = GlobalPhiLUT.tellg();
      if (length == (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(short)) {
        GlobalPhiLUT.seekg(0, std::ios::beg);
        GlobalPhiLUT.read(reinterpret_cast<char*>(me_global_phi), length);
      } else
        edm::LogError("CSCSectorReceiverLUT") << "File " << fName << " is incorrect size!";
      GlobalPhiLUT.close();
    } else {
      GlobalPhiLUT.open(fName.c_str());
      unsigned short temp = 0;
      unsigned i = 0;
      while (!GlobalPhiLUT.eof() && i < 1 << CSCBitWidths::kGlobalPhiAddressWidth) {
        GlobalPhiLUT >> temp;
        me_global_phi[i++] = (*reinterpret_cast<gblphidat*>(&temp));
      }
      GlobalPhiLUT.close();
    }
  }
  if (!mb_global_phi && _station == 1)  // MB lut only in station one.
  {
    mb_global_phi = new gblphidat[1 << CSCBitWidths::kGlobalPhiAddressWidth];
    std::string fName = mb_gbl_phi_file.fullPath();
    std::ifstream GlobalPhiLUT;
 
    edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
    if (isBinary) {
      GlobalPhiLUT.open(fName.c_str(), std::ios::binary);
      GlobalPhiLUT.seekg(0, std::ios::end);
      int length = GlobalPhiLUT.tellg();
      if (length == (1 << CSCBitWidths::kGlobalPhiAddressWidth) * sizeof(short)) {
        GlobalPhiLUT.seekg(0, std::ios::beg);
        GlobalPhiLUT.read(reinterpret_cast<char*>(mb_global_phi), length);
      } else
        edm::LogError("CSCSectorReceiverLUT") << "File " << fName << " is incorrect size!";
      GlobalPhiLUT.close();
    } else {
      GlobalPhiLUT.open(fName.c_str());
      unsigned short temp = 0;
      unsigned i = 0;
      while (!GlobalPhiLUT.eof() && i < 1 << CSCBitWidths::kGlobalPhiAddressWidth) {
        GlobalPhiLUT >> temp;
        mb_global_phi[i++] = (*reinterpret_cast<gblphidat*>(&temp));
      }
      GlobalPhiLUT.close();
    }
  }
  if (!me_global_eta) {
    me_global_eta = new gbletadat[1 << CSCBitWidths::kGlobalEtaAddressWidth];
    std::string fName = me_gbl_eta_file.fullPath();
    std::ifstream GlobalEtaLUT;
 
    edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
    if (isBinary) {
      GlobalEtaLUT.open(fName.c_str(), std::ios::binary);
      GlobalEtaLUT.seekg(0, std::ios::end);
      int length = GlobalEtaLUT.tellg();
      if (length == (1 << CSCBitWidths::kGlobalEtaAddressWidth) * sizeof(short)) {
        GlobalEtaLUT.seekg(0, std::ios::beg);
        GlobalEtaLUT.read(reinterpret_cast<char*>(me_global_eta), length);
      } else
        edm::LogError("CSCSectorReceiverLUT") << "File " << fName << " is incorrect size!";
      GlobalEtaLUT.close();
    } else {
      GlobalEtaLUT.open(fName.c_str());
      unsigned short temp = 0;
      unsigned i = 0;
      while (!GlobalEtaLUT.eof() && i < 1 << CSCBitWidths::kGlobalEtaAddressWidth) {
        GlobalEtaLUT >> temp;
        me_global_eta[i++] = (*reinterpret_cast<gbletadat*>(&temp));
      }
      GlobalEtaLUT.close();
    }
  }
}

References _station, mps_fire::end, MainPageGenerator::fName, edm::FileInPath::fullPath(), mps_fire::i, isBinary, CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, CSCBitWidths::kLocalPhiAddressWidth, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, me_lcl_phi, me_lcl_phi_file, me_lcl_phi_loaded, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by CSCSectorReceiverLUT().

setCSCGeometry()

void CSCSectorReceiverLUT::setCSCGeometry ( const CSCGeometry *  g )

inline

Definition at line 50 of file CSCSectorReceiverLUT.h.

{ csc_g = g; }

References csc_g, and g.

Member Data Documentation

_endcap

int CSCSectorReceiverLUT::_endcap

private

Definition at line 53 of file CSCSectorReceiverLUT.h.

Referenced by calcGlobalPhiME(), calcLocalPhi(), encodeFileIndex(), getGlobalEtaValue(), globalEtaME(), globalPhiME(), and operator=().

_sector

int CSCSectorReceiverLUT::_sector

private

Definition at line 53 of file CSCSectorReceiverLUT.h.

Referenced by calcGlobalEtaME(), calcGlobalPhiME(), encodeFileIndex(), getGlobalEtaValue(), globalEtaME(), globalPhiME(), and operator=().

_station

int CSCSectorReceiverLUT::_station

private

Definition at line 53 of file CSCSectorReceiverLUT.h.

Referenced by calcGlobalEtaME(), calcGlobalPhiME(), calcLocalPhi(), encodeFileIndex(), getGlobalEtaValue(), globalEtaME(), globalPhiME(), operator=(), and readLUTsFromFile().

_subsector

int CSCSectorReceiverLUT::_subsector

private

Definition at line 53 of file CSCSectorReceiverLUT.h.

Referenced by calcGlobalPhiMB(), calcGlobalPhiME(), encodeFileIndex(), getGlobalEtaValue(), globalEtaME(), globalPhiME(), and operator=().

csc_g

const CSCGeometry* CSCSectorReceiverLUT::csc_g

private

Definition at line 88 of file CSCSectorReceiverLUT.h.

Referenced by calcGlobalPhiME(), getGlobalEtaValue(), and setCSCGeometry().

isBinary

bool CSCSectorReceiverLUT::isBinary

private

Definition at line 75 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), operator=(), and readLUTsFromFile().

isTMB07

bool CSCSectorReceiverLUT::isTMB07

private

Definition at line 77 of file CSCSectorReceiverLUT.h.

Referenced by calcLocalPhi(), globalEtaME(), globalPhiME(), and localPhi().

LUTsFromFile

bool CSCSectorReceiverLUT::LUTsFromFile

private

Definition at line 73 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), globalEtaME(), globalPhiMB(), globalPhiME(), localPhi(), and operator=().

mb_gbl_phi_file

edm::FileInPath CSCSectorReceiverLUT::mb_gbl_phi_file

private

Definition at line 71 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), operator=(), and readLUTsFromFile().

mb_global_phi

gblphidat * CSCSectorReceiverLUT::mb_global_phi

private

Definition at line 85 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), globalPhiMB(), operator=(), readLUTsFromFile(), and ~CSCSectorReceiverLUT().

me_gbl_eta_file

edm::FileInPath CSCSectorReceiverLUT::me_gbl_eta_file

private

Definition at line 72 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), operator=(), and readLUTsFromFile().

me_gbl_phi_file

edm::FileInPath CSCSectorReceiverLUT::me_gbl_phi_file

private

Definition at line 70 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), operator=(), and readLUTsFromFile().

me_global_eta

gbletadat* CSCSectorReceiverLUT::me_global_eta

private

Definition at line 86 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), globalEtaME(), operator=(), readLUTsFromFile(), and ~CSCSectorReceiverLUT().

me_global_phi

gblphidat* CSCSectorReceiverLUT::me_global_phi

private

Definition at line 85 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), globalPhiME(), operator=(), readLUTsFromFile(), and ~CSCSectorReceiverLUT().

me_lcl_phi

lclphidat * CSCSectorReceiverLUT::me_lcl_phi = nullptr

staticprivate

Definition at line 84 of file CSCSectorReceiverLUT.h.

Referenced by localPhi(), readLUTsFromFile(), and ~CSCSectorReceiverLUT().

me_lcl_phi_file

edm::FileInPath CSCSectorReceiverLUT::me_lcl_phi_file

private

Definition at line 69 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), operator=(), and readLUTsFromFile().

me_lcl_phi_loaded

bool CSCSectorReceiverLUT::me_lcl_phi_loaded = false

staticprivate

Definition at line 83 of file CSCSectorReceiverLUT.h.

Referenced by readLUTsFromFile(), and ~CSCSectorReceiverLUT().

useMiniLUTs

bool CSCSectorReceiverLUT::useMiniLUTs

private

Definition at line 74 of file CSCSectorReceiverLUT.h.

Referenced by CSCSectorReceiverLUT(), globalEtaME(), globalPhiME(), and localPhi().