---

RPCRingFromRolls Class Reference

Class describng 2PI "rings" constructed from RpcDetId's of the same eta (same as L1RpcRoll in ORCA). More...

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

List of all members.

Public Types
enum	{ IROLL_MAX = 17, NPOS = 3, NHPLANES = 6, TOWERMAX = 16 }
typedef std::vector < RPCConnection >	RPCConnectionsVec
typedef std::map< stripCords, RPCConnectionsVec, stripCordsOp >	RPCLinks
Public Member Functions
bool	addDetId (RPCDetInfo detInfo)
	Adds detId tu the curl.
int	getMaxTower () const
	Returns value of max m_tower.
int	getMinTower () const
	Returns value of min m_tower.
int	getRingFromRollsId () const
	Returns value of max m_tower.
RPCLinks	giveConnections ()
bool	isRefPlane () const
	Returns value of m_isReferencePlane.
int	makeOtherConnections (float phiCenter, int m_tower, int m_PAC)
	Makes connections for Rings not beeing a refernce ones.
int	makeRefConnections (RPCRingFromRolls *)
	Makes connections for reference rings.
void	printContents ()
	prints the contents of a RPCRingFromRolls.
	RPCRingFromRolls ()
	Default constructor.
	~RPCRingFromRolls ()
Private Types
typedef std::map< float, stripCords, phiMapCompare >	GlobalStripPhiMap
typedef std::map< uint32_t, RPCDetInfo >	RPCDetInfoMap
typedef std::map< float, uint32_t >	RPCDetInfoPhiMap
Private Member Functions
void	doVirtualStrips ()
	Fills strip map with virtual strips.
void	filterMixedStrips ()
	Filters strip.
int	giveLogPlaneForTower (int m_tower)
	Calculates m_logplane.
void	setRefPlane ()
	Checks and sets value of m_isReferencePlane.
void	updatePhiStripsMap (RPCDetInfo detInfo)
	Updates m_stripPhiMap.
Private Attributes
int	m_curlId
	this curlId
bool	m_didFiltering
bool	m_didVirtuals
int	m_globRoll
int	m_hwPlane
	Hardware plane no.
bool	m_isDataFresh
	Defines if data has real world contents.
bool	m_isRefPlane
	tells if detIds from this curl form a reference plane
RPCLinks	m_links
int	m_physStripsInRingFromRolls
	m_Number of existing strips in curl;
int	m_region
	Region no - 0 for barell +-1 for endcaps.
int	m_ring
	Wheel number for barell, ring number for endcaps.
int	m_roll
	roll no
RPCDetInfoMap	m_RPCDetInfoMap
	Stores all DetId`s of a curl.
RPCDetInfoPhiMap	m_RPCDetPhiMap
	Stores DetId`s rawId in a phi order.
GlobalStripPhiMap	m_stripPhiMap
int	m_towerMax
	The highest m_tower no. to which curl contributes.
int	m_towerMin
	The lowest m_tower no. to which curl contributes.
int	m_virtStripsInRingFromRolls
	m_Number of virtual strips in curl;
Static Private Attributes
static const unsigned int	m_LOGPLANE_SIZE [17][6]
static const int	m_mrlogp [RPCRingFromRolls::IROLL_MAX+1][RPCRingFromRolls::NHPLANES][RPCRingFromRolls::NPOS]
static const int	m_mrtow [RPCRingFromRolls::IROLL_MAX+1][RPCRingFromRolls::NHPLANES][RPCRingFromRolls::NPOS]
Friends
class	RPCVHDLConeMaker
Classes
struct	phiMapCompare
struct	RPCConnection
struct	stripCords
struct	stripCordsOp

---

Detailed Description

Class describng 2PI "rings" constructed from RpcDetId's of the same eta (same as L1RpcRoll in ORCA).

Author:

Tomasz Fruboes

Definition at line 17 of file RPCRingFromRolls.h.

---

Member Typedef Documentation

typedef std::map<float, stripCords, phiMapCompare> RPCRingFromRolls::GlobalStripPhiMap [private]

Definition at line 126 of file RPCRingFromRolls.h.

typedef std::vector<RPCConnection> RPCRingFromRolls::RPCConnectionsVec

Definition at line 49 of file RPCRingFromRolls.h.

typedef std::map<uint32_t, RPCDetInfo> RPCRingFromRolls::RPCDetInfoMap [private]

Definition at line 98 of file RPCRingFromRolls.h.

typedef std::map<float, uint32_t> RPCRingFromRolls::RPCDetInfoPhiMap [private]

Definition at line 102 of file RPCRingFromRolls.h.

typedef std::map<stripCords, RPCConnectionsVec, stripCordsOp> RPCRingFromRolls::RPCLinks

Definition at line 50 of file RPCRingFromRolls.h.

---

Member Enumeration Documentation

anonymous enum

Enumerator:

IROLL_MAX
NPOS
NHPLANES
TOWERMAX

Definition at line 22 of file RPCRingFromRolls.h.

{ IROLL_MAX = 17, NPOS = 3, NHPLANES  = 6, TOWERMAX = 16 };  

---

Constructor & Destructor Documentation

RPCRingFromRolls::RPCRingFromRolls

(

)

Default constructor.

Definition at line 19 of file RPCRingFromRolls.cc.

References m_curlId, m_didFiltering, m_didVirtuals, m_globRoll, m_hwPlane, m_isDataFresh, m_isRefPlane, m_physStripsInRingFromRolls, m_region, m_ring, m_roll, m_towerMax, m_towerMin, and m_virtStripsInRingFromRolls.

{ 
  m_towerMin = 0;
  m_towerMax = 0;
  m_hwPlane = 0;
  m_region = 0;
  m_ring = 0;
  m_roll = 0;
  m_curlId = 0;
  m_globRoll = 0;
  
  m_physStripsInRingFromRolls = 0;
  m_virtStripsInRingFromRolls = 0;
  
  m_isRefPlane = false;
  m_isDataFresh = true;
  m_didVirtuals = false; 
  m_didFiltering = false;
  
}

RPCRingFromRolls::~RPCRingFromRolls

(

)

Definition at line 40 of file RPCRingFromRolls.cc.

{ }

---

Member Function Documentation

bool RPCRingFromRolls::addDetId

(

RPCDetInfo

detInfo

)

Adds detId tu the curl.

Todo:

Implement check if added detInfo _does_ belong to this RPCRingFromRolls

Todo:

check if added detInfo is allready in map

Todo:

Implement xcheck if towers are calculated properly

Definition at line 51 of file RPCRingFromRolls.cc.

References funct::abs(), RPCDetInfo::getGlobRollNo(), RPCDetInfo::getHwPlane(), RPCDetInfo::getPhi(), RPCDetInfo::getRegion(), RPCDetInfo::getRing(), RPCDetInfo::getRingFromRollsId(), RPCDetInfo::getRoll(), i, m_curlId, m_globRoll, m_hwPlane, m_isDataFresh, m_mrtow, m_region, m_ring, m_roll, m_RPCDetInfoMap, m_RPCDetPhiMap, m_towerMax, m_towerMin, RPCDetInfo::rawId(), setRefPlane(), pyDBSRunClass::temp, and updatePhiStripsMap().

Referenced by RPCTriggerGeo::addDet().

                                                 {
  
  if(m_isDataFresh) { // should be done in constructor...
    
//    m_towerMin=detInfo.getMinTower();
    //m_towerMax=detInfo.getMaxTower();
    
    m_hwPlane = detInfo.getHwPlane();
    m_region = detInfo.getRegion();
    m_ring = detInfo.getRing();
    m_roll = detInfo.getRoll();
    m_curlId = detInfo.getRingFromRollsId();
    m_globRoll = detInfo.getGlobRollNo();
    
    setRefPlane();
    
    m_towerMin=-1;
    m_towerMax=-1;
    
    for (int i=0; i < 3; i++){
      int ttemp = m_mrtow [std::abs(m_globRoll)] [m_hwPlane-1][i];
      if (  ((m_towerMin < 0)||(m_towerMax < 0)) && (ttemp >= 0)   ){ 
        m_towerMin = ttemp;
        m_towerMax = ttemp;
      }
      if (ttemp >= 0) {
        if (ttemp < m_towerMin)
          m_towerMin = ttemp;
        if (ttemp > m_towerMax)
          m_towerMax = ttemp;
      }
    }
    
    if (m_globRoll < 0){
      int temp = m_towerMin;
      m_towerMin = -m_towerMax;
      m_towerMax = -temp; // swap is needed (!)
    }
    
    m_isDataFresh=false;
  } 
  /*
  else 
  {
    int min = detInfo.getMinTower();
    int max = detInfo.getMinTower();
    if (min < m_towerMin)
      min = m_towerMin;
    if (max > m_towerMax)
      max = m_towerMax;
  }
  */
  
  updatePhiStripsMap(detInfo);
  
  m_RPCDetInfoMap[detInfo.rawId()]=detInfo; 
  m_RPCDetPhiMap[detInfo.getPhi()]=detInfo.rawId();
 
  
  return true;
}

void RPCRingFromRolls::doVirtualStrips

(

)

[private]

Fills strip map with virtual strips.

Bug:

RingFromRolls 4102 has diffrent no. of virtuals than 4002.

Todo:

Improve this function. Some curls seem to have wrong number of virtuals

Todo:

Possible xcheck - check if virtual and physical strips sum to 1152 or more - only for ref curl

Todo:

Implement check if we have symetry (x1xx vs x0xx; whell +y vs -y)

Definition at line 530 of file RPCRingFromRolls.cc.

References cmssw-higgs-4mu::firstRun, RPCDetInfo::getMaxPhi(), RPCDetInfo::getMinPhi(), getRingFromRollsId(), i, int, isRefPlane(), it, RPCRingFromRolls::stripCords::m_detRawId, m_didVirtuals, m_hwPlane, RPCRingFromRolls::stripCords::m_isVirtual, m_physStripsInRingFromRolls, m_RPCDetInfoMap, m_RPCDetPhiMap, RPCRingFromRolls::stripCords::m_stripNo, m_stripPhiMap, m_virtStripsInRingFromRolls, and pi.

Referenced by makeOtherConnections(), and makeRefConnections().

                                      {
  
  if (m_didVirtuals){ // run once
    return;
  }
  m_didVirtuals=true;
  
  const float pi = 3.141592654;

  bool firstRun=true;
  GlobalStripPhiMap newVirtualStrips;
  
  double dphi=2.0*pi/1152;  // defines angular granulation of strips.
  
  float phiMinNext=0, phiMaxNext=0, phiMinLast=0,phiMaxLast=0;
  uint32_t rawDetIDLast=0,rawDetIDNext=0;
  
  //now we iterate over all dets adding virtual strips begining from phiMax+dphi
  RPCDetInfoPhiMap::const_iterator it;
  for (it=m_RPCDetPhiMap.begin(); it != m_RPCDetPhiMap.end(); it++){
    
    RPCDetInfo *det = &m_RPCDetInfoMap[it->second];
    
    /*
      In first iteration we dont have *Last and *Next values. We must suck them
      in 'artificial' way
    */
    if(firstRun){
      phiMinNext = det->getMinPhi();
      phiMaxNext = det->getMaxPhi();
      rawDetIDNext=it->second; // not really needed
      
      RPCDetInfoPhiMap::const_reverse_iterator itTemp = m_RPCDetPhiMap.rbegin();
      RPCDetInfo *detTemp = &m_RPCDetInfoMap[itTemp->second];
      phiMinLast=detTemp->getMinPhi();
      phiMaxLast=detTemp->getMaxPhi();
      rawDetIDLast= itTemp->second;
      firstRun=false;
    }
    else {
      rawDetIDLast=rawDetIDNext;
      rawDetIDNext=it->second;
      phiMinLast = phiMinNext;
      phiMaxLast = phiMaxNext;
      phiMinNext = det->getMinPhi();
      phiMaxNext = det->getMaxPhi();
    }
    
    float delta = phiMinNext - phiMaxLast;
    delta += 2*pi*(delta<-5);// (-5) Fixes problem of overlaping chambers
    
    if (delta<0)
      continue;

    int stripsToAdd = (int)std::floor(delta/dphi)-1;
    if ( isRefPlane() && m_hwPlane==6)
       stripsToAdd++; 
    
    stripCords sc;
    sc.m_detRawId = rawDetIDLast;
    sc.m_stripNo = 0;
    sc.m_isVirtual = true;
    for (int i = 0;i<stripsToAdd;i++){
        sc.m_stripNo--;
        newVirtualStrips[phiMaxLast+dphi*(i+1)]=sc;
        m_virtStripsInRingFromRolls++;
    }
  } // loop over dets end 
  
  
  if ( (isRefPlane()) && (m_virtStripsInRingFromRolls+m_physStripsInRingFromRolls!=1152)){
    
    edm::LogError("RPCTrigger")<<"Trouble. Reference curl " << getRingFromRollsId() 
        << " has " << m_virtStripsInRingFromRolls+m_physStripsInRingFromRolls << " strips."
        << " (v=" << m_virtStripsInRingFromRolls 
        << ";p=" << m_physStripsInRingFromRolls <<")";         
  }
  
  m_stripPhiMap.insert(newVirtualStrips.begin(),newVirtualStrips.end() );
}

void RPCRingFromRolls::filterMixedStrips

(

)

[private]

Filters strip.

Definition at line 436 of file RPCRingFromRolls.cc.

References find(), cmssw-higgs-4mu::firstRun, it, m_didFiltering, m_hwPlane, m_region, m_RPCDetInfoMap, m_stripPhiMap, and phi.

Referenced by makeOtherConnections().

                                        {

  if (m_didFiltering){ // run once
    return;
  }
  
  m_didFiltering=true;
  
  if (m_region != 0 || m_hwPlane != 4) 
    return;
  
//  std::cout << "Another filtering" << std::endl;
  
  RPCRingFromRolls::phiMapCompare compare;
  /*
                  // compare(a,b) <=>  (a<b)
  if (compare(lowestPhiMap[scTemp.m_detRawId],it->first))
  {
    lowestPhiMap[scTemp.m_detRawId]=it->first;
  }
  */
  /*  
  std::map<uint32_t,float> phiCutMap;
  //Iterate over the chambers. For each chamber calculate a cut in phi
  RPCDetInfoPhiMap::const_iterator it = m_RPCDetPhiMap.begin();
  for(;it!=m_RPCDetPhiMap.end();it++){
  
  
}*/
  
  // filter strips
  
  uint32_t curRawID = 0, firstRawID = 0;
  bool firstRun=true;
  float phiCut = 0;
  
  std::vector<uint32_t> procChambers; // Stores rawIds of chambers that were processed
    
  GlobalStripPhiMap::iterator it = m_stripPhiMap.begin();
  for(;it!=m_stripPhiMap.end();it++){
    
    if(firstRun){
      firstRun=false;
      curRawID = it->second.m_detRawId;
      phiCut = m_RPCDetInfoMap[curRawID].getMaxPhi();
      firstRawID = curRawID; // First chamber is processed twice - at begin at the end of processing
    } 
    else {
      float phi = it->first;
      uint32_t rawID = it->second.m_detRawId;
  //    std::cout << rawID << " " << phi << " " << phiCut << std::endl;
      if (rawID!=curRawID){ // Region of mixed strips
        //if (procChambers.find(rawID)!=procChambers.end()){
        if (std::find(procChambers.begin(),procChambers.end(),rawID)!=procChambers.end()){
          if (rawID == firstRawID && procChambers.size() != 1) {} //do nothing for first processed chamber when  
                                                                  // proccesing it second time at the end
          else
            throw RPCException("The chamber should be allready processed");
        }
        if (compare(phi,phiCut)){  // compare(a,b) <=>  (a<b)
          //GlobalStripPhiMap::iterator ittemp = it;
          m_stripPhiMap.erase(it++);// delete strip pointed by it (not by it++ !)
          //ittemp--; // 
          //it=ittemp; 
          it--; // go to prev. element - loop will inc. it for us
        } 
        else { // Strip is ok - start new chamber
          procChambers.push_back(curRawID); // Store info, that the chamber was proccessd
          curRawID=rawID; // save new chamber id
          phiCut = m_RPCDetInfoMap[curRawID].getMaxPhi(); // get new cut
        }
      
      }
        
        
    }
  
  
  }
  
  

}

int RPCRingFromRolls::getMaxTower

(

)

const

Returns value of max m_tower.

Definition at line 639 of file RPCRingFromRolls.cc.

References m_towerMax.

Referenced by makeOtherConnections().

int RPCRingFromRolls::getMinTower

(

)

const

Returns value of min m_tower.

Definition at line 638 of file RPCRingFromRolls.cc.

References m_towerMin.

Referenced by makeOtherConnections().

int RPCRingFromRolls::getRingFromRollsId

(

)

const

Returns value of max m_tower.

Definition at line 640 of file RPCRingFromRolls.cc.

References m_curlId.

Referenced by doVirtualStrips(), and makeOtherConnections().

RPCRingFromRolls::RPCLinks RPCRingFromRolls::giveConnections

(

)

Definition at line 260 of file RPCRingFromRolls.cc.

References m_links.

                                                          {
  
  return m_links;
}

int RPCRingFromRolls::giveLogPlaneForTower

(

int

tower

)

[private]

Calculates m_logplane.

Todo:

Clean this method

Definition at line 370 of file RPCRingFromRolls.cc.

References funct::abs(), i, m_globRoll, m_hwPlane, m_mrlogp, and m_mrtow.

Referenced by makeOtherConnections(), and makeRefConnections().

                                                   {
    
  int logplane = -1;
  for (int i=0;i<3;i++){
    int ttemp = m_mrtow [std::abs(m_globRoll)] [m_hwPlane-1][i];
    if ( ttemp == std::abs(tower) )
      logplane = m_mrlogp [std::abs(m_globRoll)] [m_hwPlane-1][i];
  }

  return logplane;
}

bool RPCRingFromRolls::isRefPlane

(

)

const

Returns value of m_isReferencePlane.

Definition at line 637 of file RPCRingFromRolls.cc.

References m_isRefPlane.

Referenced by doVirtualStrips(), makeOtherConnections(), makeRefConnections(), and printContents().

int RPCRingFromRolls::makeOtherConnections	(	float	phiCenter,
		int	m_tower,
		int	m_PAC
	)

Makes connections for Rings not beeing a refernce ones.

Definition at line 120 of file RPCRingFromRolls.cc.

References funct::abs(), doVirtualStrips(), filterMixedStrips(), getMaxTower(), getMinTower(), getRingFromRollsId(), giveLogPlaneForTower(), i, isRefPlane(), it, LogDebug, m_curlId, m_links, RPCRingFromRolls::RPCConnection::m_logplane, m_LOGPLANE_SIZE, RPCRingFromRolls::RPCConnection::m_PAC, RPCRingFromRolls::RPCConnection::m_posInCone, m_stripPhiMap, and RPCRingFromRolls::RPCConnection::m_tower.

Referenced by makeRefConnections().

                                                                                 {
  
  if (isRefPlane()){
    edm::LogError("RPCTrigger") << "Trouble. RingFromRolls " << m_curlId
        << " is a reference curl. makeOtherConnections() is not good for reference curls";
    return -1;
  }

  if ( (m_tower < getMinTower()) || (m_tower > getMaxTower()))  // This curl not contributes to this m_tower.
    return 0;

  doVirtualStrips();
  filterMixedStrips(); // Fixes overlaping chambers problem
  
  RPCConnection newConnection;
  newConnection.m_PAC = m_PAC;
  newConnection.m_tower = m_tower; 
  newConnection.m_logplane = giveLogPlaneForTower(newConnection.m_tower);
    
  if (newConnection.m_logplane < 0){
    
    LogDebug("RPCTrigger") << "Trouble. RingFromRolls "<< getRingFromRollsId()
        << " wants to contribute to m_tower " << m_tower;
       
    return -1;
  }
  
  int logplaneSize = m_LOGPLANE_SIZE[std::abs(newConnection.m_tower)][newConnection.m_logplane-1];
  //int logplaneSize = m_LOGPLANE_SIZE[std::abs(newConnection.m_tower)][m_hwPlane-1];
  
  if ((logplaneSize > 72)||(logplaneSize < 1)){
    LogDebug("RPCTrigger") << "Trouble. RingFromRolls "<< getRingFromRollsId()
        << " wants to have wrong strips number (" << logplaneSize<< ")"
        << " in plane " << newConnection.m_logplane
        << " in m_tower " << newConnection.m_tower;
        
    return -1;
  }
  
      
  // \note The  m_stripPhiMap is sorted in a special way (see header)
  GlobalStripPhiMap::const_iterator it = m_stripPhiMap.lower_bound(phiCentre);
  if (it==m_stripPhiMap.end()){
      it == m_stripPhiMap.begin();
  }
    
  
  for (int i=0; i < logplaneSize/2; i++){ 
    if (it==m_stripPhiMap.begin())
      it=m_stripPhiMap.end();  // (m_stripPhiMap.end()--) is ok.
    it--;
  }
  
  // In barell station 4 (farrest station) chambers overlap in phi.
  // This is the q&d method to avoid mixing of strips in logplanes
  /*
  if (m_region == 0 && m_hwPlane == 4){
               
      std::map<uint32_t,GlobalStripPhiMap> chambersMap;
      std::map<uint32_t,float> lowestPhiMap; // For finding lowest phi in each chamber
      
      for (int i=0; i < logplaneSize; i++){
          stripCords scTemp = it->second;
          (chambersMap[scTemp.m_detRawId])[it->first]=it->second;
          //aMap[it->first]=it->second;
          
          if (lowestPhiMap.find(scTemp.m_detRawId)==lowestPhiMap.end())// New detID
            {
               lowestPhiMap[scTemp.m_detRawId]=it->first;                                               
            } 
          else // detId allready in map
            {
               RPCRingFromRolls::phiMapCompare compare;
                  // compare(a,b) <=>  (a<b)
               if (compare(lowestPhiMap[scTemp.m_detRawId],it->first))
                 {
                   lowestPhiMap[scTemp.m_detRawId]=it->first;
                 }
            }
        it++;
        if (it==m_stripPhiMap.end())
          it=m_stripPhiMap.begin();
      } // for (int i=0; i < logplaneSize; i++) ends
      

      
      // sort chambers in phi
      std::map<float,uint32_t,phiMapCompare> chambersIds;
      
      std::map<uint32_t,float>::const_iterator phiIt =  lowestPhiMap.begin();
      for (;phiIt!=lowestPhiMap.end();phiIt++){
          chambersIds[phiIt->second]=phiIt->first;
      }
      
      // Now we can iterate over the strips in each chamber      
      std::map<float,uint32_t,phiMapCompare>::const_iterator chambersIt = chambersIds.begin();
      int curStripInConeNo = 0;
      for (;chambersIt!=chambersIds.end();chambersIt++){
          GlobalStripPhiMap aMap = chambersMap[chambersIt->second];
          
          GlobalStripPhiMap::const_iterator stripIt = aMap.begin();
          for(;stripIt!=aMap.end();stripIt++){
             //stripCords scTemp = stripIt->second;
             newConnection.m_posInCone = curStripInConeNo;
             m_links[stripIt->second].push_back(newConnection);
             curStripInConeNo++;
          }
      }
  
}
  else // Normal, non overlaping chamber
  {
      for (int i=0; i < logplaneSize; i++){
        stripCords scTemp = it->second;
        newConnection.m_posInCone = i;
        m_links[it->second].push_back(newConnection);
    
        it++;
        if (it==m_stripPhiMap.end())
          it=m_stripPhiMap.begin();
      }
  }
  */
  
  // 
  for (int i=0; i < logplaneSize; i++){
    stripCords scTemp = it->second;
    newConnection.m_posInCone = i;
    m_links[it->second].push_back(newConnection);
    
    it++;
    if (it==m_stripPhiMap.end())
      it=m_stripPhiMap.begin();
  }

    
  return 0;
  
}

int RPCRingFromRolls::makeRefConnections

(

RPCRingFromRolls *

otherRingFromRolls

)

Makes connections for reference rings.

Todo:

Calculate centrePhi in more elegant way

Note:

Conevention: first strip in m_logplane is no. 0

Definition at line 273 of file RPCRingFromRolls.cc.

References doVirtualStrips(), giveLogPlaneForTower(), i, isRefPlane(), it, m_curlId, m_links, RPCRingFromRolls::RPCConnection::m_logplane, RPCRingFromRolls::RPCConnection::m_PAC, RPCRingFromRolls::RPCConnection::m_posInCone, m_stripPhiMap, RPCRingFromRolls::RPCConnection::m_tower, m_towerMin, makeOtherConnections(), max, min, and pi.

                                                                            {
  
  if (!isRefPlane()){
    
    edm::LogError("RPCTrigger") << "Trouble. RingFromRolls " << m_curlId 
        << " is not a reference curl. makeRefConnections() is good only for reference curls";
        
    return -1;
  }
  
  doVirtualStrips();
  
  int curPacNo=-1;  // pacs are numbered from 0 to 143 (there is curPacNo++ in first iteration)
  int curStripNo=0;
  int curBegStripNo=0;
  
  
  GlobalStripPhiMap::const_iterator it;    
  // \note The  m_stripPhiMap is sorted in a special way (see header)
  for (it=m_stripPhiMap.begin(); it != m_stripPhiMap.end(); it++){
    
    if (curStripNo%8==0)    // new pac
    {
      curPacNo++;
      curBegStripNo=curStripNo;
      
      GlobalStripPhiMap::const_iterator plus8 = it;    
      for (int i=0;i<7;i++){  // i<7 (!) - there are 8 strips in ref plane !! i<8 would be wrong
        plus8++;
        if (plus8==m_stripPhiMap.end()){ // \note The  m_stripPhiMap is sorted in a special way (see header)
          plus8--;
          break;
        }
      }
      
      float phi1 = it->first;
      float phi2 = plus8->first;
      float centrePhi = (phi1+phi2)/2;
      
      if (std::min(phi1,phi2) < 1 && std::max(phi1,phi2) > 5)// to avoid (0+2pi)/2 = pi (should be = 0 )
      {
        const float pi = 3.141592654;
        centrePhi -= pi;
        if (centrePhi<0)
          centrePhi += 2*pi;
      }
      otherRingFromRolls->makeOtherConnections(centrePhi, m_towerMin, curPacNo);// Make Connections within the other curl
    } // new pac end
    
    RPCConnection newConnection;
    newConnection.m_PAC = curPacNo;
    newConnection.m_tower = m_towerMin; // For refRingFromRolls m_towerMin and m_towerMax are equal
    newConnection.m_posInCone = curStripNo-curBegStripNo;  // Conevention: first strip in m_logplane is no. 0 
    
    newConnection.m_logplane = giveLogPlaneForTower(newConnection.m_tower);
  
    if (newConnection.m_logplane < 0){
      
      edm::LogError("RPCTrigger") << "Trouble. Strip " << it->second.m_stripNo
          << " of det " << it->second.m_detRawId
          << " has negative m_logplane";
      
    }
    
    if (m_links.find(it->second)==m_links.end() ){// new strip in map
      m_links[it->second].push_back(newConnection);
    } 
    else {  // strip allready in map, we should have the same connections
      
      RPCConnectionsVec existingConnection = m_links[it->second];
      if ( (existingConnection[0].m_PAC != newConnection.m_PAC ) ||  
            (existingConnection[0].m_tower != newConnection.m_tower ) ||
            (existingConnection[0].m_logplane != newConnection.m_logplane ) ||
            (existingConnection[0].m_posInCone != newConnection.m_posInCone ) )
      {
        
        edm::LogError("RPCTrigger") << "Trouble. Strip " << it->second.m_stripNo
            << " of reference det " << it->second.m_detRawId
            << " has multiple connections";
            
      }
      
    } // end check if strip allready in map
    curStripNo++;
  }// end loop over strips
  
  
  return 0;    
}

void RPCRingFromRolls::printContents

(

)

prints the contents of a RPCRingFromRolls.

Definition at line 732 of file RPCRingFromRolls.cc.

References isRefPlane(), LogDebug, m_globRoll, m_hwPlane, m_links, m_physStripsInRingFromRolls, m_RPCDetInfoMap, m_towerMax, m_towerMin, and m_virtStripsInRingFromRolls.

                                     {

  /*
  if (getRingFromRollsId()==71001){

    GlobalStripPhiMap::const_iterator it;
    for (it=m_stripPhiMap.begin(); it != m_stripPhiMap.end(); it++){
      LogDebug("RPCTrigger") << "phi" << it->first
          << " m_stripNo=" << (it->second).m_stripNo
          << " m_isVirtual=" << (it->second).m_isVirtual
    }
  }//*/

  if (isRefPlane())
    LogDebug("RPCTrigger") << " Reference plane:";
  else
    LogDebug("RPCTrigger") << " Normal plane:";
  
  LogDebug("RPCTrigger") << "No. of DetInfo's " << m_RPCDetInfoMap.size()
      << "; towers: min= " << m_towerMin 
      << " max= " << m_towerMax 
      << "|globRoll= " << m_globRoll
      << " hwPlane= " << m_hwPlane
      << "|strips:"
      << " phys= " << m_physStripsInRingFromRolls
      << " virt= " << m_virtStripsInRingFromRolls
      << " all= " << m_virtStripsInRingFromRolls+m_physStripsInRingFromRolls
      << "|strips conneced: " << m_links.size(); // with or without virtual strips. check it, it may have changed
  
  
  /*
  RPCDetInfoPhiMap::const_iterator it;
  for (it = m_RPCDetPhiMap.begin(); it != m_RPCDetPhiMap.end(); it++){
  
    //LogDebug("RPCTrigger")
    //    << "Phi: " << it->first << " "
    //   << "detId: " << it->second  <<
  
    
    m_RPCDetInfoMap[it->second].printContents();
        
  }
  //*/
  /*
  GlobalStripPhiMap::const_iterator it;
  for (it = m_stripPhiMap.begin(); it != m_stripPhiMap.end(); it++){
  LogDebug("RPCTrigger")
        << "Phi: " << it->first 
        << " detId: " << it->second.m_detRawId 
        << " m_stripNo: " << it->second.m_stripNo  << 
  }//*/

}

void RPCRingFromRolls::setRefPlane

(

)

[private]

Checks and sets value of m_isReferencePlane.

Note:

hwPlane numbering is non trivial

Definition at line 618 of file RPCRingFromRolls.cc.

References funct::abs(), m_curlId, m_hwPlane, m_isRefPlane, m_region, and m_ring.

Referenced by addDetId().

                                   {
  
  m_isRefPlane = false;
  if (m_region == 0 && std::abs(m_ring)<2 && m_hwPlane == 2) // for barell wheel -1,0,1 refplane is hwPlane=2
    m_isRefPlane = true;
  else if (m_region == 0 && std::abs(m_ring)==2 && m_hwPlane == 6) // for barell wheel -2,2 refplane is hwPlane=6
    m_isRefPlane = true;
  else if (m_region != 0 && m_hwPlane == 2) // for endcaps
    m_isRefPlane = true;
  
  if( m_curlId == 2008 || m_curlId == 2108) //exception: endcaps;hwplane 2;farest roll from beam
    m_isRefPlane = false;
}

void RPCRingFromRolls::updatePhiStripsMap

(

RPCDetInfo

detInfo

)

[private]

Updates m_stripPhiMap.

Definition at line 388 of file RPCRingFromRolls.cc.

References RPCDetInfo::getRPCStripPhiMap(), it, RPCRingFromRolls::stripCords::m_detRawId, RPCRingFromRolls::stripCords::m_isVirtual, m_physStripsInRingFromRolls, RPCRingFromRolls::stripCords::m_stripNo, m_stripPhiMap, HLT_VtxMuL3::maxPhi, HLT_VtxMuL3::minPhi, phi, and RPCDetInfo::rawId().

Referenced by addDetId().

                                                           {
  
  uint32_t rawId = detInfo.rawId();
  
  RPCDetInfo::RPCStripPhiMap sourceMap = detInfo.getRPCStripPhiMap();
  RPCDetInfo::RPCStripPhiMap::const_iterator it;
  
  float maxPhi=0, minPhi=0;
  int maxStripNo=0;
  bool firstIt=true;
  
  for (it = sourceMap.begin(); it != sourceMap.end(); it++){

    float phi = it->second;
    stripCords sc;
    sc.m_stripNo = it->first;
    sc.m_detRawId = rawId;
    sc.m_isVirtual = false;
    m_stripPhiMap[phi]=sc;
    
    if(firstIt){
      maxPhi=phi;
      minPhi=phi;
      maxStripNo = sc.m_stripNo;
      firstIt=false;          
    } 
    
    if(phi < minPhi){
      minPhi=phi;
    }
    if(phi > maxPhi){
      maxPhi=phi;
    }
    
    if (maxStripNo<sc.m_stripNo)
      maxStripNo=sc.m_stripNo;
    
    m_physStripsInRingFromRolls++;
  }// loop end
  
}

---

Friends And Related Function Documentation

friend class RPCVHDLConeMaker [friend]

Definition at line 20 of file RPCRingFromRolls.h.

---

Member Data Documentation

int RPCRingFromRolls::m_curlId [private]

this curlId

Definition at line 84 of file RPCRingFromRolls.h.

Referenced by addDetId(), getRingFromRollsId(), makeOtherConnections(), makeRefConnections(), RPCRingFromRolls(), and setRefPlane().

bool RPCRingFromRolls::m_didFiltering [private]

Definition at line 93 of file RPCRingFromRolls.h.

Referenced by filterMixedStrips(), and RPCRingFromRolls().

bool RPCRingFromRolls::m_didVirtuals [private]

Definition at line 92 of file RPCRingFromRolls.h.

Referenced by doVirtualStrips(), and RPCRingFromRolls().

int RPCRingFromRolls::m_globRoll [private]

Definition at line 88 of file RPCRingFromRolls.h.

Referenced by addDetId(), giveLogPlaneForTower(), printContents(), and RPCRingFromRolls().

int RPCRingFromRolls::m_hwPlane [private]

Hardware plane no.

Definition at line 80 of file RPCRingFromRolls.h.

Referenced by addDetId(), doVirtualStrips(), filterMixedStrips(), giveLogPlaneForTower(), printContents(), RPCRingFromRolls(), and setRefPlane().

bool RPCRingFromRolls::m_isDataFresh [private]

Defines if data has real world contents.

Definition at line 90 of file RPCRingFromRolls.h.

Referenced by addDetId(), and RPCRingFromRolls().

bool RPCRingFromRolls::m_isRefPlane [private]

tells if detIds from this curl form a reference plane

Definition at line 91 of file RPCRingFromRolls.h.

Referenced by isRefPlane(), RPCRingFromRolls(), and setRefPlane().

RPCLinks RPCRingFromRolls::m_links [private]

Definition at line 94 of file RPCRingFromRolls.h.

Referenced by giveConnections(), makeOtherConnections(), makeRefConnections(), and printContents().

const unsigned int RPCRingFromRolls::m_LOGPLANE_SIZE [static, private]

Initial value:

 {

 
           {72, 56,  8, 40, 40, 24}, 
           {72, 56,  8, 40, 40, 24}, 
           {72, 56,  8, 40, 40, 24}, 
           {72, 56,  8, 40, 40, 24}, 
           {72, 56,  8, 40, 40, 24}, 
           {72, 56, 40,  8, 40, 24}, 
           {56, 72, 40,  8, 24,  0}, 
           {72, 56, 40,  8, 24,  0}, 
           {72, 24, 40,  8,  0,  0}, 
           {72,  8, 40,  0,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}, 
           {72,  8, 40, 24,  0,  0}  

}

Definition at line 131 of file RPCRingFromRolls.h.

Referenced by makeOtherConnections(), RPCVHDLConeMaker::writeHeader(), RPCVHDLConeMaker::writePatternsDef(), and RPCVHDLConeMaker::writeXMLPatternsDef().

const int RPCRingFromRolls::m_mrlogp [static, private]

Initial value:

{


  {  {0,0,0},   {3,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,-1},  {3,0,0},   {5,5,0},   {6,6,0},   {2,2,-2},  {4,4,0} },  
  {  {1,1,1},   {3,0,0},   {5,5,0},   {6,6,0},   {2,2,2},   {4,4,0} },  
  {  {0,0,0},   {3,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,-5},  {3,0,0},   {5,5,5},   {6,6,0},   {2,2,0},   {4,4,0} },  
  {  {1,1,1},   {3,-3,3},  {5,5,0},   {6,0,0},   {2,2,2},   {4,0,0} },  
  {  {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {4,0,0} },  
  {  {1,1,0},   {3,-3,0},  {5,5,0},   {6,6,0},   {2,2,0},   {4,0,0} },  
  {  {0,5,0},   {0,0,0},   {3,-5,0},  {4,0,0},   {0,0,0},   {0,0,0} },  
  {  {5,3,0},   {4,0,0},   {3,-5,3},  {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {3,0,0},   {2,0,0},   {3,3,0},   {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {1,0,0},   {2,0,0},   {3,3,0},   {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,0},   {2,0,0},   {3,3,0},   {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,0},   {2,0,0},   {3,3,0},   {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,0},   {2,0,0},   {3,3,0},   {4,4,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,0},   {2,0,0},   {3,3,0},   {4,0,0},   {0,0,0},   {0,0,0} },  
  {  {1,1,0},   {2,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0} },  
  {  {1,0,0},   {2,0,0},   {0,0,0},   {0,0,0},   {0,0,0},   {0,0,0} }   
}

Definition at line 130 of file RPCRingFromRolls.h.

Referenced by giveLogPlaneForTower().

const int RPCRingFromRolls::m_mrtow [static, private]

Initial value:

{


  { {-1,-1,-1},{ 0,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1} },   
  { { 0, 1,-2},{ 1,-1,-1},{ 0, 1,-1},{ 0, 1,-1},{ 0, 1,-2},{ 0, 1,-1} },   
  { { 2, 3, 4},{ 2,-1,-1},{ 1, 2,-1},{ 1, 2,-1},{ 2, 3, 4},{ 2, 3,-1} },   
  { {-1,-1,-1},{ 3,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1} },   
  { { 4, 5,-6},{ 4,-1,-1},{ 2, 3, 4},{ 2, 3,-1},{ 4, 5,-1},{ 3, 4,-1} },   
  { { 6, 7, 8},{ 5,-6, 6},{ 4, 5,-1},{ 4,-1,-1},{ 5, 6, 7},{ 5,-1,-1} },   
  { {-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{ 6,-1,-1} },   
  { { 8, 9,-1},{ 7,-7,-1},{ 5, 6,-1},{ 4, 5,-1},{ 7, 8,-1},{ 7,-1,-1} },   
  { {-1, 7,-1},{-1,-1,-1},{ 9,-9,-1},{10,-1,-1},{-1,-1,-1},{-1,-1,-1} },   
  { { 7, 8,-1},{ 8,-1,-1},{ 9,-9,10},{10,11,-1},{-1,-1,-1},{-1,-1,-1} },   
  { { 8,-1,-1},{ 9,-1,-1},{10,11,-1},{11,12,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {10,-1,-1},{10,-1,-1},{11,12,-1},{12,13,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {10,11,-1},{11,-1,-1},{12,13,-1},{13,14,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {11,12,-1},{12,-1,-1},{13,14,-1},{14,15,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {13,14,-1},{13,-1,-1},{14,15,-1},{15,16,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {14,15,-1},{14,-1,-1},{15,16,-1},{16,-1,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {15,16,-1},{15,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1} },   
  { {16,-1,-1},{16,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1},{-1,-1,-1} }    
}

Definition at line 129 of file RPCRingFromRolls.h.

Referenced by addDetId(), and giveLogPlaneForTower().

int RPCRingFromRolls::m_physStripsInRingFromRolls [private]

m_Number of existing strips in curl;

Definition at line 85 of file RPCRingFromRolls.h.

Referenced by doVirtualStrips(), printContents(), RPCRingFromRolls(), and updatePhiStripsMap().

int RPCRingFromRolls::m_region [private]

Region no - 0 for barell +-1 for endcaps.

Definition at line 81 of file RPCRingFromRolls.h.

Referenced by addDetId(), filterMixedStrips(), RPCRingFromRolls(), and setRefPlane().

int RPCRingFromRolls::m_ring [private]

Wheel number for barell, ring number for endcaps.

Definition at line 82 of file RPCRingFromRolls.h.

Referenced by addDetId(), RPCRingFromRolls(), and setRefPlane().

int RPCRingFromRolls::m_roll [private]

roll no

Definition at line 83 of file RPCRingFromRolls.h.

Referenced by addDetId(), and RPCRingFromRolls().

RPCDetInfoMap RPCRingFromRolls::m_RPCDetInfoMap [private]

Stores all DetId`s of a curl.

Definition at line 99 of file RPCRingFromRolls.h.

Referenced by addDetId(), doVirtualStrips(), filterMixedStrips(), and printContents().

RPCDetInfoPhiMap RPCRingFromRolls::m_RPCDetPhiMap [private]

Stores DetId`s rawId in a phi order.

Definition at line 103 of file RPCRingFromRolls.h.

Referenced by addDetId(), and doVirtualStrips().

GlobalStripPhiMap RPCRingFromRolls::m_stripPhiMap [private]

Definition at line 127 of file RPCRingFromRolls.h.

Referenced by doVirtualStrips(), filterMixedStrips(), makeOtherConnections(), makeRefConnections(), and updatePhiStripsMap().

int RPCRingFromRolls::m_towerMax [private]

The highest m_tower no. to which curl contributes.

Definition at line 79 of file RPCRingFromRolls.h.

Referenced by addDetId(), getMaxTower(), printContents(), and RPCRingFromRolls().

int RPCRingFromRolls::m_towerMin [private]

The lowest m_tower no. to which curl contributes.

Definition at line 78 of file RPCRingFromRolls.h.

Referenced by addDetId(), getMinTower(), makeRefConnections(), printContents(), and RPCRingFromRolls().

int RPCRingFromRolls::m_virtStripsInRingFromRolls [private]

m_Number of virtual strips in curl;

Definition at line 86 of file RPCRingFromRolls.h.

Referenced by doVirtualStrips(), printContents(), and RPCRingFromRolls().

---

The documentation for this class was generated from the following files:

• L1Trigger/RPCTrigger/interface/RPCRingFromRolls.h
• L1Trigger/RPCTrigger/src/RPCRingFromRolls.cc

---