MuonHoughTransformer_CurvedAtACylinder Class Reference

#include <MuonHoughTransformer_CurvedAtACylinder.h>

Inheritance diagram for MuonHoughTransformer_CurvedAtACylinder:

Collaboration diagram for MuonHoughTransformer_CurvedAtACylinder:

Public Member Functions
	MuonHoughTransformer_CurvedAtACylinder (int nbins, int nbins_angle, double detectorsize, double detectorsize_angle, double threshold_histo, int number_of_sectors=1)
	constructor
	~MuonHoughTransformer_CurvedAtACylinder ()=default
	destructor
void	fillHit (const std::shared_ptr< MuonHoughHit > &hit, double weight) override final
	fill hit in histogram
int	fillHisto (double xbin, double theta, double weight, int sector) override final
	fill transformed values in histogram
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
int	sector (const std::shared_ptr< MuonHoughHit > &hit) const override final
	returns the phi sector
float	weightHoughTransform (double r0) const override final
	not implemented for this transform
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.

Protected Member Functions
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::unique_ptr< double[]>	m_invcurvature
	array that stores the inverse curvatures that are scanned
std::unique_ptr< double[]>	m_weightcurvature
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_CurvedAtACylinder.h.

Constructor & Destructor Documentation

MuonHoughTransformer_CurvedAtACylinder()

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

constructor

Definition at line 11 of file MuonHoughTransformer_CurvedAtACylinder.cxx.

                                                                                                      :
    MuonHoughTransformer("MuonHoughTransformer_CurvedAtACylinder", nbins, nbins_angle, detectorsize, detectorsize_angle, threshold_histo, number_of_sectors) {
    m_add_weight_radius = false;
    m_weight_constant_radius = 0.;
    m_add_weight_angle = false;
 
    // fill array with scanned curvatures
 
    m_invcurvature.reset(new double[m_nbins / 2]);
    m_weightcurvature.reset(new double[m_nbins / 2]);
 
    for (int i = 0; i < m_nbins / 2; i++) {
        double x0 = -i + 24;                      // 24 ... -55
        if (x0 > 15.) x0 = 15 + (x0 - 15) * 0.5;  // 19.5,19,18.5, .., 15.5,15,14,13,.. 2,1,0,-1...-55  // 80 bins
 
        double curvature = -3. * 3500. * 20.25 / (x0 - 19.75);  // >0
        m_invcurvature[i] = 1. / curvature;
        if (i <= 10) {
            m_weightcurvature[i] = 1.;
        } else if (i <= 20) {
            m_weightcurvature[i] = 1 - 0.05 * (i - 10);
        } else {
            m_weightcurvature[i] = 0.5;
        }
    }
}

~MuonHoughTransformer_CurvedAtACylinder()

MuonHoughTransformer_CurvedAtACylinder::~MuonHoughTransformer_CurvedAtACylinder ( )

default

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

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_CurvedAtACylinder::fillHisto ( double xbin, double theta, double weight, int sector )

finaloverridevirtual

fill transformed values in histogram

Implements MuonHoughTransformer.

Definition at line 87 of file MuonHoughTransformer_CurvedAtACylinder.cxx.

                                                                                                                  {
    MuonHoughHisto2D* histo = m_histos.getHisto(sector);
 
    const int filled_binnumber = histo->fill(xbin, theta_in_grad, weight);
 
    // overlap filling:
    // overlap and single sector filling:
    // nearby sectors:
    if (m_number_of_sectors >= 3) {
        const double reduced_weight = 0.8 * weight;  // arbitrary should be between 0.5 and 1
        if (sector != 0 && sector != m_number_of_sectors - 1) {
            m_histos.getHisto(sector + 1)->fill(filled_binnumber, reduced_weight);
            m_histos.getHisto(sector - 1)->fill(filled_binnumber, reduced_weight);
        } else if (sector == 0) {
            m_histos.getHisto(sector + 1)->fill(filled_binnumber, reduced_weight);
            m_histos.getHisto(m_number_of_sectors - 1)->fill(filled_binnumber, reduced_weight);
        } else {
            m_histos.getHisto(sector - 1)->fill(filled_binnumber, reduced_weight);
            m_histos.getHisto(0)->fill(filled_binnumber, reduced_weight);
        }
    }
 
    // smearing effect:
 
    const double fifth_weight = 0.2 * weight;
    const int upperright = filled_binnumber + m_nbins_plus3;
    const int lowerleft = filled_binnumber - m_nbins_plus3;
 
    if (theta_in_grad - m_binwidthy < 0) {
        histo->fill(upperright, fifth_weight);
 
        if (m_use_negative_weights) { histo->fill(upperright - 2, -fifth_weight); }
    } else if (theta_in_grad + m_binwidthy > 180.) {
        histo->fill(lowerleft, fifth_weight);
        if (m_use_negative_weights) { histo->fill(xbin + m_binwidthx, theta_in_grad - m_binwidthy, -fifth_weight); }
    } else {
        histo->fill(upperright, fifth_weight);
        histo->fill(lowerleft, fifth_weight);
        if (m_use_negative_weights) {
            histo->fill(upperright - 2, -fifth_weight);
            histo->fill(lowerleft + 2, -fifth_weight);
        }
    }
    return filled_binnumber;
}

fillHit()

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

finaloverridevirtual

fill hit in histogram

Implements MuonHoughTransformer.

Definition at line 41 of file MuonHoughTransformer_CurvedAtACylinder.cxx.

                                                                                                          {
    // MuonHough transform studies
 
    // cylinder for extrapolation planes in muon system endcap/barrel transition
 
    int sectorhit = sector(hit);
 
    bool isbarrel = hit->isBarrel();
 
    for (int i = 0; i < m_nbins / 2; i++) {
        // not a too large curve for endcap hits (generates peaks in houghtransform)
        const double ratio = hit->getMagneticTrackRatio() * m_invcurvature[i];
        if (!isbarrel && std::abs(ratio) > 0.5) break;
 
        // positive curvature (for positive i):
        double thetas[2];
        MuonHoughMathUtils::thetasForCurvedHit(ratio, hit.get(), thetas[0], thetas[1]);
 
        const double weight_curvature =
            weight * 1. /
            (1. +
             m_eventsize_weightfactor *
                 (thetas[0] -
                  hit->getTheta()));  //* m_weightcurvature[i]; // m_eventsize_weightfactor is defined in MuonHoughTransformer::fill(event)
 
        // Remove theta solutions outside 0 - 180 degree range
        if (thetas[0] > 0. && thetas[0] < M_PI) {
            double theta_in_grad = thetas[0] * MuonHough::rad_degree_conversion_factor;
 
            const double weight_curvature_theta = weight_curvature * (0.5 + 0.5 * std::sin(thetas[0]));
 
            fillHisto(i + 0.5, theta_in_grad, weight_curvature_theta, 2 * sectorhit);  // overlap and single sector filling
        }
 
        // negative curvature (for negative i)
 
        // Remove theta solutions outside 0 - 180 degree range
        if (thetas[1] > 0. && thetas[1] < M_PI) {
            double theta_in_grad = thetas[1] * MuonHough::rad_degree_conversion_factor;
 
            const double weight_curvature_theta = weight_curvature * (0.5 + 0.5 * std::sin(thetas[1]));
            fillHisto(-i - 0.5, theta_in_grad, weight_curvature_theta, 2 * sectorhit);  // overlap and single sector filling
        }
    }
}

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

finaloverridevirtual

associate hits to maximum found

Implements MuonHoughTransformer.

Definition at line 133 of file MuonHoughTransformer_CurvedAtACylinder.cxx.

                                                                                                          {
    std::unique_ptr<MuonHoughPattern> houghpattern = std::make_unique<MuonHoughPattern>(MuonHough::hough_curved_at_a_cylinder);
 
    // double ecurvature=0. // todo: recalculate estimated curvature for hits associated to maximum
    double etheta{0.}, sin_phi{0.}, cos_phi{0.}, sin_theta{0.}, cos_theta{0.}, ephi{0.};
    const double theta = m_muonhoughmathutils.angleFromGradToRadial(coordsmaximum.second);
    double invcurvature{0.}, curvature{0.};
    if (m_nbins < 40) {
        curvature = MuonHoughMathUtils::sgn(coordsmaximum.first) / (coordsmaximum.first * coordsmaximum.first);
        invcurvature = 1. / curvature;
    } else {
        // coordsmaximum.first = -80.5 .. 80.5 // 160 bins
        int index = static_cast<int>(std::floor(std::abs(coordsmaximum.first)));
        if (index >= m_nbins / 2) {
            index = m_nbins / 2 - 1;
           ATH_MSG_VERBOSE("warning overflow maximum found "<<index<<" vs. "<<m_nbins / 2 );
        }
        invcurvature = MuonHoughMathUtils::sgn(coordsmaximum.first) * m_invcurvature[index];
        curvature = 1. / invcurvature;
    }
 
    // allowed sectors:
    int sector_1 = maxsector / 2;  // primary sector
    int sector_2 = sector_1 + 1;
    int sector_3 = sector_1 - 1;
    if (sector_2 > m_number_of_sectors / 2 - 1) { sector_2 = 0; }  // if sector_2 larger than 15 -> 0
    if (maxsector % 2 == 1) {                                      // if overlap maximum then only association to 2 sectors
        sector_3 = sector_1;
    } else if (sector_3 < 0) {
        sector_3 = m_number_of_sectors / 2 - 1;
    }  // if sector_3 smaller than 0 -> 15
 
    ATH_MSG_VERBOSE("sector: " << maxsector
         << " coordsmaximumfirst: " << coordsmaximum.first << " curvature: " << curvature 
         << " coordsmaximumsecond: " << coordsmaximum.second << " coordsmaximumsecondinrad: " << theta 
         << " MuonHoughTransformer_CurvedAtACylinder::size of event: " << event.size() 
         << " allowed sectors: " << sector_1 << " , " << sector_2 << " & " << sector_3 );
 
    for (unsigned int i = 0; i < event.size(); i++) {
        std::shared_ptr<MuonHoughHit> hit = event.getHit(i);
        int sectorhit = sector(hit);
        if (sectorhit == sector_1 || sectorhit == sector_2 || sectorhit == sector_3) {
            double z0{0.};  // offset from IP on z-axis
            const double sdis = MuonHoughMathUtils::signedDistanceCurvedToHit(z0, theta, invcurvature, hit->getPosition());
 
            double radius3d = std::min(15000.,std::max(5000.,hit->getAbs()));
            double scale = radius3d / 5000.;
 
            double residu_distance_mm = std::abs(sdis);
 
           
            ATH_MSG_VERBOSE(" hit position " << hit->getPosition() <<" residu_distance: " << sdis
                                << " max_residu_mm*scale: " << max_residu_mm * scale);
 
            if (std::abs(residu_distance_mm) < max_residu_mm * scale)  // here no circular effect
            {
                double phi = hit->getPhi();
                CxxUtils::sincos scphi(phi);
                sin_phi += scphi.sn;
                cos_phi += scphi.cs;
 
                const double theta = MuonHoughMathUtils::thetaForCurvedHit(invcurvature, event.getHit(i).get());
                if (theta > 0 && theta < M_PI) {
                    ATH_MSG_VERBOSE("hit added to houghpattern! Sector number: " << sectorhit 
                                    <<" associated earlier "<<event.getHit(i)->getAssociated());
                    houghpattern->addHit(event.getHit(i));
                    event.getHit(i)->setAssociated(true);
                    CxxUtils::sincos sctheta(theta);
                    sin_theta += sctheta.sn;
                    cos_theta += sctheta.cs;
                }
            }  // residu
        }      // sector constraint
    }          // hitno
 
    etheta = std::atan2(sin_theta, cos_theta);
    //  etheta = theta;
    ephi = std::atan2(sin_phi, cos_phi);
    houghpattern->setETheta(etheta);
    houghpattern->setERTheta(0.);
    houghpattern->setEPhi(ephi);
    houghpattern->setECurvature(curvature);
 
    ATH_MSG_VERBOSE(" number of hits added to pattern: " << houghpattern->size());
    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_CurvedAtACylinder::sector ( const std::shared_ptr< MuonHoughHit > & hit ) const

inlinefinaloverridevirtual

returns the phi sector

Implements MuonHoughTransformer.

Definition at line 39 of file MuonHoughTransformer_CurvedAtACylinder.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()

float MuonHoughTransformer_CurvedAtACylinder::weightHoughTransform ( double r0 ) const

finaloverridevirtual

not implemented for this transform

Implements MuonHoughTransformer.

Definition at line 223 of file MuonHoughTransformer_CurvedAtACylinder.cxx.

                                                                                 {
    // not in use for this transform
    return 1.;
}

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_invcurvature

std::unique_ptr<double[]> MuonHoughTransformer_CurvedAtACylinder::m_invcurvature

private

array that stores the inverse curvatures that are scanned

Definition at line 34 of file MuonHoughTransformer_CurvedAtACylinder.h.

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.

m_weightcurvature

std::unique_ptr<double[]> MuonHoughTransformer_CurvedAtACylinder::m_weightcurvature

private

Definition at line 35 of file MuonHoughTransformer_CurvedAtACylinder.h.

---

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

• MuonHoughTransformer_CurvedAtACylinder.h
• MuonHoughTransformer_CurvedAtACylinder.cxx