ATLAS Offline Software
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 527 of file L1EnergyCMXTools.cxx.

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

◆ crateEnergyToEtSums() [2/2]

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

Definition at line 620 of file L1EnergyCMXTools.cxx.

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

◆ 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 941 of file L1EnergyCMXTools.cxx.

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

◆ 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 805 of file L1EnergyCMXTools.cxx.

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

◆ 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 361 of file L1EnergyCMXTools.cxx.

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

◆ 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 321 of file L1EnergyCMXTools.cxx.

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

◆ 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 432 of file L1EnergyCMXTools.cxx.

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

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

◆ 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 216 of file L1EnergyCMXTools.cxx.

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

◆ 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 303 of file L1EnergyCMXTools.cxx.

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

◆ 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 258 of file L1EnergyCMXTools.cxx.

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

◆ 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 474 of file L1EnergyCMXTools.cxx.

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

◆ 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 737 of file L1EnergyCMXTools.cxx.

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

◆ 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:15
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:33
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
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:432
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:27
LVL1::L1EnergyCMXTools::formCMXEtSumsModule
virtual void formCMXEtSumsModule(const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
form partial CMXEtSums (module) from JEMEtSums
Definition: L1EnergyCMXTools.cxx:155
LVL1::L1EnergyCMXTools::crateEnergyToEtSums
void crateEnergyToEtSums(const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert internal CrateEnergy containers to CMXEtSums container.
Definition: L1EnergyCMXTools.cxx:527
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:270
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:27
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:33
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:361
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:581
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
xAOD::CMXEtSums
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CMXEtSums.h:20
LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD
@ MISSING_ET_SIG_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:35
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
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:172
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:737
LVL1::L1EnergyCMXTools::dumpCrateEnergies
void dumpCrateEnergies(const std::string &msg, const MultiSliceCrateEnergy &crates) const
Definition: L1EnergyCMXTools.cxx:941
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)
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:623
LVL1::CMXEtSums::MISSING_ET_RESTRICTED
@ MISSING_ET_RESTRICTED
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:34
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:805
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:34
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:474
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:321
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 Thu Nov 7 2024 22:17:55 for ATLAS Offline Software by   doxygen 1.8.18