Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Phase2-hgx316C Add a few utility methods in HGCalDDDConstants #38547

Merged
merged 5 commits into from
Jul 3, 2022
Merged

Phase2-hgx316C Add a few utility methods in HGCalDDDConstants #38547

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
4e9e429
Add a few utility methods in HGCalDDDConstants
Jun 29, 2022
80c8de7
Use inline wherever applicable
Jun 30, 2022
255e4a9
Code check
Jun 30, 2022
97dbe35
Add one additional debug statement
Jun 30, 2022
c58eddd
Code check
Jun 30, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
144 changes: 48 additions & 96 deletions Geometry/HGCalCommonData/interface/HGCalDDDConstants.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@
#include "Geometry/HGCalCommonData/interface/HGCalParameters.h"
#include "Geometry/HGCalCommonData/interface/HGCalTileIndex.h"
#include "Geometry/HGCalCommonData/interface/HGCalTypes.h"
#include "Geometry/HGCalCommonData/interface/HGCalWaferIndex.h"
#include <CLHEP/Geometry/Point3D.h>

#include <array>
Expand All @@ -34,15 +35,15 @@
class HGCalDDDConstants {
public:
HGCalDDDConstants(const HGCalParameters* hp, const std::string& name);
~HGCalDDDConstants();
~HGCalDDDConstants() = default;

std::pair<int, int> assignCell(float x, float y, int lay, int subSec, bool reco) const;
std::array<int, 5> assignCellHex(float x, float y, int lay, bool reco, bool extend = false, bool debug = false) const;
std::array<int, 3> assignCellTrap(float x, float y, float z, int lay, bool reco) const;
std::pair<double, double> cellEtaPhiTrap(int type, int irad) const;
bool cellInLayer(int waferU, int waferV, int cellU, int cellV, int lay, bool reco) const;
double cellSizeHex(int type) const;
std::pair<double, double> cellSizeTrap(int type, int irad) const {
inline std::pair<double, double> cellSizeTrap(int type, int irad) const {
return std::make_pair(hgpar_->radiusLayer_[type][irad - 1], hgpar_->radiusLayer_[type][irad]);
}
double cellThickness(int layer, int waferU, int waferV) const;
Expand All @@ -57,26 +58,25 @@ class HGCalDDDConstants {
int& iphi,
int& type,
double& wt) const;
int firstLayer() const { return hgpar_->firstLayer_; }
HGCalGeometryMode::GeometryMode geomMode() const { return mode_; }
inline int firstLayer() const { return hgpar_->firstLayer_; }
inline HGCalGeometryMode::GeometryMode geomMode() const { return mode_; }
int getLayer(double z, bool reco) const;
int getLayerOffset() const { return hgpar_->layerOffset_; }
HGCalParameters::hgtrap getModule(unsigned int k, bool hexType, bool reco) const;
std::vector<HGCalParameters::hgtrap> getModules() const;
const HGCalParameters* getParameter() const { return hgpar_; }
inline const HGCalParameters* getParameter() const { return hgpar_; }
int getPhiBins(int lay) const;
std::pair<int, int> getREtaRange(int lay) const;
const std::vector<double>& getRadiusLayer(int layer) const {
int type = (tileTrapezoid() ? hgpar_->scintType(layer) : 0);
return hgpar_->radiusLayer_[type];
inline const std::vector<double>& getRadiusLayer(int layer) const {
return hgpar_->radiusLayer_[(tileTrapezoid() ? hgpar_->scintType(layer) : 0)];
}
HGCalParameters::hgtrform getTrForm(unsigned int k) const { return hgpar_->getTrForm(k); }
unsigned int getTrFormN() const { return hgpar_->trformIndex_.size(); }
inline HGCalParameters::hgtrform getTrForm(unsigned int k) const { return hgpar_->getTrForm(k); }
inline unsigned int getTrFormN() const { return hgpar_->trformIndex_.size(); }
std::vector<HGCalParameters::hgtrform> getTrForms() const;
int getTypeTrap(int layer) const;
int getTypeHex(int layer, int waferU, int waferV) const;
std::pair<double, double> getXY(int layer, double x, double y, bool forwd) const;
int getUVMax(int type) const { return ((type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_); }
inline int getUVMax(int type) const { return ((type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_); }
bool isHalfCell(int waferType, int cell) const;
bool isValidHex(int lay, int mod, int cell, bool reco) const;
bool isValidHex8(int lay, int waferU, int waferV, bool fullAndPart = false) const;
Expand All @@ -86,6 +86,9 @@ class HGCalDDDConstants {
int layerIndex(int lay, bool reco) const;
unsigned int layers(bool reco) const;
unsigned int layersInit(bool reco) const;
inline int layerType(int lay) const {
return ((hgpar_->layerType_.empty()) ? HGCalTypes::WaferCenter : hgpar_->layerType_[lay - hgpar_->firstLayer_]);
}
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

CMS coding rule 4.3:
Header files must not contain any implementation except for class templates and code to be inlined.

Add inline if you intend these methods to be inlined.

std::pair<float, float> localToGlobal8(
int lay, int waferU, int waferV, double localX, double localY, bool reco, bool debug) const;
std::pair<float, float> locateCell(int cell, int lay, int type, bool reco) const;
Expand All @@ -102,15 +105,15 @@ class HGCalDDDConstants {
std::pair<float, float> locateCell(const HGCScintillatorDetId&, bool debug = false) const;
std::pair<float, float> locateCellHex(int cell, int wafer, bool reco) const;
std::pair<float, float> locateCellTrap(int lay, int ieta, int iphi, bool reco, bool debug = false) const;
int levelTop(int ind = 0) const { return hgpar_->levelT_[ind]; }
inline int levelTop(int ind = 0) const { return hgpar_->levelT_[ind]; }
bool maskCell(const DetId& id, int corners) const;
int maxCellUV() const { return (tileTrapezoid() ? hgpar_->nCellsFine_ : 2 * hgpar_->nCellsFine_); }
inline int maxCellUV() const { return (tileTrapezoid() ? hgpar_->nCellsFine_ : 2 * hgpar_->nCellsFine_); }
int maxCells(bool reco) const;
int maxCells(int lay, bool reco) const;
int maxModules() const { return modHalf_; }
int maxModulesPerLayer() const { return maxWafersPerLayer_; }
inline int maxModules() const { return modHalf_; }
inline int maxModulesPerLayer() const { return maxWafersPerLayer_; }
int maxRows(int lay, bool reco) const;
double minSlope() const { return hgpar_->slopeMin_[0]; }
inline double minSlope() const { return hgpar_->slopeMin_[0]; }
int modifyUV(int uv, int type1, int type2) const;
int modules(int lay, bool reco) const;
int modulesInit(int lay, bool reco) const;
Expand All @@ -123,44 +126,23 @@ class HGCalDDDConstants {
std::pair<double, double> rangeRLayer(int lay, bool reco) const;
std::pair<double, double> rangeZ(bool reco) const;
std::pair<int, int> rowColumnWafer(const int wafer) const;
int sectors() const { return hgpar_->nSectors_; }
inline int sectors() const { return hgpar_->nSectors_; }
std::pair<int, int> simToReco(int cell, int layer, int mod, bool half) const;
int tileCount(int layer, int ring) const;
bool tileExist(int zside, int layer, int ring, int phi) const {
int indx = HGCalTileIndex::tileIndex(layer, ring, 0);
auto itr = hgpar_->tileInfoMap_.find(indx);
bool ok = (itr == hgpar_->tileInfoMap_.end()) ? false : HGCalTileIndex::tileExist(itr->second.hex, zside, phi);
return ok;
}
std::pair<int, int> tileRings(int layer) const {
if ((mode_ == HGCalGeometryMode::TrapezoidFile) || (mode_ == HGCalGeometryMode::TrapezoidModule) ||
(mode_ == HGCalGeometryMode::TrapezoidCassette)) {
int ll = layer - hgpar_->firstLayer_;
if (ll >= 0 && ll < static_cast<int>(hgpar_->tileRingRange_.size()))
return hgpar_->tileRingRange_[ll];
}
return std::make_pair(0, 0);
}
int tileSiPM(int sipm) const { return ((sipm > 0) ? HGCalTypes::SiPMSmall : HGCalTypes::SiPMLarge); }
bool tileExist(int zside, int layer, int ring, int phi) const;
HGCalParameters::tileInfo tileInfo(int zside, int layer, int ring) const;
std::pair<int, int> tileRings(int layer) const;
inline int tileSiPM(int sipm) const { return ((sipm > 0) ? HGCalTypes::SiPMSmall : HGCalTypes::SiPMLarge); }
bool tileTrapezoid() const {
return ((mode_ == HGCalGeometryMode::Trapezoid) || (mode_ == HGCalGeometryMode::TrapezoidFile) ||
(mode_ == HGCalGeometryMode::TrapezoidModule) || (mode_ == HGCalGeometryMode::TrapezoidCassette));
}
std::pair<int, int> tileType(int layer, int ring, int phi) const {
int indx = HGCalTileIndex::tileIndex(layer, ring, phi);
int type(-1), sipm(-1);
auto itr = hgpar_->tileInfoMap_.find(indx);
if (itr != hgpar_->tileInfoMap_.end()) {
type = 1 + (itr->second).type;
sipm = ((itr->second).sipm == HGCalTypes::SiPMLarge) ? 0 : 1;
}
return std::make_pair(type, sipm);
}
bool trapezoidFile() const {
std::pair<int, int> tileType(int layer, int ring, int phi) const;
inline bool trapezoidFile() const {
return ((mode_ == HGCalGeometryMode::TrapezoidFile) || (mode_ == HGCalGeometryMode::TrapezoidModule) ||
(mode_ == HGCalGeometryMode::TrapezoidCassette));
}
unsigned int volumes() const { return hgpar_->moduleLayR_.size(); }
inline unsigned int volumes() const { return hgpar_->moduleLayR_.size(); }
int waferFromCopy(int copy) const;
void waferFromPosition(const double x, const double y, int& wafer, int& icell, int& celltyp) const;
void waferFromPosition(const double x,
Expand All @@ -174,93 +156,63 @@ class HGCalDDDConstants {
double& wt,
bool extend = false,
bool debug = false) const;
bool waferHexagon6() const {
inline bool waferHexagon6() const {
return ((mode_ == HGCalGeometryMode::Hexagon) || (mode_ == HGCalGeometryMode::HexagonFull));
}
bool waferHexagon8() const {
inline bool waferHexagon8() const {
return ((mode_ == HGCalGeometryMode::Hexagon8) || (mode_ == HGCalGeometryMode::Hexagon8Full) ||
(mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module) ||
(mode_ == HGCalGeometryMode::Hexagon8Cassette));
}
bool waferHexagon8File() const {
inline bool waferHexagon8File() const {
return ((mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module) ||
(mode_ == HGCalGeometryMode::Hexagon8Cassette));
}
bool waferInLayer(int wafer, int lay, bool reco) const;
bool waferFullInLayer(int wafer, int lay, bool reco) const;
int waferCount(const int type) const { return ((type == 0) ? waferMax_[2] : waferMax_[3]); }
int waferMax() const { return waferMax_[1]; }
int waferMin() const { return waferMax_[0]; }
inline int waferCount(const int type) const { return ((type == 0) ? waferMax_[2] : waferMax_[3]); }
HGCalParameters::waferInfo waferInfo(int lay, int waferU, int waferV) const;
inline int waferMax() const { return waferMax_[1]; }
inline int waferMin() const { return waferMax_[0]; }
std::pair<double, double> waferParameters(bool reco) const;
std::pair<double, double> waferPosition(int wafer, bool reco) const;
std::pair<double, double> waferPosition(int lay, int waferU, int waferV, bool reco, bool debug = false) const;
unsigned int waferFileSize() const { return hgpar_->waferInfoMap_.size(); }
int waferFileIndex(unsigned int kk) const {
if (kk < hgpar_->waferInfoMap_.size()) {
auto itr = hgpar_->waferInfoMap_.begin();
std::advance(itr, kk);
return itr->first;
} else
return 0;
}
std::tuple<int, int, int> waferFileInfo(unsigned int kk) const {
if (kk < hgpar_->waferInfoMap_.size()) {
auto itr = hgpar_->waferInfoMap_.begin();
std::advance(itr, kk);
return std::make_tuple(itr->second.type, itr->second.part, itr->second.orient);
} else
return std::make_tuple(0, 0, 0);
}
std::tuple<int, int, int> waferFileInfoFromIndex(int kk) const {
auto itr = hgpar_->waferInfoMap_.find(kk);
if (itr != hgpar_->waferInfoMap_.end()) {
return std::make_tuple(itr->second.type, itr->second.part, itr->second.orient);
} else
return std::make_tuple(0, 0, 0);
}
bool waferFileInfoExist(int kk) const { return (hgpar_->waferInfoMap_.find(kk) != hgpar_->waferInfoMap_.end()); }
double waferSepar(bool reco) const {
return (reco ? hgpar_->sensorSeparation_ : HGCalParameters::k_ScaleToDDD * hgpar_->sensorSeparation_);
inline unsigned int waferFileSize() const { return hgpar_->waferInfoMap_.size(); }
int waferFileIndex(unsigned int kk) const;
std::tuple<int, int, int> waferFileInfo(unsigned int kk) const;
std::tuple<int, int, int> waferFileInfoFromIndex(int kk) const;
inline bool waferFileInfoExist(int kk) const {
return (hgpar_->waferInfoMap_.find(kk) != hgpar_->waferInfoMap_.end());
}
GlobalPoint waferLocal2Global(
HepGeom::Point3D<float>& loc, const DetId& id, bool useWafer, bool reco, bool debug) const {
HGCSiliconDetId detid(id);
double x(0), y(0);
if (useWafer) {
auto xyw = waferPositionNoRot(detid.layer(), detid.waferU(), detid.waferV(), reco, debug);
x = xyw.first;
y = xyw.second;
}
auto xy = getXY(detid.layer(), (x + loc.x()), (y + loc.y()), false);
double zz =
(detid.zside() < 0) ? -(loc.z() + waferZ(detid.layer(), reco)) : (loc.z() + waferZ(detid.layer(), reco));
double xx = (detid.zside() < 0) ? -xy.first : xy.first;
return GlobalPoint(xx, xy.second, zz);
HepGeom::Point3D<float>& loc, const DetId& id, bool useWafer, bool reco, bool debug) const;
inline double waferSepar(bool reco) const {
return (reco ? hgpar_->sensorSeparation_ : HGCalParameters::k_ScaleToDDD * hgpar_->sensorSeparation_);
}
double waferSize(bool reco) const {
inline double waferSize(bool reco) const {
return (reco ? hgpar_->waferSize_ : HGCalParameters::k_ScaleToDDD * hgpar_->waferSize_);
}
int wafers() const;
int wafers(int layer, int type) const;
int waferToCopy(int wafer) const {
inline int waferToCopy(int wafer) const {
return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferCopy_.size())))
? hgpar_->waferCopy_[wafer]
: static_cast<int>(hgpar_->waferCopy_.size());
}
// wafer transverse thickness classification (2 = coarse, 1 = fine)
int waferTypeT(int wafer) const {
inline int waferTypeT(int wafer) const {
return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferTypeT_.size()))) ? hgpar_->waferTypeT_[wafer] : 0;
}
// wafer longitudinal thickness classification (1 = 100um, 2 = 200um, 3=300um)
int waferTypeL(int wafer) const {
inline int waferTypeL(int wafer) const {
return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferTypeL_.size()))) ? hgpar_->waferTypeL_[wafer] : 0;
}
int waferType(DetId const& id, bool fromFile = false) const;
int waferType(int layer, int waferU, int waferV, bool fromFile = false) const;
std::tuple<int, int, int> waferType(HGCSiliconDetId const& id, bool fromFile = false) const;
std::pair<int, int> waferTypeRotation(
int layer, int waferU, int waferV, bool fromFile = false, bool debug = false) const;
int waferUVMax() const { return hgpar_->waferUVMax_; }
inline int waferUVMax() const { return hgpar_->waferUVMax_; }
bool waferVirtual(int layer, int waferU, int waferV) const;
double waferZ(int layer, bool reco) const;

Expand Down
Loading