#include <GEMNumberingScheme.h>

Inheritance diagram for GEMNumberingScheme:

Public Member Functions
int	baseNumberToUnitNumber (const MuonBaseNumber &) const override

	GEMNumberingScheme (const MuonGeometryConstants &muonConstants)

	~GEMNumberingScheme () override

Public Member Functions inherited from MuonNumberingScheme
	MuonNumberingScheme ()

virtual	~MuonNumberingScheme ()

Private Member Functions
void	initMe (const MuonGeometryConstants &muonConstants)

Private Attributes
int	theRegionLevel

int	theRingLevel

int	theRollLevel

int	theSectorLevel

int	theStationLevel

Detailed Description

Definition at line 9 of file GEMNumberingScheme.h.

Constructor & Destructor Documentation

◆ GEMNumberingScheme()

GEMNumberingScheme::GEMNumberingScheme ( const MuonGeometryConstants & muonConstants )

Definition at line 9 of file GEMNumberingScheme.cc.

9 { initMe(muonConstants); }

References initMe().

◆ ~GEMNumberingScheme()

GEMNumberingScheme::~GEMNumberingScheme ( )

inlineoverride

Definition at line 13 of file GEMNumberingScheme.h.

13 {};

Member Function Documentation

◆ baseNumberToUnitNumber()

int GEMNumberingScheme::baseNumberToUnitNumber ( const MuonBaseNumber & num ) const

overridevirtual

Reimplemented from MuonNumberingScheme.

Definition at line 26 of file GEMNumberingScheme.cc.

                                                                               {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("GEMNumberingScheme") << "GEMNumbering " << num.getLevels();
   for (int level = 1; level <= num.getLevels(); level++) {
     edm::LogVerbatim("GEMNumberingScheme") << level << " " << num.getSuperNo(level) << " " << num.getBaseNo(level);
   }
 #endif
  
   int levels = num.getLevels();
 #ifdef EDM_ML_DEBUG
   if (levels != theRollLevel)
     edm::LogVerbatim("GEMNumberingScheme") << "MuonGEMNumberingScheme::BNToUN: BaseNumber has " << num.getLevels()
                                            << " levels, need at least till " << theRollLevel;
 #endif
  
   int region(GEMDetId::minRegionId), ring(GEMDetId::minRingId);
   int station(GEMDetId::minStationId0), layer(GEMDetId::minLayerId);
   int chamber(1 + GEMDetId::minChamberId), roll(GEMDetId::minRollId);
  
   //decode significant GEM levels
  
   if (levels >= theRegionLevel) {
     if (num.getBaseNo(theRegionLevel) == 0)
       region = 1;
     else
       region = -1;
   }
  
   // All GEM super chambers in stations 1 and 2 are on ring 1.
   // The long super chambers in station 2 are assigned *station 3* due
   // to the current limitation in the definition of the GEMDetId,
   // i.e. only 2 layers available per station.
   //  ring    = num.getSuperNo(theRingLevel);
   // GEM are only on the first ring
   ring = 1;
  
   // GE0 has the layer encoded in the ring level
   if (levels > theRingLevel) {
     if (num.getBaseNo(theRingLevel) == 0) {  // 0 => GE1/1, GE2/1
       station = num.getSuperNo(theStationLevel);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("GEMNumberingScheme")
           << "GEMNumbering: Ring " << ring << " Station " << num.getSuperNo(theStationLevel) << ":" << station;
 #endif
       if (levels >= theRollLevel)
         roll = num.getBaseNo(theRollLevel) + 1;
       if (levels >= theSectorLevel) {
         const int copyno = num.getBaseNo(theSectorLevel) + 1;
         // Half the chambers are flipped back to front, this is encoded in
         // the chamber number, which affects the layer numbering. Layer 1
         // is always the closest layer to the interaction point.
         const int layerDemarcation = 50;
         if (copyno < layerDemarcation) {
           if (copyno % 2 == 0) {
             layer = 2;
             chamber = copyno - 1;
           } else {
             layer = 1;
             chamber = copyno;
           }
         } else {
           int copynp = copyno - layerDemarcation;
           if (copynp % 2 != 0) {
             layer = 2;
             chamber = copynp - 1;
           } else {
             layer = 1;
             chamber = copynp;
           }
         }
       }
     } else {  // GE0 encodes the layer
       station = GEMDetId::minStationId0;
       layer = num.getBaseNo(theRingLevel);
       if (levels >= theSectorLevel)
         chamber = num.getBaseNo(theSectorLevel) + 1;
       if (levels >= theRollLevel)
         roll = num.getBaseNo(theRollLevel) + 1;
     }
   } else if (levels == theRingLevel) {
     station = GEMDetId::minStationId0;
     layer = 1;
   }
  
   // collect all info
  
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("GEMNumberingScheme") << "GEMNumberingScheme: Region " << region << " Ring " << ring << " Station "
                                          << station << " Layer " << layer << " Chamber " << chamber << " Roll " << roll;
 #endif
  
   // Build the actual numbering
   GEMDetId id(region, ring, station, layer, chamber, roll);
  
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("GEMNumberingScheme") << id.rawId() << " DetId " << id;
 #endif
  
   return id.rawId();
 }

References relativeConstraints::chamber, triggerObjects_cff::id, phase1PixelTopology::layer, personalPlayback::level, jets_cff::levels, GEMDetId::minChamberId, GEMDetId::minLayerId, GEMDetId::minRegionId, GEMDetId::minRingId, GEMDetId::minRollId, GEMDetId::minStationId0, EgammaValidation_cff::num, HLT_FULL_cff::region, relativeConstraints::ring, relativeConstraints::station, theRegionLevel, theRingLevel, theRollLevel, theSectorLevel, and theStationLevel.

Referenced by GEMGeometryBuilder::build(), and GEMGeometryParsFromDD::buildGeometry().

◆ initMe()

void GEMNumberingScheme::initMe ( const MuonGeometryConstants & muonConstants )

private

Definition at line 11 of file GEMNumberingScheme.cc.

                                                                           {
   int theLevelPart = muonConstants.getValue("level");
   theRegionLevel = muonConstants.getValue("mg_region") / theLevelPart;
   theStationLevel = muonConstants.getValue("mg_station") / theLevelPart;
   theRingLevel = muonConstants.getValue("mg_ring") / theLevelPart;
   theSectorLevel = muonConstants.getValue("mg_sector") / theLevelPart;
   theRollLevel = muonConstants.getValue("mg_roll") / theLevelPart;
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("GEMNumberingScheme") << "Initialize GEMNumberingScheme"
                                          << "\ntheRegionLevel " << theRegionLevel << "\ntheStationLevel "
                                          << theStationLevel << "\ntheRingLevel " << theRingLevel << "\ntheSectorLevel "
                                          << theSectorLevel << "\ntheRollLevel " << theRollLevel;
 #endif
 }