GlobalSim::eEmSortSelectCountContainerAlgTool Class Reference

#include <eEmSortSelectCountContainerAlgTool.h>

Inheritance diagram for GlobalSim::eEmSortSelectCountContainerAlgTool:

Collaboration diagram for GlobalSim::eEmSortSelectCountContainerAlgTool:

Public Types
using	GenTobPtr = typename eEmSortSelectCountContainerPortsOut::GenTobPtr

Public Member Functions
	eEmSortSelectCountContainerAlgTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~eEmSortSelectCountContainerAlgTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	run (const EventContext &ctx) const override
virtual std::string	toString () const override

Private Member Functions
StatusCode	make_selectedTobs (const std::vector< eEmTobPtr > &, std::vector< std::vector< eEmTobPtr >> &) const
std::vector< std::size_t >	count_tobs (const std::vector< std::vector< GenTobPtr >> &) const

Private Attributes
Gaudi::Property< bool >	m_enableDump
SG::ReadHandleKey< GlobalSim::GepAlgoHypothesisFIFO >	m_HypoFIFOReadKey
SG::WriteHandleKey< GlobalSim::eEmSortSelectCountContainerPortsOut >	m_portsOutWriteKey
std::vector< unsigned >	m_EtMin
std::vector< unsigned >	m_REtaMin
std::vector< unsigned >	m_RHadMin
std::vector< unsigned >	m_WsTotMin
std::vector< std::vector< int > >	m_count_EtMin
std::vector< std::vector< int > >	m_count_EtaMin
std::vector< std::vector< int > >	m_count_EtaMax

Static Private Attributes
constexpr static std::size_t	s_NumCnt {24}
constexpr static std::size_t	s_NumEtaRanges {3}
constexpr static std::array< std::size_t, s_NumCnt >	s_CntSelN
constexpr static auto &	s_NumSelect
constexpr static auto &	s_NumSort
constexpr static auto &	s_NumNoSort
constexpr static auto &	s_SortOutWidths
constexpr static auto &	s_SortOutWidth
constexpr static auto &	s_SortOutStart
constexpr static auto &	s_max_counts
constexpr static auto &	s_CountOutWidth
constexpr static auto &	s_NumTotalCountWidth

Detailed Description

Definition at line 21 of file eEmSortSelectCountContainerAlgTool.h.

Member Typedef Documentation

GenTobPtr

using GlobalSim::eEmSortSelectCountContainerAlgTool::GenTobPtr = typename eEmSortSelectCountContainerPortsOut::GenTobPtr

Definition at line 25 of file eEmSortSelectCountContainerAlgTool.h.

Constructor & Destructor Documentation

eEmSortSelectCountContainerAlgTool()

GlobalSim::eEmSortSelectCountContainerAlgTool::eEmSortSelectCountContainerAlgTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 27 of file eEmSortSelectCountContainerAlgTool.cxx.

                                                               :
    base_class(type, name, parent){
  }

~eEmSortSelectCountContainerAlgTool()

virtual GlobalSim::eEmSortSelectCountContainerAlgTool::~eEmSortSelectCountContainerAlgTool ( )

virtualdefault

Member Function Documentation

count_tobs()

std::vector< std::size_t > GlobalSim::eEmSortSelectCountContainerAlgTool::count_tobs ( const std::vector< std::vector< GenTobPtr >> &  tobContainerVector ) const

private

Definition at line 316 of file eEmSortSelectCountContainerAlgTool.cxx.

  {
    auto counts = std::vector<std::size_t>(s_NumCnt, 0);
    
    for (std::size_t i = 0; i != s_NumCnt; ++i) {
      const auto& gTobs = tobContainerVector[s_CntSelN[i]];
    
      counts[i] = std::count_if(std::begin(gTobs),
                std::end(gTobs),
                [etMin_etaRegs = m_count_EtMin[i],
                 etaMin_etaRegs = m_count_EtaMin[i],
                 etaMax_etaRegs = m_count_EtaMax[i]](const auto& tob) {
 
                  // loop over eta regions
                  for(std::size_t j{0}; j != etMin_etaRegs.size(); ++j) {
                    if (tob->Et() > etMin_etaRegs[j] and
                    tob->Eta() > etaMin_etaRegs[j] and
                    tob->Eta() <= etaMax_etaRegs[j]) {return true;}
                  }
                  return false;
                });
      
    }
    return counts;
  }

initialize()

StatusCode GlobalSim::eEmSortSelectCountContainerAlgTool::initialize ( )

overridevirtual

Definition at line 33 of file eEmSortSelectCountContainerAlgTool.cxx.

                                                            {
       
    CHECK(m_HypoFIFOReadKey.initialize());
    CHECK(m_portsOutWriteKey.initialize());
 
    // Cut values for Select part of Algorithm. Not yet provided in VHDL
 
    
    m_EtMin = std::vector(s_NumSelect, 0U);
    m_REtaMin = std::vector(s_NumSelect, 0U);
    m_RHadMin = std::vector(s_NumSelect, 0U);
    m_WsTotMin = std::vector(s_NumSelect, 0U);
 
    // Cut values for the Count part of Algorithm.
    // All values set to EM5 for now
    
    m_count_EtMin =
      std::vector<std::vector<int>> (s_NumCnt,
                     std::vector<int>(s_NumEtaRanges,
                              0x019));
 
 
    // Eta min is tricky:
    // It has been set to 0x100000000 in a 9 bit word. So it is negative.
    // But our words have > 9 bits.
    m_count_EtaMin =
      std::vector<std::vector<int>>(s_NumCnt,
                    std::vector<int>(s_NumEtaRanges, -0b011111111));
    
    m_count_EtaMax = std::vector<std::vector<int>>(s_NumCnt,
                           std::vector<int>(s_NumEtaRanges, 0b011111111));
 
 
    return StatusCode::SUCCESS;
  }

make_selectedTobs()

StatusCode GlobalSim::eEmSortSelectCountContainerAlgTool::make_selectedTobs ( const std::vector< eEmTobPtr > &  eEmTobs, std::vector< std::vector< eEmTobPtr >> &  selectedTobs  ) const

private

Definition at line 283 of file eEmSortSelectCountContainerAlgTool.cxx.

                                                                                 {
  
    selectedTobs.reserve(s_NumSelect);
    
    for(std::size_t i = 0; i != s_NumSelect; ++i) {
      auto selector = [etMin = m_EtMin[i],
               rEtaMin= m_REtaMin[i],
               rHadMin = m_RHadMin[i],
               wsTotMin = m_WsTotMin[i]](const auto& tob){
 
    return
      (tob->Et_bits()).to_ulong() >= etMin and
      (tob->REta_bits()).to_ulong() >= rEtaMin and
      (tob->RHad_bits()).to_ulong() >= rHadMin and
      (tob->WsTot_bits()).to_ulong() >= wsTotMin;
      };
   
      std::vector<eEmTobPtr> s_tobs;
      s_tobs.reserve(eEmTobs.size());
      std::copy_if(eEmTobs.cbegin(),
           eEmTobs.cend(),
           std::back_inserter(s_tobs),
           selector);
      
      selectedTobs.push_back(s_tobs);
      
    }
 
    return StatusCode::SUCCESS;
  }

run()

StatusCode GlobalSim::eEmSortSelectCountContainerAlgTool::run ( const EventContext &  ctx ) const

overridevirtual

Definition at line 70 of file eEmSortSelectCountContainerAlgTool.cxx.

                                                                       {
    ATH_MSG_DEBUG("run()");
 
  
    // read in input data (a FIFO) for GepAlgoHypothesis from the event store
 
    auto fifo =
      SG::ReadHandle<GlobalSim::GepAlgoHypothesisFIFO>(m_HypoFIFOReadKey,
                               ctx);
    CHECK(fifo.isValid());
     
    ATH_MSG_DEBUG("read in GepAlgoHypothesis fifo ");
 
    {
      std::stringstream ss;
      ss <<'\n';
      for (const auto& p : *fifo) {
    ss  << eEmInputTOBToString(*(p.m_I_eEmTobs)) << '\n';
      }
      ATH_MSG_DEBUG(ss.str());
    }
      
    
    auto eEmTobs = make_eEmTobs(*fifo);
 
    auto collector = std::make_unique<DataCollector>();
    collector->collect("eEmTobs in", eEmTobs);
    
    // Select. In the VHDL, ech TOB is treated indiviually. Here
    // we split the TOBs into vectors of selected TOBs, where
    // each selection has a set of associated cuts.
    auto selected_eEmTobs = std::vector<std::vector<eEmTobPtr>>();
    CHECK(make_selectedTobs(eEmTobs, selected_eEmTobs));
 
    collector->collect("selected eEmTobs containers", selected_eEmTobs);
    
    // why isn't the selection done on Generic TOBs? - bacause the original
    // VHDL does not.
 
    auto selected_genericTobs =
      std::vector<std::vector<GenTobPtr>>(selected_eEmTobs.size(),
                      std::vector<GenTobPtr>());
 
    auto make_genericTob = [](const auto& tob) {
      return std::make_shared<GenericTob>(tob);
    };
 
    for (std::size_t i = 0; i != selected_eEmTobs.size(); ++i){
      std::transform(std::begin(selected_eEmTobs[i]),
             std::end(selected_eEmTobs[i]),
             std::back_inserter(selected_genericTobs[i]),
             make_genericTob);
    }
      
    collector->collect("Selected generic tob containers",
               selected_genericTobs);
    // Sort
    auto EtGreater = [] (const GenTobPtr& l, const GenTobPtr& r) {
      return l->Et() > r->Et();
    };
 
 
    auto ports_out = std::make_unique<eEmSortSelectCountContainerPortsOut>();
 
    // sort selected tobs, and copy to the appropriate location in the
    // output port
 
    auto& outputTobs = ports_out->m_O_eEmGenTob;
    for (std::size_t i = 0; i != s_NumSort; ++i) {
 
      auto& sel =  selected_genericTobs[i];
      auto divider = std::begin(sel) + std::min(sel.size(),
                        s_SortOutWidths[i]);
 
 
      std::partial_sort(std::begin(sel),
            divider,
            std::end(sel),
            EtGreater);
 
      auto start_iter =
    std::begin(outputTobs) + s_SortOutStart[i];
 
      std::copy(std::begin(sel),
        divider,
        start_iter);
    }
 
    collector->collect("Sorted generic tob containers",
               selected_genericTobs);
 
 
    // write unsorted generic TOBs to the output port
    std::size_t numToCopy = std::min(outputTobs.size()-s_SortOutWidth,
                     eEmTobs.size());
 
    std::transform(std::cbegin(eEmTobs),
           std::cbegin(eEmTobs)+numToCopy,
           std::begin(outputTobs) + s_SortOutWidth,
           make_genericTob);
           
           
 
    // count the tobs according to various criteria.
    // limit the counts so that the number of output bits are not exeeded.
    // write the counts to the output port
 
    // find the number count values
    auto ntobs = count_tobs(selected_genericTobs);
    collector->collect("eEmSortSelectCount counts", ntobs);
 
 
    // limit the count values
    std::vector<std::pair<std::size_t, unsigned>> bounded_counts;
    bounded_counts.reserve(ntobs.size());
 
    for(std::size_t i = 0; i != ntobs.size(); ++i) {
      bounded_counts.push_back({
      std::min(ntobs[i], s_max_counts[i]),
      s_CountOutWidth[i]});
    };
 
    // convert each limited count value to 0, 1 (type: short)
    std::vector<std::vector<short>> int_bit_vecs;
    int_bit_vecs.reserve(bounded_counts.size());
 
 
    std::transform(std::cbegin(bounded_counts),
           std::cend(bounded_counts),
           std::back_inserter(int_bit_vecs),
           [](const auto& p) {
             std::vector<short> bits(p.second, 0);
             std::size_t i{0};
             auto ntob = p.first; 
             while (ntob) {
               if (ntob&1) {bits.at(i) = 1;}
               ntob >>= 1;
               ++i;
             }
             std::reverse(std::begin(bits),
                  std::end(bits));
             
             return bits;});
 
    // flatten the vectors of count bits
    std::vector<short> int_bits;
    for (const auto& v : int_bit_vecs) {
      int_bits.insert(int_bits.end(), std::cbegin(v), std::cend(v));
    }
 
    // sanity check
 
    if (int_bits.size() != s_NumTotalCountWidth or
    int_bits.size() != (ports_out->m_O_Multiplicity)->size()) {
      ATH_MSG_ERROR("incorrect number of count bits. Expected "
            << s_NumTotalCountWidth
            << " obtained " << int_bits.size()
            << " number bits in output ports "
            << (ports_out->m_O_Multiplicity)->size());
      return StatusCode::FAILURE;
    }
 
    // convert the 0, 1 (as shorts) to bits in the output port
    auto& count_bits_out = ports_out->m_O_Multiplicity;
    for (std::size_t i = 0; i != int_bits.size(); ++i){
      if (int_bits[i] == 1) {
    count_bits_out->set(i);
      } else {
    count_bits_out->reset(i);
      }
    }
 
 
    {
      std::stringstream ss;
      ss << *collector;
      ATH_MSG_DEBUG(ss.str());
    }
 
    {
      std::stringstream ss;
      ss << *ports_out;
      ATH_MSG_DEBUG(ss.str());
    }
 
    // write the output port to the event store
    
    auto h_write =
      SG::WriteHandle<eEmSortSelectCountContainerPortsOut>(m_portsOutWriteKey,
                               ctx);
 
    CHECK(h_write.record(std::move(ports_out)));
    return StatusCode::SUCCESS;
  }

toString()

std::string GlobalSim::eEmSortSelectCountContainerAlgTool::toString ( ) const

overridevirtual

Definition at line 343 of file eEmSortSelectCountContainerAlgTool.cxx.

                                                               {
 
    std::stringstream ss;
    ss << "eEmSortSelectCountContainerAlgTool.name: " << name() << '\n'
       << m_HypoFIFOReadKey << '\n'
       << '\n';
    return ss.str();
  }

Member Data Documentation

m_count_EtaMax

std::vector<std::vector<int> > GlobalSim::eEmSortSelectCountContainerAlgTool::m_count_EtaMax

private

Definition at line 82 of file eEmSortSelectCountContainerAlgTool.h.

m_count_EtaMin

std::vector<std::vector<int> > GlobalSim::eEmSortSelectCountContainerAlgTool::m_count_EtaMin

private

Definition at line 81 of file eEmSortSelectCountContainerAlgTool.h.

m_count_EtMin

std::vector<std::vector<int> > GlobalSim::eEmSortSelectCountContainerAlgTool::m_count_EtMin

private

Definition at line 80 of file eEmSortSelectCountContainerAlgTool.h.

m_enableDump

Gaudi::Property<bool> GlobalSim::eEmSortSelectCountContainerAlgTool::m_enableDump

private

Initial value:

{this,
    "enableDump",
      {false},
    "flag to enable dumps"}

Definition at line 43 of file eEmSortSelectCountContainerAlgTool.h.

m_EtMin

std::vector<unsigned> GlobalSim::eEmSortSelectCountContainerAlgTool::m_EtMin

private

Definition at line 70 of file eEmSortSelectCountContainerAlgTool.h.

m_HypoFIFOReadKey

SG::ReadHandleKey<GlobalSim::GepAlgoHypothesisFIFO> GlobalSim::eEmSortSelectCountContainerAlgTool::m_HypoFIFOReadKey

private

Initial value:

{
      this,
      "HypoFIFOReadKey",
      "hypoFIFO",
      "key to read input port data for the hypo block"}

Definition at line 50 of file eEmSortSelectCountContainerAlgTool.h.

m_portsOutWriteKey

SG::WriteHandleKey<GlobalSim::eEmSortSelectCountContainerPortsOut> GlobalSim::eEmSortSelectCountContainerAlgTool::m_portsOutWriteKey

private

Initial value:

{
      this,
      "PortsOutKey",
      "eEmSortSelectCount",
      "key to write output ports data"}

Definition at line 59 of file eEmSortSelectCountContainerAlgTool.h.

m_REtaMin

std::vector<unsigned> GlobalSim::eEmSortSelectCountContainerAlgTool::m_REtaMin

private

Definition at line 71 of file eEmSortSelectCountContainerAlgTool.h.

m_RHadMin

std::vector<unsigned> GlobalSim::eEmSortSelectCountContainerAlgTool::m_RHadMin

private

Definition at line 72 of file eEmSortSelectCountContainerAlgTool.h.

m_WsTotMin

std::vector<unsigned> GlobalSim::eEmSortSelectCountContainerAlgTool::m_WsTotMin

private

Definition at line 73 of file eEmSortSelectCountContainerAlgTool.h.

s_CntSelN

constexpr static std::array<std::size_t, s_NumCnt> GlobalSim::eEmSortSelectCountContainerAlgTool::s_CntSelN

staticconstexprprivate

Initial value:

{
      0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}

Definition at line 97 of file eEmSortSelectCountContainerAlgTool.h.

s_CountOutWidth

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_CountOutWidth

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::CountOutWidth

Definition at line 123 of file eEmSortSelectCountContainerAlgTool.h.

s_max_counts

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_max_counts

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::max_counts

Definition at line 120 of file eEmSortSelectCountContainerAlgTool.h.

s_NumCnt

constexpr static std::size_t GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumCnt {24}

staticconstexprprivate

Definition at line 91 of file eEmSortSelectCountContainerAlgTool.h.

s_NumEtaRanges

constexpr static std::size_t GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumEtaRanges {3}

staticconstexprprivate

Definition at line 92 of file eEmSortSelectCountContainerAlgTool.h.

s_NumNoSort

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumNoSort

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::NumNoSort

Definition at line 107 of file eEmSortSelectCountContainerAlgTool.h.

s_NumSelect

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumSelect

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::NumSelect

Definition at line 100 of file eEmSortSelectCountContainerAlgTool.h.

s_NumSort

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumSort

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::NumSort

Definition at line 103 of file eEmSortSelectCountContainerAlgTool.h.

s_NumTotalCountWidth

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_NumTotalCountWidth

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::NumTotalCountWidth

Definition at line 127 of file eEmSortSelectCountContainerAlgTool.h.

s_SortOutStart

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_SortOutStart

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::SortOutStart

Definition at line 117 of file eEmSortSelectCountContainerAlgTool.h.

s_SortOutWidth

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_SortOutWidth

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::SortOutWidth

Definition at line 114 of file eEmSortSelectCountContainerAlgTool.h.

s_SortOutWidths

constexpr static auto& GlobalSim::eEmSortSelectCountContainerAlgTool::s_SortOutWidths

staticconstexprprivate

Initial value:

=
      eEmSortSelectCountContainerPortsOut::SortOutWidths

Definition at line 111 of file eEmSortSelectCountContainerAlgTool.h.

---

The documentation for this class was generated from the following files:

• eEmSortSelectCountContainerAlgTool.h
• eEmSortSelectCountContainerAlgTool.cxx