GlobalSim::eRatioAlgTool_UCL Class Reference

#include <eRatioAlgTool_UCL.h>

Inheritance diagram for GlobalSim::eRatioAlgTool_UCL:

Collaboration diagram for GlobalSim::eRatioAlgTool_UCL:

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

Private Member Functions
std::vector< double >	combine_phi (const IOBitwise::eEmNbhoodTOB *) 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::eEmNbhoodTOBContainer >	m_nbhdTOBContainerReadKey
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 29 of file eRatioAlgTool_UCL.h.

Constructor & Destructor Documentation

eRatioAlgTool_UCL()

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

Definition at line 16 of file eRatioAlgTool_UCL.cxx.

                                                 :
    base_class(type, name, parent){
  }

~eRatioAlgTool_UCL()

virtual GlobalSim::eRatioAlgTool_UCL::~eRatioAlgTool_UCL ( )

virtualdefault

Member Function Documentation

combine_phi()

std::vector< double > GlobalSim::eRatioAlgTool_UCL::combine_phi ( const IOBitwise::eEmNbhoodTOB * nbhdTOB ) const

private

Definition at line 170 of file eRatioAlgTool_UCL.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::eRatioAlgTool_UCL::initialize ( )

override

Definition at line 22 of file eRatioAlgTool_UCL.cxx.

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

run()

StatusCode GlobalSim::eRatioAlgTool_UCL::run ( const std::unique_ptr< IDataCollector > & dc, const EventContext & ctx ) const

overridevirtual

Definition at line 32 of file eRatioAlgTool_UCL.cxx.

                                            {
    ATH_MSG_DEBUG("run()");
 
    if (dc){dc->collect(*this, "start");}
      
    // read in LArStrip neighborhoods from the event store
    auto in =
      SG::ReadHandle<IOBitwise::eEmNbhoodTOBContainer>(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<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 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());
      }
 
      //Neighbourhood size sanity check
      if(input.size() == 51){
    //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 " << eRatioSimple);
    }
      }
    }
 
    if (dc){dc->collect(*this, "end");}
 
    return StatusCode::SUCCESS;
  }

secondPeakSearch()

ap_int< 16 > GlobalSim::eRatioAlgTool_UCL::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 126 of file eRatioAlgTool_UCL.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);
    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::eRatioAlgTool_UCL::toString ( ) const

overridevirtual

Definition at line 198 of file eRatioAlgTool_UCL.cxx.

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

Member Data Documentation

m_enableDump

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

private

Initial value:

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

Definition at line 48 of file eRatioAlgTool_UCL.h.

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

m_eRatioKey

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

private

Initial value:

{
      this,
      "eRatioKey",
      "eRatio"}

Definition at line 62 of file eRatioAlgTool_UCL.h.

                {
      this,
      "eRatioKey",
      "eRatio"};

m_eRatioSimpleKey

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

private

Initial value:

{
      this,
      "eRatioSimpleKey",
      "eRatioSimple"}

Definition at line 68 of file eRatioAlgTool_UCL.h.

                      {
      this,
      "eRatioSimpleKey",
      "eRatioSimple"};

m_nbhdTOBContainerReadKey

SG::ReadHandleKey<IOBitwise::eEmNbhoodTOBContainer> GlobalSim::eRatioAlgTool_UCL::m_nbhdTOBContainerReadKey

private

Initial value:

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

Definition at line 55 of file eRatioAlgTool_UCL.h.

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

s_combination_len

int GlobalSim::eRatioAlgTool_UCL::s_combination_len = 51

inlinestaticconstexprprivate

Definition at line 85 of file eRatioAlgTool_UCL.h.

s_required_phi_len

int GlobalSim::eRatioAlgTool_UCL::s_required_phi_len = 17

inlinestaticconstexprprivate

Definition at line 81 of file eRatioAlgTool_UCL.h.

---

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

• eRatioAlgTool_UCL.h
• eRatioAlgTool_UCL.cxx