|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
#ifndef Geometry_TrackerGeometryBuilder_RectangularPixelTopology_H
#define Geometry_TrackerGeometryBuilder_RectangularPixelTopology_H
/**
* Topology for rectangular pixel detector with BIG pixels.
*/
// Modified for the large pixels. Should work for barrel and forward.
// Danek Kotlinski & Michele Pioppi, 3/06.
// The bigger pixels are on the ROC boundries.
// For columns (Y direction, longer direction):
// the normal pixel are 150um long, big pixels are 300um long,
// the pixel index goes from 0 to 416 (or less for smaller modules)
// the big pixel are in 0, 52,104,156,208,260,312,363
// 51,103,155,207,259,311,363,415 .
// For rows (X direction, shorter direction):
// the normal pixel are 100um wide, big pixels are 200um wide,
// the pixel index goes from 0 to 159 (or less for smaller modules)
// the big pixel are in 79,80.
// The ROC has rows=80, cols=52.
// There are a lot of hardwired constants, sorry but this is a very
// specific class. For any other sensor design it has to be rewritten.
// G. Giurgiu 11/27/06 ---------------------------------------------
// Check whether the pixel is at the edge of the module by adding the
// following functions (ixbin and iybin are the pixel row and column
// inside the module):
// bool isItEdgePixelInX (int ixbin)
// bool isItEdgePixelInY (int iybin)
// bool isItEdgePixel (int ixbin, int iybin)
// ------------------------------------------------------------------
// Add the individual measurement to local trasformations classes 01/07 d.k.
// ------------------------------------------------------------------
// Add big pixel flags for cluster range 15/3/07 V.Chiochia
#include "Geometry/CommonTopologies/interface/PixelTopology.h"
#include "DataFormats/SiPixelDetId/interface/PixelChannelIdentifier.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
class RectangularPixelTopology final : public PixelTopology {
public:
// Constructor, initilize
RectangularPixelTopology(int nrows,
int ncols,
float pitchx,
float pitchy,
int ROWS_PER_ROC, // Num of Rows per ROC
int COLS_PER_ROC, // Num of Cols per ROC
int BIG_PIX_PER_ROC_X, // in x direction, rows. BIG_PIX_PER_ROC_X = 0 for SLHC
int BIG_PIX_PER_ROC_Y, // in y direction, cols. BIG_PIX_PER_ROC_Y = 0 for SLHC
int ROCS_X,
int ROCS_Y)
: m_pitchx(pitchx),
m_pitchy(pitchy),
m_nrows(nrows),
m_ncols(ncols),
m_ROWS_PER_ROC(ROWS_PER_ROC), // Num of Rows per ROC
m_COLS_PER_ROC(COLS_PER_ROC), // Num of Cols per ROC
m_ROCS_X(ROCS_X), // 2 for SLHC
m_ROCS_Y(ROCS_Y) // 8 for SLHC
{
// Calculate the edge of the active sensor with respect to the center,
// that is simply the half-size.
// Take into account large pixels
m_xoffset = -(m_nrows + BIG_PIX_PER_ROC_X * m_nrows / ROWS_PER_ROC) / 2. * m_pitchx;
m_yoffset = -(m_ncols + BIG_PIX_PER_ROC_Y * m_ncols / COLS_PER_ROC) / 2. * m_pitchy;
LogDebug("RectangularPixelTopology") << "nrows " << m_nrows << ", ncols " << m_ncols << ", pitchx " << m_pitchx
<< ", pitchy " << m_pitchy << ", xoffset " << m_xoffset << ", yoffset "
<< m_yoffset << ", BIG_PIX_PER_ROC_X " << BIG_PIX_PER_ROC_X
<< ", BIG_PIX_PER_ROC_Y " << BIG_PIX_PER_ROC_Y << ", ROWS_PER_ROC "
<< ROWS_PER_ROC << ", COLS_PER_ROC " << COLS_PER_ROC << ", ROCS_X " << ROCS_X
<< ", ROCS_Y " << ROCS_Y << "\nNROWS " << m_ROWS_PER_ROC * m_ROCS_X
<< ", NCOL " << m_COLS_PER_ROC * m_ROCS_Y;
}
// Topology interface, go from Masurement to Local corrdinates
// pixel coordinates (mp) -> cm (LocalPoint)
LocalPoint localPosition(const MeasurementPoint& mp) const override;
// Transform LocalPoint to Measurement. Call pixel().
MeasurementPoint measurementPosition(const LocalPoint& lp) const override {
std::pair<float, float> p = pixel(lp);
return MeasurementPoint(p.first, p.second);
}
// PixelTopology interface.
// Transform LocalPoint in cm to measurement in pitch units.
std::pair<float, float> pixel(const LocalPoint& p) const override;
// Errors
// Error in local (cm) from the masurement errors
LocalError localError(const MeasurementPoint&, const MeasurementError&) const override;
// Errors in pitch units from localpoint error (in cm)
MeasurementError measurementError(const LocalPoint&, const LocalError&) const override;
//-------------------------------------------------------------
// Transform LocalPoint to channel. Call pixel()
//
int channel(const LocalPoint& lp) const override {
std::pair<float, float> p = pixel(lp);
return PixelChannelIdentifier::pixelToChannel(int(p.first), int(p.second));
}
//-------------------------------------------------------------
// Transform measurement to local coordinates individually in each dimension
//
float localX(const float mpX) const override;
float localY(const float mpY) const override;
//-------------------------------------------------------------
// Return the BIG pixel information for a given pixel
//
bool isItBigPixelInX(const int ixbin) const override { return ((ixbin == 79) | (ixbin == 80)); }
bool isItBigPixelInY(const int iybin) const override {
int iybin0 = iybin % 52;
return ((iybin0 == 0) | (iybin0 == 51));
}
float pixelFractionInX(const int ixbin) const override {
if ((ixbin == 79) | (ixbin == 80)) {
return 2.0f;
} else {
return 1.0f;
}
}
float pixelFractionInY(const int iybin) const override {
int iybin0 = iybin % 52;
if ((iybin0 == 0) | (iybin0 == 51)) {
return 2.0f;
} else {
return 1.0f;
}
}
// constexpr int bigYIndeces[]{0,51,52,103,104,155,156,207,208,259,260,311,312,363,364,415,416,511};
// return *std::lower_bound(std::begin(bigYIndeces),std::end(bigYIndeces),iybin) == iybin;
//-------------------------------------------------------------
// Return BIG pixel flag in a given pixel range
//
bool containsBigPixelInX(int ixmin, int ixmax) const override { return ((ixmin <= 80) & (ixmax >= 79)); }
bool containsBigPixelInY(int iymin, int iymax) const override {
return (isItBigPixelInY(iymin) || isItBigPixelInY(iymax) || (iymin / 52) != (iymax / 52));
}
bool bigpixelsX() const override { return false; }
bool bigpixelsY() const override { return false; }
//-------------------------------------------------------------
// Check whether the pixel is at the edge of the module
//
bool isItEdgePixelInX(int ixbin) const override { return ((ixbin == 0) | (ixbin == (m_nrows - 1))); }
bool isItEdgePixelInY(int iybin) const override { return ((iybin == 0) | (iybin == (m_ncols - 1))); }
bool isItEdgePixel(int ixbin, int iybin) const override {
return (isItEdgePixelInX(ixbin) || isItEdgePixelInY(iybin));
}
//------------------------------------------------------------------
// Return pitch
std::pair<float, float> pitch() const override { return std::pair<float, float>(float(m_pitchx), float(m_pitchy)); }
// Return number of rows
int nrows() const override { return (m_nrows); }
// Return number of cols
int ncolumns() const override { return (m_ncols); }
// mlw Return number of ROCS Y
int rocsY() const override { return m_ROCS_Y; }
// mlw Return number of ROCS X
int rocsX() const override { return m_ROCS_X; }
// mlw Return number of rows per roc
int rowsperroc() const override { return m_ROWS_PER_ROC; }
// mlw Return number of cols per roc
int colsperroc() const override { return m_COLS_PER_ROC; }
float xoffset() const { return m_xoffset; }
float yoffset() const { return m_yoffset; }
private:
float m_pitchx;
float m_pitchy;
float m_xoffset;
float m_yoffset;
int m_nrows;
int m_ncols;
int m_ROWS_PER_ROC;
int m_COLS_PER_ROC;
int m_ROCS_X;
int m_ROCS_Y;
};
#endif
|