MuonHough::MuonLayerHough Struct Reference

#include <MuonLayerHough.h>

Collaboration diagram for MuonHough::MuonLayerHough:

Classes
struct	Maximum
	struct representing the maximum in the hough space More...

Public Types
using	DetRegIdx = Muon::MuonStationIndex::DetectorRegionIndex
using	ChIdx = Muon::MuonStationIndex::ChIndex

Public Member Functions
	MuonLayerHough (const RegionDescriptor &descriptor)
	constructor More...
	~MuonLayerHough ()=default
	destructor More...
void	reset ()
	reset the transform More...
void	setDebug (bool d)
	enable debug output More...
int	bin (const Hit &hit) const
	calculate the position bin the hit will endup in More...
int	bin (float x, float y) const
	calculate the bin corresponing to the given x,y position More...
float	yval (int posBin) const
	access to y coordinate of a given bin More...
void	pars (int posBin, int, float &x, float &y) const
	calculate x,y for the given position bin More...
float	layerConfirmation (const Hit &hit, float range=1000.) const
	calculate the highest value of the hough transform within the specified range for the given hit More...
float	layerConfirmation (float x, float y, float range=1000.) const
	calculate the highest value of the hough transform within the specified range for the given hit position More...
std::pair< float, float >	layerConfirmation (unsigned int thetaBin, float x, float y, float range=1000.) const
	calculate the highest value of the hough transform within the specified range for the given hit position More...
bool	findMaximum (Maximum &maximum, const MuonLayerHoughSelector &selector) const
	find the highest maximum that is above maxval More...
void	associateHitsToMaximum (Maximum &maximum, const HitVec &hits) const
	associates the list of input hits to the provided maximum More...
std::pair< int, int >	range (const float x, const float y1, const float y2, const int bintheta) const
	calculates the first and last bin the hit should be filled in for a given theta bin More...
std::pair< float, float >	maximum (float x, float y, int &posbin, int &thetabin) const
	returns a pair with the position and angle corresponing to the input x,y values More...
void	fill (const Hit &hit)
	fill the hough space with a single position More...
void	fill (float x, float y, float weight)
	fill the hough space with a single position More...
void	fillLayer (const HitVec &hits, bool substract=false)
	fill the hough space with a vector of hits using the layer mode More...
void	fillLayer2 (const HitVec &hits, bool subtract=false)
std::vector< TH1 * >	rootHistos (const std::string &prefix, const float *rmin=0, const float *rmax=0) const
	returns a vector with all the histograms of the hough as TH1* More...

Public Attributes
float	m_binsize {0}
float	m_invbinsize {0}
	binsize More...
int	m_nbins {-1}
	inverse binsize More...
unsigned int	max {0}
int	maxhist {-1}
int	maxbin {-1}
bool	m_debug {false}
std::vector< std::unique_ptr< unsigned int[]> >	m_histos
RegionDescriptor	m_descriptor

Detailed Description

Definition at line 59 of file MuonLayerHough.h.

Member Typedef Documentation

ChIdx

using MuonHough::MuonLayerHough::ChIdx = Muon::MuonStationIndex::ChIndex

Definition at line 62 of file MuonLayerHough.h.

DetRegIdx

using MuonHough::MuonLayerHough::DetRegIdx = Muon::MuonStationIndex::DetectorRegionIndex

Definition at line 61 of file MuonLayerHough.h.

Constructor & Destructor Documentation

MuonLayerHough()

MuonHough::MuonLayerHough::MuonLayerHough

(

const RegionDescriptor &

descriptor

)

constructor

Definition at line 35 of file MuonLayerHough.cxx.

                                                                     :
         m_descriptor(descriptor) {
        // calculate the number of bins
        m_nbins = (m_descriptor.yMaxRange - m_descriptor.yMinRange) / m_descriptor.yBinSize;  // the same for all the cycles
        m_binsize = (m_descriptor.yMaxRange - m_descriptor.yMinRange) / m_nbins;
        m_invbinsize = 1. / m_binsize;  // binsize in the floating plane
 
        // setup the histograms; determines the number of theta slices
        m_histos.reserve(m_descriptor.nthetaSamples);  // it contains all the theta layers
        for (unsigned int i = 0; i < m_descriptor.nthetaSamples; ++i) m_histos.emplace_back(new unsigned int[m_nbins]);
        reset();
    }

~MuonLayerHough()

MuonHough::MuonLayerHough::~MuonLayerHough ( )

default

destructor

Member Function Documentation

associateHitsToMaximum()

void MuonHough::MuonLayerHough::associateHitsToMaximum	(	MuonLayerHough::Maximum &	maximum,
		const HitVec &	hits
	)		const

associates the list of input hits to the provided maximum

Definition at line 368 of file MuonLayerHough.cxx.

                                                                                                        {
        if (maximum.bintheta == -1 || maximum.binposmax == -1 || maximum.binposmin == -1) return;
        // loop over hits and find those that are compatible with the maximum
        HitVec::const_iterator it = hits.begin();
        HitVec::const_iterator it_end = hits.end();
        for (; it != it_end; ++it) {
            // calculate the bins associated with the hit and check whether any of they are part of the maximum
            std::pair<int, int> minMax = range((*it)->x, (*it)->ymin, (*it)->ymax, maximum.bintheta);
            if (m_debug) {
                std::cout << " associating hit: x " << (*it)->x << " ymin " << (*it)->ymin << " ymax " << (*it)->ymax << " layer "
                          << (*it)->layer << " range " << minMax.first << "  " << minMax.second << "  max range " << maximum.binposmin
                          << "  " << maximum.binposmax << " prd " << (*it)->prd << " tgc " << (*it)->tgc;
                if ((*it)->debugInfo()) std::cout << " trigC " << (*it)->debugInfo()->trigConfirm;
                std::cout << std::endl;
            }
            if (minMax.first > maximum.binposmax) continue;   // minimum bin large than the maximum, drop
            if (minMax.second < maximum.binposmin) continue;  // maximum bin smaller than the minimum, drop
            // keep everything else
            maximum.hits.push_back(*it);
            if ((*it)->debugInfo() && (*it)->debugInfo()->trigConfirm > 0) ++maximum.triggerConfirmed;
        }
    }

bin() [1/2]

int MuonHough::MuonLayerHough::bin ( const Hit &  hit ) const

inline

calculate the position bin the hit will endup in

Definition at line 190 of file MuonLayerHough.h.

{ return bin(hit.x, hit.ymin); }

bin() [2/2]

int MuonHough::MuonLayerHough::bin ( float  x, float  y  ) const

inline

calculate the bin corresponing to the given x,y position

Definition at line 192 of file MuonLayerHough.h.

                                                         {
        float yref = y * (m_descriptor.referencePosition - x) / x + y;
        int in = (yref - m_descriptor.yMinRange) / m_binsize;
        if (in < 0 || in >= m_nbins) in = -1;
        return in;
    }

fill() [1/2]

void MuonHough::MuonLayerHough::fill ( const Hit &  hit )

inline

fill the hough space with a single position

Definition at line 208 of file MuonLayerHough.h.

{ fill(hit.x, hit.ymin, hit.w); }

fill() [2/2]

void MuonHough::MuonLayerHough::fill	(	float	x,
		float	y,
		float	weight
	)

fill the hough space with a single position

Definition at line 55 of file MuonLayerHough.cxx.

                                                            {
        int cycles = m_histos.size();
        for (int ci = 0; ci < cycles; ++ci) {
            float dtheta = m_descriptor.thetaStep;
            float dthetaOffset = 2 * m_descriptor.thetaStep * (ci - (cycles - 1) / 2.);
            float theta = std::atan2(x, y);
            float zref = (m_descriptor.referencePosition - x) * cot(theta - dthetaOffset) + y;
            float z0 = (m_descriptor.referencePosition - x) * cot(theta - dthetaOffset + dtheta) + y;
            float z1 = (m_descriptor.referencePosition - x) * cot(theta - dthetaOffset - dtheta) + y;
 
            float zmin = z0 < z1 ? z0 : z1;
            float zmax = z0 < z1 ? z1 : z0;
            int bincenter = (zref - m_descriptor.yMinRange) * m_invbinsize;
 
            int binmin = (zmin - m_descriptor.yMinRange) * m_invbinsize;
            int binmax = (zmax - m_descriptor.yMinRange) * m_invbinsize;
            if (binmin - bincenter < -3) binmin = bincenter - 3;
            if (binmin == bincenter) binmin -= 1;
            if (binmax == bincenter) binmax += 1;
            if (binmin >= m_nbins) continue;
            if (binmax - bincenter > 3) binmax = bincenter + 3;
            if (binmax < 0) continue;
 
            if (binmin < 0) binmin = 0;
            if (binmax >= m_nbins) binmax = m_nbins - 1;
            if (m_debug)
                std::cout << " filling " << x << " y " << binmin << " " << binmax << " w " << weight << " center " << bincenter << " range "
                          << (zmin - m_descriptor.yMinRange) * m_invbinsize << " " << (zmax - m_descriptor.yMinRange) * m_invbinsize
                          << std::endl;
            for (int n = binmin; n <= binmax; ++n) {
                unsigned int& val = m_histos[ci][n];
                int w = 1000 * weight;
                if (w < 0 && (int)val < -w)
                    val = 0;
                else
                    val += weight;
                if (val > max) {
                    max = val;
                    maxhist = ci;
                    maxbin = n;
                }
            }
        }
    }

fillLayer()

void MuonHough::MuonLayerHough::fillLayer	(	const HitVec &	hits,
		bool	substract = false
	)

fill the hough space with a vector of hits using the layer mode

Definition at line 100 of file MuonLayerHough.cxx.

                                                                    {
        if (hits.empty()) return;
 
        // outer loop over cycles
        int cycles = m_histos.size();
        for (int ci = 0; ci < cycles; ++ci) {
            // float dtheta = m_descriptor.thetaStep;
            // float dthetaOffset = 2*m_descriptor.thetaStep*(ci-(cycles-1)/2.);
 
            int prevlayer = -1;
            int prevbinmin = 10000;
            int prevbinmax = -1;
            // inner loop over hits
            HitVec::const_iterator it = hits.begin();
            HitVec::const_iterator it_end = hits.end();
            for (; it != it_end; ++it) {
                float x = (*it)->x;
                float y1 = (*it)->ymin;
                float y2 = (*it)->ymax;
                std::pair<int, int> minMax = range((*it)->x, (*it)->ymin, (*it)->ymax, ci);
                int binmin = std::max(minMax.first,0);
                int binmax = std::min(minMax.second, m_nbins - 1);
                if (binmin >= m_nbins || binmax < 0) continue;
                
                if (m_debug) {
                    std::cout << " filling hit " << x << " refpos " << m_descriptor.referencePosition << " ymin " << y1 << " ymax " << y2
                              << " layer " << (*it)->layer << " binmin " << binmin << " max " << binmax;
                    if ((*it)->debugInfo()) {
                        const HitDebugInfo* db1 = (*it)->debugInfo();
                        std::cout << " sec " << db1->sector << " r " <<Muon::MuonStationIndex::regionName(db1->region) << " type " 
                                  << db1->type << " lay " << Muon::MuonStationIndex::layerName(db1->layer)
                                  << " slay " << db1->sublayer << std::endl;
                    } else
                        std::cout << std::endl;
                }
                // first hit within range
                if (prevbinmax == -1) {
                    if (m_debug) std::cout << " first range " << binmin << "  " << binmax << std::endl;
                    prevbinmin = binmin;
                    prevbinmax = binmax;
                    prevlayer = (*it)->layer;
                    continue;
                }
 
                if (binmin < prevbinmin && prevlayer == (*it)->layer) {
                    std::cout << "Error hits are out of order: min " << binmin << " max " << binmax << " lay " << (*it)->layer << std::endl;
                }
                // if the max value of the previous hit is smaller than the current minvalue fill the histogram of the previous hit
                // do the same when reached last hit
                if (prevbinmax < binmin || prevlayer != (*it)->layer) {
                    if (m_debug)
                        std::cout << " filling range " << prevbinmin << " " << prevbinmax << " new min " << binmin << "  " << binmax
                                  << " weight " << (*it)->w << std::endl;
                    for (int n = prevbinmin; n <= prevbinmax; ++n) {
                        unsigned int& val = m_histos[ci][n];
                        int w = 1000 * (*it)->w;
                        if (subtract) w *= -1;
                        if (w < 0 && (int)val < -w)
                            val = 0;
                        else
                            val += w;
                        if (val > max) {
                            max = val;
                            maxhist = ci;
                            maxbin = n;
                        }
                    }
                    prevbinmin = binmin;
                    prevbinmax = binmax;
                    prevlayer = (*it)->layer;
 
                } else {
                    // update the maximum value of the window
                    if (m_debug)
                        std::cout << " updating range " << prevbinmin << " " << prevbinmax << " hit " << binmin << "  " << binmax
                                  << "  new " << prevbinmin << " " << binmax << std::endl;
                    prevbinmax = binmax;
                }
            }
            if (prevbinmax != -1) {
                if (m_debug)
                    std::cout << " filling last range " << prevbinmin << " " << prevbinmax << " weight " << hits.back()->w << std::endl;
                for (int n = prevbinmin; n <= prevbinmax; ++n) {
                    unsigned int& val = m_histos[ci][n];
                    int w = 1000 * hits.back()->w;
                    if (subtract) w *= -1;
                    if (w < 0 && (int)val < -w)
                        val = 0;
                    else
                        val += w;
                    if (val > max) {
                        max = val;
                        maxhist = ci;
                        maxbin = n;
                    }
                }
            }
        }
    }

fillLayer2()

void MuonHough::MuonLayerHough::fillLayer2	(	const HitVec &	hits,
		bool	subtract = false
	)

Definition at line 200 of file MuonLayerHough.cxx.

                                                                     {
        if (hits.empty()) return;
 
        std::vector<int> layerCounts(m_nbins, 0);
        int sign = subtract ? -1000 : 1000;
        // outer loop over cycles
        int cycles = m_histos.size();
        for (int ci = 0; ci < cycles; ++ci) {
            // keep track of the previous layer
            int prevlayer = hits.front()->layer;
 
            // inner loop over hits
            HitVec::const_iterator it = hits.begin();
            HitVec::const_iterator it_end = hits.end();
            for (; it != it_end; ++it) {
                // if we get to the next layer process the current one and fill the Hough space
                if (prevlayer != (*it)->layer) {
                    for (int i = 0; i < m_nbins; ++i) {
                        if (subtract && -layerCounts[i] >= static_cast<int>(m_histos[ci][i]))
                            m_histos[ci][i] = 0;
                        else
                            m_histos[ci][i] += layerCounts[i];
                        layerCounts[i] = 0;  // reset bin
                    }
                    prevlayer = (*it)->layer;
                }
 
                // get bin range
                std::pair<int, int> minMax = range((*it)->x, (*it)->ymin, (*it)->ymax, ci);
                int binmin = minMax.first;
                int binmax = minMax.second;
 
                // check wether we are within the Hough space
                if (binmin >= m_nbins) continue;
                if (binmax < 0) continue;
 
                // adjust boundaries if needed
                if (binmin < 0) binmin = 0;
                if (binmax >= m_nbins) binmax = m_nbins - 1;
 
                // output hit for debug purposes
                if (m_debug) {
                    std::cout << " cycle(theta layers) " << ci << " filling hit " << (*it)->x << " refpos "
                              << m_descriptor.referencePosition << " ymin " << (*it)->ymin << " ymax " << (*it)->ymax << " layer "
                              << (*it)->layer << " weight " << (*it)->w << " binmin " << binmin << " max " << binmax;
                    std::cout << " zmin " << binmin * m_binsize + m_descriptor.yMinRange << " zmax "
                              << binmax * m_binsize + m_descriptor.yMinRange;
                    if ((*it)->debugInfo()) {
                        const HitDebugInfo* db1 = (*it)->debugInfo();
                        std::cout << " sec " << db1->sector << " r " << Muon::MuonStationIndex::regionName(db1->region)
                         << " type " << db1->type << " lay " << Muon::MuonStationIndex::layerName(db1->layer)
                         << " bc " << db1->barcode << std::endl;
                    } else
                        std::cout << std::endl;
                }
                int weight = sign * (*it)->w;  // set the hit weight
                // set bits to true
                for (; binmin <= binmax; ++binmin) layerCounts[binmin] = weight;
            }  // end of loopin gover hits
            // if the last set of hits was not filled, fill them now; just for the last layer
            for (int i = 0; i < m_nbins; ++i) {
                if (subtract && -layerCounts[i] >= static_cast<int>(m_histos[ci][i]))
                    m_histos[ci][i] = 0;
                else
                    m_histos[ci][i] += layerCounts[i];
                // if( m_debug && layerCounts[i] != 0 ) std::cout << " filling layer " << prevlayer << " bin " << i << " val " <<
                // layerCounts[i] << " tot " << m_histos[ci][i] << std::endl;
                layerCounts[i] = 0;  // reset bin
            }
        }
    }

findMaximum()

bool MuonHough::MuonLayerHough::findMaximum	(	Maximum &	maximum,
		const MuonLayerHoughSelector &	selector
	)		const

find the highest maximum that is above maxval

Definition at line 290 of file MuonLayerHough.cxx.

                                                                                                   {
        const float preMaxCut = selector.getMinCutValue();  // in this case it is likely to be 1.9
        maximum.max = 0;
        maximum.pos = 0;
        maximum.theta = 0;
        maximum.refpos = 0;
        maximum.refregion = DetRegIdx::DetectorRegionUnknown;
        maximum.refchIndex = ChIdx::ChUnknown;
        maximum.binpos = -1;
        maximum.binposmin = -1;
        maximum.binposmax = -1;
        maximum.binsize = -1;
        maximum.bintheta = -1;
        maximum.triggerConfirmed = 0;
        maximum.hits.clear();
        maximum.hough = this;
 
        if (preMaxCut < 0) return false;  // this is where there is no cut
 
        float tmax = 0;
        int posb = -1;
        int thetab = -1;
        int imaxval = preMaxCut * 1000;
        const int cycles = m_histos.size();
        // loop over histograms and find maximum
        for (int ci = 0; ci < cycles; ++ci) {
            const float scale =
                1. - 0.01 * std::abs(ci - cycles / 2.0);  // small deweighting of non pointing bins; weighting more on the central part
            for (int n = 0; n < m_nbins; ++n) {
                const int val = m_histos[ci][n];
                if (val < imaxval) continue;
 
                if (scale * val > tmax) {
                    tmax = scale * val;
                    posb = n;
                    thetab = ci;
                }
            }
        }
        if (posb == -1) return false;  // didn't find a max
 
        const float candidatePos = m_descriptor.yMinRange + m_binsize * posb;
        if (tmax < selector.getCutValue(candidatePos)) return false;
 
        maximum.max = tmax * 0.001;
        maximum.pos = candidatePos;
        maximum.theta =
            -m_descriptor.thetaStep * (thetab - (m_histos.size() - 1) * 0.5) + std::atan2(m_descriptor.referencePosition, maximum.pos);
        maximum.refpos = m_descriptor.referencePosition;
        maximum.refregion = m_descriptor.region;
        maximum.refchIndex = m_descriptor.chIndex;
        maximum.binpos = posb;
        maximum.binposmin = posb;
        maximum.binposmax = posb;
        maximum.binsize = m_binsize;
        maximum.bintheta = thetab;
 
        // determin width of maximum; now to be 70% of the original height
        unsigned int imax = m_histos[thetab][posb];
        unsigned int sidemax = 0.7 * imax;
        // loop down, catch case the maximum is in the first bin
        for (int n = posb != 0 ? posb - 1 : posb; n >= 0; --n) {
            if (m_histos[thetab][n] > sidemax) {
                maximum.binposmin = n;
            } else {
                break;
            }
        }
        for (int n = posb + 1; n < m_nbins; ++n) {
            if (m_histos[thetab][n] > sidemax) {
                maximum.binposmax = n;
            } else {
                break;
            }
        }
        return true;
    }

layerConfirmation() [1/3]

float MuonHough::MuonLayerHough::layerConfirmation ( const Hit &  hit, float  range = 1000.  ) const

inline

calculate the highest value of the hough transform within the specified range for the given hit

Definition at line 206 of file MuonLayerHough.h.

{ return layerConfirmation(hit.x, hit.ymin, range); }

layerConfirmation() [2/3]

float MuonHough::MuonLayerHough::layerConfirmation	(	float	x,
		float	y,
		float	range = 1000.
	)		const

calculate the highest value of the hough transform within the specified range for the given hit position

Definition at line 427 of file MuonLayerHough.cxx.

                                                                               {
        unsigned int max = 0;
        if (x == 0) return 0;
 
        float yloc = m_descriptor.referencePosition * y / x;
        int bincenter = (yloc - m_descriptor.yMinRange) / m_binsize;
        int scanRange = range / m_binsize;
        int binmin = bincenter - scanRange;
        int binmax = bincenter + scanRange;
        if (binmin >= m_nbins) return 0;
        if (binmax < 0) return 0;
 
        int maxbin = -1;
        if (binmin < 0) binmin = 0;
        if (binmax >= m_nbins) binmax = m_nbins - 1;
        int cyclesmin = 0;
        int cycles = m_histos.size();
        if (cycles > 3) {
            int c0 = cycles / 2;
            cyclesmin = c0 - 1;
            cycles = c0 + 1;
        }
        for (int n = binmin; n < binmax; ++n) {
            for (int ci = cyclesmin; ci < cycles; ++ci) {
                if (max < m_histos[ci][n]) {
                    max = m_histos[ci][n];
                    maxbin = n;
                }
            }
        }
        if (range == 900) std::cout << " layerConfirmation " << max << " bin " << maxbin << " entry " << bincenter << std::endl;
        return 0.001 * max;
    }

layerConfirmation() [3/3]

std::pair< float, float > MuonHough::MuonLayerHough::layerConfirmation	(	unsigned int	thetaBin,
		float	x,
		float	y,
		float	range = 1000.
	)		const

calculate the highest value of the hough transform within the specified range for the given hit position

Definition at line 461 of file MuonLayerHough.cxx.

                                                                                                                      {
        unsigned int max = 0;
        if (x == 0) return std::make_pair(0., 0.);
        if (thetaBin >= m_histos.size()) return std::make_pair(0., 0.);
        float yloc = m_descriptor.referencePosition * y / x;
        int bincenter = (yloc - m_descriptor.yMinRange) / m_binsize;
        int scanRange = range / m_binsize;
        int binmin = bincenter - scanRange;
        int binmax = bincenter + scanRange;
        if (binmin >= m_nbins) return std::make_pair(0., 0.);
        if (binmax < 0) return std::make_pair(0., 0.);
 
        int maxbin = -1;
        if (binmin < 0) binmin = 0;
        if (binmax >= m_nbins) binmax = m_nbins - 1;
        for (int n = binmin; n < binmax; ++n) {
            if (max < m_histos[thetaBin][n]) {
                max = m_histos[thetaBin][n];
                maxbin = n;
            }
        }
        std::cout << " layerConfirmation " << max << " bin " << maxbin << " entry " << bincenter << " val " << yval(max) << std::endl;
        return std::make_pair(0.001 * max, yval(maxbin));
    }

maximum()

std::pair< float, float > MuonHough::MuonLayerHough::maximum	(	float	x,
		float	y,
		int &	posbin,
		int &	thetabin
	)		const

returns a pair with the position and angle corresponing to the input x,y values

Definition at line 391 of file MuonLayerHough.cxx.

                                                                                                    {
        unsigned int max = 0;
        thetabin = -1;
        posbin = -1;
 
        int cycles = m_histos.size();
        for (int ci = 0; ci < cycles; ++ci) {
            int relbin = ci - (cycles - 1) / 2;
            float dtheta = m_descriptor.thetaStep;
            float dthetaOffset = 2 * m_descriptor.thetaStep * (relbin);  // if bintheta = cycles, this is the same as dtheta * (cycles + 1 )
            float theta = std::atan2(x, y);
            float z0 = (m_descriptor.referencePosition - x) * cot(theta - dthetaOffset + dtheta) +
                       y;  // move the angle by a step, recalculate the new y value
            float z1 = (m_descriptor.referencePosition - x) * cot(theta - dthetaOffset - dtheta) + y;
 
            float zmin = z0 < z1 ? z0 : z1;
            float zmax = z0 < z1 ? z1 : z0;
            int binmin = (zmin - m_descriptor.yMinRange) / m_binsize - 1;
            int binmax = (zmax - m_descriptor.yMinRange) / m_binsize + 1;
            if (binmin >= m_nbins) continue;
            if (binmax < 0) continue;
 
            if (binmin < 0) binmin = 0;
            if (binmax >= m_nbins) binmax = m_nbins - 1;
            for (int n = binmin; n < binmax; ++n) {
                if (max < m_histos[ci][n]) {
                    max = m_histos[ci][n];
                    posbin = n;
                    thetabin = ci;
                }
            }
        }
        float dthetaOffset = 2 * m_descriptor.thetaStep * (thetabin - (cycles - 1) / 2.);
        return std::make_pair(0.001 * max, -dthetaOffset);
    }

pars()

void MuonHough::MuonLayerHough::pars ( int  posBin, int  , float &  x, float &  y  ) const

inline

calculate x,y for the given position bin

Definition at line 199 of file MuonLayerHough.h.

                                                                                {
        x = m_descriptor.referencePosition;
        y = yval(posBin);
    }

range()

std::pair< int, int > MuonHough::MuonLayerHough::range	(	const float	x,
		const float	y1,
		const float	y2,
		const int	bintheta
	)		const

calculates the first and last bin the hit should be filled in for a given theta bin

The z values shall be some where inside the cavern. Given that the out wheel is at 22m, this is a very rough estimate to crimp the z value and to hopefully avoid spooky FPEs

Definition at line 486 of file MuonLayerHough.cxx.

                                                                                                                   {
        int cycles = m_histos.size();
        float dx = m_descriptor.referencePosition - x;
        float dtheta = m_descriptor.thetaStep;
        if (dtheta <= 0)
            throw std::runtime_error(
                Form("File: %s, Line: %d\nMuonLayerHough::range() - dtheta is not positive (%.4f)", __FILE__, __LINE__, dtheta));
        float dthetaOffset = 2 * dtheta * (bintheta - (cycles - 1) / 2.);
 
        float theta1 = std::atan2(x, y1) - dthetaOffset;
        float z01 = dx * cot(theta1 + dtheta) + y1;
        float z11 = dx * cot(theta1 - dtheta) + y1;
        float zmin1 = std::min(z01, z11);
        float zmax1 = std::max(z01, z11);
 
        float theta2 = std::atan2(x, y2) - dthetaOffset;
        float z02 = dx * cot(theta2 + dtheta) + y2;
        float z12 = dx * cot(theta2 - dtheta) + y2;
        float zmin2 = std::min(z02, z12);
        float zmax2 = std::max(z02, z12);
 
        const float zmin = std::min(zmin1, zmin2);
        const float zmax = std::max(zmax1, zmax2);
        
        constexpr float cavern_size = 100.*Gaudi::Units::meter;     
        const float flt_lower_bin = std::max(-cavern_size, (zmin - m_descriptor.yMinRange) * m_invbinsize);
        const float flt_upper_bin = std::min(cavern_size,  (zmax - m_descriptor.yMinRange) * m_invbinsize);
        const int lower_bin = std::floor(flt_lower_bin);
        const int upper_bin = std::floor(flt_upper_bin);
       
        return std::make_pair(lower_bin, upper_bin);  // convert the output to bins
    }

reset()

void MuonHough::MuonLayerHough::reset

(

)

reset the transform

Definition at line 48 of file MuonLayerHough.cxx.

                               {
        for (unsigned int i = 0; i < m_histos.size(); ++i) memset(m_histos[i].get(), 0, sizeof(unsigned int) * m_nbins);
        max = 0;
        maxhist = -1;
        maxbin = -1;
    }

rootHistos()

std::vector< TH1 * > MuonHough::MuonLayerHough::rootHistos	(	const std::string &	prefix,
		const float *	rmin = 0,
		const float *	rmax = 0
	)		const

returns a vector with all the histograms of the hough as TH1*

Definition at line 272 of file MuonLayerHough.cxx.

                                                                                                                {
        std::vector<TH1*> hists;
        hists.reserve(m_histos.size());
 
        float rmin = rmi ? *rmi : m_descriptor.yMinRange;
        float rmax = rma ? *rma : m_descriptor.yMaxRange;
 
        int cycles = m_histos.size();
        for (int ci = 0; ci < cycles; ++ci) {
            TString hname = prefix + "_hist";
            hname += ci;
            TH1F* h = new TH1F(hname, hname, m_nbins, rmin, rmax);  // register the new histograms here
            for (int n = 0; n < m_nbins; ++n) h->SetBinContent(n + 1, m_histos[ci][n] * 0.001);
            hists.push_back(h);
        }
        return hists;
    }

setDebug()

void MuonHough::MuonLayerHough::setDebug ( bool  d )

inline

enable debug output

Definition at line 124 of file MuonLayerHough.h.

{ m_debug = d; }

yval()

float MuonHough::MuonLayerHough::yval ( int  posBin ) const

inline

access to y coordinate of a given bin

Definition at line 204 of file MuonLayerHough.h.

{ return m_descriptor.yMinRange + posBin * m_binsize; }

Member Data Documentation

m_binsize

float MuonHough::MuonLayerHough::m_binsize {0}

Definition at line 176 of file MuonLayerHough.h.

m_debug

bool MuonHough::MuonLayerHough::m_debug {false}

Definition at line 185 of file MuonLayerHough.h.

m_descriptor

RegionDescriptor MuonHough::MuonLayerHough::m_descriptor

Definition at line 187 of file MuonLayerHough.h.

m_histos

std::vector<std::unique_ptr<unsigned int[]> > MuonHough::MuonLayerHough::m_histos

Definition at line 186 of file MuonLayerHough.h.

m_invbinsize

float MuonHough::MuonLayerHough::m_invbinsize {0}

binsize

Definition at line 177 of file MuonLayerHough.h.

m_nbins

int MuonHough::MuonLayerHough::m_nbins {-1}

inverse binsize

Definition at line 180 of file MuonLayerHough.h.

max

unsigned int MuonHough::MuonLayerHough::max {0}

Definition at line 182 of file MuonLayerHough.h.

maxbin

int MuonHough::MuonLayerHough::maxbin {-1}

Definition at line 184 of file MuonLayerHough.h.

maxhist

int MuonHough::MuonLayerHough::maxhist {-1}

Definition at line 183 of file MuonLayerHough.h.

---

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

• MuonLayerHough.h
• MuonLayerHough.cxx