#include <L1Trigger/RPCTriggerConfig/src/RPCConeBuilder.cc>

Inheritance diagram for RPCConeBuilder:

Public Types
typedef std::shared_ptr< L1RPCConeBuilder >	ReturnType

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

Public Member Functions
void	coneDefCallback (const L1RPCConeDefinitionRcd &)

void	geometryCallback (const MuonGeometryRecord &)

ReturnType	produce (const L1RPCConeBuilderRcd &)

	RPCConeBuilder (const edm::ParameterSet &)

	~RPCConeBuilder () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	~ESProducer ()(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Private Member Functions
std::pair< int, int >	areConnected (RPCStripsRing::TIdToRindMap::iterator ref, RPCStripsRing::TIdToRindMap::iterator other)

void	buildCones (const edm::ESHandle< RPCGeometry > &rpcGeom)

void	buildConnections ()

Private Attributes
int	m_hwPlaneBeg

int	m_hwPlaneEnd

edm::ESHandle< L1RPCConeDefinition >	m_L1RPCConeDefinition

RPCStripsRing::TIdToRindMap	m_ringsMap

int	m_rollBeg

int	m_rollEnd

edm::ESHandle< RPCGeometry >	m_rpcGeometry

bool	m_runOnceBuildCones

int	m_towerBeg
	Returns logplane number for this connection, if not connected returns -1. In second lpSize. More...

int	m_towerEnd

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::ESProducer
template<typename T >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())

template<typename T >
void	setWhatProduced (T iThis, const char iLabel)

template<typename T >
void	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
void	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel=es::Label())

template<typename T , typename TReturn , typename TRecord >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel=es::Label())

template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Detailed Description

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

Usage: <usage>

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

Implementation: <Notes on="" implementation>="">

Definition at line 35 of file RPCConeBuilder.h.

Member Typedef Documentation

typedef std::shared_ptr<L1RPCConeBuilder> RPCConeBuilder::ReturnType

Definition at line 39 of file RPCConeBuilder.h.

Constructor & Destructor Documentation

RPCConeBuilder::RPCConeBuilder ( const edm::ParameterSet & iConfig )

Definition at line 42 of file RPCConeBuilder.cc.

References coneDefCallback(), edm::eventsetup::dependsOn(), geometryCallback(), and edm::ESProducer::setWhatProduced().

                                                              :
       m_towerBeg(iConfig.getParameter<int>("towerBeg")),
       m_towerEnd(iConfig.getParameter<int>("towerEnd")),
       m_runOnceBuildCones(false)
       //m_rollBeg(iConfig.getParameter<int>("rollBeg")),
       //m_rollEnd(iConfig.getParameter<int>("rollEnd")),
       //m_hwPlaneBeg(iConfig.getParameter<int>("hwPlaneBeg")),
       //m_hwPlaneEnd(iConfig.getParameter<int>("hwPlaneEnd"))
 {
    
   setWhatProduced(this, (dependsOn (&RPCConeBuilder::geometryCallback) &  
                                    (&RPCConeBuilder::coneDefCallback)     )
                         );
 
   /* TT
    for (int i = m_towerBeg; i <= m_towerEnd; ++i){
       
       std::stringstream name;
       name << "lpSizeTower" << i;
       
       L1RPCConeBuilder::TLogPlaneSize newSizes = 
             iConfig.getParameter<std::vector<int> >(name.str().c_str());
       
       m_LPSizesInTowers.push_back(newSizes);
       
    }
   
   */
    
    //  hw planes numbered from 0 to 5
    // rolls from 0 to 17 (etaPartition)
    //
    //  rollConnLP_[roll]_[hwPlane-1]
    //  rollConnLP_5_3 = cms.vint32(6, 0, 0),
    //     ----- roll 5, hwPlane 4 (3+1) is logplane 6 (OK)
    //
    //  rollConnT_[roll]_[hwPlane-1]
    //  rollConnT_5_3 = cms.vint32(4, -1, -1),
    //     ----- roll 5, hwPlane 4 (3+1) contirubtes to tower 4 (OK)
   
   /*
    for (int roll = m_rollBeg; roll <= m_rollEnd; ++roll){
       L1RPCConeDefinition::THWplaneToTower newHwPlToTower;
       L1RPCConeDefinition::THWplaneToLP newHWplaneToLP;
       for (int hwpl = m_hwPlaneBeg; hwpl <= m_hwPlaneEnd; ++hwpl){
          std::stringstream name;
          name << "rollConnLP_" << roll << "_" << hwpl;
          
          L1RPCConeDefinition::TTowerList newListLP = 
                iConfig.getParameter<std::vector<int> >(name.str().c_str());
          newHWplaneToLP.push_back(newListLP);
          
          
          std::stringstream name1;
          name1 << "rollConnT_" << roll << "_" << hwpl;
          
          L1RPCConeDefinition::TLPList newListT = 
                iConfig.getParameter<std::vector<int> >(name1.str().c_str());
          newHwPlToTower.push_back(newListT);
       }
       m_RingsToTowers.push_back(newHwPlToTower);
       m_RingsToLP.push_back(newHWplaneToLP);
    }
   */
 }

RPCConeBuilder::~RPCConeBuilder ( )

inlineoverride

Definition at line 39 of file RPCConeBuilder.h.

References areConnected(), buildCones(), buildConnections(), coneDefCallback(), geometryCallback(), trackingPlots::other, and produce().

39 {};

Member Function Documentation

std::pair< int, int > RPCConeBuilder::areConnected	(	RPCStripsRing::TIdToRindMap::iterator	ref,
		RPCStripsRing::TIdToRindMap::iterator	other
	)

private

Definition at line 351 of file RPCConeBuilder.cc.

References funct::abs(), Exception, L1RPCConeDefinition::getLPSizeVec(), L1RPCConeDefinition::getRingToLPVec(), L1RPCConeDefinition::getRingToTowerVec(), and m_L1RPCConeDefinition.

Referenced by buildConnections(), and ~RPCConeBuilder().

                                                                           {
 
   int logplane = -1;
   
   //std::cout << "Checking " << ref->first << " and " << other->first << std::endl;
   
   // Do not connect  rolls lying on the oposite side of detector
   if ( ref->second.getEtaPartition()*other->second.getEtaPartition()<0  )
     return std::make_pair(-1,0);  
   
   
   /*std::cout << "Ref " << ref->second.getEtaPartition() << " " <<ref->second.getHwPlane() << std::endl;
   std::cout << "Other " << other->second.getEtaPartition() << " " <<other->second.getHwPlane() << std::endl;
   std::cout.flush();*/
   
   // refRing and otherRing areConnected, if they contribute to the same tower
   /*
   L1RPCConeDefinition::TTowerList refTowList 
       = m_L1RPCConeDefinition->getRingsToTowers().at(std::abs(ref->second.getEtaPartition()))
                          .at(ref->second.getHwPlane()-1);
       
 
   L1RPCConeDefinition::TTowerList otherTowList 
       = m_L1RPCConeDefinition->getRingsToTowers().at(std::abs(other->second.getEtaPartition()))
                          .at(other->second.getHwPlane()-1);
   */
 
   L1RPCConeDefinition::TRingToTowerVec::const_iterator itRef
       = m_L1RPCConeDefinition->getRingToTowerVec().begin();
   
   const L1RPCConeDefinition::TRingToTowerVec::const_iterator itEnd 
       = m_L1RPCConeDefinition->getRingToTowerVec().end();
     
   L1RPCConeDefinition::TRingToTowerVec::const_iterator itOther = itRef;
   
   int refTowerCnt = 0;
   int index = -1;
   int refTower = -1;
   
   for (;itRef != itEnd; ++itRef){
     if ( itRef->m_etaPart != std::abs(ref->second.getEtaPartition())
         || itRef->m_hwPlane != std::abs(ref->second.getHwPlane()-1) // -1?
        ) continue;
       
     ++refTowerCnt;
     refTower = itRef->m_tower;
     
     for (;itOther != itEnd; ++itOther){
       if ( itOther->m_etaPart != std::abs(other->second.getEtaPartition())
         || itOther->m_hwPlane != std::abs(other->second.getHwPlane()-1) // -1?
         ) continue;  
       
       if (itOther->m_tower == refTower) index = itOther->m_index;
       
     }
     
   }
   
   if(refTowerCnt>1){
     throw cms::Exception("RPCConeBuilder") << " Reference(?) ring "
         << ref->first << " "
         << "wants to be connected to " << refTowerCnt << " towers \n";
   
   }
 
   if(refTowerCnt==0){
     throw cms::Exception("RPCConeBuilder") << " Reference(?) ring "
         << ref->first << " "
         << " is not connected anywhere \n";
   
   }
   
   /*  
   if(index == -1){
     throw cms::Exception("RPCConeBuilder") << "Wrong Index -1 \n"
                                   }*/
   
   
   /*
   int refTower = -1;
   
   L1RPCConeDefinition::TTowerList::iterator rtlIt = refTowList.begin();
   for (; rtlIt != refTowList.end(); ++rtlIt){
   
      if ( *rtlIt >= 0 && refTower < 0){
         refTower = *rtlIt;
      }
      else if ( *rtlIt >= 0 && refTower >= 0) {
       throw cms::Exception("RPCConfig") << " Reference(?) ring "
             << ref->first << " "
             << "wants to be connected more than one tower: "
             << refTower << " "
             << *rtlIt << "\n";
      
      }
   
   }
   
   if (refTower < 0) {
      throw cms::Exception("RPCConfig") << " Reference(?) ring "
            << ref->first
            << " is not connected anywhere \n";
   }
   
   L1RPCConeDefinition::TTowerList::iterator otlIt = otherTowList.begin();
   
   int index = -1, i = 0;
   for (; otlIt != otherTowList.end(); ++otlIt){
      if (*otlIt == refTower) {
         index = i;
      }
      ++i;
   }
   */
   
   int lpSize = 0;
   if (index != -1){
     /*
     logplane = m_L1RPCConeDefinition->getRingsToLP().at(std::abs(other->second.getEtaPartition()))
            .at(other->second.getHwPlane()-1)
     .at(index);*/
     {
       L1RPCConeDefinition::TRingToLPVec::const_iterator it = m_L1RPCConeDefinition->getRingToLPVec().begin();
       L1RPCConeDefinition::TRingToLPVec::const_iterator itEnd = m_L1RPCConeDefinition->getRingToLPVec().end();
       for (;it!=itEnd;++it){
         
         if (it->m_etaPart != std::abs(other->second.getEtaPartition())
             || it->m_hwPlane != std::abs(other->second.getHwPlane()-1) 
             || it->m_index != index) continue;
         
         logplane = it->m_LP;  
         
       }
     }    
     //lpSize = m_L1RPCConeDefinition->getLPSizeForTowers().at(refTower).at(logplane-1);
     
     {
       L1RPCConeDefinition::TLPSizeVec::const_iterator it = m_L1RPCConeDefinition->getLPSizeVec().begin();
       L1RPCConeDefinition::TLPSizeVec::const_iterator itEnd = m_L1RPCConeDefinition->getLPSizeVec().end();
       for (;it!=itEnd;++it){
               
         //std::cout << it->m_LP  << " " << logplane << std::endl;
         if (it->m_tower != std::abs(refTower) || it->m_LP != logplane-1) continue;
         lpSize = it->m_size;
               
       }
   
               //FIXME
       if (lpSize==-1) {
                 //throw cms::Exception("getLogStrip") << " lpSize==-1\n";
       }
     }
   }
   
   
   /*
   if (logplane != -1){
     
      std::cout << ref->first << " <-> " << other->first 
            << " logplane " << logplane
            << " lpsize " << lpSize 
            << std::endl;
   }//*/
   
   return std::make_pair(logplane,lpSize);
 
 }

void RPCConeBuilder::buildCones ( const edm::ESHandle< RPCGeometry > & rpcGeom )

private

Definition at line 179 of file RPCConeBuilder.cc.

References funct::abs(), buildConnections(), RPCGeometry::dets(), Exception, RPCStripsRing::getRingId(), crabWrapper::key, m_ringsMap, m_runOnceBuildCones, nullptr, and Validation_hcalonly_cfi::sign.

Referenced by produce(), and ~RPCConeBuilder().

                                                                         {
   
 
   if (!m_runOnceBuildCones){
     m_runOnceBuildCones = true;
   } else {
     throw cms::Exception("RPCInternal") << "buildCones called twice \n";
   }
   
   //std::cout << "    ---> buildCones called " << std::endl; 
   
   // fetch geometricall data
   auto uncompressedCons = std::make_shared<L1RPCConeBuilder::TConMap>();
   
   
   int rolls = 0;
   for(TrackingGeometry::DetContainer::const_iterator it = rpcGeom->dets().begin();
       it != rpcGeom->dets().end();
       ++it)
   {
   
       if( dynamic_cast< RPCRoll const * >( *it ) == nullptr ) continue;
       
       ++rolls;
       RPCRoll const* roll = dynamic_cast< RPCRoll const*>( *it );
       
       int ringId = RPCStripsRing::getRingId(roll);
       if ( m_ringsMap.find(ringId)  == m_ringsMap.end() ) {
         m_ringsMap[ringId]=RPCStripsRing(roll, uncompressedCons);
       } else {
          m_ringsMap[ringId].addRoll(roll);
       }
       //RPCStripsRing sr(roll);
       
   }
 
   //std::cout << " found: " << rolls << " dets" << std::endl;
   
   RPCStripsRing::TIdToRindMap::iterator it = m_ringsMap.begin();
   
   // filtermixed strips, fill gaps with virtual strips
   for (;it != m_ringsMap.end(); ++it){
      
     //int before = it->second.size();
     
     it->second.filterOverlapingChambers();    
     it->second.fillWithVirtualStrips();
 
     
     //std::cout << it->first << " " <<  it->second.isReferenceRing() << " " 
      //   << before << " -> " 
       //  << it->second.size() << std::endl;
     
     // In reference plane we should have 144*8 = 1152 strips
     //int plane = it->first/1000;
     int etaPart =  it->first%100; 
     if (it->second.isReferenceRing() && (it->second.size() != 1152)){
 
       if (std::abs(etaPart)>=14 || std::abs(etaPart)<=17 ) {
         //std::cout << "etaPart "  << etaPart << " size " << it->second.size() << std::endl;
       }
       else {
         throw cms::Exception("RPCInternal") << "Problem: refring " << it->first 
           << " has " << it->second.size() << " strips \n";
       }
     }
     
     
   }
     
   // Xcheck, if rings are symettrical 
   it = m_ringsMap.begin();
   for (;it != m_ringsMap.end(); ++it){
     int key = it->first;
     int sign = key/100 - (key/1000)*10;
     
     if (sign == 0) {
       key += 100;
     } else {
       key -= 100;
     }
     
     if  (key != 2000){// Hey 2100 has no counterring
       if (it->second.size() !=  m_ringsMap[key].size())  
       {
          throw cms::Exception("RPCInternal") << " Size differs for ring " << key << " +- 100 \n";
       }
     }
   
   
   }
       
   buildConnections();
 }

void RPCConeBuilder::buildConnections ( )

private

Definition at line 275 of file RPCConeBuilder.cc.

References areConnected(), Exception, RPCStripsRing::TOtherConnStruct::m_it, RPCStripsRing::TOtherConnStruct::m_logplane, RPCStripsRing::TOtherConnStruct::m_logplaneSize, and m_ringsMap.

Referenced by buildCones(), and ~RPCConeBuilder().

                                      {
 
 
 
    RPCStripsRing::TIdToRindMap::iterator itRef = m_ringsMap.begin();
    for (;itRef != m_ringsMap.end(); ++itRef){ // iterate over reference rings
       
       
       RPCStripsRing::TOtherConnStructVec ringsToConnect; 
       
       if (!itRef->second.isReferenceRing()) continue; // iterate over reference rings
       
       RPCStripsRing::TIdToRindMap::iterator itOther = m_ringsMap.begin();
       for (;itOther != m_ringsMap.end(); ++itOther){ // iterate over nonreference rings
          
          if (itOther->second.isReferenceRing()) continue; // iterate over nonreference rings
          
          std::pair<int,int> pr = areConnected(itRef, itOther);
          if ( pr.first != -1 ) {
             RPCStripsRing::TOtherConnStruct newOtherConn;
             newOtherConn.m_it = itOther;
             newOtherConn.m_logplane = pr.first;
             newOtherConn.m_logplaneSize = pr.second;
             ringsToConnect.push_back(newOtherConn);
          }
          
          
       } // OtherRings iteration ends
       
       // 
       std::pair<int,int> prRef = areConnected(itRef, itRef);
       if (prRef.first == -1){
         throw cms::Exception("RPCConfig") << " Cannot determine logplane for reference ring "
             << itRef->first << "\n ";
       }
 
       /*&
       if (prRef.second != 8){
         // XXX        
         throw cms::Exception("RPCConfig") << " logplaneSize for reference ring "
             << itRef->first << " wrong "
             << " logplane: " << prRef.first
             << " etaPart: " << itRef->second.getEtaPartition()
             << " tower: " << itRef->second.getTowerForRefRing()
             << " hwPlane: " << itRef->second.getHwPlane()
             << " strips " << prRef.second << "\n";
       }*/
       
       itRef->second.createRefConnections(ringsToConnect, prRef.first, prRef.second);
       
    } // RefRings iteration ends
 
    
    // Fetch connection data, and save in one place
    /*
    RPCStripsRing::TIdToRindMap::iterator it = m_ringsMap.begin();
    for (;it != m_ringsMap.end(); ++it) { 
      
      L1RPCConeBuilder::TConMap nmap = it->second.getConnectionsMap();
      L1RPCConeBuilder::TConMap::iterator newMapIt = nmap.begin();
      for (; newMapIt != nmap.end(); ++ newMapIt) {
        uint32_t raw = newMapIt->first;
        TStrip2ConVec stripsVec = newMapIt->second;
        TStrip2ConVec::iterator stripIt = stripsVec.first
        //unsigned char strip = 
      
      
      }
      
      
   }*/
    
 }

void RPCConeBuilder::coneDefCallback ( const L1RPCConeDefinitionRcd & record )

Definition at line 163 of file RPCConeBuilder.cc.

References edm::eventsetup::EventSetupRecord::get(), m_L1RPCConeDefinition, and m_runOnceBuildCones.

Referenced by RPCConeBuilder(), and ~RPCConeBuilder().

                                                                           {
 
   //std::cout << " ConeDef callback called " << std::endl; 
   m_runOnceBuildCones = false; // allow re-running of buildCones
 
   //edm::ESHandle<RPCGeometry> rpcGeom;
   record.get(m_L1RPCConeDefinition);
   
   //std::cout << " ConeDef callback exit " << std::endl; 
   //std::cout.flush();
   //buildCones(rpcGeom);
   
 }

void RPCConeBuilder::geometryCallback ( const MuonGeometryRecord & record )

Definition at line 154 of file RPCConeBuilder.cc.

References edm::eventsetup::EventSetupRecord::get(), m_rpcGeometry, and m_runOnceBuildCones.

Referenced by RPCConeBuilder(), and ~RPCConeBuilder().

                                                                        {
 
   //std::cout << " Geometry callback called " << std::endl; 
   m_runOnceBuildCones = false; // allow re-running of buildCones
   record.get(m_rpcGeometry);
   
   
 }

RPCConeBuilder::ReturnType RPCConeBuilder::produce ( const L1RPCConeBuilderRcd & iRecord )

Definition at line 117 of file RPCConeBuilder.cc.

References buildCones(), m_ringsMap, m_rpcGeometry, m_towerBeg, and m_towerEnd.

Referenced by ~RPCConeBuilder().

 {
 
   
    //std::cout << " RPCConeBuilder::produce called " << std::endl;
    using namespace edm::es;
    auto pL1RPCConeBuilder = std::make_shared<L1RPCConeBuilder>();
    
    pL1RPCConeBuilder->setFirstTower(m_towerBeg);
    pL1RPCConeBuilder->setLastTower(m_towerEnd);
    
    /*
    pL1RPCConeBuilder->setLPSizeForTowers(m_LPSizesInTowers);
    pL1RPCConeBuilder->setRingsToLP(m_RingsToLP);
    */
    
    //iRecord.get(m_rpcGeometry);
    //iRecord.get(m_L1RPCConeDefinition);
    buildCones(m_rpcGeometry);
 
    // Compress all connections. Since members of this class are shared
    // pointers this call will compress all data
    m_ringsMap.begin()->second.compressConnections();
       
    pL1RPCConeBuilder->setConeConnectionMap(m_ringsMap.begin()->second.getConnectionsMap());
    
    pL1RPCConeBuilder->setCompressedConeConnectionMap(
            m_ringsMap.begin()->second.getCompressedConnectionsMap());
            
    m_ringsMap.clear(); // free mem
       
    return pL1RPCConeBuilder;
    
 }

Member Data Documentation

int RPCConeBuilder::m_hwPlaneBeg

private

Definition at line 63 of file RPCConeBuilder.h.

int RPCConeBuilder::m_hwPlaneEnd

private

Definition at line 64 of file RPCConeBuilder.h.

edm::ESHandle<L1RPCConeDefinition> RPCConeBuilder::m_L1RPCConeDefinition

private

Definition at line 66 of file RPCConeBuilder.h.

Referenced by areConnected(), and coneDefCallback().

RPCStripsRing::TIdToRindMap RPCConeBuilder::m_ringsMap

private

Definition at line 70 of file RPCConeBuilder.h.

Referenced by buildCones(), buildConnections(), and produce().

int RPCConeBuilder::m_rollBeg

private

Definition at line 61 of file RPCConeBuilder.h.

int RPCConeBuilder::m_rollEnd

private

Definition at line 62 of file RPCConeBuilder.h.

edm::ESHandle<RPCGeometry> RPCConeBuilder::m_rpcGeometry

private

Definition at line 67 of file RPCConeBuilder.h.

Referenced by geometryCallback(), and produce().

bool RPCConeBuilder::m_runOnceBuildCones

private

Definition at line 68 of file RPCConeBuilder.h.

Referenced by buildCones(), coneDefCallback(), and geometryCallback().

int RPCConeBuilder::m_towerBeg

private

Returns logplane number for this connection, if not connected returns -1. In second lpSize.

Definition at line 59 of file RPCConeBuilder.h.

Referenced by produce().

int RPCConeBuilder::m_towerEnd

private

Definition at line 60 of file RPCConeBuilder.h.

Referenced by produce().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation