AngleConverter Class Reference

#include <AngleConverter.h>

Public Member Functions
	AngleConverter (edm::ConsumesCollector &, bool getDuringEvent=true)
void	checkAndUpdateGeometry (const edm::EventSetup &, unsigned int)
	Update the Geometry with current Event Setup. More...
int	getGlobalEta (unsigned int rawid, const L1MuDTChambPhDigi &aDigi, const L1MuDTChambThContainer *dtThDigis)
	Convert local eta coordinate to global digital microGMT scale. More...
int	getGlobalEta (unsigned int rawid, const CSCCorrelatedLCTDigi &aDigi)
	Convert local eta coordinate to global digital microGMT scale. More...
int	getGlobalEta (unsigned int rawid, const unsigned int &aDigi)
	Convert local eta coordinate to global digital microGMT scale. More...
int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const L1MuDTChambPhDigi &digi) const
int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const CSCDetId &csc, const CSCCorrelatedLCTDigi &digi) const
int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const RPCDetId &rollId, const unsigned int &digi) const
int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const RPCDetId &rollId, const unsigned int &digi1, const unsigned int &digi2) const
	~AngleConverter ()

Private Member Functions
const int	findBTIgroup (const L1MuDTChambPhDigi &aDigi, const L1MuDTChambThContainer *dtThDigis)
	Find BTI group. More...
bool	isCSCCounterClockwise (const std::unique_ptr< const CSCLayer > &layer) const
	Check orientation of strips in given CSC chamber. More...

Private Attributes
CSCGeometry const *	_geocsc
DTGeometry const *	_geodt
unsigned long long	_geom_cache_id
RPCGeometry const *	_georpc
edm::ESGetToken< CSCGeometry, MuonGeometryRecord >	cscGeometryToken_
edm::ESGetToken< DTGeometry, MuonGeometryRecord >	dtGeometryToken_
unsigned int	nPhiBins
	Number of phi bins along 2Pi. More...
edm::ESGetToken< RPCGeometry, MuonGeometryRecord >	rpcGeometryToken_

Detailed Description

Definition at line 26 of file AngleConverter.h.

Constructor & Destructor Documentation

AngleConverter::AngleConverter	(	edm::ConsumesCollector &	iC,
		bool	getDuringEvent = true
	)

Definition at line 151 of file AngleConverter.cc.

References edm::BeginRun, cscGeometryToken_, dtGeometryToken_, edm::ConsumesCollector::esConsumes(), and rpcGeometryToken_.

                                                                            : _geom_cache_id(0ULL) {
  if (getDuringEvent) {
    rpcGeometryToken_ = iC.esConsumes<RPCGeometry, MuonGeometryRecord>();
    cscGeometryToken_ = iC.esConsumes<CSCGeometry, MuonGeometryRecord>();
    dtGeometryToken_ = iC.esConsumes<DTGeometry, MuonGeometryRecord>();
  } else {
    rpcGeometryToken_ = iC.esConsumes<RPCGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
    cscGeometryToken_ = iC.esConsumes<CSCGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
    dtGeometryToken_ = iC.esConsumes<DTGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
  }
}

AngleConverter::~AngleConverter

(

)

Definition at line 164 of file AngleConverter.cc.

{}

Member Function Documentation

void AngleConverter::checkAndUpdateGeometry	(	const edm::EventSetup &	es,
		unsigned int	phiBins
	)

Update the Geometry with current Event Setup.

Definition at line 167 of file AngleConverter.cc.

References _geocsc, _geodt, _geom_cache_id, _georpc, edm::eventsetup::EventSetupRecord::cacheIdentifier(), cscGeometryToken_, dtGeometryToken_, relativeConstraints::geom, edm::EventSetup::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), nPhiBins, and rpcGeometryToken_.

                                                                                         {
  const MuonGeometryRecord &geom = es.get<MuonGeometryRecord>();
  unsigned long long geomid = geom.cacheIdentifier();
  if (_geom_cache_id != geomid) {
    _georpc = &geom.get(rpcGeometryToken_);
    _geocsc = &geom.get(cscGeometryToken_);
    _geodt = &geom.get(dtGeometryToken_);
    _geom_cache_id = geomid;
  }

  nPhiBins = phiBins;
}

const int AngleConverter::findBTIgroup ( const L1MuDTChambPhDigi &  aDigi, const L1MuDTChambThContainer *  dtThDigis  )

private

Find BTI group.

If there are more than one theta digi we do not take is due to unresolvet ambiguity. In this case we take eta of the middle of the chamber.

Definition at line 518 of file AngleConverter.cc.

References L1MuDTChambPhDigi::bxNum(), L1MuDTChambThContainer::chThetaSegm(), mps_fire::i, L1MuDTChambThDigi::position(), L1MuDTChambPhDigi::scNum(), L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

                                                                                                              {
  int bti_group = -1;

  const L1MuDTChambThDigi *theta_segm =
      dtThDigis->chThetaSegm(aDigi.whNum(), aDigi.stNum(), aDigi.scNum(), aDigi.bxNum());
  if (!theta_segm)
    return bti_group;

  for (unsigned int i = 0; i < 7; ++i) {
    if (theta_segm->position(i) && bti_group < 0)
      bti_group = i;
    else if (theta_segm->position(i) && bti_group > -1)
      return -1;
  }

  return bti_group;
}

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const L1MuDTChambPhDigi &	aDigi,
		const L1MuDTChambThContainer *	dtThDigis
	)

Convert local eta coordinate to global digital microGMT scale.

Definition at line 364 of file AngleConverter.cc.

References _geodt, L1MuDTChambPhDigi::bxNum(), DTGeometry::chamber(), L1MuDTChambThContainer::chThetaSegm(), PV3DBase< T, PVType, FrameType >::eta(), mps_fire::i, L1MuDTChambThDigi::position(), L1MuDTChambPhDigi::scNum(), FWPFMaths::sgn(), L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

                                                                          {
  const DTChamberId baseid(aDigi.whNum(), aDigi.stNum(), aDigi.scNum() + 1);

  // do not use this pointer for anything other than creating a trig geom
  std::unique_ptr<DTChamber> chamb(const_cast<DTChamber *>(_geodt->chamber(baseid)));

  std::unique_ptr<DTTrigGeom> trig_geom(new DTTrigGeom(chamb.get(), false));
  chamb.release();  // release it here so no one gets funny ideas
  // super layer one is the theta superlayer in a DT chamber
  // station 4 does not have a theta super layer
  // the BTI index from the theta trigger is an OR of some BTI outputs
  // so, we choose the BTI that's in the middle of the group
  // as the BTI that we get theta from
  // TODO:::::>>> need to make sure this ordering doesn't flip under wheel sign
  const int NBTI_theta = ((baseid.station() != 4) ? trig_geom->nCell(2) : trig_geom->nCell(3));

  //  const int bti_group = findBTIgroup(aDigi,dtThDigis);
  //  const unsigned bti_actual = bti_group*NBTI_theta/7 + NBTI_theta/14 + 1;
  //  DTBtiId thetaBTI;
  //  if ( baseid.station() != 4 && bti_group != -1) {
  //    thetaBTI = DTBtiId(baseid,2,bti_actual);
  //  } else {
  //    // since this is phi oriented it'll give us theta in the middle
  //    // of the chamber
  //    thetaBTI = DTBtiId(baseid,3,1);
  //  }
  //  const GlobalPoint theta_gp = trig_geom->CMSPosition(thetaBTI);
  //  int iEta = theta_gp.eta()/2.61*240;
  //  return iEta;

  const L1MuDTChambThDigi *theta_segm =
      dtThDigis->chThetaSegm(aDigi.whNum(), aDigi.stNum(), aDigi.scNum(), aDigi.bxNum());
  int bti_group = -1;
  if (theta_segm) {
    for (unsigned int i = 0; i < 7; ++i)
      if (theta_segm->position(i) && bti_group < 0)
        bti_group = i;
      else if (theta_segm->position(i) && bti_group > -1)
        bti_group = 511;
  }

  int iEta = 0;
  if (bti_group == 511)
    iEta = 95;
  else if (bti_group == -1 && aDigi.stNum() == 1)
    iEta = 92;
  else if (bti_group == -1 && aDigi.stNum() == 2)
    iEta = 79;
  else if (bti_group == -1 && aDigi.stNum() == 3)
    iEta = 75;
  else if (baseid.station() != 4 && bti_group >= 0) {
    //    bti_group = 6-bti_group;
    unsigned bti_actual = bti_group * NBTI_theta / 7 + NBTI_theta / 14 + 1;
    DTBtiId thetaBTI = DTBtiId(baseid, 2, bti_actual);
    GlobalPoint theta_gp = trig_geom->CMSPosition(thetaBTI);
    iEta = etaVal2Code(fabs(theta_gp.eta()));
  }
  int signEta = sgn(aDigi.whNum());
  iEta *= signEta;
  return iEta;
}

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const CSCCorrelatedLCTDigi &	aDigi
	)

Convert local eta coordinate to global digital microGMT scale.

Code taken from GeometryTranslator. Will be replaced by direct CSC phi local to global scale transformation as used in FPGA implementation

Definition at line 430 of file AngleConverter.cc.

References _geocsc, CSCGeometry::chamber(), CSCCorrelatedLCTDigi::getKeyWG(), CSCPatternBank::getLegacyPosition(), CSCCorrelatedLCTDigi::getPattern(), CSCCorrelatedLCTDigi::getStrip(), gpuClustering::id, isCSCCounterClockwise(), CSCConstants::KEY_ALCT_LAYER, phase1PixelTopology::layer, PV3DBase< T, PVType, FrameType >::mag(), hltrates_dqm_sourceclient-live_cfg::offset, PV3DBase< T, PVType, FrameType >::phi(), digitizers_cfi::strip, PV3DBase< T, PVType, FrameType >::theta(), and Geom::Phi< T1, Range >::value().

                                                                                      {

  // alot of this is transcription and consolidation of the CSC
  // global phi calculation code
  // this works directly with the geometry
  // rather than using the old phi luts
  const CSCDetId id(rawid);
  // we should change this to weak_ptrs at some point
  // requires introducing std::shared_ptrs to geometry
  std::unique_ptr<const CSCChamber> chamb(_geocsc->chamber(id));
  std::unique_ptr<const CSCLayerGeometry> layer_geom(chamb->layer(CSCConstants::KEY_ALCT_LAYER)->geometry());
  std::unique_ptr<const CSCLayer> layer(chamb->layer(CSCConstants::KEY_ALCT_LAYER));

  const uint16_t halfstrip = aDigi.getStrip();
  const uint16_t pattern = aDigi.getPattern();
  const uint16_t keyWG = aDigi.getKeyWG();
  //const unsigned maxStrips = layer_geom->numberOfStrips();

  // so we can extend this later
  // assume TMB2007 half-strips only as baseline
  double offset = 0.0;
  switch (1) {
    case 1:
      offset = CSCPatternBank::getLegacyPosition(pattern);
  }
  const unsigned halfstrip_offs = unsigned(0.5 + halfstrip + offset);
  const unsigned strip = halfstrip_offs / 2 + 1;  // geom starts from 1

  // the rough location of the hit at the ALCT key layer
  // we will refine this using the half strip information
  const LocalPoint coarse_lp = layer_geom->stripWireGroupIntersection(strip, keyWG);
  const GlobalPoint coarse_gp = layer->surface().toGlobal(coarse_lp);

  // the strip width/4.0 gives the offset of the half-strip
  // center with respect to the strip center
  const double hs_offset = layer_geom->stripPhiPitch() / 4.0;

  // determine handedness of the chamber
  const bool ccw = isCSCCounterClockwise(layer);
  // we need to subtract the offset of even half strips and add the odd ones
  const double phi_offset = ((halfstrip_offs % 2 ? 1 : -1) * (ccw ? -hs_offset : hs_offset));

  // the global eta calculation uses the middle of the strip
  // so no need to increment it
  const GlobalPoint final_gp(
      GlobalPoint::Polar(coarse_gp.theta(), (coarse_gp.phi().value() + phi_offset), coarse_gp.mag()));
  // release ownership of the pointers
  chamb.release();
  layer_geom.release();
  layer.release();

  //  std::cout <<id<<" st: " << id.station()<< "ri: "<<id.ring()<<" eta: " <<  final_gp.eta()
  //           <<" etaCode_simple: " <<  etaVal2Code( final_gp.eta() )<< " KW: "<<keyWG <<" etaKeyWG2Code: "<<etaKeyWG2Code(id,keyWG)<< std::endl;
  //  int station = (id.endcap()==1) ? id.station() : -id.station();
  //  std::cout <<"ETA_CSC: " << station <<" "<<id.ring()<<" "<< final_gp.eta()<<" "<<keyWG <<" "<< etaKeyWG2Code(id,keyWG) << std::endl;

  return etaKeyWG2Code(id, keyWG);

  // return etaVal2Code( final_gp.eta() );
  // int iEta =  final_gp.eta()/2.61*240;
  // return iEta;
}

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const unsigned int &	aDigi
	)

Convert local eta coordinate to global digital microGMT scale.

Definition at line 497 of file AngleConverter.cc.

References _georpc, PV3DBase< T, PVType, FrameType >::eta(), runTauDisplay::gp, gpuClustering::id, and RPCGeometry::roll().

                                                                              {
  const RPCDetId id(rawid);
  std::unique_ptr<const RPCRoll> roll(_georpc->roll(id));
  const LocalPoint lp = roll->centreOfStrip((int)strip);
  const GlobalPoint gp = roll->toGlobal(lp);
  roll.release();

  return etaVal2Code(gp.eta());
  //  float iEta = gp.eta()/2.61*240;
  //  return iEta;
}

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const L1MuDTChambPhDigi &	digi
	)		const

get phi of DT,CSC and RPC azimutal angle digi in processor scale, used by OMTF algorithm. in case of wrong phi returns OMTFConfiguration::instance()->nPhiBins

Definition at line 181 of file AngleConverter.cc.

References M_PI, nPhiBins, l1t::omtf_pos, phi, L1MuDTChambPhDigi::phi(), funct::pow(), pileupReCalc_HLTpaths::scale, L1MuDTChambPhDigi::scNum(), relativeConstraints::station, L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

                                                                                                                {
  double hsPhiPitch = 2 * M_PI / nPhiBins;  // width of phi Pitch, related to halfStrip at CSC station 2
  const int dummy = nPhiBins;
  int processor = iProcessor + 1;                         // FIXME: get from OMTF name when available
  int posneg = (part == l1t::tftype::omtf_pos) ? 1 : -1;  // FIXME: get from OMTF name

  int sector =
      digi.scNum() + 1;  //NOTE: there is a inconsistency in DT sector numb. Thus +1 needed to get detector numb.
  int wheel = digi.whNum();
  int station = digi.stNum();
  int phiDT = digi.phi();

  if (posneg * 2 != wheel)
    return dummy;
  if (station > 3)
    return dummy;

  //FIXME: update the following two lines with proper method when Connections introduced
  if (processor != 6 && !(sector >= processor * 2 - 1 && sector <= processor * 2 + 1))
    return dummy;
  if (processor == 6 && !(sector >= 11 || sector == 1))
    return dummy;

  // ichamber is consecutive chamber connected to processor, starting from 0 (overlaping one)
  int ichamber = sector - 1 - 2 * (processor - 1);
  if (ichamber < 0)
    ichamber += 12;

  int offsetLoc = lround(((ichamber - 1) * M_PI / 6 + M_PI / 12.) / hsPhiPitch);
  double scale = 1. / 4096 / hsPhiPitch;
  int scale_coeff = lround(scale * pow(2, 11));
  //  int phi = static_cast<int>(phiDT*scale) + offsetLoc;
  int phi = floor(phiDT * scale_coeff / pow(2, 11)) + offsetLoc;

  return phi;
}

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const CSCDetId &	csc,
		const CSCCorrelatedLCTDigi &	digi
	)		const

Definition at line 219 of file AngleConverter.cc.

References _geocsc, CSCLayer::centerOfStrip(), CSCDetId::chamber(), CSCGeometry::chamber(), CSCCorrelatedLCTDigi::getStrip(), CSCChamber::layer(), phase1PixelTopology::layer, M_PI, nPhiBins, l1t::omtf_pos, phi, PV3DBase< T, PVType, FrameType >::phi(), CSCDetId::ring(), pileupReCalc_HLTpaths::scale, CSCChamber::specs(), CSCDetId::station(), CSCChamberSpecs::stripPhiPitch(), and CSCDetId::zendcap().

                                                                            {
  const double hsPhiPitch = 2 * M_PI / nPhiBins;
  const int dummy = nPhiBins;
  int processor = iProcessor + 1;                         // FIXME: get from OMTF name when available
  int posneg = (part == l1t::tftype::omtf_pos) ? 1 : -1;  // FIXME: get from OMTF name

  // filter out chambers not connected to OMTF board
  // FIXME: temporary - use Connections or relay that filtering done before.
  if (posneg != csc.zendcap())
    return dummy;
  if (csc.ring() != 3 && !(csc.ring() == 2 && (csc.station() == 2 || csc.station() == 3 || csc.station() == 1)))
    return dummy;
  if (processor != 6) {
    if (csc.chamber() < (processor - 1) * 6 + 2)
      return dummy;
    if (csc.chamber() > (processor - 1) * 6 + 8)
      return dummy;
  } else {
    if (csc.chamber() > 2 && csc.chamber() < 32)
      return dummy;
  }

  //
  // assign number 0..6, consecutive processor for a processor
  //
  //int ichamber = (csc.chamber()-2-6*(processor-1));
  //if (ichamber < 0) ichamber += 36;

  //
  // get offset for each chamber.
  // FIXME: These parameters depends on processor and chamber only so may be precomputed and put in map
  //
  const CSCChamber *chamber = _geocsc->chamber(csc);
  const CSCChamberSpecs *cspec = chamber->specs();
  const CSCLayer *layer = chamber->layer(3);
  int order = (layer->centerOfStrip(2).phi() - layer->centerOfStrip(1).phi() > 0) ? 1 : -1;
  double stripPhiPitch = cspec->stripPhiPitch();
  double scale = fabs(stripPhiPitch / hsPhiPitch / 2.);
  if (fabs(scale - 1.) < 0.0002)
    scale = 1.;
  double phi15deg = M_PI / 3. * (processor - 1) + M_PI / 12.;
  double phiHalfStrip0 = layer->centerOfStrip(10).phi() - order * 9 * stripPhiPitch - order * stripPhiPitch / 4.;
  if (processor == 6 || phiHalfStrip0 < 0)
    phiHalfStrip0 += 2 * M_PI;
  int offsetLoc = lround((phiHalfStrip0 - phi15deg) / hsPhiPitch);

  int halfStrip = digi.getStrip();  // returns halfStrip 0..159
  //FIXME: to be checked (only important for ME1/3) keep more bits for offset, truncate at the end

  // a quick fix for towards geometry changes due to global tag.
  // in case of MC tag fixOff shold be identical to offsetLoc
  int fixOff = fixCscOffsetGeom(offsetLoc);

  int phi = fixOff + order * scale * halfStrip;

  //  std::cout <<" hs: "<< halfStrip <<" offset: " << offsetLoc <<" oder*scale: "<< order*scale
  //            <<" phi: " <<phi<<" ("<<offsetLoc + order*scale*halfStrip<<")"<< std::endl;

  return phi;
}

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const RPCDetId &	rollId,
		const unsigned int &	digi
	)		const

Definition at line 327 of file AngleConverter.cc.

References _georpc, RPCRoll::centreOfStrip(), M_PI, nPhiBins, RPCGeometry::roll(), and GeomDet::toGlobal().

                                                                    {
  const double hsPhiPitch = 2 * M_PI / nPhiBins;
  const int dummy = nPhiBins;
  int processor = iProcessor + 1;
  const RPCRoll *roll = _georpc->roll(rollId);
  if (!roll)
    return dummy;

  double phi15deg =
      M_PI / 3. * (processor - 1) + M_PI / 12.;  // "0" is 15degree moved cyclicaly to each processor, note [0,2pi]
  double stripPhi = (roll->toGlobal(roll->centreOfStrip((int)digi))).phi();  // note [-pi,pi]

  // adjust [0,2pi] and [-pi,pi] to get deltaPhi difference properly
  switch (processor) {
    case 1:
      break;
    case 6: {
      phi15deg -= 2 * M_PI;
      break;
    }
    default: {
      if (stripPhi < 0)
        stripPhi += 2 * M_PI;
      break;
    }
  }

  // local angle in CSC halfStrip usnits
  int halfStrip = lround((stripPhi - phi15deg) / hsPhiPitch);

  return halfStrip;
}

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const RPCDetId &	rollId,
		const unsigned int &	digi1,
		const unsigned int &	digi2
	)		const

Definition at line 285 of file AngleConverter.cc.

References _georpc, RPCRoll::centreOfStrip(), M_PI, nPhiBins, RPCGeometry::roll(), and GeomDet::toGlobal().

                                                                     {
  const double hsPhiPitch = 2 * M_PI / nPhiBins;
  const int dummy = nPhiBins;
  int processor = iProcessor + 1;
  const RPCRoll *roll = _georpc->roll(rollId);
  if (!roll)
    return dummy;

  double phi15deg =
      M_PI / 3. * (processor - 1) + M_PI / 12.;  // "0" is 15degree moved cyclicaly to each processor, note [0,2pi]
  double stripPhi1 = (roll->toGlobal(roll->centreOfStrip((int)digi1))).phi();  // note [-pi,pi]
  double stripPhi2 = (roll->toGlobal(roll->centreOfStrip((int)digi2))).phi();  // note [-pi,pi]

  // stripPhi from geometry is given in [-pi,pi] range.
  // Keep like that for OMTFp1 [15-10deg,75deg] and OMTFp6 [-45-10deg,15deg].
  // For OMTFp2..OMTFp5  move to [0,2pi] range
  switch (processor) {
    case 1:
      break;
    case 6: {
      phi15deg -= 2 * M_PI;
      break;
    }
    default: {
      if (stripPhi1 < 0)
        stripPhi1 += 2 * M_PI;
      if (stripPhi2 < 0)
        stripPhi2 += 2 * M_PI;
      break;
    }
  }

  // local angle in CSC halfStrip usnits
  int halfStrip = lround(((stripPhi1 + stripPhi2) / 2. - phi15deg) / hsPhiPitch);

  return halfStrip;
}

bool AngleConverter::isCSCCounterClockwise ( const std::unique_ptr< const CSCLayer > &  layer ) const

private

Check orientation of strips in given CSC chamber.

Definition at line 510 of file AngleConverter.cc.

References funct::abs(), M_PI, and me0TriggerPseudoDigis_cff::nStrips.

Referenced by getGlobalEta().

                                                                                           {
  const int nStrips = layer->geometry()->numberOfStrips();
  const double phi1 = layer->centerOfStrip(1).phi();
  const double phiN = layer->centerOfStrip(nStrips).phi();
  return ((std::abs(phi1 - phiN) < M_PI && phi1 >= phiN) || (std::abs(phi1 - phiN) >= M_PI && phi1 < phiN));
}

Member Data Documentation

CSCGeometry const* AngleConverter::_geocsc

private

Definition at line 71 of file AngleConverter.h.

Referenced by checkAndUpdateGeometry(), getGlobalEta(), and getProcessorPhi().

DTGeometry const* AngleConverter::_geodt

private

Definition at line 72 of file AngleConverter.h.

Referenced by checkAndUpdateGeometry(), and getGlobalEta().

unsigned long long AngleConverter::_geom_cache_id

private

Definition at line 69 of file AngleConverter.h.

Referenced by checkAndUpdateGeometry().

RPCGeometry const* AngleConverter::_georpc

private

Definition at line 70 of file AngleConverter.h.

Referenced by checkAndUpdateGeometry(), getGlobalEta(), and getProcessorPhi().

edm::ESGetToken<CSCGeometry, MuonGeometryRecord> AngleConverter::cscGeometryToken_

private

Definition at line 65 of file AngleConverter.h.

Referenced by AngleConverter(), and checkAndUpdateGeometry().

edm::ESGetToken<DTGeometry, MuonGeometryRecord> AngleConverter::dtGeometryToken_

private

Definition at line 66 of file AngleConverter.h.

Referenced by AngleConverter(), and checkAndUpdateGeometry().

unsigned int AngleConverter::nPhiBins

private

Number of phi bins along 2Pi.

Definition at line 75 of file AngleConverter.h.

Referenced by checkAndUpdateGeometry(), and getProcessorPhi().

edm::ESGetToken<RPCGeometry, MuonGeometryRecord> AngleConverter::rpcGeometryToken_

private

Definition at line 64 of file AngleConverter.h.

Referenced by AngleConverter(), and checkAndUpdateGeometry().