MuonHoughTransformer_rz Class Reference

#include <MuonHoughTransformer_rz.h>

Inheritance diagram for MuonHoughTransformer_rz:

Collaboration diagram for MuonHoughTransformer_rz:

Public Member Functions
	MuonHoughTransformer_rz (int nbins, int nbins_angle, double detectorsize, double detectorsize_angle, double threshold_histo, int number_of_sectors=1)
virtual	~MuonHoughTransformer_rz ()=default
virtual void	fillHit (const std::shared_ptr< MuonHoughHit > &hit, double weight=1.) override final
	fill histograms with hit
virtual int	fillHisto (double rz0, double theta, double weight, int sector) override final
	fill histogram with certain coordinate
virtual float	weightHoughTransform (double r0) const override final
	weight houghtransform, give more importance to houghtransforms close to origin
float	weightHoughTransform (double r0, double angle) const
int	sector (const std::shared_ptr< MuonHoughHit > &hit) const override final
	returns sector for coords
virtual void	fill (const MuonHoughHitContainer &event, bool subtract=false)
	fill histograms with hitcontainer
std::unique_ptr< MuonHoughPattern >	associateHitsToMaximum (const MuonHoughHitContainer &event, double residu_mm, double residu_grad, int maximum_number) const
	associate hits to certain maximum number of histograms
std::unique_ptr< MuonHoughPattern >	associateHitsToCoords (const MuonHoughHitContainer &event, std::pair< double, double > coords, double residu_mm, double residu_angle, int sector=0) const
	associate hits to certain coordinates and sector
std::unique_ptr< MuonHoughPattern >	associateHitsToBinnumber (const MuonHoughHitContainer &event, int binnumber, double maximum_residu_mm, double maximum_residu_angle, int sector=0) const
	associate hits to certain binnumber and sector
void	resetHisto ()
	reset histograms
void	useNegativeWeights (bool use_negative_weights)
	use negative weights
std::vector< std::pair< int, int > >	getMaxima (int max_patterns) const
	return the first certain number of maxima of histograms
void	setIP (bool ip_setting)
	set m_ip_setting (e.g.
const MuonHoughHisto2DContainer &	histos () const
	access to histograms
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.

Static Public Member Functions
static double	calculateAngle (double hitx, double hity, double hitz, double z0)

Protected Member Functions
std::unique_ptr< MuonHoughPattern >	hookAssociateHitsToMaximum (const MuonHoughHitContainer &event, std::pair< double, double > coordsmaximum, double residu_mm, double residu_grad, int sector) const override final
	pure virtual method for derived class implementation of associateHitsToMaximum method
std::pair< double, double >	getEndPointsFillLoop (double radius, double stepsize, int sector) const
	returns begin and end value of the filling loop

Protected Attributes
const bool	m_use_residu_grad
MuonHoughHisto2DContainer	m_histos
	histogram container
double	m_threshold_histo
	threshold of histograms
unsigned int	m_eventsize
	size of event to be filled (can be used for weighting)
double	m_eventsize_weightfactor
	weightfactor based on eventsize (used in curved hough transform)
bool	m_add_weight_angle
	use weight of patterns in angle coordinate
double	m_weight_constant_angle
	weight constant of patterns in angle coordinate
bool	m_add_weight_radius
	use weight of patterns in radius coordinate
double	m_weight_constant_radius
	weight constant of patterns in radius coordinate
bool	m_use_negative_weights
	use of negative weights
MuonHoughMathUtils	m_muonhoughmathutils
	object for use of mathematical formulas for trackmodels
const int	m_nbins
	number of bins in histograms in radius coordinate
const int	m_nbins_plus3
	number of bins in histograms in radius coordinate
const int	m_nbins_angle
	number of bins in histograms in angle coordinate
const double	m_detectorsize
	range of radius coordinate
const double	m_detectorsize_angle
	range of angle coordinate
double	m_binwidthx
	x-binwidth of histogram
double	m_binwidthy
	y-binwidth of histogram
double	m_stepsize
	stepsize of transform for radius coordinate
double	m_stepsize_per_angle
	stepsize of transform for angle coordinate
bool	m_ip_setting
	use settings for patterns originating from origin
const int	m_number_of_sectors
	number of histograms (1 for cosmics 16 for rz)

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
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

Definition at line 10 of file MuonHoughTransformer_rz.h.

Constructor & Destructor Documentation

MuonHoughTransformer_rz()

MuonHoughTransformer_rz::MuonHoughTransformer_rz	(	int	nbins,
		int	nbins_angle,
		double	detectorsize,
		double	detectorsize_angle,
		double	threshold_histo,
		int	number_of_sectors = 1 )

Definition at line 7 of file MuonHoughTransformer_rz.cxx.

                                                                                                :
    MuonHoughTransformer("MuonHoughTransformer_rz", nbins, nbins_angle, detectorsize, detectorsize_angle, threshold_histo, number_of_sectors),
    m_use_residu_grad(false) {
    m_add_weight_radius = false;
    m_weight_constant_radius = 0.;
    m_add_weight_angle = false;
}

~MuonHoughTransformer_rz()

virtual MuonHoughTransformer_rz::~MuonHoughTransformer_rz ( )

virtualdefault

Member Function Documentation

associateHitsToBinnumber()

std::unique_ptr< MuonHoughPattern > MuonHoughTransformer::associateHitsToBinnumber ( const MuonHoughHitContainer & event, int binnumber, double maximum_residu_mm, double maximum_residu_angle, int sector = 0 ) const

inherited

associate hits to certain binnumber and sector

Definition at line 96 of file MuonHoughTransformer.cxx.

                                                                                                                                          {
    ATH_MSG_VERBOSE("associateHitsToBinnumber() -- sector "<<sector<<",binnumber "<<binnumber<<
                    " maximum of histogram: " << m_histos.getHisto(sector)->getBinContent(binnumber));
   
    std::pair<double, double> coordsmaximum = m_histos.getHisto(sector)->binnumberToCoords(binnumber);
    std::unique_ptr<MuonHoughPattern> houghpattern = hookAssociateHitsToMaximum(event, coordsmaximum, 
                                                     maximum_residu_mm, maximum_residu_angle, sector);
    houghpattern->setMaximumHistogram(m_histos.getHisto(sector)->getBinContent(binnumber));
    return houghpattern;
}

associateHitsToCoords()

std::unique_ptr< MuonHoughPattern > MuonHoughTransformer::associateHitsToCoords ( const MuonHoughHitContainer & event, std::pair< double, double > coords, double residu_mm, double residu_angle, int sector = 0 ) const

inherited

associate hits to certain coordinates and sector

Definition at line 91 of file MuonHoughTransformer.cxx.

                                                                                                                                       {
    return hookAssociateHitsToMaximum(event, coordsmaximum, maximum_residu_mm, maximum_residu_angle, sector);   
}

associateHitsToMaximum()

std::unique_ptr< MuonHoughPattern > MuonHoughTransformer::associateHitsToMaximum ( const MuonHoughHitContainer & event, double residu_mm, double residu_grad, int maximum_number ) const

inherited

associate hits to certain maximum number of histograms

Definition at line 63 of file MuonHoughTransformer.cxx.

                                                                                                                     {
    std::unique_ptr<MuonHoughPattern> houghpattern{};
    std::pair<double, double> coordsmaximum;
    std::pair<int, int> maximumbin;
    maximumbin = m_histos.getMaximumBinnumber();
 
    int sector = maximumbin.first;
 
    if (sector != -1) {
        coordsmaximum = m_histos.getHisto(sector)->getCoordsMaximum(maximum_number);
        if (maximumbin.second == -1){  // no maximum, no bin above threshold
            ATH_MSG_VERBOSE("No Maximum Found");
            return nullptr;
        }
        ATH_MSG_VERBOSE("maximum binnumber of histogram: " << maximumbin.second
                        << " value: " << m_histos.getHisto(sector)->getBinContent(maximumbin.second));
        ATH_MSG_VERBOSE(" coordinates: " << coordsmaximum.first << " second " << coordsmaximum.second<<" sector: "<<sector);
        houghpattern = hookAssociateHitsToMaximum(event, coordsmaximum, maximum_residu_mm, maximum_residu_grad, sector);
        if (houghpattern) { houghpattern->setMaximumHistogram(m_histos.getHisto(sector)->getBinContent(maximumbin.second)); }
    } else {
        ATH_MSG_VERBOSE("No Maximum Found sector is -1");
        return nullptr;
    }
 
    return houghpattern;
}

calculateAngle()

double MuonHoughTransformer_rz::calculateAngle ( double hitx, double hity, double hitz, double z0 )

static

Definition at line 100 of file MuonHoughTransformer_rz.cxx.

                                                                                               {
    // z0 is cartesian coordinate where track goes through z axis
 
    // analog to xyz:
    double theta = 0;
    double r = std::sqrt(hitx * hitx + hity * hity);
 
    theta = std::atan2(r, hitz - z0);
 
    return theta;
}

fill()

void MuonHoughTransformer::fill ( const MuonHoughHitContainer & event, bool subtract = false )

virtualinherited

fill histograms with hitcontainer

Definition at line 47 of file MuonHoughTransformer.cxx.

                                                                                 {
    m_eventsize = event.size();
    m_eventsize_weightfactor = 20. * std::sqrt(m_eventsize) / std::sqrt(7000.);
    if (subtract) {
        // invalidate maxima
        for (int i = 0; i < m_histos.size(); ++i) m_histos.getHisto(i)->setMaximumIsValid(false);
 
        for (unsigned int hitid = 0; hitid < m_eventsize; hitid++) {
            std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
            if (hit->getAssociated()) fillHit(hit, -1. * hit->getWeight());
        }
    } else {
        for (unsigned int hitid = 0; hitid < m_eventsize; hitid++) { fillHit(event.getHit(hitid), event.getHit(hitid)->getWeight()); }
    }
}

fillHisto()

int MuonHoughTransformer_rz::fillHisto ( double coord1, double coord2, double weight, int sector )

finaloverridevirtual

fill histogram with certain coordinate

Implements MuonHoughTransformer.

Definition at line 56 of file MuonHoughTransformer_rz.cxx.

                                                                                                  {
    MuonHoughHisto2D* histo = m_histos.getHisto(sector);
 
    double binwidthx = histo->getBinWidthX();
    double binwidthy = histo->getBinWidthY();
 
    int filled_binnumber = histo->fill(rz0, theta_in_grad, weight);
    // butterfly:
 
    // nearby sectors:
    if (m_number_of_sectors >= 3) {
        double third_weight = weight / 3.;
        if (sector != 0 && sector != m_number_of_sectors - 1) {
            m_histos.getHisto(sector + 1)->fill(rz0, theta_in_grad, third_weight);
            m_histos.getHisto(sector - 1)->fill(rz0, theta_in_grad, third_weight);
        } else if (sector == 0) {
            m_histos.getHisto(sector + 1)->fill(rz0, theta_in_grad, third_weight);
            m_histos.getHisto(m_number_of_sectors - 1)->fill(rz0, theta_in_grad, third_weight);
        } else {
            m_histos.getHisto(sector - 1)->fill(rz0, theta_in_grad, third_weight);
            m_histos.getHisto(0)->fill(rz0, theta_in_grad, third_weight);
        }
    }
 
    double half_weight = 0.5 * weight;
 
    if (theta_in_grad - binwidthy < 0) {
        histo->fill(rz0 + binwidthx, theta_in_grad + binwidthy, half_weight);
        if (m_use_negative_weights) { histo->fill(rz0 - binwidthx, theta_in_grad + binwidthy, -half_weight); }
 
    } else if (theta_in_grad + binwidthy > 180.) {
        histo->fill(rz0 - binwidthx, theta_in_grad - binwidthy, half_weight);
        if (m_use_negative_weights) { histo->fill(rz0 + binwidthx, theta_in_grad - binwidthy, -half_weight); }
    } else {
        histo->fill(rz0 + binwidthx, theta_in_grad + binwidthy, half_weight);
        histo->fill(rz0 - binwidthx, theta_in_grad - binwidthy, half_weight);
        if (m_use_negative_weights) {
            histo->fill(rz0 - binwidthx, theta_in_grad + binwidthy, -half_weight);
            histo->fill(rz0 + binwidthx, theta_in_grad - binwidthy, -half_weight);
        }
    }
    return filled_binnumber;
}

fillHit()

void MuonHoughTransformer_rz::fillHit ( const std::shared_ptr< MuonHoughHit > & hit, double weight = 1. )

finaloverridevirtual

fill histograms with hit

Implements MuonHoughTransformer.

Definition at line 16 of file MuonHoughTransformer_rz.cxx.

                                                                                           {
    const double hitz = hit->getHitz();
 
    if (m_ip_setting)  // niels and peter alg, butterfly to be added, and to be looked into the method
    {
        const int sectorhit = sector(hit);
        const double perp = hit->getRadius();
        const double radius = hit->getAbs();
 
        double dotprod = 0;
        MuonHoughHisto2D* histo = m_histos.getHisto(sectorhit);
        for (double rz0 = histo->getXmin() + m_stepsize / 2.; rz0 < histo->getXmax(); rz0 += m_stepsize) {
            if (std::abs(rz0) > radius) continue;
 
            double height = std::sqrt(radius * radius - rz0 * rz0);
            double theta = std::atan2(perp, hitz) + std::atan2(rz0, height);
            double theta_in_grad = (theta / M_PI) * 180.;
 
            dotprod = perp * std::sin(theta) + hitz * std::cos(theta);
 
            if (theta_in_grad > 180.) continue;  // to keep the angle physical
            if (theta_in_grad < 0.) continue;    // idem
 
            if (dotprod >= 0) { fillHisto(rz0, theta_in_grad, weight, sectorhit); }
        }
    } else {
        int sectorhit = 0;
        const double radius = hit->getRadius();
 
        for (double theta = m_stepsize_per_angle / 2.; theta < m_detectorsize_angle; theta += m_stepsize_per_angle) {
            double theta_in_rad = M_PI * theta / 180.;
            double rz0 = hitz * std::sin(theta_in_rad) - radius * std::cos(theta_in_rad);
            double dotprod = 0;
 
            dotprod = radius * std::sin(theta_in_rad) + hitz * std::cos(theta_in_rad);
            if (dotprod >= 0) { fillHisto(rz0, theta, weight, sectorhit); }  // dotprod
        }
    }  // m_atlas_setting
}

getEndPointsFillLoop()

std::pair< double, double > MuonHoughTransformer::getEndPointsFillLoop ( double radius, double stepsize, int sector ) const

protectedinherited

returns begin and end value of the filling loop

Definition at line 108 of file MuonHoughTransformer.cxx.

                                                                                                                   {
    std::pair<double, double> endpoints(-radius + 0.00001, radius);  // why +0.00001?
 
    if (-radius < m_histos.getHisto(sector)->getXmin())  // randomizer to avoid binning effects
    {
        endpoints.first = m_histos.getHisto(sector)->getXmin() + 0.5 * stepsize;  // no randomizer! no radius constraint
    }
 
    if (radius > m_histos.getHisto(sector)->getXmax()) { endpoints.second = m_histos.getHisto(sector)->getXmax(); }
    return endpoints;
}

getMaxima()

std::vector< std::pair< int, int > > MuonHoughTransformer::getMaxima ( int max_patterns ) const

inherited

return the first certain number of maxima of histograms

Definition at line 122 of file MuonHoughTransformer.cxx.

                                                                                    {
    std::vector<std::pair<int, int> > maximumbins;  // sorted
 
    std::vector<std::pair<std::pair<int, int>, double> > maxima;
 
    for (int sector = 0; sector < m_number_of_sectors; sector++)  // to be made more general when m_number_of_sectors ==1 e.g.
    {
        std::pair<int, double> maximumbin = m_histos.getHisto(sector)->getMax();
        std::pair<std::pair<int, int>, double> maximum;
        maximum.first.first = sector;
        maximum.first.second = maximumbin.first;
        maximum.second = maximumbin.second;
        maxima.push_back(maximum);
    }
 
    sort(maxima.begin(), maxima.end(), maximaCompare());
 
    unsigned int count_maxima = 0;  // should be iterator
    int number_of_patterns = 0;
    std::set<int> sectors;  // sectors that are already used
    const unsigned int size = maxima.size();
    while (count_maxima != size && number_of_patterns != max_patterns) {
        std::pair<int, int> maximumbin = maxima[count_maxima].first;
 
        bool check = true;  // check if sector is not nearby a sector already chosen
        int sector = maximumbin.first;
 
        if (sectors.find(sector) != sectors.end()) { check = false; }
 
        if (check) {
            maximumbins.push_back(maximumbin);
            sectors.insert(maximumbin.first);
 
            int sectormin = sector - 1;
            int sectorplus = sector + 1;
            if (sectormin < 0) { sectormin = m_number_of_sectors; }
            if (sectorplus > m_number_of_sectors) { sectorplus = 0; }
 
            sectors.insert(sectormin);
            sectors.insert(sectorplus);
 
            if (m_number_of_sectors > 20 && maximumbin.first % 2 == 1)  // hack for new single and overlap filling curved transform!
            {
                int sectorminmin = sectormin - 1;
                int sectorplusplus = sectorplus + 1;
                sectors.insert(sectorminmin);
                sectors.insert(sectorplusplus);
            }
 
            count_maxima++;
            number_of_patterns++;
        } else {
            count_maxima++;
        }
    }
 
    return maximumbins;
}

histos()

const MuonHoughHisto2DContainer & MuonHoughTransformer::histos ( ) const

inlineinherited

access to histograms

Definition at line 60 of file MuonHoughTransformer.h.

{ return m_histos; }

hookAssociateHitsToMaximum()

std::unique_ptr< MuonHoughPattern > MuonHoughTransformer_rz::hookAssociateHitsToMaximum ( const MuonHoughHitContainer & event, std::pair< double, double > coordsmaximum, double residu_mm, double residu_angle, int sector ) const

finaloverrideprotectedvirtual

pure virtual method for derived class implementation of associateHitsToMaximum method

Implements MuonHoughTransformer.

Definition at line 112 of file MuonHoughTransformer_rz.cxx.

                                                                                                                        {
    
    std::unique_ptr<MuonHoughPattern> houghpattern = std::make_unique<MuonHoughPattern>(MuonHough::hough_rz);
 
    double theta{0.}, residu_distance{0.}, maximum_residu{0.};
    double eradius{0.}, etheta{0.}, sin_theta{0.}, cos_theta{0.}, sin_phi{0.}, cos_phi{0.}, phi{0.}, ephi{0.};
    double coordsmaximumsecondinrad = m_muonhoughmathutils.angleFromGradToRadial(coordsmaximum.second);
    double rz0 = coordsmaximum.first;
 
    ATH_MSG_VERBOSE("MuonHoughTransformer_rz::hookAssociateHitsToMaximum() -- sector: " << maxsector
                    << "coordsmaximumfirst: " << rz0 << "coordsmaximumsecond: " << coordsmaximum.second 
                    << " coordsmaximumsecondinrad: " << coordsmaximumsecondinrad
                    <<" size of event: " << event.size());
 
    for (unsigned int i = 0; i < event.size(); i++) {
        double dotprod = 0;
        double hitx = event.getHitx(i);
        double hity = event.getHity(i);
        int sectorhit = sector(event.getHit(i));
        int maxsecmax = maxsector + 1;
        int maxsecmin = maxsector - 1;
        if (maxsecmin < 0) maxsecmin = m_number_of_sectors - 1;
        if (maxsecmax > m_number_of_sectors - 1) maxsecmax = 0;
        // select which hits could be in maximum:
        if (sectorhit == maxsector || sectorhit == maxsecmin || sectorhit == maxsecmax) {
            double hitz = event.getHitz(i);
            double radius = std::hypot(hitx, hity);
 
            dotprod = radius * std::sin(coordsmaximumsecondinrad) + hitz * std::cos(coordsmaximumsecondinrad);
 
            if (dotprod >= 0) {
                double residu_distance_mm = MuonHoughMathUtils::signedDistanceToLine(hitz, radius, rz0, coordsmaximumsecondinrad);
 
                // Use this code for rz scan and theta
                //
                double radius3 = std::hypot(hitx, hity, hitz);
                double height{0.};
                if (std::abs(rz0) < radius3) {
                    height = std::sqrt(radius3 * radius3 - rz0 * rz0);
                } else {
                    height = std::sqrt(rz0 * rz0 - radius3 * radius3);
                }
 
                theta = std::atan2(radius, hitz) + std::atan2(rz0, height);
                ATH_MSG_VERBOSE("theta: " << theta << " height: " << height << " radius3: " << radius3
                        << "  std::atan2(radius,hitz): " << std::atan2(radius, hitz)
                        << " +std::atan2(rz0,height): " << std::atan2(rz0, height) << " rz0: ");               
                if (m_use_residu_grad == 1) {
                    double residu_distance_grad = std::abs(std::sin(theta - coordsmaximumsecondinrad));
                    residu_distance = residu_distance_grad;
                    maximum_residu = maximum_residu_angle;
                } else {
                    residu_distance = residu_distance_mm;
                    maximum_residu = maximum_residu_mm;
                }
 
                ATH_MSG_VERBOSE("hitx: " << hitx << " hity: " << hity << " hitz: " << hitz 
                                << ", residu_distance: " << residu_distance);                
                bool inmax = false;
                if (std::abs(theta * 180. / M_PI - coordsmaximum.second) < 1.1) inmax = true;
 
                if (std::abs(residu_distance) < maximum_residu)  // here no circular effect
                {
                   ATH_MSG_VERBOSE(" hit added to houghpattern! -- sector number hit " << sectorhit << " max " << maxsector
                            << " detector: " << event.getHit(i)->getWhichDetector() <<  
                            (inmax ?  " MuonHoughTransformer_rz:: in maximum " : " OUTSIDE maximum" )<< " theta hit " << theta * 180. / M_PI << " max Hough theta "
                                << coordsmaximum.second );
                    houghpattern->addHit(event.getHit(i));
 
                    event.getHit(i)->setAssociated(true);
 
                    double rz0hit = residu_distance_mm + rz0;
                    eradius += rz0hit;
                    ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" calculateAngle: " << theta << " calculateradius: " << rz0hit
                                    << " R Z hit added to hough pattern theta hit " 
                                    << atan2(std::hypot(event.getHitx(i) ,event.getHity(i)), event.getHitz(i))
                                    << " theta all " << coordsmaximumsecondinrad);
                    sin_theta += std::sin(theta);
                    cos_theta += std::cos(theta);
 
                    phi = std::atan2(hity, hitx);
 
                    sin_phi += std::sin(phi);
                    cos_phi += std::cos(phi);
                    //}
                } else if (inmax)
                    ATH_MSG_WARNING("LOST hit in maximum distance " );
            }  // dotprod
        }      // sector constraint
    }          // hitno
 
    etheta = std::atan2(sin_theta, cos_theta);
    ephi = std::atan2(sin_phi, cos_phi);
    houghpattern->setEPhi(ephi);
 
    eradius = eradius / (houghpattern->size() + 0.0001);
 
    ATH_MSG_VERBOSE("Etheta : " << etheta << " Size houghpattern " << houghpattern->size() << " ephi "
                    << ephi );
    houghpattern->setETheta(etheta);
    houghpattern->setERTheta(eradius);
    houghpattern->setECurvature(1.);
 
    if (houghpattern->empty()) {
        ATH_MSG_VERBOSE("no hits found on pattern");
    }
 
    else if (std::abs(eradius - rz0) > 500. || std::sin(etheta - coordsmaximumsecondinrad) > 0.05) {
        ATH_MSG_VERBOSE("WARNING Eradius or Etheta calc. WRONG -- rz0: " << rz0 
                        << " etheta: " << coordsmaximumsecondinrad<< " eradius: " << eradius << " etheta: " << etheta );
        houghpattern->setETheta(coordsmaximumsecondinrad);  // coordsmaximumsecondinrad
        houghpattern->setERTheta(rz0);
    }
 
    return houghpattern;
}

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.

{ return msg() << lvl; }

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;
  }
}

resetHisto()

void MuonHoughTransformer::resetHisto ( )

inherited

reset histograms

Definition at line 120 of file MuonHoughTransformer.cxx.

{ m_histos.reset(); }

sector()

int MuonHoughTransformer_rz::sector ( const std::shared_ptr< MuonHoughHit > & hit ) const

inlinefinaloverridevirtual

returns sector for coords

Implements MuonHoughTransformer.

Definition at line 33 of file MuonHoughTransformer_rz.h.

{ return hit->phiSector(); }

setIP()

void MuonHoughTransformer::setIP ( bool ip_setting )

inlineinherited

set m_ip_setting (e.g.

to not split patterns)

Definition at line 140 of file MuonHoughTransformer.h.

{ m_ip_setting = ip_setting; }

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;
}

useNegativeWeights()

void MuonHoughTransformer::useNegativeWeights ( bool use_negative_weights )

inlineinherited

use negative weights

Definition at line 141 of file MuonHoughTransformer.h.

{ m_use_negative_weights = use_negative_weights; }

weightHoughTransform() [1/2]

float MuonHoughTransformer_rz::weightHoughTransform ( double r0 ) const

finaloverridevirtual

weight houghtransform, give more importance to houghtransforms close to origin

Implements MuonHoughTransformer.

Definition at line 231 of file MuonHoughTransformer_rz.cxx.

                                                                   {
    if (m_add_weight_radius) {
        return 1. / (std::abs(r0 / (m_weight_constant_radius + 1.)));
    } else {
        return 1;
    }  // weight function, to give more importance to patterns close to origin
}

weightHoughTransform() [2/2]

float MuonHoughTransformer_rz::weightHoughTransform	(	double	r0,
		double	angle ) const

Definition at line 239 of file MuonHoughTransformer_rz.cxx.

{
    if (!m_add_weight_angle) {
        return weightHoughTransform(r0);
    } else {
        if (m_add_weight_radius) {
            double theta_rad = m_muonhoughmathutils.angleFromGradToRadial(theta);
 
            float r_theta_weight = std::abs(std::sin(theta_rad)) / (1. + std::abs((r0 / 6000.)));
 
            return r_theta_weight;
        }
 
        else {
            return 1;
        }  // weight function, to give more importance to patterns close to origin
    }
}

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_add_weight_angle

bool MuonHoughTransformer::m_add_weight_angle

protectedinherited

use weight of patterns in angle coordinate

Definition at line 90 of file MuonHoughTransformer.h.

m_add_weight_radius

bool MuonHoughTransformer::m_add_weight_radius

protectedinherited

use weight of patterns in radius coordinate

Definition at line 94 of file MuonHoughTransformer.h.

m_binwidthx

double MuonHoughTransformer::m_binwidthx

protectedinherited

x-binwidth of histogram

Definition at line 115 of file MuonHoughTransformer.h.

m_binwidthy

double MuonHoughTransformer::m_binwidthy

protectedinherited

y-binwidth of histogram

Definition at line 117 of file MuonHoughTransformer.h.

m_detectorsize

const double MuonHoughTransformer::m_detectorsize

protectedinherited

range of radius coordinate

Definition at line 111 of file MuonHoughTransformer.h.

m_detectorsize_angle

const double MuonHoughTransformer::m_detectorsize_angle

protectedinherited

range of angle coordinate

Definition at line 113 of file MuonHoughTransformer.h.

m_eventsize

unsigned int MuonHoughTransformer::m_eventsize

protectedinherited

size of event to be filled (can be used for weighting)

Definition at line 85 of file MuonHoughTransformer.h.

m_eventsize_weightfactor

double MuonHoughTransformer::m_eventsize_weightfactor

protectedinherited

weightfactor based on eventsize (used in curved hough transform)

Definition at line 87 of file MuonHoughTransformer.h.

m_histos

MuonHoughHisto2DContainer MuonHoughTransformer::m_histos

protectedinherited

histogram container

Definition at line 79 of file MuonHoughTransformer.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_ip_setting

bool MuonHoughTransformer::m_ip_setting

protectedinherited

use settings for patterns originating from origin

Definition at line 125 of file MuonHoughTransformer.h.

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

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_muonhoughmathutils

MuonHoughMathUtils MuonHoughTransformer::m_muonhoughmathutils

protectedinherited

object for use of mathematical formulas for trackmodels

Definition at line 102 of file MuonHoughTransformer.h.

m_nbins

const int MuonHoughTransformer::m_nbins

protectedinherited

number of bins in histograms in radius coordinate

Definition at line 105 of file MuonHoughTransformer.h.

m_nbins_angle

const int MuonHoughTransformer::m_nbins_angle

protectedinherited

number of bins in histograms in angle coordinate

Definition at line 109 of file MuonHoughTransformer.h.

m_nbins_plus3

const int MuonHoughTransformer::m_nbins_plus3

protectedinherited

number of bins in histograms in radius coordinate

Definition at line 107 of file MuonHoughTransformer.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_number_of_sectors

const int MuonHoughTransformer::m_number_of_sectors

protectedinherited

number of histograms (1 for cosmics 16 for rz)

Definition at line 128 of file MuonHoughTransformer.h.

m_stepsize

double MuonHoughTransformer::m_stepsize

protectedinherited

stepsize of transform for radius coordinate

Definition at line 120 of file MuonHoughTransformer.h.

m_stepsize_per_angle

double MuonHoughTransformer::m_stepsize_per_angle

protectedinherited

stepsize of transform for angle coordinate

Definition at line 122 of file MuonHoughTransformer.h.

m_threshold_histo

double MuonHoughTransformer::m_threshold_histo

protectedinherited

threshold of histograms

Definition at line 82 of file MuonHoughTransformer.h.

m_use_negative_weights

bool MuonHoughTransformer::m_use_negative_weights

protectedinherited

use of negative weights

Definition at line 99 of file MuonHoughTransformer.h.

m_use_residu_grad

const bool MuonHoughTransformer_rz::m_use_residu_grad

protected

Definition at line 30 of file MuonHoughTransformer_rz.h.

m_weight_constant_angle

double MuonHoughTransformer::m_weight_constant_angle

protectedinherited

weight constant of patterns in angle coordinate

Definition at line 92 of file MuonHoughTransformer.h.

m_weight_constant_radius

double MuonHoughTransformer::m_weight_constant_radius

protectedinherited

weight constant of patterns in radius coordinate

Definition at line 96 of file MuonHoughTransformer.h.

---

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

• MuonHoughTransformer_rz.h
• MuonHoughTransformer_rz.cxx