GlobalSim::Egamma1eRatioAlgTool Class Reference

#include <Egamma1eRatioAlgTool.h>

Inheritance diagram for GlobalSim::Egamma1eRatioAlgTool:

Collaboration diagram for GlobalSim::Egamma1eRatioAlgTool:

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

Private Member Functions
std::vector< double >	combine_phi (const IOBitwise::IeEmNbhoodTOB *) const
ap_int< 16 >	secondPeakSearch (const std::vector< ap_int< 16 >> &input, const ap_int< 16 > peak, const int startCell, const int endCell, const ap_int< 16 > noiseMargin) const

Private Attributes
Gaudi::Property< bool >	m_enableDump
SG::ReadHandleKey< IOBitwise::IeEmNbhoodTOBContainer >	m_nbhdTOBContainerReadKey
SG::WriteHandleKey< IOBitwise::IeEmEg1eRatioTOBContainer >	m_eRatioResultKey
SG::WriteHandleKey< std::vector< int > >	m_eRatioKey
SG::WriteHandleKey< std::vector< float > >	m_eRatioSimpleKey

Static Private Attributes
static constexpr int	s_required_phi_len = 17
static constexpr int	s_combination_len = 51

Detailed Description

Definition at line 29 of file Egamma1eRatioAlgTool.h.

Constructor & Destructor Documentation

Egamma1eRatioAlgTool()

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

Definition at line 15 of file Egamma1eRatioAlgTool.cxx.

                                                 :
    base_class(type, name, parent){
  }

~Egamma1eRatioAlgTool()

virtual GlobalSim::Egamma1eRatioAlgTool::~Egamma1eRatioAlgTool ( )

virtualdefault

Member Function Documentation

combine_phi()

std::vector< double > GlobalSim::Egamma1eRatioAlgTool::combine_phi ( const IOBitwise::IeEmNbhoodTOB *  nbhdTOB ) const

private

Definition at line 178 of file Egamma1eRatioAlgTool.cxx.

                                                                                {
    auto result = std::vector<double>();
 
    const auto& phi_low = nbhdTOB->Neighbourhood().phi_low();
    //if (phi_low.size() != s_required_phi_len) {return result;}
 
    const auto& phi_center = nbhdTOB->Neighbourhood().phi_center();
    //if (phi_center.size() != s_required_phi_len) {return result;}
    
    const auto& phi_high = nbhdTOB->Neighbourhood().phi_high();
    //if (phi_high.size() != s_required_phi_len) {return result;}
 
    result.reserve(s_combination_len);
 
    //Make a big vector as the VHDL does. Not strictly necessary, could just use the nbhd.
    std::transform(std::begin(phi_high), std::end(phi_high), std::back_inserter(result), [](const auto& high) {
      return high.m_e;
    });
    std::transform(std::begin(phi_center), std::end(phi_center), std::back_inserter(result), [](const auto& center) {
      return center.m_e;
    });
    std::transform(std::begin(phi_low), std::end(phi_low), std::back_inserter(result), [](const auto& low) {
      return low.m_e;
    });
 
    return result;
  }

initialize()

StatusCode GlobalSim::Egamma1eRatioAlgTool::initialize ( )

override

Definition at line 21 of file Egamma1eRatioAlgTool.cxx.

                                              {
       
    CHECK(m_nbhdTOBContainerReadKey.initialize());
    CHECK(m_eRatioResultKey.initialize());
    CHECK(m_eRatioKey.initialize());
    CHECK(m_eRatioSimpleKey.initialize());
    
    return StatusCode::SUCCESS;
  }

run()

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

overridevirtual

Definition at line 32 of file Egamma1eRatioAlgTool.cxx.

                                                         {
    ATH_MSG_DEBUG("run()");
 
  
    // read in LArStrip neighborhoods from the event store
    auto in =
      SG::ReadHandle<IOBitwise::IeEmNbhoodTOBContainer>(m_nbhdTOBContainerReadKey,
                            ctx);
    CHECK(in.isValid());
 
    ATH_MSG_DEBUG("read in " << (*in).size() << " neighborhoods");
 
    ap_int<16> peak = 0;
    ap_int<16> secondMax = 0;
 
    SG::WriteHandle<IOBitwise::IeEmEg1eRatioTOBContainer> h_eRatioResult(m_eRatioResultKey, ctx);
    CHECK(h_eRatioResult.record(std::make_unique<IOBitwise::IeEmEg1eRatioTOBContainer>()));
    SG::WriteHandle<std::vector<int> > h_eRatio(m_eRatioKey, ctx);
    CHECK(h_eRatio.record(std::make_unique<std::vector<int> >()));
    SG::WriteHandle<std::vector<float> > h_eRatioSimple(m_eRatioSimpleKey, ctx);
    CHECK(h_eRatioSimple.record(std::make_unique<std::vector<float> >()));
 
    for (const auto nbhdTOB : *in) {
      auto c_phi = combine_phi(nbhdTOB);
      if (msgLevel() <= MSG::DEBUG) {
        std::stringstream ss;
        ss << "eRatio input: ";
        for (const auto& i : c_phi) {ss << i << ' ';}
        ATH_MSG_DEBUG(ss.str());
      }
      //if (c_phi.empty()) {continue;}  // corner case: not all phi have len 17
      auto input = digitizer::digitize16(c_phi);
      //Do want to ap_int them?
      //ap_int<10>* c_input = &input[0];  // vector->array
 
      if (msgLevel() <= MSG::DEBUG) {
    std::stringstream ss;
    ss << "eRatio input: ";
    for (const auto& i : input) {ss << i << ' ';}
    ATH_MSG_DEBUG(ss.str());
      }
 
      //Central peak is easy, it's column 9 in the middle row, i.e. entry 25.
      peak = input.at(25);
      ATH_MSG_DEBUG("Peak " << peak);
 
      //Find the 6 secondary peaks, lets do it like the VHDL
      //holder of the current second peak (we will have 6)
      std::vector<ap_int<16>> secondPeak;
      secondPeak.resize(6);
      
      //Noise Margin: This should be 2sigma... set to 1 for now...
      int noiseMargin = 1;
      //Route one: <<< middle row, 24 down to 17
      secondPeak[0] = secondPeakSearch(input, peak, 24, 17, noiseMargin);
      //Route two: middle row >>>, 26 up to 33
      secondPeak[1] = secondPeakSearch(input, peak, 26, 33, noiseMargin);
      //Route three: <<< top row, 8 down to 0
      secondPeak[2] = secondPeakSearch(input, peak, 8, 0, noiseMargin);
      //Route four: top row >>>, 8 up to 16
      secondPeak[3] = secondPeakSearch(input, peak, 8, 16, noiseMargin);
      //Route five: <<< bottom row, 42 down to 34
      secondPeak[4] = secondPeakSearch(input, peak, 42, 34, noiseMargin);
      //Route five: bottom row >>>, 42 up to 50
      secondPeak[5] = secondPeakSearch(input, peak, 42, 50, noiseMargin);
 
      auto result = std::max_element(secondPeak.begin(), secondPeak.end());
      ATH_MSG_DEBUG("Max element found at index "
            << std::distance(secondPeak.begin(), result)
            << " has value " << *result);
 
      secondMax = *result;
      ATH_MSG_DEBUG("Peak " << peak << " second " << secondMax);
      
      //I am not confident on waht div_gen_0 does. So I am casting to floats for now.
      if(peak > 0 || secondMax > 0){
    auto eRatio = static_cast< float >(peak - secondMax)/static_cast< float >(peak + secondMax);
    //h_eRatio->push_back(eRatio);
    ATH_MSG_DEBUG("eRatio (p-sp/p+sp) is " << eRatio);
    
    auto eRatioSimple = static_cast< float >(secondMax)/static_cast< float >(peak);
    h_eRatioSimple->push_back(eRatioSimple);
    ATH_MSG_DEBUG("eRatio (sp/p) is " << eRatio);
 
    //Make a bitset to hold the result
    std::bitset<IOBitwise::IeEmEg1eRatioTOB::s_eGamma1eRatio_width> result = 0;
    //Sanity check to make sure we are in range 0-1
    if(eRatio >= 0. && eRatio <= 1.0){
      //Convert to 0-2047. If s_eGamma1eRatio_width changes this will change.
      int eRatioPower = (1 << IOBitwise::IeEmEg1eRatioTOB::s_eGamma1eRatio_width) -1;
      h_eRatio->push_back((int)(eRatio*eRatioPower));
      result = (int)(eRatio*eRatioPower);
    } else {
       ATH_MSG_DEBUG("eRatio is not in the range 0-1");
    }
    h_eRatioResult->push_back(std::make_unique<IOBitwise::eEmEg1eRatioTOB>(*nbhdTOB, result));
      }
    }
    
    return StatusCode::SUCCESS;
  }

secondPeakSearch()

ap_int< 16 > GlobalSim::Egamma1eRatioAlgTool::secondPeakSearch ( const std::vector< ap_int< 16 >> &  input, const ap_int< 16 >  peak, const int  startCell, const int  endCell, const ap_int< 16 >  noiseMargin  ) const

private

Definition at line 134 of file Egamma1eRatioAlgTool.cxx.

                                                                  {
    //First set a series of counters to "descending" = 0                                                            
    int ascending = 0;
 
    //Setup holder of the last energy we checked... which starts at the peak...
    ap_int<16> lastEnergy = peak;
    ap_int<16> secondPeak = 0;
 
    //There must be a better way to do this?
    int direction = 0;
    if(startCell > endCell) {
      direction =-1;
    } else {
      direction =1;
    }
    
    //Route 1: go down in the middlle row
    for (auto itr = input.begin() + startCell; itr != input.begin() + endCell + direction; itr+=direction){
      //Going down hill... until we are not...
      ATH_MSG_DEBUG("Input is " << *itr << " last energy is " << lastEnergy);
      if(ascending==0 && *itr>lastEnergy && *itr-lastEnergy > noiseMargin){
    ATH_MSG_DEBUG("We are going up now " << *itr << "  is more then " << lastEnergy);
    ascending=1;
    lastEnergy=*itr;
    //Now check if we are at the peak as we are going uphill
      } else if(ascending==1 && lastEnergy>*itr && lastEnergy-*itr > noiseMargin){
    ATH_MSG_DEBUG("We are past the top " << *itr << "  is less than " << lastEnergy);
    if(secondPeak<*itr) secondPeak = lastEnergy;
    ATH_MSG_DEBUG("The peak was " << secondPeak);
    //I think we can break here... don't need to find a third peak
    break;
      } else {
    lastEnergy=*itr;
      }
    }
    
    return secondPeak;
  }

toString()

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

overridevirtual

Definition at line 206 of file Egamma1eRatioAlgTool.cxx.

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

Member Data Documentation

m_enableDump

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

private

Initial value:

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

Definition at line 47 of file Egamma1eRatioAlgTool.h.

m_eRatioKey

SG::WriteHandleKey<std::vector<int> > GlobalSim::Egamma1eRatioAlgTool::m_eRatioKey

private

Initial value:

{
      this,
      "eRatioKey",
      "eRatio"}

Definition at line 67 of file Egamma1eRatioAlgTool.h.

m_eRatioResultKey

SG::WriteHandleKey<IOBitwise::IeEmEg1eRatioTOBContainer> GlobalSim::Egamma1eRatioAlgTool::m_eRatioResultKey

private

Initial value:

{
      this,
      "eRatioResultKey",
      "eRatioResult"}

Definition at line 61 of file Egamma1eRatioAlgTool.h.

m_eRatioSimpleKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1eRatioAlgTool::m_eRatioSimpleKey

private

Initial value:

{
      this,
      "eRatioSimpleKey",
      "eRatioSimple"}

Definition at line 73 of file Egamma1eRatioAlgTool.h.

m_nbhdTOBContainerReadKey

SG::ReadHandleKey<IOBitwise::IeEmNbhoodTOBContainer> GlobalSim::Egamma1eRatioAlgTool::m_nbhdTOBContainerReadKey

private

Initial value:

{
      this,
      "LArNeighborhoodTOBContainerReadKey",
      "stripNeighborhoodTOBContainer",
      "key to read inLArNeighborhoodTOBsReadKeys"}

Definition at line 54 of file Egamma1eRatioAlgTool.h.

s_combination_len

constexpr int GlobalSim::Egamma1eRatioAlgTool::s_combination_len = 51

inlinestaticconstexprprivate

Definition at line 90 of file Egamma1eRatioAlgTool.h.

s_required_phi_len

constexpr int GlobalSim::Egamma1eRatioAlgTool::s_required_phi_len = 17

inlinestaticconstexprprivate

Definition at line 86 of file Egamma1eRatioAlgTool.h.

---

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

• Egamma1eRatioAlgTool.h
• Egamma1eRatioAlgTool.cxx