MuonGEMDetLayerGeometryBuilder.cc

Go to the documentation of this file.

#include <RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h>

#include <DataFormats/MuonDetId/interface/GEMDetId.h>
#include <Geometry/CommonDetUnit/interface/GeomDet.h>
#include <RecoMuon/DetLayers/interface/MuRingForwardDoubleLayer.h>
#include <RecoMuon/DetLayers/interface/MuRodBarrelLayer.h>
#include <RecoMuon/DetLayers/interface/MuDetRing.h>
#include <RecoMuon/DetLayers/interface/MuDetRod.h>

#include <Utilities/General/interface/precomputed_value_sort.h>
#include <Geometry/CommonDetUnit/interface/DetSorting.h>
#include "Utilities/BinningTools/interface/ClusterizingHistogram.h"

#include <FWCore/MessageLogger/interface/MessageLogger.h>

#include <iostream>

using namespace std;

MuonGEMDetLayerGeometryBuilder::~MuonGEMDetLayerGeometryBuilder() {
}

// Builds the forward (first) and backward (second) layers
// Builds etaPartitions (for rechits)
pair<vector<DetLayer*>, vector<DetLayer*> > 
MuonGEMDetLayerGeometryBuilder::buildEndcapLayers(const GEMGeometry& geo) {
  
  vector<DetLayer*> result[2];
    
  for (int endcap = -1; endcap<=1; endcap+=2) {
    int iendcap = (endcap==1) ? 0 : 1; // +1: forward, -1: backward
      
    for(int station = GEMDetId::minStationId; station <= GEMDetId::maxStationId; ++station) {      
      for(int layer = GEMDetId::minLayerId+1; layer <= GEMDetId::maxLayerId; ++layer) { 

    vector<int> rolls, rings, chambers; 
    for(int ring = GEMDetId::minRingId; ring <= GEMDetId::maxRingId; ++ring) rings.push_back(ring);
    for(int chamber = GEMDetId::minChamberId+1; chamber <= GEMDetId::maxChamberId; chamber++ )
      chambers.push_back(chamber);
    for(int roll = GEMDetId::minRollId+1; roll <= GEMDetId::maxRollId; ++roll)
      rolls.push_back(roll);
    
    MuRingForwardDoubleLayer* ringLayer = buildLayer(endcap, rings, station, layer, chambers, rolls, geo);          

    if (ringLayer) result[iendcap].push_back(ringLayer);
      }
    }
  }
  pair<vector<DetLayer*>, vector<DetLayer*> > res_pair(result[0], result[1]); 

  return res_pair;
}

MuRingForwardDoubleLayer* 
MuonGEMDetLayerGeometryBuilder::buildLayer(int endcap,vector<int>& rings, int station,
                       int layer,
                       vector<int>& chambers,
                       vector<int>& rolls,
                       const GEMGeometry& geo) {

  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuonGEMDetLayerGeometryBuilder";
  MuRingForwardDoubleLayer * result = nullptr;
  vector<const ForwardDetRing*> frontRings, backRings;


  for (std::vector<int>::iterator ring=rings.begin(); ring!=rings.end()-2;ring++){ 

    for (vector<int>::iterator roll = rolls.begin(); roll!=rolls.end(); roll++) {    

      vector<const GeomDet*> frontDets, backDets;
      
      for(std::vector<int>::iterator chamber=chambers.begin(); chamber<chambers.end(); chamber++) {
          GEMDetId gemId(endcap,(*ring), station,layer,(*chamber), (*roll));

      const GeomDet* geomDet = geo.idToDet(gemId);
      
      if (geomDet !=nullptr) {
        bool isInFront = isFront(gemId);
        if(isInFront)
            {
              frontDets.push_back(geomDet);
            }
            else 
            {
              backDets.push_back(geomDet);
            }
        LogTrace(metname) << "get GEM Endcap roll "
                  << gemId
                              << (isInFront ? "front" : "back ")
                  << " at R=" << geomDet->position().perp()
                  << ", phi=" << geomDet->position().phi()
                              << ", Z=" << geomDet->position().z();
      }
      }

      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();
      }

    }

  }

  // How should they be sorted?
  //    precomputed_value_sort(muDetRods.begin(), muDetRods.end(), geomsort::ExtractZ<GeometricSearchDet,float>());                                   
  if(!backRings.empty() && !frontRings.empty()) result = new MuRingForwardDoubleLayer(frontRings, backRings);
    else result = nullptr;
  if(result != nullptr){
    LogTrace(metname) << "New MuRingForwardLayer with " << frontRings.size()
              << " and " << backRings.size()
              << " rings, at Z " << result->position().z()
              << " R1: " << result->specificSurface().innerRadius()
              << " R2: " << result->specificSurface().outerRadius();
  }
  return result;

}


bool MuonGEMDetLayerGeometryBuilder::isFront(const GEMDetId & gemId)
{

  bool result = false;
  int chamber = gemId.chamber();

    if(chamber%2 == 0) result = !result;

    return result;
}

MuDetRing * MuonGEMDetLayerGeometryBuilder::makeDetRing(vector<const GeomDet*> & geomDets)
{
    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;
}