ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
MMT_Diamond Class Reference

#include <MMT_Diamond.h>

Inheritance diagram for MMT_Diamond:
Collaboration diagram for MMT_Diamond:

Public Member Functions

 MMT_Diamond (const int diamXthreshold, const bool uv, const int diamUVthreshold, const int roadSize, const int olapEtaUp, const int olapEtaDown, const int olapStereoUp, const int olapStereoDown)
 
 ~MMT_Diamond ()=default
 
void createRoads (std::vector< std::shared_ptr< MMT_Road > > &roads, const bool isLarge) const
 
void findDiamonds (std::vector< std::shared_ptr< MMT_Hit > > &hits, const std::vector< std::shared_ptr< MMT_Road > > &roads, std::vector< slope_t > &diamondSlopes, const int sectorPhi) const
 
double phiShift (const int n, const double phi, const char side) const
 
int getRoadSize () const
 
unsigned int getXthreshold () const
 
unsigned int getUVthreshold () const
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Private Member Functions

void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

bool m_uvflag {}
 
int m_roadSize {}
 
int m_roadSizeUpX {}
 
int m_roadSizeDownX {}
 
int m_roadSizeUpUV {}
 
int m_roadSizeDownUV {}
 
int m_xthr {}
 
int m_uvthr {}
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 40 of file MMT_Diamond.h.

Constructor & Destructor Documentation

◆ MMT_Diamond()

MMT_Diamond::MMT_Diamond ( const int  diamXthreshold,
const bool  uv,
const int  diamUVthreshold,
const int  roadSize,
const int  olapEtaUp,
const int  olapEtaDown,
const int  olapStereoUp,
const int  olapStereoDown 
)

Definition at line 18 of file MMT_Diamond.cxx.

19  : AthMessaging(Athena::getMessageSvc(), "MMT_Diamond") {
20  m_xthr = diamXthreshold;
21  m_uvthr = diamUVthreshold;
22  m_uvflag = uv;
23  m_roadSize = roadSize;
24  m_roadSizeUpX = olapEtaUp;
25  m_roadSizeDownX = olapEtaDown;
26  m_roadSizeUpUV = olapStereoUp;
27  m_roadSizeDownUV = olapStereoDown;
28 }

◆ ~MMT_Diamond()

MMT_Diamond::~MMT_Diamond ( )
default

Member Function Documentation

◆ createRoads()

void MMT_Diamond::createRoads ( std::vector< std::shared_ptr< MMT_Road > > &  roads,
const bool  isLarge 
) const

Definition at line 30 of file MMT_Diamond.cxx.

30  {
31  const char sec = (isLarge) ? 'L' : 'S';
32  /*
33  * This computation is done as follows: 1024 X roads
34  * MML: for i in [0,8] -> i*6 UV roads. Then: (1024-9)*6*9 UV roads
35  * MMS: for i in [0,6] -> i*6 UV roads. Then: (1024-7)*6*7 UV roads
36  */
37  const unsigned int vecRoads = (isLarge) ? 56050 : 43864;
38  roads.reserve(vecRoads);
39  int nroad = 8192/this->getRoadSize();
40  for (int i = 0; i < nroad; ++i) {
41  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i));
42 
43  /*
44  * The computation of "nuv" is:
45  * B = (1./std::tan(1.5/180.*M_PI));
46  * nuv = std::round( par->getlWidth() / (B * 0.4 * 2.)/this->getRoadSize() );
47  * As getlWidth() has to deal with the full wedge, only two (fixed by construction) integer values are allowed, according to small (7) or large (9) wedge
48  */
49  if(m_uvflag) {
50  const int nuv = (isLarge) ? 9 : 7;
51  for (int uv = 1; uv <= nuv; uv++) {
52  if (i-uv < 0) continue;
53 
54  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i+uv, i-uv));
55  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i-uv, i+uv));
56  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i+uv-1, i-uv));
57  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i-uv, i+uv-1));
58  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i-uv+1, i+uv));
59  roads.emplace_back(std::make_shared<MMT_Road>(sec, m_roadSize, m_roadSizeUpX, m_roadSizeDownX, m_roadSizeUpUV, m_roadSizeDownUV, m_xthr, m_uvthr, i, i+uv, i-uv+1));
60  }
61  }
62  }
63 }

◆ findDiamonds()

void MMT_Diamond::findDiamonds ( std::vector< std::shared_ptr< MMT_Hit > > &  hits,
const std::vector< std::shared_ptr< MMT_Road > > &  roads,
std::vector< slope_t > &  diamondSlopes,
const int  sectorPhi 
) const

Definition at line 65 of file MMT_Diamond.cxx.

65  {
66 
67  // Comparison with lambda function (easier to implement)
68  std::sort(hits.begin(), hits.end(), [](const auto &h1, const auto &h2){ return h1->getBC() < h2->getBC(); });
69  const int bc_start = hits.front()->getBC();
70  const int bc_end = hits.front()->getBC() + 16;
71  ATH_MSG_DEBUG("Window Start: " << bc_start << " - Window End: " << bc_end);
72 
73  std::vector<std::shared_ptr<MMT_Hit> > hits_now;
74  std::vector< std::pair<int, float> > vmm_same;
75  std::vector< std::pair<int, int> > addc_same;
76  std::vector<int> to_erase;
77 
78  // each road makes independent triggers, evaluated on each BC
79  unsigned int ibc = 0;
80  for (int bc = hits.front()->getBC(); bc < bc_end; bc++) {
81  // Cleaning stuff
82  hits_now.clear();
83 
84  for (unsigned int j = ibc; j < hits.size(); j++) {
85  if (hits[j]->getBC() == bc) hits_now.push_back(hits[j]);
86  else if (hits[j]->getBC() > bc) {
87  ibc = j;
88  break;
89  }
90  }
91 
92  // Simulate harware filters: ART hits + ADDC filter
93  for (unsigned int ib = 0; ib < 8; ib++) { //loop on plane from 0 to 7
94  // VMM-ART-hit filter
95  for (int j = 0; j < n_vmm; j++) {
96  vmm_same.clear();
97  unsigned int k = 0;
98  for (const auto &hit_pointer: hits_now) {
99  if (static_cast<unsigned int>(hit_pointer->getPlane()) != ib) continue;
100  if (hit_pointer->getVMM() == j){
101  vmm_same.push_back( std::make_pair(k, hit_pointer->getTime()) );
102  }
103  k++;
104  }
105  if (vmm_same.size() > 1) {
106  to_erase.clear();
107  std::sort(vmm_same.begin(), vmm_same.end(), [](const std::pair<int, float>& p1, const std::pair<int, float>& p2) { return p1.second < p2.second; });
108  for (auto pair: vmm_same) to_erase.push_back(pair.first);
109  // reverse and erase
110  std::sort(to_erase.rbegin(), to_erase.rend());
111  to_erase.pop_back(); //removes the hit with the earliest time
112  for (auto l : to_erase) {
113  hits_now.erase(hits_now.begin() + l);
114  }
115  }
116  }
117  // ADDC-like filter
118  for (int ia = 0; ia < n_addc; ia++) { // From 0 to 3 (local index of the ART ASIC in the layer)
119  addc_same.clear();
120  for (unsigned int k = 0; k < hits_now.size(); k++) {
121  if ((unsigned int)(hits_now[k]->getPlane()) != ib) continue;
122  int istrip = (std::abs(hits_now[k]->getStationEta())-1) * (64*8*10) + hits_now[k]->getChannel(); //needed the global strip index on the sector layer (getChannel returns chamber's local strip index)
123  if (hits_now[k]->getART() == ia) addc_same.emplace_back(k, istrip);
124  }
125 
126  if (addc_same.size() > 8) {
127  // priority encode the hits by channel number; remember hits 8+
128  to_erase.clear();
129 
130  std::sort(addc_same.begin(), addc_same.end(), [](const std::pair<int, int>& p1, const std::pair<int, int>& p2) { return p1.second < p2.second; });
131  for (unsigned int it = 8; it < addc_same.size(); it++) to_erase.push_back(addc_same[it].first);
132 
133  // reverse and erase
134  std::sort(to_erase.rbegin(), to_erase.rend());
135  for (auto l : to_erase) {
136  hits_now.erase(hits_now.begin() + l);
137  }
138  }
139  }
140  } // loop on plane for VMM and ART ASIC filter
141 
142  for (auto &road : roads) {
143  road->incrementAge(bc_wind);
144  if (!hits_now.empty()) road->addHits(hits_now);
145 
146  if (road->checkCoincidences(bc_wind) && bc >= (bc_start - 1)) {
147 
148  ATH_MSG_DEBUG("------------------------------------------------------------------");
149  ATH_MSG_DEBUG("Coincidence FOUND @BC: " << bc);
150  ATH_MSG_DEBUG("Road (x, u, v, count): (" << road->iRoadx() << ", " << road->iRoadu() << ", " << road->iRoadv() << ", " << road->countHits() << ")");
151  ATH_MSG_DEBUG("------------------------------------------------------------------");
152 
153  std::vector<int> bcidVec;
154  for (const auto &hit: road->getHitVector()) {
155  bcidVec.push_back(hit->getBC());
156  }
157  std::sort(bcidVec.begin(), bcidVec.end());
158 
159  // evaluating mode of the BCID of the hits in the diamond
160  // default setting in the firmware is the mode of the hits's bcid in the diamond
161  int bcidVal=bcidVec[0], bcidCount=1, modeCount=1, bcidMode=bcidVec[0];
162  for (unsigned int i=1; i<bcidVec.size(); i++){
163  if (bcidVec[i] == bcidVal){
164  bcidCount++;
165  } else {
166  bcidCount = 1;
167  bcidVal = bcidVec[i];
168  }
169  if (bcidCount > modeCount) {
170  modeCount = bcidCount;
171  bcidMode = bcidVal;
172  }
173  }
174 
175  slope_t slope;
176  slope.BC = bcidMode;
177  slope.totalCount = road->countHits();
178  slope.realCount = road->countRealHits();
179  slope.iRoad = road->iRoadx();
180  slope.iRoadu = road->iRoadu();
181  slope.iRoadv = road->iRoadv();
182  slope.uvbkg = road->countUVHits(true); // the bool in the following 4 functions refers to background/noise hits
183  slope.xbkg = road->countXHits(true);
184  slope.uvmuon = road->countUVHits(false);
185  slope.xmuon = road->countXHits(false);
186  slope.age = slope.BC - bc_start;
187  slope.mxl = road->mxl();
188  slope.my = road->avgSofX(); // defined as my in ATL-COM-UPGRADE-2015-033
189  slope.uavg = road->avgSofUV(2,4);
190  slope.vavg = road->avgSofUV(3,5);
191  slope.mx = (slope.uavg-slope.vavg)/(2.*tan_stereo_angle);
192  const double theta = std::atan(std::sqrt(std::pow(slope.mx,2) + std::pow(slope.my,2)));
193  slope.theta = (slope.my > 0.) ? theta : M_PI - theta;
194  slope.eta = -1.*std::log(std::tan(slope.theta/2.));
195  slope.dtheta = (slope.mxl - slope.my)/(1. + slope.mxl*slope.my);
196  slope.side = (slope.my > 0.) ? 'A' : 'C';
197  slope.phi = std::atan(slope.mx/slope.my);
198  slope.phiShf = phiShift(sectorPhi, slope.phi, slope.side);
199  slope.lowRes = road->evaluateLowRes();
200 
201  diamondSlopes.push_back(slope);
202  }
203  }
204  }
205 }

◆ getRoadSize()

int MMT_Diamond::getRoadSize ( ) const
inline

Definition at line 50 of file MMT_Diamond.h.

50 { return m_roadSize; }

◆ getUVthreshold()

unsigned int MMT_Diamond::getUVthreshold ( ) const
inline

Definition at line 52 of file MMT_Diamond.h.

52 { return m_uvthr; }

◆ getXthreshold()

unsigned int MMT_Diamond::getXthreshold ( ) const
inline

Definition at line 51 of file MMT_Diamond.h.

51 { return m_xthr; }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
41  m_imsg = Athena::getMessageSvc();
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ phiShift()

double MMT_Diamond::phiShift ( const int  n,
const double  phi,
const char  side 
) const

Definition at line 207 of file MMT_Diamond.cxx.

207  {
208  double Phi = (side == 'A') ? -phi : phi;
209  double shift = (n > 8) ? (16-n)*M_PI/8. : n*M_PI/8.;
210  if (n < 8) return (Phi + shift);
211  else if (n == 8) return (Phi + ((Phi > 0.) ? -1. : 1.)*shift);
212  else return (Phi - shift);
213 }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_roadSize

int MMT_Diamond::m_roadSize {}
private

Definition at line 56 of file MMT_Diamond.h.

◆ m_roadSizeDownUV

int MMT_Diamond::m_roadSizeDownUV {}
private

Definition at line 56 of file MMT_Diamond.h.

◆ m_roadSizeDownX

int MMT_Diamond::m_roadSizeDownX {}
private

Definition at line 56 of file MMT_Diamond.h.

◆ m_roadSizeUpUV

int MMT_Diamond::m_roadSizeUpUV {}
private

Definition at line 56 of file MMT_Diamond.h.

◆ m_roadSizeUpX

int MMT_Diamond::m_roadSizeUpX {}
private

Definition at line 56 of file MMT_Diamond.h.

◆ m_uvflag

bool MMT_Diamond::m_uvflag {}
private

Definition at line 55 of file MMT_Diamond.h.

◆ m_uvthr

int MMT_Diamond::m_uvthr {}
private

Definition at line 57 of file MMT_Diamond.h.

◆ m_xthr

int MMT_Diamond::m_xthr {}
private

Definition at line 57 of file MMT_Diamond.h.

The documentation for this class was generated from the following files:
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
slope_t::eta
double eta
Definition: MMT_Diamond.h:32
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
slope_t::BC
int BC
Definition: MMT_Diamond.h:15
MMT_Diamond::getRoadSize
int getRoadSize() const
Definition: MMT_Diamond.h:50
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
slope_t::uavg
double uavg
Definition: MMT_Diamond.h:28
slope_t::my
double my
Definition: MMT_Diamond.h:27
slope_t::xmuon
unsigned int xmuon
Definition: MMT_Diamond.h:24
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
skel.it
it
Definition: skel.GENtoEVGEN.py:407
M_PI
#define M_PI
Definition: ActiveFraction.h:11
PlotCalibFromCool.ib
ib
Definition: PlotCalibFromCool.py:419
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
slope_t::iRoadu
int iRoadu
Definition: MMT_Diamond.h:19
Phi
@ Phi
Definition: RPCdef.h:8
MMT_Diamond::m_uvthr
int m_uvthr
Definition: MMT_Diamond.h:57
slope_t::totalCount
unsigned int totalCount
Definition: MMT_Diamond.h:16
read_hist_ntuple.h1
h1
Definition: read_hist_ntuple.py:21
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
slope_t::vavg
double vavg
Definition: MMT_Diamond.h:29
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
MMT_Diamond::phiShift
double phiShift(const int n, const double phi, const char side) const
Definition: MMT_Diamond.cxx:207
TRT::Hit::side
@ side
Definition: HitInfo.h:83
slope_t::side
char side
Definition: MMT_Diamond.h:36
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
MMT_Diamond::m_roadSizeDownX
int m_roadSizeDownX
Definition: MMT_Diamond.h:56
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
slope_t::dtheta
double dtheta
Definition: MMT_Diamond.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
MMT_Diamond::m_roadSizeUpUV
int m_roadSizeUpUV
Definition: MMT_Diamond.h:56
beamspotman.n
n
Definition: beamspotman.py:729
slope_t::phiShf
double phiShf
Definition: MMT_Diamond.h:35
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
slope_t::theta
double theta
Definition: MMT_Diamond.h:31
slope_t::mx
double mx
Definition: MMT_Diamond.h:30
MMT_Diamond::m_roadSize
int m_roadSize
Definition: MMT_Diamond.h:56
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
slope_t::iRoad
int iRoad
Definition: MMT_Diamond.h:18
slope_t::iRoadv
int iRoadv
Definition: MMT_Diamond.h:20
MMT_Diamond::m_roadSizeUpX
int m_roadSizeUpX
Definition: MMT_Diamond.h:56
MMT_Diamond::m_uvflag
bool m_uvflag
Definition: MMT_Diamond.h:55
MMT_Diamond::m_xthr
int m_xthr
Definition: MMT_Diamond.h:57
slope_t::age
int age
Definition: MMT_Diamond.h:25
slope_t::realCount
unsigned int realCount
Definition: MMT_Diamond.h:17
MMT_Diamond::m_roadSizeDownUV
int m_roadSizeDownUV
Definition: MMT_Diamond.h:56
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
slope_t::lowRes
bool lowRes
Definition: MMT_Diamond.h:37
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
slope_t::phi
double phi
Definition: MMT_Diamond.h:34
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
slope_t::mxl
double mxl
Definition: MMT_Diamond.h:26
slope_t::xbkg
unsigned int xbkg
Definition: MMT_Diamond.h:22
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
slope_t
Definition: MMT_Diamond.h:13
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
slope_t::uvbkg
unsigned int uvbkg
Definition: MMT_Diamond.h:21
fitman.k
k
Definition: fitman.py:528
slope_t::uvmuon
unsigned int uvmuon
Definition: MMT_Diamond.h:23
python.SystemOfUnits.ms
float ms
Definition: SystemOfUnits.py:148
Generated on Mon Sep 1 2025 21:42:10 for ATLAS Offline Software by   doxygen 1.8.18