MuonHoughTransformer_xyz Class Reference

abstract base class for hough transform with carthesian coordinates More...

#include <MuonHoughTransformer_xyz.h>

Inheritance diagram for MuonHoughTransformer_xyz:

Collaboration diagram for MuonHoughTransformer_xyz:

Public Member Functions
virtual	~MuonHoughTransformer_xyz ()=default
	destructor
void	fillHit (const std::shared_ptr< MuonHoughHit > &hit, double weight) override final
	fill hit in histogram
int	fillHisto (double r0, double phi, double weight, int sector) override final
	fill transformed values in histogram
int	sector (const std::shared_ptr< MuonHoughHit > &hit) const override final
	returns the rz sector
virtual std::unique_ptr< MuonHoughPattern >	initialiseHoughPattern () const =0
	build new houghpattern
float	weightHoughTransform (double r0) const override final
	put weight on houghtransform dependent on r0
virtual std::pair< double, double >	getHitPos (const MuonHoughHitContainer &event, int hitid) const =0
	returns the relevant 2d hit position
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 r0)
	calcalates the phi angle for a given hit and r0

Protected Member Functions
	MuonHoughTransformer_xyz (int nbins, int nbins_angle, double detectorsize, double detectorsize_angle, double threshold_histo, int number_of_sectors=1)
	constructor
std::unique_ptr< MuonHoughPattern >	hookAssociateHitsToMaximum (const MuonHoughHitContainer &event, std::pair< double, double > coordsmaximum, double residu_mm, double residu_grad, int sector) const override final
	associate hits to maximum found
std::pair< double, double >	getEndPointsFillLoop (double radius, double stepsize, int sector) const
	returns begin and end value of the filling loop

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

abstract base class for hough transform with carthesian coordinates

Definition at line 11 of file MuonHoughTransformer_xyz.h.

Constructor & Destructor Documentation

MuonHoughTransformer_xyz()

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

protected

constructor

Definition at line 8 of file MuonHoughTransformer_xyz.cxx.

                                                                                                  :
    MuonHoughTransformer("MuonHoughTransformer_xyz", nbins, nbins_angle, detectorsize, detectorsize_angle, threshold_histo, number_of_sectors) {
    m_add_weight_radius = true;
    m_weight_constant_radius = 3000;
}

~MuonHoughTransformer_xyz()

virtual MuonHoughTransformer_xyz::~MuonHoughTransformer_xyz ( )

virtualdefault

destructor

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_xyz::calculateAngle ( double hitx, double hity, double r0 )

static

calcalates the phi angle for a given hit and r0

Definition at line 103 of file MuonHoughTransformer_xyz.cxx.

                                                                                   {
    double phi = 0;
    double height_squared = hitx * hitx + hity * hity - r0 * r0;
    if (height_squared >= 0) {
        double height = std::sqrt(height_squared);
        phi = std::atan2(hity, hitx) + std::atan2(r0, height);
    }
 
    else {
        phi = std::atan2(hity, hitx);
    }
 
    if (phi < 0) { phi += MuonHough::two_Pi; }
    if (phi > MuonHough::two_Pi) { phi -= MuonHough::two_Pi; }
 
    return phi;
}

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_xyz::fillHisto ( double r0, double phi, double weight, int sector )

finaloverridevirtual

fill transformed values in histogram

Implements MuonHoughTransformer.

Definition at line 46 of file MuonHoughTransformer_xyz.cxx.

{
    MuonHoughHisto2D* histo = m_histos.getHisto(sector);
 
    const int filled_binnumber = histo->fill(r0, phi, weight);
 
    // applying a 'butterfly' weighting effect:
    bool butterfly = true;
    if (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(filled_binnumber, third_weight);
                m_histos.getHisto(sector - 1)->fill(filled_binnumber, third_weight);
            } else if (sector == 0) {
                m_histos.getHisto(sector + 1)->fill(filled_binnumber, third_weight);
            } else  // sector == m_number_of_sectors - 1
            {
                m_histos.getHisto(sector - 1)->fill(filled_binnumber, third_weight);
            }
        }
 
        double half_weight = 0.5 * weight;
 
        histo->fill(filled_binnumber - 1, half_weight);
        histo->fill(filled_binnumber + 1, half_weight);
 
        const int upperright = filled_binnumber + m_nbins_plus3;
        const int lowerleft = filled_binnumber - m_nbins_plus3;
 
        if (phi - m_binwidthy < 0) {
            histo->fill(r0 - m_binwidthx, phi - m_binwidthy + m_detectorsize_angle, half_weight);  // should calculate binnumber..
            histo->fill(upperright, half_weight);
            if (m_use_negative_weights) {
                histo->fill(r0 + m_binwidthx, phi - m_binwidthy + m_detectorsize_angle, -half_weight);
                histo->fill(upperright - 2, -half_weight);
            }
        } else if (phi + m_binwidthy > m_detectorsize_angle) {
            histo->fill(lowerleft, half_weight);
            histo->fill(r0 + m_binwidthx, phi + m_binwidthy - m_detectorsize_angle, half_weight);
            if (m_use_negative_weights) {
                histo->fill(lowerleft + 2, -half_weight);
                histo->fill(r0 - m_binwidthx, phi + m_binwidthy - m_detectorsize_angle, -half_weight);
            }
        } else {
            histo->fill(lowerleft, half_weight);
            histo->fill(upperright, half_weight);
            if (m_use_negative_weights) {
                histo->fill(lowerleft + 2, -half_weight);
                histo->fill(upperright - 2, -half_weight);
            }
        }
    }
    return filled_binnumber;
}

fillHit()

void MuonHoughTransformer_xyz::fillHit ( const std::shared_ptr< MuonHoughHit > & hit, double weight )

finaloverridevirtual

fill hit in histogram

Implements MuonHoughTransformer.

Definition at line 15 of file MuonHoughTransformer_xyz.cxx.

                                                                                            {
    double radius = hit->getRadius();
    double hitx = hit->getHitx();
    double hity = hit->getHity();
    int sectorhit = sector(hit);
    double dotprod{0.};
 
    if (m_ip_setting) {
        std::pair<double, double> endpoints = getEndPointsFillLoop(radius, m_stepsize, sectorhit);
        for (double r0 = endpoints.first; r0 < endpoints.second; r0 += m_stepsize) {
            double phi = calculateAngle(hitx, hity, r0);
            CxxUtils::sincos scphi(phi);
            dotprod = scphi.apply(hity, hitx);  // hity * sincosphi[0] + hitx * sincosphi[1];
            if (dotprod >= 0) {
                double phi_in_grad = phi * MuonHough::rad_degree_conversion_factor;
                fillHisto(r0, phi_in_grad, weight, sectorhit);
            }
        }
    }  // m_ip_setting
 
    else  // m_ip_setting == false
    {
        for (double phi = m_stepsize_per_angle / 2.; phi < m_detectorsize_angle; phi += m_stepsize_per_angle) {
            double phi_in_rad = MuonHough::degree_rad_conversion_factor * phi;
            CxxUtils::sincos scphi(phi_in_rad);
            double r0 = scphi.apply(hitx, -hity);
            fillHisto(r0, phi, weight, sectorhit);
        }
    }
}

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

getHitPos()

virtual std::pair< double, double > MuonHoughTransformer_xyz::getHitPos ( const MuonHoughHitContainer & event, int hitid ) const

pure virtual

returns the relevant 2d hit position

Implemented in MuonHoughTransformer_xy, and MuonHoughTransformer_yz.

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_xyz::hookAssociateHitsToMaximum ( const MuonHoughHitContainer & event, std::pair< double, double > coordsmaximum, double residu_mm, double residu_grad, int sector ) const

finaloverrideprotectedvirtual

associate hits to maximum found

Implements MuonHoughTransformer.

Definition at line 121 of file MuonHoughTransformer_xyz.cxx.

                                                                                                       {
    std::unique_ptr<MuonHoughPattern> houghpattern{initialiseHoughPattern()};
    ATH_MSG_DEBUG("MuonHoughTransformer_xyz::hookAssociateHitsToMaximum  (start)");
    
 
    double ephi{0.}, eradius{0.}, sin_phi{0.}, cos_phi{0.};
    double dotprod{0.}, etheta{0.}, residu_distance{0.};
 
    ATH_MSG_DEBUG("MuonHoughTransformer_xyz::size_event: " << event.size() );
    ATH_MSG_DEBUG("MuonHoughTransformer_xyz::found_maximum: r: " << coordsmaximum.first << " phi: " << coordsmaximum.second
                                                                 << " sector: " << max_sector);
           
    
 
    double phimax = m_muonhoughmathutils.angleFromGradToRadial(coordsmaximum.second);
    CxxUtils::sincos scphimax(phimax);
 
    int max_secmax = max_sector + 1;
    int max_secmin = max_sector - 1;
    if (max_secmin < 0) max_secmin = max_sector;
    if (max_secmax > m_number_of_sectors - 1) max_secmax = max_sector;
 
    for (unsigned int i = 0; i < event.size(); i++) {
        double hitx = event.getHitx(i);
        double hity = event.getHity(i);
        double hitz = event.getHitz(i);
 
        double radiushit = std::sqrt(hitx * hitx + hity * hity);
        int sectorhit = sector(event.getHit(i));
 
        if (sectorhit == max_sector || sectorhit == max_secmin || sectorhit == max_secmax) {
            if (!m_ip_setting) {
                dotprod = 1.;
            } else {
                dotprod = scphimax.apply(getHitPos(event, i).second,
                                         getHitPos(event, i).first);  
            }
            if (dotprod >= 0) {
                residu_distance = -coordsmaximum.first +
                                   scphimax.apply(getHitPos(event, i).first,
                                                  -getHitPos(event, i).second); 
                ATH_MSG_VERBOSE("MuonHoughTransformer_xyz::hitx: " << getHitPos(event, i).first
                                << " hity: " << getHitPos(event, i).second << " dotprod: " << dotprod << " sector: " 
                                << sectorhit<<",residu_distance: " << residu_distance);                
 
                if (std::abs(residu_distance) < max_residu_mm) {
                    houghpattern->addHit(event.getHit(i));
 
                    ATH_MSG_VERBOSE("MuonHoughTransformer_xyz::hit added to houghpattern!");
                    ATH_MSG_VERBOSE(" hit already earlier associated to pattern!");
 
                    event.getHit(i)->setAssociated(true);
 
                    double phi = calculateAngle(hitx, hity, coordsmaximum.first);
 
                    double thetah = std::atan2(radiushit, hitz);
                    ATH_MSG_VERBOSE(" X Y hit added to hough pattern phi hit " << std::atan2(event.getHity(i), event.getHitx(i))
                                     << " phi_calc: " << phi << " phi all " << phimax << " theta hit " << thetah );
                    
 
                    etheta += thetah;
                    CxxUtils::sincos scphi(phi);
 
                    sin_phi += scphi.sn;
                    cos_phi += scphi.cs;
 
                    double radius = MuonHoughMathUtils::signedDistanceOfLineToOrigin2D(event.getHitx(i), event.getHity(i), phimax);
                    eradius += radius;
                    ATH_MSG_VERBOSE(" calculateAngle: " << phi << " calculateradius: " << radius);                    
                }
            }  // dotprod >=0
        }      // sector requirement
    }          // size
 
    eradius = eradius / (houghpattern->size() + 0.0001);
    etheta = etheta / (houghpattern->size() + 0.0001);
    ephi = std::atan2(sin_phi, cos_phi);
 
    ATH_MSG_VERBOSE("ephi: " << ephi << " eradius: " << eradius << " etheta " << etheta);
 
    if (m_ip_setting)
        houghpattern->setEPhi(ephi);
    else {
        houghpattern->setEPhi(phimax);
    }
 
    houghpattern->setERPhi(coordsmaximum.first);
    houghpattern->setETheta(etheta);
 
    if (!houghpattern->empty() && std::abs(std::sin(houghpattern->getEPhi() - phimax)) > 0.05) {
        ATH_MSG_WARNING("MuonHoughTransformer_xyz:: Ephi calculation went wrong -- histo radius: " 
                        << coordsmaximum.first << " phi: " << phimax <<", ephi: " << ephi);
        houghpattern->setEPhi(MuonHoughMathUtils::angleFromMinusPiToPi(phimax));
        houghpattern->setERPhi(coordsmaximum.first);
    }
 
    if (!m_ip_setting) {
        houghpattern->updateParametersRPhi(true);  // switch off ip constraint! (cosmics==true), on by default (cosmics== false)
 
        ATH_MSG_VERBOSE("updateParameterstheta new phi (phi flipped Pi for cosmics): " << houghpattern->getEPhi()
                        << " old phi: " << phimax <<" new r0: " << houghpattern->getERPhi()
                        << " old r0: " << coordsmaximum.first);
    }
 
    return houghpattern;
}

initialiseHoughPattern()

virtual std::unique_ptr< MuonHoughPattern > MuonHoughTransformer_xyz::initialiseHoughPattern ( ) const

pure virtual

build new houghpattern

Implemented in MuonHoughTransformer_xy, and MuonHoughTransformer_yz.

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_xyz::sector ( const std::shared_ptr< MuonHoughHit > & hit ) const

finaloverridevirtual

returns the rz sector

Implements MuonHoughTransformer.

Definition at line 238 of file MuonHoughTransformer_xyz.cxx.

                                                                                 {
    double radius = hit->getRadius();
    double hitz = hit->getHitz();
 
    //  returns  the sector number of the hit 0..m_number_of_sectors-1
 
    // Peter Kluit correction
    double theta = std::atan2(radius, hitz);  // radius>0 : theta: [0,Pi]
 
    int sectorhit = static_cast<int>(theta * m_number_of_sectors / M_PI);
    if (sectorhit == m_number_of_sectors) sectorhit += -1;  // could happen in rare cases
    return sectorhit;                                       // only valid for xy!! yz to be done (or to be abondoned)
}

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()

float MuonHoughTransformer_xyz::weightHoughTransform ( double r0 ) const

finaloverridevirtual

put weight on houghtransform dependent on r0

Implements MuonHoughTransformer.

Definition at line 230 of file MuonHoughTransformer_xyz.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
}

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_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_xyz.h
• MuonHoughTransformer_xyz.cxx