RPCConeBuilder Class Reference

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

Inheritance diagram for RPCConeBuilder:

Public Types
using	ReturnType = std::unique_ptr< L1RPCConeBuilder >
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
ReturnType	produce (const L1RPCConeBuilderRcd &)
	RPCConeBuilder (const edm::ParameterSet &)
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final
	~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, L1RPCConeDefinition const *)
void	buildCones (RPCGeometry const *, L1RPCConeDefinition const *, RPCStripsRing::TIdToRindMap &)
void	buildConnections (L1RPCConeDefinition const *, RPCStripsRing::TIdToRindMap &)

Private Attributes
int	m_towerBeg
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
	ESProducer (const ESProducer &)=delete
ESProducer const &	operator= (const ESProducer &)=delete
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})
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 32 of file RPCConeBuilder.h.

Member Typedef Documentation

using RPCConeBuilder::ReturnType = std::unique_ptr<L1RPCConeBuilder>

Definition at line 37 of file RPCConeBuilder.h.

Constructor & Destructor Documentation

RPCConeBuilder::RPCConeBuilder

(

const edm::ParameterSet &

iConfig

)

Definition at line 31 of file RPCConeBuilder.cc.

References edm::ESProducer::setWhatProduced().

                                                             :
   m_towerBeg(iConfig.getParameter<int>("towerBeg")),
   m_towerEnd(iConfig.getParameter<int>("towerEnd"))
{
   setWhatProduced(this);
}

Member Function Documentation

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

private

In the pair that is returned, the first element is the logplane number for this connection (if not connected returns -1) and the second element is lpSize.

Definition at line 161 of file RPCConeBuilder.cc.

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

Referenced by buildConnections().

                                                                             {

   int logplane = -1;

   // 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);

   int refTowerCnt = 0;
   int index = -1;
   int refTower = -1;

   for (auto const& itRef : l1RPCConeDefinition->getRingToTowerVec()) {

      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 (auto const& itOther : l1RPCConeDefinition->getRingToTowerVec()) {

         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";
   }

   int lpSize = 0;
   if (index != -1) {

      for (auto const& it : l1RPCConeDefinition->getRingToLPVec()) {
         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;
      }

      for (auto const& it : l1RPCConeDefinition->getLPSizeVec()) {
         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";
      }
   }
   return std::make_pair(logplane, lpSize);
}

void RPCConeBuilder::buildCones ( RPCGeometry const *  rpcGeom, L1RPCConeDefinition const *  l1RPCConeDefinition, RPCStripsRing::TIdToRindMap &  ringsMap  )

private

Definition at line 69 of file RPCConeBuilder.cc.

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

Referenced by produce().

                                                                     {

   // fetch geometrical data
   auto uncompressedCons = std::make_shared<L1RPCConeBuilder::TConMap>();

   int rolls = 0;
   for (auto const& it : rpcGeom->dets()) {

      if ( dynamic_cast< RPCRoll const * >( it ) == nullptr ) {
         continue;
      }

      ++rolls;
      RPCRoll const* roll = dynamic_cast< RPCRoll const*>( it );

      int ringId = RPCStripsRing::getRingId(roll);
      if ( ringsMap.find(ringId) == ringsMap.end() ) {
         ringsMap[ringId] = RPCStripsRing(roll, uncompressedCons);
      } else {
         ringsMap[ringId].addRoll(roll);
      }
   }

   // filtermixed strips, fill gaps with virtual strips
   for (auto& it : ringsMap) {

      it.second.filterOverlapingChambers();
      it.second.fillWithVirtualStrips();
   }

   // Xcheck, if rings are symettrical
   for (auto& it : ringsMap) {
      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() !=  ringsMap[key].size())
         {
            throw cms::Exception("RPCInternal") << " Size differs for ring " << key << " +- 100 \n";
         }
      }
   }
   buildConnections(l1RPCConeDefinition, ringsMap);
}

void RPCConeBuilder::buildConnections ( L1RPCConeDefinition const *  l1RPCConeDefinition, RPCStripsRing::TIdToRindMap &  ringsMap  )

private

Definition at line 122 of file RPCConeBuilder.cc.

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

Referenced by buildCones().

                                                                           {

   RPCStripsRing::TIdToRindMap::iterator itRef = ringsMap.begin();
   for (;itRef != ringsMap.end(); ++itRef){ // iterate over reference rings

      RPCStripsRing::TOtherConnStructVec ringsToConnect;

      if (!itRef->second.isReferenceRing()) continue; // iterate over reference rings

      RPCStripsRing::TIdToRindMap::iterator itOther = ringsMap.begin();
      for (;itOther != ringsMap.end(); ++itOther){ // iterate over nonreference rings

         if (itOther->second.isReferenceRing()) continue; // iterate over nonreference rings

         std::pair<int,int> pr = areConnected(itRef, itOther, l1RPCConeDefinition);
         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, l1RPCConeDefinition);
      if (prRef.first == -1){
         throw cms::Exception("RPCConfig") << " Cannot determine logplane for reference ring "
            << itRef->first << "\n ";
      }

      itRef->second.createRefConnections(ringsToConnect, prRef.first, prRef.second);

   } // RefRings iteration ends
}

RPCConeBuilder::ReturnType RPCConeBuilder::produce

(

const L1RPCConeBuilderRcd &

iRecord

)

Definition at line 40 of file RPCConeBuilder.cc.

References buildCones(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), m_towerBeg, m_towerEnd, and edm::ESHandle< T >::product().

{
   auto pL1RPCConeBuilder = std::make_unique<L1RPCConeBuilder>();

   pL1RPCConeBuilder->setFirstTower(m_towerBeg);
   pL1RPCConeBuilder->setLastTower(m_towerEnd);

   edm::ESHandle<RPCGeometry> rpcGeometry;
   iRecord.getRecord<MuonGeometryRecord>().get(rpcGeometry);

   edm::ESHandle<L1RPCConeDefinition> l1RPCConeDefinition;
   iRecord.getRecord<L1RPCConeDefinitionRcd>().get(l1RPCConeDefinition);

   RPCStripsRing::TIdToRindMap ringsMap;

   buildCones(rpcGeometry.product(), l1RPCConeDefinition.product(), ringsMap);

   // Compress all connections. Since members of this class are shared
   // pointers this call will compress all data
   ringsMap.begin()->second.compressConnections();

   pL1RPCConeBuilder->setConeConnectionMap(ringsMap.begin()->second.getConnectionsMap());

   pL1RPCConeBuilder->setCompressedConeConnectionMap(
      ringsMap.begin()->second.getCompressedConnectionsMap());

   return pL1RPCConeBuilder;
}

Member Data Documentation

int RPCConeBuilder::m_towerBeg

private

Definition at line 58 of file RPCConeBuilder.h.

Referenced by produce().

int RPCConeBuilder::m_towerEnd

private

Definition at line 59 of file RPCConeBuilder.h.

Referenced by produce().