Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
LVL1::L1EnergyCMXTools Class Reference

#include <L1EnergyCMXTools.h>

Inheritance diagram for LVL1::L1EnergyCMXTools:
Collaboration diagram for LVL1::L1EnergyCMXTools:

Public Member Functions

 L1EnergyCMXTools (const std::string &type, const std::string &name, const IInterface *parent)
 Constructor. More...
 
virtual ~L1EnergyCMXTools ()
 default destructor More...
 
virtual StatusCode initialize ()
 standard Athena-Algorithm method More...
 
virtual StatusCode finalize ()
 standard Athena-Algorithm method More...
 
virtual void formJEMEtSums (const xAOD::JetElementContainer *jetElementVec, xAOD::JEMEtSumsContainer *jemEtSumsVec) const
 form JEMEtSums from JetElements More...
 
virtual void formCMXEtSums (const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec) const
 form complete CMXEtSums from JEMEtSums More...
 
virtual void formCMXEtSumsModule (const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
 form partial CMXEtSums (module) from JEMEtSums More...
 
virtual void formCMXEtSumsCrate (const xAOD::CMXEtSumsContainer *cmxEtSumsMod, xAOD::CMXEtSumsContainer *cmxEtSumsCrate) const
 form partial CMXEtSums (crate) from module CMXEtSums More...
 
virtual void formCMXEtSumsSystem (const xAOD::CMXEtSumsContainer *cmxEtSumsCrate, xAOD::CMXEtSumsContainer *cmxEtSumsSys) const
 form partial CMXEtSums (system) from crate CMXEtSums More...
 
virtual void formCMXEtSumsEtMaps (const xAOD::CMXEtSumsContainer *cmxEtSumsSys, xAOD::CMXEtSumsContainer *cmxEtSumsMap) const
 form partial CMXEtSums (sumEt/missingEt maps) from system CMXEtSums More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef std::vector< uint16_t > EnergyVector
 
typedef std::vector< uint32_t > ErrorVector
 
typedef std::vector< DataVector< ModuleEnergy > * > MultiSliceModuleEnergy
 
typedef std::vector< DataVector< CrateEnergy > * > MultiSliceCrateEnergy
 
typedef std::vector< SystemEnergy * > MultiSliceSystemEnergy
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void etSumsToModuleEnergy (const xAOD::CMXEtSumsContainer *etSums, MultiSliceModuleEnergy &modulesVec, int &peak) const
 Convert CMXEtSums container to internal ModuleEnergy containers. More...
 
void etSumsToCrateEnergy (const xAOD::CMXEtSumsContainer *etSums, MultiSliceCrateEnergy &crateVecFull, MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
 Convert CMXEtSums container to internal CrateEnergy containers. More...
 
void etSumsToSystemEnergy (const xAOD::CMXEtSumsContainer *etSums, MultiSliceSystemEnergy &systemVec, int &peak) const
 Convert CMXEtSums container to internal SystemEnergy objects. More...
 
void moduleEnergyToEtSums (const MultiSliceModuleEnergy &modulesVec, xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
 Convert internal ModuleEnergy containers to JEMEtSums container. More...
 
void crateEnergyToEtSums (const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
 Convert internal CrateEnergy containers to CMXEtSums container. More...
 
void crateEnergyToEtSums (const MultiSliceCrateEnergy &cratesVecFull, const MultiSliceCrateEnergy &cratesVecRestricted, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
 
void systemEnergyToEtSums (const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak, xAOD::CMXEtSums_v1::Sources source=xAOD::CMXEtSums::TOTAL_STANDARD) const
 Convert internal SystemEnergy objects to CMXEtSums object. More...
 
void etMapsToEtSums (const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
 Convert maps from internal SystemEnergy objects to CMXEtSums objects. More...
 
void findRestrictedEta (uint32_t &maskXE, uint32_t &maskTE) const
 form partial CMXEtSums (crate) from module CMXEtSums More...
 
void dumpCrateEnergies (const std::string &msg, const MultiSliceCrateEnergy &crates) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
 
ToolHandle< LVL1::IL1JetElementTools > m_jeTool
 Tool for JetElement map. More...
 
ToolHandle< LVL1::IL1EtTools > m_etTool
 Tool for energy sums. More...
 
bool m_debug = false
 Debug flag. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

This is a tool to reconstruct the L1 JEM and CMX-Energy Et sums from Jet Elements. Used for offline monitoring and trigger reconstruction.

Useage: L1EnergyCMXTools->formJEMEtSums() // Form JEMEtSums from JetElements L1EnergyCMXTools->formCMXEtSums() // Form CMXEtSums from JEMEtSums 

  @author  Peter Faulkner

Definition at line 50 of file L1EnergyCMXTools.h.

Member Typedef Documentation

◆ EnergyVector

typedef std::vector<uint16_t> LVL1::L1EnergyCMXTools::EnergyVector
private

Definition at line 86 of file L1EnergyCMXTools.h.

◆ ErrorVector

typedef std::vector<uint32_t> LVL1::L1EnergyCMXTools::ErrorVector
private

Definition at line 87 of file L1EnergyCMXTools.h.

◆ MultiSliceCrateEnergy

typedef std::vector<DataVector<CrateEnergy> *> LVL1::L1EnergyCMXTools::MultiSliceCrateEnergy
private

Definition at line 89 of file L1EnergyCMXTools.h.

◆ MultiSliceModuleEnergy

typedef std::vector<DataVector<ModuleEnergy> *> LVL1::L1EnergyCMXTools::MultiSliceModuleEnergy
private

Definition at line 88 of file L1EnergyCMXTools.h.

◆ MultiSliceSystemEnergy

typedef std::vector<SystemEnergy *> LVL1::L1EnergyCMXTools::MultiSliceSystemEnergy
private

Definition at line 90 of file L1EnergyCMXTools.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ L1EnergyCMXTools()

LVL1::L1EnergyCMXTools::L1EnergyCMXTools ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Constructor.

Definition at line 25 of file L1EnergyCMXTools.cxx.

28  : AthAlgTool(type, name, parent),
29  m_jeTool("LVL1::L1JetElementTools/L1JetElementTools"),
30  m_etTool("LVL1::L1EtTools/L1EtTools")
31 {
32  declareInterface<IL1EnergyCMXTools>(this);
33  declareProperty("JetElementTool", m_jeTool);
34  declareProperty("EtTool", m_etTool);
35 }

◆ ~L1EnergyCMXTools()

LVL1::L1EnergyCMXTools::~L1EnergyCMXTools ( )
virtual

default destructor

Destructor.

Definition at line 39 of file L1EnergyCMXTools.cxx.

40 {
41 }

Member Function Documentation

◆ crateEnergyToEtSums() [1/2]

void LVL1::L1EnergyCMXTools::crateEnergyToEtSums ( const MultiSliceCrateEnergy &  cratesVec,
xAOD::CMXEtSumsContainer *  cmxEtSumsVec,
int  peak 
) const
private

Convert internal CrateEnergy containers to CMXEtSums container.

Definition at line 528 of file L1EnergyCMXTools.cxx.

531 {
532  std::map<int, xAOD::CMXEtSums *> etMap;
533  unsigned int nslices = cratesVec.size();
534  std::vector<uint16_t> dummy(nslices);
535  std::vector<uint32_t> error(nslices);
536  for (unsigned int slice = 0; slice < nslices; ++slice)
537  {
538  const DataVector<CrateEnergy> *crates = cratesVec[slice];
539  DataVector<CrateEnergy>::const_iterator pos = crates->begin();
540  DataVector<CrateEnergy>::const_iterator pose = crates->end();
541  for (; pos != pose; ++pos)
542  {
543  const CrateEnergy *energy = *pos;
544  unsigned int ex = energy->exTC();
545  unsigned int ey = energy->eyTC();
546  unsigned int et = energy->et();
547  int exOverflow = energy->exOverflow();
548  int eyOverflow = energy->eyOverflow();
549  int etOverflow = energy->etOverflow();
550  if (ex == 0 && ey == 0 && et == 0 &&
551  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
552  continue;
553  int crate = energy->crate();
554  xAOD::CMXEtSums *sums = 0;
555  int source = xAOD::CMXEtSums::LOCAL_STANDARD;
556  for (int i = 0; i < 2; ++i)
557  {
558  for (int j = 0; j < 2; ++j)
559  {
560  int key = crate * 100 + source;
561  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
562  if (iter == etMap.end())
563  {
564  sums = new xAOD::CMXEtSums;
565  sums->makePrivateStore();
566  sums->initialize(crate, source, dummy, dummy, dummy,
567  error, error, error, peak);
568  etMap.insert(std::make_pair(key, sums));
569  cmxEtSumsVec->push_back(sums);
570  }
571  else
572  sums = iter->second;
573  std::vector<uint16_t> exVec(sums->exVec());
574  std::vector<uint16_t> eyVec(sums->eyVec());
575  std::vector<uint16_t> etVec(sums->etVec());
576  std::vector<uint32_t> exErr(sums->exErrorVec());
577  std::vector<uint32_t> eyErr(sums->eyErrorVec());
578  std::vector<uint32_t> etErr(sums->etErrorVec());
579  exVec[slice] = ex;
580  eyVec[slice] = ey;
581  etVec[slice] = et;
582  if (exOverflow)
583  {
584  DataError dEx(exErr[slice]);
585  dEx.set(DataError::Overflow);
586  exErr[slice] = dEx.error();
587  }
588  if (eyOverflow)
589  {
590  DataError dEy(eyErr[slice]);
591  dEy.set(DataError::Overflow);
592  eyErr[slice] = dEy.error();
593  }
594  if (etOverflow)
595  {
596  DataError dEt(etErr[slice]);
597  dEt.set(DataError::Overflow);
598  etErr[slice] = dEt.error();
599  }
600  sums->addEx(exVec, exErr);
601  sums->addEy(eyVec, eyErr);
602  sums->addEt(etVec, etErr);
603  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
604  {
605  source = xAOD::CMXEtSums::LOCAL_RESTRICTED;
606  }
607  else
608  {
609  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
610  }
611  }
612  if (crate == 1)
613  break;
614  crate = 1;
615  source = xAOD::CMXEtSums::REMOTE_STANDARD;
616  }
617  }
618  }
619 }

◆ crateEnergyToEtSums() [2/2]

void LVL1::L1EnergyCMXTools::crateEnergyToEtSums ( const MultiSliceCrateEnergy &  cratesVecFull,
const MultiSliceCrateEnergy &  cratesVecRestricted,
xAOD::CMXEtSumsContainer *  cmxEtSumsVec,
int  peak 
) const
private

Definition at line 621 of file L1EnergyCMXTools.cxx.

624 {
625  std::map<int, xAOD::CMXEtSums *> etMap;
626  unsigned int nslices = cratesVecFull.size();
627  std::vector<uint16_t> dummy(nslices);
628  std::vector<uint32_t> error(nslices);
629 
630  dumpCrateEnergies("Crates from full region", cratesVecFull);
631  dumpCrateEnergies("Crates from restricted region", cratesVecRestricted);
632 
633 
634  for (unsigned int slice = 0; slice < nslices; ++slice)
635  {
636  for (unsigned int i = 0; i < 2; i++)
637  {
638  const auto *crates = (i == 0 ? cratesVecFull[slice] : cratesVecRestricted[slice]);
639  int origSource = i == 0 ? xAOD::CMXEtSums::LOCAL_STANDARD : xAOD::CMXEtSums::LOCAL_RESTRICTED;
640 
641  for (auto pos : *crates)
642  {
643  int source = origSource;
644  const CrateEnergy *energy = pos;
645  unsigned int ex = energy->exTC();
646  unsigned int ey = energy->eyTC();
647  unsigned int et = energy->et();
648  int exOverflow = energy->exOverflow();
649  int eyOverflow = energy->eyOverflow();
650  int etOverflow = energy->etOverflow();
651  if (ex == 0 && ey == 0 && et == 0 &&
652  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
653  continue;
654  int crate = energy->crate();
655  xAOD::CMXEtSums *sums = 0;
656 
657  while (true)
658  {
659  int key = crate * 100 + source;
660  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
661  if (iter == etMap.end())
662  {
663  sums = new xAOD::CMXEtSums;
664  sums->makePrivateStore();
665  sums->initialize(crate, source, dummy, dummy, dummy,
666  error, error, error, peak);
667  etMap.insert(std::make_pair(key, sums));
668  cmxEtSumsVec->push_back(sums);
669  }
670  else
671  sums = iter->second;
672  std::vector<uint16_t> exVec(sums->exVec());
673  std::vector<uint16_t> eyVec(sums->eyVec());
674  std::vector<uint16_t> etVec(sums->etVec());
675  std::vector<uint32_t> exErr(sums->exErrorVec());
676  std::vector<uint32_t> eyErr(sums->eyErrorVec());
677  std::vector<uint32_t> etErr(sums->etErrorVec());
678  exVec[slice] = ex;
679  eyVec[slice] = ey;
680  etVec[slice] = et;
681  if (exOverflow)
682  {
683  DataError dEx(exErr[slice]);
684  dEx.set(DataError::Overflow);
685  exErr[slice] = dEx.error();
686  }
687  if (eyOverflow)
688  {
689  DataError dEy(eyErr[slice]);
690  dEy.set(DataError::Overflow);
691  eyErr[slice] = dEy.error();
692  }
693  if (etOverflow)
694  {
695  DataError dEt(etErr[slice]);
696  dEt.set(DataError::Overflow);
697  etErr[slice] = dEt.error();
698  }
699  sums->addEx(exVec, exErr);
700  sums->addEy(eyVec, eyErr);
701  sums->addEt(etVec, etErr);
702  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
703  {
704  if (crate == 1)
705  {
706  break;
707  }
708  else
709  {
710  crate = 1;
711  source = xAOD::CMXEtSums::REMOTE_STANDARD;
712  }
713  }
714  else if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED)
715  {
716  if (crate == 1)
717  {
718  break;
719  }
720  else
721  {
722  crate = 1;
723  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
724  }
725  }
726  else
727  {
728  break;
729  }
730  }
731  } // crates
732  } //for i
733  }
734 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ dumpCrateEnergies()

void LVL1::L1EnergyCMXTools::dumpCrateEnergies ( const std::string &  msg,
const MultiSliceCrateEnergy &  crates 
) const
private

Definition at line 942 of file L1EnergyCMXTools.cxx.

943  {
944  if (!m_debug) return;
945 
946  ATH_MSG_DEBUG(msg);
947  for (const auto& p : crates) {
948  for (const LVL1::CrateEnergy* c : *p) {
949  ATH_MSG_DEBUG(" CrateEnergy: crate " << c->crate() << " results ");
950  ATH_MSG_DEBUG(" Et " << c->et() << " overflow " << c->etOverflow());
951  ATH_MSG_DEBUG(" Ex " << c->ex() << " overflow " << c->exOverflow());
952  ATH_MSG_DEBUG(" Ey " << c->ey() << " overflow "<< c->eyOverflow());
953  }
954  ATH_MSG_DEBUG("");
955  }
956 }

◆ etMapsToEtSums()

void LVL1::L1EnergyCMXTools::etMapsToEtSums ( const MultiSliceSystemEnergy &  systemVec,
xAOD::CMXEtSumsContainer *  cmxEtSumsVec,
int  peak 
) const
private

Convert maps from internal SystemEnergy objects to CMXEtSums objects.

Definition at line 806 of file L1EnergyCMXTools.cxx.

809 {
810 
811  xAOD::CMXEtSums **sumEt = 0;
812  xAOD::CMXEtSums **missEt = 0;
813  xAOD::CMXEtSums **missEtSig = 0;
814 
815  xAOD::CMXEtSums *sumEtFull = 0;
816  xAOD::CMXEtSums *missEtFull = 0;
817  xAOD::CMXEtSums *missEtSigFull = 0;
818 
819  xAOD::CMXEtSums *sumEtRestricted = 0;
820  xAOD::CMXEtSums *missEtRestricted = 0;
821  xAOD::CMXEtSums *missEtSigRestricted = 0;
822 
823  int nslicesFull = 0;
824  int nslicesRestricted = 0;
825 
826  std::map<int, bool> isRestrictedMap;
827 
828 
829  for (unsigned int i = 0; i < systemVec.size(); ++i)
830  {
831  bool isRestricted = (systemVec[i]->roiWord0() >> 26) & 1;
832  isRestrictedMap[i] = isRestricted;
833  if (isRestricted) {
834  nslicesRestricted++;
835  }else{
836  nslicesFull++;
837  }
838  // ATH_MSG_DEBUG("isRestriced=" << isRestricted << " slice=" << (isRestricted? nslicesRestricted: nslicesFull)
839  // << " et=" << systemVec[i]->et() << " etSumHits=" << systemVec[i]->etSumHits());
840  }
841 
842  std::vector<uint16_t> dataFull(nslicesFull);
843  std::vector<uint32_t> errorFull(nslicesFull);
844 
845  std::vector<uint16_t> dataRestricted(nslicesRestricted);
846  std::vector<uint32_t> errorRestricted(nslicesRestricted);
847 
848  int iSliceFull = 0;
849  int iSliceRestricted = 0;
850  int *iSlice = 0;
851 
852  for (unsigned int i = 0; i < systemVec.size(); ++i)
853  {
854  SystemEnergy *energy = systemVec[i];
855  bool restricted = isRestrictedMap[i];
856 
857  std::vector<uint16_t>* data;
858  std::vector<uint32_t>* error;
859  if (restricted)
860  {
861  sumEt = &sumEtRestricted;
862  missEt = &missEtRestricted;
863  missEtSig = &missEtSigRestricted;
864  iSlice = &iSliceRestricted;
865  data = &dataRestricted;
866  error = &errorRestricted;
867  }
868  else
869  {
870  sumEt = &sumEtFull;
871  missEt = &missEtFull;
872  missEtSig = &missEtSigFull;
873  iSlice = &iSliceFull;
874  data = &dataFull;
875  error = &errorFull;
876  }
877 
878  unsigned int slice = *iSlice;
879 
880 
881  unsigned int etSumHits = energy->etSumHits();
882  if (etSumHits)
883  {
884  if (!*sumEt)
885  {
886  *sumEt = new xAOD::CMXEtSums;
887  (*sumEt)->makePrivateStore();
888  (*sumEt)->initialize(1, restricted
889  ? CMXEtSums::SUM_ET_RESTRICTED
890  : CMXEtSums::SUM_ET_STANDARD,
891  *data, *data, *data, *error, *error, *error, peak);
892  cmxEtSumsVec->push_back(*sumEt);
893  }
894  std::vector<uint16_t> etVec((*sumEt)->etVec());
895  etVec[slice] = etSumHits;
896 
897  (*sumEt)->addEx(etVec, *error);
898  (*sumEt)->addEy(etVec, *error);
899  (*sumEt)->addEt(etVec, *error);
900 
901  // ATH_MSG_DEBUG("slice=" << slice << " restricted=" << restricted << " etVec=" << (*sumEt)->etVec() << " etSumHits=" << etSumHits);
902  }
903  unsigned int etMissHits = energy->etMissHits();
904  if (etMissHits)
905  {
906  if (!*missEt)
907  {
908  *missEt = new xAOD::CMXEtSums;
909  (*missEt)->makePrivateStore();
910  (*missEt)->initialize(1, restricted
911  ? CMXEtSums::MISSING_ET_RESTRICTED
912  : CMXEtSums::MISSING_ET_STANDARD,
913  *data, *data, *data, *error, *error, *error, peak);
914  cmxEtSumsVec->push_back(*missEt);
915  }
916  std::vector<uint16_t> etVec((*missEt)->etVec());
917  etVec[slice] = etMissHits;
918  (*missEt)->addEx(etVec, *error);
919  (*missEt)->addEy(etVec, *error);
920  (*missEt)->addEt(etVec, *error);
921  }
922  unsigned int etMissSigHits = energy->metSigHits();
923  if (etMissSigHits)
924  {
925  if (!*missEtSig)
926  {
927  *missEtSig = new xAOD::CMXEtSums;
928  (*missEtSig)->makePrivateStore();
929  (*missEtSig)->initialize(1, CMXEtSums::MISSING_ET_SIG_STANDARD, *data, *data, *data, *error, *error, *error, peak);
930  cmxEtSumsVec->push_back(*missEtSig);
931  }
932  std::vector<uint16_t> etVec((*missEtSig)->etVec());
933  etVec[slice] = etMissSigHits;
934  (*missEtSig)->addEx(etVec, *error);
935  (*missEtSig)->addEy(etVec, *error);
936  (*missEtSig)->addEt(etVec, *error);
937  }
938  (*iSlice)++;
939  }
940 }

◆ etSumsToCrateEnergy()

void LVL1::L1EnergyCMXTools::etSumsToCrateEnergy ( const xAOD::CMXEtSumsContainer *  etSums,
MultiSliceCrateEnergy &  crateVecFull,
MultiSliceCrateEnergy &  crateVecRestricted,
int &  peak 
) const
private

Convert CMXEtSums container to internal CrateEnergy containers.

Definition at line 362 of file L1EnergyCMXTools.cxx.

365 {
366  peak = 0;
367  unsigned int nslicesFull = 0;
368  unsigned int nslicesRestricted = 0;
369  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
370  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
371 
372  MultiSliceCrateEnergy *crateVec = nullptr;
373  unsigned int *nslices = nullptr;
374  bool restricted = false;
375  for (; pos != pose; ++pos)
376  {
377  const xAOD::CMXEtSums *sums = *pos;
378  int crate = sums->crate();
379  if (crate != 1)
380  continue;
381  int source = sums->sourceComponent();
382  if (source != xAOD::CMXEtSums::LOCAL_STANDARD && source != xAOD::CMXEtSums::LOCAL_RESTRICTED
383  && source != xAOD::CMXEtSums::REMOTE_STANDARD && source != xAOD::CMXEtSums::REMOTE_RESTRICTED)
384  continue;
385  if (source == xAOD::CMXEtSums::REMOTE_STANDARD || source == xAOD::CMXEtSums::REMOTE_RESTRICTED)
386  crate = 0; // SASHA: check
387  if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED || source == xAOD::CMXEtSums::REMOTE_RESTRICTED){
388  crateVec = &crateVecRestricted;
389  nslices = &nslicesRestricted;
390  restricted = true;
391  }else{
392  crateVec = &crateVecFull;
393  nslices = &nslicesFull;
394  restricted = false;
395  }
396  if (sums->peak() > peak)
397  peak = sums->peak();
398  const EnergyVector &ex(sums->exVec());
399  const EnergyVector &ey(sums->eyVec());
400  const EnergyVector &et(sums->etVec());
401  const ErrorVector &exErrVec(sums->exErrorVec());
402  const ErrorVector &eyErrVec(sums->eyErrorVec());
403  const ErrorVector &etErrVec(sums->etErrorVec());
404  unsigned int slices = et.size();
405 
406  if (slices > *nslices)
407  {
408  for (unsigned int i = *nslices; i < slices; ++i)
409  {
410  crateVec->push_back(new DataVector<CrateEnergy>);
411  }
412  *nslices = slices;
413  }
414  for (unsigned int sl = 0; sl < slices; ++sl)
415  {
416  DataVector<CrateEnergy> *crates = (*crateVec)[sl];
417  DataError exErr(exErrVec[sl]);
418  DataError eyErr(eyErrVec[sl]);
419  DataError etErr(etErrVec[sl]);
420  crates->push_back(new CrateEnergy(crate, et[sl], ex[sl], ey[sl],
421  etErr.get(DataError::Overflow),
422  exErr.get(DataError::Overflow),
423  eyErr.get(DataError::Overflow), restricted));
424  }
425  }
426 
427  dumpCrateEnergies("Crates from full region (for total)", crateVecFull);
428  dumpCrateEnergies("Crates from restricted region (for total)", crateVecRestricted);
429 }

◆ etSumsToModuleEnergy()

void LVL1::L1EnergyCMXTools::etSumsToModuleEnergy ( const xAOD::CMXEtSumsContainer *  etSums,
MultiSliceModuleEnergy &  modulesVec,
int &  peak 
) const
private

Convert CMXEtSums container to internal ModuleEnergy containers.

Definition at line 322 of file L1EnergyCMXTools.cxx.

325 {
326  peak = 0;
327  unsigned int nslices = 0;
328  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
329  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
330  for (; pos != pose; ++pos)
331  {
332  const xAOD::CMXEtSums *sums = *pos;
333  int source = sums->sourceComponent();
334  if (source > 15)
335  continue;
336  int crate = sums->crate();
337  if (sums->peak() > peak)
338  peak = sums->peak();
339  const EnergyVector &ex(sums->exVec());
340  const EnergyVector &ey(sums->eyVec());
341  const EnergyVector &et(sums->etVec());
342  unsigned int slices = et.size();
343  if (slices > nslices)
344  {
345  for (unsigned int i = nslices; i < slices; ++i)
346  {
347  modulesVec.push_back(new DataVector<ModuleEnergy>);
348  }
349  nslices = slices;
350  }
351  for (unsigned int sl = 0; sl < slices; ++sl)
352  {
353  DataVector<ModuleEnergy> *modules = modulesVec[sl];
354  modules->push_back(new ModuleEnergy(crate, source,
355  et[sl], ex[sl], ey[sl]));
356  }
357  }
358 }

◆ etSumsToSystemEnergy()

void LVL1::L1EnergyCMXTools::etSumsToSystemEnergy ( const xAOD::CMXEtSumsContainer *  etSums,
MultiSliceSystemEnergy &  systemVec,
int &  peak 
) const
private

Convert CMXEtSums container to internal SystemEnergy objects.

Definition at line 433 of file L1EnergyCMXTools.cxx.

436 {
437  peak = 0;
438  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
439  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
440  for (; pos != pose; ++pos)
441  {
442  const xAOD::CMXEtSums *sums = *pos;
443  int source = sums->sourceComponent();
444  if (source != xAOD::CMXEtSums::TOTAL_STANDARD && source != xAOD::CMXEtSums::TOTAL_RESTRICTED)
445  continue;
446  if (sums->peak() > peak)
447  peak = sums->peak();
448  const EnergyVector &ex(sums->exVec());
449  const EnergyVector &ey(sums->eyVec());
450  const EnergyVector &et(sums->etVec());
451  const ErrorVector &exErrVec(sums->exErrorVec());
452  const ErrorVector &eyErrVec(sums->eyErrorVec());
453  const ErrorVector &etErrVec(sums->etErrorVec());
454  unsigned int slices = et.size();
455  auto l1Menu = SG::makeHandle( m_L1MenuKey );
456  for (unsigned int sl = 0; sl < slices; ++sl)
457  {
458  DataError exErr(exErrVec[sl]);
459  DataError eyErr(eyErrVec[sl]);
460  DataError etErr(etErrVec[sl]);
461  auto systemEnergy = new SystemEnergy(et[sl], ex[sl], ey[sl],
462  etErr.get(DataError::Overflow),
463  exErr.get(DataError::Overflow),
464  eyErr.get(DataError::Overflow),
465  source == xAOD::CMXEtSums::TOTAL_RESTRICTED,
466  &(*l1Menu));
467  // bool srestricted = (systemEnergy->roiWord0() >> 26) & 1;
468  systemVec.push_back(systemEnergy);
469  }
470  }
471 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode LVL1::L1EnergyCMXTools::finalize ( )
virtual

standard Athena-Algorithm method

Finalisation.

Definition at line 60 of file L1EnergyCMXTools.cxx.

61 {
62  return StatusCode::SUCCESS;
63 }

◆ findRestrictedEta()

void LVL1::L1EnergyCMXTools::findRestrictedEta ( uint32_t &  maskXE,
uint32_t &  maskTE 
) const
private

form partial CMXEtSums (crate) from module CMXEtSums

Definition at line 175 of file L1EnergyCMXTools.cxx.

176 {
177  using TrigConf::L1DataDef;
178  const float moduleEta[8] = {-4.,-2.,-1.2,-0.4,0.4,1.2,2.,4.};
179  maskXE = 0;
180  maskTE = 0;
181  bool maskXESet = false;
182  bool maskTESet = false;
183 
184  auto l1Menu = SG::makeHandle( m_L1MenuKey );
185  std::vector<std::shared_ptr<TrigConf::L1Threshold>> allThresholds = l1Menu->thresholds();
186  for ( const auto& thresh : allThresholds ) {
187  if ( ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE) ||
188  thresh->type() == L1DataDef::typeAsString(L1DataDef::TE) ) && thresh->mapping() > 7 ) {
189  auto thresh_Calo = static_cast<TrigConf::L1Threshold_Calo*>(thresh.get());
190  auto tvcs = thresh_Calo->thrValuesCounts();
191  // Make sure only set masks from the first valid threshold in the range (for each type)
192  if (maskXE > 0) maskXESet = true;
193  if (maskTE > 0) maskTESet = true;
194  if (tvcs.size() == 0) {
195  tvcs.addRangeValue(thresh_Calo->thrValueCounts(),-49, 49, 1, true);
196  }
197  for (const auto& tVC : tvcs) {
198  // Bits are set false by default, so ignore thresholds that are just doing that
199  if (tVC.value() >= 0x7fff) continue;
200  // Set bits true if module centre between etaMin and etaMax
201  if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE) && !maskXESet ) {
202  for (unsigned int bin = 0; bin < 8; ++bin) {
203  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
204  maskXE |= (1<<bin);
205  }
206  }
207  else if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::TE) && !maskTESet ) {
208  for (unsigned int bin = 0; bin < 8; ++bin) {
209  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
210  maskTE |= (1<<bin);
211  }
212  }
213  } // loop over TTV
214  } // Is this XE or TE threshold?
215  }
216 }

◆ formCMXEtSums()

void LVL1::L1EnergyCMXTools::formCMXEtSums ( const xAOD::JEMEtSumsContainer *  jemEtSumsVec,
xAOD::CMXEtSumsContainer *  cmxEtSumsVec 
) const
virtual

form complete CMXEtSums from JEMEtSums

Implements LVL1::IL1EnergyCMXTools.

Definition at line 115 of file L1EnergyCMXTools.cxx.

117 {
118  formCMXEtSumsModule(jemEtSumsVec, cmxEtSumsVec);
119  // Convert to internal containers
120  int peak = 0;
121  MultiSliceModuleEnergy modulesVec;
122  MultiSliceCrateEnergy cratesVec;
123  MultiSliceSystemEnergy systemVec;
124  etSumsToModuleEnergy(cmxEtSumsVec, modulesVec, peak);
125  // Process each slice
126  MultiSliceModuleEnergy::iterator iter = modulesVec.begin();
127  MultiSliceModuleEnergy::iterator iterE = modulesVec.end();
128 
129  auto l1Menu = SG::makeHandle( m_L1MenuKey );
130  for (; iter != iterE; ++iter)
131  {
132  DataVector<ModuleEnergy> *modules = *iter;
133  DataVector<CrateEnergy> *crates = new DataVector<CrateEnergy>;
134  cratesVec.push_back(crates);
135  m_etTool->crateSums(modules, crates);
136  systemVec.push_back(new SystemEnergy(crates, &(*l1Menu)));
137  delete modules;
138  }
139  // Convert back to CMXEtSums
140  crateEnergyToEtSums(cratesVec, cmxEtSumsVec, peak);
141  MultiSliceCrateEnergy::iterator citer = cratesVec.begin();
142  MultiSliceCrateEnergy::iterator citerE = cratesVec.end();
143  for (; citer != citerE; ++citer)
144  delete *citer;
145  systemEnergyToEtSums(systemVec, cmxEtSumsVec, peak);
146  etMapsToEtSums(systemVec, cmxEtSumsVec, peak);
147  MultiSliceSystemEnergy::iterator siter = systemVec.begin();
148  MultiSliceSystemEnergy::iterator siterE = systemVec.end();
149  for (; siter != siterE; ++siter)
150  delete *siter;
151 }

◆ formCMXEtSumsCrate()

void LVL1::L1EnergyCMXTools::formCMXEtSumsCrate ( const xAOD::CMXEtSumsContainer *  cmxEtSumsMod,
xAOD::CMXEtSumsContainer *  cmxEtSumsCrate 
) const
virtual

form partial CMXEtSums (crate) from module CMXEtSums

Implements LVL1::IL1EnergyCMXTools.

Definition at line 217 of file L1EnergyCMXTools.cxx.

220 {
221  uint32_t maskXE, maskTE;
222  findRestrictedEta(maskXE, maskTE);
223  ATH_MSG_DEBUG("Restricted eta masks: XE=" << MSG::hex << maskXE << ", TE=" << maskTE << MSG::dec);
224  // Convert to internal containers
225  int peak = 0;
226  MultiSliceModuleEnergy modulesVec;
227  MultiSliceCrateEnergy cratesVecFull;
228  MultiSliceCrateEnergy cratesVecRestricted;
229  etSumsToModuleEnergy(cmxEtSumsMod, modulesVec, peak);
230  // Process each slice
231  for (auto iter : modulesVec)
232  {
233  DataVector<ModuleEnergy> *modules = iter;
234  DataVector<CrateEnergy> *cratesFull = new DataVector<CrateEnergy>;
235  DataVector<CrateEnergy> *cratesRestricted = new DataVector<CrateEnergy>;
236  cratesVecFull.push_back(cratesFull);
237  cratesVecRestricted.push_back(cratesRestricted);
238  m_etTool->crateSums(modules, cratesFull);
239  m_etTool->crateSums(modules, cratesRestricted, maskXE, maskTE, true);
240  delete modules;
241  }
242 
243  // Convert back to CMXEtSums
244  crateEnergyToEtSums(cratesVecFull, cratesVecRestricted, cmxEtSumsCrate, peak);
245  // crateEnergyToEtSums(cratesVecRestricted, cmxEtSumsCrate, peak);
246 
247  for (auto crate : cratesVecFull)
248  {
249  delete crate;
250  }
251  for (auto crate : cratesVecRestricted)
252  {
253  delete crate;
254  }
255 }

◆ formCMXEtSumsEtMaps()

void LVL1::L1EnergyCMXTools::formCMXEtSumsEtMaps ( const xAOD::CMXEtSumsContainer *  cmxEtSumsSys,
xAOD::CMXEtSumsContainer *  cmxEtSumsMap 
) const
virtual

form partial CMXEtSums (sumEt/missingEt maps) from system CMXEtSums

form partial CMXEtSums (sumEt/missingEt/missingEtSig maps) from system CMXEtSums

Implements LVL1::IL1EnergyCMXTools.

Definition at line 304 of file L1EnergyCMXTools.cxx.

307 {
308  // Convert to internal objects
309  int peak = 0;
310  MultiSliceSystemEnergy systemVec;
311  etSumsToSystemEnergy(cmxEtSumsSys, systemVec, peak);
312  // Convert back to CMXEtSums
313  etMapsToEtSums(systemVec, cmxEtSumsMap, peak);
314  MultiSliceSystemEnergy::iterator iter = systemVec.begin();
315  MultiSliceSystemEnergy::iterator iterE = systemVec.end();
316  for (; iter != iterE; ++iter)
317  delete *iter;
318 }

◆ formCMXEtSumsModule()

void LVL1::L1EnergyCMXTools::formCMXEtSumsModule ( const xAOD::JEMEtSumsContainer *  jemEtSumsVec,
xAOD::CMXEtSumsContainer *  cmxEtSumsMod 
) const
virtual

form partial CMXEtSums (module) from JEMEtSums

Implements LVL1::IL1EnergyCMXTools.

Definition at line 155 of file L1EnergyCMXTools.cxx.

158 {
159  xAOD::JEMEtSumsContainer::const_iterator pos = jemEtSumsVec->begin();
160  xAOD::JEMEtSumsContainer::const_iterator pose = jemEtSumsVec->end();
161  for (; pos != pose; ++pos)
162  {
163  const xAOD::JEMEtSums *sums = *pos;
164  ErrorVector err(sums->etVec().size());
165  auto item = new xAOD::CMXEtSums;
166  item->makePrivateStore();
167  item->initialize(sums->crate(), sums->module(),
168  sums->etVec(), sums->exVec(), sums->eyVec(),
169  err, err, err, sums->peak());
170  cmxEtSumsMod->push_back(item);
171  }
172 }

◆ formCMXEtSumsSystem()

void LVL1::L1EnergyCMXTools::formCMXEtSumsSystem ( const xAOD::CMXEtSumsContainer *  cmxEtSumsCrate,
xAOD::CMXEtSumsContainer *  cmxEtSumsSys 
) const
virtual

form partial CMXEtSums (system) from crate CMXEtSums

Implements LVL1::IL1EnergyCMXTools.

Definition at line 259 of file L1EnergyCMXTools.cxx.

262 {
263  // Convert to internal containers
264  int peak = 0;
265  MultiSliceCrateEnergy cratesVecFull;
266  MultiSliceCrateEnergy cratesVecRestricted;
267 
268  MultiSliceSystemEnergy systemVecFull;
269  MultiSliceSystemEnergy systemVecRestricted;
270  auto l1Menu = SG::makeHandle( m_L1MenuKey );
271  etSumsToCrateEnergy(cmxEtSumsCrate, cratesVecFull, cratesVecRestricted, peak);
272  for (int i = 0; i < 2; i++)
273  {
274  MultiSliceCrateEnergy *cratesVec = i == 0? &cratesVecFull: &cratesVecRestricted;
275  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
276  // Process each slice
277  MultiSliceCrateEnergy::iterator iter = (*cratesVec).begin();
278  MultiSliceCrateEnergy::iterator iterE = (*cratesVec).end();
279  for (; iter != iterE; ++iter)
280  {
281  DataVector<CrateEnergy> *crates = *iter;
282  //systemVec.push_back(new SystemEnergy(m_etTool->systemSums(crates)));
283  systemVec->push_back(new SystemEnergy(crates, &(*l1Menu)));
284  delete crates;
285  }
286  }
287  // Convert back to CMXEtSums
288  systemEnergyToEtSums(systemVecFull, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_STANDARD);
289  systemEnergyToEtSums(systemVecRestricted, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_RESTRICTED);
290 
291  for (int i = 0; i < 2; i++)
292  {
293  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
294  MultiSliceSystemEnergy::iterator siter = (*systemVec).begin();
295  MultiSliceSystemEnergy::iterator siterE = (*systemVec).end();
296  for (; siter != siterE; ++siter)
297  delete *siter;
298  }
299 }

◆ formJEMEtSums()

void LVL1::L1EnergyCMXTools::formJEMEtSums ( const xAOD::JetElementContainer *  jetElementVec,
xAOD::JEMEtSumsContainer *  jemEtSumsVec 
) const
virtual

form JEMEtSums from JetElements

Temporary version for testing bytestream converters and monitoring.

Until ModuleEnergy et al updated takes masked and normal values the same. Effect of quadlinear encoding/decoding ignored. form JEMEtSums from JetElements

Implements LVL1::IL1EnergyCMXTools.

Definition at line 71 of file L1EnergyCMXTools.cxx.

74 {
75  // Find number of slices
76  int peak = 0;
77  unsigned int nslices = 1;
78  xAOD::JetElementContainer::const_iterator iter = jetElementVec->begin();
79  xAOD::JetElementContainer::const_iterator iterE = jetElementVec->end();
80  for (; iter != iterE; ++iter)
81  {
82  if ((*iter)->emJetElementETVec().size() > nslices)
83  {
84  nslices = (*iter)->emJetElementETVec().size();
85  peak = (*iter)->peak();
86  break;
87  }
88  if ((*iter)->hadJetElementETVec().size() > nslices)
89  {
90  nslices = (*iter)->hadJetElementETVec().size();
91  peak = (*iter)->peak();
92  break;
93  }
94  }
95  // Process each slice
96  xAOD::JetElementMap_t jeMap;
97  m_jeTool->mapJetElements(jetElementVec, &jeMap);
98  MultiSliceModuleEnergy modulesVec;
99  for (unsigned int slice = 0; slice < nslices; ++slice)
100  {
101  DataVector<ModuleEnergy> *modules = new DataVector<ModuleEnergy>;
102  modulesVec.push_back(modules);
103  m_etTool->moduleSums(&jeMap, modules, slice);
104  }
105  // Convert to JEMEtSums
106  moduleEnergyToEtSums(modulesVec, jemEtSumsVec, peak);
107  MultiSliceModuleEnergy::iterator miter = modulesVec.begin();
108  MultiSliceModuleEnergy::iterator miterE = modulesVec.end();
109  for (; miter != miterE; ++miter)
110  delete *miter;
111 }

◆ initialize()

StatusCode LVL1::L1EnergyCMXTools::initialize ( )
virtual

standard Athena-Algorithm method

Initialisation.

Definition at line 45 of file L1EnergyCMXTools.cxx.

46 {
47  m_debug = msgLvl(MSG::DEBUG);
48  ATH_CHECK( m_L1MenuKey.initialize() );
49 
50  // Retrieve jet element tool
51 
52  ATH_CHECK(m_jeTool.retrieve());
53  ATH_CHECK(m_etTool.retrieve());
54 
55  return StatusCode::SUCCESS;
56 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & LVL1::IL1EnergyCMXTools::interfaceID ( )
inlinestaticinherited

Definition at line 51 of file IL1EnergyCMXTools.h.

52  {
53  return IID_IL1EnergyCMXTools;
54  }

◆ moduleEnergyToEtSums()

void LVL1::L1EnergyCMXTools::moduleEnergyToEtSums ( const MultiSliceModuleEnergy &  modulesVec,
xAOD::JEMEtSumsContainer *  jemEtSumsVec,
int  peak 
) const
private

Convert internal ModuleEnergy containers to JEMEtSums container.

Definition at line 475 of file L1EnergyCMXTools.cxx.

478 {
479  std::map<int, xAOD::JEMEtSums *> etMap;
480  unsigned int nslices = modulesVec.size();
481  std::vector<uint16_t> dummy(nslices);
482  for (unsigned int slice = 0; slice < nslices; ++slice)
483  {
484  const DataVector<ModuleEnergy> *modules = modulesVec[slice];
485  DataVector<ModuleEnergy>::const_iterator pos = modules->begin();
486  DataVector<ModuleEnergy>::const_iterator pose = modules->end();
487  for (; pos != pose; ++pos)
488  {
489  const ModuleEnergy *energy = *pos;
490  //unsigned int ex = energy->exCompressed();
491  //unsigned int ey = energy->eyCompressed();
492  //unsigned int et = energy->etCompressed();
493  unsigned int ex = energy->ex();
494  unsigned int ey = energy->ey();
495  unsigned int et = energy->et();
496  if (ex == 0 && ey == 0 && et == 0)
497  continue;
498  int crate = energy->crate();
499  int module = energy->module();
500  xAOD::JEMEtSums *sums = 0;
501  int key = crate * 100 + module;
502  std::map<int, xAOD::JEMEtSums *>::iterator iter = etMap.find(key);
503  if (iter == etMap.end())
504  {
505  sums = new xAOD::JEMEtSums;
506  sums->makePrivateStore();
507  sums->initialize(crate, module, dummy, dummy, dummy, peak);
508  etMap.insert(std::make_pair(key, sums));
509  jemEtSumsVec->push_back(sums);
510  }
511  else
512  sums = iter->second;
513  std::vector<uint16_t> exVec(sums->exVec());
514  std::vector<uint16_t> eyVec(sums->eyVec());
515  std::vector<uint16_t> etVec(sums->etVec());
516  exVec[slice] = ex;
517  eyVec[slice] = ey;
518  etVec[slice] = et;
519  sums->setExVec(exVec);
520  sums->setEyVec(eyVec);
521  sums->setEtVec(etVec);
522  }
523  }
524 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ systemEnergyToEtSums()

void LVL1::L1EnergyCMXTools::systemEnergyToEtSums ( const MultiSliceSystemEnergy &  systemVec,
xAOD::CMXEtSumsContainer *  cmxEtSumsVec,
int  peak,
xAOD::CMXEtSums_v1::Sources  source = xAOD::CMXEtSums::TOTAL_STANDARD 
) const
private

Convert internal SystemEnergy objects to CMXEtSums object.

Definition at line 738 of file L1EnergyCMXTools.cxx.

741 {
742  xAOD::CMXEtSums *sums = nullptr;
743 
744  unsigned int nslices = systemVec.size();
745  std::vector<uint16_t> data(nslices);
746  std::vector<uint32_t> error(nslices);
747  for (unsigned int slice = 0; slice < nslices; ++slice)
748  {
749  SystemEnergy *energy = systemVec[slice];
750  unsigned int ex = energy->exTC();
751  unsigned int ey = energy->eyTC();
752  unsigned int et = energy->et();
753  int exOverflow = energy->exOverflow();
754  int eyOverflow = energy->eyOverflow();
755  int etOverflow = energy->etOverflow();
756 
757  // don't trust to exOverflow for restricted
758  if (ex == 0 && ey == 0 && et == 0 &&
759  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
760  continue;
761  if (!sums)
762  {
763  sums = new xAOD::CMXEtSums;
764  sums->makePrivateStore();
765  sums->initialize(1, source, data, data, data,
766  error, error, error, peak);
767  cmxEtSumsVec->push_back(sums);
768  }
769  std::vector<uint16_t> exVec(sums->exVec());
770  std::vector<uint16_t> eyVec(sums->eyVec());
771  std::vector<uint16_t> etVec(sums->etVec());
772  std::vector<uint32_t> exErr(sums->exErrorVec());
773  std::vector<uint32_t> eyErr(sums->eyErrorVec());
774  std::vector<uint32_t> etErr(sums->etErrorVec());
775  exVec[slice] = ex;
776  eyVec[slice] = ey;
777  etVec[slice] = et;
778 
779  if (exOverflow)
780  {
781  DataError dEx(exErr[slice]);
782  dEx.set(DataError::Overflow);
783  exErr[slice] = dEx.error();
784  }
785 
786  if (eyOverflow)
787  {
788  DataError dEy(eyErr[slice]);
789  dEy.set(DataError::Overflow);
790  eyErr[slice] = dEy.error();
791  }
792  if (etOverflow)
793  {
794  DataError dEt(etErr[slice]);
795  dEt.set(DataError::Overflow);
796  etErr[slice] = dEt.error();
797  }
798  sums->addEx(exVec, exErr);
799  sums->addEy(eyVec, eyErr);
800  sums->addEt(etVec, etErr);
801  }
802 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_debug

bool LVL1::L1EnergyCMXTools::m_debug = false
private

Debug flag.

Definition at line 127 of file L1EnergyCMXTools.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_etTool

ToolHandle<LVL1::IL1EtTools> LVL1::L1EnergyCMXTools::m_etTool
private

Tool for energy sums.

Definition at line 125 of file L1EnergyCMXTools.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_jeTool

ToolHandle<LVL1::IL1JetElementTools> LVL1::L1EnergyCMXTools::m_jeTool
private

Tool for JetElement map.

Definition at line 123 of file L1EnergyCMXTools.h.

◆ m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> LVL1::L1EnergyCMXTools::m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
private

Definition at line 121 of file L1EnergyCMXTools.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigConf::L1Threshold_Calo::thrValuesCounts
virtual ValueWithEtaDependence< unsigned int > thrValuesCounts() const
access to the list of ThresholdValues in energy units
Definition: L1ThresholdBase.cxx:317
xAOD::CMXEtSums_v1::LOCAL_RESTRICTED
@ LOCAL_RESTRICTED
Definition: CMXEtSums_v1.h:31
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
et
Extra patterns decribing particle interation process.
xAOD::CMXEtSums_v1::addEy
void addEy(const std::vector< uint16_t > &eyVec, const std::vector< uint32_t > &eyErrorVec)
add Ey
Definition: CMXEtSums_v1.cxx:103
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
module_driven_slicing.nslices
nslices
Definition: module_driven_slicing.py:575
xAOD::JEMEtSums_v2::setExVec
void setExVec(const std::vector< uint16_t > &)
set exVec - ex for all time slices
xAOD::CMXEtSums_v1::exVec
const std::vector< uint16_t > & exVec() const
get exVec
xAOD::JEMEtSums
JEMEtSums_v2 JEMEtSums
Define the latest version of the JEMEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JEMEtSums.h:16
xAOD::JEMEtSums_v2::initialize
virtual void initialize(const uint8_t crate, const uint8_t module)
initialize
Definition: JEMEtSums_v2.cxx:24
LVL1::L1EnergyCMXTools::MultiSliceCrateEnergy
std::vector< DataVector< CrateEnergy > * > MultiSliceCrateEnergy
Definition: L1EnergyCMXTools.h:89
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
physval_make_web_display.thresh
thresh
Definition: physval_make_web_display.py:36
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1::CrateEnergy
CrateEnergy class declaration Simulates behaviour of the Crate-CMM System CMM logic is done in Energy...
Definition: CrateEnergy.h:34
LVL1::L1EnergyCMXTools::MultiSliceModuleEnergy
std::vector< DataVector< ModuleEnergy > * > MultiSliceModuleEnergy
Definition: L1EnergyCMXTools.h:88
xAOD::CMXEtSums_v1::TOTAL_RESTRICTED
@ TOTAL_RESTRICTED
Definition: CMXEtSums_v1.h:32
xAOD::JEMEtSums_v2::exVec
const std::vector< uint16_t > & exVec() const
get exVec - ex for all time slices
bin
Definition: BinsDiffFromStripMedian.h:43
LVL1::CMXEtSums::SUM_ET_RESTRICTED
@ SUM_ET_RESTRICTED
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:32
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::CMXEtSums_v1::etVec
const std::vector< uint16_t > & etVec() const
get etVec
xAOD::JEMEtSums_v2::peak
uint8_t peak() const
get peak
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::JEMEtSums_v2::crate
uint8_t crate() const
get crate number
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::CMXEtSums_v1::peak
uint8_t peak() const
get peak
LVL1::L1EnergyCMXTools::etSumsToSystemEnergy
void etSumsToSystemEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceSystemEnergy &systemVec, int &peak) const
Convert CMXEtSums container to internal SystemEnergy objects.
Definition: L1EnergyCMXTools.cxx:433
xAOD::CMXEtSums_v1::REMOTE_STANDARD
@ REMOTE_STANDARD
Definition: CMXEtSums_v1.h:30
LVL1::L1EnergyCMXTools::m_jeTool
ToolHandle< LVL1::IL1JetElementTools > m_jeTool
Tool for JetElement map.
Definition: L1EnergyCMXTools.h:123
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::JEMEtSums_v2::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec - ey for all time slices
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LVL1::L1EnergyCMXTools::formCMXEtSumsModule
virtual void formCMXEtSumsModule(const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
form partial CMXEtSums (module) from JEMEtSums
Definition: L1EnergyCMXTools.cxx:155
TrigConf::L1DataDef::XE
@ XE
Definition: L1DataDef.h:22
LVL1::L1EnergyCMXTools::crateEnergyToEtSums
void crateEnergyToEtSums(const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert internal CrateEnergy containers to CMXEtSums container.
Definition: L1EnergyCMXTools.cxx:528
TrigConf::L1Threshold_Calo
Definition: L1ThresholdBase.h:188
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
xAOD::JEMEtSums_v2::setEtVec
void setEtVec(const std::vector< uint16_t > &)
set etVec - et for all time slices
python.PyAthena.module
module
Definition: PyAthena.py:131
LVL1::L1EnergyCMXTools::m_debug
bool m_debug
Debug flag.
Definition: L1EnergyCMXTools.h:127
LVL1::L1EnergyCMXTools::EnergyVector
std::vector< uint16_t > EnergyVector
Definition: L1EnergyCMXTools.h:86
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TrigConf::L1DataDef
Definition: L1DataDef.h:16
AthCommonDataStore
Definition: AthCommonDataStore.h:52
xAOD::JetElementMap_t
std::map< int, const JetElement * > JetElementMap_t
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JetElement.h:18
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LVL1::L1EnergyCMXTools::ErrorVector
std::vector< uint32_t > ErrorVector
Definition: L1EnergyCMXTools.h:87
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
LVL1::DataError::Overflow
@ Overflow
Definition: DataError.h:31
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
xAOD::CMXEtSums_v1
Description of CMXEtSums_v1.
Definition: CMXEtSums_v1.h:28
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::JEMEtSums_v2
Description of JEMEtSums_v2.
Definition: JEMEtSums_v2.h:26
xAOD::CMXEtSums_v1::crate
uint8_t crate() const
get crate
LVL1::L1EnergyCMXTools::m_etTool
ToolHandle< LVL1::IL1EtTools > m_etTool
Tool for energy sums.
Definition: L1EnergyCMXTools.h:125
xAOD::CMXEtSums_v1::addEt
void addEt(const std::vector< uint16_t > &etVec, const std::vector< uint32_t > &etErrorVec)
add data to existing object add Et
Definition: CMXEtSums_v1.cxx:89
LVL1::CMXEtSums::SUM_ET_STANDARD
@ SUM_ET_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:32
xAOD::CMXEtSums_v1::TOTAL_STANDARD
@ TOTAL_STANDARD
Definition: CMXEtSums_v1.h:32
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::L1EnergyCMXTools::findRestrictedEta
void findRestrictedEta(uint32_t &maskXE, uint32_t &maskTE) const
form partial CMXEtSums (crate) from module CMXEtSums
Definition: L1EnergyCMXTools.cxx:175
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LVL1::L1EnergyCMXTools::etSumsToCrateEnergy
void etSumsToCrateEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceCrateEnergy &crateVecFull, MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
Convert CMXEtSums container to internal CrateEnergy containers.
Definition: L1EnergyCMXTools.cxx:362
xAOD::JEMEtSums_v2::etVec
const std::vector< uint16_t > & etVec() const
Please note that in the context of JEMEtSums, et is total energy, not transverse energy For transvers...
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::CMXEtSums_v1::eyErrorVec
const std::vector< uint32_t > & eyErrorVec() const
get eyErrorVec
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
xAOD::CMXEtSums_v1::REMOTE_RESTRICTED
@ REMOTE_RESTRICTED
Definition: CMXEtSums_v1.h:30
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TrigConf::L1DataDef::TE
@ TE
Definition: L1DataDef.h:22
xAOD::CMXEtSums
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CMXEtSums.h:20
TrigConf::L1DataDef::typeAsString
static std::string & typeAsString(TriggerType tt)
Definition: L1DataDef.h:53
LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD
@ MISSING_ET_SIG_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:34
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
LVL1::L1EnergyCMXTools::m_L1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey
Definition: L1EnergyCMXTools.h:121
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
item
Definition: ItemListSvc.h:43
LVL1::L1EnergyCMXTools::systemEnergyToEtSums
void systemEnergyToEtSums(const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak, xAOD::CMXEtSums_v1::Sources source=xAOD::CMXEtSums::TOTAL_STANDARD) const
Convert internal SystemEnergy objects to CMXEtSums object.
Definition: L1EnergyCMXTools.cxx:738
LVL1::L1EnergyCMXTools::dumpCrateEnergies
void dumpCrateEnergies(const std::string &msg, const MultiSliceCrateEnergy &crates) const
Definition: L1EnergyCMXTools.cxx:942
xAOD::CMXEtSums_v1::addEx
void addEx(const std::vector< uint16_t > &exVec, const std::vector< uint32_t > &exErrorVec)
add Ex
Definition: CMXEtSums_v1.cxx:96
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TrigConf::ValueWithEtaDependence::addRangeValue
void addRangeValue(const T &value, int etaMin, int etaMax, unsigned int priority, bool symmetric=true)
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
LVL1::CMXEtSums::MISSING_ET_RESTRICTED
@ MISSING_ET_RESTRICTED
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:33
copySelective.source
string source
Definition: copySelective.py:32
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::CMXEtSums_v1::LOCAL_STANDARD
@ LOCAL_STANDARD
Definition: CMXEtSums_v1.h:31
xAOD::CMXEtSums_v1::etErrorVec
const std::vector< uint32_t > & etErrorVec() const
get etErrorVec
xAOD::JEMEtSums_v2::module
uint8_t module() const
get module
xAOD::CMXEtSums_v1::sourceComponent
uint8_t sourceComponent() const
get source
LVL1::L1EnergyCMXTools::etMapsToEtSums
void etMapsToEtSums(const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert maps from internal SystemEnergy objects to CMXEtSums objects.
Definition: L1EnergyCMXTools.cxx:806
get_generator_info.error
error
Definition: get_generator_info.py:40
LVL1::L1EnergyCMXTools::MultiSliceSystemEnergy
std::vector< SystemEnergy * > MultiSliceSystemEnergy
Definition: L1EnergyCMXTools.h:90
error
Definition: IImpactPoint3dEstimator.h:70
xAOD::CMXEtSums_v1::initialize
virtual void initialize(const uint8_t crate, const uint8_t source)
initialize
Definition: CMXEtSums_v1.cxx:59
python.compressB64.c
def c
Definition: compressB64.py:93
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LVL1::CMXEtSums::MISSING_ET_STANDARD
@ MISSING_ET_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:33
xAOD::JEMEtSums_v2::setEyVec
void setEyVec(const std::vector< uint16_t > &)
set eyVec - ey for all time slices
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
LVL1::L1EnergyCMXTools::moduleEnergyToEtSums
void moduleEnergyToEtSums(const MultiSliceModuleEnergy &modulesVec, xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
Convert internal ModuleEnergy containers to JEMEtSums container.
Definition: L1EnergyCMXTools.cxx:475
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
LVL1::L1EnergyCMXTools::etSumsToModuleEnergy
void etSumsToModuleEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceModuleEnergy &modulesVec, int &peak) const
Convert CMXEtSums container to internal ModuleEnergy containers.
Definition: L1EnergyCMXTools.cxx:322
fitman.k
k
Definition: fitman.py:528
xAOD::CMXEtSums_v1::exErrorVec
const std::vector< uint32_t > & exErrorVec() const
get exErrorVec
xAOD::CMXEtSums_v1::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Sat Apr 12 2025 22:01:30 for ATLAS Offline Software by   doxygen 1.8.18