ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Public Attributes | List of all members
SignalStateCnv Class Reference

#include <JetSignalStateCnv.h>

Collaboration diagram for SignalStateCnv:

Public Types

enum  CompressionLevel { HIGH , MEDIUM , LOW , NO_COMPRESSION }

Public Member Functions

 SignalStateCnv ()
char round (double d) const
char char_from_ratio (double r) const
double ratio_from_char (char c) const
JetConverterTypes::signalState_pers_t compress (const JetConverterTypes::momentum &momCal, const JetConverterTypes::momentum &momRaw, CompressionLevel level, MsgStream &msg) const
JetConverterTypes::momentum decompress (const JetConverterTypes::signalState_pers_t &ps, JetConverterTypes::momentum momCal, MsgStream &msg) const

Public Attributes

double m_delta_p
double m_step_p
double m_delta_m
double m_step_m
double m_center

Detailed Description

to convert a double into a char

New implementation: Sept. 12th 2008 Rolf Seuster

Still keep the old implementation around - we need this to read old jets. Now, we store the differences as Delta_0 = M_cal / M_raw - 1 Delta_1 = phi_cal - phi_raw Delta_2 = eta_cal - eta_raw Delta_3 = Pt_cal / Pt_raw - 1

These differences will in general be small, so storing them as a semi-float will help. The new functions return a vector<unsigned short> where all deltas are compressed together, a bit simular to EventCommonTPCnv/Compressor. An additional parameter determines the compression, store everything in 2, 3, 4, 6 or 8 short. 2 short == 4 char = 8 bit / delta : 3 exponent, 1 sign, 4 mantissa 3 short == 48 bit = 12 bit / delta : 4 exponent, 1 sign, 7 mantissa 4 short == 64 bit = 16 bit / delta : 5 exponent, 1 sign, 10 mantissa 8 short == 128 bit == 4 floats We can also take into account that: Delta_0/3 are always positive Delta_1 is in [-pi;pi] to improve the precision.

Convert ratio of calibrated and uncalibrated jet quantities into a char. It is assumed that the ratio is in a given range so that he precision loss due to converting a float in a double is small (~0.5 %)

first implementation (before finding better/cleaner way?)

Author
P.A. Delsart

Definition at line 77 of file JetSignalStateCnv.h.

Member Enumeration Documentation

◆ CompressionLevel

enum SignalStateCnv::CompressionLevel
Enumerator
HIGH 
MEDIUM 
LOW 
NO_COMPRESSION 

Definition at line 130 of file JetSignalStateCnv.h.

130{ HIGH, MEDIUM, LOW, NO_COMPRESSION };

Constructor & Destructor Documentation

◆ SignalStateCnv()

SignalStateCnv::SignalStateCnv ( )
inline

Definition at line 80 of file JetSignalStateCnv.h.

80 {
81 m_delta_p = 1.0;
82 m_step_p = 1.0 / 127;
83 m_delta_m = 0.4;
84 m_step_m = 0.4 / 127;
85 m_center = 0.8;
86 }

Member Function Documentation

◆ char_from_ratio()

char SignalStateCnv::char_from_ratio ( double r) const
inline

Definition at line 101 of file JetSignalStateCnv.h.

101 {
102 double d = r - m_center;
103
104 if (d > 0) {
105 if (d > m_delta_p) {
106 d = m_delta_p;
107 }
108 return round(d / m_step_p);
109 }
110
111 if (d < -m_delta_m) {
112 d = -m_delta_m;
113 }
114
115 const auto value = static_cast<unsigned char>(round(std::fabs(d) / m_step_m));
116 return static_cast<char>(value | 0x80u);
117 }
SignalStateCnv::round
char round(double d) const
Definition JetSignalStateCnv.h:97
r
int r
Definition globals.cxx:22
hist_file_dump.d
d
Definition hist_file_dump.py:142

◆ compress()

JetConverterTypes::signalState_pers_t SignalStateCnv::compress ( const JetConverterTypes::momentum & momCal,
const JetConverterTypes::momentum & momRaw,
CompressionLevel level,
MsgStream & msg ) const
inline

Definition at line 134 of file JetSignalStateCnv.h.

137 {
138 int exponent[4];
139 double mantissa[4] = {0};
140 JetConverterTypes::signalState_pers_t ps;
141
142 double delta0(0);
143 double delta1(0);
144 double delta2(0);
145 double delta3(0);
146 int factor;
147
148 msg << MSG::VERBOSE << "called JetSignalStateCnv::compress() for :" << endmsg;
149 msg << MSG::VERBOSE << " raw momentum ( px | py | pz | m ) : ( "
150 << momRaw.m_px << " | "
151 << momRaw.m_py << " | "
152 << momRaw.m_pz << " | "
153 << momRaw.m_m << " )" << endmsg;
154 msg << MSG::VERBOSE << " cal momentum ( px | py | pz | m ) : ( "
155 << momCal.m_px << " | "
156 << momCal.m_py << " | "
157 << momCal.m_pz << " | "
158 << momCal.m_m << " )" << endmsg;
159
160 bool forceNoCompression = false;
161
162 // switch off compression, if M or pT of raw or calibrated jet are zero...
163 if (momRaw.m_m == 0 || momCal.m_m == 0) {
164 forceNoCompression = true;
165 }
166 if (momRaw.m_px == 0 && momRaw.m_py == 0) {
167 forceNoCompression = true;
168 }
169 if (momCal.m_px == 0 && momCal.m_py == 0) {
170 forceNoCompression = true;
171 }
172
173 if (forceNoCompression) {
174 msg << MSG::DEBUG << "M or PT of calibrated or raw signal state of jet zero !"
175 << " Switching off compression for this jet !!!" << endmsg;
176 level = NO_COMPRESSION;
177 }
178
179 // prepare for compression the ratios
180 if (level != NO_COMPRESSION) {
181 double angleC = std::atan2(momCal.m_py, momCal.m_px);
182 double angleR = std::atan2(momRaw.m_py, momRaw.m_px);
183 double p_traC = std::sqrt(momCal.m_px * momCal.m_px + momCal.m_py * momCal.m_py);
184 double p_traR = std::sqrt(momRaw.m_px * momRaw.m_px + momRaw.m_py * momRaw.m_py);
185 mantissa[0] = std::frexp(momCal.m_m / momRaw.m_m - 1, &exponent[0]);
186 mantissa[1] = std::frexp(angleC - angleR, &exponent[1]);
187 mantissa[2] = std::frexp(momCal.eta() - momRaw.eta(), &exponent[2]);
188 mantissa[3] = std::frexp(p_traC / p_traR - 1, &exponent[3]);
189
190 delta0 = momCal.m_m / momRaw.m_m - 1;
191 delta1 = angleC - angleR;
192 delta2 = momCal.eta() - momRaw.eta();
193 delta3 = p_traC / p_traR - 1;
194 }
195
196 unsigned long tmp0(0);
197 unsigned long tmp1(0);
198 unsigned long tmp2(0);
199 unsigned long tmp3(0);
200
201 unsigned short vec0(0);
202 unsigned short vec1(0);
203 unsigned short vec2(0);
204
205 switch (level) {
206 case HIGH: // HIGH compression means, store differnces in 2 shorts
207 factor = 0; // compress the mass ratio
208 exponent[0] += 2;
209 if (exponent[0] > 0x7) {
210 exponent[0] = 0x7;
211 }
212 if (exponent[0] < 0x0) {
213 factor = -exponent[0];
214 exponent[0] = 0x0;
215 }
216 tmp0 = int(std::fabs(mantissa[0]) * 0x10) >> factor;
217 tmp0 |= (exponent[0] & 0x7) << 5;
218 if (mantissa[0] < 0) {
219 tmp0 |= 0x10;
220 }
221
222 factor = 0; // compress delta phi
223 exponent[1] += 5;
224 if (exponent[1] > 0x7) {
225 exponent[1] = 0x7;
226 }
227 if (exponent[1] < 0x0) {
228 factor = -exponent[1];
229 exponent[1] = 0x0;
230 }
231 tmp1 = int(std::fabs(mantissa[1]) * 0x10) >> factor;
232 tmp1 |= (exponent[1] & 0x7) << 5;
233 if (mantissa[1] < 0) {
234 tmp1 |= 0x10;
235 }
236
237 factor = 0; // compresss delta eta
238 exponent[2] += 5;
239 if (exponent[2] > 0x7) {
240 exponent[2] = 0x7;
241 }
242 if (exponent[2] < 0x0) {
243 factor = -exponent[2];
244 exponent[2] = 0x0;
245 }
246 tmp2 = int(std::fabs(mantissa[2]) * 0x10) >> factor;
247 tmp2 |= (exponent[2] & 0x7) << 5;
248 if (mantissa[2] < 0) {
249 tmp2 |= 0x10;
250 }
251
252 factor = 0; // compresss the pT ratio
253 exponent[3] += 5;
254 if (exponent[3] > 0x7) {
255 exponent[3] = 0x7;
256 }
257 if (exponent[3] < 0x0) {
258 factor = -exponent[3];
259 exponent[3] = 0x0;
260 }
261 tmp3 = int(std::fabs(mantissa[3]) * 0x10) >> factor;
262 tmp3 |= (exponent[3] & 0x7) << 5;
263 if (mantissa[3] < 0) {
264 tmp3 |= 0x10;
265 }
266
267 vec0 = tmp0;
268 vec0 += tmp1 << 8;
269 vec1 = tmp2;
270 vec1 += tmp3 << 8;
271 ps.push_back(vec0);
272 ps.push_back(vec1);
273 break;
274
275 case MEDIUM: // MEDIUM compression means, store differences in 3 shorts
276 factor = 0; // compress the mass ratio
277 exponent[0] += 3;
278 if (exponent[0] > 0xF) {
279 exponent[0] = 0xF;
280 }
281 if (exponent[0] < 0x0) {
282 factor = -exponent[0];
283 exponent[0] = 0;
284 }
285 tmp0 = int(std::fabs(mantissa[0]) * 0x80) >> factor;
286 if (mantissa[0] < 0) {
287 tmp0 |= 0x80;
288 }
289
290 factor = 0; // compress delta phi
291 exponent[1] += 6;
292 if (exponent[1] > 0xF) {
293 exponent[1] = 0xF;
294 }
295 if (exponent[1] < 0x0) {
296 factor = -exponent[1];
297 exponent[1] = 0;
298 }
299 tmp1 = int(std::fabs(mantissa[1]) * 0x80) >> factor;
300 if (mantissa[1] < 0) {
301 tmp1 |= 0x80;
302 }
303
304 factor = 0; // compresss delta eta
305 exponent[2] += 6;
306 if (exponent[2] > 0xF) {
307 exponent[2] = 0xF;
308 }
309 if (exponent[2] < 0x0) {
310 factor = -exponent[2];
311 exponent[2] = 0;
312 }
313 tmp2 = int(std::fabs(mantissa[2]) * 0x80) >> factor;
314 if (mantissa[2] < 0) {
315 tmp2 |= 0x80;
316 }
317
318 factor = 0; // compresss the pT ratio
319 exponent[3] += 6;
320 if (exponent[3] > 0xF) {
321 exponent[3] = 0xF;
322 }
323 if (exponent[3] < 0x0) {
324 factor = -exponent[3];
325 exponent[3] = 0;
326 }
327 tmp3 = int(std::fabs(mantissa[3]) * 0x80) >> factor;
328 if (mantissa[3] < 0) {
329 tmp3 |= 0x80;
330 }
331
332 vec0 = (tmp0 & 0xFF);
333 vec0 += (tmp1 & 0xFF) << 8;
334 vec1 = (tmp2 & 0xFF);
335 vec1 += (tmp3 & 0xFF) << 8;
336 vec2 = exponent[0];
337 vec2 |= exponent[1] << 4;
338 vec2 |= exponent[2] << 8;
339 vec2 |= exponent[3] << 12;
340 ps.push_back(vec0);
341 ps.push_back(vec1);
342 ps.push_back(vec2);
343 break;
344
345 case LOW: // LOW compression means, store differences in 4 shorts
346 factor = 0; // compress the mass ratio
347 exponent[0] += 5;
348 if (exponent[0] > 31) {
349 exponent[0] = 31;
350 }
351 if (exponent[0] < 0) {
352 factor = -exponent[0];
353 exponent[0] = 0;
354 }
355 tmp0 = int(std::fabs(mantissa[0]) * 0x400) >> factor;
356 tmp0 |= exponent[0] << 11;
357 if (mantissa[0] < 0) {
358 tmp0 |= 0x400;
359 }
360
361 factor = 0; // compress delta phi
362 exponent[1] += 7;
363 if (exponent[1] > 31) {
364 exponent[1] = 31;
365 }
366 if (exponent[1] < 0) {
367 factor = -exponent[1];
368 exponent[1] = 0;
369 }
370 tmp1 = int(std::fabs(mantissa[1]) * 0x400) >> factor;
371 tmp1 |= exponent[1] << 11;
372 if (mantissa[1] < 0) {
373 tmp1 |= 0x400;
374 }
375
376 factor = 0; // compresss delta eta
377 exponent[2] += 7;
378 if (exponent[2] > 31) {
379 exponent[2] = 31;
380 }
381 if (exponent[2] < 0) {
382 factor = -exponent[2];
383 exponent[2] = 0;
384 }
385 tmp2 = int(std::fabs(mantissa[2]) * 0x400) >> factor;
386 tmp2 |= exponent[2] << 11;
387 if (mantissa[2] < 0) {
388 tmp2 |= 0x400;
389 }
390
391 factor = 0; // compresss the pT ratio
392 exponent[3] += 7;
393 if (exponent[3] > 31) {
394 exponent[3] = 31;
395 }
396 if (exponent[3] < 0) {
397 factor = -exponent[3];
398 exponent[3] = 0;
399 }
400 tmp3 = int(std::fabs(mantissa[3]) * 0x400) >> factor;
401 tmp3 |= exponent[3] << 11;
402 if (mantissa[3] < 0) {
403 tmp3 |= 0x400;
404 }
405
406 ps.push_back(tmp0);
407 ps.push_back(tmp1);
408 ps.push_back(tmp2);
409 ps.push_back(tmp3);
410 break;
411
412 case NO_COMPRESSION:
413 default:
414 {
415 const auto px = SignalStateCnv_detail::shortsFromFloat(momRaw.m_px);
416 ps.push_back(px[0]);
417 ps.push_back(px[1]);
418
419 const auto py = SignalStateCnv_detail::shortsFromFloat(momRaw.m_py);
420 ps.push_back(py[0]);
421 ps.push_back(py[1]);
422
423 const auto pz = SignalStateCnv_detail::shortsFromFloat(momRaw.m_pz);
424 ps.push_back(pz[0]);
425 ps.push_back(pz[1]);
426
427 const auto mass = SignalStateCnv_detail::shortsFromFloat(momRaw.m_m);
428 ps.push_back(mass[0]);
429 ps.push_back(mass[1]);
430
431 msg << MSG::VERBOSE << " compress x : " << momRaw.m_px
432 << " = " << px[0] << " = " << px[1] << endmsg;
433 msg << MSG::VERBOSE << " compress y : " << momRaw.m_py
434 << " = " << py[0] << " = " << py[1] << endmsg;
435 msg << MSG::VERBOSE << " compress z : " << momRaw.m_pz
436 << " = " << pz[0] << " = " << pz[1] << endmsg;
437 msg << MSG::VERBOSE << " compress m : " << momRaw.m_m
438 << " = " << mass[0] << " = " << mass[1] << endmsg;
439 break;
440 }
441 }
442
443 if (msg.level() <= MSG::VERBOSE) {
444 msg << MSG::VERBOSE << " compress # ps : " << ps.size() << " : ";
445 for (JetConverterTypes::signalState_pers_t::const_iterator it = ps.begin(); it != ps.end(); ++it) {
446 msg << std::hex << *it << " ";
447 }
448 msg << std::dec << endmsg;
449 msg << MSG::VERBOSE << " compress x : " << momRaw.m_px << endmsg;
450 msg << MSG::VERBOSE << " compress y : " << momRaw.m_py << endmsg;
451 msg << MSG::VERBOSE << " compress z : " << momRaw.m_pz << endmsg;
452 msg << MSG::VERBOSE << " compress m : " << momRaw.m_m << endmsg;
453
454 int d0(0);
455 int d1(0);
456
457 switch (level) {
458 case HIGH:
459 d0 = 2;
460 d1 = 5;
461 break;
462 case MEDIUM:
463 d0 = 3;
464 d1 = 6;
465 break;
466 case LOW:
467 d0 = 5;
468 d1 = 7;
469 break;
470 case NO_COMPRESSION:
471 default:
472 break;
473 }
474
475 msg << MSG::DEBUG << " compress M : " << delta0 << " = "
476 << mantissa[0] << " *2^ " << exponent[0] - d0 << endmsg;
477 msg << MSG::DEBUG << " compress phi : " << delta1 << " = "
478 << mantissa[1] << " *2^ " << exponent[1] - d1 << endmsg;
479 msg << MSG::DEBUG << " compress eta : " << delta2 << " = "
480 << mantissa[2] << " *2^ " << exponent[2] - d1 << endmsg;
481 msg << MSG::DEBUG << " compress pT : " << delta3 << " = "
482 << mantissa[3] << " *2^ " << exponent[3] - d1 << endmsg;
483 }
484 return ps;
485 }
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
Base_Fragment.mass
mass
Definition Sherpa_i/share/common/Base_Fragment.py:59
D3PDMakerTestInstan::vec2
std::vector< D3PDTest::MyVec2 > vec2
Definition D3PDMakerTestDict.h:14
JetConverterTypes::signalState_pers_t
std::vector< unsigned short > signalState_pers_t
Definition JetConverterBase.h:12
SignalStateCnv_detail::shortsFromFloat
std::array< std::uint16_t, 2 > shortsFromFloat(float value)
Definition JetSignalStateCnv.h:67
dq_defect_virtual_defect_validation.d1
d1
Definition dq_defect_virtual_defect_validation.py:79
test_pyathena.px
px
Definition test_pyathena.py:18
msg
MsgStream & msg
Definition testRead.cxx:32

◆ decompress()

JetConverterTypes::momentum SignalStateCnv::decompress ( const JetConverterTypes::signalState_pers_t & ps,
JetConverterTypes::momentum momCal,
MsgStream & msg ) const
inline

Definition at line 488 of file JetSignalStateCnv.h.

490 {
491 JetConverterTypes::momentum momRaw;
492 int exponent[4] = {0};
493 double mantissa[4] = {0};
494
495 switch (ps.size()) {
496 case 2:
497 exponent[0] = ((ps[0] >> 5) & 0x7) - 2;
498 exponent[1] = ((ps[0] >> 13) & 0x7) - 5;
499 exponent[2] = ((ps[1] >> 5) & 0x7) - 5;
500 exponent[3] = ((ps[1] >> 13) & 0x7) - 5;
501
502 mantissa[0] = double( ps[0] & 0x1F) / 0x10;
503 mantissa[1] = double((ps[0] >> 8) & 0x1F) / 0x10;
504 mantissa[2] = double( ps[1] & 0x1F) / 0x10;
505 mantissa[3] = double((ps[1] >> 8) & 0x1F) / 0x10;
506 if (ps[0] & 0x10) {
507 mantissa[0] = -mantissa[0];
508 }
509 if (ps[0] & 0x1000) {
510 mantissa[1] = -mantissa[1];
511 }
512 if (ps[1] & 0x10) {
513 mantissa[2] = -mantissa[2];
514 }
515 if (ps[1] & 0x1000) {
516 mantissa[3] = -mantissa[3];
517 }
518 break;
519
520 case 3:
521 exponent[0] = ( ps[2] & 0xF) - 3;
522 exponent[1] = ((ps[2] >> 4) & 0xF) - 6;
523 exponent[2] = ((ps[2] >> 8) & 0xF) - 6;
524 exponent[3] = ((ps[2] >> 12) & 0xF) - 6;
525
526 mantissa[0] = double( ps[0] & 0x7F) / 0x80;
527 mantissa[1] = double((ps[0] >> 8) & 0x7F) / 0x80;
528 mantissa[2] = double( ps[1] & 0x7F) / 0x80;
529 mantissa[3] = double((ps[1] >> 8) & 0x7F) / 0x80;
530 if (ps[0] & 0x80) {
531 mantissa[0] = -mantissa[0];
532 }
533 if (ps[0] & 0x8000) {
534 mantissa[1] = -mantissa[1];
535 }
536 if (ps[1] & 0x80) {
537 mantissa[2] = -mantissa[2];
538 }
539 if (ps[1] & 0x8000) {
540 mantissa[3] = -mantissa[3];
541 }
542 break;
543
544 case 4:
545 exponent[0] = ((ps[0] >> 11) & 0x1F) - 5;
546 exponent[1] = ((ps[1] >> 11) & 0x1F) - 7;
547 exponent[2] = ((ps[2] >> 11) & 0x1F) - 7;
548 exponent[3] = ((ps[3] >> 11) & 0x1F) - 7;
549
550 mantissa[0] = double(ps[0] & 0x3FF) / 0x400;
551 mantissa[1] = double(ps[1] & 0x3FF) / 0x400;
552 mantissa[2] = double(ps[2] & 0x3FF) / 0x400;
553 mantissa[3] = double(ps[3] & 0x3FF) / 0x400;
554 if (ps[0] & 0x400) {
555 mantissa[0] = -mantissa[0];
556 }
557 if (ps[1] & 0x400) {
558 mantissa[1] = -mantissa[1];
559 }
560 if (ps[2] & 0x400) {
561 mantissa[2] = -mantissa[2];
562 }
563 if (ps[3] & 0x400) {
564 mantissa[3] = -mantissa[3];
565 }
566 break;
567
568 case 8:
569 default:
570 if (ps.size() < 8) {
571 msg << MSG::WARNING
572 << "Bad signal state size " << ps.size()
573 << " in SignalStateCnv::decompress; returning default momentum."
574 << endmsg;
575 return momRaw;
576 }
577
578 momRaw.m_px = SignalStateCnv_detail::floatFromShorts(ps[0], ps[1]);
579 momRaw.m_py = SignalStateCnv_detail::floatFromShorts(ps[2], ps[3]);
580 momRaw.m_pz = SignalStateCnv_detail::floatFromShorts(ps[4], ps[5]);
581 momRaw.m_m = SignalStateCnv_detail::floatFromShorts(ps[6], ps[7]);
582
583 msg << MSG::VERBOSE << " RS x : " << momRaw.m_px
584 << " = " << ps[0] << " = " << ps[1] << endmsg;
585 msg << MSG::VERBOSE << " RS y : " << momRaw.m_py
586 << " = " << ps[2] << " = " << ps[3] << endmsg;
587 msg << MSG::VERBOSE << " RS z : " << momRaw.m_pz
588 << " = " << ps[4] << " = " << ps[5] << endmsg;
589 msg << MSG::VERBOSE << " RS m : " << momRaw.m_m
590 << " = " << ps[6] << " = " << ps[7] << endmsg;
591 break;
592 }
593
594 if (ps.size() < 8) {
595 double delta0 = std::ldexp(mantissa[0], exponent[0]);
596 double delta1 = std::ldexp(mantissa[1], exponent[1]);
597 double delta2 = std::ldexp(mantissa[2], exponent[2]);
598 double delta3 = std::ldexp(mantissa[3], exponent[3]);
599
600 if ((delta0 == -1) || (delta3 == -1)) {
601 msg << MSG::WARNING
602 << "A jet was badly decompressed. Returning null to avoid fpe in SignalStateCnv::decompress "
603 << endmsg;
604 return momRaw;
605 }
606
607 msg << MSG::VERBOSE << " RS 0 : " << delta0 << " = " << mantissa[0] << " = " << exponent[0] << endmsg;
608 msg << MSG::VERBOSE << " RS 1 : " << delta1 << " = " << mantissa[1] << " = " << exponent[1] << endmsg;
609 msg << MSG::VERBOSE << " RS 2 : " << delta2 << " = " << mantissa[2] << " = " << exponent[2] << endmsg;
610 msg << MSG::VERBOSE << " RS 3 : " << delta3 << " = " << mantissa[3] << " = " << exponent[3] << endmsg;
611
612 double angleC = std::atan2(momCal.m_py, momCal.m_px);
613 double p_traC = std::sqrt(momCal.m_px * momCal.m_px + momCal.m_py * momCal.m_py);
614
615 double angleR = angleC - delta1;
616 double eta_R = momCal.eta() - delta2;
617 double p_traR = p_traC / (delta3 + 1);
618 momRaw.m_m = momCal.m_m / (delta0 + 1);
619 momRaw.m_px = p_traR * std::cos(angleR);
620 momRaw.m_py = p_traR * std::sin(angleR);
621 momRaw.m_pz = p_traR * std::sinh(eta_R);
622 }
623
624 msg << MSG::VERBOSE << " RS # ps : " << ps.size() << " : ";
625 for (JetConverterTypes::signalState_pers_t::const_iterator it = ps.begin(); it != ps.end(); ++it) {
626 msg << std::hex << *it << " ";
627 }
628 msg << std::dec << endmsg;
629 msg << MSG::VERBOSE << " RS x : " << momRaw.m_px << endmsg;
630 msg << MSG::VERBOSE << " RS y : " << momRaw.m_py << endmsg;
631 msg << MSG::VERBOSE << " RS z : " << momRaw.m_pz << endmsg;
632 msg << MSG::VERBOSE << " RS m : " << momRaw.m_m << endmsg;
633
634 return momRaw;
635 }
SignalStateCnv_detail::floatFromShorts
float floatFromShorts(std::uint16_t lo, std::uint16_t hi)
Definition JetSignalStateCnv.h:58

◆ ratio_from_char()

double SignalStateCnv::ratio_from_char ( char c) const
inline

Definition at line 119 of file JetSignalStateCnv.h.

119 {
120 const auto uc = static_cast<unsigned char>(c);
121 const bool isneg = uc & 0x80u;
122 const int val = uc & 0x7fu;
123
124 if (isneg) {
125 return m_center - val * m_step_m;
126 }
127 return m_center + val * m_step_p;
128 }
Pythia8_RapidityOrderMPI.val
val
Definition Pythia8_RapidityOrderMPI.py:14

◆ round()

char SignalStateCnv::round ( double d) const
inline

Definition at line 97 of file JetSignalStateCnv.h.

97 {
98 return static_cast<char>(std::floor(d + 0.5));
99 }

Member Data Documentation

◆ m_center

double SignalStateCnv::m_center

Definition at line 94 of file JetSignalStateCnv.h.

◆ m_delta_m

double SignalStateCnv::m_delta_m

Definition at line 92 of file JetSignalStateCnv.h.

◆ m_delta_p

double SignalStateCnv::m_delta_p

Definition at line 90 of file JetSignalStateCnv.h.

◆ m_step_m

double SignalStateCnv::m_step_m

Definition at line 93 of file JetSignalStateCnv.h.

◆ m_step_p

double SignalStateCnv::m_step_p

Definition at line 91 of file JetSignalStateCnv.h.

The documentation for this class was generated from the following file:
Generated on for ATLAS Offline Software by doxygen 1.16.1