GlobalSim::Egamma1BaselineAlgTool Class Reference

#include <Egamma1BaselineAlgTool.h>

Inheritance diagram for GlobalSim::Egamma1BaselineAlgTool:

Collaboration diagram for GlobalSim::Egamma1BaselineAlgTool:

Public Member Functions
	Egamma1BaselineAlgTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~Egamma1BaselineAlgTool ()=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 LArStripNeighborhood *) 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< LArStripNeighborhoodContainer >	m_nbhdContainerReadKey
SG::WriteHandleKey< std::vector< float > >	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 25 of file Egamma1BaselineAlgTool.h.

Constructor & Destructor Documentation

Egamma1BaselineAlgTool()

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

Definition at line 13 of file Egamma1BaselineAlgTool.cxx.

                                                 :
    base_class(type, name, parent){
  }

~Egamma1BaselineAlgTool()

virtual GlobalSim::Egamma1BaselineAlgTool::~Egamma1BaselineAlgTool ( )

virtualdefault

Member Function Documentation

combine_phi()

std::vector< double > GlobalSim::Egamma1BaselineAlgTool::combine_phi ( const LArStripNeighborhood *  nbhd ) const

private

Definition at line 162 of file Egamma1BaselineAlgTool.cxx.

                                                                             {
    auto result = std::vector<double>();
 
    const auto& phi_low = nbhd->phi_low();
    //if (phi_low.size() != s_required_phi_len) {return result;}
 
    const auto& phi_center = nbhd->phi_center();
    //if (phi_center.size() != s_required_phi_len) {return result;}
    
    const auto& phi_high = nbhd->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::Egamma1BaselineAlgTool::initialize ( )

override

Definition at line 19 of file Egamma1BaselineAlgTool.cxx.

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

run()

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

overridevirtual

Definition at line 29 of file Egamma1BaselineAlgTool.cxx.

                                                           {
    ATH_MSG_DEBUG("run()");
 
  
    // read in LArStrip neighborhoods from the event store
    // there is one neighborhood per EFex RoI
    auto in =
      SG::ReadHandle<LArStripNeighborhoodContainer>(m_nbhdContainerReadKey,
                            ctx);
    CHECK(in.isValid());
 
    ATH_MSG_DEBUG("read in " << (*in).size() << " neighborhoods");
 
    ap_int<16> peak = 0;
    ap_int<16> secondMax = 0;
 
    SG::WriteHandle<std::vector<float> > h_eRatio(m_eRatioKey, ctx);
    CHECK(h_eRatio.record(std::make_unique<std::vector<float> >()));
    SG::WriteHandle<std::vector<float> > h_eRatioSimple(m_eRatioSimpleKey, ctx);
    CHECK(h_eRatioSimple.record(std::make_unique<std::vector<float> >()));
    
    for (const auto& nbhd : *in) {
      auto c_phi = combine_phi(nbhd);
      if (msgLevel() <= MSG::DEBUG) {
        std::stringstream ss;
        ss << "Baseline 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 << "Baseline 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);
      //tidy up.
      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);
      } 
      
    }
    
    return StatusCode::SUCCESS;
  }

secondPeakSearch()

ap_int< 16 > GlobalSim::Egamma1BaselineAlgTool::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 118 of file Egamma1BaselineAlgTool.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::Egamma1BaselineAlgTool::toString ( ) const

overridevirtual

Definition at line 190 of file Egamma1BaselineAlgTool.cxx.

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

Member Data Documentation

m_enableDump

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

private

Initial value:

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

Definition at line 44 of file Egamma1BaselineAlgTool.h.

m_eRatioKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1BaselineAlgTool::m_eRatioKey

private

Initial value:

{
      this,
      "eRatioKey",
      "eRatio"}

Definition at line 58 of file Egamma1BaselineAlgTool.h.

m_eRatioSimpleKey

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

private

Initial value:

{
      this,
      "eRatioSimpleKey",
      "eRatioSimple"}

Definition at line 64 of file Egamma1BaselineAlgTool.h.

m_nbhdContainerReadKey

SG::ReadHandleKey<LArStripNeighborhoodContainer> GlobalSim::Egamma1BaselineAlgTool::m_nbhdContainerReadKey

private

Initial value:

{
      this,
      "LArNeighborhoodContainerReadKey",
      "stripNeighborhoodContainer",
      "key to read inLArNeighborhoodReadKeys"}

Definition at line 51 of file Egamma1BaselineAlgTool.h.

s_combination_len

constexpr int GlobalSim::Egamma1BaselineAlgTool::s_combination_len = 51

inlinestaticconstexprprivate

Definition at line 81 of file Egamma1BaselineAlgTool.h.

s_required_phi_len

constexpr int GlobalSim::Egamma1BaselineAlgTool::s_required_phi_len = 17

inlinestaticconstexprprivate

Definition at line 77 of file Egamma1BaselineAlgTool.h.

---

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

• Egamma1BaselineAlgTool.h
• Egamma1BaselineAlgTool.cxx