ATLAS Offline Software
jFEXForwardJetsAlgo.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 //***************************************************************************
5 // jFEXForwardJetsAlgo - Algorithm for forward Jets in jFEX
6 // -------------------
7 // begin : 07 06 2021
8 // email : Sergi.Rodriguez@cern.ch
9 //***************************************************************************
10 #include <iostream>
11 #include <vector>
12 #include <string>
13 #include <map>
15 #include "L1CaloFEXSim/jTower.h"
23 #include "StoreGate/StoreGateSvc.h"
24 
25 #include <fstream>
26 
27 namespace LVL1{
28 
29 //Default Constructor
30 LVL1::jFEXForwardJetsAlgo::jFEXForwardJetsAlgo(const std::string& type, const std::string& name, const IInterface* parent):
32  {
33  declareInterface<IjFEXForwardJetsAlgo>(this);
34  }
35 
38 {
39 }
41 
42  ATH_CHECK(m_jFEXForwardJetsAlgo_jTowerContainerKey.initialize());
43 
44  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_SeedRingStr) , m_SeedRingMap ));
45  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_1stRingStr) , m_1stRingMap ));
46  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_2ndRingStr) , m_2ndRingMap ));
47  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_CorrStr) , m_CorrMap ));
48  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_Corr2Str) , m_Corr2Map ));
49  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_SearchGStr) , m_SearchGMap ));
50  ATH_CHECK(ReadfromFile(PathResolver::find_calib_file(m_SearchGeStr) , m_SearchGeMap ));
51 
52  return StatusCode::SUCCESS;
53 
54 }
55 
56 //calls container for TT
58  m_jTowerContainer = SG::ReadHandle<jTowerContainer>(m_jFEXForwardJetsAlgo_jTowerContainerKey);
59  if(! m_jTowerContainer.isValid()) {
60  ATH_MSG_ERROR("Could not retrieve jTowerContainer " << m_jFEXForwardJetsAlgo_jTowerContainerKey.key());
61 
62  return StatusCode::FAILURE;
63  }
64 
65  return StatusCode::SUCCESS;
66 }
67 
69  return StatusCode::SUCCESS;
70 }
71 
73  std::copy(&inputTable[0][0], &inputTable[0][0] + (FEXAlgoSpaceDefs::jFEX_algoSpace_height*FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width), &m_jFEXalgoTowerID[0][0]);
74  m_jfex=jfex;
75 }
76 
77 //Gets geometric global centre Eta and Phi coord of the TT
78 //Has the advantage over the individual eta, phi methods that it does only one tower search
79 std::array<float,2> LVL1::jFEXForwardJetsAlgo::globalEtaPhi(int TTID) {
80  if(TTID == 0) {
81  return {999,999};
82  }
83 
84  const LVL1::jTower *tmpTower = m_jTowerContainer->findTower(TTID);
85  return {tmpTower->centreEta(),tmpTower->centrephi_toPI()};
86 }
87 
88 int LVL1::jFEXForwardJetsAlgo::getEt(unsigned int TTID) {
89  if(TTID == 0) {
90  return -999;
91  }
92 
93  auto itr = m_map_Etvalues.find(TTID);
94 
95  if( itr == m_map_Etvalues.end()) {
96  return -999;
97  }
98 
99  return itr->second[0];
100 }
101 
102 std::unordered_map<int, jFEXForwardJetsInfo> LVL1::jFEXForwardJetsAlgo::FcalJetsTowerIDLists(int seedThreshold) {
103 
104  std::unordered_map<int, jFEXForwardJetsInfo> FCALJetTowerIDLists;
105 
106  std::vector<int> lower_centre_neta;
107  std::vector<int> upper_centre_neta;
108  m_lowerEM_eta = 0;
109  m_upperEM_eta = 0;
110 
111  //STEP 1: check if we are in module 0 or 5 and assign corrrect eta FEXAlgoSpace parameters
112  if(m_jfex == 0) {
113  //Module 0
118  }
119  else {
120  //Module 5
123 
126 
127  }
128 
129 
130 
131  //STEP 2: define phi FEXAlgoSpace parameters
134 
135  //STEP 3: loop over different EM/FCAL0 eta phi core fpga regions. These are potential central trigger towers for jets
136  for(int myCounter = 0; myCounter<3; myCounter++) {
137  for(int centre_nphi = lower_centre_nphi[myCounter]; centre_nphi < upper_centre_nphi[myCounter]; centre_nphi++) {
138  for(int centre_neta = lower_centre_neta[myCounter]; centre_neta < upper_centre_neta[myCounter]; centre_neta++) {
139 
140  //STEP 4: define TTID which will be the key for class in map
141  int myTTIDKey = m_jFEXalgoTowerID[centre_nphi][centre_neta];
142 
143  //STEP 5: ignore when tower ID is zero. Should not happend though
144  if(myTTIDKey == 0) {
145  continue;
146  }
147  bool iAmJet = false;
148  bool bool_isLM = false;
149  bool bool_condCorr2 = false;
150  bool bool_isLMabove = false;
151  bool bool_condCorr = false;
152 
153  //Know which condition should satisfy
154  unsigned int elemCorr = elementsCorr(myTTIDKey);
155  unsigned int elemCorr2 = elementsCorr2(myTTIDKey);
156 
157  if(elemCorr == 0 and elemCorr2 == 0){
158  bool_isLM = isLM(myTTIDKey);
159  iAmJet = bool_isLM;
160  }
161  else if(elemCorr == 0 and elemCorr2 > 0){
162  bool_isLM = isLM(myTTIDKey);
163  bool_condCorr2 = condCorr2(myTTIDKey);
164  iAmJet = bool_isLM and bool_condCorr2;
165  }
166  else if(elemCorr > 0 and elemCorr2 == 0){
167  bool_isLM = isLM(myTTIDKey);
168  bool_isLMabove = isLMabove(myTTIDKey);
169  bool_condCorr = condCorr(myTTIDKey);
170  iAmJet = bool_isLM or (bool_isLMabove and bool_condCorr);
171  }
172  else if(elemCorr > 0 and elemCorr2 > 0){
173  bool_isLM = isLM(myTTIDKey);
174  bool_condCorr2 = condCorr2(myTTIDKey);
175  bool_isLMabove = isLMabove(myTTIDKey);
176  bool_condCorr = condCorr(myTTIDKey);
177  iAmJet = (bool_isLM and bool_condCorr2) or (bool_isLMabove and bool_condCorr);
178  }
179 
180  //veto seeds below seed threshold
181  if (SumEtSeed(myTTIDKey) <= seedThreshold){
182  iAmJet = false;
183  }
184 
185  if(iAmJet){
186 
187  //STEP 6: define class
188  jFEXForwardJetsInfo TriggerTowerInformation;
189 
190  TriggerTowerInformation.setCentreLocalTTPhi(centre_nphi);
191  TriggerTowerInformation.setCentreLocalTTEta(centre_neta);
192 
193  const auto [centreTT_eta,centreTT_phi] = globalEtaPhi(myTTIDKey);
194  TriggerTowerInformation.setCentreTTPhi(centreTT_phi);
195  TriggerTowerInformation.setCentreTTEta(centreTT_eta);
196 
197 
198  //STEP 7: Filling energies
199  int saturation = 0;
200  // Seed
201  auto it_seed_map = m_SeedRingMap.find(myTTIDKey);
202  if(it_seed_map == m_SeedRingMap.end()) {
203  ATH_MSG_ERROR("Could not find TT" << myTTIDKey << " in Jet seed file.");
204  }
205 
206  for(const auto& seedTT : it_seed_map->second){
207  TriggerTowerInformation.includeTTinSeed(seedTT);
208  saturation = saturation || getTTowerSat(seedTT);
209  TriggerTowerInformation.addToSeedET(getEt(seedTT));
210  }
211 
212  // 1st Energy Ring!
213  it_seed_map = m_1stRingMap.find(myTTIDKey);
214  if(it_seed_map == m_1stRingMap.end()) {
215  ATH_MSG_ERROR("Could not find TT" << myTTIDKey << " in 1st Energy ring file.");
216  }
217 
218  for(const auto& firstER_TT : it_seed_map->second){
219  TriggerTowerInformation.addToFirstEnergyRingET(getEt(firstER_TT));
220  saturation = saturation || getTTowerSat(firstER_TT);
221  if(m_storeEnergyRingTTIDs) {
222  TriggerTowerInformation.includeTTIDinFirstER(firstER_TT);
223  }
224  }
225 
226  //setting saturation for jJ
227  if(saturation) TriggerTowerInformation.setSRjetSat();
228 
229 
230  // 2nd Energy Ring!
231  it_seed_map = m_2ndRingMap.find(myTTIDKey);
232  if(it_seed_map == m_2ndRingMap.end()) {
233  ATH_MSG_ERROR("Could not find TT" << myTTIDKey << " in 2nd Energy ring file.");
234  }
235 
236  for(const auto& secondER_TT : it_seed_map->second){
237  TriggerTowerInformation.addToSecondEnergyRingET(getEt(secondER_TT));
238  saturation = saturation || getTTowerSat(secondER_TT);
239  if(m_storeEnergyRingTTIDs) {
240  TriggerTowerInformation.includeTTIDinSecondER(secondER_TT);
241  }
242  }
243 
244  //setting saturation for jLJ
245  if(saturation) TriggerTowerInformation.setLRjetSat();
246 
247  // Storing all jets in the same map!
248  FCALJetTowerIDLists[myTTIDKey] = std::move(TriggerTowerInformation);
249  }
250 
251  }//end of centre_neta loop
252  }//end of centre_nphi loop
253  }//end of myCounter loop
254 
255  return FCALJetTowerIDLists;
256 }
257 
258 int LVL1::jFEXForwardJetsAlgo::SumEtSeed(unsigned int TTID) {
259 
260  // Exists the jTower in the mapping?
261  auto it_seed_map = m_SeedRingMap.find(TTID);
262  if(it_seed_map == m_SeedRingMap.end()) {
263  ATH_MSG_ERROR("Could not find TT" << TTID << " in Jet seed file.");
264  return 0;
265  }
266  int summedEt = 0;
267  for(const auto& seedTT : it_seed_map->second){
268  summedEt += getEt(seedTT);
269  }
270 
271  return summedEt;
272 }
273 
274 bool LVL1::jFEXForwardJetsAlgo::isLM(unsigned int TTID){
275 
276  int CentralSeedEt = SumEtSeed(TTID);
277 
278  // Exists the jTower in the seach (greater than) tower map?
279  auto it_seed_map = m_SearchGMap.find(TTID);
280  if(it_seed_map == m_SearchGMap.end()) {
281  ATH_MSG_ERROR("Could not find TT" << TTID << " in the seach (>) local maxima for jets file.");
282  return false;
283  }
284 
285  bool greater = true;
286  for (const auto& Gtt : it_seed_map->second ){
287  //checking if the Central seed has strictly more energy than its neighbours
288  int tmpEt = SumEtSeed(Gtt);
289  if( !(CentralSeedEt > tmpEt) ){
290  greater = false;
291  break;
292  }
293  }
294 
295  //No need to continue.. Not a LM
296  if(!greater){
297  return false;
298  }
299 
300  // Exists the jTower in the seach (greater or equal than) tower map?
301  it_seed_map = m_SearchGeMap.find(TTID);
302  if(it_seed_map == m_SearchGeMap.end()) {
303  ATH_MSG_ERROR("Could not find TT" << TTID << " in the seach (>=) local maxima for jets file.");
304  return false;
305  }
306 
307  bool greaterEqual = true;
308  for (const auto& Gtt : it_seed_map->second ){
309  //checking if the Central seed has more energy or equal than its neighbours
310  int tmpEt = SumEtSeed(Gtt);
311  if( !(CentralSeedEt >= tmpEt) ){
312  greaterEqual = false;
313  break;
314  }
315  }
316 
317  //Not a LM
318  if(!greaterEqual){
319  return false;
320  }
321  return true;
322 }
323 
324 bool LVL1::jFEXForwardJetsAlgo::isLMabove(unsigned int TTID){
325 
326  // Exists the jTower in the correction tower map?
327  auto it_seed_map = m_CorrMap.find(TTID);
328  if(it_seed_map == m_CorrMap.end()) {
329  ATH_MSG_ERROR("Could not find TT" << TTID << " in the correction (LM above) for jets file.");
330  return false;
331  }
332 
333  // If there is not Trigger tower to correct with, then return false
334  const auto & GttVec = it_seed_map->second;
335  if (! GttVec.empty()) return isLM(GttVec.front());
336  return false;
337 }
338 
339 unsigned int LVL1::jFEXForwardJetsAlgo::elementsCorr(unsigned int TTID){
340  auto it_seed_map = m_CorrMap.find(TTID);
341  if(it_seed_map == m_CorrMap.end()) {
342  ATH_MSG_ERROR("Could not find TT" << TTID << " in the condition (greater than) for jets file.");
343  return 0;
344  }
345 
346  return (it_seed_map->second).size();
347 }
348 
349 bool LVL1::jFEXForwardJetsAlgo::condCorr(unsigned int TTID){
350 
351  // Exists the jTower in the correction tower map?
352  auto it_seed_map = m_CorrMap.find(TTID);
353  if(it_seed_map == m_CorrMap.end()) {
354  ATH_MSG_ERROR("Could not find TT" << TTID << " in the condition (greater than) for jets file.");
355  return false;
356  }
357 
358  // If there is no TT to check then the Et of central is always bigger :D
359  if( (it_seed_map->second).size() == 0){
360  ATH_MSG_ERROR("Elements=0 in condCorr function for element"<< TTID <<". This should never happend. REPORT IT!");
361  return true;
362  }
363 
364  int centralEt = getEt(TTID);
365  int centralSeed = SumEtSeed(TTID);
366  for (const auto& Gtt : it_seed_map->second ){
367  //Checking if central Et is always strictly greater than the previous TT Et
368  int tmpEt = getEt(Gtt);
369  int tmpSeedEt = SumEtSeed(Gtt);
370  if( !(centralEt > tmpEt && centralSeed >= tmpSeedEt ) ){
371  return false;
372  }
373  }
374 
375  return true;
376 
377 }
378 
379 unsigned int LVL1::jFEXForwardJetsAlgo::elementsCorr2(unsigned int TTID){
380  auto it_seed_map = m_Corr2Map.find(TTID);
381  if(it_seed_map == m_Corr2Map.end()) {
382  ATH_MSG_ERROR("Could not find TT" << TTID << " in the condition (greater than) for jets file.");
383  return 0;
384  }
385 
386  return (it_seed_map->second).size();
387 }
388 
389 bool LVL1::jFEXForwardJetsAlgo::condCorr2(unsigned int TTID){
390 
391  // Exists the jTower in the correction tower map?
392  auto it_seed_map = m_Corr2Map.find(TTID);
393  if(it_seed_map == m_Corr2Map.end()) {
394  ATH_MSG_ERROR("Could not find TT" << TTID << " in the correction (greater or equal) file.");
395  return false;
396  }
397 
398  int centralEt = getEt(TTID);
399  int centralSeed = SumEtSeed(TTID);
400 
401  for (const auto& Gtt : it_seed_map->second ){
402  //Checking if central Et is always greater or equal than the previous TT Et
403  int tmpEt = getEt(Gtt);
404 
405  //(central >= 1stElem or seedcentral > seed1stElem) and ( central >= 2stElem or seedcentral > seed2stElem)
406  if( !( centralEt >= tmpEt || centralSeed > SumEtSeed(Gtt) ) ){
407  return false;
408  }
409  }
410 
411  return true;
412 
413 }
414 
415 std::unordered_map<int, jFEXForwardJetsInfo> LVL1::jFEXForwardJetsAlgo::calculateJetETs(int seedThreshold) {
416 
417  std::unordered_map<int, jFEXForwardJetsInfo> localMaximas = FcalJetsTowerIDLists(seedThreshold);
418  return localMaximas;
419 }
420 
421 
422 void LVL1::jFEXForwardJetsAlgo::setFPGAEnergy(std::unordered_map<int,std::vector<int> > et_map){
423  m_map_Etvalues=std::move(et_map);
424 }
425 
426 //getter for tower saturation
427 bool LVL1::jFEXForwardJetsAlgo::getTTowerSat(unsigned int TTID ) {
428  if(TTID == 0) {
429  return false;
430  }
431 
432  const LVL1::jTower * tmpTower = m_jTowerContainer->findTower(TTID);
433  return tmpTower->getTowerSat();
434 }
435 
436 StatusCode LVL1::jFEXForwardJetsAlgo::ReadfromFile(const std::string & fileName, std::unordered_map<unsigned int, std::vector<unsigned int> >& fillingMap){
437 
438  std::string myline;
439 
440  //opening file with ifstream
441  std::ifstream myfile(fileName);
442 
443  if ( !myfile.is_open() ){
444  ATH_MSG_ERROR("Could not open file:" << fileName);
445  return StatusCode::FAILURE;
446  }
447 
448  //loading the mapping information
449  while ( std::getline (myfile, myline) ) {
450 
451  //removing the header of the file (it is just information!)
452  if(myline[0] == '#') continue;
453 
454  //Splitting myline in different substrings
455  std::stringstream oneLine(myline);
456 
457  //reading elements
458  std::vector<unsigned int> elements;
459  std::string element;
460  while(std::getline(oneLine, element, ' '))
461  {
462  elements.push_back(std::stoi(element));
463  }
464 
465  // We should have at least two elements! Central TT and (at least) itself
466  if(elements.size() < 1){
467  ATH_MSG_ERROR("Unexpected number of elemennts (<1 expected) in file: "<< fileName);
468  return StatusCode::FAILURE;
469  }
470 
471  //Central TiggerTower
472  unsigned int TTID = elements.at(0);
473 
474  // rest of TTs that need to be checked
475  elements.erase(elements.begin());
476 
477  fillingMap[TTID] = std::move(elements);
478 
479  }
480  myfile.close();
481 
482  return StatusCode::SUCCESS;
483 }
484 
485 
486 
487 }// end of namespace LVL1
488 
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_start_phi
constexpr static int jFEX_algoSpace_EMB_start_phi
Definition: FEXAlgoSpaceDefs.h:89
LVL1::jFEXForwardJetsAlgo::getTTowerSat
bool getTTowerSat(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:427
PathResolver::find_calib_file
static std::string find_calib_file(const std::string &logical_file_name)
Definition: PathResolver.cxx:384
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_start_phi
constexpr static int jFEX_algoSpace_EMIE_start_phi
Definition: FEXAlgoSpaceDefs.h:91
LVL1::jFEXForwardJetsAlgo::jFEXForwardJetsAlgo
jFEXForwardJetsAlgo(const std::string &type, const std::string &name, const IInterface *parent)
Constructors.
Definition: jFEXForwardJetsAlgo.cxx:30
LVL1::jFEXForwardJetsAlgo::isLM
bool isLM(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:274
LVL1::jFEXForwardJetsAlgo::setup
virtual void setup(int inputTable[FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width], int jfex) override
Definition: jFEXForwardJetsAlgo.cxx:72
LVL1::jFEXForwardJetsAlgo::setFPGAEnergy
virtual void setFPGAEnergy(std::unordered_map< int, std::vector< int > > et_map) override
Definition: jFEXForwardJetsAlgo.cxx:422
LVL1::jFEXForwardJetsInfo::includeTTIDinSecondER
void includeTTIDinSecondER(int secondER_TTID)
Definition: jFEXForwardJetsInfo.cxx:102
LVL1::jFEXForwardJetsInfo::setCentreTTPhi
void setCentreTTPhi(float centreTTPhi)
Definition: jFEXForwardJetsInfo.cxx:35
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMIE_end_eta
constexpr static int jFEX_algoSpace_C_EMIE_end_eta
Definition: FEXAlgoSpaceDefs.h:66
LVL1::jFEXForwardJetsAlgo::getEt
int getEt(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:88
LVL1::jTower::centrephi_toPI
float centrephi_toPI() const
Definition: jTower.h:85
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_FCAL_end_eta
constexpr static int jFEX_algoSpace_C_FCAL_end_eta
Definition: FEXAlgoSpaceDefs.h:68
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_FCAL_end_eta
constexpr static int jFEX_algoSpace_A_FCAL_end_eta
Definition: FEXAlgoSpaceDefs.h:48
LVL1::jFEXForwardJetsAlgo::SumEtSeed
virtual int SumEtSeed(unsigned int TTID) override
Definition: jFEXForwardJetsAlgo.cxx:258
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMB_start_eta
constexpr static int jFEX_algoSpace_C_EMB_start_eta
Definition: FEXAlgoSpaceDefs.h:63
jFEXForwardJetsAlgo.h
LVL1::jFEXForwardJetsInfo::setSRjetSat
void setSRjetSat()
Definition: jFEXForwardJetsInfo.h:37
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_height
constexpr static int jFEX_algoSpace_height
Definition: FEXAlgoSpaceDefs.h:27
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_end_phi
constexpr static int jFEX_algoSpace_EMB_end_phi
Definition: FEXAlgoSpaceDefs.h:90
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_lowerEM_eta
constexpr static int jFEX_algoSpace_A_lowerEM_eta
Definition: FEXAlgoSpaceDefs.h:51
LVL1::jFEXForwardJetsAlgo::ReadfromFile
StatusCode ReadfromFile(const std::string &, std::unordered_map< unsigned int, std::vector< unsigned int > > &)
Definition: jFEXForwardJetsAlgo.cxx:436
LVL1::jFEXForwardJetsInfo::includeTTIDinFirstER
void includeTTIDinFirstER(int firstER_TTID)
Definition: jFEXForwardJetsInfo.cxx:93
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_FCAL_start_eta
constexpr static int jFEX_algoSpace_C_FCAL_start_eta
Definition: FEXAlgoSpaceDefs.h:67
LVL1::jTower::centreEta
float centreEta() const
Definition: jTower.h:83
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_EMB_eta
constexpr static int jFEX_algoSpace_A_EMB_eta
Definition: FEXAlgoSpaceDefs.h:45
LVL1::jFEXForwardJetsInfo
Definition: jFEXForwardJetsInfo.h:25
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
CxxUtils::fpcompare::greater
bool greater(double a, double b)
Compare two FP numbers, working around x87 precision issues.
Definition: fpcompare.h:140
LVL1::jFEXForwardJetsAlgo::isLMabove
bool isLMabove(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:324
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_lowerEM_eta
constexpr static int jFEX_algoSpace_C_lowerEM_eta
Definition: FEXAlgoSpaceDefs.h:71
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_end_phi
constexpr static int jFEX_algoSpace_EMIE_end_phi
Definition: FEXAlgoSpaceDefs.h:92
LVL1::jTower::getTowerSat
bool getTowerSat() const
Definition: jTower.h:65
AthAlgorithm.h
LVL1::jFEXForwardJetsInfo::addToFirstEnergyRingET
void addToFirstEnergyRingET(int firstER_ET)
Definition: jFEXForwardJetsInfo.cxx:84
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_upperEM_eta
constexpr static int jFEX_algoSpace_C_upperEM_eta
Definition: FEXAlgoSpaceDefs.h:72
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMIE_start_eta
constexpr static int jFEX_algoSpace_C_EMIE_start_eta
Definition: FEXAlgoSpaceDefs.h:65
LVL1::jFEXForwardJetsAlgo::globalEtaPhi
std::array< float, 2 > globalEtaPhi(int TTID)
Definition: jFEXForwardJetsAlgo.cxx:79
LVL1::jFEXForwardJetsAlgo::initialize
virtual StatusCode initialize() override
standard Athena-Algorithm method
Definition: jFEXForwardJetsAlgo.cxx:40
FortranAlgorithmOptions.fileName
fileName
Definition: FortranAlgorithmOptions.py:13
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LVL1::jFEXForwardJetsAlgo::~jFEXForwardJetsAlgo
virtual ~jFEXForwardJetsAlgo()
Destructor.
Definition: jFEXForwardJetsAlgo.cxx:37
LVL1::jFEXForwardJetsAlgo::elementsCorr2
unsigned int elementsCorr2(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:379
LVL1::jFEXForwardJetsAlgo::FcalJetsTowerIDLists
virtual std::unordered_map< int, jFEXForwardJetsInfo > FcalJetsTowerIDLists(int seedThreshold) override
Definition: jFEXForwardJetsAlgo.cxx:102
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LVL1::jFEXForwardJetsAlgo::safetyTest
virtual StatusCode safetyTest() override
Definition: jFEXForwardJetsAlgo.cxx:57
LVL1::FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width
constexpr static int jFEX_wide_algoSpace_width
Definition: FEXAlgoSpaceDefs.h:25
LVL1::jFEXForwardJetsInfo::setCentreLocalTTPhi
void setCentreLocalTTPhi(float centreLocalTTPhi)
Definition: jFEXForwardJetsInfo.cxx:54
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMB_end_eta
constexpr static int jFEX_algoSpace_C_EMB_end_eta
Definition: FEXAlgoSpaceDefs.h:64
test_pyathena.parent
parent
Definition: test_pyathena.py:15
CaloCell_SuperCell_ID.h
Helper class for offline supercell identifiers.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LVL1::jFEXForwardJetsInfo::includeTTinSeed
void includeTTinSeed(int TT_ID)
Definition: jFEXForwardJetsInfo.cxx:64
FEXAlgoSpaceDefs.h
LVL1::jFEXForwardJetsInfo::addToSeedET
void addToSeedET(int seed_ET)
Definition: jFEXForwardJetsInfo.cxx:74
TrigConf::name
Definition: HLTChainList.h:35
LVL1::jFEXForwardJetsInfo::setCentreTTEta
void setCentreTTEta(float centreTTEta)
Definition: jFEXForwardJetsInfo.cxx:25
jTowerContainer.h
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_end_phi
constexpr static int jFEX_algoSpace_FCAL_end_phi
Definition: FEXAlgoSpaceDefs.h:94
jFEXForwardJetsInfo.h
LVL1::jFEXForwardJetsAlgo::condCorr
bool condCorr(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:349
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_FCAL_start_eta
constexpr static int jFEX_algoSpace_A_FCAL_start_eta
Definition: FEXAlgoSpaceDefs.h:47
LVL1::jFEXForwardJetsInfo::setCentreLocalTTEta
void setCentreLocalTTEta(float centreLocalTTEta)
Definition: jFEXForwardJetsInfo.cxx:44
CaloCellContainer.h
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_EMIE_eta
constexpr static int jFEX_algoSpace_A_EMIE_eta
Definition: FEXAlgoSpaceDefs.h:46
LVL1::jFEXForwardJetsAlgo::reset
virtual StatusCode reset() override
Definition: jFEXForwardJetsAlgo.cxx:68
LVL1::jFEXForwardJetsAlgo::calculateJetETs
virtual std::unordered_map< int, jFEXForwardJetsInfo > calculateJetETs(int seedThreshold) override
Definition: jFEXForwardJetsAlgo.cxx:415
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::jFEXForwardJetsInfo::setLRjetSat
void setLRjetSat()
Definition: jFEXForwardJetsInfo.h:38
LVL1::jTower
The jTower class is an interface object for jFEX trigger algorithms The purposes are twofold:
Definition: jTower.h:40
CaloIdManager.h
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_A_upperEM_eta
constexpr static int jFEX_algoSpace_A_upperEM_eta
Definition: FEXAlgoSpaceDefs.h:52
LVL1::jFEXForwardJetsAlgo::elementsCorr
unsigned int elementsCorr(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:339
calibdata.copy
bool copy
Definition: calibdata.py:27
LVL1::jFEXForwardJetsAlgo::condCorr2
bool condCorr2(unsigned int TTID)
Definition: jFEXForwardJetsAlgo.cxx:389
AthAlgTool
Definition: AthAlgTool.h:26
jTower.h
StoreGateSvc.h
LVL1::jFEXForwardJetsInfo::addToSecondEnergyRingET
void addToSecondEnergyRingET(int secondER_ET)
Definition: jFEXForwardJetsInfo.cxx:111
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_start_phi
constexpr static int jFEX_algoSpace_FCAL_start_phi
Definition: FEXAlgoSpaceDefs.h:93