RPCDD4HEP bis

Geometry/MuonNumbering/interface/DD4hep_RPCNumberingScheme.h

@@ -0,0 +1,42 @@
+#ifndef GEOMETRY_MUON_NUMBERING_RPC_NUMBERING_SCHEME_H
+#define GEOMETRY_MUON_NUMBERING_RPC_NUMBERING_SCHEME_H
+
+/*
+//\class RPCNumberingScheme
+
+ Description: RPC Numbering Scheme for DD4hep
+
+//
+// Author:  Sergio Lo Meo (sergio.lo.meo@cern.ch) following what Ianna Osburne made for DTs (DD4HEP migration)
+//          Created:  Fri, 20 Sep 2019 
+*/
+
+#include "Geometry/MuonNumbering/interface/DD4hep_MuonNumbering.h"
+
+class MuonBaseNumber;
+class MuonConstants;
+
+namespace cms {
+  class RPCNumberingScheme {
+  public:
+    RPCNumberingScheme(const MuonConstants& muonConstants);
+    void baseNumberToUnitNumber(const MuonBaseNumber&);
+    int getDetId() const { return detId; }
+
+  private:
+    const int get(const char*, const MuonConstants&) const;
+    void initMe(const MuonConstants& muonConstants);
+    void setDetId(int idnew) { detId = idnew; }
+    int theRegionLevel;
+    int theBWheelLevel;
+    int theBStationLevel;
+    int theBPlaneLevel;
+    int theBChamberLevel;
+    int theEPlaneLevel;
+    int theESectorLevel;
+    int theERollLevel;
+
+    int detId;
+  };
+}  // namespace cms
+#endif

Geometry/MuonNumbering/src/DD4hep_RPCNumberingScheme.cc

@@ -0,0 +1,148 @@
+
+#include "Geometry/MuonNumbering/interface/DD4hep_RPCNumberingScheme.h"
+#include "Geometry/MuonNumbering/interface/DD4hep_MuonNumbering.h"
+#include "DataFormats/MuonDetId/interface/RPCDetId.h"
+#include "Geometry/MuonNumbering/interface/MuonBaseNumber.h"
+#include <FWCore/Utilities/interface/Exception.h>
+#include <cassert>
+
+using namespace cms;
+
+RPCNumberingScheme::RPCNumberingScheme(const MuonConstants& muonConstants) { initMe(muonConstants); }
+
+void RPCNumberingScheme::initMe(const MuonConstants& muonConstants) {
+  int levelPart = get("level", muonConstants);
+
+  assert(levelPart != 0);
+  theRegionLevel = get("mr_region", muonConstants) / levelPart;
+  theBWheelLevel = get("mr_bwheel", muonConstants) / levelPart;
+  theBStationLevel = get("mr_bstation", muonConstants) / levelPart;
+  theBPlaneLevel = get("mr_bplane", muonConstants) / levelPart;
+  theBChamberLevel = get("mr_bchamber", muonConstants) / levelPart;
+  theEPlaneLevel = get("mr_eplane", muonConstants) / levelPart;
+  theESectorLevel = get("mr_esector", muonConstants) / levelPart;
+  theERollLevel = get("mr_eroll", muonConstants) / levelPart;
+}
+
+void RPCNumberingScheme::baseNumberToUnitNumber(const MuonBaseNumber& num) {
+  const int barrel = num.getSuperNo(theRegionLevel);
+
+  bool barrel_muon = (barrel == 1);
+  int maxLevel;
+  if (barrel_muon) {
+    maxLevel = theBChamberLevel;
+  } else {
+    maxLevel = theERollLevel;
+  }
+  if (num.getLevels() != maxLevel) {
+    throw cms::Exception("DD4hep_RPCNumberingScheme", "num.getLevels() != maxLevel");
+  }
+
+  int plane_id = 0;
+  int sector_id = 0;
+  int copy_id = 0;
+  int roll_id = 0;
+  int eta_id = 0;
+  int rr12_id = 0;
+  bool forward = false;
+  int sector_copy = 0;
+
+  for (int level = 1; level <= maxLevel; level++) {
+    if (level == theRegionLevel) {
+      if (barrel_muon) {
+        roll_id = 0;
+      } else {
+        copy_id = 1;
+      }
+    }
+    if (barrel_muon) {
+      if (level == theBWheelLevel) {
+        const int copyno = num.getBaseNo(level);
+        eta_id = 4 + copyno;
+      } else if (level == theBStationLevel) {
+        const int copyno = num.getBaseNo(level);
+        sector_id = copyno + 1;
+        if (sector_id == 13) {
+          sector_id = 4;
+          sector_copy = 1;
+        } else if (sector_id == 14) {
+          sector_id = 10;
+          sector_copy = 1;
+        }
+        sector_id *= 3;
+      } else if (level == theBPlaneLevel) {
+        const int plane_tag = num.getSuperNo(level);
+        if (plane_tag == 1) {
+          plane_id = 1;
+        } else if (plane_tag == 2) {
+          plane_id = 5;
+        } else if (plane_tag == 3) {
+          plane_id = 2;
+        } else if (plane_tag == 4) {
+          plane_id = 6;
+        } else if (plane_tag == 5) {
+          plane_id = 3;
+        } else {
+          plane_id = 4;
+        }
+      } else if (level == theBChamberLevel) {
+        const int copyno = num.getBaseNo(level);
+        if ((plane_id == 4) && (sector_id == 4 * 3)) {
+          copy_id = sector_copy * 2 + copyno + 1;
+        } else if ((plane_id == 4) && (sector_id == 10 * 3)) {
+          copy_id = sector_copy + 1;
+        } else {
+          copy_id = copyno + 1;
+        }
+        const int rollno = num.getSuperNo(level);
+        roll_id = rollno;
+      }
+    } else {
+      if (level == theRegionLevel) {
+        const int copyno = num.getBaseNo(level);
+        forward = (copyno == 0);
+      } else if (level == theEPlaneLevel) {
+        const int plane_tag = num.getSuperNo(level);
+        const int rr12_tag = num.getBaseNo(level);
+        plane_id = plane_tag;
+        rr12_id = rr12_tag;
+      } else if (level == theESectorLevel) {
+        const int copyno = num.getBaseNo(level);
+        sector_id = copyno + 1;
+        if (rr12_id == 1) {
+          sector_id = sector_id * 2 - 1;
+        } else if (rr12_id == 2) {
+          sector_id = sector_id * 2;
+        }
+      } else if (level == theERollLevel) {
+        const int copyno = num.getBaseNo(level);
+        const int eta_tag = num.getSuperNo(level);
+        if ((eta_tag == 1) || (eta_tag == 4) || (eta_tag == 7) || (eta_tag == 8)) {
+          eta_id = 1;
+        } else if ((eta_tag == 2) || (eta_tag == 5)) {
+          eta_id = 2;
+        } else if ((eta_tag == 3) || (eta_tag == 6)) {
+          eta_id = 3;
+        }
+        if (forward)
+          eta_id = 12 - eta_id;
+        if ((eta_tag == 4) || (eta_tag == 7) || (eta_tag == 8)) {
+          sector_id *= 2;
+        }
+        roll_id = copyno + 1;
+      }
+    }
+  }
+  int trIndex = (eta_id * 10000 + plane_id * 1000 + sector_id * 10 + copy_id) * 10 + roll_id;
+  RPCDetId id;
+  id.buildfromTrIndex(trIndex);
+  setDetId(id.rawId());
+}
+
+const int RPCNumberingScheme::get(const char* key, const MuonConstants& muonConstants) const {
+  int result(0);
+  auto const& it = (muonConstants.find(key));
+  if (it != end(muonConstants))
+    result = it->second;
+  return result;
+}

Geometry/RPCGeometryBuilder/BuildFile.xml

@@ -1,6 +1,8 @@
 <use name="Geometry/MuonNumbering"/>
 <use name="Geometry/RPCGeometry"/>
 <use name="DetectorDescription/Core"/>
+<use name="DetectorDescription/DDCMS"/>
+<use name="dd4hep"/>
 <export>
  <lib name="1"/>
 </export>

Geometry/RPCGeometryBuilder/plugins/BuildFile.xml

@@ -1,11 +1,25 @@
+<use name="CondFormats/AlignmentRecord"/>
+<use name="CondFormats/Alignment"/>
+<use name="CondFormats/DataRecord"/>
+<use name="CondFormats/GeometryObjects"/>
+<use name="FWCore/Framework"/>
+<use name="FWCore/ParameterSet"/>
 <use name="Geometry/MuonNumbering"/>
 <use name="Geometry/Records"/>
+
+<library name="RPCGeometryPlugins" file="RPCGeometryESModule.cc">
+<use name="DetectorDescription/Core"/>
+<use name="DetectorDescription/DDCMS"/>
 <use name="Geometry/RPCGeometry"/>
+<use name="dd4hep"/>
+<lib name="Geom"/>
 <use name="Geometry/RPCGeometryBuilder"/>
-<use name="CondFormats/GeometryObjects"/>
-<use name="DetectorDescription/Core"/>
-<library file="RPCGeometryESModule.cc"> 
-  <flags EDM_PLUGIN="1"/>
+<flags EDM_PLUGIN="1"/>
 </library>
 
-
+<library name="RPCGeometryValidationPlugins" file="RPCGeometryValidate.cc">
+  <use name="Fireworks/Core"/>
+  <use name="Geometry/RPCGeometry"/>
+  <use name="rootgeom"/>
+  <flags EDM_PLUGIN="1"/>
+</library> 

Geometry/RPCGeometryBuilder/plugins/RPCGeometryESModule.cc

@@ -1,47 +1,67 @@
-/** \file
- *
- *  \author M. Maggi - INFN Bari
- */
+/*
+//\class RPCGeometryESModule
+
+ Description: RPC GeometryESModule from DD & DD4hep
+              DD4hep part added to the original old file (DD version) made by M. Maggi (INFN Bari)
+//
+// Author:  Sergio Lo Meo (sergio.lo.meo@cern.ch) following what Ianna Osburne made for DTs (DD4HEP migration)
+//          Created:  Fri, 20 Sep 2019 
+*/
 
 #include "Geometry/RPCGeometryBuilder/plugins/RPCGeometryESModule.h"
 #include "Geometry/RPCGeometryBuilder/src/RPCGeometryBuilderFromDDD.h"
 #include "Geometry/RPCGeometryBuilder/src/RPCGeometryBuilderFromCondDB.h"
 
+#include "Geometry/MuonNumbering/interface/DD4hep_MuonNumbering.h"
+#include "Geometry/MuonNumbering/interface/MuonDDDNumbering.h"
+#include "Geometry/MuonNumbering/interface/MuonBaseNumber.h"
+
 #include <FWCore/Framework/interface/EventSetup.h>
 #include "FWCore/Framework/interface/ESTransientHandle.h"
 #include <FWCore/Framework/interface/ESHandle.h>
 #include <FWCore/Framework/interface/ModuleFactory.h>
 #include <FWCore/Framework/interface/ESProducer.h>
 
+#include <unordered_map>
+
 #include <memory>
 
 using namespace edm;
 
 RPCGeometryESModule::RPCGeometryESModule(const edm::ParameterSet& p)
-    : comp11{p.getUntrackedParameter<bool>("compatibiltyWith11", true)},
-      // Find out if using the DDD or CondDB Geometry source.
-      useDDD{p.getUntrackedParameter<bool>("useDDD", true)} {
+    : comp11_{p.getUntrackedParameter<bool>("compatibiltyWith11", true)},
+      useDDD_{p.getUntrackedParameter<bool>("useDDD", true)},
+      useDD4hep_{p.getUntrackedParameter<bool>("useDD4hep", false)} {
   auto cc = setWhatProduced(this);
 
   const edm::ESInputTag kEmptyTag;
-  if (useDDD) {
+  if (useDDD_) {
     idealGeomToken_ = cc.consumesFrom<DDCompactView, IdealGeometryRecord>(kEmptyTag);
     dddConstantsToken_ = cc.consumesFrom<MuonDDDConstants, MuonNumberingRecord>(kEmptyTag);
+  } else if (useDD4hep_) {
+    idealDD4hepGeomToken_ = cc.consumesFrom<cms::DDCompactView, IdealGeometryRecord>(kEmptyTag);
+    dd4hepConstantsToken_ = cc.consumesFrom<cms::MuonNumbering, MuonNumberingRecord>(kEmptyTag);
   } else {
     recoIdealToken_ = cc.consumesFrom<RecoIdealGeometry, RPCRecoGeometryRcd>(kEmptyTag);
   }
 }
 
 std::unique_ptr<RPCGeometry> RPCGeometryESModule::produce(const MuonGeometryRecord& record) {
-  if (useDDD) {
+  if (useDDD_) {
     edm::ESTransientHandle<DDCompactView> cpv = record.getTransientHandle(idealGeomToken_);
 
     auto const& mdc = record.get(dddConstantsToken_);
-    RPCGeometryBuilderFromDDD builder(comp11);
+    RPCGeometryBuilderFromDDD builder(comp11_);
+    return std::unique_ptr<RPCGeometry>(builder.build(&(*cpv), mdc));
+  } else if (useDD4hep_) {
+    edm::ESTransientHandle<cms::DDCompactView> cpv = record.getTransientHandle(idealDD4hepGeomToken_);
+
+    auto const& mdc = record.get(dd4hepConstantsToken_);
+    RPCGeometryBuilderFromDDD builder(comp11_);
     return std::unique_ptr<RPCGeometry>(builder.build(&(*cpv), mdc));
   } else {
     auto const& rigrpc = record.get(recoIdealToken_);
-    RPCGeometryBuilderFromCondDB builder(comp11);
+    RPCGeometryBuilderFromCondDB builder(comp11_);
     return std::unique_ptr<RPCGeometry>(builder.build(rigrpc));
   }
 }

Geometry/RPCGeometryBuilder/plugins/RPCGeometryESModule.h

@@ -1,12 +1,15 @@
 #ifndef RPCGeometry_RPCGeometryESModule_h
 #define RPCGeometry_RPCGeometryESModule_h
 
-/** \class RPCGeometryESModule
- * 
- *  ESProducer for RPCGeometry in MuonGeometryRecord
- *
- *  \author M. Maggi - INFN Bari
- */
+/*
+//\class RPCGeometryESModule
+
+ Description: RPC GeometryESModule from DD & DD4hep
+              DD4hep part added to the original old file (DD version) made by M. Maggi (INFN Bari)
+//
+// Author:  Sergio Lo Meo (sergio.lo.meo@cern.ch) following what Ianna Osburne made for DTs (DD4HEP migration)
+//          Created:  Fri, 20 Sep 2019 
+*/
 
 #include <FWCore/Framework/interface/ESProducer.h>
 #include <FWCore/ParameterSet/interface/ParameterSet.h>
@@ -15,7 +18,9 @@
 
 #include <Geometry/Records/interface/IdealGeometryRecord.h>
 #include <Geometry/MuonNumbering/interface/MuonDDDConstants.h>
+#include <Geometry/MuonNumbering/interface/DD4hep_MuonNumbering.h>
 #include <DetectorDescription/Core/interface/DDCompactView.h>
+#include <DetectorDescription/DDCMS/interface/DDCompactView.h>
 
 #include "Geometry/Records/interface/RPCRecoGeometryRcd.h"
 #include "CondFormats/GeometryObjects/interface/RecoIdealGeometry.h"
@@ -24,24 +29,23 @@
 
 class RPCGeometryESModule : public edm::ESProducer {
 public:
-  /// Constructor
   RPCGeometryESModule(const edm::ParameterSet& p);
-
-  /// Destructor
   ~RPCGeometryESModule() override = default;
-
-  /// Produce RPCGeometry.
   std::unique_ptr<RPCGeometry> produce(const MuonGeometryRecord& record);
 
 private:
-  //Used without DDD
+  //DDD
   edm::ESGetToken<DDCompactView, IdealGeometryRecord> idealGeomToken_;
   edm::ESGetToken<MuonDDDConstants, MuonNumberingRecord> dddConstantsToken_;
+  // dd4hep
+  edm::ESGetToken<cms::DDCompactView, IdealGeometryRecord> idealDD4hepGeomToken_;
+  edm::ESGetToken<cms::MuonNumbering, MuonNumberingRecord> dd4hepConstantsToken_;
 
-  //Used with DDD
+  //DDD
   edm::ESGetToken<RecoIdealGeometry, RPCRecoGeometryRcd> recoIdealToken_;
 
-  const bool comp11;
-  const bool useDDD;
+  const bool comp11_;
+  const bool useDDD_;
+  const bool useDD4hep_;
 };
 #endif