LVL1::L1EnergyCMXTools Class Reference

This is a tool to reconstruct the L1 JEM and CMX-Energy Et sums from Jet Elements. More...

#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.
virtual	~L1EnergyCMXTools ()
	default destructor
virtual StatusCode	initialize ()
	standard Athena-Algorithm method
virtual StatusCode	finalize ()
	standard Athena-Algorithm method
virtual void	formJEMEtSums (const xAOD::JetElementContainer *jetElementVec, xAOD::JEMEtSumsContainer *jemEtSumsVec) const
	form JEMEtSums from JetElements
virtual void	formCMXEtSums (const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec) const
	form complete CMXEtSums from JEMEtSums
virtual void	formCMXEtSumsModule (const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
	form partial CMXEtSums (module) from JEMEtSums
virtual void	formCMXEtSumsCrate (const xAOD::CMXEtSumsContainer *cmxEtSumsMod, xAOD::CMXEtSumsContainer *cmxEtSumsCrate) const
	form partial CMXEtSums (crate) from module CMXEtSums
virtual void	formCMXEtSumsSystem (const xAOD::CMXEtSumsContainer *cmxEtSumsCrate, xAOD::CMXEtSumsContainer *cmxEtSumsSys) const
	form partial CMXEtSums (system) from crate CMXEtSums
virtual void	formCMXEtSumsEtMaps (const xAOD::CMXEtSumsContainer *cmxEtSumsSys, xAOD::CMXEtSumsContainer *cmxEtSumsMap) const
	form partial CMXEtSums (sumEt/missingEt maps) from system CMXEtSums
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () 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
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.

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.
void	etSumsToCrateEnergy (const xAOD::CMXEtSumsContainer *etSums, MultiSliceCrateEnergy &crateVecFull, MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
	Convert CMXEtSums container to internal CrateEnergy containers.
void	etSumsToSystemEnergy (const xAOD::CMXEtSumsContainer *etSums, MultiSliceSystemEnergy &systemVec, int &peak) const
	Convert CMXEtSums container to internal SystemEnergy objects.
void	moduleEnergyToEtSums (const MultiSliceModuleEnergy &modulesVec, xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
	Convert internal ModuleEnergy containers to JEMEtSums container.
void	crateEnergyToEtSums (const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
	Convert internal CrateEnergy containers to CMXEtSums container.
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.
void	etMapsToEtSums (const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
	Convert maps from internal SystemEnergy objects to CMXEtSums objects.
void	findRestrictedEta (uint32_t &maskXE, uint32_t &maskTE) const
	form partial CMXEtSums (crate) from module CMXEtSums
void	dumpCrateEnergies (const std::string &msg, const MultiSliceCrateEnergy &crates) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< TrigConf::L1Menu >	m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
ToolHandle< LVL1::IL1JetElementTools >	m_jeTool
	Tool for JetElement map.
ToolHandle< LVL1::IL1EtTools >	m_etTool
	Tool for energy sums.
bool	m_debug = false
	Debug flag.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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 47 of file L1EnergyCMXTools.h.

Member Typedef Documentation

EnergyVector

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

private

Definition at line 83 of file L1EnergyCMXTools.h.

ErrorVector

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

private

Definition at line 84 of file L1EnergyCMXTools.h.

MultiSliceCrateEnergy

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

private

Definition at line 86 of file L1EnergyCMXTools.h.

MultiSliceModuleEnergy

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

private

Definition at line 85 of file L1EnergyCMXTools.h.

MultiSliceSystemEnergy

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

private

Definition at line 87 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.

    : AthAlgTool(type, name, parent),
      m_jeTool("LVL1::L1JetElementTools/L1JetElementTools"),
      m_etTool("LVL1::L1EtTools/L1EtTools")
{
    declareInterface<IL1EnergyCMXTools>(this);
    declareProperty("JetElementTool", m_jeTool);
    declareProperty("EtTool", m_etTool);
}

~L1EnergyCMXTools()

LVL1::L1EnergyCMXTools::~L1EnergyCMXTools ( )

virtual

default destructor

Destructor.

Definition at line 39 of file L1EnergyCMXTools.cxx.

{
}

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.

{
    std::map<int, xAOD::CMXEtSums *> etMap;
    unsigned int nslices = cratesVec.size();
    std::vector<uint16_t> dummy(nslices);
    std::vector<uint32_t> error(nslices);
    for (unsigned int slice = 0; slice < nslices; ++slice)
    {
        const DataVector<CrateEnergy> *crates = cratesVec[slice];
        DataVector<CrateEnergy>::const_iterator pos = crates->begin();
        DataVector<CrateEnergy>::const_iterator pose = crates->end();
        for (; pos != pose; ++pos)
        {
            const CrateEnergy *energy = *pos;
            unsigned int ex = energy->exTC();
            unsigned int ey = energy->eyTC();
            unsigned int et = energy->et();
            int exOverflow = energy->exOverflow();
            int eyOverflow = energy->eyOverflow();
            int etOverflow = energy->etOverflow();
            if (ex == 0 && ey == 0 && et == 0 &&
                exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
                continue;
            int crate = energy->crate();
            xAOD::CMXEtSums *sums = 0;
            int source = xAOD::CMXEtSums::LOCAL_STANDARD;
            for (int i = 0; i < 2; ++i)
            {
                for (int j = 0; j < 2; ++j)
                {
                    int key = crate * 100 + source;
                    std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
                    if (iter == etMap.end())
                    {
                        sums = new xAOD::CMXEtSums;
                        sums->makePrivateStore();
                        sums->initialize(crate, source, dummy, dummy, dummy,
                                         error, error, error, peak);
                        etMap.insert(std::make_pair(key, sums));
                        cmxEtSumsVec->push_back(sums);
                    }
                    else
                        sums = iter->second;
                    std::vector<uint16_t> exVec(sums->exVec());
                    std::vector<uint16_t> eyVec(sums->eyVec());
                    std::vector<uint16_t> etVec(sums->etVec());
                    std::vector<uint32_t> exErr(sums->exErrorVec());
                    std::vector<uint32_t> eyErr(sums->eyErrorVec());
                    std::vector<uint32_t> etErr(sums->etErrorVec());
                    exVec[slice] = ex;
                    eyVec[slice] = ey;
                    etVec[slice] = et;
                    if (exOverflow)
                    {
                        DataError dEx(exErr[slice]);
                        dEx.set(DataError::Overflow);
                        exErr[slice] = dEx.error();
                    }
                    if (eyOverflow)
                    {
                        DataError dEy(eyErr[slice]);
                        dEy.set(DataError::Overflow);
                        eyErr[slice] = dEy.error();
                    }
                    if (etOverflow)
                    {
                        DataError dEt(etErr[slice]);
                        dEt.set(DataError::Overflow);
                        etErr[slice] = dEt.error();
                    }
                    sums->addEx(exVec, exErr);
                    sums->addEy(eyVec, eyErr);
                    sums->addEt(etVec, etErr);
                    if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
                    {
                        source = xAOD::CMXEtSums::LOCAL_RESTRICTED;
                    }
                    else
                    {
                        source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
                    }
                }
                if (crate == 1)
                    break;
                crate = 1;
                source = xAOD::CMXEtSums::REMOTE_STANDARD;
            }
        }
    }
}

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.

{
    std::map<int, xAOD::CMXEtSums *> etMap;
    unsigned int nslices = cratesVecFull.size();
    std::vector<uint16_t> dummy(nslices);
    std::vector<uint32_t> error(nslices);
    
    dumpCrateEnergies("Crates from full region", cratesVecFull);
    dumpCrateEnergies("Crates from restricted region", cratesVecRestricted);
    
 
    for (unsigned int slice = 0; slice < nslices; ++slice)
    {
        for (unsigned int i = 0; i < 2; i++)
        {
            const auto *crates = (i == 0 ? cratesVecFull[slice] : cratesVecRestricted[slice]);
            int origSource = i == 0 ? xAOD::CMXEtSums::LOCAL_STANDARD : xAOD::CMXEtSums::LOCAL_RESTRICTED;
 
            for (auto pos : *crates)
            {
                int source = origSource;
                const CrateEnergy *energy = pos;
                unsigned int ex = energy->exTC();
                unsigned int ey = energy->eyTC();
                unsigned int et = energy->et();
                int exOverflow = energy->exOverflow();
                int eyOverflow = energy->eyOverflow();
                int etOverflow = energy->etOverflow();
                if (ex == 0 && ey == 0 && et == 0 &&
                    exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
                    continue;
                int crate = energy->crate();
                xAOD::CMXEtSums *sums = 0;
 
                while (true)
                {
                    int key = crate * 100 + source;
                    std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
                    if (iter == etMap.end())
                    {
                        sums = new xAOD::CMXEtSums;
                        sums->makePrivateStore();
                        sums->initialize(crate, source, dummy, dummy, dummy,
                                         error, error, error, peak);
                        etMap.insert(std::make_pair(key, sums));
                        cmxEtSumsVec->push_back(sums);
                    }
                    else
                        sums = iter->second;
                    std::vector<uint16_t> exVec(sums->exVec());
                    std::vector<uint16_t> eyVec(sums->eyVec());
                    std::vector<uint16_t> etVec(sums->etVec());
                    std::vector<uint32_t> exErr(sums->exErrorVec());
                    std::vector<uint32_t> eyErr(sums->eyErrorVec());
                    std::vector<uint32_t> etErr(sums->etErrorVec());
                    exVec[slice] = ex;
                    eyVec[slice] = ey;
                    etVec[slice] = et;
                    if (exOverflow)
                    {
                        DataError dEx(exErr[slice]);
                        dEx.set(DataError::Overflow);
                        exErr[slice] = dEx.error();
                    }
                    if (eyOverflow)
                    {
                        DataError dEy(eyErr[slice]);
                        dEy.set(DataError::Overflow);
                        eyErr[slice] = dEy.error();
                    }
                    if (etOverflow)
                    {
                        DataError dEt(etErr[slice]);
                        dEt.set(DataError::Overflow);
                        etErr[slice] = dEt.error();
                    }
                    sums->addEx(exVec, exErr);
                    sums->addEy(eyVec, eyErr);
                    sums->addEt(etVec, etErr);
                    if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
                    {
                        if (crate == 1)
                        {
                            break;
                        }
                        else
                        {
                            crate = 1;
                            source = xAOD::CMXEtSums::REMOTE_STANDARD;
                        }
                    }
                    else if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED)
                    {
                        if (crate == 1)
                        {
                            break;
                        }
                        else
                        {
                            crate = 1;
                            source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            } // crates
        }     //for i
    }
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ 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.

                                                                     {
  if (!m_debug) return;
 
  ATH_MSG_DEBUG(msg);
  for (const auto& p : crates) {
    for (const LVL1::CrateEnergy* c : *p) {
      ATH_MSG_DEBUG(" CrateEnergy: crate " << c->crate() << " results ");
      ATH_MSG_DEBUG("  Et " << c->et() << " overflow " << c->etOverflow());
      ATH_MSG_DEBUG("  Ex " << c->ex() << " overflow " << c->exOverflow());
      ATH_MSG_DEBUG("  Ey " << c->ey() << " overflow "<< c->eyOverflow());
    }
    ATH_MSG_DEBUG("");
  }
}

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.

{
 
    xAOD::CMXEtSums **sumEt = 0;
    xAOD::CMXEtSums **missEt = 0;
    xAOD::CMXEtSums **missEtSig = 0;
 
    xAOD::CMXEtSums *sumEtFull = 0;
    xAOD::CMXEtSums *missEtFull = 0;
    xAOD::CMXEtSums *missEtSigFull = 0;
 
    xAOD::CMXEtSums *sumEtRestricted = 0;
    xAOD::CMXEtSums *missEtRestricted = 0;
    xAOD::CMXEtSums *missEtSigRestricted = 0;
 
    int nslicesFull = 0;
    int nslicesRestricted = 0;
    
    std::map<int, bool> isRestrictedMap;
 
 
    for (unsigned int i = 0; i < systemVec.size(); ++i)
    {
        bool isRestricted = (systemVec[i]->roiWord0() >> 26) & 1; 
        isRestrictedMap[i] = isRestricted;
        if (isRestricted) {
            nslicesRestricted++;
        }else{
            nslicesFull++;
        }
        // ATH_MSG_DEBUG("isRestriced=" << isRestricted << " slice=" << (isRestricted? nslicesRestricted: nslicesFull) 
        //  <<  " et=" << systemVec[i]->et() << " etSumHits=" << systemVec[i]->etSumHits());
    }
 
    std::vector<uint16_t> dataFull(nslicesFull);
    std::vector<uint32_t> errorFull(nslicesFull);
 
    std::vector<uint16_t> dataRestricted(nslicesRestricted);
    std::vector<uint32_t> errorRestricted(nslicesRestricted);
    
    int iSliceFull = 0;
    int iSliceRestricted = 0;
    int *iSlice = 0;
 
    for (unsigned int i = 0; i < systemVec.size(); ++i)
    {
        SystemEnergy *energy = systemVec[i];
        bool restricted = isRestrictedMap[i];
 
        std::vector<uint16_t>* data;
        std::vector<uint32_t>* error;
        if (restricted)
        {
            sumEt = &sumEtRestricted;
            missEt = &missEtRestricted;
            missEtSig = &missEtSigRestricted;
            iSlice = &iSliceRestricted;
            data = &dataRestricted;
            error = &errorRestricted;
        }
        else
        {
            sumEt = &sumEtFull;
            missEt = &missEtFull;
            missEtSig = &missEtSigFull;
            iSlice = &iSliceFull;
            data = &dataFull;
            error = &errorFull;
        }
 
        unsigned int slice = *iSlice;
 
 
        unsigned int etSumHits = energy->etSumHits();
        if (etSumHits)
        {
            if (!*sumEt)
            {
                *sumEt = new xAOD::CMXEtSums;
                (*sumEt)->makePrivateStore();
                (*sumEt)->initialize(1, restricted
                                            ? CMXEtSums::SUM_ET_RESTRICTED
                                            : CMXEtSums::SUM_ET_STANDARD,
                                     *data, *data, *data, *error, *error, *error, peak);
                cmxEtSumsVec->push_back(*sumEt);
            }
            std::vector<uint16_t> etVec((*sumEt)->etVec());
            etVec[slice] = etSumHits;
 
            (*sumEt)->addEx(etVec, *error);
            (*sumEt)->addEy(etVec, *error);
            (*sumEt)->addEt(etVec, *error);
 
            // ATH_MSG_DEBUG("slice=" << slice << " restricted=" << restricted << " etVec=" << (*sumEt)->etVec() << " etSumHits=" << etSumHits);
        }
        unsigned int etMissHits = energy->etMissHits();
        if (etMissHits)
        {
            if (!*missEt)
            {
                *missEt = new xAOD::CMXEtSums;
                (*missEt)->makePrivateStore();
                (*missEt)->initialize(1, restricted
                                             ? CMXEtSums::MISSING_ET_RESTRICTED
                                             : CMXEtSums::MISSING_ET_STANDARD,
                                      *data, *data, *data, *error, *error, *error, peak);
                cmxEtSumsVec->push_back(*missEt);
            }
            std::vector<uint16_t> etVec((*missEt)->etVec());
            etVec[slice] = etMissHits;
            (*missEt)->addEx(etVec, *error);
            (*missEt)->addEy(etVec, *error);
            (*missEt)->addEt(etVec, *error);
        }
        unsigned int etMissSigHits = energy->metSigHits();
        if (etMissSigHits)
        {
            if (!*missEtSig)
            {
                *missEtSig = new xAOD::CMXEtSums;
                (*missEtSig)->makePrivateStore();
                (*missEtSig)->initialize(1, CMXEtSums::MISSING_ET_SIG_STANDARD, *data, *data, *data, *error, *error, *error, peak);
                cmxEtSumsVec->push_back(*missEtSig);
            }
            std::vector<uint16_t> etVec((*missEtSig)->etVec());
            etVec[slice] = etMissSigHits;
            (*missEtSig)->addEx(etVec, *error);
            (*missEtSig)->addEy(etVec, *error);
            (*missEtSig)->addEt(etVec, *error);
        }
        (*iSlice)++;
    }
}

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.

{
    peak = 0;
    unsigned int nslicesFull = 0;
    unsigned int nslicesRestricted = 0;
    xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
    xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
    
    MultiSliceCrateEnergy *crateVec = nullptr;
    unsigned int *nslices = nullptr;
    bool restricted = false;
    for (; pos != pose; ++pos)
    {
        const xAOD::CMXEtSums *sums = *pos;
        int crate = sums->crate();
        if (crate != 1)
            continue;
        int source = sums->sourceComponent();
        if (source != xAOD::CMXEtSums::LOCAL_STANDARD && source != xAOD::CMXEtSums::LOCAL_RESTRICTED
            && source != xAOD::CMXEtSums::REMOTE_STANDARD && source != xAOD::CMXEtSums::REMOTE_RESTRICTED)
            continue;
        if (source == xAOD::CMXEtSums::REMOTE_STANDARD || source == xAOD::CMXEtSums::REMOTE_RESTRICTED)
            crate = 0; // SASHA: check
        if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED || source == xAOD::CMXEtSums::REMOTE_RESTRICTED){
            crateVec = &crateVecRestricted;
            nslices = &nslicesRestricted;
            restricted = true;
        }else{
            crateVec = &crateVecFull;
            nslices = &nslicesFull;
            restricted = false;
        }
        if (sums->peak() > peak)
            peak = sums->peak();
        const EnergyVector &ex(sums->exVec());
        const EnergyVector &ey(sums->eyVec());
        const EnergyVector &et(sums->etVec());
        const ErrorVector &exErrVec(sums->exErrorVec());
        const ErrorVector &eyErrVec(sums->eyErrorVec());
        const ErrorVector &etErrVec(sums->etErrorVec());
        unsigned int slices = et.size();
 
        if (slices > *nslices)
        {
            for (unsigned int i = *nslices; i < slices; ++i)
            {
                crateVec->push_back(new DataVector<CrateEnergy>);
            }
            *nslices = slices;
        }
        for (unsigned int sl = 0; sl < slices; ++sl)
        {
            DataVector<CrateEnergy> *crates = (*crateVec)[sl];
            DataError exErr(exErrVec[sl]);
            DataError eyErr(eyErrVec[sl]);
            DataError etErr(etErrVec[sl]);
            crates->push_back(new CrateEnergy(crate, et[sl], ex[sl], ey[sl],
                                              etErr.get(DataError::Overflow),
                                              exErr.get(DataError::Overflow),
                                              eyErr.get(DataError::Overflow), restricted));
        }
    }
 
    dumpCrateEnergies("Crates from full region (for total)", crateVecFull);
    dumpCrateEnergies("Crates from restricted region (for total)", crateVecRestricted);
}

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.

{
    peak = 0;
    unsigned int nslices = 0;
    xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
    xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
    for (; pos != pose; ++pos)
    {
        const xAOD::CMXEtSums *sums = *pos;
        int source = sums->sourceComponent();
        if (source > 15)
            continue;
        int crate = sums->crate();
        if (sums->peak() > peak)
            peak = sums->peak();
        const EnergyVector &ex(sums->exVec());
        const EnergyVector &ey(sums->eyVec());
        const EnergyVector &et(sums->etVec());
        unsigned int slices = et.size();
        if (slices > nslices)
        {
            for (unsigned int i = nslices; i < slices; ++i)
            {
                modulesVec.push_back(new DataVector<ModuleEnergy>);
            }
            nslices = slices;
        }
        for (unsigned int sl = 0; sl < slices; ++sl)
        {
            DataVector<ModuleEnergy> *modules = modulesVec[sl];
            modules->push_back(new ModuleEnergy(crate, source,
                                                et[sl], ex[sl], ey[sl]));
        }
    }
}

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.

{
    peak = 0;
    xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
    xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
    for (; pos != pose; ++pos)
    {
        const xAOD::CMXEtSums *sums = *pos;
        int source = sums->sourceComponent();
        if (source != xAOD::CMXEtSums::TOTAL_STANDARD && source != xAOD::CMXEtSums::TOTAL_RESTRICTED)
            continue;
        if (sums->peak() > peak)
            peak = sums->peak();
        const EnergyVector &ex(sums->exVec());
        const EnergyVector &ey(sums->eyVec());
        const EnergyVector &et(sums->etVec());
        const ErrorVector &exErrVec(sums->exErrorVec());
        const ErrorVector &eyErrVec(sums->eyErrorVec());
        const ErrorVector &etErrVec(sums->etErrorVec());
        unsigned int slices = et.size();
        auto l1Menu = SG::makeHandle( m_L1MenuKey );
        for (unsigned int sl = 0; sl < slices; ++sl)
        {
            DataError exErr(exErrVec[sl]);
            DataError eyErr(eyErrVec[sl]);
            DataError etErr(etErrVec[sl]);
            auto systemEnergy = new SystemEnergy(et[sl], ex[sl], ey[sl],
                                                 etErr.get(DataError::Overflow),
                                                 exErr.get(DataError::Overflow),
                                                 eyErr.get(DataError::Overflow),
                                                 source == xAOD::CMXEtSums::TOTAL_RESTRICTED,
                                                 &(*l1Menu));
            // bool srestricted = (systemEnergy->roiWord0() >> 26) & 1;
            systemVec.push_back(systemEnergy);
        }
    }
}

evtStore()

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.

{ 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.

{
    return StatusCode::SUCCESS;
}

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.

{
    using TrigConf::L1DataDef;
    const float moduleEta[8] = {-4.,-2.,-1.2,-0.4,0.4,1.2,2.,4.};
    maskXE =  0;
    maskTE =  0;
    bool maskXESet = false;
    bool maskTESet = false;
 
    auto l1Menu = SG::makeHandle( m_L1MenuKey );
    std::vector<std::shared_ptr<TrigConf::L1Threshold>> allThresholds = l1Menu->thresholds();
    for ( const auto& thresh : allThresholds ) {
      if ( ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE) ||
             thresh->type() == L1DataDef::typeAsString(L1DataDef::TE) ) && thresh->mapping() > 7 ) {
        auto thresh_Calo = static_cast<TrigConf::L1Threshold_Calo*>(thresh.get());
        auto tvcs = thresh_Calo->thrValuesCounts();
        // Make sure only set masks from the first valid threshold in the range (for each type)
        if (maskXE > 0) maskXESet = true;
        if (maskTE > 0) maskTESet = true;
        if (tvcs.size() == 0) {
          tvcs.addRangeValue(thresh_Calo->thrValueCounts(),-49, 49, 1, true);
        }
        for (const auto& tVC : tvcs) {
          // Bits are set false by default, so ignore thresholds that are just doing that
          if (tVC.value() >= 0x7fff) continue;
          // Set bits true if module centre between etaMin and etaMax
          if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE)  && !maskXESet ) {
            for (unsigned int bin = 0; bin < 8; ++bin) {
              if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
                maskXE |= (1<<bin);
            }
          }
          else if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::TE)  && !maskTESet ) {
            for (unsigned int bin = 0; bin < 8; ++bin) {
              if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
                maskTE |= (1<<bin);
            }
          }
        }  // loop over TTV
      } // Is this XE or TE threshold?
    }
}

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.

{
    formCMXEtSumsModule(jemEtSumsVec, cmxEtSumsVec);
    // Convert to internal containers
    int peak = 0;
    MultiSliceModuleEnergy modulesVec;
    MultiSliceCrateEnergy cratesVec;
    MultiSliceSystemEnergy systemVec;
    etSumsToModuleEnergy(cmxEtSumsVec, modulesVec, peak);
    // Process each slice
    MultiSliceModuleEnergy::iterator iter = modulesVec.begin();
    MultiSliceModuleEnergy::iterator iterE = modulesVec.end();
 
    auto l1Menu = SG::makeHandle( m_L1MenuKey );
    for (; iter != iterE; ++iter)
    {
        DataVector<ModuleEnergy> *modules = *iter;
        DataVector<CrateEnergy> *crates = new DataVector<CrateEnergy>;
        cratesVec.push_back(crates);
        m_etTool->crateSums(modules, crates);
        systemVec.push_back(new SystemEnergy(crates, &(*l1Menu)));
        delete modules;
    }
    // Convert back to CMXEtSums
    crateEnergyToEtSums(cratesVec, cmxEtSumsVec, peak);
    MultiSliceCrateEnergy::iterator citer = cratesVec.begin();
    MultiSliceCrateEnergy::iterator citerE = cratesVec.end();
    for (; citer != citerE; ++citer)
        delete *citer;
    systemEnergyToEtSums(systemVec, cmxEtSumsVec, peak);
    etMapsToEtSums(systemVec, cmxEtSumsVec, peak);
    MultiSliceSystemEnergy::iterator siter = systemVec.begin();
    MultiSliceSystemEnergy::iterator siterE = systemVec.end();
    for (; siter != siterE; ++siter)
        delete *siter;
}

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.

{
    uint32_t maskXE, maskTE;
    findRestrictedEta(maskXE, maskTE);
    ATH_MSG_DEBUG("Restricted eta masks: XE=" << MSG::hex << maskXE << ", TE=" << maskTE << MSG::dec);
    // Convert to internal containers
    int peak = 0;
    MultiSliceModuleEnergy modulesVec;
    MultiSliceCrateEnergy cratesVecFull;
    MultiSliceCrateEnergy cratesVecRestricted;
    etSumsToModuleEnergy(cmxEtSumsMod, modulesVec, peak);
    // Process each slice
    for (auto iter : modulesVec)
    {
        DataVector<ModuleEnergy> *modules = iter;
        DataVector<CrateEnergy> *cratesFull = new DataVector<CrateEnergy>;
        DataVector<CrateEnergy> *cratesRestricted = new DataVector<CrateEnergy>;
        cratesVecFull.push_back(cratesFull);
        cratesVecRestricted.push_back(cratesRestricted);
        m_etTool->crateSums(modules, cratesFull);
        m_etTool->crateSums(modules, cratesRestricted, maskXE, maskTE, true);
        delete modules;
    }
 
    // Convert back to CMXEtSums
    crateEnergyToEtSums(cratesVecFull, cratesVecRestricted, cmxEtSumsCrate, peak);
    // crateEnergyToEtSums(cratesVecRestricted, cmxEtSumsCrate, peak);
 
    for (auto crate : cratesVecFull)
    {
        delete crate;
    }
    for (auto crate : cratesVecRestricted)
    {
        delete crate;
    }
}

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.

{
    // Convert to internal objects
    int peak = 0;
    MultiSliceSystemEnergy systemVec;
    etSumsToSystemEnergy(cmxEtSumsSys, systemVec, peak);
    // Convert back to CMXEtSums
    etMapsToEtSums(systemVec, cmxEtSumsMap, peak);
    MultiSliceSystemEnergy::iterator iter = systemVec.begin();
    MultiSliceSystemEnergy::iterator iterE = systemVec.end();
    for (; iter != iterE; ++iter)
        delete *iter;
}

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.

{
    xAOD::JEMEtSumsContainer::const_iterator pos = jemEtSumsVec->begin();
    xAOD::JEMEtSumsContainer::const_iterator pose = jemEtSumsVec->end();
    for (; pos != pose; ++pos)
    {
        const xAOD::JEMEtSums *sums = *pos;
        ErrorVector err(sums->etVec().size());
        auto item = new xAOD::CMXEtSums;
        item->makePrivateStore();
        item->initialize(sums->crate(), sums->module(),
                         sums->etVec(), sums->exVec(), sums->eyVec(),
                         err, err, err, sums->peak());
        cmxEtSumsMod->push_back(item);
    }
}

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.

{
    // Convert to internal containers
    int peak = 0;
    MultiSliceCrateEnergy cratesVecFull;
    MultiSliceCrateEnergy cratesVecRestricted;
    
    MultiSliceSystemEnergy systemVecFull;
    MultiSliceSystemEnergy systemVecRestricted;
    auto l1Menu = SG::makeHandle( m_L1MenuKey );
    etSumsToCrateEnergy(cmxEtSumsCrate, cratesVecFull, cratesVecRestricted, peak);
    for (int i = 0; i < 2; i++)
    {
        MultiSliceCrateEnergy *cratesVec = i == 0? &cratesVecFull: &cratesVecRestricted;
        MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
        // Process each slice
        MultiSliceCrateEnergy::iterator iter = (*cratesVec).begin();
        MultiSliceCrateEnergy::iterator iterE = (*cratesVec).end();
        for (; iter != iterE; ++iter)
        {
            DataVector<CrateEnergy> *crates = *iter;
            //systemVec.push_back(new SystemEnergy(m_etTool->systemSums(crates)));
            systemVec->push_back(new SystemEnergy(crates, &(*l1Menu)));
            delete crates;
        }
    }
    // Convert back to CMXEtSums
    systemEnergyToEtSums(systemVecFull, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_STANDARD);
    systemEnergyToEtSums(systemVecRestricted, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_RESTRICTED);
 
    for (int i = 0; i < 2; i++)
    {
        MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
        MultiSliceSystemEnergy::iterator siter = (*systemVec).begin();
        MultiSliceSystemEnergy::iterator siterE = (*systemVec).end();
        for (; siter != siterE; ++siter)
            delete *siter;
    }
}

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.

{
    // Find number of slices
    int peak = 0;
    unsigned int nslices = 1;
    xAOD::JetElementContainer::const_iterator iter = jetElementVec->begin();
    xAOD::JetElementContainer::const_iterator iterE = jetElementVec->end();
    for (; iter != iterE; ++iter)
    {
        if ((*iter)->emJetElementETVec().size() > nslices)
        {
            nslices = (*iter)->emJetElementETVec().size();
            peak = (*iter)->peak();
            break;
        }
        if ((*iter)->hadJetElementETVec().size() > nslices)
        {
            nslices = (*iter)->hadJetElementETVec().size();
            peak = (*iter)->peak();
            break;
        }
    }
    // Process each slice
    xAOD::JetElementMap_t jeMap;
    m_jeTool->mapJetElements(jetElementVec, &jeMap);
    MultiSliceModuleEnergy modulesVec;
    for (unsigned int slice = 0; slice < nslices; ++slice)
    {
        DataVector<ModuleEnergy> *modules = new DataVector<ModuleEnergy>;
        modulesVec.push_back(modules);
        m_etTool->moduleSums(&jeMap, modules, slice);
    }
    // Convert to JEMEtSums
    moduleEnergyToEtSums(modulesVec, jemEtSumsVec, peak);
    MultiSliceModuleEnergy::iterator miter = modulesVec.begin();
    MultiSliceModuleEnergy::iterator miterE = modulesVec.end();
    for (; miter != miterE; ++miter)
        delete *miter;
}

initialize()

StatusCode LVL1::L1EnergyCMXTools::initialize ( )

virtual

standard Athena-Algorithm method

Initialisation.

Definition at line 45 of file L1EnergyCMXTools.cxx.

{
    m_debug = msgLvl(MSG::DEBUG);
    ATH_CHECK( m_L1MenuKey.initialize() );
 
    // Retrieve jet element tool
 
    ATH_CHECK(m_jeTool.retrieve());
    ATH_CHECK(m_etTool.retrieve());
 
    return StatusCode::SUCCESS;
}

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.

    { 
      return IID_IL1EnergyCMXTools;
    }

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.

{
    std::map<int, xAOD::JEMEtSums *> etMap;
    unsigned int nslices = modulesVec.size();
    std::vector<uint16_t> dummy(nslices);
    for (unsigned int slice = 0; slice < nslices; ++slice)
    {
        const DataVector<ModuleEnergy> *modules = modulesVec[slice];
        DataVector<ModuleEnergy>::const_iterator pos = modules->begin();
        DataVector<ModuleEnergy>::const_iterator pose = modules->end();
        for (; pos != pose; ++pos)
        {
            const ModuleEnergy *energy = *pos;
            //unsigned int ex = energy->exCompressed();
            //unsigned int ey = energy->eyCompressed();
            //unsigned int et = energy->etCompressed();
            unsigned int ex = energy->ex();
            unsigned int ey = energy->ey();
            unsigned int et = energy->et();
            if (ex == 0 && ey == 0 && et == 0)
                continue;
            int crate = energy->crate();
            int module = energy->module();
            xAOD::JEMEtSums *sums = 0;
            int key = crate * 100 + module;
            std::map<int, xAOD::JEMEtSums *>::iterator iter = etMap.find(key);
            if (iter == etMap.end())
            {
                sums = new xAOD::JEMEtSums;
                sums->makePrivateStore();
                sums->initialize(crate, module, dummy, dummy, dummy, peak);
                etMap.insert(std::make_pair(key, sums));
                jemEtSumsVec->push_back(sums);
            }
            else
                sums = iter->second;
            std::vector<uint16_t> exVec(sums->exVec());
            std::vector<uint16_t> eyVec(sums->eyVec());
            std::vector<uint16_t> etVec(sums->etVec());
            exVec[slice] = ex;
            eyVec[slice] = ey;
            etVec[slice] = et;
            sums->setExVec(exVec);
            sums->setEyVec(eyVec);
            sums->setEtVec(etVec);
        }
    }
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

{
    xAOD::CMXEtSums *sums = nullptr;
 
    unsigned int nslices = systemVec.size();
    std::vector<uint16_t> data(nslices);
    std::vector<uint32_t> error(nslices);
    for (unsigned int slice = 0; slice < nslices; ++slice)
    {
        SystemEnergy *energy = systemVec[slice];
        unsigned int ex = energy->exTC();
        unsigned int ey = energy->eyTC();
        unsigned int et = energy->et();
        int exOverflow = energy->exOverflow();
        int eyOverflow = energy->eyOverflow();
        int etOverflow = energy->etOverflow();
        
        // don't trust to exOverflow for restricted
        if (ex == 0 && ey == 0 && et == 0 &&
            exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
            continue;
        if (!sums)
        {
            sums = new xAOD::CMXEtSums;
            sums->makePrivateStore();
            sums->initialize(1, source, data, data, data,
                                error, error, error, peak);
            cmxEtSumsVec->push_back(sums);
        }
        std::vector<uint16_t> exVec(sums->exVec());
        std::vector<uint16_t> eyVec(sums->eyVec());
        std::vector<uint16_t> etVec(sums->etVec());
        std::vector<uint32_t> exErr(sums->exErrorVec());
        std::vector<uint32_t> eyErr(sums->eyErrorVec());
        std::vector<uint32_t> etErr(sums->etErrorVec());
        exVec[slice] = ex;
        eyVec[slice] = ey;
        etVec[slice] = et;
 
        if (exOverflow)
        {
            DataError dEx(exErr[slice]);
            dEx.set(DataError::Overflow);
            exErr[slice] = dEx.error();
        }
 
        if (eyOverflow)
        {
            DataError dEy(eyErr[slice]);
            dEy.set(DataError::Overflow);
            eyErr[slice] = dEy.error();
        }
        if (etOverflow)
        {
            DataError dEt(etErr[slice]);
            dEt.set(DataError::Overflow);
            etErr[slice] = dEt.error();
        }
        sums->addEx(exVec, exErr);
        sums->addEy(eyVec, eyErr);
        sums->addEt(etVec, etErr);
    }
}

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_debug

bool LVL1::L1EnergyCMXTools::m_debug = false

private

Debug flag.

Definition at line 124 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 122 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 120 of file L1EnergyCMXTools.h.

m_L1MenuKey

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

private

Definition at line 118 of file L1EnergyCMXTools.h.

{ this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" };

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:

• L1EnergyCMXTools.h
• L1EnergyCMXTools.cxx