LVL1::L1JetCMXTools Class Reference

This is a tool to reconstruct the L1 JEM and CMX-Jet hits from RoIs. More...

#include <L1JetCMXTools.h>

Inheritance diagram for LVL1::L1JetCMXTools:

Collaboration diagram for LVL1::L1JetCMXTools:

Public Member Functions
	L1JetCMXTools (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~L1JetCMXTools ()
	default destructor
virtual StatusCode	initialize ()
	standard Athena-Algorithm method
virtual void	formCMXJetTob (const xAOD::JEMTobRoIContainer *jemRoiVec, xAOD::CMXJetTobContainer *cmxTobVec) const
	form CMX-Jet TOBs from RoIs - single slice
virtual void	formCMXJetTob (const std::vector< const xAOD::JEMTobRoIContainer * > &jemRoiColls, xAOD::CMXJetTobContainer *cmxTobVec, int peak) const
	form CMX-Jet TOBs from RoIs - multiple slices
virtual void	formCMXJetHits (const xAOD::CMXJetTobContainer *cmxTobVec, xAOD::CMXJetHitsContainer *cmxHitsVec) const
	form complete CMX-Jet hits from CMX-Jet TOBs
virtual void	formCMXJetHitsCrate (const xAOD::CMXJetTobContainer *cmxTobVec, xAOD::CMXJetHitsContainer *cmxHitsCrate) const
	form partial CMX-Jet hits (crate) from CMX-Jet TOBs
virtual void	formCMXJetHitsSystem (const xAOD::CMXJetHitsContainer *cmxHitsCrate, xAOD::CMXJetHitsContainer *cmxHitsSys) const
	form partial CMX-Jet hits (system) from crate CMX-Jet hits
virtual void	formCMXJetHitsTopo (const xAOD::CMXJetTobContainer *cmxTobVec, xAOD::CMXJetHitsContainer *cmxHitsTopo) const
	form partial CMX-Jet hits (topo) from system CMX-Jet TOBs
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
enum	HitsType { MAIN_HITS , FORWARD_HITS }
typedef std::vector< uint32_t >	HitsVector
typedef std::vector< uint32_t >	ErrorVector
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	getHits (const xAOD::CMXJetTob *tob, HitsVector &hit10, HitsVector &hit11, HitsVector &hit20, HitsVector &hit21) const
	Get hit map.
void	addOverflow (ErrorVector &hitErr, const ErrorVector &tobErr) const
	Add overflow bit.
void	addCMXJetHits (HitsVector &vec1, const HitsVector &vec2, HitsType type) const
	Add hits from second vector to first.
unsigned int	addHits (unsigned int hitMult, unsigned int hitVec, int multBits, int vecBits, int nthresh) const
	Increment JEM/CMX hit word.
void	mergeCMXJetHits (xAOD::CMXJetHitsContainer *cmxHitsVec1, xAOD::CMXJetHitsContainer *cmxHitsVec2) const
	Merge CMX-Jet hits vectors.
void	saveCMXJetHits (xAOD::CMXJetHitsContainer *cmxHitsVec, const HitsVector &hits0, const HitsVector &hits1, const ErrorVector &err0, const ErrorVector &err1, int crate, int source, int peak) const
	Save non-zero CMX-Jet hits.
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" }
int	m_crates
	Number of crates.
int	m_modules
	Number of JEM modules per crate.
int	m_maxTobs
	Maximum number of TOBs per module to CMXs.
int	m_sysCrate
	System crate number.
bool	m_debug
	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-Jet hits from RoIs.

Used for offline monitoring and trigger reconstruction.

Useage: L1JetCMXTools->formJEMTobRoI() // convert to JEMTobRoI from other RoI classes L1JetCMXTools->formCMXJetTob() // form CMX-Jet TOBs from JEMTobRoIs L1JetCMXTools->formCMXJetHits() // form CMX-Jet hits from CMXJetTobs

@author  Peter Faulkner

Definition at line 36 of file L1JetCMXTools.h.

Member Typedef Documentation

ErrorVector

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

private

Definition at line 77 of file L1JetCMXTools.h.

HitsVector

typedef std::vector<uint32_t> LVL1::L1JetCMXTools::HitsVector

private

Definition at line 76 of file L1JetCMXTools.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

HitsType

enum LVL1::L1JetCMXTools::HitsType

private

Enumerator
MAIN_HITS
FORWARD_HITS

Definition at line 74 of file L1JetCMXTools.h.

{ MAIN_HITS, FORWARD_HITS };

Constructor & Destructor Documentation

L1JetCMXTools()

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

Constructor.

Definition at line 34 of file L1JetCMXTools.cxx.

    : AthAlgTool(type, name, parent),
      m_crates(2),
      m_modules(16), m_maxTobs(4), m_sysCrate(1), m_debug(false) {
  declareInterface<IL1JetCMXTools>(this);
}

~L1JetCMXTools()

LVL1::L1JetCMXTools::~L1JetCMXTools ( )

virtual

default destructor

Destructor.

Definition at line 44 of file L1JetCMXTools.cxx.

{}

Member Function Documentation

addCMXJetHits()

void LVL1::L1JetCMXTools::addCMXJetHits ( HitsVector & vec1, const HitsVector & vec2, HitsType type ) const

private

Add hits from second vector to first.

Definition at line 409 of file L1JetCMXTools.cxx.

                                                       {
  int size1 = vec1.size();
  int size2 = vec2.size();
  if (size1 < size2)
    vec1.resize(size2);
  HitsVector::iterator pos1 = vec1.begin();
  HitsVector::iterator pose1 = vec1.end();
  HitsVector::const_iterator pos2 = vec2.begin();
  HitsVector::const_iterator pose2 = vec2.end();
  for (; pos1 != pose1 && pos2 != pose2; ++pos1, ++pos2) {
    if (type == MAIN_HITS)
      *pos1 = addHits(*pos1, *pos2, 15, 15, 5);
    else
      *pos1 = addHits(*pos1, *pos2, 16, 16, 8);
  }
}

addHits()

unsigned int LVL1::L1JetCMXTools::addHits ( unsigned int hitMult, unsigned int hitVec, int multBits, int vecBits, int nthresh ) const

private

Increment JEM/CMX hit word.

Definition at line 429 of file L1JetCMXTools.cxx.

                                                       {
  if (m_debug)
    msg(MSG::DEBUG) << "addHits: Original hitMult = " << std::hex << hitMult
                    << ". Add hitWord = " << hitVec << std::dec << endmsg;
 
  int nbitsOut = multBits / nthresh;
  int nbitsIn = vecBits / nthresh;
 
  if (m_debug)
    msg(MSG::DEBUG) << " Bits per threshold = " << nbitsOut << endmsg;
 
  int max = (1 << nbitsOut) - 1;
  unsigned int multMask = max;
  unsigned int hitMask = (1 << nbitsIn) - 1;
  unsigned int shift = 0;
 
  unsigned int hits = 0;
 
  for (int i = 0; i < nthresh; i++) {
    int mult = (hitMult & multMask) + (hitVec & hitMask);
    mult = ((mult <= max) ? mult : max);
    hits += (mult << shift);
 
    hitMult >>= nbitsOut;
    hitVec >>= nbitsIn;
    shift += nbitsOut;
  }
 
  if (m_debug)
    msg(MSG::DEBUG) << "addHits returning hitMult = " << std::hex << hits
                    << std::dec << endmsg;
 
  return hits;
}

addOverflow()

void LVL1::L1JetCMXTools::addOverflow ( ErrorVector & hitErr, const ErrorVector & tobErr ) const

private

Add overflow bit.

Definition at line 391 of file L1JetCMXTools.cxx.

                                                                 {
  const int timeslices = tobErr.size();
  hitErr.resize(timeslices);
  for (int slice = 0; slice < timeslices; ++slice) {
    int error = tobErr[slice];
    if (error) {
      LVL1::DataError err(error);
      int overflow = err.get(LVL1::DataError::Overflow);
      LVL1::DataError err2;
      err2.set(LVL1::DataError::Overflow, overflow);
      hitErr[slice] |= err2.error();
    }
  }
}

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; }

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

formCMXJetHits()

void LVL1::L1JetCMXTools::formCMXJetHits ( const xAOD::CMXJetTobContainer * cmxTobVec, xAOD::CMXJetHitsContainer * cmxHitsVec ) const

virtual

form complete CMX-Jet hits from CMX-Jet TOBs

Implements LVL1::IL1JetCMXTools.

Definition at line 144 of file L1JetCMXTools.cxx.

                                               {
  xAOD::CMXJetHitsContainer *cmxHitsCrate = new xAOD::CMXJetHitsContainer;
  xAOD::CMXJetHitsContainer *cmxHitsSys = new xAOD::CMXJetHitsContainer;
  xAOD::CMXJetHitsContainer *cmxHitsTopo = new xAOD::CMXJetHitsContainer;
 
  formCMXJetHitsCrate(cmxTobVec, cmxHitsCrate);
  formCMXJetHitsSystem(cmxHitsCrate, cmxHitsSys);
  formCMXJetHitsTopo(cmxTobVec, cmxHitsTopo);
 
  mergeCMXJetHits(cmxHitsVec, cmxHitsCrate);
  mergeCMXJetHits(cmxHitsVec, cmxHitsSys);
  mergeCMXJetHits(cmxHitsVec, cmxHitsTopo);
 
  delete cmxHitsCrate;
  delete cmxHitsSys;
  delete cmxHitsTopo;
}

formCMXJetHitsCrate()

void LVL1::L1JetCMXTools::formCMXJetHitsCrate ( const xAOD::CMXJetTobContainer * cmxTobVec, xAOD::CMXJetHitsContainer * cmxHitsCrate ) const

virtual

form partial CMX-Jet hits (crate) from CMX-Jet TOBs

Implements LVL1::IL1JetCMXTools.

Definition at line 164 of file L1JetCMXTools.cxx.

                                                 {
  int peakm = 0;
  std::vector<HitsVector> hitVecM(2 * m_crates);
  std::vector<HitsVector> hitVecF(2 * m_crates);
  std::vector<ErrorVector> errVecM(2 * m_crates); // Need overflow
  std::vector<ErrorVector> errVecF(2 * m_crates);
  HitsVector hit10, hit20;
  HitsVector hit11, hit21;
  xAOD::CMXJetTobContainer::const_iterator pos = cmxTobVec->begin();
  xAOD::CMXJetTobContainer::const_iterator pose = cmxTobVec->end();
  for (; pos != pose; ++pos) {
    const xAOD::CMXJetTob *tob = *pos;
    const int index = 2 * tob->crate();
    const std::vector<uint32_t> error(tob->errorVec());
    hit10.clear();
    hit11.clear();
    hit20.clear();
    hit21.clear();
    getHits(tob, hit10, hit11, hit20, hit21);
 
    addCMXJetHits(hitVecM[index], hit10, MAIN_HITS);
    addCMXJetHits(hitVecM[index + 1], hit11, MAIN_HITS);
    addCMXJetHits(hitVecF[index], hit20, FORWARD_HITS);
    addCMXJetHits(hitVecF[index + 1], hit21, FORWARD_HITS);
 
    addOverflow(errVecF[index], error);
    addOverflow(errVecF[index + 1], error);
    addOverflow(errVecM[index], error);
    addOverflow(errVecM[index + 1], error);
    const int peak = tob->peak();
    if (peak > peakm)
      peakm = peak;
  }
  // Save non-zero crate totals
  for (int crate = 0; crate < m_crates; ++crate) {
    const int index = crate * 2;
    saveCMXJetHits(cmxHitsCrate, hitVecM[index], hitVecM[index + 1],
                   errVecM[index], errVecM[index + 1], crate,
                   xAOD::CMXJetHits::LOCAL_MAIN, peakm);
    saveCMXJetHits(cmxHitsCrate, hitVecF[index], hitVecF[index + 1],
                   errVecF[index], errVecF[index + 1], crate,
                   xAOD::CMXJetHits::LOCAL_FORWARD, peakm);
    if (crate != m_sysCrate) { // REMOTE totals
      saveCMXJetHits(cmxHitsCrate, hitVecM[index], hitVecM[index + 1],
                     errVecM[index], errVecM[index + 1], m_sysCrate,
                     xAOD::CMXJetHits::REMOTE_MAIN, peakm);
      saveCMXJetHits(cmxHitsCrate, hitVecF[index], hitVecF[index + 1],
                     errVecF[index], errVecF[index + 1], m_sysCrate,
                     xAOD::CMXJetHits::REMOTE_FORWARD, peakm);
    }
  }
}

formCMXJetHitsSystem()

void LVL1::L1JetCMXTools::formCMXJetHitsSystem ( const xAOD::CMXJetHitsContainer * cmxHitsCrate, xAOD::CMXJetHitsContainer * cmxHitsSys ) const

virtual

form partial CMX-Jet hits (system) from crate CMX-Jet hits

Implements LVL1::IL1JetCMXTools.

Definition at line 219 of file L1JetCMXTools.cxx.

                                               {
  int peakm = 0;
  HitsVector systemMain0(1);
  HitsVector systemMain1(1);
  HitsVector systemFwd0(1);
  HitsVector systemFwd1(1);
  ErrorVector errVec(1);
  xAOD::CMXJetHitsContainer::const_iterator pos = cmxHitsCrate->begin();
  xAOD::CMXJetHitsContainer::const_iterator pose = cmxHitsCrate->end();
  for (; pos != pose; ++pos) {
    const xAOD::CMXJetHits *hits = *pos;
    if (hits->crate() != m_sysCrate)
      continue;
    int source = hits->sourceComponent();
    if (source != xAOD::CMXJetHits::LOCAL_MAIN &&
        source != xAOD::CMXJetHits::LOCAL_FORWARD &&
        source != xAOD::CMXJetHits::REMOTE_MAIN &&
        source != xAOD::CMXJetHits::REMOTE_FORWARD)
      continue;
    int peak = hits->peak();
    if (peak > peakm)
      peakm = peak;
    HitsVector hitsVec0(hits->hitsVec0());
    HitsVector hitsVec1(hits->hitsVec1());
    if (source == xAOD::CMXJetHits::LOCAL_MAIN ||
        source == xAOD::CMXJetHits::REMOTE_MAIN) {
      addCMXJetHits(systemMain0, hitsVec0, MAIN_HITS);
      addCMXJetHits(systemMain1, hitsVec1, MAIN_HITS);
    } else {
      addCMXJetHits(systemFwd0, hitsVec0, FORWARD_HITS);
      addCMXJetHits(systemFwd1, hitsVec1, FORWARD_HITS);
    }
    ErrorVector error(hits->errorVec0()); // all have same error so redundant?
    addOverflow(errVec, error);
  }
  // Save non-zero system totals
  saveCMXJetHits(cmxHitsSys, systemMain0, systemMain1, errVec, errVec,
                 m_sysCrate, CMXJetHits::TOTAL_MAIN, peakm);
  saveCMXJetHits(cmxHitsSys, systemFwd0, systemFwd1, errVec, errVec, m_sysCrate,
                 CMXJetHits::TOTAL_FORWARD, peakm);
}

formCMXJetHitsTopo()

void LVL1::L1JetCMXTools::formCMXJetHitsTopo ( const xAOD::CMXJetTobContainer * cmxTobVec, xAOD::CMXJetHitsContainer * cmxHitsTopo ) const

virtual

form partial CMX-Jet hits (topo) from system CMX-Jet TOBs

Implements LVL1::IL1JetCMXTools.

Definition at line 263 of file L1JetCMXTools.cxx.

                                                {
  int peakm = 0;
  int timeslices = 0;
  std::vector<HitsVector> hitVec(4 * m_crates);
  xAOD::CMXJetTobContainer::const_iterator pos = cmxTobVec->begin();
  xAOD::CMXJetTobContainer::const_iterator pose = cmxTobVec->end();
  for (; pos != pose; ++pos) {
    const xAOD::CMXJetTob *tob = *pos;
    const int crate = tob->crate();
    const int jem = tob->jem();
    const int frame = tob->frame();
    const int loc = tob->location();
    const int index = crate * 4;
    const std::vector<int> energyLg(tob->energyLargeVec().begin(),
                                    tob->energyLargeVec().end());
    const std::vector<int> energySm(tob->energySmallVec().begin(),
                                    tob->energySmallVec().end());
    // const std::vector<int>& error(tob->errorVec());
    timeslices = energyLg.size();
    HitsVector &checksum(hitVec[index]);
    HitsVector &map(hitVec[index + 1]);
    HitsVector &countsLow(hitVec[index + 2]);
    HitsVector &countsHigh(hitVec[index + 3]);
    checksum.resize(timeslices);
    map.resize(timeslices);
    countsLow.resize(timeslices);
    countsHigh.resize(timeslices);
    for (int slice = 0; slice < timeslices; ++slice) {
      if (energyLg[slice] == 0 && energySm[slice] == 0)
        continue;
      // checksum
      // LVL1::DataError err(error[slice]);
      // const int overflow = err.get(LVL1::DataError::Overflow);
      const int overflow = 0; // don't include overflow as not in slink data
      checksum[slice] +=
          jem + frame + loc + energyLg[slice] + energySm[slice] + overflow;
      checksum[slice] &= 0xffff;
      // occupancy map
      map[slice] |= (1 << jem);
      // occupancy counts
      if (jem < 8) {
        countsLow[slice] += (1 << (3 * jem)); // can't saturate
      } else {
        countsHigh[slice] += (1 << (3 * (jem - 8)));
      }
    }
    const int peak = tob->peak();
    if (peak > peakm)
      peakm = peak;
  }
  // Save non-zero crate totals
  HitsVector dummy(timeslices);
  ErrorVector dummyE(timeslices);
  for (int crate = 0; crate < m_crates; ++crate) {
    const int index = crate * 4;
    saveCMXJetHits(cmxHitsTopo, hitVec[index], dummy, dummyE, dummyE, crate,
                   xAOD::CMXJetHits::TOPO_CHECKSUM, peakm);
    saveCMXJetHits(cmxHitsTopo, hitVec[index + 1], dummy, dummyE, dummyE, crate,
                   xAOD::CMXJetHits::TOPO_OCCUPANCY_MAP, peakm);
    saveCMXJetHits(cmxHitsTopo, hitVec[index + 2], hitVec[index + 3], dummyE,
                   dummyE, crate, xAOD::CMXJetHits::TOPO_OCCUPANCY_COUNTS,
                   peakm);
  }
}

formCMXJetTob() [1/2]

void LVL1::L1JetCMXTools::formCMXJetTob ( const std::vector< const xAOD::JEMTobRoIContainer * > & jemRoiColls, xAOD::CMXJetTobContainer * cmxTobVec, int peak ) const

virtual

form CMX-Jet TOBs from RoIs - multiple slices

Implements LVL1::IL1JetCMXTools.

Definition at line 64 of file L1JetCMXTools.cxx.

                                                       {
  std::map<uint32_t, const xAOD::JEMTobRoI *> jemRoiMap;
  std::map<int, xAOD::CMXJetTob *> cmxTobMap;
  xAOD::JEMTobRoIContainer::const_iterator it;
  int timeslices = jemRoiColls.size();
  for (int slice = 0; slice < timeslices; ++slice) {
    const xAOD::JEMTobRoIContainer *jemRoiVec = jemRoiColls[slice];
    jemRoiMap.clear();
    std::vector<unsigned int> presenceMaps(m_crates * m_modules);
    std::vector<int> tobCount(m_crates * m_modules);
    xAOD::JEMTobRoIContainer::const_iterator it = jemRoiVec->begin();
    xAOD::JEMTobRoIContainer::const_iterator itE = jemRoiVec->end();
    for (; it != itE; ++it) { // get sorted list
      const xAOD::JEMTobRoI *roi = *it;
      const int crate = roi->crate();
      const int jem = roi->jem();
      const int index = crate * m_modules + jem;
      const int presenceBit = roi->frame(); // <<== CHECK
      presenceMaps[index] |= (1 << presenceBit);
      tobCount[index]++;
      uint32_t key = roi->roiWord();
      jemRoiMap.insert(std::make_pair(key, roi));
    }
    std::map<uint32_t, const xAOD::JEMTobRoI *>::const_iterator mit =
        jemRoiMap.begin();
    std::map<uint32_t, const xAOD::JEMTobRoI *>::const_iterator mitE =
        jemRoiMap.end();
    for (; mit != mitE; ++mit) {
      const xAOD::JEMTobRoI *roi = mit->second;
      const int crate = roi->crate();
      const int jem = roi->jem();
      const int frame = roi->frame();
      const int loc = roi->location();
      const int index = crate * m_modules + jem;
      const int energyLg = roi->energyLarge();
      const int energySm = roi->energySmall();
      const unsigned int presence = presenceMaps[index];
      int error = 0;
      if (tobCount[index] > m_maxTobs) { // overflow
        int count = 0;
        for (int bit = 0; bit <= frame; ++bit)
          count += (presence >> bit) & 0x1;
        if (count > m_maxTobs)
          continue;
        LVL1::DataError err;
        err.set(LVL1::DataError::Overflow);
        error = err.error();
      }
      const int key = (((((crate << 4) | jem) << 3) | frame) << 2) | loc;
      xAOD::CMXJetTob *tob = 0;
      std::map<int, xAOD::CMXJetTob *>::iterator xit = cmxTobMap.find(key);
      if (xit == cmxTobMap.end()) {
        tob = new xAOD::CMXJetTob;
        tob->makePrivateStore();
        tob->initialize(crate, jem, frame, loc);
        if (timeslices > 0) { // TODO(amazurov): need to check >1 or >0
          std::vector<uint16_t> vecU16(timeslices);
          std::vector<uint32_t> vecU32(timeslices);
          tob->addTob(vecU16, vecU16, vecU32, vecU16);
          tob->setPeak(peak);
        }
        cmxTobMap.insert(std::make_pair(key, tob));
        cmxTobVec->push_back(tob);
      } else
        tob = xit->second;
      std::vector<uint16_t> energyLgVec(tob->energyLargeVec());
      std::vector<uint16_t> energySmVec(tob->energySmallVec());
      std::vector<uint32_t> errorVec(tob->errorVec());
      std::vector<uint16_t> presenceMapVec(tob->presenceMapVec());
      energyLgVec[slice] = energyLg;
      energySmVec[slice] = energySm;
      errorVec[slice] = error;
      presenceMapVec[slice] = presence;
      tob->addTob(energyLgVec, energySmVec, errorVec, presenceMapVec);
    }
  }
}

formCMXJetTob() [2/2]

void LVL1::L1JetCMXTools::formCMXJetTob ( const xAOD::JEMTobRoIContainer * jemRoiVec, xAOD::CMXJetTobContainer * cmxTobVec ) const

virtual

form CMX-Jet TOBs from RoIs - single slice

Implements LVL1::IL1JetCMXTools.

Definition at line 58 of file L1JetCMXTools.cxx.

                                                                           {
  std::vector<const xAOD::JEMTobRoIContainer *> jemRoiColls(1, jemRoiVec);
  formCMXJetTob(jemRoiColls, cmxTobVec, 0);
}

getHits()

void LVL1::L1JetCMXTools::getHits ( const xAOD::CMXJetTob * tob, HitsVector & hit10, HitsVector & hit11, HitsVector & hit20, HitsVector & hit21 ) const

private

Get hit map.

Definition at line 330 of file L1JetCMXTools.cxx.

                                                     {
  using namespace TrigConf;
  const std::vector<uint16_t> &energyLg(tob->energyLargeVec());
  const std::vector<uint16_t> &energySm(tob->energySmallVec());
  const int timeslices = energyLg.size();
  auto err = LVL1::DataError(tob->error());
 
  hit10.assign(timeslices, 0);
  hit11.assign(timeslices, 0);
  hit20.assign(timeslices, 0);
  hit21.assign(timeslices, 0);
 
  for (int slice = 0; slice < timeslices; ++slice) {
    if (err.get(LVL1::DataError::Overflow)) {
      hit10[slice] = 0x7fff;
      hit11[slice] = 0x7fff;
      hit20[slice] = 0xffff;
      hit21[slice] = 0x3fff;
      continue;
    }
 
    if (energyLg[slice] == 0 && energySm[slice] == 0)
      continue;
 
    xAOD::JEMTobRoI tobRoi;
    tobRoi.makePrivateStore();
    tobRoi.initialize(tob->crate(), tob->jem(), tob->frame(), tob->location(),
                      energyLg[slice], energySm[slice]);
 
    auto l1Menu = SG::makeHandle( m_L1MenuKey );
    LVL1::RecJetRoI roi(tobRoi.roiWord(), &(*l1Menu));
 
    unsigned int numThresholdsHalf = 5;
    unsigned int numBitsPerCounter = 3;
 
    for (unsigned int i = 0; i < numThresholdsHalf * 2; ++i) {
      if (roi.passedThreshold(i)) {
        HitsVector &hit = i < numThresholdsHalf ? hit10 : hit11;
        unsigned int ibit = i < numThresholdsHalf ? i : i - numThresholdsHalf;
        hit[slice] |= (1 << (ibit * numBitsPerCounter));
      }
    }
 
    numThresholdsHalf = 8;
    numBitsPerCounter = 2;
 
    for (unsigned int i = 0; i < numThresholdsHalf * 2; ++i) {
      if (roi.passedThreshold(10 + i)) {
        HitsVector &hit = i < numThresholdsHalf ? hit20 : hit21;
        unsigned int ibit = i < numThresholdsHalf ? i : i - numThresholdsHalf;
        hit[slice] |= (1 << (ibit * numBitsPerCounter));
      }
    }
 
  } // end slice for-loop
}

initialize()

StatusCode LVL1::L1JetCMXTools::initialize ( )

virtual

standard Athena-Algorithm method

Initialisation.

Definition at line 48 of file L1JetCMXTools.cxx.

                                     {
  m_debug = msgLvl(MSG::DEBUG);
 
  ATH_CHECK( m_L1MenuKey.initialize() );
 
  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::IL1JetCMXTools::interfaceID ( )

inlinestaticinherited

Definition at line 55 of file IL1JetCMXTools.h.

    { 
      return IID_IL1JetCMXTools;
    }

mergeCMXJetHits()

void LVL1::L1JetCMXTools::mergeCMXJetHits ( xAOD::CMXJetHitsContainer * cmxHitsVec1, xAOD::CMXJetHitsContainer * cmxHitsVec2 ) const

private

Merge CMX-Jet hits vectors.

Definition at line 468 of file L1JetCMXTools.cxx.

                                                {
  int size = cmxHitsVec2->size();
  for (int index = 0; index < size; ++index) {
    xAOD::CMXJetHits *hitsIn = 0;
    xAOD::CMXJetHits *hitsOut = 0;
    cmxHitsVec2->swapElement(index, hitsIn, hitsOut);
    cmxHitsVec1->push_back(hitsOut);
  }
  cmxHitsVec2->clear();
}

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();
  }

saveCMXJetHits()

void LVL1::L1JetCMXTools::saveCMXJetHits ( xAOD::CMXJetHitsContainer * cmxHitsVec, const HitsVector & hits0, const HitsVector & hits1, const ErrorVector & err0, const ErrorVector & err1, int crate, int source, int peak ) const

private

Save non-zero CMX-Jet hits.

Definition at line 483 of file L1JetCMXTools.cxx.

                                                               {
  if (std::accumulate(hits0.begin(), hits0.end(), 0) ||
      std::accumulate(hits1.begin(), hits1.end(), 0)) {
    xAOD::CMXJetHits *item = new xAOD::CMXJetHits;
    item->makePrivateStore();
    item->initialize(crate, source, hits0, hits1, err0, err1, peak);
    cmxHitsVec->push_back(item);
  }
}

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.

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_crates

int LVL1::L1JetCMXTools::m_crates

private

Number of crates.

Definition at line 103 of file L1JetCMXTools.h.

m_debug

bool LVL1::L1JetCMXTools::m_debug

private

Debug flag.

Definition at line 111 of file L1JetCMXTools.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_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_L1MenuKey

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

private

Definition at line 101 of file L1JetCMXTools.h.

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

m_maxTobs

int LVL1::L1JetCMXTools::m_maxTobs

private

Maximum number of TOBs per module to CMXs.

Definition at line 107 of file L1JetCMXTools.h.

m_modules

int LVL1::L1JetCMXTools::m_modules

private

Number of JEM modules per crate.

Definition at line 105 of file L1JetCMXTools.h.

m_sysCrate

int LVL1::L1JetCMXTools::m_sysCrate

private

System crate number.

Definition at line 109 of file L1JetCMXTools.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:

• L1JetCMXTools.h
• L1JetCMXTools.cxx