MuonHoughPatternTool Class Reference

#include <MuonHoughPatternTool.h>

Inheritance diagram for MuonHoughPatternTool:

Collaboration diagram for MuonHoughPatternTool:

Public Member Functions
	MuonHoughPatternTool (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor.
virtual	~MuonHoughPatternTool ()=default
	Destructor.
virtual void	makePatterns (const MuonHoughHitContainer &hitcontainer, MuonHoughPatternContainerShip &houghpatterns) const override
	method that builds the patterns
virtual StatusCode	initialize () override
	initiates private members
virtual StatusCode	finalize () override
	deletes private members
virtual std::unique_ptr< MuonPrdPatternCollection >	getPhiMuonPatterns (MuonHoughPatternContainerShip &houghpatterns) const override
	returns phipattern container in EDM
virtual std::unique_ptr< MuonPrdPatternCollection >	getEtaMuonPatterns (MuonHoughPatternContainerShip &houghpatterns) const override
	returns etapattern container in EDM
virtual MuonHoughPatternContainerShip	emptyHoughPattern () const override
	creates houghpatterns, called from FinderTool
	DeclareInterfaceID (IMuonHoughPatternTool, 1, 0)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	makePatterns (int id_number, double weightmdt, const MuonHoughHitContainer &event, MuonHoughPatternContainerShip &houghpatterns) const
	method that builds the patterns
std::unique_ptr< MuonPrdPatternCollection >	getCurvedMuonPatterns (MuonHoughPatternContainerShip &houghpatterns) const
	returns curvedpattern container in EDM
void	useIPMuons ()
	reduces Detector sizes for Hough Histograms to find patterns from muons from the Interaction Point (default on)
bool	analyseHisto (int id_number, int level, const std::unique_ptr< MuonHoughHitContainer > &event_to_analyse, std::unique_ptr< MuonHoughTransformSteering > &houghtransform, MuonHoughPatternContainerShip &houghpatterns) const
	analyses the hough histograms
int	numberOfHits (const MuonHoughHitContainer &event) const
	returns number of hits left (unused)
bool	hitInHoughPattern (const std::shared_ptr< MuonHoughHit > &hit, const MuonHoughPatternContainer &houghpattern) const
	checks if hit is already in one of the found houghpatterns (unused)
void	weightRescaling (const MuonHoughHitContainer &event, int id_number, int level) const
	rescales hits per iteration to reduce number of patterns when already some have been found
void	calculateWeights (const MuonHoughHitContainer &event, double weightmdt) const
	calculates new weights based on rejection factor (1-origweight) and number of hits in event, only done for MDTs
int	overlapHoughPatterns (const MuonHoughPattern &houghpattern1, const MuonHoughPattern &houghpattern2) const
	returns number of hits that are in both hough patterns
std::unique_ptr< MuonHoughHitContainer >	whichEventHough (int id, const MuonHoughHitContainer &event, double weightmdt) const
	selects the hitcontainer to be used for filling the histograms
std::unique_ptr< MuonHoughHitContainer >	whichEventAssociation (int id, const MuonHoughHitContainer &event) const
	selects the hitcontainer to be used to associate to the maxima
std::unique_ptr< MuonHoughTransformSteering >	whichHoughTransform (int id) const
	returns the Houghtransform for the id
std::vector< int >	maxLevelHoughPattern (const MuonHoughPatternContainerShip &houghpattern) const
	returns the maximum iteration, not in use
int	maxLevelHoughPattern (const MuonHoughPatternContainerShip &houghpattern, int id_number) const
	returns the maximum iteration, not in use
std::unique_ptr< Muon::MuonPrdPattern >	houghPatternToEtaPattern (const MuonHoughPattern &houghpattern) const
	converts hough pattern to EDM eta patterns
std::unique_ptr< Muon::MuonPrdPattern >	houghPatternToPhiPattern (const MuonHoughPattern &houghpattern) const
	converts hough pattern to EDM phi patterns
std::unique_ptr< Muon::MuonPrdPattern >	houghPatternsToOneEtaPattern (const MuonHoughPattern &houghpattern1, const MuonHoughPattern &houghpattern2) const
	converts and combines two hough patterns to one EDM phi pattern
std::unique_ptr< Muon::MuonPrdPattern >	houghPatternsToOnePhiPattern (const MuonHoughPattern &houghpattern1, const MuonHoughPattern &houghpattern2) const
	converts and combines two hough patterns to one EDM phi pattern
std::unique_ptr< Muon::MuonPrdPattern >	houghPatternToCleanPhiPattern (MuonHoughPattern &houghpattern) const
	converts hough pattern to EDM phi patterns and cleans it from outliers
unsigned int	getThresholdHoughPattern (int id_number) const
	returns minimum number of hits a hough pattern can contain
double	getThresholdHisto (int id_number) const
	returns minimum number for the maximum of a hough transform
void	setWeightMdtCutValue (const MuonHoughHitContainer &event, double &weightmdt) const
	calculates the mdt weight cut value
bool	hitThroughCut (const std::shared_ptr< MuonHoughHit > &hit, double weightmdt) const
	hit through weight cut?
void	printPattern (Muon::MuonPrdPattern *muonpattern) const
	print out pattern hits
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	resetAssociation (const MuonHoughHitContainer &event)
	reset association flag of hits in m_event
static bool	hitsLeft (const MuonHoughHitContainer &event)
	returns if there are hits left
static std::unique_ptr< MuonHoughHitContainer >	hitsNotInPattern (const MuonHoughHitContainer &event, int id_number)
	returns a hitcontainer with hits not yet used in pattern
static void	transformCoordsMaximum (std::pair< double, double > &coordsmaximum, double r0_true)
	corrects the maximum of the histogram with a factor (not in use anymore, used for old rz transform)

Private Attributes
std::unique_ptr< TFile >	m_file
	pointer to the file name for the hough histograms
MuonHoughMathUtils	m_muonhoughmathutils
	object for use of mathematical formulas for trackmodels
Gaudi::Property< bool >	m_use_histos {this, "UseHistos", false}
	output histograms (false)
Gaudi::Property< bool >	m_use_cosmics {this, "UseCosmics", false}
	use cosmic settings (false)
Gaudi::Property< bool >	m_use_csc_in_pattern {this, "UseCscInPattern", true}
	use csc hits in association / pattern (true)
Gaudi::Property< bool >	m_use_csc_in_hough {this, "UseCscInHough", true}
	use csc hits in histogram (false)
Gaudi::Property< bool >	m_use_negative_weights {this, "UseNegativeWeights", false}
	use negative weights (false)
Gaudi::Property< bool >	m_use_curvedhough {this, "UseCurvedHough", true}
	use curved hough transformation for eta patterns (true)
int	m_number_of_ids {7}
	number of hough transforms currently supported (7)
Gaudi::Property< int >	m_number_of_maxima {this, "NumberOfMaximaPerIterations", 5}
	number of iterations (5)
bool	m_use_ip {false}
	use interaction point constraint (true)
Gaudi::Property< unsigned int >	m_thresholdpattern_xyz {this, "SetThresholdPatternRPhi", 1}
	minimal size for a phi pattern (1)
Gaudi::Property< unsigned int >	m_thresholdpattern_rz {this, "SetThresholdPatternREta", 3}
	minimal size for a eta pattern (3)
double	m_detectorsize_xy {0.}
	acceptancy of patterns in xy (phi) in mm
double	m_detectorsize_yz {0.}
	acceptancy of patterns in yz (not used) in mm
double	m_detectorsize_rz {0.}
	acceptancy of patterns in rz (eta) in mm
Gaudi::Property< bool >	m_weightcut {this, "ApplyWeightCut", true}
	weight_cut for hits in hough
Gaudi::Property< double >	m_weight {this, "WeightCut", 0.25}
	value of weight cut
Gaudi::Property< bool >	m_weightcutmdt
	weight_cut for mdt hits in hough
Gaudi::Property< double >	m_thresholdhisto_xyz {this, "SetThresholdHistoRPhi", 0.9}
	threshold histogram in xyz
Gaudi::Property< double >	m_thresholdhisto_rz {this, "SetThresholdHistoREta", 2.1}
	threshold histogram in rz
Gaudi::Property< int >	m_number_of_sectors_xyz {this, "SetNumberOfSectorsRPhi", 12}
	number of sectors (different regions in which patterns can be found in the same iteration) in xyz
Gaudi::Property< int >	m_number_of_sectors_rz {this, "SetNumberOfSectorsREta", 16}
	number of sectors (different regions in which patterns can be found in the same iteration) in rz
int	m_number_of_sectors_rz_cosmics {12}
	number of sectors (different regions in which patterns can be found in the same iteration) in rzcosmics
Gaudi::Property< int >	m_printlevel {this, "Printlevel", 0}
	output level (range 0-10) (default 0)
std::atomic_uint	m_ncalls {0}
Gaudi::Property< int >	m_maxNumberOfPhiHits {this, "MaximumNumberOfPhiHits", -1}
	maximum number of phi hits to do pattern recognition, if small zero no cut is applied
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr bool	m_use_rpc_measures_eta {true}
	use rpc phi strips in phi-patterns (true)
static constexpr double	m_maximum_residu_mm {500.}
	distance hits are associated with pattern in mm
static constexpr double	m_maximum_residu_mm_cosmics {2000.}
	distance hits are associated with pattern in mm for cosmics
static constexpr double	m_maximum_residu_angle {3.}
	distance hits are associated with pattern in degrees
static constexpr int	m_maximum_level {5}
	// number of maximum iterations over houghtransform
static constexpr double	m_z_cor_constant {-10000.}
	use hough correction to correct the maximum found in rz-plane slightly as there is a bias in the houghtransform
static constexpr double	m_z_cor_constant2 {6000.}
	constant 2 for z for hough correction
static constexpr double	m_theta_cor_constant {-0.042}
	constant 1 for theta for hough correction
static constexpr double	m_theta_cor_constant2 {4000.}
	constant 2 for theta for hough correction
static constexpr double	m_detectorsize_xy_full {15000.}
	size of full detector in xy (phi) in mm, used as acceptancy for cosmics
static constexpr double	m_detectorsize_yz_full {25000.}
	size of full detector in yz (not used) in mm, used as acceptancy for cosmics
static constexpr double	m_detectorsize_rz_full {27750.}
	size of full detector in rz (eta) in mm, used as acceptancy for cosmics
static constexpr double	m_detectorsize_xy_ip {600.}
	acceptancy of patterns for ip in xy (phi) in mm
static constexpr double	m_detectorsize_yz_ip {1000.}
	acceptancy of patterns for ip in yz (not used) in mm
static constexpr double	m_detectorsize_rz_ip {1500.}
	acceptancy of patterns for ip in rz (eta) in mm
static constexpr double	m_detectorsize_angle_xyz {360.}
	max range of angle in xyz in degrees (360)
static constexpr double	m_detectorsize_angle_rz {180.}
	max range of angle in rz in degrees (180)
static constexpr double	m_stepsize_xy {75.}
	max range of 1/sqrt(curvature) for curved transform, corresponds to 0.02 ~ 2,5m ~ 1.6GeV
static constexpr double	m_stepsize_yz {250.}
	bin width for yz
static constexpr double	m_stepsize_rz {75.}
	bin width for rz
static constexpr double	m_stepsize_xy_cosmics {150.}
	bin width for xy cosmics
static constexpr double	m_stepsize_rz_cosmics {150.}
	bin width for rzcosmics
static constexpr double	m_stepsize_per_angle_xyz {0.25}
	bin width for angle in xyz
static constexpr double	m_stepsize_per_angle_rz {0.25}
	bin width for angle in rz
static constexpr double	m_stepsize_per_angle_xy_cosmics {1.}
	bin width for angle in xy cosmics
static constexpr double	m_stepsize_per_angle_rz_cosmics {2.}
	bin width for angle in rzcosmics
static constexpr int	m_nbins_curved {160}
	bin width for 1/sqrt(curvature)

Detailed Description

Definition at line 18 of file MuonHoughPatternTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonHoughPatternTool()

MuonHoughPatternTool::MuonHoughPatternTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Default constructor.

Definition at line 24 of file MuonHoughPatternTool.cxx.

                                                                                                                 :
    AthAlgTool(type, name, parent) {
    declareInterface<IMuonHoughPatternTool>(this);
 
    m_detectorsize_xy = m_detectorsize_xy_full;
    m_detectorsize_yz = m_detectorsize_yz_full;
    m_detectorsize_rz = m_detectorsize_rz_full;
}

~MuonHoughPatternTool()

virtual MuonHoughPatternTool::~MuonHoughPatternTool ( )

virtualdefault

Destructor.

Member Function Documentation

analyseHisto()

bool MuonHoughPatternTool::analyseHisto ( int id_number, int level, const std::unique_ptr< MuonHoughHitContainer > & event_to_analyse, std::unique_ptr< MuonHoughTransformSteering > & houghtransform, MuonHoughPatternContainerShip & houghpatterns ) const

private

analyses the hough histograms

Parameters

[in]	id_number	The enum number corresponding to the HoughTransform
[in]	level	The iteration number
[in]	event_to_analyse	The hitcontainer which will be associated to the pattern
[in]	houghtransform	The HoughTransform

The Analyse-fillHistos loop is at three times ended for each id: 1- if the maximum_number of hhistos[id] ==0 2- if the houghpattern.size() < threshold_for_next_houghpattern 3 - if level == maximum_level at all these 3 times an array[number_of_ids] of int levelmax will be houghpattern has to be deleted.. (all in level>0) 4- if level not gets to 1 // but then no houghpatterns made.. ? 5- if numberOfHits left ==0

Definition at line 224 of file MuonHoughPatternTool.cxx.

                                                                                                {
    ATH_MSG_VERBOSE("analyseHisto MuonHoughPatternTool (start)");

 
    bool test_for_next_level = false;
 
    const unsigned int threshold_for_next_houghpattern = getThresholdHoughPattern(id_number);
    double numberofmaxima = 0;
    double maximum_residu = m_maximum_residu_mm;
    if (m_use_cosmics) { maximum_residu = m_maximum_residu_mm_cosmics; }
    MuonHoughPatternCollection houghpatterns = houghtransform->constructHoughPatterns(
        *event_to_analyse, maximum_residu, m_maximum_residu_angle, m_number_of_maxima);
 
    for (unsigned int maximum_number = 0; maximum_number < houghpatterns.size(); ++maximum_number) {
  
        std::unique_ptr<MuonHoughPattern>& houghpattern = houghpatterns[maximum_number];
        if (!houghpattern) { continue; }
        numberofmaxima = houghpattern->getMaximumHistogram();
        ATH_MSG_DEBUG("id_number: " << id_number << " maximum_number: " << maximum_number << " size patternseg: " << houghpattern->size());
 
        if (houghpattern->empty()) { ATH_MSG_DEBUG("houghpattern==0"); }
 
        // some print statements
        if (houghpattern->size() < numberofmaxima) {
            ATH_MSG_DEBUG("ERROR: houghpattern smaller than maximum, id: " << id_number << " houghpattern.size(): " << houghpattern->size()
                                                                           << " numberofmaxima: " << numberofmaxima);
        }
 
       if (m_printlevel >= 4) { houghpattern->printHoughPattern(); }
 
        // checks for next level / maximum
 
        if (houghpattern->size() >= threshold_for_next_houghpattern) {
            if (level + 1 >= m_maximum_level) {
                ATH_MSG_DEBUG("possibly more levels");
            } else {
                test_for_next_level = hitsLeft(*event_to_analyse);
            }
        } else if (maximum_number == 0) {
            ATH_MSG_DEBUG("houghpattern too small for next level : " << level << " id: " << id_number);
        }
 
        // print_of houghpatterns:
        ATH_MSG_DEBUG("Size of HoughPatterns: " << houghpattern->size());
        houghpatterns_all[id_number][level][maximum_number] = std::move(houghpattern);
 
    }  // maximum_number
 
    ATH_MSG_DEBUG(" Test for next level: " << test_for_next_level);
 
    return test_for_next_level;
 
}  // analyseHisto

calculateWeights()

void MuonHoughPatternTool::calculateWeights ( const MuonHoughHitContainer & event, double weightmdt ) const

private

calculates new weights based on rejection factor (1-origweight) and number of hits in event, only done for MDTs

Definition at line 383 of file MuonHoughPatternTool.cxx.

                                                                                                      {
    if (weightmdt < 0.5) return;
    // else do nothing (e.g. cosmics case)
    for (unsigned int i = 0; i < event.size(); ++i) {
        std::shared_ptr<MuonHoughHit> hit = event.getHit(i);
        MuonHough::DetectorTechnology technology = hit->getDetectorId();
        if (technology == MuonHough::MDT) {
            // recalculate weight, especially important for cavern background MDT events
            double p_old = hit->getOrigWeight();
            double p_calc = 0.25 * p_old * (1. - weightmdt);
            double p_new = p_calc / (p_calc + weightmdt * (1 - p_old));
            ATH_MSG_VERBOSE(" MDT probability old " << p_old << " Recalculated " << p_new);
            hit->setWeight(p_new);
        }
    }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

IMuonHoughPatternTool::DeclareInterfaceID ( IMuonHoughPatternTool , 1 , 0  )

inherited

Todo

should be rethought and possibly using the Moore Interface

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

emptyHoughPattern()

MuonHoughPatternContainerShip MuonHoughPatternTool::emptyHoughPattern ( ) const

overridevirtual

creates houghpatterns, called from FinderTool

Implements IMuonHoughPatternTool.

Definition at line 202 of file MuonHoughPatternTool.cxx.

                                                                            {
    MuonHoughPatternContainerShip houghpattern;
    houghpattern.reserve(m_number_of_ids);
    for (int i = 0; i < m_number_of_ids; ++i) {
        MuonHoughPatternContainer which_segment_vector;
        which_segment_vector.reserve(m_maximum_level);
        houghpattern.emplace_back(std::move(which_segment_vector));
 
        for (int lvl = 0; lvl < m_maximum_level; lvl++) {
            MuonHoughPatternCollection level_vector;
            level_vector.reserve(m_number_of_maxima);
            houghpattern[i].emplace_back(std::move(level_vector));
 
            for (int maximum_number = 0; maximum_number < m_number_of_maxima; maximum_number++) {
                houghpattern[i][lvl].emplace_back(nullptr);
 
            }  // maximum_number
        }      // maximum_level
    }          // number_of_ids
    return houghpattern;
}  // emptyHoughPattern

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode MuonHoughPatternTool::finalize ( )

overridevirtual

deletes private members

Definition at line 191 of file MuonHoughPatternTool.cxx.

                                          {
    ATH_MSG_VERBOSE("finalize()");
 
    if (m_use_histos) {
        m_file->Write();
        m_file.reset();
    }
 
    return StatusCode::SUCCESS;
}

getCurvedMuonPatterns()

std::unique_ptr< MuonPrdPatternCollection > MuonHoughPatternTool::getCurvedMuonPatterns ( MuonHoughPatternContainerShip & houghpatterns ) const

private

returns curvedpattern container in EDM

Definition at line 953 of file MuonHoughPatternTool.cxx.

                                                                                                                                      {
    std::unique_ptr<MuonPrdPatternCollection> curvedpatterncollection = std::make_unique<MuonPrdPatternCollection>();
 
    int maximum_number_of_patterns = m_maximum_level * m_number_of_maxima;
 
    curvedpatterncollection->reserve(maximum_number_of_patterns);
 
    MuonHoughPatternContainer& curvedpatterns = houghpatterns[MuonHough::hough_curved_at_a_cylinder];
    for (unsigned int i = 0; i < curvedpatterns.size(); ++i) {
        for (unsigned int j = 0; j < curvedpatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern = curvedpatterns[i][j];
            if (!houghpattern) { continue; }
 
            if (!curvedpatterns[i][j]->empty()) {
                std::unique_ptr<Muon::MuonPrdPattern> muonpattern = houghPatternToEtaPattern(*curvedpatterns[i][j]);
                curvedpatterncollection->push_back(std::move(muonpattern));
                ATH_MSG_DEBUG(" Lift MuoncurvedPattern size " << curvedpatterns[i][j]->size());
            }
        }
    }
    return curvedpatterncollection;
}

getEtaMuonPatterns()

std::unique_ptr< MuonPrdPatternCollection > MuonHoughPatternTool::getEtaMuonPatterns ( MuonHoughPatternContainerShip & houghpatterns ) const

overridevirtual

returns etapattern container in EDM

Implements IMuonHoughPatternTool.

Definition at line 806 of file MuonHoughPatternTool.cxx.

                                                                                                                                   {
    std::unique_ptr<MuonPrdPatternCollection> etapatterncollection = std::make_unique<MuonPrdPatternCollection>();
 
    int maximum_number_of_patterns = m_maximum_level * m_number_of_maxima;
 
    if (m_use_curvedhough) maximum_number_of_patterns = 2 * maximum_number_of_patterns;
 
    etapatterncollection->reserve(maximum_number_of_patterns);
 
    int id = MuonHough::hough_rz;
    if (m_use_cosmics) {
        id = MuonHough::hough_rzcosmics;
        ATH_MSG_DEBUG(" GetEtaMuonPatterns Use RZ curved hough patterns ");
    } else if (m_use_curvedhough) {
        id = MuonHough::hough_curved_at_a_cylinder;
        ATH_MSG_DEBUG(" GetEtaMuonPatterns Use curved hough patterns ");
    } else {
        ATH_MSG_DEBUG(" GetEtaMuonPatterns Use RZ hough patterns ");
    }
 
    MuonHoughPatternContainer& etapatterns = houghpatterns[id];
 
    // Bookkeeping for merged or double eta patterns
 
    std::map<MuonHoughPattern*, int> mergedpatterns;
    for (unsigned int i = 0; i < etapatterns.size(); ++i) {
        for (unsigned int j = 0; j < etapatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern = etapatterns[i][j];
            if (!houghpattern) continue;
            mergedpatterns[houghpattern.get()] = 0;
        }
    }
 
    // Search for identical eta patterns and remove them
    // and search for overlapping eta patterns and merge them (10-1-2008, does merging ever happen? JS, yes it does!)
 
    for (unsigned int i = 0; i < etapatterns.size(); ++i) {
        for (unsigned int j = 0; j < etapatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern1 = etapatterns[i][j];
            if (!houghpattern1) continue;
            if (etapatterns[i][j]->size() < m_thresholdpattern_rz) continue;
            ATH_MSG_DEBUG(" Eta patterns size before Merge " << etapatterns[i][j]->size());
            for (unsigned int k = i; k < etapatterns.size(); k++) {
                for (unsigned int l = 0; l < etapatterns[k].size(); l++) {
                    std::unique_ptr<MuonHoughPattern>& houghpattern2 = etapatterns[k][l];
                    if (!houghpattern2) continue;
                    if (etapatterns[k][l]->size() < m_thresholdpattern_rz) continue;
                    //cppcheck-suppress mismatchingContainers
                    if (houghpattern1.get() == houghpattern2.get()) continue;
                    if (mergedpatterns[houghpattern1.get()] == 1) continue;
                    if (mergedpatterns[houghpattern2.get()] == 1) continue;
 
                    // calculate if curvatures are compatible, not done for cosmics
                    double alpha = 0.;
                    if (!m_use_cosmics) {
                        double curv1 = houghpattern1->getECurvature();
                        double curv2 = houghpattern2->getECurvature();
                        if (std::abs(curv1) < 1001. || std::abs(curv2) < 1001.) {
                            ATH_MSG_DEBUG("Curvature too small, should not be possible: " << curv1 << " " << curv2);
                            continue;
                        }
 
                        double angle1 = std::acos((std::abs(curv1) - 1000.) / curv1);  // angle change after 1000 (mm)
                        double angle2 = std::acos((std::abs(curv2) - 1000.) / curv2);
                        alpha = std::abs(std::sin(angle1 - angle2));
 
                        ATH_MSG_DEBUG(" patterns curv1 " << curv1 << " curv2 " << curv2 << " alpha " << alpha);
                    }
 
                    double phi1 = houghpattern1->getEPhi();
                    double phi2 = houghpattern2->getEPhi();
                    double dotprod = std::cos(phi1) * std::cos(phi2) + std::sin(phi1) * std::sin(phi2);
                    if (dotprod > 1.)
                        dotprod = 1.;
                    else if (dotprod < -1.)
                        dotprod = -1.;
                    double psi = std::acos(dotprod);
                    double the1 = houghpattern1->getETheta();
                    double the2 = houghpattern2->getETheta();
                    dotprod = std::cos(the1) * std::cos(the2) + std::sin(the1) * std::sin(the2);
                    if (dotprod > 1.)
                        dotprod = 1.;
                    else if (dotprod < -1.)
                        dotprod = -1.;
                    double chi = std::acos(dotprod);
 
                    ATH_MSG_DEBUG(" patterns phi1 " << phi1 << " phi2 " << phi2 << " psi " << psi);
                    ATH_MSG_DEBUG(" patterns the1 " << the1 << " the2 " << the2 << " chi " << chi);
 
                    if (chi < 0.5 && psi < 0.5 && alpha < 0.05) {  // 0.05 (rad) corresponds with 3 degrees per m
 
                        int overlap = overlapHoughPatterns(*houghpattern1, *houghpattern2);
                        const int ns1 = houghpattern1->size();
                        const int ns2 = houghpattern2->size();
 
                        ATH_MSG_DEBUG(" Eta Overlap " << overlap << " size1 " << ns1 << " size2 " << ns2);
 
                        if (overlap == ns2 && overlap <= ns1) {
                            ATH_MSG_DEBUG(" DROP patterns overlapping hits ");
                            mergedpatterns[houghpattern2.get()] = 1;
                            continue;
                        }
                        if (overlap == ns1 && overlap < ns2) {
                            ATH_MSG_DEBUG(" DROP patterns overlapping hits ");
                            mergedpatterns[houghpattern1.get()] = 1;
                            continue;
                        }
                        std::unique_ptr<Muon::MuonPrdPattern> muonpattern;
                        // Look for 80% or more overlap
                        if ((overlap > 0.8 * ns1 || overlap > 0.8 * ns2) && ns1 >= ns2) {
                            muonpattern = houghPatternsToOneEtaPattern(*etapatterns[i][j], *etapatterns[k][l]);
                        }
                        if ((overlap > 0.8 * ns1 || overlap > 0.8 * ns2) && ns1 < ns2) {
                            muonpattern = houghPatternsToOneEtaPattern(*etapatterns[k][l], *etapatterns[i][j]);
                        }
                        if (muonpattern) {
                            etapatterncollection->push_back(std::move(muonpattern));
                            mergedpatterns[houghpattern1.get()] = 1;
                            mergedpatterns[houghpattern2.get()] = 1;
                            continue;
                        }
                    }  // end angular cut
                }
            }  // end k
        }
    }  // end i
 
    for (unsigned int i = 0; i < etapatterns.size(); ++i) {
        for (unsigned int j = 0; j < etapatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern = etapatterns[i][j];
            if (!houghpattern) { continue; }
            if (mergedpatterns[houghpattern.get()] == 1) continue;
 
            if (!etapatterns[i][j]->empty()) {
                std::unique_ptr<Muon::MuonPrdPattern> muonpattern = houghPatternToEtaPattern(*etapatterns[i][j]);
                //use muonpattern *before* you move it
                if (msgLvl(MSG::VERBOSE)) { printPattern(muonpattern.get()); }
                etapatterncollection->push_back(std::move(muonpattern));
                ATH_MSG_DEBUG(" Lift MuonEtaPattern size " << etapatterns[i][j]->size());
                
            }
        }
    }
 
    return etapatterncollection;
}

getPhiMuonPatterns()

std::unique_ptr< MuonPrdPatternCollection > MuonHoughPatternTool::getPhiMuonPatterns ( MuonHoughPatternContainerShip & houghpatterns ) const

overridevirtual

returns phipattern container in EDM

Implements IMuonHoughPatternTool.

Definition at line 683 of file MuonHoughPatternTool.cxx.

                                                                                                                                   {
    std::unique_ptr<MuonPrdPatternCollection> phipatterncollection = std::make_unique<MuonPrdPatternCollection>();
    phipatterncollection->reserve(m_maximum_level * m_number_of_maxima);
 
    MuonHoughPatternContainer& phipatterns = houghpatterns[MuonHough::hough_xy];
 
    // Bookkeeping for merged or double phi pattersn
 
    std::map<MuonHoughPattern*, int> mergedpatterns;
    for (unsigned int i = 0; i < phipatterns.size(); ++i) {
        for (unsigned int j = 0; j < phipatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern = phipatterns[i][j];
            if (!houghpattern) continue;
            mergedpatterns[houghpattern.get()] = 0;
        }
    }
 
    // Search for identical phi patterns and remove them
    // and search for overlapping phi patterns and merge them for IP constraint (10-1-2008, does merging ever happen? JS)
 
    for (unsigned int i = 0; i < phipatterns.size(); ++i) {
        for (unsigned int j = 0; j < phipatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern1 = phipatterns[i][j];
            if (!houghpattern1) continue;
            if (phipatterns[i][j]->size() < m_thresholdpattern_xyz) continue;
            ATH_MSG_DEBUG(" patterns size before Merge " << phipatterns[i][j]->size());
            for (unsigned int k = i; k < phipatterns.size(); k++) {
                for (unsigned int l = 0; l < phipatterns[k].size(); l++) {
                    std::unique_ptr<MuonHoughPattern>& houghpattern2 = phipatterns[k][l];
                    if (!houghpattern2) continue;
                    if (phipatterns[k][l]->size() < m_thresholdpattern_xyz) continue;
                    //cppcheck-suppress mismatchingContainers
                    if (houghpattern1.get() == houghpattern2.get()) continue;
                    if (mergedpatterns[houghpattern1.get()] == 1) continue;
                    if (mergedpatterns[houghpattern2.get()] == 1) continue;
                    const double phi1 = houghpattern1->getEPhi();
                    const double phi2 = houghpattern2->getEPhi();
                    CxxUtils::sincos scphi1(phi1);
                    CxxUtils::sincos scphi2(phi2);
                    double dotprod = scphi1.cs * scphi2.cs + scphi1.sn * scphi2.sn;
                    if (dotprod > 1.)
                        dotprod = 1.;
                    else if (dotprod < -1.)
                        dotprod = -1.;
                    double psi = std::acos(dotprod);
                    const double the1 = houghpattern1->getETheta();
                    const double the2 = houghpattern2->getETheta();
                    CxxUtils::sincos scthe1(the1);
                    CxxUtils::sincos scthe2(the2);
                    dotprod = scthe1.cs * scthe2.cs + scthe1.sn * scthe2.sn;
                    if (dotprod > 1.)
                        dotprod = 1.;
                    else if (dotprod < -1.)
                        dotprod = -1.;
                    double chi = std::acos(dotprod);
                    ATH_MSG_DEBUG(" patterns phi1 " << phi1 << " phi2 " << phi2 << " psi " << psi);
                    ATH_MSG_DEBUG(" patterns the1 " << the1 << " the2 " << the2 << " chi " << chi);
                    if (chi < 0.5 || psi < 0.5) {
                        int overlap = overlapHoughPatterns(*houghpattern1, *houghpattern2);
                        ATH_MSG_DEBUG(" Phi Overlap " << overlap << " size1 " << houghpattern1->size() << " size2 "
                                                      << houghpattern2->size());
                        int ns1 = houghpattern1->size();
                        int ns2 = houghpattern2->size();
                        if (overlap <= ns1 && overlap == ns2) {
                            ATH_MSG_DEBUG(" DROP patterns same hits ");
                            mergedpatterns[houghpattern2.get()] = 1;
                            continue;
                        }
                        if (overlap == ns1 && overlap < ns2) {
                            ATH_MSG_DEBUG(" DROP patterns same hits ");
                            mergedpatterns[houghpattern1.get()] = 1;
                            continue;
                        }
                        if (m_use_ip) {
                            // Merge and do cleaning  (IP constraint)
                            std::unique_ptr<Muon::MuonPrdPattern> muonpattern;
                            if ((overlap > 0.8 * ns1 || overlap > 0.8 * ns2) && ns1 >= ns2) {
                                muonpattern = houghPatternsToOnePhiPattern(*phipatterns[i][j], *phipatterns[k][l]);
                            }
                            if ((overlap > 0.8 * ns1 || overlap > 0.8 * ns2) && ns1 < ns2) {
                                // Merge and do cleaning  (IP constraint)
                                muonpattern = houghPatternsToOnePhiPattern(*phipatterns[k][l], *phipatterns[i][j]);
                            }
                            if (muonpattern) {
                                phipatterncollection->push_back(std::move(muonpattern));
                                mergedpatterns[houghpattern1.get()] = 1;
                                mergedpatterns[houghpattern2.get()] = 1;
                                continue;
                            }
                        }  // use IP
                    }      // angular cut
                }
            }  // end k
        }
    }  // end i
 
    for (unsigned int i = 0; i < phipatterns.size(); ++i) {
        for (unsigned int j = 0; j < phipatterns[i].size(); ++j) {
            std::unique_ptr<MuonHoughPattern>& houghpattern = phipatterns[i][j];
            if (!houghpattern) { continue; }
            if (mergedpatterns[houghpattern.get()] == 1) continue;
 
            if (!phipatterns[i][j]->empty()) {
                std::unique_ptr<Muon::MuonPrdPattern> muonpattern;
 
                if (!m_use_ip) {
                    muonpattern = houghPatternToPhiPattern(*phipatterns[i][j]);
                } else {
                    muonpattern = houghPatternToCleanPhiPattern(*phipatterns[i][j]);
                }
 
                if (muonpattern) {
                    ATH_MSG_DEBUG(" Lift MuonPhiPattern size " << muonpattern->numberOfContainedPrds());
                    if (msgLvl(MSG::VERBOSE)) { printPattern(muonpattern.get()); }
                    phipatterncollection->push_back(std::move(muonpattern));
                }
            }
        }
    }
 
    return phipatterncollection;
}

getThresholdHisto()

double MuonHoughPatternTool::getThresholdHisto ( int id_number ) const

private

returns minimum number for the maximum of a hough transform

Definition at line 1421 of file MuonHoughPatternTool.cxx.

                                                                  {
    double thresholdhisto = 0.;
    switch (id_number) {
        case MuonHough::hough_xy:
        case MuonHough::hough_yz: thresholdhisto = m_thresholdhisto_xyz; break;
        case MuonHough::hough_rz:
        case MuonHough::hough_rzcosmics:
        case MuonHough::hough_rz_rpc:
        case MuonHough::hough_rz_mdt:
        case MuonHough::hough_curved_at_a_cylinder: thresholdhisto = m_thresholdhisto_rz; break;
        default: ATH_MSG_WARNING("no valid id (id_number)");
    }  // switch
    return thresholdhisto;
}

getThresholdHoughPattern()

unsigned int MuonHoughPatternTool::getThresholdHoughPattern ( int id_number ) const

private

returns minimum number of hits a hough pattern can contain

Definition at line 1406 of file MuonHoughPatternTool.cxx.

                                                                               {
    unsigned int thresholdpattern = 0;
    switch (id_number) {
        case MuonHough::hough_xy:
        case MuonHough::hough_yz: thresholdpattern = m_thresholdpattern_xyz; break;
        case MuonHough::hough_rz:
        case MuonHough::hough_rzcosmics:
        case MuonHough::hough_rz_rpc:
        case MuonHough::hough_rz_mdt:
        case MuonHough::hough_curved_at_a_cylinder: thresholdpattern = m_thresholdpattern_rz; break;
        default: ATH_MSG_WARNING("no valid id (id_number)");
    }  // switch
    return thresholdpattern;
}

hitInHoughPattern()

bool MuonHoughPatternTool::hitInHoughPattern ( const std::shared_ptr< MuonHoughHit > & hit, const MuonHoughPatternContainer & houghpattern ) const

private

checks if hit is already in one of the found houghpatterns (unused)

Definition at line 308 of file MuonHoughPatternTool.cxx.

                                                                                                                                        {
    // checks if hit is already assigned to a houghpattern
 
    for (unsigned int i = 0; i < houghpattern.size(); ++i) {
        for (unsigned int j = 0; j < houghpattern[i].size(); ++j) {
            if (houghpattern[i][j]) {
                if (houghpattern[i][j]->hitInHoughPattern(hit)) {
                    ATH_MSG_VERBOSE("Hit in hough pattern found level " << i << " max " << j << "hitid: " << hit->getId());
                    return true;
                }
            }
        }
    }
    return false;
}

hitsLeft()

bool MuonHoughPatternTool::hitsLeft ( const MuonHoughHitContainer & event )

staticprivate

returns if there are hits left

Definition at line 287 of file MuonHoughPatternTool.cxx.

                                                                      {
    int number_of_hits = event.size();
    for (int hitid = 0; hitid < number_of_hits; ++hitid) {
        if (!event.getHit(hitid)->getAssociated()) { return true; }
    }
    return false;
}

hitsNotInPattern()

std::unique_ptr< MuonHoughHitContainer > MuonHoughPatternTool::hitsNotInPattern ( const MuonHoughHitContainer & event, int id_number )

staticprivate

returns a hitcontainer with hits not yet used in pattern

Definition at line 1398 of file MuonHoughPatternTool.cxx.

                                                                                                                     {
    std::unique_ptr<MuonHoughHitContainer> hits_not_in_patterns = std::make_unique<MuonHoughHitContainer>();
 
    for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
        if (!event.getHit(hitid)->getAssociated()) { hits_not_in_patterns->addHit(event.getHit(hitid)); }
    }
    return hits_not_in_patterns;
}

hitThroughCut()

bool MuonHoughPatternTool::hitThroughCut ( const std::shared_ptr< MuonHoughHit > & hit, double weightmdt ) const

private

hit through weight cut?

Definition at line 1445 of file MuonHoughPatternTool.cxx.

                                                                                                       {
    return (!m_weightcutmdt || hit->getDetectorId() != MuonHough::MDT || hit->getProbability() >= weightmdt) &&
           (!m_weightcut || hit->getProbability() >= m_weight);
}

houghPatternsToOneEtaPattern()

std::unique_ptr< Muon::MuonPrdPattern > MuonHoughPatternTool::houghPatternsToOneEtaPattern ( const MuonHoughPattern & houghpattern1, const MuonHoughPattern & houghpattern2 ) const

private

converts and combines two hough patterns to one EDM phi pattern

Definition at line 1023 of file MuonHoughPatternTool.cxx.

                                                                                                                                      {
    ATH_MSG_DEBUG("houghPatternsToOneEtaPattern");
 
    const int ns1 = houghpattern1.size();
    const int ns2 = houghpattern2.size();
 
    const double the1 = houghpattern1.getETheta();
    const double the2 = houghpattern2.getETheta();
    const double theta = (ns1 * the1 + ns2 * the2) / (ns1 + ns2);
 
    const double phi1 = houghpattern1.getEPhi();
    const double phi2 = houghpattern2.getEPhi();
    const double cos_phi = (ns1 * std::cos(phi1) + ns2 * std::cos(phi2)) / (ns1 + ns2);
    const double sin_phi = (ns1 * std::sin(phi1) + ns2 * std::sin(phi2)) / (ns1 + ns2);
    const double phi = std::atan2(sin_phi, cos_phi);
 
    const double invcur1 = 1. / houghpattern1.getECurvature();
    const double invcur2 = 1. / houghpattern2.getECurvature();
 
    const Amg::Vector3D position1 = houghpattern1.getEPos();
    const Amg::Vector3D position2 = houghpattern2.getEPos();
    const double z0 = (ns1 * position1[2] + ns2 * position2[2]) / (ns1 + ns2);
 
    const double invcur = (ns1 * invcur1 + ns2 * invcur2) / (ns1 + ns2);
 
    ATH_MSG_DEBUG("Start Making one eta pattern theta " << theta << " phi " << phi << " invcur " << invcur);
 
    ATH_MSG_DEBUG("eta patterns theta1  " << the1 << " theta2 " << the2 << " phi1 " << phi1 << " phi2 " << phi2 << " invcur1 " << invcur1
                                          << " invcur2 " << invcur2 << " ns1 " << ns1 << " ns2 " << ns2);
 
    ATH_MSG_DEBUG(" z values " << z0 << " z1 " << position1[2] << " z2 " << position2[2]);
 
    // require at least two eta hits on muon pattern
 
    if (ns1 + ns2 < 2) return nullptr;
 
    double invcurvature = invcur;
    double charge = 1.;
    if (invcurvature < 0) charge = -1;
    double pscale = 1.;
    if (invcurvature != 0) pscale = 1. / std::abs(invcurvature);
 
    double r0 = 0.001;
 
    if (m_use_cosmics) {  // calculate new r0
        r0 = (ns1 * houghpattern1.getERPhi() + ns2 * houghpattern2.getERPhi()) / (ns1 + ns2);
        ATH_MSG_DEBUG("New r0: " << r0);
    }
 
    double x0 = charge * r0 * sin_phi;
    double y0 = -charge * r0 * cos_phi;
 
    ATH_MSG_DEBUG(" Lift one Eta pattern charge " << charge << " curvature  " << pscale);
 
    const Amg::Vector3D pos = Amg::Vector3D(x0, y0, z0);
    const Amg::Vector3D dir =
        Amg::Vector3D(pscale * std::sin(theta) * cos_phi, pscale * std::sin(theta) * sin_phi, pscale * std::cos(theta));
 
    std::unique_ptr<Muon::MuonPrdPattern> muonpattern = std::make_unique<Muon::MuonPrdPattern>(pos, dir);
    int neta = 0;
 
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double the = houghpattern1.getTheta(i);
        muonpattern->addPrd(houghpattern1.getPrd(i));
        ++neta;
        ATH_MSG_VERBOSE("PrepRawData Added theta " << the);
    }
 
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        bool accept = true;
        double the = houghpattern2.getTheta(i);
        for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
            if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
        }
        if (accept) {
            muonpattern->addPrd(houghpattern2.getPrd(i));
            ++neta;
            ATH_MSG_VERBOSE("PrepRawData Added theta " << the);
        } else {
            ATH_MSG_VERBOSE(" PrepRawData already there " << the);
        }
    }
 
    ATH_MSG_VERBOSE(" END make One Eta pattern hits " << neta);
 
    return muonpattern;
}

houghPatternsToOnePhiPattern()

std::unique_ptr< Muon::MuonPrdPattern > MuonHoughPatternTool::houghPatternsToOnePhiPattern ( const MuonHoughPattern & houghpattern1, const MuonHoughPattern & houghpattern2 ) const

private

converts and combines two hough patterns to one EDM phi pattern

IP constraint used, should not be used for cosmics!

Definition at line 1112 of file MuonHoughPatternTool.cxx.

                                                                                                                                      {
 
    ATH_MSG_DEBUG("houghPatternsToOnePhiPattern");
 
    double theta = (houghpattern1.getETheta() + houghpattern2.getETheta()) / 2.;
    double cos_phi{0.}, sin_phi{0.};
    int nphi = 0;
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double phi = houghpattern1.getPhi(i);
        cos_phi += std::cos(phi);
        sin_phi += std::sin(phi);
        ++nphi;
    }
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        double phi = houghpattern2.getPhi(i);
        bool accept = true;
        for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
            if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
        }
        if (accept) {
            cos_phi += std::cos(phi);
            sin_phi += std::sin(phi);
            ++nphi;
        }
    }
 
    ATH_MSG_VERBOSE("Start Merged Phi hits cleaning with " << nphi << " hits ");
    // require at least two phi hits on muon phi pattern
 
    if (nphi < 2) return nullptr;
 
    double cphit = cos_phi / nphi;
    double sphit = sin_phi / nphi;
 
    cos_phi = 0.;
    sin_phi = 0.;
    nphi = 0;
 
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double phi = houghpattern1.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.95) {
            cos_phi += std::cos(phi);
            sin_phi += std::sin(phi);
            ++nphi;
        }
    }
 
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        double phi = houghpattern2.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.95) {
            bool accept = true;
            for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
                if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
            }
            if (accept) {
                cos_phi += std::cos(phi);
                sin_phi += std::sin(phi);
                ++nphi;
            }
        }
    }
 
    if (nphi < 2) return nullptr;
    cphit = cos_phi / nphi;
    sphit = sin_phi / nphi;
 
    cos_phi = 0.;
    sin_phi = 0.;
    nphi = 0;
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double phi = houghpattern1.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.99) {
            cos_phi += std::cos(phi);
            sin_phi += std::sin(phi);
            ++nphi;
        }
    }
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        double phi = houghpattern2.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.99) {
            bool accept = true;
            for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
                if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
            }
            if (accept) {
                cos_phi += std::cos(phi);
                sin_phi += std::sin(phi);
                ++nphi;
            }
        }
    }
    if (nphi < 2) return nullptr;
    cphit = cos_phi / nphi;
    sphit = sin_phi / nphi;
 
    theta = 0;
    cos_phi = 0.;
    sin_phi = 0.;
    nphi = 0;
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double phi = houghpattern1.getPhi(i);
        double thetah = houghpattern1.getTheta(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.995) {
            cos_phi += std::cos(phi);
            sin_phi += std::sin(phi);
            theta += thetah;
            ++nphi;
        }
    }
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        double phi = houghpattern2.getPhi(i);
        double thetah = houghpattern2.getTheta(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.995) {
            bool accept = true;
            for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
                if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
            }
            if (accept) {
                cos_phi += std::cos(phi);
                sin_phi += std::sin(phi);
                theta += thetah;
                ++nphi;
            }
        }
    }
    if (nphi < 2) return nullptr;
    cphit = cos_phi / nphi;
    sphit = sin_phi / nphi;
    theta = theta / nphi;
 
    double r0 = 1.;  // put 1 mm r0 value
    double x0 = r0 * sphit;
    double y0 = -r0 * cphit;
    double z0 = 0.;
 
    const Amg::Vector3D pos{x0, y0, z0};
    const Amg::Vector3D dir{std::sin(theta) * cphit, std::sin(theta) * sphit, std::cos(theta)};
 
    std::unique_ptr<Muon::MuonPrdPattern> muonpattern = std::make_unique<Muon::MuonPrdPattern>(pos, dir);
    nphi = 0;
 
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        double phi = houghpattern1.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.995) {
            muonpattern->addPrd(houghpattern1.getPrd(i));
            ++nphi;
            ATH_MSG_VERBOSE("PrepRawData Merged Clean Phi Added " << phi);
        } else {
            ATH_MSG_VERBOSE("PrepRawData Merged Phi Dropped " << phi);
        }
    }
 
    for (unsigned int i = 0; i < houghpattern2.size(); ++i) {
        double phi = houghpattern2.getPhi(i);
        double dotprod = cphit * std::cos(phi) + sphit * std::sin(phi);
        if (dotprod > 0.995) {
            bool accept = true;
            for (unsigned int j = 0; j < houghpattern1.size(); ++j) {
                if (houghpattern2.getPrd(i) == houghpattern1.getPrd(j)) accept = false;
            }
            if (accept) {
                muonpattern->addPrd(houghpattern2.getPrd(i));
                ++nphi;
                ATH_MSG_VERBOSE("PrepRawData Merged Clean Phi Added " << phi);
            } else {
                ATH_MSG_VERBOSE("PrepRawData Merged Phi Dropped " << phi);
            }
        } else {
            ATH_MSG_VERBOSE("PrepRawData Merged Phi Dropped " << phi);
        }
    }
 
    ATH_MSG_VERBOSE("END Clean Merged Phi hits " << nphi);
 
    return muonpattern;
}

houghPatternToCleanPhiPattern()

std::unique_ptr< Muon::MuonPrdPattern > MuonHoughPatternTool::houghPatternToCleanPhiPattern ( MuonHoughPattern & houghpattern ) const

private

converts hough pattern to EDM phi patterns and cleans it from outliers

IP constraint used, should not be used for cosmics!

Definition at line 1298 of file MuonHoughPatternTool.cxx.

                                                                                                                          {
 
    // TODO: rewrite with removing hits from patterns, instead of building up
 
    ATH_MSG_DEBUG("houghPatternToCleanPhiPattern");
 
    if (msgLevel(MSG::VERBOSE)) {
        for (unsigned int i = 0; i < houghpattern.size(); ++i) {
            const std::shared_ptr<MuonHoughHit> hit = houghpattern.getHit(i);
            ATH_MSG_VERBOSE(hit->getHitx() << " " << hit->getHity() << " " << hit->getHitz() << " " << hit->getPhi() << " "
                                           << hit->getMeasuresPhi() << " " << hit->getWhichDetector() << " " << hit->getWeight() << " "
                                           << hit->getAssociated());
        }
    }
 
    double theta = houghpattern.getETheta();
    unsigned int size = houghpattern.size();
    double phi = houghpattern.getEPhi();
    double r0 = houghpattern.getERPhi();
 
    ATH_MSG_DEBUG("Start Phi hits cleaning with " << size << " hits "
                                                  << " theta " << theta);
    ATH_MSG_DEBUG("Start Phi: " << phi << " r0: " << r0);
    houghpattern.updateParametersRPhi();
    unsigned int newsize = houghpattern.size();
 
    ATH_MSG_VERBOSE("size: " << newsize << " r0: " << r0 << " phi: " << phi);
 
    CxxUtils::sincos scphi(phi);
 
    const int number_of_iterations = 4;
    static constexpr std::array<double, number_of_iterations> cutvalues{1000., 500., 250., 125.};
 
    const MuonHoughPattern* newpattern{&houghpattern};
    std::unique_ptr<MuonHoughPattern> pat_owner{};
    for (int it = 0; it < number_of_iterations; it++) {
        bool change = true;
        while (change) {
            ATH_MSG_VERBOSE("size: " << newsize << " r0: " << r0 << " phi: " << phi);
 
            double max_dist = 0.;
            unsigned int max_i = UINT_MAX;
            for (unsigned int i = 0; i < newpattern->size(); ++i) {
                double dist = newpattern->getHitx(i) * scphi.sn - newpattern->getHity(i) * scphi.cs - r0;
                ATH_MSG_VERBOSE("Dist: " << dist);
                if (dist > max_dist) {
                    max_dist = dist;
                    max_i = i;
                }
            }
            if (max_dist < cutvalues[it]) {
                change = false;
            } else {
                std::unique_ptr<MuonHoughPattern> newpattern2 = std::make_unique<MuonHoughPattern>(MuonHough::hough_xy);
                for (unsigned int i = 0; i < newpattern->size(); ++i) {
                    if (i != max_i) { newpattern2->addHit(newpattern->getHit(i)); }
                }
                newpattern2->updateParametersRPhi();
                phi = newpattern2->getEPhi();
                r0 = newpattern2->getERPhi();
                newsize = newpattern2->size();
                pat_owner = std::move(newpattern2);
                newpattern = pat_owner.get();
                scphi = CxxUtils::sincos(phi);
            }
        }
    }
 
    ATH_MSG_DEBUG("Final size: " << newsize << " r0: " << r0 << " phi: " << phi);
 
    double thetanew = 0.;
    for (unsigned int i = 0; i < newpattern->size(); ++i) {
        double thetah = newpattern->getTheta(i);
        thetanew += thetah;
    }
 
    thetanew = thetanew / (newpattern->size() + 1e-7);
 
    double r0_new = 1.;  // put 1 mm r0 value
    double x0_new = r0_new * scphi.sn;
    double y0_new = -r0_new * scphi.cs;
    double z0_new = 0.;
 
    CxxUtils::sincos sctheta(thetanew);
 
    const Amg::Vector3D pos = Amg::Vector3D(x0_new, y0_new, z0_new);
    const Amg::Vector3D dir = Amg::Vector3D(sctheta.sn * scphi.cs, sctheta.sn * scphi.sn, sctheta.cs);
 
    std::unique_ptr<Muon::MuonPrdPattern> muonpattern = std::make_unique<Muon::MuonPrdPattern>(pos, dir);
 
    for (unsigned int i = 0; i < newpattern->size(); ++i) { muonpattern->addPrd(newpattern->getPrd(i)); }
 
    ATH_MSG_DEBUG("END Clean Phi hits " << newsize << " theta " << thetanew);
 
    ATH_MSG_VERBOSE("cleaned pattern: ");
    if (msgLvl(MSG::VERBOSE)) { printPattern(muonpattern.get()); }
    return muonpattern;
}

houghPatternToEtaPattern()

std::unique_ptr< Muon::MuonPrdPattern > MuonHoughPatternTool::houghPatternToEtaPattern ( const MuonHoughPattern & houghpattern ) const

private

converts hough pattern to EDM eta patterns

Definition at line 976 of file MuonHoughPatternTool.cxx.

                                                                                                                           {
    ATH_MSG_VERBOSE("houghPatternToEtaPattern");
 
    const Amg::Vector3D position = houghpattern.getEPos();
    const Amg::Vector3D direction = houghpattern.getEDir();
 
    double curvature = houghpattern.getECurvature();
    double charge = curvature < 0 ? -1 : 1.;
    double pscale = std::abs(curvature);
 
    const double r0 = m_use_cosmics ? houghpattern.getERPhi() : 0.001;
 
    double x0 = charge * r0 * std::sin(houghpattern.getEPhi());
    double y0 = -charge * r0 * std::cos(houghpattern.getEPhi());
 
    const Amg::Vector3D pos = Amg::Vector3D(x0, y0, position[2]);
    const Amg::Vector3D dir = Amg::Vector3D(pscale * direction[0], pscale * direction[1], pscale * direction[2]);
 
    ATH_MSG_DEBUG("position: " << x0 << " " << y0 << " " << position[2]);
    ATH_MSG_DEBUG("direction: " << direction[0] << " " << direction[1] << " " << direction[2]);
 
    ATH_MSG_DEBUG(" Lift Eta Hough Pattern with charge " << charge << " Curvature " << pscale);
    std::unique_ptr<Muon::MuonPrdPattern> muonpattern = std::make_unique<Muon::MuonPrdPattern>(pos, dir);
 
    for (unsigned int i = 0; i < houghpattern.size(); ++i) { muonpattern->addPrd(houghpattern.getPrd(i)); }
 
    return muonpattern;
}

houghPatternToPhiPattern()

std::unique_ptr< Muon::MuonPrdPattern > MuonHoughPatternTool::houghPatternToPhiPattern ( const MuonHoughPattern & houghpattern ) const

private

converts hough pattern to EDM phi patterns

Definition at line 1004 of file MuonHoughPatternTool.cxx.

                                                                                                                           {
    ATH_MSG_VERBOSE("houghPatternToPhiPattern");
 
    const Amg::Vector3D pos = houghpattern.getEPos();
    const Amg::Vector3D dir = houghpattern.getEDir();
 
    ATH_MSG_DEBUG("position: " << pos[0] << " " << pos[1] << " " << pos[2]);
    ATH_MSG_DEBUG("direction: " << dir[0] << " " << dir[1] << " " << dir[2]);
    std::unique_ptr<Muon::MuonPrdPattern> muonpattern = std::make_unique<Muon::MuonPrdPattern>(pos, dir);
 
    for (unsigned int i = 0; i < houghpattern.size(); ++i) {
        muonpattern->addPrd(houghpattern.getPrd(i));
 
        ATH_MSG_VERBOSE("PrepRawData Added " << houghpattern.getPrd(i));
    }
 
    return muonpattern;
}

initialize()

StatusCode MuonHoughPatternTool::initialize ( )

overridevirtual

initiates private members

Definition at line 152 of file MuonHoughPatternTool.cxx.

                                            {
    if (m_use_histos)  // debug histos
    {
        m_file = std::make_unique<TFile>("HoughPattern.root", "RECREATE");
    }
 
    ATH_MSG_DEBUG("Use Cosmic Settings: " << m_use_cosmics);
 
    if (!m_use_cosmics) {
        // change histogram sizes:
        useIPMuons();
    }
 
    else {
        m_number_of_sectors_xyz = 1;
        m_number_of_sectors_rz = 1;
        // only 1 maximum search (number of sectors ==1):
        m_number_of_maxima = 1;
        // no curved hough for cosmics (muons assumed from ip):
        m_use_curvedhough = false;
    }
 
    ATH_MSG_VERBOSE("Thresholds for histo: xyz: " << m_thresholdhisto_xyz << " rz: " << m_thresholdhisto_rz);
 
    ATH_MSG_VERBOSE("Thresholds for pattern: xyz: " << m_thresholdpattern_xyz << " rz: " << m_thresholdpattern_rz);
 
    ATH_MSG_DEBUG("Number of iterations: " << m_maximum_level << " Maxima per iteration: " << m_number_of_maxima);
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

makePatterns() [1/2]

void MuonHoughPatternTool::makePatterns ( const MuonHoughHitContainer & hitcontainer, MuonHoughPatternContainerShip & houghpatterns ) const

overridevirtual

method that builds the patterns

skip cosmic events that have more than 1000 phi hits

value of mdt weight cut, dependent on # hits in event

Implements IMuonHoughPatternTool.

Definition at line 40 of file MuonHoughPatternTool.cxx.

                                                                                                                                    {
    if (m_use_cosmics && m_maxNumberOfPhiHits >= 0) {
        int phihits{0};
        for (unsigned int hitid = 0; hitid < hitcontainer.size(); ++hitid) { phihits += hitcontainer.getMeasuresPhi(hitid); }
        if (phihits > m_maxNumberOfPhiHits) {
            ATH_MSG_DEBUG("Cosmic event has more than 1000 phi hits: " << phihits << " event is not reconstructed!");
            return;
        }
    }

    double weightmdt{0.};
    if (m_weightcutmdt) { setWeightMdtCutValue(hitcontainer, weightmdt); }
 
    ATH_MSG_DEBUG("Mdt Cut Value: " << weightmdt);
 
    // reset weights, based on rejection factor and weightmdt
    calculateWeights(hitcontainer, weightmdt);
 
    if (msgLevel(MSG::VERBOSE)) {
        ATH_MSG_VERBOSE("Event Info");
        ATH_MSG_VERBOSE("Size: " << hitcontainer.size());
 
        for (unsigned int i = 0; i < hitcontainer.size(); ++i) {
            const std::shared_ptr<MuonHoughHit> hit = hitcontainer.getHit(i);
            ATH_MSG_VERBOSE(hit->getHitx() << " " << hit->getHity() << " " << hit->getHitz() << " " << hit->getMeasuresPhi() << " "
                                           << hit->getWhichDetector() << " " << hit->getProbability() << " " << hit->getWeight() << " "
                                           << hit->getAssociated());
        }
    }
    makePatterns(MuonHough::hough_xy, weightmdt, hitcontainer, houghpattern);
 
    if (m_use_cosmics) {
        makePatterns(MuonHough::hough_rzcosmics, weightmdt, hitcontainer, houghpattern);
    } else if (m_use_curvedhough) {
        makePatterns(MuonHough::hough_curved_at_a_cylinder, weightmdt, hitcontainer, houghpattern);
    } else {
        makePatterns(MuonHough::hough_rz, weightmdt, hitcontainer, houghpattern);
    }
 
    ATH_MSG_VERBOSE("End makePatterns ");
}

makePatterns() [2/2]

void MuonHoughPatternTool::makePatterns ( int id_number, double weightmdt, const MuonHoughHitContainer & event, MuonHoughPatternContainerShip & houghpatterns ) const

private

method that builds the patterns

Definition at line 84 of file MuonHoughPatternTool.cxx.

                                                                                           {
    ATH_MSG_DEBUG("makePatterns");
 
    resetAssociation(event);  // resets association, for hits that are already assigned to pattern in a previous hough
 
    std::unique_ptr<MuonHoughHitContainer> event_for_hough{whichEventHough(id_number, event, weightmdt)};
    std::unique_ptr<MuonHoughHitContainer> event_for_association{whichEventAssociation(id_number, event)};
 
    if (msgLevel(MSG::VERBOSE)) {
        ATH_MSG_VERBOSE("Size event fill: " << event_for_hough->size());
        for (unsigned int i = 0; i < event_for_hough->size(); ++i) {
            const std::shared_ptr<MuonHoughHit> hit = event_for_hough->getHit(i);
            ATH_MSG_VERBOSE(hit->getHitx() << " " << hit->getHity() << " " << hit->getHitz() << " " << hit->getMeasuresPhi() << " "
                                           << hit->getWhichDetector() << " " << hit->getProbability() << " " << hit->getWeight() << " "
                                           << hit->getAssociated());
        }
 
        ATH_MSG_VERBOSE("Size event association: " << event_for_association->size());
        for (unsigned int i = 0; i < event_for_association->size(); ++i) {
            const std::shared_ptr<MuonHoughHit> hit = event_for_association->getHit(i);
            ATH_MSG_VERBOSE(hit->getHitx() << " " << hit->getHity() << " " << hit->getHitz() << " " << hit->getMeasuresPhi() << " "
                                           << hit->getWhichDetector() << " " << hit->getProbability() << " " << hit->getWeight() << " "
                                           << hit->getAssociated());
        }
 
        ATH_MSG_DEBUG("size of event: " << event_for_association->size() << " id_number: " << id_number);
    }
    std::unique_ptr<MuonHoughTransformSteering> houghtransform{whichHoughTransform(id_number)};  // const?
 
    ATH_MSG_DEBUG("HoughTransform chosen");
 
    bool test_for_next_level = true;
 
    for (int level = 0; level < m_maximum_level; level++) {
        if (test_for_next_level) {
            ATH_MSG_DEBUG("Iteration number: " << level);
            
            houghtransform->resetHisto();
            ATH_MSG_DEBUG("fillHistos size hits not in patterns " << event_for_hough->size());
            houghtransform->fill(*event_for_hough);
    
            if (m_use_histos && level == 0 && id_number == MuonHough::hough_curved_at_a_cylinder) {
                const MuonHoughHisto2DContainer& histos = houghtransform->histos();
                TDirectory* dir = gDirectory;
                m_file->cd();
                for (int i = 0; i < histos.size(); ++i) {
                    const std::string hname = "hough_call_" + std::to_string(m_ncalls) + "_hist_" + std::to_string(i);
                    histos.getHisto(i)->bookAndFillRootHistogram(hname)->Write();
                }
                gDirectory = dir;
                ++m_ncalls;
            }
 
            // hitcontainer for association not updated
            test_for_next_level = analyseHisto(id_number, level, event_for_association, houghtransform, houghpattern);
 
            if (test_for_next_level) {
                event_for_hough = whichEventHough(id_number, *event_for_hough, weightmdt);
                ATH_MSG_DEBUG("New event size for transform: " << event_for_hough->size());
            }
        } else {
            break;
        }
    }
 
}  // id_number

maxLevelHoughPattern() [1/2]

std::vector< int > MuonHoughPatternTool::maxLevelHoughPattern ( const MuonHoughPatternContainerShip & houghpattern ) const

private

returns the maximum iteration, not in use

Definition at line 629 of file MuonHoughPatternTool.cxx.

{
    std::vector<int> maxlevel_houghpattern(m_number_of_ids);
 
    for (int id_number = 0; id_number < m_number_of_ids; id_number++) {
        maxlevel_houghpattern[id_number] = maxLevelHoughPattern(houghpattern, id_number);
    }  // number_of_ids
    return maxlevel_houghpattern;
}

maxLevelHoughPattern() [2/2]

int MuonHoughPatternTool::maxLevelHoughPattern ( const MuonHoughPatternContainerShip & houghpattern, int id_number ) const

private

returns the maximum iteration, not in use

Todo

should be in houghpattern?

Definition at line 639 of file MuonHoughPatternTool.cxx.

                                                                                                                     {
    int maxlevel = houghpattern[id_number].size();
    bool continu = true;
    while (maxlevel >= 1 && continu == 1) {
        unsigned int maximum_number = 0;
 
        while (continu && maximum_number < houghpattern[id_number][maxlevel - 1].size())  // m_number_of_maxima)
        {
            ATH_MSG_DEBUG("maximum_number: " << maximum_number << " "
                                             << "maxlevel_houghpattern: " << maxlevel << " id: " << id_number);
            if (!houghpattern[id_number][maxlevel - 1][maximum_number]->empty()) { continu = false; }
 
            ++maximum_number;
 
        }  // number_of_maxima
 
        if (continu) { maxlevel--; }
    }  // while
    return maxlevel;
}  // maxLevelHoughPattern

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

numberOfHits()

int MuonHoughPatternTool::numberOfHits ( const MuonHoughHitContainer & event ) const

private

returns number of hits left (unused)

Definition at line 295 of file MuonHoughPatternTool.cxx.

                                                                               {
    int number_of_hits_left = 0;
    int number_of_hits = event.size();
 
    for (int hitid = 0; hitid < number_of_hits; ++hitid) { number_of_hits_left += !event.getHit(hitid)->getAssociated(); }
 
    // logically impossible --- if (number_of_hits_left <0) {ATH_MSG_WARNING("number of hits smaller than 0");}
 
    ATH_MSG_VERBOSE("numberOfHits left: " << number_of_hits_left);
    ATH_MSG_VERBOSE("number_of_hits: " << number_of_hits);
    return number_of_hits_left;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

overlapHoughPatterns()

int MuonHoughPatternTool::overlapHoughPatterns ( const MuonHoughPattern & houghpattern1, const MuonHoughPattern & houghpattern2 ) const

private

returns number of hits that are in both hough patterns

Definition at line 400 of file MuonHoughPatternTool.cxx.

                                                                                                                                 {
    // both vectors houghpatterns->m_hitid[] are ordered, asked is the percentage of overlap between both vectors
 
    int overlap = 0;
    unsigned int j = 0;
 
    for (unsigned int i = 0; i < houghpattern1.size(); ++i) {
        while (j < houghpattern2.size()) {
            if (houghpattern1.getHitId(i) == houghpattern2.getHitId(j)) {
                ++overlap;
                ++j;  // this j cant be found again
                break;
            }
            if (houghpattern1.getHitId(i) < houghpattern2.getHitId(j)) { break; }
            ++j;
        }
    }
    double percentage1 = (1.0 * overlap) / houghpattern1.size();  // size() gives double
    double percentage2 = (1.0 * overlap) / houghpattern2.size();
 
    ATH_MSG_DEBUG("Percentage Overlap: " << percentage1 << " " << percentage2);
    return overlap;
}

printPattern()

void MuonHoughPatternTool::printPattern ( Muon::MuonPrdPattern * muonpattern ) const

private

print out pattern hits

Definition at line 1450 of file MuonHoughPatternTool.cxx.

                                                                             {
    if (!muonpattern) {
        ATH_MSG_VERBOSE("Printout of Pattern: nullptr");
        return;
    }
    ATH_MSG_VERBOSE("Printout of Pattern: ");
    for (unsigned int k = 0; k < muonpattern->numberOfContainedPrds(); k++) {
        const Trk::PrepRawData* prd = muonpattern->prd(k);
        const Muon::MdtPrepData* mdtprd = dynamic_cast<const Muon::MdtPrepData*>(prd);
        if (mdtprd) {
            const Trk::Surface& surface = mdtprd->detectorElement()->surface(mdtprd->identify());
            const Amg::Vector3D& gpos = surface.center();
            ATH_MSG_VERBOSE("mdt " << k << " x: " << gpos.x() << " y: " << gpos.y() << " z: " << gpos.z());
        } else if (!mdtprd) {
            const Muon::MuonCluster* muoncluster = dynamic_cast<const Muon::MuonCluster*>(prd);
            if (muoncluster) {
                const Amg::Vector3D& gpos = muoncluster->globalPosition();
                ATH_MSG_VERBOSE("cluster " << k << " x: " << gpos.x() << " y: " << gpos.y() << " z: " << gpos.z());
            }
            if (!muoncluster) { ATH_MSG_DEBUG("no muon prd? "); }
        }
    }
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resetAssociation()

void MuonHoughPatternTool::resetAssociation ( const MuonHoughHitContainer & event )

staticprivate

reset association flag of hits in m_event

Definition at line 183 of file MuonHoughPatternTool.cxx.

                                                                              {
    for (unsigned int i = 0; i < event.size(); ++i) {
        std::shared_ptr<MuonHoughHit> hit = event.getHit(i);
        hit->setAssociated(false);
        hit->setId(-1);  // ugly, to be changed?
    }
}

setWeightMdtCutValue()

void MuonHoughPatternTool::setWeightMdtCutValue ( const MuonHoughHitContainer & event, double & weightmdt ) const

private

calculates the mdt weight cut value

Definition at line 1436 of file MuonHoughPatternTool.cxx.

                                                                                                           {
    if (m_use_cosmics) {
        weightmdt = 0.;
        return;
    }
    int mdthits = event.getMDThitno();  // slow function!
    weightmdt = mdthits > 0. ? 1. - 5. / std::sqrt(mdthits) : 0.;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

transformCoordsMaximum()

void MuonHoughPatternTool::transformCoordsMaximum ( std::pair< double, double > & coordsmaximum, double r0_true )

staticprivate

corrects the maximum of the histogram with a factor (not in use anymore, used for old rz transform)

Definition at line 660 of file MuonHoughPatternTool.cxx.

                                                                                                        {
    double z_true = coordsmaximum.first;
    double theta_true = coordsmaximum.second;
 
    //  double theta_cor = - 0.042*(r0_true/4000.)*(r0_true/4000);
    double theta_cor = m_theta_cor_constant * (r0_true / m_theta_cor_constant2) * (r0_true / m_theta_cor_constant2);
 
    //  double z_cor = - 10000 * (std::cos(theta_true) * r0_true/6000.) * (std::cos(theta_true)*r0_true/6000.);
    double z_cor =
        m_z_cor_constant * (std::cos(theta_true) * r0_true / m_z_cor_constant2) * (std::cos(theta_true) * r0_true / m_z_cor_constant2);
 
    double z_rec = z_true + z_cor;
    double theta_rec = theta_true + theta_cor;
 
    if (std::cos(theta_true) < 0) {
        z_rec = z_true - z_cor;
        theta_rec = theta_true - theta_cor;
    }
 
    coordsmaximum.first = z_rec;
    coordsmaximum.second = theta_rec;
}  // transformCoordsMaximum

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

useIPMuons()

void MuonHoughPatternTool::useIPMuons ( )

private

reduces Detector sizes for Hough Histograms to find patterns from muons from the Interaction Point (default on)

Definition at line 33 of file MuonHoughPatternTool.cxx.

                                      {
    m_detectorsize_xy = m_detectorsize_xy_ip;
    m_detectorsize_yz = m_detectorsize_yz_ip;
    m_detectorsize_rz = m_detectorsize_rz_ip;
    m_use_ip = true;
}

weightRescaling()

void MuonHoughPatternTool::weightRescaling ( const MuonHoughHitContainer & event, int id_number, int level ) const

private

rescales hits per iteration to reduce number of patterns when already some have been found

Definition at line 324 of file MuonHoughPatternTool.cxx.

                                                                                                             {
    double weight_trigger_hits = 1.;
    double weight_mdt_hits = 1.;
 
    switch (id_number) {
        case MuonHough::hough_xy:
        case MuonHough::hough_yz:
            weight_trigger_hits = 1 - (level - 1) * (1. / (m_maximum_level + 0.0));  // 1 , 1, 0.8, 0.6 , 0.4
            if (weight_trigger_hits > 1) weight_trigger_hits = 1.;
            weight_mdt_hits = weight_trigger_hits;
            break;
        case MuonHough::hough_rz:
        case MuonHough::hough_rzcosmics:
        case MuonHough::hough_rz_rpc:
        case MuonHough::hough_rz_mdt:
        case MuonHough::hough_curved_at_a_cylinder:
            switch (level) {
                case 0:
                    weight_trigger_hits = 1.;
                    weight_mdt_hits = 1.;
                    break;
                case 1:
                    weight_trigger_hits = 1.;
                    weight_mdt_hits = 1.;
                    break;
                case 2:
                    weight_trigger_hits = 1.;
                    weight_mdt_hits = 0.75;
                    break;
                case 3:
                    weight_trigger_hits = 0.75;
                    weight_mdt_hits = 0.5;
                    break;
                case 4:
                    weight_trigger_hits = 0.5;
                    weight_mdt_hits = 0.25;
                    break;
                default:
                    ATH_MSG_DEBUG("no weight defined for this level");
                    weight_trigger_hits = 0.5;
                    weight_mdt_hits = 0.25;
            }
            break;
        default: ATH_MSG_WARNING("no valid id (id_number)");
    }
 
    for (unsigned int i = 0; i < event.size(); ++i) {
        std::shared_ptr<MuonHoughHit> hit = event.getHit(i);
        MuonHough::DetectorTechnology technology = hit->getDetectorId();
        switch (technology) {
            case MuonHough::CSC:
            case MuonHough::RPC:
            case MuonHough::TGC: hit->setWeight(hit->getOrigWeight() * weight_trigger_hits); break;
            case MuonHough::MDT: hit->setWeight(hit->getOrigWeight() * weight_mdt_hits); break;
            default: ATH_MSG_WARNING("no valid detector technology");
        }
    }
}

whichEventAssociation()

std::unique_ptr< MuonHoughHitContainer > MuonHoughPatternTool::whichEventAssociation ( int id, const MuonHoughHitContainer & event ) const

private

selects the hitcontainer to be used to associate to the maxima

Definition at line 424 of file MuonHoughPatternTool.cxx.

                                                                                                                             {
    std::unique_ptr<MuonHoughHitContainer> event_to_analyse = std::make_unique<MuonHoughHitContainer>();
 
    switch (id_number) {
        case MuonHough::hough_xy:
 
            for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                if (hit->getMeasuresPhi()) {
                    if (m_use_csc_in_pattern || (!m_use_csc_in_pattern && hit->getDetectorId() != MuonHough::CSC)) {
                        event_to_analyse->addHit(hit);
                    }
                }
            }
            break;
        case MuonHough::hough_yz:
            for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                event_to_analyse->addHit(hit);
            }
            break;
        case MuonHough::hough_rz:
        case MuonHough::hough_rzcosmics:
        case MuonHough::hough_curved_at_a_cylinder:
            for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                if (!hit->getMeasuresPhi()) {
                    if (m_use_csc_in_pattern || (!m_use_csc_in_pattern && hit->getDetectorId() != MuonHough::CSC)) {
                        event_to_analyse->addHit(hit);
                    }
                }
            }
            break;
        case MuonHough::hough_rz_rpc:
            if (m_use_rpc_measures_eta == 1) {
                for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                    std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                    if (hit->getDetectorId() == MuonHough::RPC) {
                        if (!hit->getMeasuresPhi()) { event_to_analyse->addHit(hit); }
                    }
                }
            } else {
                for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                    std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                    if (hit->getDetectorId() == MuonHough::RPC) { event_to_analyse->addHit(hit); }
                }
            }
            break;
        case MuonHough::hough_rz_mdt:
            for (unsigned int hitid = 0; hitid < event.size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = event.getHit(hitid);
                if (hit->getDetectorId() == MuonHough::MDT) { event_to_analyse->addHit(hit); }
            }
            break;
        default: ATH_MSG_WARNING(" no valid id");
    }
 
    return event_to_analyse;
}

whichEventHough()

std::unique_ptr< MuonHoughHitContainer > MuonHoughPatternTool::whichEventHough ( int id, const MuonHoughHitContainer & event, double weightmdt ) const

private

selects the hitcontainer to be used for filling the histograms

Definition at line 485 of file MuonHoughPatternTool.cxx.

                                                                                                     {
    ATH_MSG_DEBUG("whichEventHough::size of event: " << event.size());
    std::unique_ptr<MuonHoughHitContainer> hits_not_in_patterns{hitsNotInPattern(event, id_number)};
    ATH_MSG_DEBUG("whichEventHough::hitsNotInPattern: " << hits_not_in_patterns->size());
    std::unique_ptr<MuonHoughHitContainer> event_to_analyse = std::make_unique<MuonHoughHitContainer>();
 
    switch (id_number) {
        case MuonHough::hough_xy:
 
            for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                if (hit->getMeasuresPhi() == 1) {
                    if (hitThroughCut(hit, weightmdt)) {
                        if (m_use_csc_in_hough || (!m_use_csc_in_hough && hit->getDetectorId() == MuonHough::CSC)) {
                            event_to_analyse->addHit(hit);
                        }
                    }
                }
            }
            break;
        case MuonHough::hough_yz:
            for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                if (hitThroughCut(hit, weightmdt)) { event_to_analyse->addHit(hit); }
            }
            break;
        case MuonHough::hough_rz:
        case MuonHough::hough_rzcosmics:
        case MuonHough::hough_curved_at_a_cylinder:
            for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                if (hitThroughCut(hit, weightmdt)) {
                    if (hit->getMeasuresPhi() == 0) {
                        if (m_use_csc_in_hough || (!m_use_csc_in_hough && hit->getDetectorId() == MuonHough::CSC)) {
                            event_to_analyse->addHit(hit);
                        }
                    }
                }
            }
            break;
        case MuonHough::hough_rz_rpc:
            if (m_use_rpc_measures_eta == 1) {
                for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                    if (hits_not_in_patterns->getDetectorId(hitid) == MuonHough::RPC) {
                        std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                        if (hit->getMeasuresPhi() == 0) { event_to_analyse->addHit(hit); }
                    }
                }
            } else {
                for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                    if (hits_not_in_patterns->getDetectorId(hitid) == MuonHough::RPC) {
                        std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                        event_to_analyse->addHit(hit);
                    }
                }
            }
            break;
        case MuonHough::hough_rz_mdt:
            for (unsigned int hitid = 0; hitid < hits_not_in_patterns->size(); ++hitid) {
                if (hits_not_in_patterns->getDetectorId(hitid) == MuonHough::MDT) {
                    std::shared_ptr<MuonHoughHit> hit = hits_not_in_patterns->getHit(hitid);
                    if (hitThroughCut(hit, weightmdt)) { event_to_analyse->addHit(hit); }
                }
            }
            break;
        default: ATH_MSG_WARNING(" no valid id");
    }
 
    return event_to_analyse;
}

whichHoughTransform()

std::unique_ptr< MuonHoughTransformSteering > MuonHoughPatternTool::whichHoughTransform ( int id ) const

private

returns the Houghtransform for the id

Definition at line 557 of file MuonHoughPatternTool.cxx.

                                                                                                       {
    std::unique_ptr<MuonHoughTransformer> houghtransformer;
 
    int nbins = 0;
    int nbins_angle = 0;
    double detectorsize_angle_xy = m_detectorsize_angle_xyz;
    double stepsize_per_angle_xy = m_stepsize_per_angle_xyz;
    double detectorsize_curved = m_nbins_curved / 2.;
    double stepsize_xy = m_stepsize_xy;
    // additional histograms for overlaps:
    int number_of_histos_rz = 2 * m_number_of_sectors_rz;
 
    switch (id_number) {
        case MuonHough::hough_xy:
            if (m_use_cosmics) {
                stepsize_xy = m_stepsize_xy_cosmics;
                stepsize_per_angle_xy = m_stepsize_per_angle_xy_cosmics;
                detectorsize_angle_xy = (m_detectorsize_angle_xyz / 2.);  // patterns not split for cosmics
            }
            nbins = static_cast<int>(2 * m_detectorsize_xy / stepsize_xy);
            nbins_angle = static_cast<int>(detectorsize_angle_xy / stepsize_per_angle_xy);
            houghtransformer = std::make_unique<MuonHoughTransformer_xy>(nbins, nbins_angle, m_detectorsize_xy, detectorsize_angle_xy,
                                                                         m_thresholdhisto_xyz, m_number_of_sectors_xyz);
            break;
 
        case MuonHough::hough_yz:
            nbins = static_cast<int>(2 * m_detectorsize_yz / m_stepsize_yz);
            nbins_angle = static_cast<int>(m_detectorsize_angle_xyz / m_stepsize_per_angle_xyz);
            houghtransformer = std::make_unique<MuonHoughTransformer_yz>(nbins, nbins_angle, m_detectorsize_yz, m_detectorsize_angle_xyz,
                                                                         m_thresholdhisto_xyz, m_number_of_sectors_xyz);
            break;
 
        case MuonHough::hough_rz:
        case MuonHough::hough_rz_rpc:
        case MuonHough::hough_rz_mdt:
            nbins = static_cast<int>(2 * m_detectorsize_rz / m_stepsize_rz);
            nbins_angle = static_cast<int>(m_detectorsize_angle_rz / m_stepsize_per_angle_rz);
            houghtransformer = std::make_unique<MuonHoughTransformer_rz>(nbins, nbins_angle, m_detectorsize_rz, m_detectorsize_angle_rz,
                                                                         m_thresholdhisto_rz, m_number_of_sectors_rz);
            break;
 
        case MuonHough::hough_rzcosmics:
            nbins = static_cast<int>(2 * m_detectorsize_rz / m_stepsize_rz_cosmics);
            nbins_angle = static_cast<int>(m_detectorsize_angle_rz / m_stepsize_per_angle_rz_cosmics);
            houghtransformer = std::make_unique<MuonHoughTransformer_rzcosmics>(
                nbins, nbins_angle, m_detectorsize_rz, m_detectorsize_angle_rz, m_thresholdhisto_rz, m_number_of_sectors_rz_cosmics);
            break;
 
        case MuonHough::hough_curved_at_a_cylinder:
            nbins = m_nbins_curved;
            nbins_angle = static_cast<int>(m_detectorsize_angle_rz / (2 * m_stepsize_per_angle_rz));
            houghtransformer = std::make_unique<MuonHoughTransformer_CurvedAtACylinder>(
                nbins, nbins_angle, detectorsize_curved, m_detectorsize_angle_rz, m_thresholdhisto_rz, number_of_histos_rz);
            break;
 
        default: ATH_MSG_WARNING("no valid id");
    }
 
    if (houghtransformer) {
        houghtransformer->useNegativeWeights(m_use_negative_weights);
        houghtransformer->setIP(!m_use_cosmics);
    }
 
    ATH_MSG_DEBUG("**** histo houghtransformer: ****");
    ATH_MSG_DEBUG("Id number: " << id_number);
    ATH_MSG_DEBUG("NBins: " << nbins << " angle: " << nbins_angle);
    if (m_use_negative_weights) ATH_MSG_DEBUG(" Negative weights are used ");
    ATH_MSG_DEBUG("IP setting: " << !m_use_cosmics);
    ATH_MSG_DEBUG("*********************************");
    return std::make_unique<MuonHoughTransformSteering>(std::move(houghtransformer));
}

Member Data Documentation

m_detectorsize_angle_rz

double MuonHoughPatternTool::m_detectorsize_angle_rz {180.}

staticconstexprprivate

max range of angle in rz in degrees (180)

Definition at line 216 of file MuonHoughPatternTool.h.

{180.};

m_detectorsize_angle_xyz

double MuonHoughPatternTool::m_detectorsize_angle_xyz {360.}

staticconstexprprivate

max range of angle in xyz in degrees (360)

Definition at line 214 of file MuonHoughPatternTool.h.

{360.};

m_detectorsize_rz

double MuonHoughPatternTool::m_detectorsize_rz {0.}

private

acceptancy of patterns in rz (eta) in mm

Definition at line 198 of file MuonHoughPatternTool.h.

{0.};

m_detectorsize_rz_full

double MuonHoughPatternTool::m_detectorsize_rz_full {27750.}

staticconstexprprivate

size of full detector in rz (eta) in mm, used as acceptancy for cosmics

Definition at line 204 of file MuonHoughPatternTool.h.

{27750.};

m_detectorsize_rz_ip

double MuonHoughPatternTool::m_detectorsize_rz_ip {1500.}

staticconstexprprivate

acceptancy of patterns for ip in rz (eta) in mm

Definition at line 211 of file MuonHoughPatternTool.h.

{1500.};

m_detectorsize_xy

double MuonHoughPatternTool::m_detectorsize_xy {0.}

private

acceptancy of patterns in xy (phi) in mm

Definition at line 194 of file MuonHoughPatternTool.h.

{0.};

m_detectorsize_xy_full

double MuonHoughPatternTool::m_detectorsize_xy_full {15000.}

staticconstexprprivate

size of full detector in xy (phi) in mm, used as acceptancy for cosmics

Definition at line 200 of file MuonHoughPatternTool.h.

{15000.};

m_detectorsize_xy_ip

double MuonHoughPatternTool::m_detectorsize_xy_ip {600.}

staticconstexprprivate

acceptancy of patterns for ip in xy (phi) in mm

Definition at line 207 of file MuonHoughPatternTool.h.

{600.};

m_detectorsize_yz

double MuonHoughPatternTool::m_detectorsize_yz {0.}

private

acceptancy of patterns in yz (not used) in mm

Definition at line 196 of file MuonHoughPatternTool.h.

{0.};

m_detectorsize_yz_full

double MuonHoughPatternTool::m_detectorsize_yz_full {25000.}

staticconstexprprivate

size of full detector in yz (not used) in mm, used as acceptancy for cosmics

Definition at line 202 of file MuonHoughPatternTool.h.

{25000.};

m_detectorsize_yz_ip

double MuonHoughPatternTool::m_detectorsize_yz_ip {1000.}

staticconstexprprivate

acceptancy of patterns for ip in yz (not used) in mm

Definition at line 209 of file MuonHoughPatternTool.h.

{1000.};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_file

std::unique_ptr<TFile> MuonHoughPatternTool::m_file

private

pointer to the file name for the hough histograms

Definition at line 131 of file MuonHoughPatternTool.h.

m_maximum_level

int MuonHoughPatternTool::m_maximum_level {5}

staticconstexprprivate

// number of maximum iterations over houghtransform

Definition at line 176 of file MuonHoughPatternTool.h.

{5};

m_maximum_residu_angle

double MuonHoughPatternTool::m_maximum_residu_angle {3.}

staticconstexprprivate

distance hits are associated with pattern in degrees

Definition at line 173 of file MuonHoughPatternTool.h.

{3.};

m_maximum_residu_mm

double MuonHoughPatternTool::m_maximum_residu_mm {500.}

staticconstexprprivate

distance hits are associated with pattern in mm

Definition at line 169 of file MuonHoughPatternTool.h.

{500.};

m_maximum_residu_mm_cosmics

double MuonHoughPatternTool::m_maximum_residu_mm_cosmics {2000.}

staticconstexprprivate

distance hits are associated with pattern in mm for cosmics

Definition at line 171 of file MuonHoughPatternTool.h.

{2000.};

m_maxNumberOfPhiHits

Gaudi::Property<int> MuonHoughPatternTool::m_maxNumberOfPhiHits {this, "MaximumNumberOfPhiHits", -1}

private

maximum number of phi hits to do pattern recognition, if small zero no cut is applied

Definition at line 274 of file MuonHoughPatternTool.h.

{this, "MaximumNumberOfPhiHits", -1};

m_muonhoughmathutils

MuonHoughMathUtils MuonHoughPatternTool::m_muonhoughmathutils

private

object for use of mathematical formulas for trackmodels

Definition at line 133 of file MuonHoughPatternTool.h.

m_nbins_curved

int MuonHoughPatternTool::m_nbins_curved {160}

staticconstexprprivate

bin width for 1/sqrt(curvature)

new curved properties

Definition at line 244 of file MuonHoughPatternTool.h.

{160};

m_ncalls

std::atomic_uint MuonHoughPatternTool::m_ncalls {0}

mutableprivate

Definition at line 271 of file MuonHoughPatternTool.h.

{0};

m_number_of_ids

int MuonHoughPatternTool::m_number_of_ids {7}

private

number of hough transforms currently supported (7)

Definition at line 149 of file MuonHoughPatternTool.h.

{7};

m_number_of_maxima

Gaudi::Property<int> MuonHoughPatternTool::m_number_of_maxima {this, "NumberOfMaximaPerIterations", 5}

private

number of iterations (5)

Definition at line 152 of file MuonHoughPatternTool.h.

{this, "NumberOfMaximaPerIterations", 5};

m_number_of_sectors_rz

Gaudi::Property<int> MuonHoughPatternTool::m_number_of_sectors_rz {this, "SetNumberOfSectorsREta", 16}

private

number of sectors (different regions in which patterns can be found in the same iteration) in rz

Definition at line 264 of file MuonHoughPatternTool.h.

{this, "SetNumberOfSectorsREta", 16};

m_number_of_sectors_rz_cosmics

int MuonHoughPatternTool::m_number_of_sectors_rz_cosmics {12}

private

number of sectors (different regions in which patterns can be found in the same iteration) in rzcosmics

Definition at line 266 of file MuonHoughPatternTool.h.

{12};

m_number_of_sectors_xyz

Gaudi::Property<int> MuonHoughPatternTool::m_number_of_sectors_xyz {this, "SetNumberOfSectorsRPhi", 12}

private

number of sectors (different regions in which patterns can be found in the same iteration) in xyz

Definition at line 262 of file MuonHoughPatternTool.h.

{this, "SetNumberOfSectorsRPhi", 12};

m_printlevel

Gaudi::Property<int> MuonHoughPatternTool::m_printlevel {this, "Printlevel", 0}

private

output level (range 0-10) (default 0)

Definition at line 269 of file MuonHoughPatternTool.h.

{this, "Printlevel", 0};

m_stepsize_per_angle_rz

double MuonHoughPatternTool::m_stepsize_per_angle_rz {0.25}

staticconstexprprivate

bin width for angle in rz

Definition at line 235 of file MuonHoughPatternTool.h.

{0.25};

m_stepsize_per_angle_rz_cosmics

double MuonHoughPatternTool::m_stepsize_per_angle_rz_cosmics {2.}

staticconstexprprivate

bin width for angle in rzcosmics

Definition at line 239 of file MuonHoughPatternTool.h.

{2.};

m_stepsize_per_angle_xy_cosmics

double MuonHoughPatternTool::m_stepsize_per_angle_xy_cosmics {1.}

staticconstexprprivate

bin width for angle in xy cosmics

Definition at line 237 of file MuonHoughPatternTool.h.

{1.};

m_stepsize_per_angle_xyz

double MuonHoughPatternTool::m_stepsize_per_angle_xyz {0.25}

staticconstexprprivate

bin width for angle in xyz

Definition at line 233 of file MuonHoughPatternTool.h.

{0.25};

m_stepsize_rz

double MuonHoughPatternTool::m_stepsize_rz {75.}

staticconstexprprivate

bin width for rz

Definition at line 227 of file MuonHoughPatternTool.h.

{75.};

m_stepsize_rz_cosmics

double MuonHoughPatternTool::m_stepsize_rz_cosmics {150.}

staticconstexprprivate

bin width for rzcosmics

Definition at line 231 of file MuonHoughPatternTool.h.

{150.};

m_stepsize_xy

double MuonHoughPatternTool::m_stepsize_xy {75.}

staticconstexprprivate

max range of 1/sqrt(curvature) for curved transform, corresponds to 0.02 ~ 2,5m ~ 1.6GeV

bin width for xy

Definition at line 223 of file MuonHoughPatternTool.h.

{75.};

m_stepsize_xy_cosmics

double MuonHoughPatternTool::m_stepsize_xy_cosmics {150.}

staticconstexprprivate

bin width for xy cosmics

Definition at line 229 of file MuonHoughPatternTool.h.

{150.};

m_stepsize_yz

double MuonHoughPatternTool::m_stepsize_yz {250.}

staticconstexprprivate

bin width for yz

Definition at line 225 of file MuonHoughPatternTool.h.

{250.};

m_theta_cor_constant

double MuonHoughPatternTool::m_theta_cor_constant {-0.042}

staticconstexprprivate

constant 1 for theta for hough correction

Definition at line 187 of file MuonHoughPatternTool.h.

{-0.042};

m_theta_cor_constant2

double MuonHoughPatternTool::m_theta_cor_constant2 {4000.}

staticconstexprprivate

constant 2 for theta for hough correction

Definition at line 189 of file MuonHoughPatternTool.h.

{4000.};

m_thresholdhisto_rz

Gaudi::Property<double> MuonHoughPatternTool::m_thresholdhisto_rz {this, "SetThresholdHistoREta", 2.1}

private

threshold histogram in rz

Definition at line 259 of file MuonHoughPatternTool.h.

{this, "SetThresholdHistoREta", 2.1};

m_thresholdhisto_xyz

Gaudi::Property<double> MuonHoughPatternTool::m_thresholdhisto_xyz {this, "SetThresholdHistoRPhi", 0.9}

private

threshold histogram in xyz

Definition at line 257 of file MuonHoughPatternTool.h.

{this, "SetThresholdHistoRPhi", 0.9};

m_thresholdpattern_rz

Gaudi::Property<unsigned int> MuonHoughPatternTool::m_thresholdpattern_rz {this, "SetThresholdPatternREta", 3}

private

minimal size for a eta pattern (3)

Definition at line 164 of file MuonHoughPatternTool.h.

{this, "SetThresholdPatternREta", 3};

m_thresholdpattern_xyz

Gaudi::Property<unsigned int> MuonHoughPatternTool::m_thresholdpattern_xyz {this, "SetThresholdPatternRPhi", 1}

private

minimal size for a phi pattern (1)

Definition at line 162 of file MuonHoughPatternTool.h.

{this, "SetThresholdPatternRPhi", 1};

m_use_cosmics

Gaudi::Property<bool> MuonHoughPatternTool::m_use_cosmics {this, "UseCosmics", false}

private

use cosmic settings (false)

Definition at line 138 of file MuonHoughPatternTool.h.

{this, "UseCosmics", false};

m_use_csc_in_hough

Gaudi::Property<bool> MuonHoughPatternTool::m_use_csc_in_hough {this, "UseCscInHough", true}

private

use csc hits in histogram (false)

Definition at line 142 of file MuonHoughPatternTool.h.

{this, "UseCscInHough", true};

m_use_csc_in_pattern

Gaudi::Property<bool> MuonHoughPatternTool::m_use_csc_in_pattern {this, "UseCscInPattern", true}

private

use csc hits in association / pattern (true)

Definition at line 140 of file MuonHoughPatternTool.h.

{this, "UseCscInPattern", true};

m_use_curvedhough

Gaudi::Property<bool> MuonHoughPatternTool::m_use_curvedhough {this, "UseCurvedHough", true}

private

use curved hough transformation for eta patterns (true)

Definition at line 146 of file MuonHoughPatternTool.h.

{this, "UseCurvedHough", true};

m_use_histos

Gaudi::Property<bool> MuonHoughPatternTool::m_use_histos {this, "UseHistos", false}

private

output histograms (false)

Definition at line 136 of file MuonHoughPatternTool.h.

{this, "UseHistos", false};

m_use_ip

bool MuonHoughPatternTool::m_use_ip {false}

private

use interaction point constraint (true)

Definition at line 159 of file MuonHoughPatternTool.h.

{false};

m_use_negative_weights

Gaudi::Property<bool> MuonHoughPatternTool::m_use_negative_weights {this, "UseNegativeWeights", false}

private

use negative weights (false)

Definition at line 144 of file MuonHoughPatternTool.h.

{this, "UseNegativeWeights", false};

m_use_rpc_measures_eta

bool MuonHoughPatternTool::m_use_rpc_measures_eta {true}

staticconstexprprivate

use rpc phi strips in phi-patterns (true)

use rpc eta strips in eta-patterns (true)

Definition at line 157 of file MuonHoughPatternTool.h.

{true};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_weight

Gaudi::Property<double> MuonHoughPatternTool::m_weight {this, "WeightCut", 0.25}

private

value of weight cut

Definition at line 250 of file MuonHoughPatternTool.h.

{this, "WeightCut", 0.25};  // cut all hits under 0.25

m_weightcut

Gaudi::Property<bool> MuonHoughPatternTool::m_weightcut {this, "ApplyWeightCut", true}

private

weight_cut for hits in hough

Definition at line 247 of file MuonHoughPatternTool.h.

{this, "ApplyWeightCut", true};

m_weightcutmdt

Gaudi::Property<bool> MuonHoughPatternTool::m_weightcutmdt

private

Initial value:

{this, "ApplyWeightCutMdt",
                                         true}

weight_cut for mdt hits in hough

Definition at line 253 of file MuonHoughPatternTool.h.

                                      {this, "ApplyWeightCutMdt",
                                         true};  // cut all mdt hits under a certain weight (dependent on number of mdt hits in event

m_z_cor_constant

double MuonHoughPatternTool::m_z_cor_constant {-10000.}

staticconstexprprivate

use hough correction to correct the maximum found in rz-plane slightly as there is a bias in the houghtransform

constant 1 for z for hough correction

Definition at line 183 of file MuonHoughPatternTool.h.

{-10000.};

m_z_cor_constant2

double MuonHoughPatternTool::m_z_cor_constant2 {6000.}

staticconstexprprivate

constant 2 for z for hough correction

Definition at line 185 of file MuonHoughPatternTool.h.

{6000.};

---

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

• MuonHoughPatternTool.h
• MuonHoughPatternTool.cxx