CMSSW Reference Manual

MuonRPCDetLayerGeometryBuilder::MuonRPCDetLayerGeometryBuilder ( ) [inline]

Constructor (disabled, only static access is allowed).

Definition at line 25 of file MuonRPCDetLayerGeometryBuilder.h.

00025 {}

MuonRPCDetLayerGeometryBuilder::~MuonRPCDetLayerGeometryBuilder ( ) [virtual]

Destructor.

Definition at line 30 of file MuonRPCDetLayerGeometryBuilder.cc.

00030                                                                 {
00031 }

vector< DetLayer * > MuonRPCDetLayerGeometryBuilder::buildBarrelLayers ( const RPCGeometry & geo ) [static]

Builds the barrel layers. Result vector is sorted inside-out.

Definition at line 181 of file MuonRPCDetLayerGeometryBuilder.cc.

References RPCGeometry::idToDet(), it, LogTrace, makeBarrelLayers(), RPCDetId::maxLayerId, RPCDetId::maxRingBarrelId, RPCDetId::maxRollId, RPCDetId::maxSectorId, RPCDetId::maxStationId, RPCDetId::maxSubSectorId, RPCDetId::minLayerId, RPCDetId::minRingBarrelId, RPCDetId::minRollId, RPCDetId::minSectorId, RPCDetId::minStationId, RPCDetId::minSubSectorId, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), GeomDet::position(), and muonGeometry::wheel.

Referenced by MuonDetLayerGeometryESProducer::produce().

00181                                                                         {
00182   const std::string metname = "Muon|RPC|RecoMuon|RecoMuonDetLayers|MuonRPCDetLayerGeometryBuilder";
00183 
00184   vector<DetLayer*> detlayers;
00185   vector<MuRodBarrelLayer*> result;
00186   int region =0;
00187 
00188   for(int station = RPCDetId::minStationId; station <= RPCDetId::maxStationId; station++) {
00189 
00190     vector<const GeomDet*> geomDets;
00191 
00192     for(int layer=RPCDetId::minLayerId; layer<= RPCDetId::maxLayerId;++layer){
00193       for(int sector = RPCDetId::minSectorId; sector <= RPCDetId::maxSectorId; sector++) {
00194         for(int subsector = RPCDetId::minSubSectorId; subsector <= RPCDetId::maxSubSectorId; subsector++) {
00195           for(int wheel = RPCDetId::minRingBarrelId; wheel <= RPCDetId::maxRingBarrelId; wheel++) {
00196             for(int roll=RPCDetId::minRollId+1; roll <= RPCDetId::maxRollId; roll++){         
00197               const GeomDet* geomDet = geo.idToDet(RPCDetId(region,wheel,station,sector,layer,subsector,roll));
00198               if (geomDet) {
00199                 geomDets.push_back(geomDet);
00200                 LogTrace(metname) << "get RPC Barrel roll " <<  RPCDetId(region,wheel,station,sector,layer,subsector,roll)
00201                                   << " at R=" << geomDet->position().perp()
00202                                   << ", phi=" << geomDet->position().phi() ;
00203               }
00204             }
00205           }
00206         }
00207       }
00208     }
00209     makeBarrelLayers(geomDets, result);
00210   }
00211   
00212 
00213   for(vector<MuRodBarrelLayer*>::const_iterator it = result.begin(); it != result.end(); it++)
00214     detlayers.push_back((DetLayer*)(*it));
00215 
00216   return detlayers;
00217 }

pair< vector< DetLayer * >, vector< DetLayer * > > MuonRPCDetLayerGeometryBuilder::buildEndcapLayers ( const RPCGeometry & geo ) [static]

Builds the forward (+Z, return.first) and backward (-Z, return.second) layers.

Both vectors are sorted inside-out

Definition at line 36 of file MuonRPCDetLayerGeometryBuilder.cc.

References buildLayer(), GeomDetEnumerators::endcap, RPCDetId::maxLayerId, RPCDetId::maxRingForwardId, RPCDetId::maxRollId, RPCDetId::maxStationId, RPCDetId::minLayerId, RPCDetId::minRingForwardId, RPCDetId::minRollId, HLT_VtxMuL3::result, and RingMakerESProducer_cfi::rings.

Referenced by MuonDetLayerGeometryESProducer::produce().

00036                                                                         {
00037   
00038   vector<DetLayer*> result[2];
00039 
00040   for (int endcap = -1; endcap<=1; endcap+=2) {
00041     int iendcap = (endcap==1) ? 0 : 1; // +1: forward, -1: backward
00042     
00043     // ME 1
00044     int firstStation=1;
00045         
00046     // ME 1/1
00047     for (int layer = RPCDetId::minLayerId; layer <= RPCDetId::maxLayerId; ++layer) { 
00048       vector<int> rolls;      
00049       std::vector<int> rings;
00050       int FirstStationRing = 1; 
00051       rings.push_back(FirstStationRing);
00052       for(int roll = RPCDetId::minRollId+1; 
00053           roll <= RPCDetId::maxRollId; ++roll) {
00054         rolls.push_back(roll);
00055       }
00056       
00057 
00058       
00059       MuRingForwardDoubleLayer* ringLayer = buildLayer(endcap, rings,
00060                                                  firstStation , layer, 
00061                                                  rolls, geo);          
00062       if (ringLayer) result[iendcap].push_back(ringLayer);
00063       
00064     }
00065         
00066     // ME 1/2 and ME1/3       
00067     for(int layer = RPCDetId::minLayerId; layer <= RPCDetId::maxLayerId; ++layer) { 
00068       vector<int> rolls;      
00069       std::vector<int> rings;
00070       for(int ring = 2; ring <= 3; ++ring) {
00071         rings.push_back(ring);
00072       }
00073       for(int roll = RPCDetId::minRollId+1; roll <= RPCDetId::maxRollId; 
00074           ++roll) {
00075         rolls.push_back(roll);
00076       }
00077                 
00078       MuRingForwardDoubleLayer* ringLayer = buildLayer(endcap, rings, firstStation , layer, rolls, geo);          
00079       if (ringLayer) result[iendcap].push_back(ringLayer);
00080     }
00081   
00082 
00083     // ME 2 and ME 3 
00084     for(int station = 2; station <= RPCDetId::maxStationId; ++station) {
00085       for(int layer = RPCDetId::minLayerId; layer <= RPCDetId::maxLayerId; ++layer) { 
00086         vector<int> rolls;      
00087         std::vector<int> rings;
00088         for(int ring = RPCDetId::minRingForwardId; ring <= RPCDetId::maxRingForwardId; ++ring) {
00089           rings.push_back(ring);
00090         }
00091         for(int roll = RPCDetId::minRollId+1; roll <= RPCDetId::maxRollId; ++roll) {
00092           rolls.push_back(roll);
00093         }
00094                 
00095         MuRingForwardDoubleLayer* ringLayer = buildLayer(endcap, rings, station, layer, rolls, geo);          
00096         if (ringLayer) result[iendcap].push_back(ringLayer);
00097       }
00098     }
00099     
00100   }
00101   pair<vector<DetLayer*>, vector<DetLayer*> > res_pair(result[0], result[1]); 
00102   return res_pair;
00103 
00104 }

static MuRingForwardDoubleLayer* MuonRPCDetLayerGeometryBuilder::buildLayer	(	int	endcap,
		std::vector< int >	rings,
		int	station,
		int	layer,
		std::vector< int > &	rolls,
		const RPCGeometry &	geo
	)			`[static, private]`

Referenced by buildEndcapLayers().

bool MuonRPCDetLayerGeometryBuilder::isFront ( const RPCDetId & rpcId ) [static, private]

Definition at line 342 of file MuonRPCDetLayerGeometryBuilder.cc.

References RPCDetId::ring(), RPCDetId::sector(), RPCDetId::station(), and RPCDetId::subsector().

00343 {
00344   // ME1/2 is always in back
00345   //  if(rpcId.station() == 1 && rpcId.ring() == 2)  return false;
00346 
00347   bool result = false;
00348   // 20 degree rings are a little weird! not anymore from 17x
00349   if(rpcId.ring() == 1 && rpcId.station() > 1)
00350   {
00351     // RE1/2 RE1/3
00352     /* goes (sector) (subsector)
00353     1 1 back   // front 
00354     1 2 front  // back
00355     1 3 front  // front
00356     2 1 front  // back
00357     2 2 back   // from
00358     2 3 back   // back
00359     */
00360     result = (rpcId.subsector() != 2);
00361     if(rpcId.sector()%2 == 0) result = !result;
00362     return result;
00363   }
00364   else
00365   {
00366     // 10 degree rings have odd subsectors in front
00367     result = (rpcId.subsector()%2 == 1);
00368   }
00369   return result;
00370 }

static void MuonRPCDetLayerGeometryBuilder::makeBarrelLayers	(	std::vector< const GeomDet * > &	geomDets,
		std::vector< MuRodBarrelLayer * > &	result
	)			`[static, private]`

Referenced by buildBarrelLayers().

static void MuonRPCDetLayerGeometryBuilder::makeBarrelRods	(	std::vector< const GeomDet * > &	geomDets,
		std::vector< const DetRod * > &	result
	)			`[static, private]`


Public Member Functions
	MuonRPCDetLayerGeometryBuilder ()
	Constructor (disabled, only static access is allowed).
virtual	~MuonRPCDetLayerGeometryBuilder ()
	Destructor.
Static Public Member Functions
static std::vector< DetLayer * >	buildBarrelLayers (const RPCGeometry &geo)
	Builds the barrel layers. Result vector is sorted inside-out.
static std::pair< std::vector < DetLayer * >, std::vector < DetLayer * > >	buildEndcapLayers (const RPCGeometry &geo)
	Builds the forward (+Z, return.first) and backward (-Z, return.second) layers.
Static Private Member Functions
static MuRingForwardDoubleLayer *	buildLayer (int endcap, std::vector< int > rings, int station, int layer, std::vector< int > &rolls, const RPCGeometry &geo)
static bool	isFront (const RPCDetId &rpcId)
static void	makeBarrelLayers (std::vector< const GeomDet * > &geomDets, std::vector< MuRodBarrelLayer * > &result)
static void	makeBarrelRods (std::vector< const GeomDet * > &geomDets, std::vector< const DetRod * > &result)

MuonRPCDetLayerGeometryBuilder Class Reference

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation