Histogram class, similar to Root's TH2D. More...

#include <MuonHoughHisto2D.h>

Inheritance diagram for MuonHoughHisto2D:

Collaboration diagram for MuonHoughHisto2D:

Public Member Functions
	~MuonHoughHisto2D ()=default
	destructor
	MuonHoughHisto2D (int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, int number_of_maxima=1)
	constructor
int	fill (double x, double y, double weight=1.)
	fill 2d histogram with point (x,y) with weight w, return binnumber filled
void	fill (int binnumber, double weight=1.)
	fill bin with weight w
int	getNbinsX () const
	returns number of bins x coordinate
int	getNbinsY () const
	returns number of bins y coordinate
double	getXmin () const
	returns min x axis
double	getXmax () const
	returns max x axis
double	getBinWidthX () const
	return binwidth x axis
double	getBinWidthY () const
	return binwidth y axis
double	getBinContent (int binnumber) const
	returns x axis
void	reset ()
	clears histogram and bins_above_threshold
void	findMaxima ()
	find maxima in histogram
std::pair< int, double >	getMax () const
	returns binnumber and maximum of histogram (doesn't use m_bins_above_threshold)
std::pair< int, double >	getMaximumBin (unsigned int maximum_number=0)
	returns binnumber and maximum of maximum number maximum_number
std::pair< double, double >	getCoordsMaximum (unsigned int maximum_number=0)
	returns coords of maximum number maximum_number
bool	checkIfMaximumAlreadyUsed (int binnumber) const
	check when searching for several maxima if binnumber is close to an earlier found maximum
bool	checkIfMaximum (int binnumber, double &maximum, int &maxbin) const
	check if binnumber is a maximum
int	distanceBins (int binnumber1, int binnumber2) const
	calculates the distance in binwidths between two binnumbers ("Manhattan metric")
double	getMaximum (unsigned int maximum_number=0)
	return value of maximum bin
int	getMaxBin (unsigned int maximum_number=0)
	return maximum binnumber
double	content_Bin_Area (int binnumber) const
	return the total content of binarea (default: content of bin)
std::pair< double, double >	binnumberToCoords (int binnumber, int printlevel=0) const
	gives coordinates for certain binnumber
double	binnumberToXCoord (int binnumber) const
	gives x-coordinate for certain binnumber
double	binnumberToYCoord (int binnumber) const
	gives y-coordinate for certain binnumber
int	coordToBinnumber (double x, double y) const
	converts coordinates to a binnumber
int	coordToBinx (double x) const
	converts x-coordinates to binx
int	coordToBiny (double y) const
	converts y-coordinates to biny
int	binInHistogram (unsigned int bin) const
	checks if bin is in histogram or if it is an under/overflow bin (unused) 0 is in histo 1 x underflow 2 x overflow 3 y underflow 4 y overflow
void	setThreshold (double threshold)
	set threshold for maxima in histogram
double	getThreshold () const
	returns threshold for maxima in histogram
std::unique_ptr< TH2F >	bookAndFillRootHistogram (const std::string &hname) const
	intialises a root histogram of MuonHoughHisto2D and fill it, used for debugging purposes
void	setMaximumIsValid (bool flag)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	init ()
	initialises private members, called in constructor
void	resetHisto ()
	resets histogram
void	setBinContent (int binnumber, double value)
	set bin content of binnumber
void	setBinContent (int binx, int biny, double value)
	set bin content of binnumber corresponding to coordinates
MuonHoughHisto2D &	operator= (const MuonHoughHisto2D &right)
	MuonHoughHisto2D (const MuonHoughHisto2D &)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::unique_ptr< unsigned int[]>	m_histBuffer {}
	actual storage of bin values
unsigned int	m_size {0}
	size of array
unsigned int	m_nbinsx {0}
	number of x bins
unsigned int	m_nbinsx_plus2 {0}
	number of x bins + 2 , used for cpu speedup
double	m_xmin {0}
	minimum x coordinate
double	m_xmax {0}
	maximum x coordinate
unsigned int	m_nbinsy {0}
	number of y bins
unsigned int	m_nbinsy_plus2 {0}
	number of y bins + 2 , used for cpu speedup
double	m_ymin {0.}
	minimum y coordinate
double	m_ymax {0.}
	maximum y coordinate
double	m_binwidthx {0.}
	binwidth x axis
double	m_binwidthy {0.}
	binwidth y axis
double	m_invbinwidthx {0.}
	inv binwidth x axis used for cpu speedup
double	m_invbinwidthy {0.}
	inv binwidth y axis used for cpu speedup
std::set< int >	m_bins_above_threshold {}
	set of bins that are above threshold used for speeding up searching for maxima
std::vector< int >	m_maximumbins {}
	binnumbers found as maxima
const int	m_number_of_maxima {0}
	number of maxima to be searched for
unsigned int	m_scale {0}
	threshold for minimum content for a maximum
unsigned int	m_threshold {0}
const int	m_distance_to_next_maximum {0}
	minimum distance for a maximum to be away from another maximum
bool	m_maxima_found {false}
	check if search for maxima already performed
int	m_maximumBin {-1}
	maximum
unsigned int	m_maximum {0}
bool	m_maximumIsValid {true}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Histogram class, similar to Root's TH2D.

Binnumbering is similar to Root's numbering. Starting in left corner to right upper corner Remind the over/under flow bins

Definition at line 22 of file MuonHoughHisto2D.h.

Constructor & Destructor Documentation

◆ ~MuonHoughHisto2D()

MuonHoughHisto2D::~MuonHoughHisto2D ( )

default

destructor

◆ MuonHoughHisto2D() [1/2]

MuonHoughHisto2D::MuonHoughHisto2D	(	int	nbinsx,
		double	xmin,
		double	xmax,
		int	nbinsy,
		double	ymin,
		double	ymax,
		int	number_of_maxima = 1 )

constructor

Definition at line 10 of file MuonHoughHisto2D.cxx.

                                                                                                                                   :
    AthMessaging("MuonHoughHisto2D"),
    m_nbinsx(nbinsx),
    m_xmin(xmin),
    m_xmax(xmax),
    m_nbinsy(nbinsy),
    m_ymin(ymin),
    m_ymax(ymax),
    m_number_of_maxima(number_of_maxima),
    m_scale(10000),
    m_threshold(2.1 * m_scale),
    m_distance_to_next_maximum(100) {
    m_nbinsx_plus2 = nbinsx + 2;
    m_nbinsy_plus2 = nbinsy + 2;
    m_size = m_nbinsx_plus2 * m_nbinsy_plus2;
 
    m_binwidthx = (m_xmax - m_xmin) / (m_nbinsx + 0.);
    m_binwidthy = (m_ymax - m_ymin) / (m_nbinsy + 0.);
 
    m_invbinwidthx = 1. / m_binwidthx;
    m_invbinwidthy = 1. / m_binwidthy;
    init();
}

◆ MuonHoughHisto2D() [2/2]

MuonHoughHisto2D::MuonHoughHisto2D ( const MuonHoughHisto2D & )

private

Member Function Documentation

◆ binInHistogram()

int MuonHoughHisto2D::binInHistogram ( unsigned int bin ) const

checks if bin is in histogram or if it is an under/overflow bin (unused) 0 is in histo 1 x underflow 2 x overflow 3 y underflow 4 y overflow

Definition at line 210 of file MuonHoughHisto2D.cxx.

                                                                 {
    int bininhisto = 0;
 
    if ((binnumber) % m_nbinsx_plus2 == 0) {
        bininhisto = 1;
    } else if ((binnumber + 1) % m_nbinsx_plus2 == 0) {
        bininhisto = 2;
    } else if (binnumber <= m_nbinsx_plus2) {
        bininhisto = 3;
    } else if (binnumber >= m_nbinsx_plus2 * (getNbinsY() + 1)) {
        bininhisto = 4;
    }
 
    return bininhisto;
}

◆ binnumberToCoords()

std::pair< double, double > MuonHoughHisto2D::binnumberToCoords	(	int	binnumber,
		int	printlevel = 0 ) const

gives coordinates for certain binnumber

Definition at line 189 of file MuonHoughHisto2D.cxx.

                                                                                      {
    std::pair<double, double> coordsbin;
    if (binnumber < 0) {
        ATH_MSG_WARNING("MuonHoughHisto2D::ERROR: negativebinnumber: " << binnumber);
        coordsbin.first = 99999.;
        coordsbin.second = 99999.;
        return coordsbin;
    }
 
    double xcoord = binnumberToXCoord(binnumber);
    double ycoord = binnumberToYCoord(binnumber);
 
    ATH_MSG_VERBOSE("MuonHoughHisto2D::Maximum: " << getBinContent(binnumber) << " binnumber: " << binnumber << " x: " << xcoord
                    << " y: " << ycoord);
    
 
    coordsbin.first = xcoord;
    coordsbin.second = ycoord;
    return coordsbin;
}

◆ binnumberToXCoord()

double MuonHoughHisto2D::binnumberToXCoord ( int binnumber ) const

inline

gives x-coordinate for certain binnumber

Definition at line 228 of file MuonHoughHisto2D.h.

                                                                     {
    return m_xmin + m_binwidthx * (-0.5 + (binnumber) % m_nbinsx_plus2);
}

◆ binnumberToYCoord()

double MuonHoughHisto2D::binnumberToYCoord ( int binnumber ) const

inline

gives y-coordinate for certain binnumber

Definition at line 231 of file MuonHoughHisto2D.h.

                                                                     {
    return m_ymin + m_binwidthy * (-0.5 + (binnumber) / m_nbinsx_plus2);
}

◆ bookAndFillRootHistogram()

std::unique_ptr< TH2F > MuonHoughHisto2D::bookAndFillRootHistogram ( const std::string & hname ) const

intialises a root histogram of MuonHoughHisto2D and fill it, used for debugging purposes

Definition at line 226 of file MuonHoughHisto2D.cxx.

                                                                                           {
    std::unique_ptr<TH2F> histogram = std::make_unique<TH2F>(hname.c_str(), hname.c_str(), m_nbinsx, m_xmin, m_xmax, m_nbinsy, m_ymin, m_ymax);
    for (unsigned int i = 0; i < m_size; i++) {
        int ix = i % m_nbinsx_plus2;
        int iy = i / m_nbinsx_plus2;
        histogram->SetBinContent(ix, iy, m_histBuffer[i] / (double)m_scale);
    }
    return histogram;
}

◆ checkIfMaximum()

bool MuonHoughHisto2D::checkIfMaximum	(	int	binnumber,
		double &	maximum,
		int &	maxbin ) const

check if binnumber is a maximum

Definition at line 157 of file MuonHoughHisto2D.cxx.

                                                                                       {
    bool check = false;
 
    double content_bin_area = content_Bin_Area(binnumber);  // now no area anymore == getBinContent
 
    // when using negative weights the following can happen:
    if (content_bin_area < m_threshold) return check;
 
    if (content_bin_area == maximum) {
        if (getBinContent(maxbin) > getBinContent(binnumber))  // give preference to maximum with peak ( _U_ )
        {
            check = true;
            maximum = content_bin_area;
            maxbin = binnumber;
        }
    } else if (content_bin_area > maximum) {
        check = true;
        maximum = content_bin_area;
        maxbin = binnumber;
    }
    return check;
}  // checkIfMaximum

◆ checkIfMaximumAlreadyUsed()

bool MuonHoughHisto2D::checkIfMaximumAlreadyUsed ( int binnumber ) const

check when searching for several maxima if binnumber is close to an earlier found maximum

Definition at line 144 of file MuonHoughHisto2D.cxx.

                                                                    {
    bool check = false;
 
    for (unsigned int i = 0; i < m_maximumbins.size(); i++) {
        if (distanceBins(binnumber, m_maximumbins[i]) < m_distance_to_next_maximum) {
            check = true;
            return check;
        }
    }
 
    return check;
}

◆ content_Bin_Area()

double MuonHoughHisto2D::content_Bin_Area ( int binnumber ) const

inline

return the total content of binarea (default: content of bin)

Definition at line 206 of file MuonHoughHisto2D.h.

206{ return getBinContent(binnumber); }

◆ coordToBinnumber()

int MuonHoughHisto2D::coordToBinnumber	(	double	x,
		double	y ) const

inline

converts coordinates to a binnumber

Definition at line 223 of file MuonHoughHisto2D.h.

                                                                      {
    int biny = coordToBiny(y);
    int binx = coordToBinx(x);
    return binx + biny * m_nbinsx_plus2;
}

◆ coordToBinx()

int MuonHoughHisto2D::coordToBinx ( double x ) const

inline

converts x-coordinates to binx

Definition at line 221 of file MuonHoughHisto2D.h.

221{ return static_cast<int>((x - m_xmin) * m_invbinwidthx) + 1; }

◆ coordToBiny()

int MuonHoughHisto2D::coordToBiny ( double y ) const

inline

converts y-coordinates to biny

Definition at line 222 of file MuonHoughHisto2D.h.

222{ return static_cast<int>((y - m_ymin) * m_invbinwidthy) + 1; }

◆ distanceBins()

int MuonHoughHisto2D::distanceBins	(	int	binnumber1,
		int	binnumber2 ) const

calculates the distance in binwidths between two binnumbers ("Manhattan metric")

Definition at line 180 of file MuonHoughHisto2D.cxx.

                                                                       {
    int binnumberdistance = std::abs(binnumber1 - binnumber2);
 
    // Manhattan metric:
    int distance = (binnumberdistance % m_nbinsx_plus2) + (binnumberdistance / m_nbinsx_plus2);
 
    return distance;
}

◆ fill() [1/2]

int MuonHoughHisto2D::fill	(	double	x,
		double	y,
		double	weight = 1. )

inline

fill 2d histogram with point (x,y) with weight w, return binnumber filled

Definition at line 190 of file MuonHoughHisto2D.h.

                                                              {
    int binnumber = coordToBinnumber(x, y);
    fill(binnumber, w);
    return binnumber;
}

◆ fill() [2/2]

void MuonHoughHisto2D::fill	(	int	binnumber,
		double	weight = 1. )

inline

fill bin with weight w

Definition at line 196 of file MuonHoughHisto2D.h.

                                                               {
    unsigned int& binval = m_histBuffer[binnumber];
    binval += m_scale * weight;
    if (binval > m_maximum) {
        m_maximum = binval;
        m_maximumBin = binnumber;
    }
}

◆ findMaxima()

void MuonHoughHisto2D::findMaxima ( )

find maxima in histogram

Definition at line 47 of file MuonHoughHisto2D.cxx.

                                  {
    m_maximumbins.clear();  // clear old m_maxima_vector and start searching again
 
    int maximum_number = 0;
 
    while (maximum_number < m_number_of_maxima) {
        double maximum = -1.;
        //coverity defect 13671: max bin was set to -1 initially, but this is sued as an index into the array
        int maxbin = 0;
 
        ATH_MSG_VERBOSE("MuonHoughHisto2D::size bins above threshold: " << m_bins_above_threshold.size());
      
        for (const int bin_num :m_bins_above_threshold) {
            if (!checkIfMaximumAlreadyUsed(bin_num)) {
                checkIfMaximum(bin_num, maximum, maxbin);  // call by ref
            }
        }
 
        if (maximum < m_threshold) {
            ATH_MSG_DEBUG("MuonHoughHisto2D:: no maximum found");
            break;
        } else {
            ATH_MSG_DEBUG("MuonHoughHisto2D:: Maximum found: " << maximum << " binnumber: " << maxbin << " R (z) " << binnumberToCoords(maxbin).first
                    << " angle " << binnumberToCoords(maxbin).second);
            m_maximumbins.push_back(maxbin);
        }  // maxbin <> m_threshold
 
        if (maximum == -1.) {
            ATH_MSG_VERBOSE("MuonHoughHisto2D::No Bins Above Threshold");
        } else {
            std::pair<double, double> coords = binnumberToCoords(maxbin);
            ATH_MSG_VERBOSE("MuonHoughHisto2D::Maximum Number: " << maximum_number << " Maximum: " << maximum
                << " binnumber: " << maxbin << " x: " << coords.first << " y: " << coords.second);
        }    
        maximum_number++;
    }  // number_of_maxima
 
    m_maxima_found = 1;
}

◆ getBinContent()

double MuonHoughHisto2D::getBinContent ( int binnumber ) const

inline

returns x axis

Definition at line 205 of file MuonHoughHisto2D.h.

205{ return m_histBuffer[binnumber] / m_scale; }

◆ getBinWidthX()

double MuonHoughHisto2D::getBinWidthX ( ) const

inline

return binwidth x axis

Definition at line 211 of file MuonHoughHisto2D.h.

211{ return m_binwidthx; }

◆ getBinWidthY()

double MuonHoughHisto2D::getBinWidthY ( ) const

inline

return binwidth y axis

Definition at line 212 of file MuonHoughHisto2D.h.

212{ return m_binwidthy; }

◆ getCoordsMaximum()

std::pair< double, double > MuonHoughHisto2D::getCoordsMaximum ( unsigned int maximum_number = 0 )

returns coords of maximum number maximum_number

Definition at line 130 of file MuonHoughHisto2D.cxx.

                                                                                      {
    std::pair<double, double> coordsmaximum;
    int binnumber = getMaxBin(maximum_number);
 
    if (binnumber != -1) {
        coordsmaximum = binnumberToCoords(binnumber);
    } else {
        ATH_MSG_WARNING("HoughTransform::No Maximum Found");
        coordsmaximum.first = 99999.;
        coordsmaximum.second = 99999.;
    }
    return coordsmaximum;
}

◆ getMax()

std::pair< int, double > MuonHoughHisto2D::getMax ( ) const

returns binnumber and maximum of histogram (doesn't use m_bins_above_threshold)

Definition at line 87 of file MuonHoughHisto2D.cxx.

                                                    {
    std::pair<int, double> maxpair;
    int maxbin = -1;  // convention! for no bin above threshold
    unsigned int maximum = m_threshold;
 
    if (m_maximumIsValid) {
        if (m_maximum > m_threshold) {
            maxbin = m_maximumBin;
            maximum = m_maximum;
        }
    } else {
        for (unsigned int i = 0; i < m_size; i++) {
            if (m_histBuffer[i] > maximum) {
                maximum = m_histBuffer[i];
                maxbin = i;
            }
        }
    }
    maxpair.first = maxbin;
    maxpair.second = maximum;
 
    return maxpair;
}

◆ getMaxBin()

int MuonHoughHisto2D::getMaxBin ( unsigned int maximum_number = 0 )

inline

return maximum binnumber

Definition at line 218 of file MuonHoughHisto2D.h.

                                                                  {
    return getMaximumBin(maximum_number).first;
}

◆ getMaximum()

double MuonHoughHisto2D::getMaximum ( unsigned int maximum_number = 0 )

inline

return value of maximum bin

Definition at line 215 of file MuonHoughHisto2D.h.

                                                                      {
    return getMaximumBin(maximum_number).second;
}

◆ getMaximumBin()

std::pair< int, double > MuonHoughHisto2D::getMaximumBin ( unsigned int maximum_number = 0 )

returns binnumber and maximum of maximum number maximum_number

Definition at line 111 of file MuonHoughHisto2D.cxx.

                                                                                {
    if (m_maxima_found == 0) {
        findMaxima();  // fills m_maximumbins
    }
 
    int maxbin = -1;
    double maximum = -1.;
 
    ATH_MSG_VERBOSE("MuonHoughHisto2D:: m_maximumbins.size: " << m_maximumbins.size());
    
 
    if (m_maximumbins.size() > maximum_number) {
        maxbin = m_maximumbins[maximum_number];
        maximum = content_Bin_Area(maxbin);
    }
    return std::make_pair(maxbin, maximum);
 
}  // getMaximumBin

◆ getNbinsX()

int MuonHoughHisto2D::getNbinsX ( ) const

inline

returns number of bins x coordinate

Definition at line 207 of file MuonHoughHisto2D.h.

207{ return m_nbinsx; }

◆ getNbinsY()

int MuonHoughHisto2D::getNbinsY ( ) const

inline

returns number of bins y coordinate

Definition at line 208 of file MuonHoughHisto2D.h.

208{ return m_nbinsy; }

◆ getThreshold()

double MuonHoughHisto2D::getThreshold ( ) const

inline

returns threshold for maxima in histogram

Definition at line 214 of file MuonHoughHisto2D.h.

214{ return m_threshold; }

◆ getXmax()

double MuonHoughHisto2D::getXmax ( ) const

inline

returns max x axis

Definition at line 210 of file MuonHoughHisto2D.h.

210{ return m_xmax; }

◆ getXmin()

double MuonHoughHisto2D::getXmin ( ) const

inline

returns min x axis

Definition at line 209 of file MuonHoughHisto2D.h.

209{ return m_xmin; }

◆ init()

void MuonHoughHisto2D::init ( )

private

initialises private members, called in constructor

Definition at line 34 of file MuonHoughHisto2D.cxx.

34{ m_histBuffer.reset( new unsigned int[m_size]); }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

179{ return msg() << lvl; }

AthMessaging::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:163

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ operator=()

MuonHoughHisto2D & MuonHoughHisto2D::operator= ( const MuonHoughHisto2D & right )

private

◆ reset()

void MuonHoughHisto2D::reset ( )

clears histogram and bins_above_threshold

Definition at line 36 of file MuonHoughHisto2D.cxx.

                             {
    resetHisto();
 
    m_bins_above_threshold.clear();
    m_maximumbins.clear();  // obsolete?
    m_maxima_found = 0;
    m_maximumBin = -1;
    m_maximum = 0;
    m_maximumIsValid = true;
}

◆ resetHisto()

void MuonHoughHisto2D::resetHisto ( )

inlineprivate

resets histogram

Definition at line 234 of file MuonHoughHisto2D.h.

234{ memset(m_histBuffer.get(), 0, sizeof(unsigned int) * m_size); }

◆ setBinContent() [1/2]

void MuonHoughHisto2D::setBinContent	(	int	binnumber,
		double	value )

inlineprivate

set bin content of binnumber

Definition at line 204 of file MuonHoughHisto2D.h.

204{ m_histBuffer[binnumber] = m_scale * value; }

athena.value

value

Definition athena.py:124

◆ setBinContent() [2/2]

void MuonHoughHisto2D::setBinContent	(	int	binx,
		int	biny,
		double	value )

private

set bin content of binnumber corresponding to coordinates

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

◆ setMaximumIsValid()

void MuonHoughHisto2D::setMaximumIsValid ( bool flag )

inline

Definition at line 115 of file MuonHoughHisto2D.h.

115{ m_maximumIsValid = flag; }

master.flag

bool flag

Definition master.py:29

◆ setThreshold()

void MuonHoughHisto2D::setThreshold ( double threshold )

inline

set threshold for maxima in histogram

Definition at line 213 of file MuonHoughHisto2D.h.

213{ m_threshold = m_scale * threshold; }

dumpTgcDigiThreshold.threshold

list threshold

Definition dumpTgcDigiThreshold.py:34

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_bins_above_threshold

std::set<int> MuonHoughHisto2D::m_bins_above_threshold {}

private

set of bins that are above threshold used for speeding up searching for maxima

Definition at line 158 of file MuonHoughHisto2D.h.

158{};

◆ m_binwidthx

double MuonHoughHisto2D::m_binwidthx {0.}

private

binwidth x axis

Definition at line 147 of file MuonHoughHisto2D.h.

147{0.};

◆ m_binwidthy

double MuonHoughHisto2D::m_binwidthy {0.}

private

binwidth y axis

Definition at line 149 of file MuonHoughHisto2D.h.

149{0.};

◆ m_distance_to_next_maximum

const int MuonHoughHisto2D::m_distance_to_next_maximum {0}

private

minimum distance for a maximum to be away from another maximum

Definition at line 172 of file MuonHoughHisto2D.h.

172{0};

◆ m_histBuffer

std::unique_ptr<unsigned int []> MuonHoughHisto2D::m_histBuffer {}

private

actual storage of bin values

Definition at line 125 of file MuonHoughHisto2D.h.

125{};

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_invbinwidthx

double MuonHoughHisto2D::m_invbinwidthx {0.}

private

inv binwidth x axis used for cpu speedup

Definition at line 152 of file MuonHoughHisto2D.h.

152{0.};

◆ m_invbinwidthy

double MuonHoughHisto2D::m_invbinwidthy {0.}

private

inv binwidth y axis used for cpu speedup

Definition at line 154 of file MuonHoughHisto2D.h.

154{0.};

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_maxima_found

bool MuonHoughHisto2D::m_maxima_found {false}

private

check if search for maxima already performed

Definition at line 175 of file MuonHoughHisto2D.h.

175{false};

◆ m_maximum

unsigned int MuonHoughHisto2D::m_maximum {0}

private

Definition at line 179 of file MuonHoughHisto2D.h.

179{0};

◆ m_maximumBin

int MuonHoughHisto2D::m_maximumBin {-1}

private

maximum

Definition at line 178 of file MuonHoughHisto2D.h.

178{-1};

◆ m_maximumbins

std::vector<int> MuonHoughHisto2D::m_maximumbins {}

private

binnumbers found as maxima

Definition at line 161 of file MuonHoughHisto2D.h.

161{};

◆ m_maximumIsValid

bool MuonHoughHisto2D::m_maximumIsValid {true}

private

Definition at line 180 of file MuonHoughHisto2D.h.

180{true}; // flag whether the maximum can be trusted

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nbinsx

unsigned int MuonHoughHisto2D::m_nbinsx {0}

private

number of x bins

Definition at line 130 of file MuonHoughHisto2D.h.

130{0};

◆ m_nbinsx_plus2

unsigned int MuonHoughHisto2D::m_nbinsx_plus2 {0}

private

number of x bins + 2 , used for cpu speedup

Definition at line 132 of file MuonHoughHisto2D.h.

132{0};

◆ m_nbinsy

unsigned int MuonHoughHisto2D::m_nbinsy {0}

private

number of y bins

Definition at line 138 of file MuonHoughHisto2D.h.

138{0};

◆ m_nbinsy_plus2

unsigned int MuonHoughHisto2D::m_nbinsy_plus2 {0}

private

number of y bins + 2 , used for cpu speedup

Definition at line 140 of file MuonHoughHisto2D.h.

140{0};

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_number_of_maxima

const int MuonHoughHisto2D::m_number_of_maxima {0}

private

number of maxima to be searched for

Definition at line 165 of file MuonHoughHisto2D.h.

165{0};

◆ m_scale

unsigned int MuonHoughHisto2D::m_scale {0}

private

threshold for minimum content for a maximum

Definition at line 168 of file MuonHoughHisto2D.h.

168{0}; // conversion from double -> unsigned int

◆ m_size

unsigned int MuonHoughHisto2D::m_size {0}

private

size of array

Definition at line 127 of file MuonHoughHisto2D.h.

127{0};

◆ m_threshold

unsigned int MuonHoughHisto2D::m_threshold {0}

private

Definition at line 169 of file MuonHoughHisto2D.h.

169{0};

◆ m_xmax

double MuonHoughHisto2D::m_xmax {0}

private

maximum x coordinate

Definition at line 136 of file MuonHoughHisto2D.h.

136{0};

◆ m_xmin

double MuonHoughHisto2D::m_xmin {0}

private

minimum x coordinate

Definition at line 134 of file MuonHoughHisto2D.h.

134{0};

◆ m_ymax

double MuonHoughHisto2D::m_ymax {0.}

private

maximum y coordinate

Definition at line 144 of file MuonHoughHisto2D.h.

144{0.};

◆ m_ymin

double MuonHoughHisto2D::m_ymin {0.}

private

minimum y coordinate

Definition at line 142 of file MuonHoughHisto2D.h.

142{0.};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~MuonHoughHisto2D()

◆ MuonHoughHisto2D() [1/2]

◆ MuonHoughHisto2D() [2/2]

Member Function Documentation

◆ binInHistogram()

◆ binnumberToCoords()

◆ binnumberToXCoord()

◆ binnumberToYCoord()

◆ bookAndFillRootHistogram()

◆ checkIfMaximum()

◆ checkIfMaximumAlreadyUsed()

◆ content_Bin_Area()

◆ coordToBinnumber()

◆ coordToBinx()

◆ coordToBiny()

◆ distanceBins()

◆ fill() [1/2]

◆ fill() [2/2]

◆ findMaxima()

◆ getBinContent()

◆ getBinWidthX()

◆ getBinWidthY()

◆ getCoordsMaximum()

◆ getMax()

◆ getMaxBin()

◆ getMaximum()

◆ getMaximumBin()

◆ getNbinsX()

◆ getNbinsY()

◆ getThreshold()

◆ getXmax()

◆ getXmin()

◆ init()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ operator=()

◆ reset()

◆ resetHisto()

◆ setBinContent() [1/2]

◆ setBinContent() [2/2]

◆ setLevel()

◆ setMaximumIsValid()

◆ setThreshold()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_bins_above_threshold

◆ m_binwidthx

◆ m_binwidthy

◆ m_distance_to_next_maximum

◆ m_histBuffer

◆ m_imsg

◆ m_invbinwidthx

◆ m_invbinwidthy

◆ m_lvl

◆ m_maxima_found

◆ m_maximum

◆ m_maximumBin

◆ m_maximumbins

◆ m_maximumIsValid

◆ m_msg_tls

◆ m_nbinsx

◆ m_nbinsx_plus2

◆ m_nbinsy

◆ m_nbinsy_plus2

◆ m_nm

◆ m_number_of_maxima

◆ m_scale

◆ m_size

◆ m_threshold

◆ m_xmax

◆ m_xmin

◆ m_ymax

◆ m_ymin