MuonGEMDetLayerGeometryBuilder Class Reference

#include <MuonGEMDetLayerGeometryBuilder.h>

Public Member Functions
	MuonGEMDetLayerGeometryBuilder ()
	Constructor (disabled, only static access is allowed) More...
virtual	~MuonGEMDetLayerGeometryBuilder ()
	Destructor. More...

Static Public Member Functions
static std::pair< std::vector< DetLayer * >, std::vector< DetLayer * > >	buildEndcapLayers (const GEMGeometry &geo)

Static Private Member Functions
static bool	isFront (const GEMDetId &gemId)
static MuDetRing *	makeDetRing (std::vector< const GeomDet *> &geomDets)

Detailed Description

Build the GEM DetLayers.

Author

R. Radogna

Definition at line 21 of file MuonGEMDetLayerGeometryBuilder.h.

Constructor & Destructor Documentation

MuonGEMDetLayerGeometryBuilder()

MuonGEMDetLayerGeometryBuilder::MuonGEMDetLayerGeometryBuilder ( )

inline

Constructor (disabled, only static access is allowed)

Definition at line 24 of file MuonGEMDetLayerGeometryBuilder.h.

{}

~MuonGEMDetLayerGeometryBuilder()

MuonGEMDetLayerGeometryBuilder::~MuonGEMDetLayerGeometryBuilder ( )

virtual

Destructor.

Definition at line 19 of file MuonGEMDetLayerGeometryBuilder.cc.

{}

Member Function Documentation

buildEndcapLayers()

pair< vector< DetLayer * >, vector< DetLayer * > > MuonGEMDetLayerGeometryBuilder::buildEndcapLayers ( const GEMGeometry &  geo )

static

Builds the forward (+Z, return.first) and backward (-Z, return.second) layers. Both vectors are sorted inside-out

Definition at line 23 of file MuonGEMDetLayerGeometryBuilder.cc.

References phase1PixelTopology::layer, LogTrace, GEMDetId::maxLayerId, GEMDetId::maxLayerId0, GEMDetId::maxRollId, metname, GEMDetId::minLayerId, GEMDetId::minRollId, GEMDetId::minStationId0, GeometricSearchDet::position(), precomputed_value_sort(), ForwardDetLayer::specificSurface(), GEMGeometry::stations(), AlCaHLTBitMon_QueryRunRegistry::string, and PV3DBase< T, PVType, FrameType >::z().

Referenced by MuonDetLayerGeometryESProducer::produce().

                                                                                                                    {
  vector<DetLayer*> endcapLayers[2];

  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuonGEMDetLayerGeometryBuilder";
  for (auto st : geo.stations()) {
    const int maxLayerId = (st->station() == GEMDetId::minStationId0) ? GEMDetId::maxLayerId0 : GEMDetId::maxLayerId;
    for (int layer = GEMDetId::minLayerId + 1; layer <= maxLayerId; ++layer) {
      ForwardDetLayer* forwardLayer = nullptr;
      vector<const ForwardDetRing*> frontRings, backRings;

      for (int roll = GEMDetId::minRollId + 1; roll <= GEMDetId::maxRollId; ++roll) {
        vector<const GeomDet*> frontDets, backDets;

        for (auto sc : st->superChambers()) {
          auto ch = sc->chamber(layer);
          if (ch == nullptr)
            continue;

          auto etaP = ch->etaPartition(roll);
          if (etaP == nullptr)
            continue;

          bool isInFront = isFront(etaP->id());
          if (isInFront) {
            frontDets.push_back(etaP);
          } else {
            backDets.push_back(etaP);
          }
        }

        if (!frontDets.empty()) {
          precomputed_value_sort(frontDets.begin(), frontDets.end(), geomsort::DetPhi());
          frontRings.push_back(new MuDetRing(frontDets));
          LogTrace(metname) << "New front ring with " << frontDets.size()
                            << " chambers at z=" << frontRings.back()->position().z();
        }
        if (!backDets.empty()) {
          precomputed_value_sort(backDets.begin(), backDets.end(), geomsort::DetPhi());
          backRings.push_back(new MuDetRing(backDets));
          LogTrace(metname) << "New back ring with " << backDets.size()
                            << " chambers at z=" << backRings.back()->position().z();
        }
      }

      if (!frontRings.empty()) {
        if (st->station() == GEMDetId::minStationId0)
          forwardLayer = new MuRingForwardLayer(frontRings);
        else if (!backRings.empty())
          forwardLayer = new MuRingForwardDoubleLayer(frontRings, backRings);
      }

      if (forwardLayer != nullptr) {
        LogTrace(metname) << "New MuRingForwardLayer with " << frontRings.size() << " and " << backRings.size()
                          << " rings, at Z " << forwardLayer->position().z()
                          << " R1: " << forwardLayer->specificSurface().innerRadius()
                          << " R2: " << forwardLayer->specificSurface().outerRadius();

        int iendcap = (st->region() == 1) ? 0 : 1;
        endcapLayers[iendcap].push_back(forwardLayer);
      }
    }
  }

  pair<vector<DetLayer*>, vector<DetLayer*> > res_pair(endcapLayers[0], endcapLayers[1]);
  return res_pair;
}

isFront()

bool MuonGEMDetLayerGeometryBuilder::isFront ( const GEMDetId &  gemId )

staticprivate

Definition at line 90 of file MuonGEMDetLayerGeometryBuilder.cc.

References GEMDetId::chamber(), GEMDetId::minStationId0, and GEMDetId::station().

                                                                  {
  // ME0s do not currently have an arrangement of which are front and which are back, going to always return true
  if (gemId.station() == GEMDetId::minStationId0)
    return true;

  return (gemId.chamber() % 2 == 0);
}

makeDetRing()

MuDetRing * MuonGEMDetLayerGeometryBuilder::makeDetRing ( std::vector< const GeomDet *> &  geomDets )

staticprivate

Definition at line 98 of file MuonGEMDetLayerGeometryBuilder.cc.

References LogTrace, metname, precomputed_value_sort(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                       {
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuonGEMDetLayerGeometryBuilder";

  precomputed_value_sort(geomDets.begin(), geomDets.end(), geomsort::DetPhi());
  MuDetRing* result = new MuDetRing(geomDets);
  LogTrace(metname) << "New MuDetRing with " << geomDets.size() << " chambers at z=" << result->position().z()
                    << " R1: " << result->specificSurface().innerRadius()
                    << " R2: " << result->specificSurface().outerRadius();
  return result;
}