ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
TrigConf::JsonFileWriterL1 Class Reference

Loader of trigger configurations from Json files. More...

#include <JsonFileWriterL1.h>

Inheritance diagram for TrigConf::JsonFileWriterL1:
Collaboration diagram for TrigConf::JsonFileWriterL1:

Public Member Functions

 JsonFileWriterL1 ()
 Constructor. More...
 
virtual ~JsonFileWriterL1 () override=default
 Destructor. More...
 
bool writeJsonFile (const std::string &filename, const L1Menu &l1menu) const
 
bool writeJsonFile (const std::string &filename, const L1BunchGroupSet &l1bgs) const
 
bool writeJsonFile (const std::string &filename, const L1PrescalesSet &l1bgs) const
 
bool msgLvl (const MSGTC::Level lvl) const
 Test the output level. More...
 
MsgStreamTC & msg () const
 The standard message stream. More...
 
MsgStreamTC & msg (const MSGTC::Level lvl) const
 The standard message stream. More...
 

Private Attributes

boost::thread_specific_ptr< MsgStreamTC > m_msg_tls
 MsgStreamTC instance (a std::cout like with print-out levels) More...
 
std::string m_name
 

Detailed Description

Loader of trigger configurations from Json files.

Definition at line 23 of file JsonFileWriterL1.h.

Constructor & Destructor Documentation

◆ JsonFileWriterL1()

TrigConf::JsonFileWriterL1::JsonFileWriterL1 ( )

Constructor.

Definition at line 15 of file JsonFileWriterL1.cxx.

15  :
16  TrigConfMessaging( "JsonFileWriterL1")
17 {}

◆ ~JsonFileWriterL1()

virtual TrigConf::JsonFileWriterL1::~JsonFileWriterL1 ( )
overridevirtualdefault

Destructor.

Member Function Documentation

◆ msg() [1/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( ) const
inlineinherited

The standard message stream.

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

Definition at line 81 of file TrigConfMessaging.h.

82  {
83  MsgStreamTC* ms = m_msg_tls.get();
84  if (!ms) {
85  ms = new MsgStreamTC(m_name);
86  m_msg_tls.reset(ms);
87  }
88  return *ms;
89  }

◆ msg() [2/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( const MSGTC::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 91 of file TrigConfMessaging.h.

92  {
93  return msg() << lvl;
94  }

◆ msgLvl()

bool TrigConf::TrigConfMessaging::msgLvl ( const MSGTC::Level  lvl) const
inlineinherited

Test the output level.

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

Definition at line 70 of file TrigConfMessaging.h.

71  {
72  if (msg().level() <= lvl) {
73  msg() << lvl;
74  return true;
75  }
76  else {
77  return false;
78  }
79  }

◆ writeJsonFile() [1/3]

bool TrigConf::JsonFileWriterL1::writeJsonFile ( const std::string &  filename,
const L1BunchGroupSet &  l1bgs 
) const

Definition at line 853 of file JsonFileWriterL1.cxx.

853  {
854 
855  json j;
856  j["filetype"] = "bunchgroupset";
857  j["name"] = l1bgs.name();
858 
859  json groups;
860  for (size_t i = 0 ; i< l1bgs.size(); ++i) {
861  const auto & group = l1bgs.getBunchGroup(i);
862  json jgroup({});
863  jgroup["name"] = group->name();
864  jgroup["id"] = group->id();
865  jgroup["info"] = std::to_string(group->size()) + " bunches, " + std::to_string(group->nGroups()) + " groups";
866  json trains = json::array();
867  for (auto [first, len]: group->trains()) {
868  json train({});
869  train["first"] = first;
870  train["length"] = len;
871  trains.push_back(train);
872  }
873  jgroup["bcids"] = trains;
874  groups["BGRP"+std::to_string(group->id())] = jgroup;
875  }
876  j["bunchGroups"] = groups;
877  std::ofstream outfile(filename);
878  outfile << std::setw(4) << j << std::endl;
879  TRG_MSG_INFO("Saved file " << filename);
880  return true;
881 }

◆ writeJsonFile() [2/3]

bool TrigConf::JsonFileWriterL1::writeJsonFile ( const std::string &  filename,
const L1Menu &  l1menu 
) const

Definition at line 21 of file JsonFileWriterL1.cxx.

22 {
23 
24  json items = json::object_t{};
25  for( auto & item : l1menu ) {
26  json jItem({});
27  jItem["name"] = item.name();
28  jItem["ctpid"] = item.ctpId();
29  jItem["definition"] = item.definition();
30  jItem["monitor"] = item.monitor();
31  jItem["partition"] = item.partition();
32  jItem["triggerType"] = item.triggerType();
33  jItem["bunchgroups"] = json(item.bunchgroups());
34  if(auto legacy = item.legacy() )
35  jItem["legacy"] = *legacy;
36  items[item.name()] = jItem;
37  };
38 
39  json thresholds = json::object_t{};
40  for(const std::string & thrType : l1menu.thresholdTypes()) {
41  json jThresholsByType({});
42  // first the thresholds of this type
43  for(auto & thr : l1menu.thresholds(thrType)) {
44  json jThr({});
45  jThr["mapping"] = thr->mapping();
46 
47  if(thr->hasChild("sectors")) { // for MBTS_A and MBTS_C
48  std::vector<std::string> sectors;
49  for(auto & s : thr->getList("sectors")) {
50  sectors.push_back(s.getValue());
51  }
52  jThr["sectors"] = sectors;
53  }
54  if(thr->hasAttribute("voltage")) { // for MBTSII
55  jThr["voltage"] = thr->getAttribute<float>("voltage");
56  }
57 
58  // value
59  try {
60  if(thr->hasAttribute("value")) {
61  auto & caloThr = dynamic_cast<const TrigConf::L1Threshold_Calo &>(*thr); // for MBTSII
62  jThr["value"] = int(caloThr.thrValue());
63  }
64  } catch(std::bad_cast&) {};
65 
66  // MU
67  try {
68  const auto & muThr = dynamic_cast<const TrigConf::L1Threshold_MU &>(*thr);
69  jThr["baThr"] = muThr.ptBarrel();
70  jThr["ecThr"] = muThr.ptEndcap();
71  jThr["fwThr"] = muThr.ptForward();
72  jThr["baIdx"] = muThr.idxBarrel();
73  jThr["ecIdx"] = muThr.idxEndcap();
74  jThr["fwIdx"] = muThr.idxForward();
75  jThr["region"] = muThr.region();
76  jThr["tgcFlags"] = muThr.tgcFlags();
77  jThr["rpcFlags"] = muThr.rpcFlags();
78  if(const std::string & roiExcl = muThr.rpcExclROIList(); !roiExcl.empty()) {
79  jThr["rpcExclROIList"] = roiExcl;
80  }
81  } catch(std::bad_cast&) {};
82 
83  // TAU
84  try {
85  const auto & tauThr = dynamic_cast<const TrigConf::L1Threshold_TAU &>(*thr);
86  std::string isobits = "00000";
87  auto isomask = tauThr.isolationMask();
88  for(size_t b=0; b<5; ++b) {
89  if(isomask & (1<<b)) { isobits[4-b] = '1'; }
90  }
91  jThr["isobits"] = isobits;
92  jThr["thrValues"] = json::array_t({});
93  for(auto & rv : tauThr.thrValues()) {
94  json jRV({});
95  jRV["value"] = static_cast<unsigned int>(rv.value());
96  jRV["etamin"] = rv.etaMin();
97  jRV["etamax"] = rv.etaMax();
98  jRV["phimin"] = 0; // never used, so not read
99  jRV["phimax"] = 64; // never used, so not read
100  jRV["priority"] = rv.priority();
101  jThr["thrValues"] += jRV;
102  }
103  } catch(std::bad_cast&) {};
104 
105  // EM
106  try {
107  const auto & EMThr = dynamic_cast<const TrigConf::L1Threshold_EM &>(*thr);
108  jThr["thrValues"] = json::array_t({});
109  for(auto & rv : EMThr.thrValues()) {
110  json jRV({});
111  jRV["value"] = static_cast<unsigned int>(rv.value());
112  jRV["etamin"] = rv.etaMin();
113  jRV["etamax"] = rv.etaMax();
114  jRV["phimin"] = 0; // never used, so not read
115  jRV["phimax"] = 64; // never used, so not read
116  std::string isobits = "00000";
117  auto isomask = EMThr.isolationMask(rv.etaMin());
118  for(size_t b=0; b<5; ++b) {
119  if(isomask & (1<<b)) { isobits[4-b] = '1'; }
120  }
121  jRV["isobits"] = isobits;
122  jRV["priority"] = rv.priority();
123  jThr["thrValues"] += jRV;
124  }
125  } catch(std::bad_cast&) {};
126 
127  // JET
128  try {
129  const auto & JThr = dynamic_cast<const TrigConf::L1Threshold_JET &>(*thr);
130  jThr["thrValues"] = json::array_t({});
131  for(auto & rv : JThr.thrValues()) {
132  json jRV({});
133  jRV["value"] = static_cast<unsigned int>(rv.value());
134  jRV["etamin"] = rv.etaMin();
135  jRV["etamax"] = rv.etaMax();
136  jRV["phimin"] = 0; // never used, so not read
137  jRV["phimax"] = 64; // never used, so not read
138  jRV["window"] = JThr.window(0);
139  jRV["priority"] = rv.priority();
140  jThr["thrValues"] += jRV;
141  }
142  } catch(std::bad_cast&) {};
143 
144  // TE
145  try {
146  const auto & teThr = dynamic_cast<const TrigConf::L1Threshold_TE &>(*thr);
147  //jThr["thrValues"] = json::array_t({});
148  for(auto & rv : teThr.thrValues()) {
149  json jRV({});
150  jRV["value"] = static_cast<unsigned int>(rv.value());
151  jRV["etamin"] = rv.etaMin();
152  jRV["etamax"] = rv.etaMax();
153  jRV["priority"] = rv.priority();
154  jThr["thrValues"] += jRV;
155  }
156  } catch(std::bad_cast&) {};
157 
158  // ZB
159  try {
160  const auto & zbThr = dynamic_cast<const TrigConf::L1Threshold_ZB &>(*thr);
161  jThr["seed"] = zbThr.seed();
162  jThr["seedBcdelay"] = zbThr.seedBcdelay();
163  jThr["seedMultiplicity"] = zbThr.seedMultiplicity();
164  } catch(std::bad_cast&) {};
165 
166  // ZBTopo
167  try {
168  const auto & zbTopoThr = dynamic_cast<const TrigConf::L1Threshold_ZBTopo &>(*thr);
169  jThr["mask0"] = zbTopoThr.mask0();
170  jThr["mask0"] = zbTopoThr.mask0();
171  jThr["mask0"] = zbTopoThr.mask0();
172  jThr["mask0"] = zbTopoThr.mask0();
173  jThr["mask0"] = zbTopoThr.mask0();
174  jThr["mask0"] = zbTopoThr.mask0();
175  jThr["seedBcdelay"] = zbTopoThr.seedBcdelay();
176 
177  } catch(std::bad_cast&) {};
178 
179  // eEM
180  try {
181  const auto & eEMThr = dynamic_cast<const TrigConf::L1Threshold_eEM &>(*thr);
182  jThr["reta"] = TrigConf::Selection::wpToString(eEMThr.reta());
183  jThr["rhad"] = TrigConf::Selection::wpToString(eEMThr.rhad());
184  jThr["wstot"] = TrigConf::Selection::wpToString(eEMThr.wstot());
185  jThr["thrValues"] = json::value_t::array;
186  for(auto & rv : eEMThr.thrValues()) {
187  json jRV({});
188  jRV["value"] = static_cast<unsigned int>(rv.value());
189  jRV["etamin"] = rv.etaMin();
190  jRV["etamax"] = rv.etaMax();
191  jRV["priority"] = rv.priority();
192  jThr["thrValues"] += jRV;
193  }
194  } catch(std::bad_cast&) {};
195 
196  // jEM
197  try {
198  const auto & jEMThr = dynamic_cast<const TrigConf::L1Threshold_jEM &>(*thr);
199  jThr["iso"] = TrigConf::Selection::wpToString(jEMThr.iso());
200  jThr["frac"] = TrigConf::Selection::wpToString(jEMThr.frac());
201  jThr["frac2"] = TrigConf::Selection::wpToString(jEMThr.frac2());
202  jThr["thrValues"] = json::value_t::array;
203  for(auto & rv : jEMThr.thrValues()) {
204  json jRV({});
205  jRV["value"] = static_cast<unsigned int>(rv.value());
206  jRV["etamin"] = rv.etaMin();
207  jRV["etamax"] = rv.etaMax();
208  jRV["priority"] = rv.priority();
209  jThr["thrValues"] += jRV;
210  }
211  } catch(std::bad_cast&) {};
212 
213  // eTAU
214  try {
215  const auto & eTAUThr = dynamic_cast<const TrigConf::L1Threshold_eTAU &>(*thr);
216  jThr["rCore"] = TrigConf::Selection::wpToString(eTAUThr.rCore());
217  jThr["rHad"] = TrigConf::Selection::wpToString(eTAUThr.rHad());
218  jThr["thrValues"] = json::array_t({});
219  for(auto & rv : eTAUThr.thrValues()) {
220  json jRV({});
221  jRV["value"] = static_cast<unsigned int>(rv.value());
222  jRV["etamin"] = rv.etaMin();
223  jRV["etamax"] = rv.etaMax();
224  jRV["phimin"] = 0; // never used, so not read
225  jRV["phimax"] = 64; // never used, so not read
226  jRV["priority"] = rv.priority();
227  jThr["thrValues"] += jRV;
228  }
229  } catch(std::bad_cast&) {};
230 
231  // jTAU
232  try {
233  const auto & jTAUThr = dynamic_cast<const TrigConf::L1Threshold_jTAU &>(*thr);
234  jThr["isolation"] = TrigConf::Selection::wpToString(jTAUThr.isolation());
235  jThr["thrValues"] = json::array_t({});
236  for(auto & rv : jTAUThr.thrValues()) {
237  json jRV({});
238  jRV["value"] = static_cast<unsigned int>(rv.value());
239  jRV["etamin"] = rv.etaMin();
240  jRV["etamax"] = rv.etaMax();
241  jRV["phimin"] = 0; // never used, so not read
242  jRV["phimax"] = 64; // never used, so not read
243  jRV["priority"] = rv.priority();
244  jThr["thrValues"] += jRV;
245  }
246  } catch(std::bad_cast&) {};
247 
248  // cTAU
249  try {
250  const auto & cTAUThr = dynamic_cast<const TrigConf::L1Threshold_cTAU &>(*thr);
251  jThr["isolation"] = TrigConf::Selection::wpToString(cTAUThr.isolation());
252  jThr["thrValues"] = json::array_t({});
253  for(auto & rv : cTAUThr.thrValues()) {
254  json jRV({});
255  jRV["value"] = static_cast<unsigned int>(rv.value());
256  jRV["etamin"] = rv.etaMin();
257  jRV["etamax"] = rv.etaMax();
258  jRV["phimin"] = 0; // never used, so not read
259  jRV["phimax"] = 64; // never used, so not read
260  jRV["priority"] = rv.priority();
261  jThr["thrValues"] += jRV;
262  }
263  } catch(std::bad_cast&) {};
264 
265  // jJ
266  try {
267  const auto & jJThr = dynamic_cast<const TrigConf::L1Threshold_jJ &>(*thr);
268  jThr["thrValues"] = json::array_t({});
269  for(auto & rv : jJThr.thrValues()) {
270  json jRV({});
271  jRV["value"] = static_cast<unsigned int>(rv.value());
272  jRV["etamin"] = rv.etaMin();
273  jRV["etamax"] = rv.etaMax();
274  jRV["priority"] = rv.priority();
275  jThr["thrValues"] += jRV;
276  }
277  } catch(std::bad_cast&) {};
278 
279  // jLJ
280  try {
281  const auto & jLJThr = dynamic_cast<const TrigConf::L1Threshold_jLJ &>(*thr);
282  jThr["thrValues"] = json::array_t({});
283  for(auto & rv : jLJThr.thrValues()) {
284  json jRV({});
285  jRV["value"] = static_cast<unsigned int>(rv.value());
286  jRV["etamin"] = rv.etaMin();
287  jRV["etamax"] = rv.etaMax();
288  jRV["priority"] = rv.priority();
289  jThr["thrValues"] += jRV;
290  }
291  } catch(std::bad_cast&) {};
292 
293  // gJ
294  try {
295  const auto & gJThr = dynamic_cast<const TrigConf::L1Threshold_gJ &>(*thr);
296  jThr["value"] = int(gJThr.thrValue());
297  } catch(std::bad_cast&) {};
298 
299  // gLJ
300  try {
301  const auto & gLJThr = dynamic_cast<const TrigConf::L1Threshold_gLJ &>(*thr);
302  jThr["value"] = int(gLJThr.thrValue());
303  } catch(std::bad_cast&) {};
304 
305  // jXE
306  try {
307  const auto & jXEThr = dynamic_cast<const TrigConf::L1Threshold_jXE &>(*thr);
308  jThr["value"] = int(jXEThr.thrValue());
309  } catch(std::bad_cast&) {};
310 
311  // jTE
312  try {
313  const auto & jTEThr = dynamic_cast<const TrigConf::L1Threshold_jTE &>(*thr);
314  jThr["value"] = int(jTEThr.thrValue());
315  } catch(std::bad_cast&) {};
316 
317  // gXE
318  try {
319  const auto & gXEThr = dynamic_cast<const TrigConf::L1Threshold_gXE &>(*thr);
320  jThr["value"] = int(gXEThr.thrValue());
321  } catch(std::bad_cast&) {};
322 
323  // gTE
324  try {
325  const auto & gTEThr = dynamic_cast<const TrigConf::L1Threshold_gTE &>(*thr);
326  jThr["value"] = int(gTEThr.thrValue());
327  } catch(std::bad_cast&) {};
328 
329  jThresholsByType[thr->name()] = jThr;
330  };
331  json jThrType({});
332  if(thrType != "internal") {
333  jThrType["thresholds"] = jThresholsByType;
334  }
335  jThrType["type"] = thrType;
336 
337  // extra info
338  auto & extraInfo = l1menu.thrExtraInfo().thrExtraInfo(thrType);
339  if(extraInfo.hasAttribute("ptMinToTopo")) { // for MBTSII
340  jThrType["ptMinToTopo"] = extraInfo.getAttribute<unsigned int>("ptMinToTopo");
341  }
342  if(extraInfo.hasAttribute("resolutionMeV")) { // for MBTSII
343  jThrType["resolutionMeV"] = extraInfo.getAttribute<unsigned int>("resolutionMeV");
344  }
345 
346  // extra info using type specific accessors
347  if(thrType == "internal") {
348  jThrType["names"] = json::array_t({});
349  for(auto & thr : l1menu.thresholds(thrType)) {
350  jThrType["names"] += thr->name();
351  }
352  auto & extInfo = l1menu.thrExtraInfo().thrExtraInfo("internal");
353  if(auto randoms = extInfo.getExtraInfo("randoms")) {
354  for(size_t rc=0; rc<4; ++rc) {
355  jThrType["randoms"]["RNDM" + std::to_string(rc)]["cut"] =
356  randoms->get().getAttribute<unsigned int>("RNDM" + std::to_string(rc)+".cut");
357  }
358  }
359  }
360 
361  if(thrType == "MU") {
362  auto & muinfo = l1menu.thrExtraInfo().MU();
363  jThrType["exclusionLists"] = json::value_t::object;
364  for(auto & listName : muinfo.exclusionListNames()) {
365  jThrType["exclusionLists"][listName] = json::array_t({});
366  for(auto & x : muinfo.exclusionList(listName)) {
367  jThrType["exclusionLists"][listName] += json({ {"sectorName", x.first}, {"rois", x.second}});
368  }
369  }
370  for(auto & rpcPt : muinfo.knownRpcPtValues()) {
371  jThrType["roads"]["rpc"][std::to_string(rpcPt)] = muinfo.rpcIdxForPt(rpcPt);
372  }
373  for(auto & tgcPt : muinfo.knownTgcPtValues()) {
374  jThrType["roads"]["tgc"][std::to_string(tgcPt)] = muinfo.tgcIdxForPt(tgcPt);
375  }
376  }
377 
378  if(thrType == "EM" && l1menu.run()>1) {
379  auto & eminfo = l1menu.thrExtraInfo().EM();
380  for(const std::string isoSet : { "EMIsoForEMthr", "HAIsoForEMthr" }) {
381  jThrType["isolation"][isoSet]["thrtype"] = isoSet;
382  jThrType["isolation"][isoSet]["Parametrization"] = json::array_t({});
383  for(size_t bit = 1; bit<=5; ++bit) {
384  auto & iso = eminfo.isolation(isoSet,bit);
385  json jIso({});
386  jIso["etamax"] = iso.etamax();
387  jIso["etamin"] = iso.etamin();
388  jIso["isobit"] = iso.isobit();
389  jIso["mincut"] = iso.mincut();
390  jIso["offset"] = iso.offset();
391  jIso["priority"] = iso.priority();
392  jIso["slope"] = iso.slope();
393  jIso["upperlimit"] = iso.upperlimit();
394  jThrType["isolation"][isoSet]["Parametrization"] += jIso;
395  }
396  }
397  }
398 
399  if(thrType == "TAU" && l1menu.run()>1) {
400  auto & tauinfo = l1menu.thrExtraInfo().TAU();
401  const std::string isoSet{ "EMIsoForTAUthr" };
402  jThrType["isolation"][isoSet]["thrtype"] = isoSet;
403  jThrType["isolation"][isoSet]["Parametrization"] = json::array_t({});
404  for(size_t bit = 1; bit<=5; ++bit) {
405  auto & iso = tauinfo.isolation(isoSet,bit);
406  json jIso({});
407  jIso["etamax"] = iso.etamax();
408  jIso["etamin"] = iso.etamin();
409  jIso["isobit"] = iso.isobit();
410  jIso["mincut"] = iso.mincut();
411  jIso["offset"] = iso.offset();
412  jIso["priority"] = iso.priority();
413  jIso["slope"] = iso.slope();
414  jIso["upperlimit"] = iso.upperlimit();
415  jThrType["isolation"][isoSet]["Parametrization"] += jIso;
416  }
417  }
418 
419  if(thrType == "JET") {
420  auto & jetinfo = l1menu.thrExtraInfo().JET();
421  jThrType["ptMinToTopoSmallWindow"] = (int)jetinfo.ptMinToTopoSmallWindow();
422  jThrType["ptMinToTopoLargeWindow"] = (int)jetinfo.ptMinToTopoLargeWindow();
423  }
424 
425  if(thrType == "XS") {
426  auto & xsinfo = l1menu.thrExtraInfo().XS();
427  jThrType["significance"]["xeMin"] = xsinfo.xeMin();
428  jThrType["significance"]["xeMax"] = xsinfo.xeMax();
429  jThrType["significance"]["teSqrtMin"] = xsinfo.teSqrtMin();
430  jThrType["significance"]["teSqrtMax"] = xsinfo.teSqrtMax();
431  jThrType["significance"]["xsSigmaScale"] = xsinfo.xsSigmaScale();
432  jThrType["significance"]["xsSigmaOffset"] = xsinfo.xsSigmaOffset();
433  }
434 
435  if(thrType == "eEM") {
436  auto & eeminfo = l1menu.thrExtraInfo().eEM();
437  jThrType["maxEt"] = (int)eeminfo.maxEt();
438  for( auto wp : {TrigConf::Selection::WP::LOOSE, TrigConf::Selection::WP::MEDIUM, TrigConf::Selection::WP::TIGHT} ) {
439  const auto & wpstr = TrigConf::Selection::wpToString(wp);
440  jThrType["workingPoints"][wpstr] = json::array_t({});
441  for(auto & iso : eeminfo.isolation(wp)) {
442  json jWPIso({});
443  std::stringstream stream;
444  stream << std::fixed << std::setprecision(3) << iso.value().reta_d();
445  jWPIso["reta"] = std::stod(stream.str());
446  jWPIso["reta_fw"] = iso.value().reta_fw();
447  stream.str("");
448  stream.clear();
449  stream << std::fixed << std::setprecision(3) << iso.value().rhad_d();
450  jWPIso["rhad"] = std::stod(stream.str());
451  jWPIso["rhad_fw"] = iso.value().rhad_fw();
452  stream.str("");
453  stream.clear();
454  stream << std::fixed << std::setprecision(3) << iso.value().wstot_d();
455  jWPIso["wstot"] = std::stod(stream.str());
456  jWPIso["wstot_fw"] = iso.value().wstot_fw();
457  jWPIso["etamin"] = iso.etaMin();
458  jWPIso["etamax"] = iso.etaMax();
459  jWPIso["priority"] = iso.priority();
460  jThrType["workingPoints"][wpstr] += jWPIso;
461  }
462  }
463  }
464 
465  if(thrType == "jEM") {
466  auto & jeminfo = l1menu.thrExtraInfo().jEM();
467  jThrType["maxEt"] = (int)jeminfo.maxEt();
468  jThrType["ptMinToTopo1"] = (int)jeminfo.ptMinToTopo("1A");
469  jThrType["ptMinToTopo2"] = (int)jeminfo.ptMinToTopo("2A");
470  jThrType["ptMinToTopo3"] = (int)jeminfo.ptMinToTopo("3A");
471  jThrType["ptMinxTOB1"] = (int)jeminfo.ptMinxTOB("1A");
472  jThrType["ptMinxTOB2"] = (int)jeminfo.ptMinxTOB("2A");
473  jThrType["ptMinxTOB3"] = (int)jeminfo.ptMinxTOB("3A");
474  for( auto wp : {TrigConf::Selection::WP::LOOSE, TrigConf::Selection::WP::MEDIUM, TrigConf::Selection::WP::TIGHT} ) {
475  const auto & wpstr = TrigConf::Selection::wpToString(wp);
476  jThrType["workingPoints"][wpstr] = json::array_t({});
477  for(auto & iso : jeminfo.isolation(wp)) {
478  json jWPIso({});
479  std::stringstream stream;
480  stream << std::fixed << std::setprecision(3) << iso.value().iso_d();
481  jWPIso["iso"] = std::stod(stream.str());
482  jWPIso["iso_fw"] = iso.value().iso_fw();
483  stream.str("");
484  stream.clear();
485  stream << std::fixed << std::setprecision(3) << iso.value().frac_d();
486  jWPIso["frac"] = std::stod(stream.str());
487  jWPIso["frac_fw"] = iso.value().frac_fw();
488  stream.str("");
489  stream.clear();
490  stream << std::fixed << std::setprecision(3) << iso.value().frac2_d();
491  jWPIso["frac2"] = std::stod(stream.str());
492  jWPIso["frac2_fw"] = iso.value().frac2_fw();
493  jWPIso["etamin"] = iso.etaMin();
494  jWPIso["etamax"] = iso.etaMax();
495  jWPIso["priority"] = iso.priority();
496  jThrType["workingPoints"][wpstr] += jWPIso;
497  }
498  }
499  }
500 
501  if(thrType == "eTAU") {
502  auto & eeminfo = l1menu.thrExtraInfo().eTAU();
503  jThrType["minIsoEt"] = (int)eeminfo.minIsoEt();
504  jThrType["maxEt"] = (int)eeminfo.maxEt();
505  jThrType["algoVersion"] = (int)eeminfo.algoVersion();
506  for( auto wp : {TrigConf::Selection::WP::LOOSE, TrigConf::Selection::WP::MEDIUM, TrigConf::Selection::WP::TIGHT,
507  TrigConf::Selection::WP::HADLOOSE, TrigConf::Selection::WP::HADMEDIUM, TrigConf::Selection::WP::HADTIGHT} ) {
508  const auto & wpstr = TrigConf::Selection::wpToString(wp);
509  jThrType["workingPoints"][wpstr] = json::array_t({});
510  for(auto & iso : eeminfo.isolation(wp)) {
511  json jWPIso({});
512  std::stringstream stream;
513  stream << std::fixed << std::setprecision(3) << iso.value().rCore_d();
514  jWPIso["rCore"] = std::stod(stream.str());
515  jWPIso["rCore_fw"] = iso.value().rCore_fw();
516  stream.str("");
517  stream.clear();
518  stream << std::fixed << std::setprecision(3) << iso.value().rHad_d();
519  jWPIso["rHad"] = std::stod(stream.str());
520  jWPIso["rHad_fw"] = iso.value().rHad_fw();
521  jThrType["workingPoints"][wpstr] += jWPIso;
522  }
523  }
524  }
525 
526  if(thrType == "jTAU") {
527  auto & jtauinfo = l1menu.thrExtraInfo().jTAU();
528  jThrType["maxEt"] = (int)jtauinfo.maxEt();
529  jThrType["ptMinToTopo1"] = (int)jtauinfo.ptMinToTopo("1A");
530  jThrType["ptMinToTopo2"] = (int)jtauinfo.ptMinToTopo("2A");
531  jThrType["ptMinToTopo3"] = (int)jtauinfo.ptMinToTopo("3A");
532  jThrType["ptMinxTOB1"] = (int)jtauinfo.ptMinxTOB("1A");
533  jThrType["ptMinxTOB2"] = (int)jtauinfo.ptMinxTOB("2A");
534  jThrType["ptMinxTOB3"] = (int)jtauinfo.ptMinxTOB("3A");
535  for( auto wp : {TrigConf::Selection::WP::LOOSE, TrigConf::Selection::WP::MEDIUM, TrigConf::Selection::WP::TIGHT} ) {
536  const auto & wpstr = TrigConf::Selection::wpToString(wp);
537  jThrType["workingPoints"][wpstr] = json::array_t({});
538  for(auto & iso : jtauinfo.isolation(wp)) {
539  json jWPIso({});
540  std::stringstream stream;
541  stream << std::fixed << std::setprecision(3) << iso.value().isolation_d();
542  jWPIso["isolation"] = std::stod(stream.str());
543  jWPIso["isolation_fw"] = iso.value().isolation_fw();
544  jThrType["workingPoints"][wpstr] += jWPIso;
545  }
546  }
547  }
548 
549  if(thrType == "cTAU") {
550  auto & eeminfo = l1menu.thrExtraInfo().cTAU();
551  for( auto wp : {TrigConf::Selection::WP::LOOSE, TrigConf::Selection::WP::MEDIUM, TrigConf::Selection::WP::TIGHT} ) {
552  const auto & wpstr = TrigConf::Selection::wpToString(wp);
553  jThrType["workingPoints"][wpstr] = json::array_t({});
554  for(auto & iso : eeminfo.isolation(wp)) {
555  json jWPIso({});
556  std::stringstream stream;
557  stream << std::fixed << std::setprecision(3) << iso.value().isolation_d();
558  jWPIso["isolation"] = std::stod(stream.str());
559  jWPIso["isolation_fw"] = iso.value().isolation_fw();
560  stream.str("");
561  stream << std::fixed << std::setprecision(3) << iso.value().isolation_jTAUCoreScale_d();
562  jWPIso["isolation_jTAUCoreScale"] = std::stod(stream.str());
563  jWPIso["isolation_jTAUCoreScale_fw"] = iso.value().isolation_jTAUCoreScale_fw();
564  stream.str("");
565  stream << std::fixed << std::setprecision(3) << iso.value().eTAU_rCoreMin_WP_d();
566  jWPIso["eTAU_rCoreMin"] = std::stod(stream.str());
567  jWPIso["eTAU_rCoreMin_WP_fw"] = iso.value().eTAU_rCoreMin_WP_fw();
568  stream.str("");
569  stream << std::fixed << std::setprecision(3) << iso.value().eTAU_rHadMin_WP_d();
570  jWPIso["eTAU_rHadMin"] = std::stod(stream.str());
571  jWPIso["eTAU_rHadMin_WP_fw"] = iso.value().eTAU_rHadMin_WP_fw();
572  jThrType["workingPoints"][wpstr] += jWPIso;
573  }
574  }
575  }
576 
577  if(thrType == "jJ") {
578  auto & jjinfo = l1menu.thrExtraInfo().jJ();
579  jThrType["ptMinToTopo1"] = (int)jjinfo.ptMinToTopo("1A");
580  jThrType["ptMinToTopo2"] = (int)jjinfo.ptMinToTopo("2A");
581  jThrType["ptMinToTopo3"] = (int)jjinfo.ptMinToTopo("3A");
582  jThrType["ptMinxTOB1"] = (int)jjinfo.ptMinxTOB("1A");
583  jThrType["ptMinxTOB2"] = (int)jjinfo.ptMinxTOB("2A");
584  jThrType["ptMinxTOB3"] = (int)jjinfo.ptMinxTOB("3A");
585  }
586 
587  if(thrType == "jLJ") {
588  auto & jljinfo = l1menu.thrExtraInfo().jLJ();
589  jThrType["ptMinToTopo1"] = (int)jljinfo.ptMinToTopo("1A");
590  jThrType["ptMinToTopo2"] = (int)jljinfo.ptMinToTopo("2A");
591  jThrType["ptMinToTopo3"] = (int)jljinfo.ptMinToTopo("3A");
592  jThrType["ptMinxTOB1"] = (int)jljinfo.ptMinxTOB("1A");
593  jThrType["ptMinxTOB2"] = (int)jljinfo.ptMinxTOB("2A");
594  jThrType["ptMinxTOB3"] = (int)jljinfo.ptMinxTOB("3A");
595  }
596 
597  if(thrType == "gJ") {
598  auto & gjinfo = l1menu.thrExtraInfo().gJ();
599  jThrType["ptMinToTopo1"] = (int)gjinfo.ptMinToTopo(1);
600  jThrType["ptMinToTopo2"] = (int)gjinfo.ptMinToTopo(2);
601  }
602 
603  if(thrType == "gLJ") {
604  auto & gljinfo = l1menu.thrExtraInfo().gLJ();
605  jThrType["ptMinToTopo1"] = (int)gljinfo.ptMinToTopo(1);
606  jThrType["ptMinToTopo2"] = (int)gljinfo.ptMinToTopo(2);
607  jThrType["seedThrA"] = (int)gljinfo.seedThr('A');
608  jThrType["seedThrB"] = (int)gljinfo.seedThr('B');
609  jThrType["seedThrC"] = (int)gljinfo.seedThr('C');
610  std::stringstream stream;
611  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMin('A');
612  jThrType["rhoTowerMinA"] = std::stod(stream.str());
613  stream.str("");
614  stream.clear();
615  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMin('B');
616  jThrType["rhoTowerMinB"] = std::stod(stream.str());
617  stream.str("");
618  stream.clear();
619  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMin('C');
620  jThrType["rhoTowerMinC"] = std::stod(stream.str());
621  stream.str("");
622  stream.clear();
623  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMax('A');
624  jThrType["rhoTowerMaxA"] = std::stod(stream.str());
625  stream.str("");
626  stream.clear();
627  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMax('B');
628  jThrType["rhoTowerMaxB"] = std::stod(stream.str());
629  stream.str("");
630  stream.clear();
631  stream << std::fixed << std::setprecision(3) << gljinfo.rhoTowerMax('C');
632  jThrType["rhoTowerMaxC"] = std::stod(stream.str());
633  }
634 
635  if(thrType == "jXE") {
636  // nothing to do for now...
637  }
638 
639  if(thrType == "jTE") {
640  auto & ei = l1menu.thrExtraInfo().jTE();
641  jThrType["etaBoundary1"] = ei.etaBoundary("1A");
642  jThrType["etaBoundary1_fw"] = ei.etaBoundary_fw("1A");
643  jThrType["etaBoundary2"] = ei.etaBoundary("2A");
644  jThrType["etaBoundary2_fw"] = ei.etaBoundary_fw("2A");
645  jThrType["etaBoundary3"] = ei.etaBoundary("3A");
646  jThrType["etaBoundary3_fw"] = ei.etaBoundary_fw("3A");
647  }
648 
649  if(thrType == "gXE") {
650  auto & ei = l1menu.thrExtraInfo().gXE();
651  jThrType["seedThrA"] = (int)ei.seedThr('A');
652  jThrType["seedThrB"] = (int)ei.seedThr('B');
653  jThrType["seedThrC"] = (int)ei.seedThr('C');
654  jThrType["XERHO_sigmaPosA"] = ei.XERHO_param('A',true);
655  jThrType["XERHO_sigmaPosB"] = ei.XERHO_param('B',true);
656  jThrType["XERHO_sigmaPosC"] = ei.XERHO_param('C',true);
657  jThrType["XERHO_sigmaNegA"] = ei.XERHO_param('A',false);
658  jThrType["XERHO_sigmaNegB"] = ei.XERHO_param('B',false);
659  jThrType["XERHO_sigmaNegC"] = ei.XERHO_param('C',false);
660  jThrType["XEJWOJ_a_A"] = ei.JWOJ_param('A','a');
661  jThrType["XEJWOJ_a_B"] = ei.JWOJ_param('B','a');
662  jThrType["XEJWOJ_a_C"] = ei.JWOJ_param('C','a');
663  jThrType["XEJWOJ_b_A"] = ei.JWOJ_param('A','b');
664  jThrType["XEJWOJ_b_B"] = ei.JWOJ_param('B','b');
665  jThrType["XEJWOJ_b_C"] = ei.JWOJ_param('C','b');
666  jThrType["XEJWOJ_c_A"] = ei.JWOJ_param('A','c');
667  jThrType["XEJWOJ_c_B"] = ei.JWOJ_param('B','c');
668  jThrType["XEJWOJ_c_C"] = ei.JWOJ_param('C','c');
669  }
670 
671  if(thrType == "gTE") {
672  // nothing to do for now...
673  }
674 
675  std::vector<std::string> legacyCalo = {"EM", "JET", "TAU", "XE", "TE", "XS", "ZB", "JB", "JF", "JE", "R2TOPO"};
676  if( std::any_of(begin(legacyCalo), end(legacyCalo), [&thrType](const std::string &c) { return c==thrType; }) ) {
677  thresholds["legacyCalo"][thrType] = jThrType;
678  } else {
679  thresholds[thrType] = jThrType;
680  }
681  };
682 
683  json boards = json::object_t{};
684  for( auto & bname : l1menu.boardNames() ) {
685  auto & bdef = l1menu.board(bname);
686  boards[bname] = json{ {"connectors", bdef.connectorNames()}, {"type", bdef.type()} };
687  if(bdef.legacy())
688  boards[bname]["legacy"] = true;
689  };
690 
691  json connectors = json::object_t{};
692  for( auto & cname : l1menu.connectorNames() ) {
693  auto jConn = json{};
694  auto & cdef = l1menu.connector(cname);
695  jConn["type"] = cdef.type();
696  if(cdef.legacy())
697  jConn["legacy"] = true;
698  jConn["triggerlines"] = json::array_t();
699  if(cdef.maxClock() == 2){
700  if(cdef.maxFpga() == 2){
701  // legacy topo, TOPO2, TOPO3 and muctpi
702  for(size_t fpga = 0; fpga<cdef.maxFpga(); ++fpga) {
703  for(size_t clock = 0; clock<cdef.maxClock(); ++clock) {
704  for(auto & tl : cdef.triggerLines(fpga, clock)) {
705  jConn["triggerlines"] += json({ {"name", tl.name()}, {"nbits",tl.nbits()}, {"startbit", tl.startbit()}, {"flatindex", tl.flatindex()}, {"fpga", tl.fpga()}, {"clock", tl.clock()}, });
706  }
707  }
708  }
709  } else {
710  // AlfaCpti and merger board
711  for(size_t fpga = 0; fpga<cdef.maxFpga(); ++fpga) {
712  for(size_t clock = 0; clock<cdef.maxClock(); ++clock) {
713  for(auto & tl : cdef.triggerLines(fpga, clock)) {
714  jConn["triggerlines"] += json({ {"name", tl.name()}, {"nbits",tl.nbits()}, {"startbit", tl.startbit()}, {"flatindex", tl.flatindex()}, {"clock", tl.clock()}, });
715  }
716  }
717  }
718  }
719  } else {
720  for(auto & tl : cdef.triggerLines()) {
721  jConn["triggerlines"] += json({ {"name", tl.name()}, {"nbits",tl.nbits()}, {"startbit", tl.startbit()}, {"flatindex", tl.flatindex()} });
722  }
723  }
724  connectors[cname] = jConn;
725  }
726 
727  json ctp = json::object_t{};
728  {
729  for(size_t slot=7; slot<=9; ++slot) {
730  std::string sName = "slot" + std::to_string(slot);
731  ctp["inputs"]["ctpin"][sName] = json({});
732  for(size_t conn=0; conn<=3; ++conn) {
733  ctp["inputs"]["ctpin"][sName]["connector" + std::to_string(conn)] = l1menu.ctp().ctpin(slot,conn);
734  }
735  }
736  ctp["inputs"]["electrical"] = json::object_t{};
737  for(size_t conn=0; conn<3; ++conn) {
738  if(l1menu.ctp().electrical(conn)=="")
739  continue;
740  ctp["inputs"]["electrical"]["connector" + std::to_string(conn)] = l1menu.ctp().electrical(conn);
741  }
742  ctp["inputs"]["optical"] = json::object_t{};
743  for(size_t conn=0; conn<12; ++conn) {
744  if(l1menu.ctp().optical(conn)=="")
745  continue;
746  ctp["inputs"]["optical"]["connector" + std::to_string(conn)] = l1menu.ctp().optical(conn);
747  }
748  json ctpmon = json::object_t{};
749  for(auto & mon : l1menu.ctp().ctpMon()) {
750  ctpmon[mon.first] = json({{"multiplicity",mon.second.first},{"thr",mon.second.second}});
751  }
752  json ctpin = json::object_t{};
753  for(auto & mon : l1menu.ctp().ctpinMon()) {
754  ctpin[mon.first] = json({{"multiplicity", mon.second.first},{"thr", mon.second.second}});
755  }
756  ctp["monitoring"] = json({{"ctpmon", ctpmon}, {"ctpin", ctpin}});
757  }
758 
759  json jtopo = json::object_t{};
760  if(l1menu.run()>1) {
761  std::map<L1TopoAlgorithm::AlgorithmType,std::string> algTypeNames = {
762  {L1TopoAlgorithm::AlgorithmType::SORTING, "sortingAlgorithms"},
763  {L1TopoAlgorithm::AlgorithmType::DECISION, "decisionAlgorithms"},
764  {L1TopoAlgorithm::AlgorithmType::MULTIPLICITY, "multiplicityAlgorithms"}
765  };
766  auto topoCategories = l1menu.isRun2() ? std::vector<std::string> {"R2TOPO"} : std::vector<std::string> {"TOPO", "MUTOPO", "MULTTOPO", "R2TOPO"};
767  for( const std::string& topoCat : topoCategories ) {
768  for(auto & algName : l1menu.topoAlgorithmNames(topoCat)) {
769  json jalg = json::object_t({});
770  auto & alg = l1menu.algorithm(algName,topoCat);
771  jalg["klass"] = alg.klass();
772  // input
773  if(alg.type()==L1TopoAlgorithm::AlgorithmType::MULTIPLICITY) {
774  if(alg.inputs().size()>0) {
775  jalg["input"] = alg.inputs()[0];
776  } else {
777  jalg["input"] = nullptr;
778  }
779  } else if(alg.type()==L1TopoAlgorithm::AlgorithmType::SORTING) {
780  jalg["input"] = alg.inputs()[0];
781  } else {
782  jalg["input"] = alg.inputs();
783  }
784  // output
785  if( alg.type() == L1TopoAlgorithm::AlgorithmType::DECISION ) {
786  jalg["output"] = alg.outputs();
787  } else {
788  jalg["output"] = alg.outputs()[0];
789  }
790  // generic parameters
791  if(topoCat == "MULTTOPO") {
792  jalg["nbits"] = alg.getAttribute<unsigned int>("nbits");
793  jalg["threshold"] = alg.getAttribute("threshold");
794  if(alg.klass()=="EnergyThreshold"){
795  for(const L1TopoAlgorithm::VariableParameter & vpar : alg.parameters()) {
796  if(vpar.name()=="flavour") jalg["flavour"] = XEFlavour::flavourIntToStr(vpar.value());
797  }
798  }
799  } else {
800  const auto & ds = alg.generics();
801  for(const auto & gpname : ds.getKeys()) {
802  auto gp = ds.getObject(gpname);
803  {
804  if(gp.hasAttribute("position")) {
805  jalg["fixedParameters"]["generics"][gpname]["position"] = gp.getAttribute<unsigned int>("position");
806  }
807  std::string pval = alg.genericParameter(gpname);
808  try{
809  int pvali = std::stoi(pval);
810  jalg["fixedParameters"]["generics"][gpname]["value"] = pvali;
811  } catch(std::invalid_argument &) {
812  jalg["fixedParameters"]["generics"][gpname]["value"] = pval;
813  }
814  }
815  }
816  }
817  // variable parameters
818  if(topoCat != "MULTTOPO") {
819  jalg["variableParameters"] = json::array_t({});
820  for(const L1TopoAlgorithm::VariableParameter & vpar : alg.parameters()) {
821  json jVPar({});
822  jVPar["name"] = vpar.name();
823  jVPar["value"] = vpar.value();
824  if(auto sel = vpar.selection_optional()) { jVPar["selection"] = *sel; }
825  jalg["variableParameters"] += jVPar;
826  }
827  }
828  jtopo[topoCat][algTypeNames[alg.type()]][algName] = jalg;
829  }
830  }
831  }
832 
833  json j = json::object_t{};
834  j["filetype"] = "l1menu";
835  j["run"] = l1menu.run();
836  j["name"] = l1menu.name();
837  j["items"] = items;
838  j["thresholds"] = thresholds;
839  j["topoAlgorithms"] = jtopo;
840  j["boards"] = boards;
841  j["connectors"] = connectors;
842  j["ctp"] = ctp;
843 
844  std::ofstream outfile(filename);
845  outfile << std::setw(4) << j << std::endl;
846 
847  TRG_MSG_INFO("Saved file " << filename);
848  return true;
849 }

◆ writeJsonFile() [3/3]

bool TrigConf::JsonFileWriterL1::writeJsonFile ( const std::string &  filename,
const L1PrescalesSet &  l1bgs 
) const

Definition at line 883 of file JsonFileWriterL1.cxx.

883  {
884  json j;
885  j["filetype"] = "l1prescale";
886  j["name"] = l1ps.name();
887  json cuts;
888  for ( const auto & [itemName, ps]: l1ps.prescales()){
889  json cut;
890  cut["cut"] = ps.cut;
891  cut["enabled"] = ps.enabled;
892  cut["info"] = "prescale: " + std::to_string(ps.prescale);
893  cuts[itemName] = cut;
894  }
895  j["cutValues"] = cuts;
896  std::ofstream outfile(filename);
897  outfile << std::setw(4) << j << std::endl;
898  TRG_MSG_INFO("Saved file " << filename);
899  return true;
900 }

Member Data Documentation

◆ m_msg_tls

boost::thread_specific_ptr<MsgStreamTC> TrigConf::TrigConfMessaging::m_msg_tls
mutableprivateinherited

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

Definition at line 66 of file TrigConfMessaging.h.

◆ m_name

std::string TrigConf::TrigConfMessaging::m_name
privateinherited

Definition at line 67 of file TrigConfMessaging.h.

The documentation for this class was generated from the following files:
TrigConf::L1Threshold_jLJ
Definition: L1Threshold.h:290
TrigConf::Selection::WP::LOOSE
@ LOOSE
TrigConf::L1Threshold_cTAU
Definition: L1Threshold.h:255
ChainDefInMenu.groups
groups
Definition: ChainDefInMenu.py:44
TrigConf::L1Threshold_gTE
Definition: L1Threshold.h:380
TrigConf::L1Threshold_jTE
Definition: L1Threshold.h:350
checkxAOD.ds
ds
Definition: Tools/PyUtils/bin/checkxAOD.py:257
checkCorrelInHIST.conn
conn
Definition: checkCorrelInHIST.py:25
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
TrigConf::L1Threshold_JET
Definition: L1Threshold.h:55
SGout2dot.alg
alg
Definition: SGout2dot.py:243
TrigConf::L1Threshold_eTAU
Definition: L1Threshold.h:212
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TrigConf::TrigConfMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStreamTC > m_msg_tls
MsgStreamTC instance (a std::cout like with print-out levels)
Definition: TrigConfMessaging.h:66
json
nlohmann::json json
Definition: HistogramDef.cxx:9
TrigConf::L1Threshold_ZB::seed
const std::string & seed() const
Definition: L1Threshold.h:111
TrigConf::L1Threshold_jTAU
Definition: L1Threshold.h:234
xAOD::JetAlgorithmType::algName
const std::string & algName(ID id)
Converts a JetAlgorithmType::ID into a string.
Definition: JetContainerInfo.cxx:67
TrigConf::Selection::wpToString
static std::string wpToString(WP)
Definition: L1ThresholdBase.cxx:347
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
TrigConf::L1Threshold_gXE
Definition: L1Threshold.h:365
TrigConf::L1Threshold_jXE
Definition: L1Threshold.h:335
TrigConf::L1Threshold_TE
Definition: L1Threshold.h:88
TrigConf::L1Threshold_eEM
Definition: L1Threshold.h:166
x
#define x
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
TrigConf::L1Threshold_jEM
Definition: L1Threshold.h:189
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
TrigConf::Selection::WP::HADLOOSE
@ HADLOOSE
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
TrigConf::L1TopoAlgorithm::AlgorithmType::SORTING
@ SORTING
TrigConf::L1Threshold_Calo
Definition: L1ThresholdBase.h:188
xAOD::tgcPt
setTeId setLumiBlock setRoiId setRoiSubsystem setRoiNumber setRoiEta tgcPt
Definition: L2StandAloneMuon_v2.cxx:352
TrigConf::L1Threshold_ZB
Definition: L1Threshold.h:101
TrigConf::TrigConfMessaging::m_name
std::string m_name
Definition: TrigConfMessaging.h:67
lumiFormat.i
int i
Definition: lumiFormat.py:92
json
nlohmann::json json
Definition: JsonFileWriterL1.cxx:11
TrigConf::TrigConfMessaging::msg
MsgStreamTC & msg() const
The standard message stream.
Definition: TrigConfMessaging.h:81
sel
sel
Definition: SUSYToolsTester.cxx:92
TrigConf::TrigConfMessaging::TrigConfMessaging
TrigConfMessaging()=delete
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
PlotSFuncertainty.wp
wp
Definition: PlotSFuncertainty.py:112
TrigConf::L1TopoAlgorithm::AlgorithmType::MULTIPLICITY
@ MULTIPLICITY
TrigConf::L1Threshold_TAU::isolationMask
uint16_t isolationMask() const
Definition: L1Threshold.h:44
TrigConf::XEFlavour::flavourIntToStr
static std::string flavourIntToStr(const unsigned int flavInt)
Definition: L1TopoAlgorithm.h:129
TRG_MSG_INFO
#define TRG_MSG_INFO(x)
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStreamMacros.h:27
TrigConf::Selection::WP::HADTIGHT
@ HADTIGHT
lumiFormat.array
array
Definition: lumiFormat.py:98
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TrigConf::L1Threshold_jJ
Definition: L1Threshold.h:275
TrigJetMonitorAlgorithm.items
items
Definition: TrigJetMonitorAlgorithm.py:79
item
Definition: ItemListSvc.h:43
dq_make_web_display.rv
def rv
Definition: dq_make_web_display.py:219
TriggerTest.ctp
ctp
Retrieve trigger EDM objects.
Definition: TriggerTest.py:14
TrigConf::Selection::WP::MEDIUM
@ MEDIUM
TrigConf::L1TopoAlgorithm::AlgorithmType::DECISION
@ DECISION
TrigConf::L1Threshold_MU
Definition: L1Threshold.h:400
TrigConf::Selection::WP::TIGHT
@ TIGHT
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
TrigConf::Selection::WP::HADMEDIUM
@ HADMEDIUM
DeMoScan.first
bool first
Definition: DeMoScan.py:534
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
python.XMLReader.l1menu
l1menu
Definition: XMLReader.py:73
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
TrigConf::L1Threshold_ZBTopo
Definition: L1Threshold.h:119
pickleTool.object
object
Definition: pickleTool.py:30
TrigConf::L1Threshold_ZBTopo::mask0
const unsigned int & mask0() const
Definition: L1Threshold.h:125
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
TrigConf::L1Threshold_TAU
Definition: L1Threshold.h:37
PrepareReferenceFile.outfile
outfile
Definition: PrepareReferenceFile.py:42
python.compressB64.c
def c
Definition: compressB64.py:93
TrigConf::L1Threshold_gJ
Definition: L1Threshold.h:305
TrigConf::L1Threshold_MU::ptBarrel
unsigned int ptBarrel() const
Definition: L1Threshold.h:413
python.trfValidateRootFile.rc
rc
Definition: trfValidateRootFile.py:350
TrigConf::L1Threshold_EM
Definition: L1Threshold.h:17
TrigConf::L1Threshold_gLJ
Definition: L1Threshold.h:320
Generated on Tue Jul 2 2024 22:29:16 for ATLAS Offline Software by   doxygen 1.8.18