MuonHoughTransformer_rzcosmics Class Reference

#include <MuonHoughTransformer_rzcosmics.h>

Inheritance diagram for MuonHoughTransformer_rzcosmics:

Collaboration diagram for MuonHoughTransformer_rzcosmics:

Public Member Functions
	MuonHoughTransformer_rzcosmics (int nbins, int nbins_angle, double detectorsize, double detectorsize_angle, double threshold_histo, int number_of_sectors=1)
	~MuonHoughTransformer_rzcosmics ()=default
void	fillHit (const std::shared_ptr< MuonHoughHit > &hit, double weight) override final
	fill histograms with hit
int	fillHisto (double rz0, double theta, double weight, int sector) override final
	fill histogram with certain coordinate
float	weightHoughTransform (double r0) const override final
	weight houghtransform, give more importance to houghtransforms close to origin
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.

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
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
float	weightHoughTransform (double r0, double sintheta, double sinphi, double dotprod) const
	weight in transform, dotprod is the phi angle between the normal and the phisector
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static void	updateParameters (MuonHoughPattern *)
	recalculate trackparameters of pattern

Private Attributes
std::unique_ptr< double[]>	m_phisec {}
	arrays that store values of transform
std::unique_ptr< double[]>	m_sinphisec {}
std::unique_ptr< double[]>	m_cosphisec {}
std::unique_ptr< double[]>	m_theta_in_grad {}
std::unique_ptr< double[]>	m_sintheta {}
std::unique_ptr< double[]>	m_costheta {}
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_rzcosmics.h.

Constructor & Destructor Documentation

MuonHoughTransformer_rzcosmics()

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

Definition at line 9 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                                              :
    MuonHoughTransformer("MuonHoughTransformer_rzcosmics", nbins, nbins_angle, detectorsize, detectorsize_angle, 
                         threshold_histo, number_of_sectors) {
    m_add_weight_radius = true;
    m_weight_constant_radius = 0.3;  // 1./(1 + m_weight_constant_radius*std::abs(r0)/m_detectorsize) = 1/(1+10^-5*r)
    m_add_weight_angle = true;
 
    m_phisec.reset(new double[m_number_of_sectors]);
    m_sinphisec.reset(new double[m_number_of_sectors]);
    m_cosphisec.reset(new double[m_number_of_sectors]);
 
    for (int phisector = 0; phisector < m_number_of_sectors; phisector++) {
        m_phisec[phisector] = (phisector + 0.5) * M_PI / (m_number_of_sectors + 0.) - M_PI;  // phi [-Pi,0]
        CxxUtils::sincos sc(m_phisec[phisector]);
        m_sinphisec[phisector] = sc.sn;
        m_cosphisec[phisector] = sc.cs;
    }
 
    m_theta_in_grad.reset(new double[m_nbins_angle]);
    m_sintheta.reset(new double[m_nbins_angle]);
    m_costheta.reset(new double[m_nbins_angle]);
 
    for (int i = 0; i < m_nbins_angle; i++) {
        m_theta_in_grad[i] = (i + 0.5) * m_stepsize_per_angle;
        const double theta_in_rad = MuonHough::degree_rad_conversion_factor * m_theta_in_grad[i];
        CxxUtils::sincos sc(theta_in_rad);
        m_sintheta[i] = sc.sn;
        m_costheta[i] = sc.cs;
    }
}

~MuonHoughTransformer_rzcosmics()

MuonHoughTransformer_rzcosmics::~MuonHoughTransformer_rzcosmics ( )

default

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_rzcosmics::fillHisto ( double coord1, double coord2, double weight, int sector )

finaloverridevirtual

fill histogram with certain coordinate

Implements MuonHoughTransformer.

Definition at line 61 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                                         {
    MuonHoughHisto2D* histo = m_histos.getHisto(sector);
 
    int filled_binnumber = histo->fill(rz0, theta_in_grad, weight);
 
    // this houghtransform has a full butterfly pattern:
    double half_weight = 0.5 * weight;
 
    // should be filled using filled_binnumber!
 
    if (theta_in_grad - m_binwidthy < 0) {
        histo->fill(rz0 + m_binwidthx, theta_in_grad + m_binwidthy, half_weight);
        // histo->fill(rz0-m_binwidthx,theta_in_grad-m_binwidthy + 180.,half_weight); // no cyclic angle here
        histo->fill(rz0 - m_binwidthx, theta_in_grad + m_binwidthy, half_weight);
    } else if (theta_in_grad + m_binwidthy > 180.) {
        // histo->fill(rz0+m_binwidthx,theta_in_grad+m_binwidthy - 180.,half_weight);
        histo->fill(rz0 - m_binwidthx, theta_in_grad - m_binwidthy, half_weight);
        histo->fill(rz0 + m_binwidthx, theta_in_grad - m_binwidthy, half_weight);
    } else {
        histo->fill(rz0 + m_binwidthx, theta_in_grad + m_binwidthy, half_weight);
        histo->fill(rz0 - m_binwidthx, theta_in_grad - m_binwidthy, half_weight);
        histo->fill(rz0 - m_binwidthx, theta_in_grad + m_binwidthy, half_weight);
        histo->fill(rz0 + m_binwidthx, theta_in_grad - m_binwidthy, half_weight);
    }
    return filled_binnumber;
}

fillHit()

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

finaloverridevirtual

fill histograms with hit

Implements MuonHoughTransformer.

Definition at line 41 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                                  {
    const double invradius = 1. / hit->getRadius();
    const double hitx = hit->getHitx();
    const double hity = hit->getHity();
    const double hitz = hit->getHitz();
 
    for (int phisector = 0; phisector < m_number_of_sectors; phisector++) {
        const double rphi = hitx * m_cosphisec[phisector] + hity * m_sinphisec[phisector];
        const double dotprod = rphi * invradius;
 
        //      for (double theta_in_grad=m_stepsize_per_angle/2.; theta_in_grad<m_detectorsize_angle; theta_in_grad+=m_stepsize_per_angle)
        //      {
        for (int i = 0; i < m_nbins_angle; i++) {
            const double rz0 = -m_costheta[i] * rphi + m_sintheta[i] * hitz;
            const double weighthough = weight * weightHoughTransform(rz0, m_sintheta[i], m_sinphisec[phisector], dotprod);
            fillHisto(rz0, m_theta_in_grad[i], weighthough, phisector);
        }
    }
}

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_rzcosmics::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 88 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                                  {
  
    std::unique_ptr<MuonHoughPattern> houghpattern = std::make_unique<MuonHoughPattern>(MuonHough::hough_rzcosmics);
 
    double eradius{0.}, er0{0.};
    const double theta = m_muonhoughmathutils.angleFromGradToRadial(coordsmaximum.second);
    const double rz0 = coordsmaximum.first;
 
    const double phimax = m_phisec[maxsector];
 
    ATH_MSG_VERBOSE("hookAssociateHitsToMaximum() -- sector: " << maxsector << " phimax: " << phimax 
                   << " coordsmaximumfirst: " << rz0 << " coordsmaximumsecond: " << coordsmaximum.second 
                   << " coordsmaximumsecondinrad: " << theta <<", size of event: " << event.size());
    for (unsigned int i = 0; i < event.size(); i++) {
        const double hitx = event.getHitx(i);
        const double hity = event.getHity(i);
 
        // select which hits could be in maximum:
        const double hitz = event.getHitz(i);
        const double perp = hitx * m_cosphisec[maxsector] + hity * m_sinphisec[maxsector];
 
        double residu_distance = MuonHoughMathUtils::signedDistanceToLine(hitz, perp, rz0, theta);
 
        ATH_MSG_VERBOSE("MuonHoughTransformer_rzcosmics() -- hitx: " << hitx << " hity: " << hity << " hitz: " << hitz
                        << " perp: " << perp <<", residu_distance: " << residu_distance );
 
        if (std::abs(residu_distance) < maximum_residu_mm)  // here no circular effect
        {
            ATH_MSG_VERBOSE("hit added to houghpattern! detector: " << event.getHit(i)->getWhichDetector()
                            <<" already associated "<< event.getHit(i)->getAssociated());
            houghpattern->addHit(event.getHit(i));
            event.getHit(i)->setAssociated(true);
 
            double rz0hit = residu_distance + rz0;
            eradius += rz0hit;
 
            double r0hit = hitx * m_sinphisec[maxsector] - hity * m_cosphisec[maxsector];
            er0 += r0hit;
 
        }  // hit in distance
    }      // hitno
 
    eradius = eradius / (houghpattern->size() + 1e-7);
    er0 = er0 / (houghpattern->size() + 1e-7);
 
    houghpattern->setEPhi(phimax);
    houghpattern->setERPhi(er0);
    houghpattern->setETheta(theta);
    houghpattern->setERTheta(eradius);
    houghpattern->setECurvature(1.);
 
    if (houghpattern->empty()) {
        ATH_MSG_VERBOSE("no hits found on pattern");
    }
 
    else if (std::abs(eradius - rz0) > 500.) {
        ATH_MSG_VERBOSE("Eradius or Etheta calc. WRONG --  rz0: " << rz0 << " theta: " 
                        << theta<< ", eradius: " << eradius);
        
        houghpattern->setERTheta(rz0);
    }
 
    updateParameters(houghpattern.get());  // not possible when phi direction not known!
 
    ATH_MSG_VERBOSE("updateParameterstheta new phi: " << houghpattern->getEPhi()
                    << " old phi: " << phimax <<", new r0: " << houghpattern->getERPhi()
                    << " old r0: " << er0 <<" new theta: " << houghpattern->getETheta()
                    << " old theta: " << theta << " new z0: " << houghpattern->getERTheta()
                    << " old z0: " << eradius );
    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_rzcosmics::sector ( const std::shared_ptr< MuonHoughHit > & hit ) const

finaloverridevirtual

returns sector for coords

Implements MuonHoughTransformer.

Definition at line 186 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                      {
    // function not implemented for this transform
    return 0;
}

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

updateParameters()

void MuonHoughTransformer_rzcosmics::updateParameters ( MuonHoughPattern * houghpattern )

staticprivate

recalculate trackparameters of pattern

Definition at line 191 of file MuonHoughTransformer_rzcosmics.cxx.

                                                                                    {
    const unsigned int size = houghpattern->size();
 
    if (size <= 1) return;
 
    const double phi = houghpattern->getEPhi();
    const double cosphi = std::cos(phi);
    const double sinphi = std::sin(phi);
 
    double sum_radii = 0.;
    double sum_z = 0.;
 
    for (unsigned int i = 0; i < size; i++) {
        sum_radii += houghpattern->getHitx(i) * cosphi + houghpattern->getHity(i) * sinphi;
        sum_z += houghpattern->getHitz(i);
    }
 
    const double av_radii = sum_radii / (size + 0.);
    const double av_z = sum_z / (size + 0.);
 
    double sumr = 0.;
    double sumz = 0.;
    for (unsigned int i = 0; i < size; i++) {
        double radius = houghpattern->getHitx(i) * cosphi + houghpattern->getHity(i) * sinphi;
        double hitz = houghpattern->getHitz(i);
        double r_offset = radius - av_radii;
        double z_offset = hitz - av_z;
        double weight = r_offset * r_offset + z_offset * z_offset;
        int sign = 1;
        if (r_offset * radius + z_offset * hitz < 0) { sign = -1; }
        sumr += weight * sign * r_offset;
        sumz += weight * sign * z_offset;
    }
 
    if (std::abs(sumr) < 0.000001 || std::abs(sumz) < 0.000001) { return; }
 
    double theta = std::atan2(sumr, sumz);
 
    if (theta < 0) theta += M_PI;
 
    // if theta almost straight rely on hit for prediction (transform has difficulties prediction direction in this case):
    double offset = 0.02;
    if (theta < offset) {
        if (houghpattern->getHitz(0) < 0) { theta = M_PI - theta; }
    }
 
    else if (theta > M_PI - offset) {
        if (houghpattern->getHitz(0) > 0) { theta = M_PI - theta; }
    }
 
    const double rz0 = av_z * std::sin(theta) - av_radii * std::cos(theta);
 
    houghpattern->setETheta(theta);
    houghpattern->setERTheta(rz0);
}

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_rzcosmics::weightHoughTransform ( double r0 ) const

finaloverridevirtual

weight houghtransform, give more importance to houghtransforms close to origin

Implements MuonHoughTransformer.

Definition at line 163 of file MuonHoughTransformer_rzcosmics.cxx.

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

weightHoughTransform() [2/2]

float MuonHoughTransformer_rzcosmics::weightHoughTransform ( double r0, double sintheta, double sinphi, double dotprod ) const

private

weight in transform, dotprod is the phi angle between the normal and the phisector

Definition at line 171 of file MuonHoughTransformer_rzcosmics.cxx.

{
    if (!m_add_weight_angle) {
        return weightHoughTransform(r0);
    } else {
        double dotprod_part = 0.5 + 0.5 * dotprod * dotprod;     // preference for angles that are normal to the chamber
        double sintheta_part = 0.9 + 0.1 * sintheta * sintheta;  // preference for patterns from above
        double sinphi_part = 0.75 + 0.25 * sinphi * sinphi;      // preference for patterns from above
        float r_theta_weight = dotprod_part * sintheta_part * sinphi_part;
 
        return r_theta_weight * weightHoughTransform(r0);  // preference for patterns with low impact parameter
    }
}

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_cosphisec

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_cosphisec {}

private

Definition at line 36 of file MuonHoughTransformer_rzcosmics.h.

{};

m_costheta

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_costheta {}

private

Definition at line 39 of file MuonHoughTransformer_rzcosmics.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_phisec

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_phisec {}

private

arrays that store values of transform

Definition at line 34 of file MuonHoughTransformer_rzcosmics.h.

{};

m_sinphisec

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_sinphisec {}

private

Definition at line 35 of file MuonHoughTransformer_rzcosmics.h.

{};

m_sintheta

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_sintheta {}

private

Definition at line 38 of file MuonHoughTransformer_rzcosmics.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_theta_in_grad

std::unique_ptr<double[]> MuonHoughTransformer_rzcosmics::m_theta_in_grad {}

private

Definition at line 37 of file MuonHoughTransformer_rzcosmics.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_rzcosmics.h
• MuonHoughTransformer_rzcosmics.cxx