diff --git a/Geometry/HGCalCommonData/test/HGCalCellUVTester.cc b/Geometry/HGCalCommonData/test/HGCalCellUVTester.cc index f216dbbb2e462..3c6e134ed5484 100644 --- a/Geometry/HGCalCommonData/test/HGCalCellUVTester.cc +++ b/Geometry/HGCalCommonData/test/HGCalCellUVTester.cc @@ -1,10 +1,10 @@ // -*- C++ -*- // -// Package: HGCalCellPositionTester -// Class: HGCalCellPositionTester +// Package: HGCalCellUVTester +// Class: HGCalCellUVTester // -/**\class HGCalCellPositionTester HGCalCellPositionTester.cc - test/HGCalCellPositionTester.cc +/**\class HGCalCellUVTester HGCalCellUVTester.cc + test/HGCalCellUVTester.cc Description: @@ -25,7 +25,6 @@ #include #include #include -//#include // user include files #include "FWCore/Framework/interface/Frameworkfwd.h" @@ -94,10 +93,10 @@ void HGCalCellUVTester::analyze(const edm::Event&, const edm::EventSetup&) { double c2 = yi - (xi / sqrt(3)); if ((xi < r2) && (xi > -1 * r2) && (c1 < R2) && (c1 > -1 * R2) && (c2 < R2) && (c2 > -1 * R2)) { //Only allowing (x, y) inside a wafer - std::pair uv1 = wafer.cellUVFromXY1(xi, yi, placeIndex_, waferType_, 0, 0); - std::pair uv2 = wafer.cellUVFromXY2(xi, yi, placeIndex_, waferType_, 0, 0); - std::pair uv3 = wafer.cellUVFromXY3(xi, yi, placeIndex_, waferType_, 1, 0); - //std::pair uv2 = wafer.HGCalCellUVFromXY2(xi, yi, placeIndex_, waferType_, 1, 0); + std::pair uv1 = wafer.cellUVFromXY1(xi, yi, placeIndex_, waferType_, true, false); + std::pair uv2 = wafer.cellUVFromXY2(xi, yi, placeIndex_, waferType_, true, false); + std::pair uv3 = wafer.cellUVFromXY3(xi, yi, placeIndex_, waferType_, true, false); + //std::pair uv2 = wafer.HGCalCellUVFromXY2(xi, yi, placeIndex_, waferType_, true, false); std::string comment = ((uv1.first != uv3.first) || (uv2.first != uv3.first) || (uv1.second != uv3.second) || (uv2.second != uv3.second)) ? " ***** ERROR *****" diff --git a/Geometry/HGCalCommonData/test/HGCalPartialCellTester.cc b/Geometry/HGCalCommonData/test/HGCalPartialCellTester.cc new file mode 100644 index 0000000000000..829d877b5e782 --- /dev/null +++ b/Geometry/HGCalCommonData/test/HGCalPartialCellTester.cc @@ -0,0 +1,146 @@ +// -*- C++ -*- +// +// Package: HGCalCellPartialCellTester +// Class: HGCalCellPartialCellTester +// +/**\class HGCalCellPartialCellTester HGCalCellPartialCellTester.cc + test/HGCalCellPartialCellTester.cc + + Description: + + Implementation: + +*/ +// +// Original Author: Sunanda Banerjee, Pruthvi Suryadevara +// Created: Mon 2022/06/10 +// +// + +// system include files +#include +#include +#include +#include +#include +#include +#include +//#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.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/HGCalCommonData/interface/HGCalCellUV.h" +#include "Geometry/HGCalCommonData/interface/HGCalCell.h" +#include "Geometry/HGCalCommonData/interface/HGCalWaferMask.h" + +class HGCalPartialCellTester : public edm::one::EDAnalyzer<> { +public: + explicit HGCalPartialCellTester(const edm::ParameterSet&); + ~HGCalPartialCellTester() override = default; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + void beginJob() override {} + void analyze(edm::Event const& iEvent, edm::EventSetup const&) override; + void endJob() override {} + +private: + const double waferSize_; + const int waferType_; + const int placeIndex_; + const int partialType_; + const int nTrials_; + const int modeUV_; +}; + +HGCalPartialCellTester::HGCalPartialCellTester(const edm::ParameterSet& iC) + : waferSize_(iC.getParameter("waferSize")), + waferType_(iC.getParameter("waferType")), + placeIndex_(iC.getParameter("cellPlacementIndex")), + partialType_(iC.getParameter("partialType")), + nTrials_(iC.getParameter("numbberOfTrials")), + modeUV_(iC.getParameter("modeUV")) { + edm::LogVerbatim("HGCalGeom") << "Test positions for wafer of size " << waferSize_ << " Type " << waferType_ + << " Placement Index " << placeIndex_ << " mode " << modeUV_ << " with " << nTrials_ + << " trials"; +} + +void HGCalPartialCellTester::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("waferSize", 166.4408); + desc.add("waferType", 1); + desc.add("cellPlacementIndex", 2); + desc.add("partialType", 11); + desc.add("numbberOfTrials", 1000); + desc.add("modeUV", 0); + descriptions.add("hgcalPartialCellTester", desc); +} + +// ------------ method called to produce the data ------------ +void HGCalPartialCellTester::analyze(const edm::Event&, const edm::EventSetup&) { + const int nFine(12), nCoarse(8); + double r2 = 0.5 * waferSize_; + double R2 = 2 * r2 / sqrt(3); + int nCells = (waferType_ == 0) ? nFine : nCoarse; + HGCalCellUV wafer(waferSize_, 0.0, nFine, nCoarse); + HGCalCell wafer2(waferSize_, nFine, nCoarse); + edm::LogVerbatim("HGCalGeom") << "\nHGCalPartialCellTester:: nCells " << nCells << " and placement index " + << placeIndex_ << "\n\n"; + auto start_t = std::chrono::high_resolution_clock::now(); + + if (modeUV_ <= 0) { + for (int i = 0; i < nTrials_; i++) { + double xi = (2 * r2 * static_cast(rand()) / RAND_MAX) - r2; + double yi = (2 * R2 * static_cast(rand()) / RAND_MAX) - R2; + double c1 = yi + xi / sqrt(3); + double c2 = yi - (xi / sqrt(3)); + if ((xi < r2) && (xi > -1 * r2) && (c1 < R2) && (c1 > -1 * R2) && (c2 < R2) && (c2 > -1 * R2) && + (xi > 0)) { //Only allowing (x, y) inside a partial wafer 11, placement index 2 + std::pair uv1 = wafer.cellUVFromXY1(xi, yi, placeIndex_, waferType_, true, false); + std::pair uv5 = + wafer.cellUVFromXY1(xi, yi, placeIndex_, waferType_, partialType_, true, false); + std::string cellType = (HGCalWaferMask::goodCell(uv5.first, uv5.second, 11)) ? "Goodcell" : "Badcell"; + std::string comment = ((uv1.first != uv5.first) || (uv1.second != uv5.second)) ? " ***** ERROR *****" : ""; + edm::LogVerbatim("HGCalGeom") << cellType << " x = " << xi << " y = " << yi << " type = " << waferType_ + << " placement index " << placeIndex_ << " u " << uv1.first << ":" << uv5.first + << ":" << uv5.first << " v " << uv1.second << ":" << uv5.second << ":" + << uv5.second << ":" << comment; + } + } + } else { + for (int i = 0; i < nTrials_; i++) { + int ui = std::floor(2 * nCells * rand() / RAND_MAX); + int vi = std::floor(2 * nCells * rand() / RAND_MAX); + if ((ui < 2 * nCells) && (vi < 2 * nCells) && ((vi - ui) < nCells) && ((ui - vi) <= nCells) && + HGCalWaferMask::goodCell(ui, vi, partialType_)) { + //Only allowing (U, V) inside a wafer + std::pair xy1 = wafer2.cellUV2XY2(ui, vi, placeIndex_, waferType_); + std::pair uv1 = + wafer.cellUVFromXY1(xy1.first, xy1.second, placeIndex_, waferType_, true, false); + std::pair uv5 = + wafer.cellUVFromXY1(xy1.first, xy1.second, placeIndex_, waferType_, partialType_, true, false); + std::string comment = ((uv1.first != ui) || (uv1.second != vi) || (uv5.first != ui) || (uv5.second != vi)) + ? " ***** ERROR *****" + : ""; + edm::LogVerbatim("HGCalGeom") << "u = " << ui << " v = " << vi << " type = " << waferType_ + << " placement index " << placeIndex_ << " x " << xy1.first << " ,y " + << xy1.second << " u " << uv5.first << " v " << uv5.second << comment; + } + } + } + auto end_t = std::chrono::high_resolution_clock::now(); + auto diff_t = end_t - start_t; + edm::LogVerbatim("HGCalGeom") << "Execution time for " << nTrials_ + << " events = " << std::chrono::duration(diff_t).count() << " ms"; +} + +// define this as a plug-in +DEFINE_FWK_MODULE(HGCalPartialCellTester); diff --git a/Geometry/HGCalCommonData/test/HGCalPartialWaferTester.cc b/Geometry/HGCalCommonData/test/HGCalPartialWaferTester.cc new file mode 100644 index 0000000000000..d5271e697bac1 --- /dev/null +++ b/Geometry/HGCalCommonData/test/HGCalPartialWaferTester.cc @@ -0,0 +1,145 @@ +// system include files +#include +#include +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.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/HGCalCommonData/interface/HGCalDDDConstants.h" +#include "Geometry/HGCalCommonData/interface/HGCalParameters.h" +#include "Geometry/HGCalCommonData/interface/HGCalWaferIndex.h" +#include "Geometry/HGCalCommonData/interface/HGCalWaferMask.h" +#include "Geometry/Records/interface/IdealGeometryRecord.h" + +class HGCalPartialWaferTester : public edm::one::EDAnalyzer<> { +public: + explicit HGCalPartialWaferTester(const edm::ParameterSet&); + ~HGCalPartialWaferTester() override = default; + 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::string nameSense_; + const std::vector orientations_, partialTypes_; + const int nTrials_; + const edm::ESGetToken dddToken_; +}; + +HGCalPartialWaferTester::HGCalPartialWaferTester(const edm::ParameterSet& iC) + : nameSense_(iC.getParameter("nameSense")), + orientations_(iC.getParameter>("waferOrientations")), + partialTypes_(iC.getParameter>("partialTypes")), + nTrials_(iC.getParameter("numberOfTrials")), + dddToken_(esConsumes(edm::ESInputTag{"", nameSense_})) { + edm::LogVerbatim("HGCalGeom") << "Test positions for " << partialTypes_.size() << " partial wafer types " + << " and " << orientations_.size() << " Orientations for " << nameSense_; +} + +void HGCalPartialWaferTester::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + std::vector orients = {HGCalTypes::WaferOrient0, + HGCalTypes::WaferOrient1, + HGCalTypes::WaferOrient2, + HGCalTypes::WaferOrient3, + HGCalTypes::WaferOrient4, + HGCalTypes::WaferOrient5}; + std::vector types = {HGCalTypes::WaferLDTop, + HGCalTypes::WaferLDBottom, + HGCalTypes::WaferLDLeft, + HGCalTypes::WaferLDRight, + HGCalTypes::WaferLDFive, + HGCalTypes::WaferLDThree, + HGCalTypes::WaferHDTop, + HGCalTypes::WaferHDBottom, + HGCalTypes::WaferHDLeft, + HGCalTypes::WaferHDRight, + HGCalTypes::WaferHDFive}; + desc.add("nameSense", "HGCalHESiliconSensitive"); + desc.add>("waferOrientations", orients); + desc.add>("partialTypes", types); + desc.add("numberOfTrials", 1000); + descriptions.add("hgcalPartialWaferTester", desc); +} + +void HGCalPartialWaferTester::analyze(const edm::Event&, const edm::EventSetup& iSetup) { + const HGCalDDDConstants& hgdc = iSetup.getData(dddToken_); + const bool reco(true), all(true), norot(false), debug1(false), debug2(false), extend(true); + for (const auto& partialType : partialTypes_) { + for (const auto& orientation : orientations_) { + int indx(-1), type(-1); + for (auto itr = hgdc.getParameter()->waferInfoMap_.begin(); itr != hgdc.getParameter()->waferInfoMap_.end(); + ++itr) { + if (((itr->second).part == partialType) && ((itr->second).orient == orientation)) { + indx = itr->first; + type = (itr->second).type; + break; + } + } + + if (indx > 0) { + int alltry(0), error(0); + int layer = HGCalWaferIndex::waferLayer(indx); + int waferU = HGCalWaferIndex::waferU(indx); + int waferV = HGCalWaferIndex::waferV(indx); + auto xy = hgdc.waferPosition(layer, waferU, waferV, true, false); + edm::LogVerbatim("HGCalGeom") << "\n\nPartial Type " << partialType << " Orientation " << orientation + << " Wafer " << waferU << ":" << waferV << " in layer " << layer << " at " + << xy.first << ":" << xy.second << "\n\n"; + int nCells = (type == 0) ? HGCSiliconDetId::HGCalFineN : HGCSiliconDetId::HGCalCoarseN; + for (int i = 0; i < nTrials_; i++) { + int ui = std::floor(2 * nCells * rand() / RAND_MAX); + int vi = std::floor(2 * nCells * rand() / RAND_MAX); + if ((ui < 2 * nCells) && (vi < 2 * nCells) && ((vi - ui) < nCells) && ((ui - vi) <= nCells) && + HGCalWaferMask::goodCell(ui, vi, partialType)) { + ++alltry; + auto xy = hgdc.locateCell(layer, waferU, waferV, ui, vi, reco, all, norot, debug1); + int lay(layer), cU(0), cV(0), wType(-1), wU(0), wV(0); + double wt(0); + hgdc.waferFromPosition(HGCalParameters::k_ScaleToDDD * xy.first, + HGCalParameters::k_ScaleToDDD * xy.second, + lay, + wU, + wV, + cU, + cV, + wType, + wt, + extend, + debug2); + bool ok = + ((wType == type) && (layer == lay) && (waferU == wU) && (waferV == wV) && (ui == cU) && (vi == cV)); + std::string comment = (ok) ? "" : " ***** ERROR *****"; + edm::LogVerbatim("HGCalGeom") + << "Layer " << layer << ":" << lay << " waferU " << waferU << ":" << wU << " waferV " << waferV << ":" + << wV << " Type " << type << ":" << wType << " cellU " << ui << ":" << cU << " cellV " << vi << ":" + << cV << " position " << xy.first << ":" << xy.second << comment; + if (!ok) + ++error; + } + } + edm::LogVerbatim("HGCalGeom") << "\n\nFound " << error << " errors among " << alltry << ":" << nTrials_ + << " trials for partial type " << partialType << " orientation " << orientation + << " of " << nameSense_; + } else { + edm::LogVerbatim("HGCalGeom") << "\n\nCannot find a wafer of type " << partialType << " and orientation " + << orientation << " for " << nameSense_; + } + } + } +} + +// define this as a plug-in +DEFINE_FWK_MODULE(HGCalPartialWaferTester); diff --git a/Geometry/HGCalCommonData/test/python/testHGCalPartialCellTester_cfg.py b/Geometry/HGCalCommonData/test/python/testHGCalPartialCellTester_cfg.py new file mode 100644 index 0000000000000..e12bab92519f2 --- /dev/null +++ b/Geometry/HGCalCommonData/test/python/testHGCalPartialCellTester_cfg.py @@ -0,0 +1,42 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("PROD") +process.load("SimGeneral.HepPDTESSource.pdt_cfi") +process.load('FWCore.MessageService.MessageLogger_cfi') + +if hasattr(process,'MessageLogger'): + process.MessageLogger.HGCalGeom=dict() + +process.load("IOMC.RandomEngine.IOMC_cff") +process.RandomNumberGeneratorService.generator.initialSeed = 456789 + +process.source = cms.Source("EmptySource") + +process.generator = cms.EDProducer("FlatRandomEGunProducer", + PGunParameters = cms.PSet( + PartID = cms.vint32(14), + MinEta = cms.double(-3.5), + MaxEta = cms.double(3.5), + MinPhi = cms.double(-3.14159265359), + MaxPhi = cms.double(3.14159265359), + MinE = cms.double(9.99), + MaxE = cms.double(10.01) + ), + AddAntiParticle = cms.bool(False), + Verbosity = cms.untracked.int32(0), + firstRun = cms.untracked.uint32(1) + ) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +process.SimpleMemoryCheck = cms.Service("SimpleMemoryCheck", + ignoreTotal = cms.untracked.int32(1), + moduleMemorySummary = cms.untracked.bool(True) +) + +process.load("Geometry.HGCalCommonData.hgcalPartialCellTester_cfi") + + +process.p1 = cms.Path(process.generator*process.hgcalPartialCellTester) diff --git a/Geometry/HGCalCommonData/test/python/testHGCalPartialWaferTester_cfg.py b/Geometry/HGCalCommonData/test/python/testHGCalPartialWaferTester_cfg.py new file mode 100644 index 0000000000000..ec744cd3aaa73 --- /dev/null +++ b/Geometry/HGCalCommonData/test/python/testHGCalPartialWaferTester_cfg.py @@ -0,0 +1,38 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("PROD") +process.load("SimGeneral.HepPDTESSource.pdt_cfi") +process.load("Configuration.Geometry.GeometryExtended2026D92_cff") +process.load('FWCore.MessageService.MessageLogger_cfi') + +if hasattr(process,'MessageLogger'): + process.MessageLogger.HGCalGeom=dict() + +process.load("IOMC.RandomEngine.IOMC_cff") +process.RandomNumberGeneratorService.generator.initialSeed = 456789 + +process.source = cms.Source("EmptySource") + +process.generator = cms.EDProducer("FlatRandomEGunProducer", + PGunParameters = cms.PSet( + PartID = cms.vint32(14), + MinEta = cms.double(-3.5), + MaxEta = cms.double(3.5), + MinPhi = cms.double(-3.14159265359), + MaxPhi = cms.double(3.14159265359), + MinE = cms.double(9.99), + MaxE = cms.double(10.01) + ), + AddAntiParticle = cms.bool(False), + Verbosity = cms.untracked.int32(0), + firstRun = cms.untracked.uint32(1) + ) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +process.load("Geometry.HGCalCommonData.hgcalPartialWaferTester_cfi") +#process.hgcalPartialWaferTester.nameSense = "HGCalEESensitive" + +process.p1 = cms.Path(process.generator*process.hgcalPartialWaferTester) diff --git a/Geometry/HGCalCommonData/test/python/testHGCalValidHex_cfg.py b/Geometry/HGCalCommonData/test/python/testHGCalValidHex_cfg.py index 89b4ce9b90232..7a904d2483703 100644 --- a/Geometry/HGCalCommonData/test/python/testHGCalValidHex_cfg.py +++ b/Geometry/HGCalCommonData/test/python/testHGCalValidHex_cfg.py @@ -5,7 +5,9 @@ #process.load("Geometry.CMSCommonData.cmsExtendedGeometry2026D49XML_cfi") #process.load("Geometry.CMSCommonData.cmsExtendedGeometry2026D68XML_cfi") #process.load("Geometry.CMSCommonData.cmsExtendedGeometry2026D70XML_cfi") -process.load("Geometry.HGCalCommonData.testHGCalV14XML_cfi") +#process.load("Geometry.CMSCommonData.cmsExtendedGeometry2026D88XML_cfi") +process.load("Geometry.CMSCommonData.cmsExtendedGeometry2026D92XML_cfi") +#process.load("Geometry.HGCalCommonData.testHGCalV14XML_cfi") process.load("Geometry.HGCalCommonData.hgcalParametersInitialization_cfi") process.load("Geometry.HGCalCommonData.hgcalNumberingInitialization_cfi") process.load("Geometry.EcalCommonData.ecalSimulationParameters_cff")