From 6e64e762b657a47482e6658eb06241667c923053 Mon Sep 17 00:00:00 2001 From: Sunanda Date: Tue, 7 Feb 2023 10:03:57 +0100 Subject: [PATCH] Provide the geometry for HGCal Test Beam application --- .../HGCalGeometry/interface/HGCalTBGeometry.h | 143 +++++ .../interface/HGCalTBGeometryLoader.h | 27 + .../plugins/HGCalTBGeometryESProducer.cc | 77 +++ .../python/HGCalTBGeometryESProducer_cfi.py | 13 + Geometry/HGCalGeometry/src/HGCalGeometry.cc | 2 +- Geometry/HGCalGeometry/src/HGCalTBGeometry.cc | 515 ++++++++++++++++++ .../src/HGCalTBGeometryLoader.cc | 111 ++++ .../HGCalGeometry/test/HGCalTBGeometryDump.cc | 61 +++ .../test/python/testHGCalTBCellDump_cfg.py | 25 + 9 files changed, 973 insertions(+), 1 deletion(-) create mode 100644 Geometry/HGCalGeometry/interface/HGCalTBGeometry.h create mode 100644 Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h create mode 100644 Geometry/HGCalGeometry/plugins/HGCalTBGeometryESProducer.cc create mode 100644 Geometry/HGCalGeometry/python/HGCalTBGeometryESProducer_cfi.py create mode 100644 Geometry/HGCalGeometry/src/HGCalTBGeometry.cc create mode 100644 Geometry/HGCalGeometry/src/HGCalTBGeometryLoader.cc create mode 100644 Geometry/HGCalGeometry/test/HGCalTBGeometryDump.cc create mode 100644 Geometry/HGCalGeometry/test/python/testHGCalTBCellDump_cfg.py diff --git a/Geometry/HGCalGeometry/interface/HGCalTBGeometry.h b/Geometry/HGCalGeometry/interface/HGCalTBGeometry.h new file mode 100644 index 0000000000000..512b4cc1d451a --- /dev/null +++ b/Geometry/HGCalGeometry/interface/HGCalTBGeometry.h @@ -0,0 +1,143 @@ +#ifndef GeometryHGCalGeometryHGCalTBGeometry_h +#define GeometryHGCalGeometryHGCalTBGeometry_h + +/* + * Geometry for High Granularity Calorimeter TestBeam + * This geometry is essentially driven by topology, + * which is thus encapsulated in this class. + * This makes this geometry not suitable to be loaded + * by regular CaloGeometryLoader + */ + +#include "DataFormats/Common/interface/AtomicPtrCache.h" +#include "DataFormats/ForwardDetId/interface/HFNoseDetId.h" +#include "DataFormats/ForwardDetId/interface/HGCalDetId.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" +#include "DataFormats/GeometryVector/interface/GlobalVector.h" +#include "DetectorDescription/Core/interface/DDFilteredView.h" +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "Geometry/CaloGeometry/interface/FlatHexagon.h" +#include "Geometry/CaloGeometry/interface/FlatTrd.h" +#include "Geometry/Records/interface/IdealGeometryRecord.h" +#include "Geometry/CaloTopology/interface/HGCalTBTopology.h" +#include "Geometry/Records/interface/HGCalGeometryRecord.h" +#include "MagneticField/Engine/interface/MagneticField.h" +#include + +class HGCalTBGeometry final : public CaloSubdetectorGeometry { +public: + typedef std::vector CellVec; + typedef std::vector CellVec2; + typedef CaloCellGeometry::CCGFloat CCGFloat; + typedef CaloCellGeometry::Pt3D Pt3D; + typedef CaloCellGeometry::Pt3DVec Pt3DVec; + + typedef std::set DetIdSet; + typedef std::vector CornersVec; + + typedef HGCalGeometryRecord AlignedRecord; // NOTE: not aligned yet + typedef PHGCalRcd PGeometryRecord; + + static constexpr unsigned int k_NumberOfParametersPerTrd = 12; // FlatTrd + static constexpr unsigned int k_NumberOfParametersPerHex = 3; // FlatHexagon + static constexpr unsigned int k_NumberOfParametersPerShape = 3; // FlatHexagon + static constexpr unsigned int k_NumberOfShapes = 100; + static constexpr unsigned int k_NumberOfShapesTrd = 1000; + + static std::string dbString() { return "PHGCalTBRcd"; } + + HGCalTBGeometry(const HGCalTBTopology& topology); + + ~HGCalTBGeometry() override; + + void localCorners(Pt3DVec& lc, const CCGFloat* pv, unsigned int i, Pt3D& ref); + + void newCell(const GlobalPoint& f1, + const GlobalPoint& f2, + const GlobalPoint& f3, + const CCGFloat* parm, + const DetId& detId) override; + + /// Get the cell geometry of a given detector id. Should return false if not found. + std::shared_ptr getGeometry(const DetId& id) const override; + + bool present(const DetId& id) const override; + + void getSummary(CaloSubdetectorGeometry::TrVec& trVector, + CaloSubdetectorGeometry::IVec& iVector, + CaloSubdetectorGeometry::DimVec& dimVector, + CaloSubdetectorGeometry::IVec& dinsVector) const override; + + GlobalPoint getPosition(const DetId& id, bool debug = false) const; + GlobalPoint getWaferPosition(const DetId& id) const; + + /// Returns area of a cell + double getArea(const DetId& detid) const; + + /// Returns the corner points of this cell's volume. + CornersVec getCorners(const DetId& id) const; + CornersVec get8Corners(const DetId& id) const; + CornersVec getNewCorners(const DetId& id, bool debug = false) const; + + // Get neighbor in z along a direction + DetId neighborZ(const DetId& idin, const GlobalVector& p) const; + DetId neighborZ(const DetId& idin, const MagneticField* bField, int charge, const GlobalVector& momentum) const; + + // avoid sorting set in base class + const std::vector& getValidDetIds(DetId::Detector det = DetId::Detector(0), int subdet = 0) const override { + return m_validIds; + } + const std::vector& getValidGeomDetIds(void) const { return m_validGeomIds; } + + // Get closest cell, etc... + DetId getClosestCell(const GlobalPoint& r) const override; + + /** \brief Get a list of all cells within a dR of the given cell + + The default implementation makes a loop over all cell geometries. + Cleverer implementations are suggested to use rough conversions between + eta/phi and ieta/iphi and test on the boundaries. + */ + DetIdSet getCells(const GlobalPoint& r, double dR) const override; + + virtual void fillNamedParams(DDFilteredView fv); + void initializeParms() override; + + static std::string producerTag() { return "HGCalTB"; } + std::string cellElement() const; + + const HGCalTBTopology& topology() const { return m_topology; } + void sortDetIds(); + +protected: + unsigned int indexFor(const DetId& id) const override; + using CaloSubdetectorGeometry::sizeForDenseIndex; + unsigned int sizeForDenseIndex() const; + + // Modify the RawPtr class + const CaloCellGeometry* getGeometryRawPtr(uint32_t index) const override; + + std::shared_ptr cellGeomPtr(uint32_t index) const override; + + void addValidID(const DetId& id); + unsigned int getClosestCellIndex(const GlobalPoint& r) const; + +private: + template + unsigned int getClosestCellIndex(const GlobalPoint& r, const std::vector& vec) const; + std::shared_ptr cellGeomPtr(uint32_t index, const GlobalPoint& p) const; + DetId getGeometryDetId(DetId detId) const; + + static constexpr double k_half = 0.5; + static constexpr double k_fac1 = 0.5; + static constexpr double k_fac2 = 1.0 / 3.0; + + const HGCalTBTopology& m_topology; + CellVec m_cellVec; + std::vector m_validGeomIds; + DetId::Detector m_det; + ForwardSubdetector m_subdet; + const double twoBysqrt3_; +}; + +#endif diff --git a/Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h b/Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h new file mode 100644 index 0000000000000..cc7bb74e371a4 --- /dev/null +++ b/Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h @@ -0,0 +1,27 @@ +#ifndef GeometryHGCalGeometryHGCalTBGeometryLoader_h +#define GeometryHGCalGeometryHGCalTBGeometryLoader_h +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" +#include "Geometry/CaloGeometry/interface/FlatHexagon.h" + +class HGCalTBTopology; +class HGCalTBGeometry; + +class HGCalTBGeometryLoader { +public: + typedef CaloCellGeometry::CCGFloat CCGFloat; + typedef std::vector ParmVec; + + HGCalTBGeometryLoader(); + ~HGCalTBGeometryLoader() = default; + + HGCalTBGeometry* build(const HGCalTBTopology&); + +private: + void buildGeom(const ParmVec&, const HepGeom::Transform3D&, const DetId&, HGCalTBGeometry*); + + const double twoBysqrt3_; + int parametersPerShape_; +}; + +#endif diff --git a/Geometry/HGCalGeometry/plugins/HGCalTBGeometryESProducer.cc b/Geometry/HGCalGeometry/plugins/HGCalTBGeometryESProducer.cc new file mode 100644 index 0000000000000..ebabcfadcb6cf --- /dev/null +++ b/Geometry/HGCalGeometry/plugins/HGCalTBGeometryESProducer.cc @@ -0,0 +1,77 @@ +// -*- C++ -*- +// +// Package: HGCalGeometry +// Class: HGCalTBGeometryESProducer +// +/**\class HGCalTBGeometryESProducer HGCalTBGeometryESProducer.h + + Description: + + Implementation: + +*/ +// +// Original Author: Sunanda Banerjee +// +// + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "Geometry/CaloTopology/interface/HGCalTBTopology.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometry.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h" +#include "Geometry/Records/interface/IdealGeometryRecord.h" + +//#define EDM_ML_DEBUG + +// +// class decleration +// + +class HGCalTBGeometryESProducer : public edm::ESProducer { +public: + HGCalTBGeometryESProducer(const edm::ParameterSet& iP); + ~HGCalTBGeometryESProducer() override; + + using ReturnType = std::unique_ptr; + + ReturnType produce(const IdealGeometryRecord&); + +private: + // ----------member data --------------------------- + edm::ESGetToken topologyToken_; + std::string name_; +}; + +HGCalTBGeometryESProducer::HGCalTBGeometryESProducer(const edm::ParameterSet& iConfig) { + name_ = iConfig.getUntrackedParameter("Name"); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "Constructing HGCalTBGeometry for " << name_; +#endif + auto cc = setWhatProduced(this, name_); + topologyToken_ = cc.consumes(edm::ESInputTag{"", name_}); +} + +HGCalTBGeometryESProducer::~HGCalTBGeometryESProducer() {} + +// +// member functions +// + +// ------------ method called to produce the data ------------ +HGCalTBGeometryESProducer::ReturnType HGCalTBGeometryESProducer::produce(const IdealGeometryRecord& iRecord) { + const auto& topo = iRecord.get(topologyToken_); + edm::LogVerbatim("HGCalGeom") << "Create HGCalTBGeometry (*topo) for " << name_; + + HGCalTBGeometryLoader builder; + return ReturnType(builder.build(topo)); +} + +DEFINE_FWK_EVENTSETUP_MODULE(HGCalTBGeometryESProducer); diff --git a/Geometry/HGCalGeometry/python/HGCalTBGeometryESProducer_cfi.py b/Geometry/HGCalGeometry/python/HGCalTBGeometryESProducer_cfi.py new file mode 100644 index 0000000000000..0a37d12c0370c --- /dev/null +++ b/Geometry/HGCalGeometry/python/HGCalTBGeometryESProducer_cfi.py @@ -0,0 +1,13 @@ +import FWCore.ParameterSet.Config as cms + +# +# This cfi should be included to build the HGCal TB Geometry +# + +HGCalTBEEGeometryESProducer = cms.ESProducer("HGCalTBGeometryESProducer", + Name = cms.untracked.string("HGCalEESensitive") ) + + +HGCalTBHESilGeometryESProducer = cms.ESProducer("HGCalTBGeometryESProducer", + Name = cms.untracked.string("HGCalHESiliconSensitive") ) + diff --git a/Geometry/HGCalGeometry/src/HGCalGeometry.cc b/Geometry/HGCalGeometry/src/HGCalGeometry.cc index ac05c04e3cbac..908711f77a02b 100644 --- a/Geometry/HGCalGeometry/src/HGCalGeometry.cc +++ b/Geometry/HGCalGeometry/src/HGCalGeometry.cc @@ -656,7 +656,7 @@ const CaloCellGeometry* HGCalGeometry::getGeometryRawPtr(uint32_t index) const { const CaloCellGeometry* cell(&m_cellVec2[index]); return (nullptr == cell->param() ? nullptr : cell); } else { - if (m_cellVec2.size() < index) + if (m_cellVec.size() < index) return nullptr; const CaloCellGeometry* cell(&m_cellVec[index]); return (nullptr == cell->param() ? nullptr : cell); diff --git a/Geometry/HGCalGeometry/src/HGCalTBGeometry.cc b/Geometry/HGCalGeometry/src/HGCalTBGeometry.cc new file mode 100644 index 0000000000000..451d2518d9630 --- /dev/null +++ b/Geometry/HGCalGeometry/src/HGCalTBGeometry.cc @@ -0,0 +1,515 @@ +/* for High Granularity Calorimeter TestBeam + * This geometry is essentially driven by topology, + * which is thus encapsulated in this class. + * This makes this geometry not suitable to be loaded + * by regular CaloGeometryLoader + */ +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "DataFormats/GeometrySurface/interface/Plane.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" +#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "TrackingTools/GeomPropagators/interface/AnalyticalPropagator.h" + +#include + +#include +#include + +typedef CaloCellGeometry::Tr3D Tr3D; +typedef std::vector ParmVec; + +//#define EDM_ML_DEBUG + +const bool debugLocate = false; + +HGCalTBGeometry::HGCalTBGeometry(const HGCalTBTopology& topology_) + : m_topology(topology_), + m_validGeomIds(topology_.totalGeomModules()), + m_det(topology_.detector()), + m_subdet(topology_.subDetector()), + twoBysqrt3_(2.0 / std::sqrt(3.0)) { + m_cellVec = CellVec(topology_.totalGeomModules()); + m_validIds.reserve(m_topology.totalModules()); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "Expected total # of Geometry Modules " << m_topology.totalGeomModules(); +#endif +} + +HGCalTBGeometry::~HGCalTBGeometry() {} + +void HGCalTBGeometry::fillNamedParams(DDFilteredView fv) {} + +void HGCalTBGeometry::initializeParms() {} + +void HGCalTBGeometry::localCorners(Pt3DVec& lc, const CCGFloat* pv, unsigned int i, Pt3D& ref) { + FlatHexagon::localCorners(lc, pv, ref); +} + +void HGCalTBGeometry::newCell( + const GlobalPoint& f1, const GlobalPoint& f2, const GlobalPoint& f3, const CCGFloat* parm, const DetId& detId) { + DetId geomId = getGeometryDetId(detId); + int cells(0); + HGCalTBTopology::DecodedDetId id = m_topology.decode(detId); + cells = m_topology.dddConstants().numberCellsHexagon(id.iSec1); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "NewCell " << HGCalDetId(detId) << " GEOM " << HGCalDetId(geomId); +#endif + const uint32_t cellIndex(m_topology.detId2denseGeomId(geomId)); + + m_cellVec.at(cellIndex) = FlatHexagon(cornersMgr(), f1, f2, f3, parm); + m_validGeomIds.at(cellIndex) = geomId; + +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "Store for DetId " << std::hex << detId.rawId() << " GeomId " << geomId.rawId() + << std::dec << " Index " << cellIndex << " cells " << cells; + unsigned int nOld = m_validIds.size(); +#endif + for (int cell = 0; cell < cells; ++cell) { + id.iCell1 = cell; + DetId idc = m_topology.encode(id); + if (m_topology.valid(idc)) { + m_validIds.emplace_back(idc); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "Valid Id [" << cell << "] " << HGCalDetId(idc); +#endif + } + } +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "HGCalTBGeometry::newCell-> [" << cellIndex << "]" + << " front:" << f1.x() << '/' << f1.y() << '/' << f1.z() << " back:" << f2.x() << '/' + << f2.y() << '/' << f2.z() << " eta|phi " << m_cellVec[cellIndex].etaPos() << ":" + << m_cellVec[cellIndex].phiPos(); + unsigned int nNew = m_validIds.size(); + edm::LogVerbatim("HGCalGeom") << "ID: " << HGCalDetId(detId) << " with valid DetId from " << nOld << " to " << nNew; +#endif +} + +std::shared_ptr HGCalTBGeometry::getGeometry(const DetId& detId) const { + if (detId == DetId()) + return nullptr; // nothing to get + DetId geomId = getGeometryDetId(detId); + const uint32_t cellIndex(m_topology.detId2denseGeomId(geomId)); + const GlobalPoint pos = (detId != geomId) ? getPosition(detId, false) : GlobalPoint(); + return cellGeomPtr(cellIndex, pos); +} + +bool HGCalTBGeometry::present(const DetId& detId) const { + if (detId == DetId()) + return false; + DetId geomId = getGeometryDetId(detId); + const uint32_t index(m_topology.detId2denseGeomId(geomId)); + return (nullptr != getGeometryRawPtr(index)); +} + +GlobalPoint HGCalTBGeometry::getPosition(const DetId& detid, bool debug) const { + unsigned int cellIndex = indexFor(detid); + GlobalPoint glob; + unsigned int maxSize = m_cellVec.size(); + if (cellIndex < maxSize) { + HGCalTBTopology::DecodedDetId id = m_topology.decode(detid); + std::pair xy; + xy = m_topology.dddConstants().locateCellHex(id.iCell1, id.iSec1, true); + const HepGeom::Point3D lcoord(xy.first, xy.second, 0); + glob = m_cellVec[cellIndex].getPosition(lcoord); + if (debug) + edm::LogVerbatim("HGCalGeom") << "getPosition:: index " << cellIndex << " Local " << lcoord.x() << ":" + << lcoord.y() << " ID " << id.iCell1 << ":" << id.iSec1 << " Global " << glob; + } + return glob; +} + +GlobalPoint HGCalTBGeometry::getWaferPosition(const DetId& detid) const { + unsigned int cellIndex = indexFor(detid); + GlobalPoint glob; + unsigned int maxSize = m_cellVec.size(); + if (cellIndex < maxSize) { + const HepGeom::Point3D lcoord(0, 0, 0); + glob = m_cellVec[cellIndex].getPosition(lcoord); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "getWaferPosition:: ID " << std::hex << detid.rawId() << std::dec << " index " + << cellIndex << " Global " << glob; +#endif + } + return glob; +} + +double HGCalTBGeometry::getArea(const DetId& detid) const { + HGCalTBGeometry::CornersVec corners = getNewCorners(detid); + double area(0); + if (corners.size() > 1) { + int n = corners.size() - 1; + int j = n - 1; + for (int i = 0; i < n; ++i) { + area += ((corners[j].x() + corners[i].x()) * (corners[i].y() - corners[j].y())); + j = i; + } + } + return std::abs(0.5 * area); +} + +HGCalTBGeometry::CornersVec HGCalTBGeometry::getCorners(const DetId& detid) const { + unsigned int ncorner = ((m_det == DetId::HGCalHSc) ? FlatTrd::ncorner_ : FlatHexagon::ncorner_); + HGCalTBGeometry::CornersVec co(ncorner, GlobalPoint(0, 0, 0)); + unsigned int cellIndex = indexFor(detid); + HGCalTBTopology::DecodedDetId id = m_topology.decode(detid); + if (cellIndex < m_cellVec.size()) { + std::pair xy; + xy = m_topology.dddConstants().locateCellHex(id.iCell1, id.iSec1, true); + float dx = m_cellVec[cellIndex].param()[FlatHexagon::k_r]; + float dy = k_half * m_cellVec[cellIndex].param()[FlatHexagon::k_R]; + float dz = m_cellVec[cellIndex].param()[FlatHexagon::k_dZ]; + static const int signx[] = {0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, 1}; + static const int signy[] = {-2, -1, 1, 2, 1, -1, -2, -1, 1, 2, 1, -1}; + static const int signz[] = {-1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1}; + for (unsigned int i = 0; i < ncorner; ++i) { + const HepGeom::Point3D lcoord(xy.first + signx[i] * dx, xy.second + signy[i] * dy, signz[i] * dz); + co[i] = m_cellVec[cellIndex].getPosition(lcoord); + } + } + return co; +} + +HGCalTBGeometry::CornersVec HGCalTBGeometry::get8Corners(const DetId& detid) const { + unsigned int ncorner = FlatTrd::ncorner_; + HGCalTBGeometry::CornersVec co(ncorner, GlobalPoint(0, 0, 0)); + unsigned int cellIndex = indexFor(detid); + HGCalTBTopology::DecodedDetId id = m_topology.decode(detid); + if (cellIndex < m_cellVec.size()) { + std::pair xy; + float dx(0); + static const int signx[] = {-1, -1, 1, 1, -1, -1, 1, 1}; + static const int signy[] = {-1, 1, 1, -1, -1, 1, 1, -1}; + static const int signz[] = {-1, -1, -1, -1, 1, 1, 1, 1}; + xy = m_topology.dddConstants().locateCellHex(id.iCell1, id.iSec1, true); + dx = m_cellVec[cellIndex].param()[FlatHexagon::k_r]; + float dz = m_cellVec[cellIndex].param()[FlatHexagon::k_dZ]; + for (unsigned int i = 0; i < ncorner; ++i) { + const HepGeom::Point3D lcoord(xy.first + signx[i] * dx, xy.second + signy[i] * dx, signz[i] * dz); + co[i] = m_cellVec[cellIndex].getPosition(lcoord); + } + } + return co; +} + +HGCalTBGeometry::CornersVec HGCalTBGeometry::getNewCorners(const DetId& detid, bool debug) const { + unsigned int ncorner = (m_det == DetId::HGCalHSc) ? 5 : 7; + HGCalTBGeometry::CornersVec co(ncorner, GlobalPoint(0, 0, 0)); + unsigned int cellIndex = indexFor(detid); + HGCalTBTopology::DecodedDetId id = m_topology.decode(detid); + if (debug) + edm::LogVerbatim("HGCalGeom") << "NewCorners for Layer " << id.iLay << " Wafer " << id.iSec1 << ":" << id.iSec2 + << " Cell " << id.iCell1 << ":" << id.iCell2; + if (cellIndex < m_cellVec.size()) { + std::pair xy; + float dx = k_fac2 * m_cellVec[cellIndex].param()[FlatHexagon::k_r]; + float dy = k_fac1 * m_cellVec[cellIndex].param()[FlatHexagon::k_R]; + float dz = -id.zSide * m_cellVec[cellIndex].param()[FlatHexagon::k_dZ]; + static const int signx[] = {1, -1, -2, -1, 1, 2}; + static const int signy[] = {1, 1, 0, -1, -1, 0}; +#ifdef EDM_ML_DEBUG + if (debug) + edm::LogVerbatim("HGCalGeom") << "kfac " << k_fac1 << ":" << k_fac2 << " dx:dy:dz " << dx << ":" << dy << ":" + << dz; +#endif + xy = m_topology.dddConstants().locateCellHex(id.iCell1, id.iSec1, true); + for (unsigned int i = 0; i < ncorner - 1; ++i) { + const HepGeom::Point3D lcoord(xy.first + signx[i] * dx, xy.second + signy[i] * dy, dz); + co[i] = m_cellVec[cellIndex].getPosition(lcoord); + } + // Used to pass downstream the thickness of this cell + co[ncorner - 1] = GlobalPoint(0, 0, -2 * dz); + } + return co; +} + +DetId HGCalTBGeometry::neighborZ(const DetId& idin, const GlobalVector& momentum) const { + DetId idnew; + HGCalTBTopology::DecodedDetId id = m_topology.decode(idin); + int lay = ((momentum.z() * id.zSide > 0) ? (id.iLay + 1) : (id.iLay - 1)); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "neighborz1:: ID " << id.iLay << ":" << id.iSec1 << ":" << id.iSec2 << ":" + << id.iCell1 << ":" << id.iCell2 << " New Layer " << lay << " Range " + << m_topology.dddConstants().firstLayer() << ":" + << m_topology.dddConstants().lastLayer(true) << " pz " << momentum.z(); +#endif + if ((lay >= m_topology.dddConstants().firstLayer()) && (lay <= m_topology.dddConstants().lastLayer(true)) && + (momentum.z() != 0.0)) { + GlobalPoint v = getPosition(idin, false); + double z = id.zSide * m_topology.dddConstants().waferZ(lay, true); + double grad = (z - v.z()) / momentum.z(); + GlobalPoint p(v.x() + grad * momentum.x(), v.y() + grad * momentum.y(), z); + double r = p.perp(); + auto rlimit = topology().dddConstants().rangeR(z, true); + if (r >= rlimit.first && r <= rlimit.second) + idnew = getClosestCell(p); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "neighborz1:: Position " << v << " New Z " << z << ":" << grad << " new position " + << p << " r-limit " << rlimit.first << ":" << rlimit.second; +#endif + } + return idnew; +} + +DetId HGCalTBGeometry::neighborZ(const DetId& idin, + const MagneticField* bField, + int charge, + const GlobalVector& momentum) const { + DetId idnew; + HGCalTBTopology::DecodedDetId id = m_topology.decode(idin); + int lay = ((momentum.z() * id.zSide > 0) ? (id.iLay + 1) : (id.iLay - 1)); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "neighborz2:: ID " << id.iLay << ":" << id.iSec1 << ":" << id.iSec2 << ":" + << id.iCell1 << ":" << id.iCell2 << " New Layer " << lay << " Range " + << m_topology.dddConstants().firstLayer() << ":" + << m_topology.dddConstants().lastLayer(true) << " pz " << momentum.z(); +#endif + if ((lay >= m_topology.dddConstants().firstLayer()) && (lay <= m_topology.dddConstants().lastLayer(true)) && + (momentum.z() != 0.0)) { + GlobalPoint v = getPosition(idin, false); + double z = id.zSide * m_topology.dddConstants().waferZ(lay, true); + FreeTrajectoryState fts(v, momentum, charge, bField); + Plane::PlanePointer nPlane = Plane::build(Plane::PositionType(0, 0, z), Plane::RotationType()); + AnalyticalPropagator myAP(bField, alongMomentum, 2 * M_PI); + TrajectoryStateOnSurface tsos = myAP.propagate(fts, *nPlane); + GlobalPoint p; + auto rlimit = topology().dddConstants().rangeR(z, true); + if (tsos.isValid()) { + p = tsos.globalPosition(); + double r = p.perp(); + if (r >= rlimit.first && r <= rlimit.second) + idnew = getClosestCell(p); + } +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "neighborz2:: Position " << v << " New Z " << z << ":" << charge << ":" + << tsos.isValid() << " new position " << p << " r limits " << rlimit.first << ":" + << rlimit.second; +#endif + } + return idnew; +} + +DetId HGCalTBGeometry::getClosestCell(const GlobalPoint& r) const { + unsigned int cellIndex = getClosestCellIndex(r); + if (cellIndex < m_cellVec.size()) { + HGCalTBTopology::DecodedDetId id = m_topology.decode(m_validGeomIds[cellIndex]); + if (id.det == 0) + id.det = static_cast(m_topology.detector()); + HepGeom::Point3D local; + if (r.z() > 0) { + local = HepGeom::Point3D(r.x(), r.y(), 0); + id.zSide = 1; + } else { + local = HepGeom::Point3D(-r.x(), r.y(), 0); + id.zSide = -1; + } + const auto& kxy = m_topology.dddConstants().assignCell(local.x(), local.y(), id.iLay, id.iType, true); + id.iCell1 = kxy.second; + id.iSec1 = kxy.first; + id.iType = m_topology.dddConstants().waferTypeT(kxy.first); + if (id.iType != 1) + id.iType = -1; +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "getClosestCell: local " << local << " Id " << id.det << ":" << id.zSide << ":" + << id.iLay << ":" << id.iSec1 << ":" << id.iSec2 << ":" << id.iType << ":" + << id.iCell1 << ":" << id.iCell2; +#endif + //check if returned cell is valid + if (id.iCell1 >= 0) + return m_topology.encode(id); + } + + //if not valid or out of bounds return a null DetId + return DetId(); +} + +HGCalTBGeometry::DetIdSet HGCalTBGeometry::getCells(const GlobalPoint& r, double dR) const { + HGCalTBGeometry::DetIdSet dss; + return dss; +} + +std::string HGCalTBGeometry::cellElement() const { + if (m_subdet == HGCEE) + return "HGCalEE"; + else if (m_subdet == HGCHEF) + return "HGCalHEFront"; + else + return "Unknown"; +} + +unsigned int HGCalTBGeometry::indexFor(const DetId& detId) const { + unsigned int cellIndex = m_cellVec.size(); + if (detId != DetId()) { + DetId geomId = getGeometryDetId(detId); + cellIndex = m_topology.detId2denseGeomId(geomId); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "indexFor " << std::hex << detId.rawId() << ":" << geomId.rawId() << std::dec + << " index " << cellIndex; +#endif + } + return cellIndex; +} + +unsigned int HGCalTBGeometry::sizeForDenseIndex() const { return m_topology.totalGeomModules(); } + +const CaloCellGeometry* HGCalTBGeometry::getGeometryRawPtr(uint32_t index) const { + // Modify the RawPtr class + if (m_cellVec.size() < index) + return nullptr; + const CaloCellGeometry* cell(&m_cellVec[index]); + return (nullptr == cell->param() ? nullptr : cell); +} + +std::shared_ptr HGCalTBGeometry::cellGeomPtr(uint32_t index) const { + if (index >= m_cellVec.size()) + return nullptr; + static const auto do_not_delete = [](const void*) {}; + auto cell = std::shared_ptr(&m_cellVec[index], do_not_delete); + if (nullptr == cell->param()) + return nullptr; + return cell; +} + +std::shared_ptr HGCalTBGeometry::cellGeomPtr(uint32_t index, const GlobalPoint& pos) const { + if ((index >= m_cellVec.size()) || (m_validGeomIds[index].rawId() == 0)) + return nullptr; + if (pos == GlobalPoint()) + return cellGeomPtr(index); + auto cell = std::make_shared(m_cellVec[index]); + cell->setPosition(pos); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "cellGeomPtr " << index << ":" << cell; +#endif + if (nullptr == cell->param()) + return nullptr; + return cell; +} + +void HGCalTBGeometry::addValidID(const DetId& id) { + edm::LogError("HGCalGeom") << "HGCalTBGeometry::addValidID is not implemented"; +} + +unsigned int HGCalTBGeometry::getClosestCellIndex(const GlobalPoint& r) const { + return (getClosestCellIndex(r, m_cellVec)); +} + +template +unsigned int HGCalTBGeometry::getClosestCellIndex(const GlobalPoint& r, const std::vector& vec) const { + float phip = r.phi(); + float zp = r.z(); + float dzmin(9999), dphimin(9999), dphi10(0.175); + unsigned int cellIndex = vec.size(); + for (unsigned int k = 0; k < vec.size(); ++k) { + float dphi = phip - vec[k].phiPos(); + while (dphi > M_PI) + dphi -= 2 * M_PI; + while (dphi <= -M_PI) + dphi += 2 * M_PI; + if (std::abs(dphi) < dphi10) { + float dz = std::abs(zp - vec[k].getPosition().z()); + if (dz < (dzmin + 0.001)) { + dzmin = dz; + if (std::abs(dphi) < (dphimin + 0.01)) { + cellIndex = k; + dphimin = std::abs(dphi); + } else { + if (cellIndex >= vec.size()) + cellIndex = k; + } + } + } + } +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "getClosestCellIndex::Input " << zp << ":" << phip << " Index " << cellIndex; + if (cellIndex < vec.size()) + edm::LogVerbatim("HGCalGeom") << " Cell z " << vec[cellIndex].getPosition().z() << ":" << dzmin << " phi " + << vec[cellIndex].phiPos() << ":" << dphimin; +#endif + return cellIndex; +} + +// FIXME: Change sorting algorithm if needed +namespace { + struct rawIdSort { + bool operator()(const DetId& a, const DetId& b) { return (a.rawId() < b.rawId()); } + }; +} // namespace + +void HGCalTBGeometry::sortDetIds(void) { + m_validIds.shrink_to_fit(); + std::sort(m_validIds.begin(), m_validIds.end(), rawIdSort()); +} + +void HGCalTBGeometry::getSummary(CaloSubdetectorGeometry::TrVec& trVector, + CaloSubdetectorGeometry::IVec& iVector, + CaloSubdetectorGeometry::DimVec& dimVector, + CaloSubdetectorGeometry::IVec& dinsVector) const { + unsigned int numberOfCells = m_topology.totalGeomModules(); // total Geom Modules both sides + unsigned int numberOfShapes = k_NumberOfShapes; + unsigned int numberOfParametersPerShape = ((m_det == DetId::HGCalHSc) ? (unsigned int)(k_NumberOfParametersPerTrd) + : (unsigned int)(k_NumberOfParametersPerHex)); + + trVector.reserve(numberOfCells * numberOfTransformParms()); + iVector.reserve(numberOfCells); + dimVector.reserve(numberOfShapes * numberOfParametersPerShape); + dinsVector.reserve(numberOfCells); + + for (unsigned itr = 0; itr < m_topology.dddConstants().getTrFormN(); ++itr) { + HGCalTBParameters::hgtrform mytr = m_topology.dddConstants().getTrForm(itr); + int layer = mytr.lay; + + for (int wafer = 0; wafer < m_topology.dddConstants().sectors(); ++wafer) { + if (m_topology.dddConstants().waferInLayer(wafer, layer, true)) { + HGCalTBParameters::hgtrap vol = m_topology.dddConstants().getModule(wafer, true, true); + ParmVec params(numberOfParametersPerShape, 0); + params[FlatHexagon::k_dZ] = vol.dz; + params[FlatHexagon::k_r] = vol.cellSize; + params[FlatHexagon::k_R] = twoBysqrt3_ * params[FlatHexagon::k_r]; + dimVector.insert(dimVector.end(), params.begin(), params.end()); + } + } + } + + for (unsigned int i(0); i < numberOfCells; ++i) { + DetId detId = m_validGeomIds[i]; + int layer = HGCalDetId(detId).layer(); + dinsVector.emplace_back(m_topology.detId2denseGeomId(detId)); + iVector.emplace_back(layer); + + Tr3D tr; + auto ptr = cellGeomPtr(i); + if (nullptr != ptr) { + ptr->getTransform(tr, (Pt3DVec*)nullptr); + + if (Tr3D() == tr) { // there is no rotation + const GlobalPoint& gp(ptr->getPosition()); + tr = HepGeom::Translate3D(gp.x(), gp.y(), gp.z()); + } + + const CLHEP::Hep3Vector tt(tr.getTranslation()); + trVector.emplace_back(tt.x()); + trVector.emplace_back(tt.y()); + trVector.emplace_back(tt.z()); + if (6 == numberOfTransformParms()) { + const CLHEP::HepRotation rr(tr.getRotation()); + const ROOT::Math::Transform3D rtr( + rr.xx(), rr.xy(), rr.xz(), tt.x(), rr.yx(), rr.yy(), rr.yz(), tt.y(), rr.zx(), rr.zy(), rr.zz(), tt.z()); + ROOT::Math::EulerAngles ea; + rtr.GetRotation(ea); + trVector.emplace_back(ea.Phi()); + trVector.emplace_back(ea.Theta()); + trVector.emplace_back(ea.Psi()); + } + } + } +} + +DetId HGCalTBGeometry::getGeometryDetId(DetId detId) const { + return static_cast(HGCalDetId(detId).geometryCell()); +} + +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(HGCalTBGeometry); diff --git a/Geometry/HGCalGeometry/src/HGCalTBGeometryLoader.cc b/Geometry/HGCalGeometry/src/HGCalTBGeometryLoader.cc new file mode 100644 index 0000000000000..618086c04a4b5 --- /dev/null +++ b/Geometry/HGCalGeometry/src/HGCalTBGeometryLoader.cc @@ -0,0 +1,111 @@ +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometryLoader.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" +#include "Geometry/CaloGeometry/interface/FlatTrd.h" +#include "Geometry/HGCalTBCommonData/interface/HGCalTBDDDConstants.h" +#include "DataFormats/ForwardDetId/interface/HGCalDetId.h" +#include "DataFormats/ForwardDetId/interface/ForwardSubdetector.h" + +//#define EDM_ML_DEBUG + +typedef CaloCellGeometry::CCGFloat CCGFloat; +typedef std::vector ParmVec; + +HGCalTBGeometryLoader::HGCalTBGeometryLoader() : twoBysqrt3_(2.0 / std::sqrt(3.0)) {} + +HGCalTBGeometry* HGCalTBGeometryLoader::build(const HGCalTBTopology& topology) { + // allocate geometry + HGCalTBGeometry* geom = new HGCalTBGeometry(topology); + unsigned int numberOfCells = topology.totalGeomModules(); // both sides + unsigned int numberExpected = topology.allGeomModules(); + parametersPerShape_ = static_cast(HGCalTBGeometry::k_NumberOfParametersPerHex); + uint32_t numberOfShapes = HGCalTBGeometry::k_NumberOfShapes; +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "Number of Cells " << numberOfCells << ":" << numberExpected << " for sub-detector " + << topology.subDetector() << " Shapes " << numberOfShapes << ":" << parametersPerShape_; +#endif + geom->allocateCorners(numberOfCells); + geom->allocatePar(numberOfShapes, parametersPerShape_); + + // loop over modules + ParmVec params(parametersPerShape_, 0); + unsigned int counter(0); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "HGCalTBGeometryLoader with # of " + << "transformation matrices " << topology.dddConstants().getTrFormN() << " and " + << topology.dddConstants().volumes() << ":" << topology.dddConstants().sectors() + << " volumes"; +#endif + for (unsigned itr = 0; itr < topology.dddConstants().getTrFormN(); ++itr) { + HGCalTBParameters::hgtrform mytr = topology.dddConstants().getTrForm(itr); + int zside = mytr.zp; + int layer = mytr.lay; +#ifdef EDM_ML_DEBUG + unsigned int kount(0); + edm::LogVerbatim("HGCalGeom") << "HGCalTBGeometryLoader:: Z:Layer " << zside << ":" << layer << " z " << mytr.h3v.z(); +#endif + ForwardSubdetector subdet = topology.subDetector(); + for (int wafer = 0; wafer < topology.dddConstants().sectors(); ++wafer) { + std::string code[2] = {"False", "True"}; + if (topology.dddConstants().waferInLayer(wafer, layer, true)) { + int type = topology.dddConstants().waferTypeT(wafer); + if (type != 1) + type = 0; + DetId detId = static_cast(HGCalDetId(subdet, zside, layer, type, wafer, 0)); + const auto& w = topology.dddConstants().waferPosition(wafer, true); + double xx = (zside > 0) ? w.first : -w.first; + CLHEP::Hep3Vector h3v(xx, w.second, mytr.h3v.z()); + const HepGeom::Transform3D ht3d(mytr.hr, h3v); +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << "HGCalTBGeometryLoader:: Wafer:Type " << wafer << ":" << type << " DetId " + << HGCalDetId(detId) << std::hex << " " << detId.rawId() << std::dec + << " transf " << ht3d.getTranslation() << " and " << ht3d.getRotation(); +#endif + HGCalTBParameters::hgtrap vol = topology.dddConstants().getModule(wafer, true, true); + params[FlatHexagon::k_dZ] = vol.dz; + params[FlatHexagon::k_r] = topology.dddConstants().cellSizeHex(type); + params[FlatHexagon::k_R] = twoBysqrt3_ * params[FlatHexagon::k_r]; + + buildGeom(params, ht3d, detId, geom); + counter++; +#ifdef EDM_ML_DEBUG + ++kount; +#endif + } + } +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HGCalGeom") << kount << " modules found in Layer " << layer << " Z " << zside; +#endif + } + + geom->sortDetIds(); + + if (counter != numberExpected) { + edm::LogError("HGCalGeom") << "Inconsistent # of cells: expected " << numberExpected << ":" << numberOfCells << " , inited " << counter; + } + + return geom; +} + +void HGCalTBGeometryLoader::buildGeom(const ParmVec& params, const HepGeom::Transform3D& ht3d, const DetId& detId, HGCalTBGeometry* geom) { +#ifdef EDM_ML_DEBUG + for (int i = 0; i < parametersPerShape_; ++i) + edm::LogVerbatim("HGCalGeom") << "Parameter[" << i << "] : " << params[i]; +#endif + std::vector corners(FlatHexagon::ncorner_); + + FlatHexagon::createCorners(params, ht3d, corners); + + const CCGFloat* parmPtr(CaloCellGeometry::getParmPtr(params, geom->parMgr(), geom->parVecVec())); + + GlobalPoint front(FlatHexagon::oneBySix_ * (corners[0].x() + corners[1].x() + corners[2].x() + corners[3].x() + corners[4].x() + corners[5].x()), FlatHexagon::oneBySix_ * (corners[0].y() + corners[1].y() + corners[2].y() + corners[3].y() + corners[4].y() + corners[5].y()), FlatHexagon::oneBySix_ * (corners[0].z() + corners[1].z() + corners[2].z() + corners[3].z() + corners[4].z() + corners[5].z())); + + GlobalPoint back(FlatHexagon::oneBySix_ * (corners[6].x() + corners[7].x() + corners[8].x() + corners[9].x() + corners[10].x() + corners[11].x()), FlatHexagon::oneBySix_ * (corners[6].y() + corners[7].y() + corners[8].y() + corners[9].y() + corners[10].y() + corners[11].y()), FlatHexagon::oneBySix_ * (corners[6].z() + corners[7].z() + corners[8].z() + corners[9].z() + corners[10].z() + corners[11].z())); + + if (front.mag2() > back.mag2()) { // front should always point to the center, so swap front and back + std::swap(front, back); + std::swap_ranges(corners.begin(), corners.begin() + FlatHexagon::ncornerBy2_, corners.begin() + FlatHexagon::ncornerBy2_); + } + geom->newCell(front, back, corners[0], parmPtr, detId); +} diff --git a/Geometry/HGCalGeometry/test/HGCalTBGeometryDump.cc b/Geometry/HGCalGeometry/test/HGCalTBGeometryDump.cc new file mode 100644 index 0000000000000..1d77b7b00d5d8 --- /dev/null +++ b/Geometry/HGCalGeometry/test/HGCalTBGeometryDump.cc @@ -0,0 +1,61 @@ +#include "FWCore/Framework/interface/one/EDAnalyzer.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "Geometry/Records/interface/IdealGeometryRecord.h" +#include "Geometry/HGCalGeometry/interface/HGCalTBGeometry.h" +#include "DataFormats/ForwardDetId/interface/HGCalDetId.h" +#include + +class HGCalTBGeometryDump : public edm::one::EDAnalyzer<> { +public: + explicit HGCalTBGeometryDump(const edm::ParameterSet&); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + void beginJob() override {} + void analyze(edm::Event const& iEvent, edm::EventSetup const&) override; + void endJob() override {} + +private: + const std::vector names_; + std::vector> geomTokens_; +}; + +HGCalTBGeometryDump::HGCalTBGeometryDump(const edm::ParameterSet& iC) + : names_(iC.getParameter>("detectorNames")) { + for (unsigned int k = 0; k < names_.size(); ++k) { + edm::LogVerbatim("HGCalGeomX") << "Study detector [" << k << "] " << names_[k] << std::endl; + geomTokens_.emplace_back(esConsumes(edm::ESInputTag{"", names_[k]})); + } +} + +void HGCalTBGeometryDump::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + std::vector names = {"HGCalEESensitive", "HGCalHESiliconSensitive"}; + desc.add>("detectorNames", names); + descriptions.add("hgcalTBGeometryDump", desc); +} + +void HGCalTBGeometryDump::analyze(const edm::Event& /*iEvent*/, const edm::EventSetup& iSetup) { + for (unsigned int k = 0; k < names_.size(); ++k) { + const auto& geomR = iSetup.getData(geomTokens_[k]); + const HGCalTBGeometry* geom = &geomR; + const std::vector& ids = geom->getValidDetIds(); + edm::LogVerbatim("HGCalGeomX") << ids.size() << " valid Ids for detector " << names_[k]; + int nall(0); + for (auto id : ids) { + ++nall; + auto cell = geom->getGeometry(id); + HGCalDetId hid(id); + edm::LogVerbatim("HGCalGeomX") << "[" << nall << "] " << hid << " Reference " << std::setprecision(4) + << cell->getPosition() << " Back " << cell->getBackPoint() << " [r,eta,phi] (" + << cell->rhoPos() << ", " << cell->etaPos() << ":" << cell->etaSpan() << ", " + << cell->phiPos() << ":" << cell->phiSpan() << ")"; + } + edm::LogVerbatim("HGCalGeomX") << "\n\nDumps " << nall << " cells of the detector\n"; + } +} + +DEFINE_FWK_MODULE(HGCalTBGeometryDump); diff --git a/Geometry/HGCalGeometry/test/python/testHGCalTBCellDump_cfg.py b/Geometry/HGCalGeometry/test/python/testHGCalTBCellDump_cfg.py new file mode 100644 index 0000000000000..9f996ac2f6437 --- /dev/null +++ b/Geometry/HGCalGeometry/test/python/testHGCalTBCellDump_cfg.py @@ -0,0 +1,25 @@ +import FWCore.ParameterSet.Config as cms +from Configuration.Eras.Era_Phase2C17I13M9_cff import Phase2C17I13M9 + +process = cms.Process("HGCalTBCellDump",Phase2C17I13M9) + +process.load("SimGeneral.HepPDTESSource.pdt_cfi") +process.load("Geometry.HGCalTBCommonData.testTB181V1XML_cfi") +process.load("Geometry.HGCalTBCommonData.hgcalTBParametersInitialization_cfi") +process.load("Geometry.HGCalTBCommonData.hgcalTBNumberingInitialization_cfi") +process.load("Geometry.CaloTopology.hgcalTBTopologyTester_cfi") +process.load("Geometry.HGCalGeometry.HGCalTBGeometryESProducer_cfi") +process.load("Geometry.HGCalGeometry.hgcalTBGeometryDump_cfi") +process.load('FWCore.MessageService.MessageLogger_cfi') + +if hasattr(process,'MessageLogger'): + process.MessageLogger.HGCalGeomX=dict() + +process.source = cms.Source("EmptySource") +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) + ) +process.Timing = cms.Service("Timing") +process.hgcalTBGeometryDump.detectorNames = ["HGCalEESensitive"] + +process.p1 = cms.Path(process.hgcalTBGeometryDump)