#include <UTPCMMClusterBuilderTool.h>

Inheritance diagram for Muon::UTPCMMClusterBuilderTool:

Collaboration diagram for Muon::UTPCMMClusterBuilderTool:

Public Types
using	RIO_Author = MMClusterOnTrack::Author
	Refinement of the cluster position after the cluster calibration loop is ran with a complete external constraint (e.g. More...

Public Member Functions
	UTPCMMClusterBuilderTool (const std::string &, const std::string &, const IInterface *)
	Default constructor. More...

virtual	~UTPCMMClusterBuilderTool ()=default
	Default destructor. More...

virtual StatusCode	initialize () override
	standard initialize method More...

virtual StatusCode	getClusters (const EventContext &ctx, std::vector< Muon::MMPrepData > &&stripsVect, std::vector< std::unique_ptr< Muon::MMPrepData >> &clustersVect) const override
	Standard Interface to produce Micromega clusters from raw Input hits without external contstaint. More...

virtual RIO_Author	getCalibratedClusterPosition (const EventContext &ctx, const std::vector< NSWCalib::CalibratedStrip > &calibratedStrips, const Amg::Vector3D &directionEstimate, Amg::Vector2D &clusterLocalPosition, Amg::MatrixX &covMatrix) const override

	DeclareInterfaceID (Muon::IMMClusterBuilderTool, 1, 0)

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
using	LaySortedPrds = std::array< std::vector< Muon::MMPrepData >, 8 >

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	runHoughTrafo (const std::vector< Muon::MMPrepData > &mmPrd, std::vector< double > &xpos, std::vector< int > &flag, std::vector< int > &idx_selected) const

StatusCode	fillHoughTrafo (const std::vector< Muon::MMPrepData > &mmPrd, std::vector< double > &xpos, std::vector< int > &flag, std::unique_ptr< TH2D > &h_hough) const

StatusCode	houghInitCummulator (std::unique_ptr< TH2D > &cummulator, double xmax, double xmin) const

StatusCode	findAlphaMax (std::unique_ptr< TH2D > &h_hough, std::vector< std::tuple< double, double >> &maxPos) const

StatusCode	selectTrack (const std::vector< Muon::MMPrepData > &mmPrd, std::vector< double > &xpos, std::vector< int > &flag, std::vector< std::tuple< double, double >> &tracks, std::vector< int > &idxGoodStrips) const

StatusCode	transformParameters (double alpha, double d, double dRMS, double &slope, double &intercept, double &interceptRMS) const

StatusCode	applyCrossTalkCut (std::vector< int > &idxSelected, const std::vector< MMPrepData > &MMPrdsOfLayer, std::vector< int > &flag, int &nStripsCut) const

StatusCode	finalFit (const std::vector< Identifier > &ids, const std::vector< float > &stripsPos, const std::vector< float > &driftDists, const std::vector< AmgVector(2)> &driftDistErrors, double &x0, double &sigmaX0, double &fitAngle, double &chiSqProb) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Muon Detector Descriptor. More...

Gaudi::Property< bool >	m_writeStripProperties {this, "writeStripProperties", true }

Gaudi::Property< double >	m_alphaMin {this, "HoughAlphaMin", -90. }

Gaudi::Property< double >	m_alphaMax {this, "HoughAlphaMax", 0. }

Gaudi::Property< double >	m_alphaResolution {this, "HoughAlphaResolution", 1.}

Gaudi::Property< double >	m_selectionCut {this, "HoughSelectionCut", 1. * Gaudi::Units::mm}

Gaudi::Property< double >	m_dMin {this, "HoughDMin", 0.}

Gaudi::Property< double >	m_dMax {this, "HoughDMax", 0.}

Gaudi::Property< double >	m_dResolution {this, "HoughDResolution", 0.125}

Gaudi::Property< double >	m_driftRange {this, "HoughExpectedDriftRange", 12.*Gaudi::Units::m}

Gaudi::Property< unsigned >	m_houghMinCounts {this, "HoughMinCounts", 3}

Gaudi::Property< double >	m_outerChargeRatioCut {this,"outerChargeRatioCut", 0.}
	charge ratio cut to supress cross talk More...

Gaudi::Property< int >	m_maxStripsCut {this, "maxStripRemove", 4}

Gaudi::Property< bool >	m_digiHasNegativeAngles {this, "digiHasNegativeAngle", true}

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 27 of file UTPCMMClusterBuilderTool.h.

Member Typedef Documentation

◆ LaySortedPrds

using Muon::UTPCMMClusterBuilderTool::LaySortedPrds = std::array<std::vector<Muon::MMPrepData>, 8>

private

Definition at line 49 of file UTPCMMClusterBuilderTool.h.

◆ RIO_Author

using Muon::IMMClusterBuilderTool::RIO_Author = MMClusterOnTrack::Author

inherited

Refinement of the cluster position after the cluster calibration loop is ran with a complete external constraint (e.g.

from the track fit). The cluster local position and the associated covariance are updated during this procedure Returns the Author of the ClusterBuilderTool, in case that the calibrated strip passes all internal constraints of the ClusterBuilder, otherwise Unknown author is returned. In the latter case, the Cluster should not be transformed into a calibrated RIO object.

Parameters

ctx	EventContext used for StoreGate access
calibratedStrips	Cluster constitutents after the calibration stage
directionEstimate	Estimate of the direction given in the local frame
clusterLocalPosition	Vector to which the final cluster position is saved to
covMatrix	Uncertainty associated with the local position

Definition at line 48 of file IMMClusterBuilderTool.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ UTPCMMClusterBuilderTool()

Muon::UTPCMMClusterBuilderTool::UTPCMMClusterBuilderTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Default constructor.

Definition at line 30 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                               :
     AthAlgTool(t, n, p) {
     declareInterface<IMMClusterBuilderTool>(this);
 }

◆ ~UTPCMMClusterBuilderTool()

virtual Muon::UTPCMMClusterBuilderTool::~UTPCMMClusterBuilderTool ( )

virtualdefault

Default destructor.

Member Function Documentation

◆ applyCrossTalkCut()

StatusCode Muon::UTPCMMClusterBuilderTool::applyCrossTalkCut	(	std::vector< int > &	idxSelected,
		const std::vector< MMPrepData > &	MMPrdsOfLayer,
		std::vector< int > &	flag,
		int &	nStripsCut
	)		const

private

Definition at line 348 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                           {
     int N = idxSelected.size();
     bool removedStrip = false;
     ATH_MSG_DEBUG("starting to remove cross talk strips " << idxSelected << " flag " << flag);
     if (N < 3 || nStripsCut >= m_maxStripsCut) {
         ATH_MSG_DEBUG("first cut failed");
         return StatusCode::FAILURE;
     }
     // reject outer strip for fit if charge ratio to second outer strip indicates strip charge is created by crosstalk only
     double ratioLastStrip = 1.0 * MMPrdsOfLayer.at(idxSelected.at(N - 1)).charge() / MMPrdsOfLayer.at(idxSelected.at(N - 2)).charge();
     double ratioFirstStrip = 1.0 * MMPrdsOfLayer.at(idxSelected.at(0)).charge() / MMPrdsOfLayer.at(idxSelected.at(1)).charge();
     ATH_MSG_DEBUG("ratioLastStrip " << ratioLastStrip << " ratioFirstStrip " << ratioFirstStrip);
     if (ratioLastStrip < m_outerChargeRatioCut) {
         flag.at(idxSelected.at(N - 1)) = 2;
         idxSelected.erase(idxSelected.begin() + (N - 1));
         removedStrip = true;
         nStripsCut++;
         ATH_MSG_DEBUG("cutting last strip nStripCuts: " << nStripsCut << " flag " << flag << " idxSelected " << idxSelected);
     }
     if (idxSelected.size() < 3 || nStripsCut >= m_maxStripsCut) {
         ATH_MSG_DEBUG("first cut failed");
         return StatusCode::FAILURE;
     }
  
     if (ratioFirstStrip < m_outerChargeRatioCut) {
         flag.at(idxSelected.at(0)) = 2;
         idxSelected.erase(idxSelected.begin() + 0);
         removedStrip = true;
         nStripsCut++;
         ATH_MSG_DEBUG("cutting first strip nStripCuts: " << nStripsCut << " flag " << flag << " idxSelected " << idxSelected);
     }
     if (nStripsCut >= m_maxStripsCut) {
         ATH_MSG_DEBUG("first cut failed");
         return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("return value " << (!removedStrip ? "FAILURE" : "SUCCESS"));
     return (!removedStrip ? StatusCode::FAILURE : StatusCode::SUCCESS);  // return success if at least one strip was removed
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ DeclareInterfaceID()

Muon::IMMClusterBuilderTool::DeclareInterfaceID	(	Muon::IMMClusterBuilderTool	,
		1	,
		0
	)

inherited

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ fillHoughTrafo()

StatusCode Muon::UTPCMMClusterBuilderTool::fillHoughTrafo	(	const std::vector< Muon::MMPrepData > &	mmPrd,
		std::vector< double > &	xpos,
		std::vector< int > &	flag,
		std::unique_ptr< TH2D > &	h_hough
	)		const

private

Definition at line 242 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                                     {
     for (size_t i_hit = 0; i_hit < mmPrd.size(); i_hit++) {
         if (flag.at(i_hit) != 0) continue;  // skip hits which have been already used or been rejected as cross talk
         for (int i_alpha = 1; i_alpha < h_hough->GetNbinsX(); i_alpha++) {
             double alpha = h_hough->GetXaxis()->GetBinCenter(i_alpha);
             double d = xpos.at(i_hit) * std::cos(alpha) - mmPrd.at(i_hit).driftDist() * std::sin(alpha);
             ATH_MSG_VERBOSE("Fill Hough alpha: " << alpha << " d " << d << " x " << xpos.at(i_hit) << " y " << mmPrd.at(i_hit).driftDist());
             h_hough->Fill(alpha, d);
         }
     }
     return StatusCode::SUCCESS;
 }

◆ finalFit()

StatusCode Muon::UTPCMMClusterBuilderTool::finalFit	(	const std::vector< Identifier > &	ids,
		const std::vector< float > &	stripsPos,
		const std::vector< float > &	driftDists,
		const std::vector< AmgVector(2)> &	driftDistErrors,
		double &	x0,
		double &	sigmaX0,
		double &	fitAngle,
		double &	chiSqProb
	)		const

private

Definition at line 388 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                                             {
     std::unique_ptr<TGraphErrors> fitGraph = std::make_unique<TGraphErrors>();
     std::unique_ptr<TF1> ffit = std::make_unique<TF1>("ffit", "pol1");
  
     double xmin = 5000;
     double xmax = -5000;
     double xmean = std::accumulate(stripsPos.begin(), stripsPos.end(), 0.0) / stripsPos.size();  // get mean x value
  
     std::unique_ptr<TLinearFitter> lf = std::make_unique<TLinearFitter>(1, "1++x");
  
     for (size_t idx = 0; idx < stripsPos.size(); idx++) {
         double xpos = stripsPos.at(idx) - xmean;  // substract mean value from x to center fit around 0
         if (xmin > xpos)
             xmin = xpos;
         else if (xmax < xpos)
             xmax = xpos;
         lf->AddPoint(&xpos, driftDists.at(idx));
         fitGraph->SetPoint(fitGraph->GetN(), xpos, driftDists.at(idx));
         fitGraph->SetPointError(fitGraph->GetN() - 1, std::sqrt(driftDistErrors.at(idx)[0]), std::sqrt(driftDistErrors.at(idx)[1]));
     }
     lf->Eval();
  
     if (m_idHelperSvc->mmIdHelper().gasGap(ids.at(0)) % 2 == 1 || !m_digiHasNegativeAngles) {
         ffit->SetParLimits(1, -11.5, -0.15);  // 5 to 81 degree
     } else {
         ffit->SetParLimits(1, 0.15, 11.5);  // 5 to 81 degree
     }
     ffit->SetParameters(lf->GetParameter(0), lf->GetParameter(1));
     TFitResultPtr s = fitGraph->Fit("ffit", "SMQ", "", xmin - .5, xmax + .5);
  
     double cov = (s->GetCovarianceMatrix())(0, 1);
     ATH_MSG_DEBUG("covariance is: " << cov);
     double fitSlope = ffit->GetParameter(1);
     double dHalfGap = 2.52;  // half the thickness of the gas gap
     double interceptCorr = dHalfGap - ffit->GetParameter(0);
     x0 = interceptCorr / fitSlope;
     sigmaX0 =       
         (std::pow(ffit->GetParError(0) / interceptCorr, 2) + std::pow(ffit->GetParError(1) / fitSlope, 2) - 2. / (fitSlope * interceptCorr) * cov) *
         std::pow(x0, 2);
     x0 += xmean;  // adding back mean value after error was calculated
     fitAngle = std::tan(-1 / fitSlope);
     chiSqProb = ffit->GetProb();
  
     {
         ATH_MSG_DEBUG("==========uTPC fit Summary==============");
  
         ATH_MSG_DEBUG("Fit slope: " << ffit->GetParameter(1));
  
         ATH_MSG_DEBUG("Fit intercept:" << ffit->GetParameter(0));
  
         ATH_MSG_DEBUG("Fit status: " << s);
  
         ATH_MSG_DEBUG("Cluster position " << x0 << " +- " << sigmaX0);
  
         ATH_MSG_DEBUG("Fit angle: " << fitAngle << " " << fitAngle * 180. / M_PI);
  
         ATH_MSG_DEBUG("ChisSqProb" << chiSqProb);
         ATH_MSG_DEBUG("nStrips:" << stripsPos.size());
         ATH_MSG_DEBUG("gas gap:" << m_idHelperSvc->mmIdHelper().gasGap(ids.at(0)));
     }
     if (s != 0 && s != 4000) {  // 4000 means fit succesfull but error optimization by minos failed; fit is still usable.
         ATH_MSG_DEBUG("Final fit failed with error code " << s);
         return StatusCode::FAILURE;
     }
     if ((m_idHelperSvc->mmIdHelper().gasGap(ids.at(0)) % 2 == 1 || !m_digiHasNegativeAngles) &&
         (ffit->GetParameter(1) <= -11.49 || ffit->GetParameter(1) >= -0.151))
         return StatusCode::FAILURE;  // fit should have negativ slope for odd gas gaps
     if (m_idHelperSvc->mmIdHelper().gasGap(ids.at(0)) % 2 == 0 && m_digiHasNegativeAngles &&
         (ffit->GetParameter(1) >= 11.49 || ffit->GetParameter(1) <= 0.151))
         return StatusCode::FAILURE;  // fit should have positiv slope for even gas gaps
     return StatusCode::SUCCESS;
 }

◆ findAlphaMax()

StatusCode Muon::UTPCMMClusterBuilderTool::findAlphaMax	(	std::unique_ptr< TH2D > &	h_hough,
		std::vector< std::tuple< double, double >> &	maxPos
	)		const

private

Definition at line 256 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                            {
     unsigned int cmax = h_hough->GetMaximum();
     if (cmax < m_houghMinCounts) {
         ATH_MSG_DEBUG("cmax " << cmax << "smaller then m_houghMinCounts " << m_houghMinCounts);
         return StatusCode::FAILURE;
     }
  
     for (int i_binX = 0; i_binX <= h_hough->GetNbinsX(); i_binX++) {
         for (int i_binY = 0; i_binY <= h_hough->GetNbinsY(); i_binY++) {
             if (h_hough->GetBinContent(i_binX, i_binY) == cmax) {
                 ATH_MSG_DEBUG("Find Max Alpha: BinX "
                               << i_binX << " Alpha: " << h_hough->GetXaxis()->GetBinCenter(i_binX) / Gaudi::Units::degree
                               << " BinY: " << i_binY << " over threshold: " << h_hough->GetBinContent(i_binX, i_binY));
                 maxPos.emplace_back(h_hough->GetXaxis()->GetBinCenter(i_binX), h_hough->GetYaxis()->GetBinCenter(i_binY));
             }
         }
     }
     return StatusCode::SUCCESS;
 }

◆ getCalibratedClusterPosition()

RIO_Author Muon::UTPCMMClusterBuilderTool::getCalibratedClusterPosition	(	const EventContext &	ctx,
		const std::vector< NSWCalib::CalibratedStrip > &	calibratedStrips,
		const Amg::Vector3D &	directionEstimate,
		Amg::Vector2D &	clusterLocalPosition,
		Amg::MatrixX &	covMatrix
	)		const

overridevirtual

Implements Muon::IMMClusterBuilderTool.

Definition at line 463 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                {
  
     std::vector<Identifier> ids;
     std::vector<float> stripsPos;
     std::vector<float> driftDists;
     std::vector<AmgVector(2)> driftDistErrors;
  
     for (const NSWCalib::CalibratedStrip& strip : calibratedStrips) {
         ids.push_back(strip.identifier);
         stripsPos.push_back(strip.locPos.x());
         driftDists.push_back(strip.distDrift);
         driftDistErrors.emplace_back(strip.resTransDistDrift, strip.resLongDistDrift);
     }
  
     double localClusterPosition = -9999;
     double sigmaLocalClusterPosition = 0;
     double finalFitAngle, finalFitChiSqProb;
  
     StatusCode sc = finalFit(ids, stripsPos, driftDists, driftDistErrors, localClusterPosition, sigmaLocalClusterPosition, finalFitAngle,
                              finalFitChiSqProb);
     if (sc == StatusCode::FAILURE) return RIO_Author::unKnownAuthor;
  
     clusterLocalPosition[Trk::locX] = localClusterPosition;
  
     Amg::MatrixX covN(1, 1);
     covN.coeffRef(0, 0) = sigmaLocalClusterPosition;
     covMatrix = covN;
     return RIO_Author::uTPCClusterBuilder;
 }

◆ getClusters()

StatusCode Muon::UTPCMMClusterBuilderTool::getClusters	(	const EventContext &	ctx,
		std::vector< Muon::MMPrepData > &&	stripsVect,
		std::vector< std::unique_ptr< Muon::MMPrepData >> &	clustersVect
	)		const

overridevirtual

Standard Interface to produce Micromega clusters from raw Input hits without external contstaint.

Executes the clusterization algorithm & fills the results in the clusterVect Returns a failure in case of conditions or unexpected problems

Parameters

ctx	EventContext used for StoreGate access
stripsVect	Vector of the single Micromega hits.
clusterVect	Output vector of the merged clusters

Implements Muon::IMMClusterBuilderTool.

Definition at line 40 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                                   {
     
     LaySortedPrds MMprdsPerLayer{};
     for (MMPrepData& MMprd : MMprds) {
         Identifier id = MMprd.identify();
         int layer = 4 * (m_idHelperSvc->mmIdHelper().multilayer(id) - 1) + (m_idHelperSvc->mmIdHelper().gasGap(id) - 1);
         ATH_MSG_DEBUG("Sorting PRD into layer layer: " << layer << " gas_gap " << m_idHelperSvc->mmIdHelper().gasGap(id) << "multilayer "
                                                        << m_idHelperSvc->mmIdHelper().multilayer(id));
         MMprdsPerLayer.at(layer).push_back(std::move(MMprd));
     }
  
     // sort MMPrds by channel
     for (std::vector<MMPrepData>& prdInLay :  MMprdsPerLayer) {
         std::sort(prdInLay.begin(), prdInLay.end(), [this](const MMPrepData& a, const MMPrepData& b) {
             return m_idHelperSvc->mmIdHelper().channel(a.identify()) < m_idHelperSvc->mmIdHelper().channel(b.identify());
         });
     }
  
     for (std::vector<MMPrepData>& MMprdsOfLayer : MMprdsPerLayer) {
         std::vector<double> stripsLocalPosX;
         stripsLocalPosX.reserve(MMprdsOfLayer.size());
  
         for (MMPrepData& MMprd : MMprdsOfLayer) {
             Identifier id_prd = MMprd.identify();
             int gasGap = m_idHelperSvc->mmIdHelper().gasGap(id_prd);
             stripsLocalPosX.push_back(
                 ((gasGap % 2 == 0 && m_digiHasNegativeAngles) ? -1 : 1) *
                 MMprd.localPosition().x());  // flip local positions for even gas gaps to reduce hough space to positiv angles
  
             // determine angle to IP for debug reasons
             double globalR = MMprd.globalPosition().perp();
             double Tan = globalR / MMprd.globalPosition().z();
             double angleToIp = std::atan(Tan) / Gaudi::Units::degree;
  
             ATH_MSG_DEBUG("Hit channel: " << m_idHelperSvc->toString(id_prd) << " time " << MMprd.time() << " drift dist "
                                           << MMprd.driftDist() << " localPosX " <<Amg::toString(MMprd.localPosition()) 
                                           << " angleToIp " << angleToIp);
         }
         if (MMprdsOfLayer.size() < 2) continue;
  
         // move hits to the origin of the coordinate system to exclude extrapolation error and to keep the size of the hough space small
         double meanX = std::accumulate(stripsLocalPosX.begin(), stripsLocalPosX.end(), 0.0) / stripsLocalPosX.size();
         ATH_MSG_DEBUG("Got mean element " << meanX);
         std::for_each(stripsLocalPosX.begin(), stripsLocalPosX.end(), [meanX](double& d) { d -= meanX; });
         ATH_MSG_VERBOSE(stripsLocalPosX);
  
         // vector of 0s, ones and twos to indicate if strip was already used (0=unused;1=used;2=rejected as cross talk)
         std::vector<int> flag = std::vector<int>(MMprdsOfLayer.size(), 0);
  
         while (true) {
             ATH_MSG_DEBUG("while true");
             std::vector<int> idx_goodStrips;
             StatusCode sc = runHoughTrafo(MMprdsOfLayer, stripsLocalPosX, flag, idx_goodStrips);
  
             ATH_MSG_DEBUG("Hough done");
             // if(sc.isFailure()) break;
             if (idx_goodStrips.size() < 3 || sc.isFailure()) {
                 // break; // should be already catched in runHough but for safety once more here
                 idx_goodStrips.clear();
                 for (size_t i_hit = 0; i_hit < MMprdsOfLayer.size(); i_hit++) {
                     if (flag.at(i_hit) == 0) idx_goodStrips.push_back(i_hit);
                 }
                 ATH_MSG_DEBUG("Hough Trafo failed, try to fit everything");
             }
  
             // remove strips induced by crosstalk till no more strip was removed
             int nStripsCutByCrosstalk = 0;
             while (!applyCrossTalkCut(idx_goodStrips, MMprdsOfLayer, flag, nStripsCutByCrosstalk).isFailure()) {}
             ATH_MSG_DEBUG("After cutting CT idx_goddStrips " << idx_goodStrips << " flag " << flag);
  
             std::vector<Identifier> stripsOfCluster;
             std::vector<uint16_t> stripsOfClusterChannels;
             std::vector<short int> stripsOfClusterTimes;
             std::vector<int> stripsOfClusterCharges;
             std::vector<float> stripsOfClusterDriftDists;
             std::vector<AmgVector(2)> stripsOfClusterDriftDistErrors;
             std::vector<float> stripsOfClusterLocalPos;  // needed for the final fit function
             stripsOfCluster.reserve(idx_goodStrips.size());
             if (m_writeStripProperties) { stripsOfClusterChannels.reserve(idx_goodStrips.size()); }
             stripsOfClusterTimes.reserve(idx_goodStrips.size());
             stripsOfClusterCharges.reserve(idx_goodStrips.size());
             stripsOfClusterDriftDists.reserve(idx_goodStrips.size());
             stripsOfClusterDriftDistErrors.reserve(idx_goodStrips.size());
             stripsOfClusterLocalPos.reserve(idx_goodStrips.size());
  
             ATH_MSG_DEBUG("Found good Strips: " << idx_goodStrips.size());
  
             for (int idx : idx_goodStrips) {
                 ATH_MSG_DEBUG("Setting good strip: " << idx << " size of strips flag: " << flag.size());
                 flag.at(idx) = 1;
                 ATH_MSG_DEBUG("Set Good strips");
                 stripsOfCluster.push_back(MMprdsOfLayer.at(idx).identify());
                 if (m_writeStripProperties) {
                     stripsOfClusterChannels.push_back(m_idHelperSvc->mmIdHelper().channel(MMprdsOfLayer.at(idx).identify()));
                     stripsOfClusterTimes.push_back(MMprdsOfLayer.at(idx).time());
                     stripsOfClusterCharges.push_back(MMprdsOfLayer.at(idx).charge());
                 }
                 stripsOfClusterDriftDists.push_back(MMprdsOfLayer.at(idx).driftDist());
                 const Amg::MatrixX cov{MMprdsOfLayer.at(idx).localCovariance()};
                 stripsOfClusterDriftDistErrors.emplace_back(cov(0,0), cov(1,1));
                 stripsOfClusterLocalPos.push_back(MMprdsOfLayer.at(idx).localPosition().x());
             }
  
             double localClusterPosition = -9999;
             double sigmaLocalClusterPosition = 0;
             double finalFitAngle, finalFitChiSqProb;
  
             sc = finalFit(stripsOfCluster, stripsOfClusterLocalPos, stripsOfClusterDriftDists, stripsOfClusterDriftDistErrors,
                           localClusterPosition, sigmaLocalClusterPosition, finalFitAngle, finalFitChiSqProb);
  
             ATH_MSG_DEBUG("final fit done");
  
             if (sc.isFailure()) break;
             ATH_MSG_DEBUG("Did final fit successfull");
  
             auto covN = Amg::MatrixX(1, 1);
             covN.coeffRef(0, 0) = sigmaLocalClusterPosition;
             ATH_MSG_DEBUG("Did set covN Matrix");
             int idx = idx_goodStrips[0];
             ATH_MSG_DEBUG("idx_goodStrips[0]: " << idx << " size: " << MMprdsOfLayer.size());
             Amg::Vector2D localClusterPositionV(localClusterPosition,
                                                 MMprdsOfLayer.at(idx).localPosition().y());  // y position is the same for all strips
             ATH_MSG_DEBUG("Did set local position");
  
             float driftDist = 0.0;
  
             std::unique_ptr<MMPrepData> prdN = std::make_unique<MMPrepData>(MMprdsOfLayer.at(idx).identify(), 
                                                                             MMprdsOfLayer.at(idx).collectionHash(), 
                                                                             std::move(localClusterPositionV), 
                                                                             std::move(stripsOfCluster),
                                                                             std::move(covN), 
                                                                             MMprdsOfLayer.at(idx).detectorElement(), 
                                                                             0,
                                                                             std::accumulate(stripsOfClusterCharges.begin(), stripsOfClusterCharges.end(), 0), 
                                                                             driftDist, 
                                                                             std::move(stripsOfClusterChannels),
                                                                             std::move(stripsOfClusterTimes), 
                                                                             std::move(stripsOfClusterCharges));
  
             ATH_MSG_DEBUG("Did create new prd");
  
             ATH_MSG_DEBUG("Setting prd angle: " << finalFitAngle << " chi2 Prob: " << finalFitChiSqProb);
  
             prdN->setAuthor(MMPrepData::Author::uTPCClusterBuilder);
             prdN->setDriftDist(std::move(stripsOfClusterDriftDists), std::move(stripsOfClusterDriftDistErrors));
  
             prdN->setMicroTPC(finalFitAngle, finalFitChiSqProb);
             ATH_MSG_DEBUG("Reading back prd angle: " << prdN->angle() << " chi2 Prob: " << prdN->chisqProb());
             clustersVect.push_back(std::move(prdN));
             ATH_MSG_DEBUG("pushedBack  prdN");
             int leftOverStrips = 0;
             for (auto f : flag) {
                 if (f == 0) leftOverStrips++;
             }
             if (leftOverStrips < 3) break;
         }
         ATH_MSG_DEBUG("End of get clusters layer");
     }
     ATH_MSG_DEBUG("End of get clusters");
     return StatusCode::SUCCESS;
 }

◆ houghInitCummulator()

StatusCode Muon::UTPCMMClusterBuilderTool::houghInitCummulator	(	std::unique_ptr< TH2D > &	cummulator,
		double	xmax,
		double	xmin
	)		const

private

Definition at line 225 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                                      {
     ATH_MSG_VERBOSE("xmax: " << xmax << " xmin: " << xmin << " m_dResolution " << m_dResolution << " m_alphaMin " << m_alphaMin
                              << " m_alphaMax: " << m_alphaMax << " m_alphaResolution: " << m_alphaResolution);
     double dmax = std::max(std::fabs(xmin), std::fabs(xmax));
     dmax = std::sqrt(std::pow(dmax, 2) +
                      std::pow(m_driftRange, 2));  // rspace =sqrt(xmax*xmax+driftrange*driftrange) where driftrange is assumed to be 6mm
     int nbinsd = static_cast<int>(1.0 * dmax * 2 / m_dResolution);
     int nbinsa = static_cast<int>((1.0 * m_alphaMax - m_alphaMin) / m_alphaResolution);
  
     ATH_MSG_VERBOSE("Hough Using nBinsA " << nbinsa << " nBinsd " << nbinsd << " dmax " << dmax);
  
     h_hough = std::make_unique<TH2D>("h_hough", "h_hough", nbinsa, m_alphaMin * Gaudi::Units::degree, m_alphaMax * Gaudi::Units::degree,
                                      nbinsd, -dmax, dmax);
  
     return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode Muon::UTPCMMClusterBuilderTool::initialize ( )

overridevirtual

standard initialize method

Definition at line 35 of file UTPCMMClusterBuilderTool.cxx.

                                                 {
     ATH_CHECK(m_idHelperSvc.retrieve());
     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.

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ 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.

◆ 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();
   }

◆ runHoughTrafo()

StatusCode Muon::UTPCMMClusterBuilderTool::runHoughTrafo	(	const std::vector< Muon::MMPrepData > &	mmPrd,
		std::vector< double > &	xpos,
		std::vector< int > &	flag,
		std::vector< int > &	idx_selected
	)		const

private

Definition at line 204 of file UTPCMMClusterBuilderTool.cxx.

                                                                                                                    {
     ATH_MSG_DEBUG("beginning of runHoughTrafo() with: " << xpos.size() << " hits");
     double maxX = *std::max_element(xpos.begin(), xpos.end());
     double minX = *std::min_element(xpos.begin(), xpos.end());
     std::unique_ptr<TH2D> h_hough = nullptr;
     StatusCode sc = houghInitCummulator(h_hough, maxX, minX);
  
     if (sc.isFailure()) return sc;
     sc = fillHoughTrafo(mmPrd, xpos, flag, h_hough);
     ATH_MSG_DEBUG("filled Hough");
     if (sc.isFailure()) return sc;
  
     std::vector<std::tuple<double, double>> houghPeaks;
     sc = findAlphaMax(h_hough, houghPeaks);
     if (sc.isFailure()) return sc;
     ATH_MSG_DEBUG("Found HoughPeaks");
     sc = selectTrack(mmPrd, xpos, flag, houghPeaks, idx_selected);
     if (sc.isFailure()) return sc;
     return StatusCode::SUCCESS;
 }

◆ selectTrack()

StatusCode Muon::UTPCMMClusterBuilderTool::selectTrack	(	const std::vector< Muon::MMPrepData > &	mmPrd,
		std::vector< double > &	xpos,
		std::vector< int > &	flag,
		std::vector< std::tuple< double, double >> &	tracks,
		std::vector< int > &	idxGoodStrips
	)		const

private

Definition at line 277 of file UTPCMMClusterBuilderTool.cxx.

                                                                                             {
     std::vector<double> chi2;
     std::vector<std::vector<int>> allGoodStrips;
     std::vector<int> ngoodStrips;
     std::vector<std::tuple<int, double>> trackQuality;  // touble holding the number of good strips and the chi2 for each track
     for (auto track : tracks) {
         double houghAngle = std::get<0>(track);
         double houghD = std::get<1>(track);
         double slope, intercept;
         double interceptRMS;
         double aRMS = 0;
         StatusCode sc = transformParameters(houghAngle, houghD, aRMS, slope, intercept, interceptRMS);
         if (sc.isFailure()) { return sc; }
         std::vector<double> dist;
         std::vector<int> indexUsedForDist, goodStrips;
         for (size_t i_hit = 0; i_hit < xpos.size(); i_hit++) {
             if (flag.at(i_hit) != 1) {
                 dist.push_back(mmPrd.at(i_hit).driftDist() - slope * xpos.at(i_hit) - intercept);
                 indexUsedForDist.push_back(i_hit);
             }
         }
         ATH_MSG_VERBOSE("indexUsedForDist " << indexUsedForDist);
         ATH_MSG_VERBOSE("distVec: " << dist);
         dist.clear();
         for (size_t i_hit : indexUsedForDist) {
             double d = mmPrd.at(i_hit).driftDist() - slope * xpos.at(i_hit) - intercept;
             ATH_MSG_VERBOSE("dist: " << d << " for index " << i_hit);
             if (std::fabs(d) < m_selectionCut) {
                 dist.push_back(d * d / mmPrd.at(i_hit).localCovariance()(1, 1));  // determine chi2
                 goodStrips.push_back(i_hit);
             }
         }
         {
             ATH_MSG_DEBUG("Angle estimate         =" << std::get<0>(track) << " " << std::get<0>(track) / Gaudi::Units::degree);
  
             ATH_MSG_DEBUG("restimate              =" << std::get<1>(track));
  
             ATH_MSG_DEBUG("slope estimate         =" << slope);
  
             ATH_MSG_DEBUG("intercept estimate     =" << intercept);
  
             ATH_MSG_DEBUG("good strips            =" << goodStrips);
  
             ATH_MSG_DEBUG("n good points          =" << goodStrips.size());
  
             ATH_MSG_DEBUG("chi2                   =" << std::accumulate(dist.begin(), dist.end(), 0.0) / (dist.size() - 2));
         }
         if (!goodStrips.empty()) {
             allGoodStrips.push_back(goodStrips);
             chi2.push_back(std::accumulate(dist.begin(), dist.end(), 0.0) / (dist.size() - 2));
             trackQuality.emplace_back(goodStrips.size(), std::accumulate(dist.begin(), dist.end(), 0.0) / (dist.size() - 2));
         }
     }
     if (chi2.empty()) return StatusCode::FAILURE;
     int trackIndex = std::min_element(trackQuality.begin(), trackQuality.end(), sortTracks) - trackQuality.begin();
     idxGoodStrips = allGoodStrips.at(trackIndex);
     return StatusCode::SUCCESS;
 }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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.

◆ transformParameters()

StatusCode Muon::UTPCMMClusterBuilderTool::transformParameters	(	double	alpha,
		double	d,
		double	dRMS,
		double &	slope,
		double &	intercept,
		double &	interceptRMS
	)		const

private

Definition at line 338 of file UTPCMMClusterBuilderTool.cxx.

                                                                                            {
     slope = 1. / std::tan(alpha);
     intercept = -d / std::sin(alpha);
     interceptRMS = std::fabs(dRMS);
     ATH_MSG_VERBOSE("transformParameters alpha: " << alpha << " d: " << d << " dRMS: " << dRMS << " slope: " << slope
                                                   << " intercept: " << intercept);
     return StatusCode::SUCCESS;
 }

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

Member Data Documentation

◆ m_alphaMax

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_alphaMax {this, "HoughAlphaMax", 0. }

private

Definition at line 57 of file UTPCMMClusterBuilderTool.h.

◆ m_alphaMin

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_alphaMin {this, "HoughAlphaMin", -90. }

private

Definition at line 56 of file UTPCMMClusterBuilderTool.h.

◆ m_alphaResolution

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_alphaResolution {this, "HoughAlphaResolution", 1.}

private

Definition at line 58 of file UTPCMMClusterBuilderTool.h.

◆ 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_digiHasNegativeAngles

Gaudi::Property<bool> Muon::UTPCMMClusterBuilderTool::m_digiHasNegativeAngles {this, "digiHasNegativeAngle", true}

private

Definition at line 71 of file UTPCMMClusterBuilderTool.h.

◆ m_dMax

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_dMax {this, "HoughDMax", 0.}

private

Definition at line 61 of file UTPCMMClusterBuilderTool.h.

◆ m_dMin

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_dMin {this, "HoughDMin", 0.}

private

Definition at line 60 of file UTPCMMClusterBuilderTool.h.

◆ m_dResolution

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_dResolution {this, "HoughDResolution", 0.125}

private

Definition at line 62 of file UTPCMMClusterBuilderTool.h.

◆ m_driftRange

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_driftRange {this, "HoughExpectedDriftRange", 12.*Gaudi::Units::m}

private

Definition at line 63 of file UTPCMMClusterBuilderTool.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_houghMinCounts

Gaudi::Property<unsigned> Muon::UTPCMMClusterBuilderTool::m_houghMinCounts {this, "HoughMinCounts", 3}

private

Definition at line 64 of file UTPCMMClusterBuilderTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::UTPCMMClusterBuilderTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Muon Detector Descriptor.

Definition at line 51 of file UTPCMMClusterBuilderTool.h.

◆ m_maxStripsCut

Gaudi::Property<int> Muon::UTPCMMClusterBuilderTool::m_maxStripsCut {this, "maxStripRemove", 4}

private

Definition at line 69 of file UTPCMMClusterBuilderTool.h.

◆ m_outerChargeRatioCut

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_outerChargeRatioCut {this,"outerChargeRatioCut", 0.}

private

charge ratio cut to supress cross talk

Definition at line 67 of file UTPCMMClusterBuilderTool.h.

◆ m_selectionCut

Gaudi::Property<double> Muon::UTPCMMClusterBuilderTool::m_selectionCut {this, "HoughSelectionCut", 1. * Gaudi::Units::mm}

private

Definition at line 59 of file UTPCMMClusterBuilderTool.h.

◆ 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_writeStripProperties

Gaudi::Property<bool> Muon::UTPCMMClusterBuilderTool::m_writeStripProperties {this, "writeStripProperties", true }

private

Definition at line 53 of file UTPCMMClusterBuilderTool.h.

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

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ LaySortedPrds

◆ RIO_Author

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ UTPCMMClusterBuilderTool()

◆ ~UTPCMMClusterBuilderTool()

Member Function Documentation

◆ applyCrossTalkCut()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ DeclareInterfaceID()

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillHoughTrafo()

◆ finalFit()

◆ findAlphaMax()

◆ getCalibratedClusterPosition()

◆ getClusters()

◆ houghInitCummulator()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ runHoughTrafo()

◆ selectTrack()

◆ sysInitialize()

◆ sysStart()

◆ transformParameters()

◆ updateVHKA()

Member Data Documentation

◆ m_alphaMax

◆ m_alphaMin

◆ m_alphaResolution

◆ m_detStore

◆ m_digiHasNegativeAngles

◆ m_dMax

◆ m_dMin

◆ m_dResolution

◆ m_driftRange

◆ m_evtStore

◆ m_houghMinCounts

◆ m_idHelperSvc

◆ m_maxStripsCut

◆ m_outerChargeRatioCut

◆ m_selectionCut

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_writeStripProperties