RPCStripsRing Class Reference

#include <L1Trigger/RPCTrigger/interface/RPCStripsRing.h>

Inheritance diagram for RPCStripsRing:

Classes
struct	TOtherConnStruct

Public Types
typedef std::map< int, RPCStripsRing >	TIdToRindMap
typedef std::vector< TOtherConnStruct >	TOtherConnStructVec

Public Member Functions
void	addRoll (const RPCRoll *roll)
void	compressConnections ()
void	createOtherConnections (int tower, int PACno, int logplane, int logplanesize, float angle)
void	createRefConnections (TOtherConnStructVec &otherRings, int logplane, int logplaneSize)
void	fillWithVirtualStrips ()
void	filterOverlapingChambers ()
std::shared_ptr< L1RPCConeBuilder::TCompressedConMap >	getCompressedConnectionsMap ()
std::shared_ptr< L1RPCConeBuilder::TConMap >	getConnectionsMap ()
int	getEtaPartition ()
int	getHwPlane ()
int	getRingId ()
int	getTowerForRefRing ()
bool	isReferenceRing ()
	RPCStripsRing (const RPCRoll *roll, std::shared_ptr< L1RPCConeBuilder::TConMap > cmap)
	RPCStripsRing ()
virtual	~RPCStripsRing ()

Static Public Member Functions
static int	calculateHwPlane (const RPCRoll *roll)
	Calculate ringId for any given RPCRoll. More...
static int	getRingId (int etaPart, int hwPlane)
static int	getRingId (const RPCRoll *roll)
	Calculate ringId for this ring. More...

Private Attributes
std::shared_ptr< L1RPCConeBuilder::TCompressedConMap >	m_compressedConnectionMap
std::shared_ptr< L1RPCConeBuilder::TConMap >	m_connectionsMap
bool	m_didFiltering
bool	m_didVirtuals
int	m_etaPartition
int	m_hwPlane
bool	m_isReferenceRing
int	m_region

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 36 of file RPCStripsRing.h.

Member Typedef Documentation

TIdToRindMap

typedef std::map<int, RPCStripsRing> RPCStripsRing::TIdToRindMap

Definition at line 39 of file RPCStripsRing.h.

TOtherConnStructVec

typedef std::vector<TOtherConnStruct> RPCStripsRing::TOtherConnStructVec

Definition at line 48 of file RPCStripsRing.h.

Constructor & Destructor Documentation

RPCStripsRing() [1/2]

RPCStripsRing::RPCStripsRing	(	const RPCRoll *	roll,
		std::shared_ptr< L1RPCConeBuilder::TConMap >	cmap
	)

Definition at line 31 of file RPCStripsRing.cc.

References funct::abs(), addRoll(), calculateHwPlane(), RPCGeomServ::eta_partition(), getRingId(), RPCRoll::id(), m_etaPartition, m_hwPlane, m_isReferenceRing, m_region, RPCDetId::region(), RPCDetId::ring(), and relativeConstraints::ring.

    : m_didVirtuals(false), m_didFiltering(false), m_connectionsMap(cmap) {
  RPCDetId detId = roll->id();
  RPCGeomServ grs(detId);

  m_etaPartition = grs.eta_partition();
  m_hwPlane = calculateHwPlane(roll);

  m_isReferenceRing = false;

  m_region = detId.region();

  int ring = detId.ring();

  if (m_region == 0 && std::abs(ring) < 2 && m_hwPlane == 2)  // for barell wheel -1,0,1 refplane is hwPlane=2
    m_isReferenceRing = true;
  else if (m_region == 0 && std::abs(ring) == 2 && m_hwPlane == 6)  // for barell wheel -2,2 refplane is hwPlane=6
    m_isReferenceRing = true;
  else if (m_region != 0 && m_hwPlane == 2)  // for endcaps
    m_isReferenceRing = true;

  if (getRingId() == 2008 || getRingId() == 2108)  //exception: endcaps;hwplane 2;farest roll from beam
    m_isReferenceRing = false;

  addRoll(roll);
}

RPCStripsRing() [2/2]

RPCStripsRing::RPCStripsRing

(

)

Definition at line 23 of file RPCStripsRing.cc.

    : m_hwPlane(-1),
      m_etaPartition(99),
      m_region(-2),
      m_isReferenceRing(false),
      m_didVirtuals(false),
      m_didFiltering(false) {}

~RPCStripsRing()

virtual RPCStripsRing::~RPCStripsRing ( )

inlinevirtual

Definition at line 53 of file RPCStripsRing.h.

{};

Member Function Documentation

addRoll()

void RPCStripsRing::addRoll

(

const RPCRoll *

roll

)

Definition at line 58 of file RPCStripsRing.cc.

References RPCRoll::centreOfStrip(), Exception, getRingId(), mps_fire::i, RPCRoll::id(), RPCRoll::nstrips(), PV3DBase< T, PVType, FrameType >::phi(), DetId::rawId(), and GeomDet::toGlobal().

Referenced by RPCStripsRing().

                                               {
  //  RPCDetId detId = roll->id();

  if (getRingId() != getRingId(roll)) {
    throw cms::Exception("RPCInternal") << "RPCStripsRing::addRoll ringsIds dont match \n";
  }

  //iterate over the strips of this roll
  for (int i = 1; i <= roll->nstrips(); i++) {
    LocalPoint lStripCentre = roll->centreOfStrip(i);
    GlobalPoint gStripCentre = roll->toGlobal(lStripCentre);
    float phiRaw = gStripCentre.phi();

    TStrip newStrip(roll->id().rawId(), i);
    (*this)[phiRaw] = newStrip;
  }
}

calculateHwPlane()

int RPCStripsRing::calculateHwPlane ( const RPCRoll *  roll )

static

Calculate ringId for any given RPCRoll.

Definition at line 100 of file RPCStripsRing.cc.

References Exception, RPCRoll::id(), RPCDetId::layer(), phase1PixelTopology::layer, RPCDetId::region(), HLT_2022v11_cff::region, relativeConstraints::station, and RPCDetId::station().

Referenced by getRingId(), and RPCStripsRing().

                                                       {
  int hwPlane = -1;
  RPCDetId detId = roll->id();
  int station = detId.station();
  int layer = detId.layer();
  int region = detId.region();

  if (region != 0) {  // endcaps
    hwPlane = station;
  }
  // Now comes the barell
  else if (station > 2) {
    hwPlane = station;
  } else if (station == 1 && layer == 1) {
    hwPlane = 1;
  } else if (station == 1 && layer == 2) {
    hwPlane = 5;
  } else if (station == 2 && layer == 1) {
    hwPlane = 2;
  } else if (station == 2 && layer == 2) {
    hwPlane = 6;
  }

  /*if (hwPlane < 1)
    std::cout << "prb: " << hwPlane << " "
        << region << " "
        << station << " "
  << layer << std::endl;*/
  if (hwPlane < 0) {
    throw cms::Exception("RPCInternal") << "Calculated negative hwplane \n";
  }

  return hwPlane;
}

compressConnections()

void RPCStripsRing::compressConnections

(

)

Definition at line 443 of file RPCStripsRing.cc.

References L1RPCConeBuilder::TCompressedCon::addStrip(), createfilelist::int, m_compressedConnectionMap, m_connectionsMap, L1RPCConeBuilder::TCompressedCon::m_logplane, L1RPCConeBuilder::TCompressedCon::m_mul, L1RPCConeBuilder::TCompressedCon::m_offset, L1RPCConeBuilder::TCompressedCon::m_PAC, and L1RPCConeBuilder::TCompressedCon::m_tower.

                                        {
  L1RPCConeBuilder::TConMap::iterator itChamber = m_connectionsMap->begin();

  auto uncompressedConsLeft = std::make_shared<L1RPCConeBuilder::TConMap>();

  m_compressedConnectionMap = std::make_shared<L1RPCConeBuilder::TCompressedConMap>();

  int compressedCons = 0, uncompressedConsBefore = 0, uncompressedConsAfter = 0;

  //   int offsetMin =0, offsetMax =0;

  for (; itChamber != m_connectionsMap->end(); ++itChamber) {
    uint32_t detId = itChamber->first;

    for (L1RPCConeBuilder::TStrip2ConVec::iterator itStrip = itChamber->second.begin();
         itStrip != itChamber->second.end();
         ++itStrip) {
      // Iterate over strip Connections
      for (L1RPCConeBuilder::TStripConVec::iterator itConn = itStrip->second.begin(); itConn != itStrip->second.end();
           ++itConn) {
        // Check if this connection isn't allready present in the compressed map
        ++uncompressedConsBefore;
        bool alreadyDone = false;
        if (m_compressedConnectionMap->find(detId) != m_compressedConnectionMap->end()) {
          // iterate over the vec, check element by element
          for (L1RPCConeBuilder::TCompressedConVec::iterator itCompConn = (*m_compressedConnectionMap)[detId].begin();
               itCompConn != (*m_compressedConnectionMap)[detId].end();
               ++itCompConn) {
            if (itCompConn->m_tower == itConn->m_tower && itCompConn->m_PAC == itConn->m_PAC &&
                itCompConn->m_logplane == itConn->m_logplane)  // connection allready compressed
            {
              alreadyDone = true;

              int logStrip = itCompConn->m_mul * itStrip->first + itCompConn->m_offset;
              if (logStrip != itConn->m_logstrip) {
                //copy the problematic connection to the "safe" map
                (*uncompressedConsLeft)[detId][itStrip->first].push_back(*itConn);
                ++uncompressedConsAfter;
                edm::LogWarning("RPCTriggerConfig")
                    << " Compression failed for det " << detId << " strip " << (int)itStrip->first << " . Got "
                    << (int)logStrip << " expected " << (int)itConn->m_logstrip << std::endl;
              } else {
                itCompConn->addStrip(itStrip->first);
              }
            }
          }  // compressed connection iteration end
        }
        //if (detId==637569977) std::cout << " Buld cons for strip " << (int)itStrip->first << std::endl;

        if (!alreadyDone) {
          // find another strip contributing to the same PAC,tower,logplane
          L1RPCConeBuilder::TStrip2ConVec::iterator itStripOther = itStrip;
          ++itStripOther;
          bool otherStripFound = false;
          signed char mul = 1;
          for (; itStripOther != itChamber->second.end() && !otherStripFound; ++itStripOther) {
            for (L1RPCConeBuilder::TStripConVec::iterator itConnOther = itStripOther->second.begin();
                 itConnOther != itStripOther->second.end();
                 ++itConnOther) {
              if (itConnOther->m_tower == itConn->m_tower && itConnOther->m_PAC == itConn->m_PAC &&
                  itConnOther->m_logplane == itConn->m_logplane)  // connection to same PAC,logplane
              {
                otherStripFound = true;
                if ((itStripOther->first - itStrip->first) * (itConnOther->m_logstrip - itConn->m_logstrip) < 0) {
                  mul = -1;
                }
                break;
              }
            }  // otherConnections iter ends
          }    // otherStrip iter ends

          /*
          if (itConn->m_tower==3 && itConn->m_PAC==73 && itConn->m_logplane==4 && detId==637569977){
            std::cout << " Buld cons for strip " << (int)itStrip->first;
            if (otherStripFound)
              std::cout << " other strip " << itStrip->first;
            else 
              std::cout << " no other strip ";
            
            std::cout << std::endl;
            
        }*/

          L1RPCConeBuilder::TCompressedCon nCompConn;
          nCompConn.m_tower = itConn->m_tower;
          nCompConn.m_PAC = itConn->m_PAC;
          nCompConn.m_logplane = itConn->m_logplane;
          nCompConn.m_mul = mul;
          nCompConn.m_offset = itConn->m_logstrip - mul * (signed short)(itStrip->first);
          nCompConn.addStrip(itStrip->first);

          if (otherStripFound) {
          } else {
            //  uncompressedConsLeft[detId][itStrip->first].push_back(*itConn);
            //  ++uncompressedConsAfter;
          }
          (*m_compressedConnectionMap)[detId].push_back(nCompConn);
          ++compressedCons;

        }  // if(!allreadyDone)
      }    // iterate on connections
    }      // iterate on strips
  }        // iterate on chambers

  // 159 -87
  //std::cout << offsetMax << " TT " << offsetMin << std::endl;

  edm::LogInfo("RPCTriggerConfig") << " Compressed: " << compressedCons << " "
                                   << sizeof(L1RPCConeBuilder::TCompressedCon)
                                   << " Uncompressed before: " << uncompressedConsBefore << " "
                                   << sizeof(L1RPCConeBuilder::TStripCon)
                                   << " Uncompressed after: " << uncompressedConsAfter << " "
                                   << sizeof(L1RPCConeBuilder::TStripCon);
  m_connectionsMap = uncompressedConsLeft;
}

createOtherConnections()

void RPCStripsRing::createOtherConnections	(	int	tower,
		int	PACno,
		int	logplane,
		int	logplanesize,
		float	angle
	)

Definition at line 361 of file RPCStripsRing.cc.

References mps_fire::end, Exception, mps_fire::i, isReferenceRing(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, L1RPCConeBuilder::TStripCon::m_logplane, L1RPCConeBuilder::TStripCon::m_logstrip, L1RPCConeBuilder::TStripCon::m_PAC, L1RPCConeBuilder::TStripCon::m_tower, and hgcalTowerProducer_cfi::tower.

                                                                                                            {
  //std::cout << "    OtherCon for " << getRingId() << std::endl;

  if (this->isReferenceRing()) {
    throw cms::Exception("RPCInternal") << " RPCStripsRing::createOtherConnections "
                                        << " called for reference ring \n";
  }

  RPCStripsRing::const_iterator it = this->lower_bound(angle);

  if (it == this->end())
    it = this->begin();

  for (int i = 0; i < logplaneSize / 2; i++) {
    if (it == this->begin())
      it = this->end();  // (m_stripPhiMap.end()--) is ok.

    --it;
  }

  for (int i = 0; i < logplaneSize; i++) {
    if (!it->second.isVirtual()) {
      L1RPCConeBuilder::TStripCon newCon;
      newCon.m_tower = tower;
      newCon.m_PAC = PACno;
      newCon.m_logplane = logplane;
      newCon.m_logstrip = i;
      (*m_connectionsMap)[it->second.m_detRawId][it->second.m_strip].push_back(newCon);
      //std::cout << " Adding other connection " << std::endl;
    }

    ++it;
    if (it == this->end())
      it = this->begin();
  }
}

createRefConnections()

void RPCStripsRing::createRefConnections	(	TOtherConnStructVec &	otherRings,
		int	logplane,
		int	logplaneSize
	)

Definition at line 249 of file RPCStripsRing.cc.

References funct::abs(), angle(), mps_fire::end, Exception, first, getTowerForRefRing(), mps_fire::i, isReferenceRing(), L1RPCConeBuilder::TStripCon::m_logplane, L1RPCConeBuilder::TStripCon::m_logstrip, L1RPCConeBuilder::TStripCon::m_PAC, L1RPCConeBuilder::TStripCon::m_tower, hltrates_dqm_sourceclient-live_cfg::offset, phi, and pi.

                                                                                                        {
  //*
  /*std::cout << "RefCon for " << getRingId() 
       << " (" << getEtaPartition()<<  ")"
       << " tower: " << getTowerForRefRing()
       << " ; connected: "
       << otherRings.size() 
       << std::endl
       << std::endl;    
  //*/

  // XXX - TODO: warning on wrong logplaneSize

  if (!this->isReferenceRing()) {
    throw cms::Exception("RPCInternal") << " RPCStripsRing::createRefConnections "
                                        << " called for non-reference ring \n";
  }

  /*
   if (logplaneSize!=8) {
     throw cms::Exception("RPCInternal") << " RPCStripsRing::createRefConnections "
         << " called for lpSize " << logplaneSize << " \n";
     
   }*/
  const float pi = 3.141592654;
  const float offset = (5. / 360.) * 2 * pi;  // XXX

  //find first reference strip of first PAC (the strip with phi ~= 5deg)
  RPCStripsRing::iterator starEndIt = this->begin();
  while ((++starEndIt)->first < offset)
    ;

  RPCStripsRing::iterator it = starEndIt;
  //--starEndIt;

  float angle = 0;
  int curPACno = -1;
  int curStripNo = 0;
  int curBegStripNo = 0;

  bool firstIter = true;

  while (it != starEndIt || firstIter) {  // iterate over strips

    firstIter = false;
    // New PAC
    if (curStripNo % logplaneSize == 0) {
      ++curPACno;
      curBegStripNo = curStripNo;
      RPCStripsRing::iterator plus8 = it;
      bool skipOccured = false;
      for (int i = 0; i < 7; ++i) {
        ++plus8;
        if (plus8 == this->end()) {
          plus8 = this->begin();
          skipOccured = true;
        }
      }

      // calculate angle
      float phi = it->first;
      float phiP8 = plus8->first;
      if (skipOccured) {
        // phiP8 is negative
        // phi is positive
        // xcheck
        if (phi * phiP8 > 0) {
          throw cms::Exception("RPCInternal") << " RPCStripsRing::createRefConnections phi/phi8 error \n";
        }
        angle = (2 * pi + phiP8 + phi) / 2;
        if (angle > pi) {  // should land on positive side
          angle -= 2 * pi;
        }

        if (std::abs(angle) > pi) {
          throw cms::Exception("RPCInternal") << " RPCStripsRing::createRefConnections "
                                              << " problem with angle calc \n";
        }
      } else {
        angle = (phiP8 + phi) / 2;
      }
      //std::cout << curPACno << " " << phiP8 << " " << phi << " "  << angle << std::endl;

      TOtherConnStructVec::iterator itOt = otherRings.begin();
      for (; itOt != otherRings.end(); ++itOt) {
        itOt->m_it->second.createOtherConnections(
            getTowerForRefRing(), curPACno, itOt->m_logplane, itOt->m_logplaneSize, angle);
      }
    }

    if (!it->second.isVirtual()) {
      L1RPCConeBuilder::TStripCon newCon;
      newCon.m_tower = getTowerForRefRing();
      newCon.m_PAC = curPACno;
      newCon.m_logplane = logplane;
      newCon.m_logstrip = curStripNo - curBegStripNo;
      //std::cout << " Adding con for " << it->second.m_detRawId << std::endl;
      (*m_connectionsMap)[it->second.m_detRawId][it->second.m_strip].push_back(newCon);
      //std::cout << " Adding ref connection " << std::endl;
    }
    ++curStripNo;
    ++it;
    if (it == this->end()) {
      it = this->begin();
    }

  }  // iteration over strips ends

  //std::cout << " refcon: " << curPACno << " PACs" << std::endl;
  //std::cout << "After refCon: " << m_connectionsMap.size() << std::endl;
}

fillWithVirtualStrips()

void RPCStripsRing::fillWithVirtualStrips

(

)

Definition at line 204 of file RPCStripsRing.cc.

References dumpMFGeometry_cfg::delta, mps_fire::end, mps_fire::i, edm::eventsetup::heterocontainer::insert(), createfilelist::int, isReferenceRing(), m_didVirtuals, m_hwPlane, and pi.

                                          {
  if (m_didVirtuals)
    return;
  m_didVirtuals = true;

  const float pi = 3.141592654;
  double dphi = 2.0 * pi / 1152;  // defines angular granulation of strips.

  RPCStripsRing stripsToInsert;

  float delta = 0;
  int stripsToAdd = 0;

  RPCStripsRing::iterator it = this->begin();
  RPCStripsRing::iterator itLast = this->begin();
  for (; it != this->end(); ++it) {
    /*std::cout << it->first << " "
        << it->second.m_detRawId << " "
        << (int)it->second.m_strip << std::endl;
    */

    delta = it->first - itLast->first;
    if (it == itLast ||                                        // skip first loop iteration
        itLast->second.m_detRawId == it->second.m_detRawId ||  // insert strips between two chambers only
        delta < 0) {
      itLast = it;
      continue;
    }

    stripsToAdd = (int)std::floor(delta / dphi) - 1;
    //std::cout << delta << " " << stripsToAdd << std::endl;

    if (isReferenceRing() && m_hwPlane == 6)
      ++stripsToAdd;

    for (int i = 0; i < stripsToAdd; ++i) {
      stripsToInsert[itLast->first + dphi * (i + 1)] = TStrip();
    }

    itLast = it;
  }
  // TODO: check delta between first and last strip in map

  this->insert(stripsToInsert.begin(), stripsToInsert.end());
}

filterOverlapingChambers()

void RPCStripsRing::filterOverlapingChambers

(

)

Definition at line 135 of file RPCStripsRing.cc.

References mps_fire::end, Exception, m_didFiltering, m_hwPlane, and m_region.

                                             {
  if (m_didFiltering)
    return;
  m_didFiltering = true;

  if (m_region != 0 || m_hwPlane != 4)
    return;

  typedef std::map<uint32_t, int> TDetId2StripNo;
  TDetId2StripNo det2stripNo;

  // Note: we begin in middle of first chamber (ch1), we have to handle that
  int ch1BegStrips = 0;  // no of strips on the begining of the map (first=last chamber of map)
  int ch1EndStrips = 0;  // no of strips on the end of the map (first=last chamber of map)

  // How many strips has each chamber?
  RPCStripsRing::iterator it = this->begin();
  uint32_t ch1Det = it->second.m_detRawId;
  for (; it != this->end(); ++it) {
    if (det2stripNo.find(it->second.m_detRawId) == det2stripNo.end()) {
      det2stripNo[it->second.m_detRawId] = 1;  // Add new chamber to a map, set strip cnt to 1
    } else {
      ++det2stripNo[it->second.m_detRawId];  // Increase strip count of a chamber
    }

    if (det2stripNo.size() == 1 && ch1Det == it->second.m_detRawId) {
      ++ch1BegStrips;
    } else if (ch1Det == it->second.m_detRawId) {
      ++ch1EndStrips;
    }
  }

  det2stripNo[ch1Det] -= ch1EndStrips;

  // std::cout << ch1BegStrips << " " << ch1EndStrips << std::endl;

  //TDetId2StripNo::iterator itIds = det2stripNo.begin();
  //for(;itIds!=det2stripNo.end();++itIds){
  //    std::cout << itIds->first << " " << itIds->second << std::endl;
  //  }

  it = this->begin();
  uint32_t lastDet = it->second.m_detRawId;
  while (it != this->end()) {
    if (det2stripNo[it->second.m_detRawId] < 0) {
      throw cms::Exception("RPCInternal") << " RPCStripsRing::filterOverlapingChambers() - no strips left \n";
    }
    if (it->second.m_detRawId == lastDet) {
      --det2stripNo[lastDet];
      ++it;
    } else if (det2stripNo[lastDet] == 0) {  // no more strips left in lastDet, proceed to new det

      if (lastDet == ch1Det) {
        det2stripNo[ch1Det] += ch1EndStrips;
      }

      lastDet = it->second.m_detRawId;
      --det2stripNo[lastDet];
      ++it;
    } else {  // there are still strips in last det, delete current strip
      --det2stripNo[it->second.m_detRawId];
      RPCStripsRing::iterator itErase = it;
      ++it;
      //std::cout << "Removing strip " <<  it->second.m_detRawId << " " << (int)it->second.m_strip << std::endl;
      this->erase(itErase);
    }
  }
}

getCompressedConnectionsMap()

std::shared_ptr<L1RPCConeBuilder::TCompressedConMap> RPCStripsRing::getCompressedConnectionsMap ( )

inline

Definition at line 79 of file RPCStripsRing.h.

References m_compressedConnectionMap.

                                                                                 {
    return m_compressedConnectionMap;
  };

getConnectionsMap()

std::shared_ptr<L1RPCConeBuilder::TConMap> RPCStripsRing::getConnectionsMap ( )

inline

Definition at line 77 of file RPCStripsRing.h.

References m_connectionsMap.

{ return m_connectionsMap; };

getEtaPartition()

int RPCStripsRing::getEtaPartition ( )

inline

Definition at line 72 of file RPCStripsRing.h.

References m_etaPartition.

Referenced by getTowerForRefRing().

{ return m_etaPartition; };

getHwPlane()

int RPCStripsRing::getHwPlane ( )

inline

Definition at line 70 of file RPCStripsRing.h.

References m_hwPlane.

{ return m_hwPlane; };

getRingId() [1/3]

int RPCStripsRing::getRingId ( int  etaPart, int  hwPlane  )

static

Definition at line 76 of file RPCStripsRing.cc.

References funct::abs(), and Validation_hcalonly_cfi::sign.

                                                     {
  int sign = 1;  // positive
  if (etaPart < 0) {
    sign = 0;
  }

  return 1000 * (hwPlane) +        //1...6
         100 * (sign) +            //
         1 * (std::abs(etaPart));  //-17...17
}

getRingId() [2/3]

int RPCStripsRing::getRingId

(

)

Definition at line 87 of file RPCStripsRing.cc.

References m_etaPartition, and m_hwPlane.

Referenced by addRoll(), RPCConeBuilder::buildCones(), getRingId(), and RPCStripsRing().

{ return getRingId(m_etaPartition, m_hwPlane); }

getRingId() [3/3]

int RPCStripsRing::getRingId ( const RPCRoll *  roll )

static

Calculate ringId for this ring.

Definition at line 89 of file RPCStripsRing.cc.

References calculateHwPlane(), RPCGeomServ::eta_partition(), getRingId(), and RPCRoll::id().

                                                {
  RPCDetId detId = roll->id();
  RPCGeomServ grs(detId);
  int etaPartition = grs.eta_partition();
  int hwPlane = calculateHwPlane(roll);

  return getRingId(etaPartition, hwPlane);
}

getTowerForRefRing()

int RPCStripsRing::getTowerForRefRing

(

)

Definition at line 399 of file RPCStripsRing.cc.

References funct::abs(), Exception, getEtaPartition(), isReferenceRing(), runTheMatrix::ret, and Validation_hcalonly_cfi::sign.

Referenced by createRefConnections().

                                      {
  int ret = 0;

  if (!this->isReferenceRing()) {
    throw cms::Exception("RPCInternal") << " RPCStripsRing::getTowerForRefRing() "
                                        << " called for non reference ring \n";
  }

  int etaAbs = std::abs(getEtaPartition());
  if (etaAbs < 8) {
    ret = getEtaPartition();
  } else if (etaAbs > 8) {
    int sign = (getEtaPartition() > 0 ? 1 : -1);
    ret = getEtaPartition() - sign;
  } else {
    throw cms::Exception("RPCInternal") << " RPCStripsRing::getTowerForRefRing() "
                                        << " called for etaPartition 8 \n";
  }

  return ret;
}

isReferenceRing()

bool RPCStripsRing::isReferenceRing ( )

inline

Definition at line 73 of file RPCStripsRing.h.

References m_isReferenceRing.

Referenced by createOtherConnections(), createRefConnections(), fillWithVirtualStrips(), and getTowerForRefRing().

{ return m_isReferenceRing; };

Member Data Documentation

m_compressedConnectionMap

std::shared_ptr<L1RPCConeBuilder::TCompressedConMap> RPCStripsRing::m_compressedConnectionMap

private

Definition at line 93 of file RPCStripsRing.h.

Referenced by compressConnections(), and getCompressedConnectionsMap().

m_connectionsMap

std::shared_ptr<L1RPCConeBuilder::TConMap> RPCStripsRing::m_connectionsMap

private

Definition at line 92 of file RPCStripsRing.h.

Referenced by compressConnections(), and getConnectionsMap().

m_didFiltering

bool RPCStripsRing::m_didFiltering

private

Definition at line 90 of file RPCStripsRing.h.

Referenced by filterOverlapingChambers().

m_didVirtuals

bool RPCStripsRing::m_didVirtuals

private

Definition at line 89 of file RPCStripsRing.h.

Referenced by fillWithVirtualStrips().

m_etaPartition

int RPCStripsRing::m_etaPartition

private

Definition at line 85 of file RPCStripsRing.h.

Referenced by getEtaPartition(), getRingId(), and RPCStripsRing().

m_hwPlane

int RPCStripsRing::m_hwPlane

private

Definition at line 81 of file RPCStripsRing.h.

Referenced by fillWithVirtualStrips(), filterOverlapingChambers(), getHwPlane(), getRingId(), and RPCStripsRing().

m_isReferenceRing

bool RPCStripsRing::m_isReferenceRing

private

Definition at line 88 of file RPCStripsRing.h.

Referenced by isReferenceRing(), and RPCStripsRing().

m_region

int RPCStripsRing::m_region

private

Definition at line 86 of file RPCStripsRing.h.

Referenced by filterOverlapingChambers(), and RPCStripsRing().