HIEventShapeIndex Class Reference

#include <HIEventShapeIndex.h>

Collaboration diagram for HIEventShapeIndex:

Classes
struct	range_index_t

Public Member Functions
	HIEventShapeIndex ()
	~HIEventShapeIndex ()
unsigned int	setBinning (const TH2 *h2, bool asMask)
unsigned int	setBinning (HI::BinningScheme scheme)
void	initializeEventShapeContainer (std::unique_ptr< xAOD::HIEventShapeContainer > &shape_container, unsigned int num_harmonics) const
unsigned int	getIndex (float eta, int layer) const
unsigned int	getIndexFromBin (unsigned int ebin, int layer) const
unsigned int	getEtaBin (float eta, int layer) const
unsigned int	getNumBins () const
xAOD::HIEventShape *	getShape (float eta, int layer, xAOD::HIEventShapeContainer *shape_container) const
const xAOD::HIEventShape *	getShape (float eta, int layer, const xAOD::HIEventShapeContainer *shape_container) const
xAOD::HIEventShape *	getShape (float eta, int layer, std::unique_ptr< xAOD::HIEventShapeContainer > &shape_container) const
std::string	print () const

Private Member Functions
unsigned int	getIndex_Internal (float eta, int layer, bool etaIndex) const
std::map< int, std::vector< range_index_t > >::const_iterator	getLayer (int layer) const
float	roundToTenth (float d) const

Private Attributes
std::map< int, std::vector< range_index_t > >	m_edges
unsigned int	m_size {}

Detailed Description

Definition at line 16 of file HIEventShapeIndex.h.

Constructor & Destructor Documentation

HIEventShapeIndex()

HIEventShapeIndex::HIEventShapeIndex

(

)

Definition at line 15 of file HIEventShapeIndex.cxx.

                                     : m_size(0)
{
}

~HIEventShapeIndex()

HIEventShapeIndex::~HIEventShapeIndex

(

)

Definition at line 19 of file HIEventShapeIndex.cxx.

{
}

Member Function Documentation

getEtaBin()

unsigned int HIEventShapeIndex::getEtaBin	(	float	eta,
		int	layer ) const

Definition at line 151 of file HIEventShapeIndex.cxx.

{
    return getIndex_Internal(eta,layer,true);
}

getIndex()

unsigned int HIEventShapeIndex::getIndex	(	float	eta,
		int	layer ) const

Definition at line 146 of file HIEventShapeIndex.cxx.

{
    return getIndex_Internal(eta,layer,false);
}

getIndex_Internal()

unsigned int HIEventShapeIndex::getIndex_Internal ( float eta, int layer, bool etaIndex ) const

private

Definition at line 111 of file HIEventShapeIndex.cxx.

{
    auto mItr=getLayer(layer);
    const std::vector<range_index_t>& vec=mItr->second;
    unsigned int vsize=vec.size();
 
    if(vsize==0)
    {
        std::cerr << "Layer " << layer << " has no range in calorimeter" << std::endl;
        throw std::range_error("Bad binning request");
        return 0;
    }
 
    float eta_c=eta;
    if(m_edges.size()>1)
    {
        float abs_eta=std::abs(eta);
        float rmin=HICaloRange::getRange().getRangeMin(layer);
        float rmax=HICaloRange::getRange().getRangeMax(layer);
 
        if(abs_eta < rmin) eta_c=rmin+std::copysign(1e-2,eta);
        else if(abs_eta > rmax) eta_c=rmax-std::copysign(1e-2,eta);
    }
 
    unsigned int pIndex=0;
    for(; pIndex < vsize-1; pIndex++)
    {
        const range_index_t& p=vec.at(pIndex);
        if(p(eta_c)) break;
    }
 
    return (etaIndex) ? pIndex : vec.at(pIndex).index;
}

getIndexFromBin()

unsigned int HIEventShapeIndex::getIndexFromBin	(	unsigned int	ebin,
		int	layer ) const

Definition at line 106 of file HIEventShapeIndex.cxx.

{
    return getLayer(layer)->second.at(ebin).index;
}

getLayer()

std::map< int, std::vector< HIEventShapeIndex::range_index_t > >::const_iterator HIEventShapeIndex::getLayer ( int layer ) const

private

Definition at line 194 of file HIEventShapeIndex.cxx.

{
    auto mItr=m_edges.find(layer);
 
    if(mItr==m_edges.end())
    {
        //ATH_MSG_ERROR("Layer " << layer << " has no binning specification");
        std::cerr << "Layer " << layer << " has no binning specification" << std::endl;
        throw std::range_error("Bad binning request");
    }
    return mItr;
}

getNumBins()

unsigned int HIEventShapeIndex::getNumBins ( ) const

inline

Definition at line 36 of file HIEventShapeIndex.h.

{return m_size;};

getShape() [1/3]

const xAOD::HIEventShape * HIEventShapeIndex::getShape	(	float	eta,
		int	layer,
		const xAOD::HIEventShapeContainer *	shape_container ) const

Definition at line 170 of file HIEventShapeIndex.cxx.

{
    if(shape_container==nullptr)
    {
        //ATH_MSG_WARNING("No default HIEventShapeContainer to query. Returning nullptr_t.");
        return nullptr;
    }
    unsigned int bin=getIndex(eta,layer);
    //correct for round-off errors in cell eta values, just need to make sure they end up in the right bin
    if( bin >= shape_container->size() )  bin=getIndex(eta-std::copysign(1e-2,eta),layer);
 
    return shape_container->at(bin);
}

getShape() [2/3]

xAOD::HIEventShape * HIEventShapeIndex::getShape	(	float	eta,
		int	layer,
		std::unique_ptr< xAOD::HIEventShapeContainer > &	shape_container ) const

Definition at line 185 of file HIEventShapeIndex.cxx.

{
    unsigned int bin=getIndex(eta,layer);
    //correct for round-off errors in cell eta values, just need to make sure they end up in the right bin
    if( bin >= shape_container->size() )  bin=getIndex(eta-std::copysign(1e-2,eta),layer);
 
    return shape_container->at(bin);
}

getShape() [3/3]

xAOD::HIEventShape * HIEventShapeIndex::getShape	(	float	eta,
		int	layer,
		xAOD::HIEventShapeContainer *	shape_container ) const

Definition at line 156 of file HIEventShapeIndex.cxx.

{
    if(shape_container==nullptr)
    {
        //ATH_MSG_WARNING("No default HIEventShapeContainer to query. Returning nullptr_t.");
        return nullptr;
    }
    unsigned int bin=getIndex(eta,layer);
    //correct for round-off errors in cell eta values, just need to make sure they end up in the right bin
    if( bin >= shape_container->size() )  bin=getIndex(eta-std::copysign(1e-2,eta),layer);
 
    return shape_container->at(bin);
}

initializeEventShapeContainer()

void HIEventShapeIndex::initializeEventShapeContainer	(	std::unique_ptr< xAOD::HIEventShapeContainer > &	shape_container,
		unsigned int	num_harmonics ) const

Definition at line 207 of file HIEventShapeIndex.cxx.

{
    if(getNumBins()==0)
    {
        //ATH_MSG_WARNING("Cannot initialize HIEventShapeContainer. Index has not been initialized.");
        return;
 
    }
    bool isEmpty=(shape_container->size()==0);
    if(isEmpty) shape_container->resize(getNumBins());
    else if(shape_container->size()!=getNumBins())
    {
        //ATH_MSG_WARNING("Cannot initialize HIEventShapeContainer. Number of elements incompatible w/ requested binning.");
        return;
 
    }
 
    for(const auto& pp : m_edges)
    {
        for(auto ri : pp.second)
        {
            xAOD::HIEventShape* slice;
            if(isEmpty)
            {
                slice=new xAOD::HIEventShape();
                //shape_container->push_back(slice);
                shape_container->operator[](ri.index)=slice;
            }
            else slice=shape_container->at(ri.index);
 
            slice->setEtaMin(ri.eta_min);
            slice->setEtaMax(ri.eta_max);
            slice->setLayer(pp.first);
            slice->etCos().assign(num_harmonics,0);
            slice->etSin().assign(num_harmonics,0);
        }
    }
}

print()

std::string HIEventShapeIndex::print

(

)

const

Definition at line 247 of file HIEventShapeIndex.cxx.

{
    std::stringstream ss;
    ss.precision(3);
    for(const auto& pp : m_edges)
    {
        for(const auto & ri : pp.second)
        {
            ss << std::setw(10) << pp.first
            << std::setw(10) << ri.eta_min
            << std::setw(10) << ri.eta_max
            << std::setw(10) << ri.index
            << std::endl;
        }
    }
    return ss.str();
}

roundToTenth()

float HIEventShapeIndex::roundToTenth ( float d ) const

inlineprivate

Definition at line 65 of file HIEventShapeIndex.h.

{return std::floor(d)+std::floor((d-std::floor(d))*10.0+0.5)/10.0;};

setBinning() [1/2]

unsigned int HIEventShapeIndex::setBinning	(	const TH2 *	h2,
		bool	asMask )

Definition at line 24 of file HIEventShapeIndex.cxx.

{
    if(h2==nullptr)
    {
        //ATH_MSG_ERROR("Bad histogram pointer");
        return 0;
    }
 
    unsigned int count=0;
    std::set<unsigned int> used_indices;
    for(int ybin=1; ybin<h2->GetNbinsY(); ybin++)
    {
        auto mItr=m_edges.emplace_hint(m_edges.end(),ybin-1,std::vector<range_index_t>());
        for(int xbin=1; xbin<h2->GetNbinsX(); xbin++)
        {
            if(h2->GetBinContent(xbin,ybin) < 0) continue;
            unsigned int v=h2->GetBinContent(xbin,ybin);
 
            if(asMask) v=count;
            else
            {
                auto sItr=used_indices.find(v);
                if(sItr==used_indices.end()) used_indices.insert(v);
                else
                {
                    //ATH_MSG_ERROR("Could not set binning. initialization histogram has duplicate indices " << v);
                    //m_edges.clear();
                    //return 0;
                    continue;
                }
            }
            mItr->second.push_back(range_index_t(h2->GetXaxis()->GetBinLowEdge(xbin),h2->GetXaxis()->GetBinUpEdge(xbin),v));
            count++;
        }
    }
    m_size=count;
    return count;
}

setBinning() [2/2]

unsigned int HIEventShapeIndex::setBinning

(

HI::BinningScheme

scheme

)

Definition at line 63 of file HIEventShapeIndex.cxx.

{
    unsigned int index=0;
    if(scheme==HI::BinningScheme::TOWER)
    {
        for(unsigned int layer=0; layer < static_cast<int>(HI::TowerBins::numLayers()); layer++)
        {
            auto mItr=m_edges.emplace_hint(m_edges.end(),layer,std::vector<range_index_t>(HI::TowerBins::numEtaBins(),range_index_t()));
            for(unsigned int eb=0; eb<HI::TowerBins::numEtaBins(); eb++,index++)
            {
 
                mItr->second[eb].eta_min=HI::TowerBins::getBinLowEdgeEta(eb);
                mItr->second[eb].eta_max=HI::TowerBins::getBinUpEdgeEta(eb);
                mItr->second[eb].index=index;
            }
        }
    }
    else if(scheme==HI::BinningScheme::COMPACT)
    {
        float deta=HI::TowerBins::getBinSizeEta();
        for(int layer=0; layer < static_cast<int>(HI::TowerBins::numLayers()); layer++)
        {
            float emax=HICaloRange::getRange().getRangeMax(layer);
            float emin=HICaloRange::getRange().getRangeMin(layer);
            unsigned int num_eta_bins= static_cast<unsigned int>(std::round(std::abs((emax-emin)/deta)));
            auto mItr=m_edges.emplace_hint(m_edges.end(),layer,std::vector<range_index_t>(2*num_eta_bins,range_index_t()));
            for(unsigned int k=0; k<num_eta_bins; k++)
            {
                mItr->second[k].eta_min=roundToTenth(-emax+k*deta);
                mItr->second[k].eta_max=roundToTenth(-emax+k*deta+deta);
                mItr->second[k].index=roundToTenth(k+index);
                mItr->second[k+num_eta_bins].eta_min=roundToTenth(emin+k*deta);
                mItr->second[k+num_eta_bins].eta_max=roundToTenth(emin+k*deta+deta);
                mItr->second[k+num_eta_bins].index=roundToTenth(k+num_eta_bins+index);
            }
            index+=2*num_eta_bins;
        }
    }
    m_size=index;
    return index;
 
}

Member Data Documentation

m_edges

std::map<int,std::vector<range_index_t> > HIEventShapeIndex::m_edges

private

Definition at line 58 of file HIEventShapeIndex.h.

m_size

unsigned int HIEventShapeIndex::m_size {}

private

Definition at line 60 of file HIEventShapeIndex.h.

{};

---

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

• HIEventShapeIndex.h
• HIEventShapeIndex.cxx