|
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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
|
#include "EventFilter/CSCRawToDigi/interface/CSCTMBHeader2020_CCLUT.h"
#include "EventFilter/CSCRawToDigi/interface/CSCDMBHeader.h"
#include "FWCore/Utilities/interface/Exception.h"
const std::vector<std::pair<unsigned, unsigned> >
run3_pattern_lookup_tbl = {{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, /// Valid LCT0, invalid LCT1 combination. Check LCT1 vpf
{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 0}, {1, 1}, {1, 2}, {1, 3},
{1, 4}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}, {3, 0}, {3, 1}, {3, 2},
{3, 3}, {3, 4}, {4, 0}, {4, 1}, {4, 2}, {4, 3}, {4, 4}}; /// pattern IDs 30,31 are reserved
const unsigned run2_pattern_lookup_tbl[2][16] = {{10, 10, 10, 8, 8, 8, 6, 6, 6, 4, 4, 4, 2, 2, 2, 2},
{10, 10, 10, 9, 9, 9, 7, 7, 7, 5, 5, 5, 3, 3, 3, 3}};
CSCTMBHeader2020_CCLUT::CSCTMBHeader2020_CCLUT() {
bzero(data(), sizeInWords() * 2);
bits.nHeaderFrames = 42;
bits.e0bline = 0x6E0B;
bits.b0cline = 0xDB0C;
bits.firmRevCode = 0x401;
bits.nTBins = 12;
bits.nCFEBs = 7;
}
CSCTMBHeader2020_CCLUT::CSCTMBHeader2020_CCLUT(const unsigned short* buf) { memcpy(data(), buf, sizeInWords() * 2); }
void CSCTMBHeader2020_CCLUT::setEventInformation(const CSCDMBHeader& dmbHeader) {
bits.cscID = dmbHeader.dmbID();
bits.l1aNumber = dmbHeader.l1a();
bits.bxnCount = dmbHeader.bxn();
}
///returns CLCT digis
std::vector<CSCCLCTDigi> CSCTMBHeader2020_CCLUT::CLCTDigis(uint32_t idlayer) {
std::vector<CSCCLCTDigi> result;
unsigned halfstrip = bits.clct0_key_low + (bits.clct0_key_high << 7);
unsigned strip = halfstrip % 32;
// CLCT0 1/4 strip bit
bool quartstrip = (bits.clct0_xky >> 1) & 0x1;
// CLCT1 1/8 strip bit
bool eighthstrip = bits.clct0_xky & 0x1;
unsigned cfeb = halfstrip / 32;
/// CLCT0 LR bend and slope are from dedicated header fields
unsigned run3_pattern = bits.clct0_shape & 0x7; // 3-bit Run3 CLCT PatternID
unsigned bend = bits.clct0_LR_bend;
unsigned slope = bits.clct0_slope;
unsigned run2_pattern = run2_pattern_lookup_tbl[bend][slope];
CSCCLCTDigi digi0(bits.clct0_valid,
bits.clct0_quality,
run2_pattern,
1,
bend,
strip,
cfeb,
bits.clct_bxn,
1,
bits.bxnPreTrigger,
bits.clct0_comparator_code,
CSCCLCTDigi::Version::Run3,
quartstrip,
eighthstrip,
run3_pattern,
slope);
halfstrip = bits.clct1_key_low + (bits.clct1_key_high << 7);
strip = halfstrip % 32;
// CLCT0 1/4 strip bit
quartstrip = (bits.clct1_xky >> 1) & 0x1;
// CLCT1 1/8 strip bit
eighthstrip = bits.clct1_xky & 0x1;
cfeb = halfstrip / 32;
// CLCT LR bend and slope are from dedicated header fields
run3_pattern = bits.clct1_shape & 0x7; // 3-bit Run3 CLCT PatternID
bend = bits.clct1_LR_bend;
slope = bits.clct1_slope;
run2_pattern = run2_pattern_lookup_tbl[bend][slope];
CSCCLCTDigi digi1(bits.clct1_valid,
bits.clct1_quality,
run2_pattern,
1,
bend,
strip,
cfeb,
bits.clct_bxn,
2,
bits.bxnPreTrigger,
bits.clct1_comparator_code,
CSCCLCTDigi::Version::Run3,
quartstrip,
eighthstrip,
run3_pattern,
slope);
result.push_back(digi0);
result.push_back(digi1);
return result;
}
///returns CorrelatedLCT digis
std::vector<CSCCorrelatedLCTDigi> CSCTMBHeader2020_CCLUT::CorrelatedLCTDigis(uint32_t idlayer) const {
std::vector<CSCCorrelatedLCTDigi> result;
/// for the zeroth MPC word:
unsigned strip = bits.MPC_Muon0_clct_key_halfstrip; //this goes from 0-223
unsigned slope = (bits.MPC_Muon0_clct_bend_low & 0x7) | (bits.MPC_Muon0_clct_bend_bit4 << 3);
unsigned hmt = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger
unsigned clct_pattern_id = bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4);
std::pair<unsigned, unsigned> run3_pattern_pair = run3_pattern_lookup_tbl[clct_pattern_id % 30];
unsigned run2_pattern = run2_pattern_lookup_tbl[bits.MPC_Muon0_clct_LR][slope];
unsigned run3_pattern = run3_pattern_pair.second & 0x7;
CSCCorrelatedLCTDigi digi(1,
bits.MPC_Muon0_lct_vpf,
bits.MPC_Muon0_lct_quality,
bits.MPC_Muon0_alct_key_wire,
strip,
run2_pattern,
bits.MPC_Muon0_clct_LR,
bits.MPC_Muon_alct_bxn,
0,
bits.MPC_Muon0_clct_bx0,
0,
0,
CSCCorrelatedLCTDigi::Version::Run3,
bits.MPC_Muon0_clct_QuarterStrip,
bits.MPC_Muon0_clct_EighthStrip,
run3_pattern,
slope);
digi.setHMT(hmt);
result.push_back(digi);
/// for the first MPC word:
strip = bits.MPC_Muon1_clct_key_halfstrip; //this goes from 0-223
slope = (bits.MPC_Muon1_clct_bend_low & 0x7) | (bits.MPC_Muon1_clct_bend_bit4 << 3);
run2_pattern = run2_pattern_lookup_tbl[bits.MPC_Muon1_clct_LR][slope];
run3_pattern = run3_pattern_pair.first & 0x7;
digi = CSCCorrelatedLCTDigi(2,
bits.MPC_Muon1_lct_vpf,
bits.MPC_Muon1_lct_quality,
bits.MPC_Muon1_alct_key_wire,
strip,
run2_pattern,
bits.MPC_Muon1_clct_LR,
bits.MPC_Muon_alct_bxn,
0,
bits.MPC_Muon1_clct_bx0,
0,
0,
CSCCorrelatedLCTDigi::Version::Run3,
bits.MPC_Muon1_clct_QuarterStrip,
bits.MPC_Muon1_clct_EighthStrip,
run3_pattern,
slope);
digi.setHMT(hmt);
result.push_back(digi);
return result;
}
CSCShowerDigi CSCTMBHeader2020_CCLUT::showerDigi(uint32_t idlayer) const {
unsigned hmt_bits = bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1); // HighMultiplicityTrigger bits
uint16_t cscid = bits.cscID; // ??? What is 4-bits CSC Id in CSshowerDigi
//L1A_TMB_WINDOW is not included in below formula
//correct version: CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + L1A_TMB_WINDOW/2;
// same for anode HMT and cathode HMT
uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win;
//LCTshower with showerType = 3. comparatorNHits from hmt_nhits() and wireNHit is not available
CSCShowerDigi result(hmt_bits & 0x3,
(hmt_bits >> 2) & 0x3,
cscid,
bx,
CSCShowerDigi::ShowerType::kLCTShower,
0,
hmt_nhits()); // 2-bits intime, 2-bits out of time
return result;
}
CSCShowerDigi CSCTMBHeader2020_CCLUT::anodeShowerDigi(uint32_t idlayer) const {
uint16_t cscid = bits.cscID;
uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win;
//ALCT shower with showerType = 1. nhits_ is not available from unpack data
CSCShowerDigi result(
bits.anode_hmt & 0x3, 0, cscid, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0); // 2-bits intime, no out of time
return result;
}
CSCShowerDigi CSCTMBHeader2020_CCLUT::cathodeShowerDigi(uint32_t idlayer) const {
uint16_t cscid = bits.cscID;
uint16_t bx = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win - bits.hmt_match_win + 3;
//CLCT shower with showerType = 2.
CSCShowerDigi result(bits.cathode_hmt & 0x3,
0,
cscid,
bx,
CSCShowerDigi::ShowerType::kCLCTShower,
0,
hmt_nhits()); // 2-bits intime, no out of time
return result;
}
void CSCTMBHeader2020_CCLUT::addALCT0(const CSCALCTDigi& digi) {
throw cms::Exception("In CSC TMBHeaderFormat 2007, ALCTs belong in ALCT header");
}
void CSCTMBHeader2020_CCLUT::addALCT1(const CSCALCTDigi& digi) {
throw cms::Exception("In CSC TMBHeaderFormat 2007, ALCTs belong in ALCT header");
}
void CSCTMBHeader2020_CCLUT::addCLCT0(const CSCCLCTDigi& digi) {
unsigned halfStrip = digi.getKeyStrip();
unsigned pattern = digi.getRun3Pattern();
bits.clct0_valid = digi.isValid();
bits.clct0_quality = digi.getQuality();
bits.clct0_shape = pattern;
// first 7 bits of halfstrip
bits.clct0_key_low = halfStrip & (0x7F);
// most-significant (8th) bit
bits.clct0_key_high = (halfStrip >> 7) & (0x1);
bits.clct_bxn = digi.getBX();
bits.bxnPreTrigger = digi.getFullBX();
bits.clct0_comparator_code = digi.getCompCode();
bits.clct0_xky = (digi.getEighthStripBit() & 0x1) + ((digi.getQuartStripBit() & 0x1) << 1);
bits.clct0_LR_bend = digi.getBend();
bits.clct0_slope = digi.getSlope();
}
void CSCTMBHeader2020_CCLUT::addCLCT1(const CSCCLCTDigi& digi) {
unsigned halfStrip = digi.getKeyStrip();
unsigned pattern = digi.getRun3Pattern();
bits.clct1_valid = digi.isValid();
bits.clct1_quality = digi.getQuality();
bits.clct1_shape = pattern;
// first 7 bits of halfstrip
bits.clct1_key_low = halfStrip & (0x7F);
// most-significant (8th) bit
bits.clct1_key_high = (halfStrip >> 7) & (0x1);
// There is just one BX field common for CLCT0 and CLCT1 (since both
// are latched at the same BX); set it in addCLCT0().
bits.bxnPreTrigger = digi.getFullBX();
bits.clct1_comparator_code = digi.getCompCode();
bits.clct1_xky = (digi.getEighthStripBit() & 0x1) + ((digi.getQuartStripBit() & 0x1) << 1);
bits.clct1_LR_bend = digi.getBend();
bits.clct1_slope = digi.getSlope();
}
void CSCTMBHeader2020_CCLUT::addCorrelatedLCT0(const CSCCorrelatedLCTDigi& digi) {
bits.MPC_Muon0_lct_vpf = digi.isValid();
bits.MPC_Muon0_alct_key_wire = digi.getKeyWG();
bits.MPC_Muon0_clct_key_halfstrip = digi.getStrip(2) & 0xFF;
bits.MPC_Muon0_clct_QuarterStrip = digi.getQuartStripBit() & 0x1;
bits.MPC_Muon0_clct_EighthStrip = digi.getEighthStripBit() & 0x1;
bits.MPC_Muon0_lct_quality = digi.getQuality() & 0x7;
// To restore 5-bits Run3 CLCT Pattern ID first assume and set pattern ID = LCT0 Run3 pattern
uint16_t run3_pattern = digi.getRun3Pattern();
bits.MPC_Muon_clct_pattern_low = run3_pattern & 0xF;
bits.MPC_Muon_clct_pattern_bit5 = (run3_pattern >> 4) & 0x1;
bits.MPC_Muon0_clct_bend_low = digi.getSlope() & 0x7;
bits.MPC_Muon0_clct_bend_bit4 = (digi.getSlope() >> 3) & 0x1;
bits.MPC_Muon0_clct_LR = digi.getBend() & 0x1;
bits.MPC_Muon_HMT_bit0 = digi.getHMT() & 0x1;
bits.MPC_Muon_HMT_high = (digi.getHMT() >> 1) & 0x7;
bits.MPC_Muon_alct_bxn = digi.getBX();
bits.MPC_Muon0_clct_bx0 = digi.getBX0();
}
void CSCTMBHeader2020_CCLUT::addCorrelatedLCT1(const CSCCorrelatedLCTDigi& digi) {
bits.MPC_Muon1_lct_vpf = digi.isValid();
bits.MPC_Muon1_alct_key_wire = digi.getKeyWG();
bits.MPC_Muon1_clct_key_halfstrip = digi.getStrip(2) & 0xFF;
bits.MPC_Muon1_clct_QuarterStrip = digi.getQuartStripBit() & 0x1;
bits.MPC_Muon1_clct_EighthStrip = digi.getEighthStripBit() & 0x1;
bits.MPC_Muon1_lct_quality = digi.getQuality() & 0x7;
// To restore 5-bits Run3 CLCT Pattern ID assume that LCT0 pattern ID is already processed
// and combine LCT1 Run3 pattern to set final 5-bit pattern ID
if (digi.isValid()) {
uint16_t clct_pattern_id = bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4);
uint16_t run3_pattern = digi.getRun3Pattern();
clct_pattern_id = (clct_pattern_id + (run3_pattern + 1) * 5) % 30;
bits.MPC_Muon_clct_pattern_low = clct_pattern_id & 0xF;
bits.MPC_Muon_clct_pattern_bit5 = (clct_pattern_id >> 4) & 0x1;
}
bits.MPC_Muon1_clct_bend_low = digi.getSlope() & 0x7;
bits.MPC_Muon1_clct_bend_bit4 = (digi.getSlope() >> 3) & 0x1;
bits.MPC_Muon1_clct_LR = digi.getBend() & 0x1;
bits.MPC_Muon_HMT_bit0 = digi.getHMT() & 0x1;
bits.MPC_Muon_HMT_high = (digi.getHMT() >> 1) & 0x7;
bits.MPC_Muon_alct_bxn = digi.getBX();
bits.MPC_Muon1_clct_bx0 = digi.getBX0();
}
void CSCTMBHeader2020_CCLUT::addShower(const CSCShowerDigi& digi) {
uint16_t hmt_bits = digi.isValid() ? (digi.bitsInTime() & 0x3) + ((digi.bitsOutOfTime() & 0x3) << 2)
//if not valid LCT shower, then in-time bits must be 0. keep out-of-time HMT:
: ((digi.bitsOutOfTime() & 0x3) << 2);
bits.MPC_Muon_HMT_bit0 = hmt_bits & 0x1;
bits.MPC_Muon_HMT_high = (hmt_bits >> 1) & 0x7;
//to keep pop_l1a_match_win
if (digi.isValid())
bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX();
else
bits.pop_l1a_match_win = 3; //default value
}
void CSCTMBHeader2020_CCLUT::addAnodeShower(const CSCShowerDigi& digi) {
uint16_t hmt_bits = digi.bitsInTime() & 0x3;
if (not digi.isValid())
hmt_bits = 0;
bits.anode_hmt = hmt_bits;
if (not(bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high) and digi.isValid())
bits.pop_l1a_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX();
else if (not(digi.isValid()))
bits.pop_l1a_match_win = 3; //default value
}
void CSCTMBHeader2020_CCLUT::addCathodeShower(const CSCShowerDigi& digi) {
uint16_t hmt_bits = digi.bitsInTime() & 0x3;
if (not digi.isValid())
hmt_bits = 0;
bits.cathode_hmt = hmt_bits;
bits.hmt_nhits_bit0 = digi.getComparatorNHits() & 0x1;
bits.hmt_nhits_bit1 = (digi.getComparatorNHits() >> 1) & 0x1;
bits.hmt_nhits_bits_high = (digi.getComparatorNHits() >> 2) & 0x1F;
if (bits.MPC_Muon_HMT_bit0 or bits.MPC_Muon_HMT_high or bits.anode_hmt) {
//matched HMT is found, then pop_l1a_match_win is assigned
bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - bits.pop_l1a_match_win + 3 - digi.getBX();
} else if (digi.isValid()) {
bits.pop_l1a_match_win = 3; //default value
bits.hmt_match_win = CSCConstants::LCT_CENTRAL_BX - digi.getBX();
} else {
bits.pop_l1a_match_win = 3; //default value
bits.hmt_match_win = 0; //no HMT case
}
}
void CSCTMBHeader2020_CCLUT::print(std::ostream& os) const {
os << "...............(O)TMB2020 CCLUT/HMT Header.................."
<< "\n";
os << std::hex << "BOC LINE " << bits.b0cline << " EOB " << bits.e0bline << "\n";
os << std::hex << "FW revision: 0x" << bits.firmRevCode << "\n";
os << std::dec << "fifoMode = " << bits.fifoMode << ", nTBins = " << bits.nTBins << "\n";
os << "boardID = " << bits.boardID << ", cscID = " << bits.cscID << "\n";
os << "l1aNumber = " << bits.l1aNumber << ", bxnCount = " << bits.bxnCount << "\n";
os << "trigSourceVect = " << bits.trigSourceVect << ", run3_trig_df = " << bits.run3_trig_df << ", activeCFEBs = 0x"
<< std::hex << (bits.activeCFEBs | (bits.activeCFEBs_2 << 5)) << ", readCFEBs = 0x" << std::hex
<< (bits.readCFEBs | (bits.readCFEBs_2 << 5)) << std::dec << "\n";
os << "bxnPreTrigger = " << bits.bxnPreTrigger << "\n";
os << "ALCT location in CLCT window " << bits.matchWin << " L1A location in TMB window " << bits.pop_l1a_match_win
<< " ALCT in cathde HMT window " << bits.hmt_match_win << "\n";
os << "tmbMatch = " << bits.tmbMatch << " alctOnly = " << bits.alctOnly << " clctOnly = " << bits.clctOnly << "\n";
os << "readoutCounter: " << std::dec << bits.readoutCounter << ", buf_q_ovf: " << bits.stackOvf
<< ", sync_err: " << bits.syncError << ", has_buf: " << bits.hasBuf << ", buf_stalled: " << bits.bufFull << "\n";
os << "r_wr_buf_adr: 0x" << std::hex << bits.r_wr_buf_adr << ", r_wr_buf_ready: " << bits.r_wr_buf_ready
<< ", wr_buf_ready: " << bits.wr_buf_ready << ", buf_q_full: " << bits.buf_q_full
<< ", buf_q_empty: " << bits.buf_q_empty << ",\nr_buf_fence_dist: 0x" << bits.r_buf_fence_dist
<< ", buf_q_ovf_err: " << bits.buf_q_ovf_err << ", buf_q_udf_err: " << bits.buf_q_udf_err
<< ", buf_q_adr_err: " << bits.buf_q_adr_err << ", buf_stalled: " << bits.buf_stalled << ",\nbuf_fence_cnt: 0x"
<< bits.buf_fence_cnt << ", reverse_hs_csc: " << bits.reverse_hs_csc
<< ", reverse_hs_me1a: " << bits.reverse_hs_me1a << ", reverse_hs_me1b: " << bits.reverse_hs_me1b << "\n";
os << "CLCT Words:\n"
<< " bits.clct0_valid = " << bits.clct0_valid << " bits.clct0_shape = " << bits.clct0_shape
<< " bits.clct0_quality = " << bits.clct0_quality
<< " halfstrip = " << (bits.clct0_key_low + (bits.clct0_key_high << 7)) << "\n";
os << " bits.clct0_xky = " << bits.clct0_xky << " bits.clct0_comparator_code = " << bits.clct0_comparator_code
<< " bits.clct0_LR_bend = " << bits.clct0_LR_bend << " bits.clct0_slope = " << bits.clct0_slope << "\n";
os << " bits.clct1_valid = " << bits.clct1_valid << " bits.clct1_shape = " << bits.clct1_shape
<< " bits.clct1_quality = " << bits.clct1_quality
<< " halfstrip = " << (bits.clct1_key_low + (bits.clct1_key_high << 7)) << "\n";
os << " bits.clct1_xky = " << bits.clct1_xky << " bits.clct1_comparator_code = " << bits.clct1_comparator_code
<< " bits.clct1_LR_bend = " << bits.clct1_LR_bend << " bits.clct1_slope = " << bits.clct1_slope << "\n";
os << "MPC Words:\n"
<< " LCT0 valid = " << bits.MPC_Muon0_lct_vpf << " key WG = " << bits.MPC_Muon0_alct_key_wire
<< " key halfstrip = " << bits.MPC_Muon0_clct_key_halfstrip
<< " 1/4strip flag = " << bits.MPC_Muon0_clct_QuarterStrip
<< " 1/8strip flag = " << bits.MPC_Muon0_clct_EighthStrip << "\n"
<< " quality = " << bits.MPC_Muon0_lct_quality
<< " slope/bend = " << ((bits.MPC_Muon0_clct_bend_low & 0x7) | (bits.MPC_Muon0_clct_bend_bit4 << 3))
<< " L/R bend = " << bits.MPC_Muon0_clct_LR << "\n";
os << " LCT1 valid = " << bits.MPC_Muon1_lct_vpf << " key WG = " << bits.MPC_Muon1_alct_key_wire
<< " key halfstrip = " << bits.MPC_Muon1_clct_key_halfstrip
<< " 1/4strip flag = " << bits.MPC_Muon1_clct_QuarterStrip
<< " 1/8strip flag = " << bits.MPC_Muon1_clct_EighthStrip << "\n"
<< " quality = " << bits.MPC_Muon1_lct_quality
<< " slope/bend = " << ((bits.MPC_Muon1_clct_bend_low & 0x7) | (bits.MPC_Muon1_clct_bend_bit4 << 3))
<< " L/R bend = " << bits.MPC_Muon1_clct_LR << "\n";
os << " clct_5bit_pattern_id = " << (bits.MPC_Muon_clct_pattern_low | (bits.MPC_Muon_clct_pattern_bit5 << 4))
<< " HMT = " << (bits.MPC_Muon_HMT_bit0 | (bits.MPC_Muon_HMT_high << 1)) << ", alctHMT = " << bits.anode_hmt
<< ", clctHMT = " << bits.cathode_hmt << " cathode nhits " << hmt_nhits() << "\n";
}
|