MuonCalib Namespace Reference

CscCalcPed - algorithm that finds the Cathode Strip Chamber pedestals from an RDO. More...

Namespaces
namespace	Legendre

Classes
class	AdaptiveResidualSmoothing
class	ADCMTHistos
	Histogram and fitter class for drift time and pulsehight spectra The rising slope is fitted by a fermi-function: \(f(t)=r_{u,0} + \frac{A}{1+exp((t_0 - t)/T_0}\). More...
class	BaseFunction
	This is an abstract base class for a set of base functions for fits to sample points. More...
class	BaseFunctionFitter
	This class performs a fit of a linear combination of base functions to a set of sample points. More...
class	BFieldCorFunc
	This class allows the user to get the difference between the drift time measured by a tube operated in a magnetic field \( \vec{B} \) and the drift time which would be measured by this tube if \( \vec{B} \) vanished. More...
class	CalibDbConnection
class	CalibFunc
	generic interface for a calibration function. More...
class	CalibHeadOperations
struct	CalibParamSorter
	Helper struct to group Mdt calibration constants which are equivalent within the target precision. More...
class	CalibrationDbIOTool
class	CalibrationTeeIOTool
	Wites to two calibtaion IO Tools. More...
class	CalibRtDbOperations
class	CalibT0DbOperations
class	ChebyshevPolynomial
	This class class provides a Chebyshev polynomial of order k. More...
class	Combination
class	ConstantContentBinMaker
class	CoolInserter
class	CscCalcPed
	does calibration of the CSC chambers More...
class	CscCalcSlope
	does calibration of the CSC chambers More...
class	CscCalibHitBase
	Athena-independent part of the CscCalibHit. More...
class	CscCondData
class	CscCondDataCollection
class	CscCondDataCollectionBase
class	CscCondDataContainer
class	CscCondParType
class	CurvedCandidateFinder
class	CurvedLine
class	CurvedPatRec
class	DataBin
class	DataPoint
class	DCSLFitter
	Straight line fitter for drift circles. More...
class	EventHandler
class	FixedIdDecoder
class	GlobalTimeFitter
	Provides the operator to fit .... More...
class	HistogramId
	Identifier class for drift time histograms. More...
class	ICalibPatternSelector
	Interface to MuonCalibPatternSelectors. More...
class	ICalibrationIOTool
class	ICalibSegmentPreparationTool
class	IConditionsStorage
class	IdToFixedIdTool
	Tool responsible for wrapping the athena dependent Identifier class to a standalone Calib-EDM MuonFixedId identifier. More...
class	IIdToFixedIdTool
	Interface for tools performing the conversion between Athena Identifiers and Muon Calibration Standalone Fixed ones. More...
class	IMdtBackgroundCorFunc
	generic interface for cavern background correction functions More...
class	IMdtBFieldCorFunc
	generic interface for b-field correction functions More...
class	IMdtCalibration
	Interface to Mdt calibration algortihms. More...
class	IMdtCalibrationOutput
	Interface to pass calibration output during calibration. More...
class	IMdtPatRecFitter
	Interface class for MdtSegment fitters performing a pattern recognition. More...
class	IMdtSegmentFitter
	Interface for MdtSegment fitters. More...
class	IMdtSegmentSelector
	Interface class for MdtSegmentSelectors. More...
class	IMdtSlewCorFunc
	generic interface for slewing correction functions More...
class	IMdtTempCorFunc
	generic interface for temperature correction functions More...
class	IMooPatternForCalibrationTool
	Interface class IMooPatternForCalibrationTool (obsolete) More...
class	IMuonCalibConditionsSource
class	IMuonCalibTool
	Interface class IMuonCalibTool. More...
class	IndexSet
class	INtupleCalibrationTool
class	IRegionSelectorTool
	Interface class IRegionSelectorTool. More...
class	IRtRelation
	generic interface for a rt-relation More...
class	IRtResolution
	Generic interface to retrieve the resolution on the drift radius as a function of the drift time. More...
class	IShiftMapTools
	Interface for the ShiftMapTools inheriting from MdtCalibrationShiftMapBase. More...
class	ITrRelation
class	LegendrePolynomial
	This class provides a legendre polynomial of order k. More...
class	LocalSegmentResolver
	Class calculates the local position and direction of the segment using the hits on track. More...
class	LocalToPrecision
	Provides transformation between local and presicion reference frames. More...
class	MdtCalibDataContainer
class	MdtCalibEventLoop
	Class collects segments for a given chamber and performs several loops over the sample until the calibration algorithm thinks it converged. More...
class	MdtCalibHitBase
	Athena-independent part of the MdtCalibHit. More...
class	MdtCorFuncSet
	Class which holds all correction functions for a given region. More...
struct	MdtFullCalibData
	class which holds the full set of calibration constants for a given tube More...
class	MdtRelativeTubeT0
class	MdtRtRelation
	class which holds calibration constants per rt-region More...
class	MdtSlewCorFuncHardcoded
	An implementation of a time slew correction function for AMT digitization chip. More...
class	MdtStationT0Container
class	MdtTubeCalibContainer
	Holds single-tube calibration constants of one chamber. More...
class	MdtTubeFitContainer
	Holds single-tube full calibration information of one chamber. More...
class	MdtTubeFullInfoContainer
	Holds single-tube full calibration information of one chamber. More...
class	MeanRMS
class	MTStraightLine
class	MTT0PatternRecognition
class	MTTmaxPatternRecognition
class	MuCCaFitter
	Interface to the straight line fitter for drift circles used by Calib. More...
class	MuCCaFitterImplementation
	The straight line fitter for drift circles used by Calib. More...
struct	MultilayerId
	Holds the station, eta, phi and multilayer Ids for a given multilayer. More...
class	MultilayerRtDifference
class	MultilayerRtDifference_Histograms
class	MuonCalibCaloHit
	Simplified class designed to store information of a MBTS hit. More...
class	MuonCalibCscTruthHit
	Class with truth information of a RPC hit, containing: More...
class	MuonCalibCylinder
class	MuonCalibDbCalibrationSource
class	MuonCalibDefaultCalibrationSource
class	MuonCalibDisk
class	MuonCalibEvent
	Container class storing all entries of the CalibrationNtuple. More...
class	MuonCalibEvent_E
	Extension to the 'original' MuonCalib::MuonCalibEvent class. More...
class	MuonCalibEventInfo
	MuonCalib::MuonCalibEventInfo: a class which stores the following information of an event: More...
class	MuonCalibExtendedRawHits
	Access to all raw hits with layer/station granularity. More...
class	MuonCalibExtendedSegment
	A segment plus everything one can dream of knowing about it. More...
class	MuonCalibExtendedTrack
	A track plus everything one can dream of knowing about a track. More...
struct	MuonCalibExtendedTrackOverlap
class	MuonCalibHit_E
	Simplified class designed to store information of a MDT hit. More...
class	MuonCalibHole_E
	class describing a Hole on track. More...
class	MuonCalibMdtTruthHit
	Class with truth information of a MDT hit, containing: More...
class	MuonCalibMUCTPI
	Simplified class designed to store information from MuCTPi processor. More...
class	MuonCalibPattern
	Class to store the information belonging to a global pattern in the muon system. More...
class	MuonCalibRawCscHit
	Calib-EDM version of CscPrepData class, containing uncalibrated information. More...
class	MuonCalibRawHitAssociationMap
	Association map between MuonFixedId and raw hits. More...
class	MuonCalibRawHitCollection
	A MuonCalibRawHitcollections is a container class within the Calibration EDM holding the MuonCalibXxxRawHits from the different technologies: More...
class	MuonCalibRawMdtHit
	Calib-EDM version of MdtPrepData class, containing uncalibrated information. More...
class	MuonCalibRawRpcCoin
	Calib-EDM version of RpcCoinData class. More...
class	MuonCalibRawRpcHit
	Calib-EDM version of RpcPrepData class, containing uncalibrated information. More...
class	MuonCalibRawRpcTriggerHit
	Calib-EDM version of RpcRawData class. More...
class	MuonCalibRawTgcCoin
	Calib-EDM version of TgcPrepData class, containing uncalibrated information. More...
class	MuonCalibRawTgcHit
	Calib-EDM version of TgcPrepData class, containing uncalibrated information. More...
class	MuonCalibRawTriggerHitCollection
class	MuonCalibRpcSectorLogic
	Simplified class designed to store information from RpcSectorLogic. More...
class	MuonCalibRpcTruthHit
	Class with truth information of a RPC hit, containing: More...
class	MuonCalibSegment
	A MuonCalibSegment is a reconstructed three dimensional track segment in the MuonSpectrometer. More...
class	MuonCalibSelector
class	MuonCalibSimpleGeometry
class	MuonCalibSimpleHoleSearch
class	MuonCalibSLPropagator
	straight line propagator More...
class	MuonCalibSurface
class	MuonCalibTgcTruthHit
	Class with truth information of a RPC hit, containing: More...
class	MuonCalibTrack_E
	Simplified class designed to store information of a Track. More...
class	MuonCalibTrackSummary
class	MuonCalibTriggerInfo
	Simplified class designed to store information of a trigger. More...
class	MuonCalibTriggerTimeInfo
class	MuonCalibTriggerTypeHelper
	helper class to for MuonCalibTriggerType which provides a mapping to the actual bit number More...
class	MuonCalibTruth
	Calib-EDM version of TrackRecord, given at the MuonSpectrometer entrance. More...
class	MuonCalibTruthCollection
	MuonCalibTruthCollection is a Calibration EDM container class containing the following truth classes: More...
class	MuonFixedId
	Implements fixed identifiers not dependent upon Athena Identifier for internal use in the calibration framework. More...
class	MuonFixedIdManipulator
class	MuonFixedIdPrinter
class	MuonFixedLongId
class	MuonSegmentReader
class	NtupleStationId
	Station Identifier for sorting calibration data. More...
class	PolygonBase
	This class provides functions which allow the user to express a polygon as a linear combination of these functions. More...
class	QuasianalyticLineReconstruction
class	RadiusResolutionChebyshev
	RadiusResolutionChebyshev parametrizes the uncertainty on the drift-radius as a function of the drift radius itself and not of the drift time. More...
class	RegionDataFromFile
	Manages the I/O of the list of multilayers belonging to a calibration region. More...
class	RegionElement
class	RegionLogicalOperation
class	RegionSelectorBase
class	RpcCalibData
	holds all conditions data for rpc strip. More...
class	RpcCalibDataContainer
class	RpcCalibDBEntry
	representation of a db entry in rpc cond db. More...
class	RpcCalibHitBase
	Athena independent part of the RpcCalibHit. More...
class	RpcCondParType
class	RpcOnlineDBEntry
	representation of an online db entry (masked chans) in rpc cond db. More...
class	RtCalibrationAnalytic
	This class performs the analytic autocalibration whose basic ideas were developed by Mario Deile (see ATL-MUON-2004-021). More...
class	RtCalibrationCurved
class	RtCalibrationIntegration
	This class allows the user to obtain an r-t relationship from the drift time spectrum in a given calibration region. More...
class	RtCalibrationOutput
	Class for communication between event loop and rt calibration algorithm contains only a rt relation for now. More...
class	RtChebyshev
	This class contains the implementation of an r(t) relationship parametrized by a linear combination of Chebyshev polyonomials. More...
class	RtData_t_r_reso
	Represents an Rt relation in the form of a set of (time,radius,resolution) points. More...
class	RtDataFromFile
	Manages the I/O of the Rt realtions from/to file. More...
class	RtFromPoints
	This class allows the user to retrieve an RtChebyshev or RtRelationLookUp object corresponding to a set of (r, t) points. More...
class	RtFullInfo
	addiitonal information used in validation of a rt-relation More...
class	RtLegendre
	This class contains the implementation of an r(t) relationship parametrized by a linear combination of Legendre polyonomials. More...
class	RtParabolicExtrapolation
class	RtRelationLookUp
	Equidistant look up table for rt-relations with the time as key. More...
class	RtResolutionChebyshev
	This class contains the implementation of a spatial resolution \( \sigma \) parametrized by a linear combination of Chebyshev polyonomials. More...
class	RtResolutionFromPoints
class	RtResolutionLookUp
	Equidistant look up table for resolution tables with the time as key. More...
class	RtSimplePolynomial
class	RtSpline
	This class contains the implementation of an r(t) relationship parameterized as support points to a cubic spline. More...
class	SamplePoint
	This class provides a sample point for the BaseFunctionFitter. More...
class	SimpleMdtSegmentSelector
	Basic MdtSegments selector. More...
class	SimplePatternSelector
	Basic Pattern selector. More...
class	SimplePolynomial
	This class provides the simple polynomials x^k (k=0, 1, ...) as base functions for fits. More...
class	StraightPatRec
class	T0CalibrationClassic
	Implementation of a T0 calibration using the classical approach. More...
class	T0CalibrationMT
	Implementation of a T0 calibration using the MT approach. More...
class	T0CalibrationOutput
	class for the communication of the results of T0 calibration algorithms More...
class	T0ClassicHistos
	Tube histograms used in T0 calibration. More...
class	T0ClassicSettings
	Settings for the T0 calibration (histogram booking and fitting parameters) More...
class	T0MTHistos
	Histogram and fitter class for drift time and pulsehight spectra The rising slope is fitted by a fermi-function: \(f(t)=r_{u,0} + \frac{A}{1+exp((t_0 - t)/T_0}\). More...
class	T0MTSettings
	Settings for the T0 calibration (histogram booking and fitting parameters) Parameters for pattern recognition. More...
class	T0MTSettingsT0
class	T0MTSettingsTMax
class	T0Refinement
class	TgcCalibHitBase
	Athena independent part of the TgcCalibHit. More...
class	TrChebyshev
class	TrLegendre
class	TrRelationLookUp
class	TrSimplePolynomial
class	TubeDataFromFile
	Manage the I/O of MdtTubeFitContainer objects. More...
class	typeNamer
class	typeNamer< bool >
class	typeNamer< double >
class	typeNamer< float >
class	typeNamer< int >
class	typeNamer< std::string >
class	typeNamer< uint16_t >
class	typeNamer< uint32_t >
class	typeNamer< uint8_t >
class	UpdateCalibHit
	Provides the operator to update drift radius and error of a given MdtCalibHit using the pointer to the IRtRelation passed to the constructor. More...
class	VariableBinwidthHistogram
	A histogram where every bin has the same number of entries. More...
class	VariableBinwidthHistogramBin
	A bin of a VariableBinwidthHistogram. More...
class	VBHBinPtrSrt
	A pointer to a VariableBinwidthHistogramBin which supports sorting. More...

Typedefs
using	IRtRelationPtr = GeoModel::TransientConstSharedPtr<IRtRelation>
using	IRtResolutionPtr = GeoModel::TransientConstSharedPtr<IRtResolution>
using	ITrRelationPtr = GeoModel::TransientConstSharedPtr<ITrRelation>
using	SingleTubeFit = MdtTubeFitContainer::SingleTubeFit
using	SingleTubeFullInfo = MdtTubeFullInfoContainer::SingleTubeFullInfo
using	CalibHitE_Ptr = std::shared_ptr<const MuonCalibHit_E>
	hit information per station layer index
using	StationIndexHitsMap = std::map<MuonFixedIdManipulator::StationIndex, std::vector<CalibHitE_Ptr> >
using	IdHitsMap = std::map<MuonFixedId, std::vector<CalibHitE_Ptr> >
	hit information per station
using	IdHitMap = std::map<MuonFixedId, CalibHitE_Ptr>
	hit information per identifier
using	StationIntersectedLayerMap = std::map<MuonFixedId, MuonCalibSimpleHoleSearch::Result>
	intersected layers in the simplified geometry per station
using	StationIndexSet = std::set<MuonFixedIdManipulator::StationIndex>
	set with station layer index
using	IdSet = std::set<MuonFixedId>
	set of identifiers
typedef Identifier	MdtBasicRegionId
	define type MdtBasicRegionId for the smallest possible MDT calibration region
typedef IdentifierHash	MdtBasicRegionHash
	define type MdtBasicRegionHash for the smallest possible MDT calibration region
typedef IdentifierHash	MdtRegionHash
	define type MdtRegionHash

Enumerations
enum	MuonCalibTriggerType {   L1_EM3 = 0 , L1_TAU5 , L1_J5 , L1_XE20 ,   L1_MBTS_1_COMM , L1_MBTS_2_COMM , L1_MU0_LOW_RPC , L1_MU6_RPC ,   L1_MU0_HIGH_RPC , L1_MU0_TGC_HALO , L1_MU0_TGC , L1_MU6_TGC ,   NUMBEROFKNOWNTRIGGERS , UNKNOWNTRIGGERTYPE = 999 }
	enum for all trigger type More...
enum	MdtCalibCreationFlags { TIME_SLEWING_CORRECTION_APPLIED =0x10 , B_FIELD_CORRECTIONS_APPLIED =0x20 }

Functions
std::istream &	operator>> (std::istream &is, RtFullInfo &data)
std::ostream &	operator<< (std::ostream &os, const RtFullInfo &data)
float	RtScalePolynomial (const float r)
float	RtScaleFunction (const float t, const bool ml2, const IRtRelation &rtrelation)
std::vector< SamplePoint >	fetchDataPoints (const IRtRelation &rtRel, const double relUnc)
	Constructs a list of sample points from the rt-relation.
std::vector< SamplePoint >	fetchDataPoints (const IRtRelation &rtRel, const IRtResolution &resoFunc)
	Constructs a list of sample points from the rt-relation.
std::vector< SamplePoint >	swapCoordinates (const std::vector< SamplePoint > &points, const IRtRelation &rtRel)
	Creates a new vector of samples points with x1 exchanged by x2 and vice-versa.
std::vector< SamplePoint >	resoFromRadius (const std::vector< SamplePoint > &points, const double uncert)
	Creates a new vector of sample points where the x2 coordinate becomes the x1 coordinate and the resolution becomes x2.
std::vector< SamplePoint >	fetchResolution (const std::vector< SamplePoint > &points, const double uncert)
	Creates a new vector of sample points where the x2 is assigned to the uncertainty and the uncertainty is replaced by a constant value.
std::vector< SamplePoint >	normalizeDomain (const std::vector< SamplePoint > &dataPoints)
	Normalizes the domain of the samples points to the interval -1 to 1.
double	calculateChi2 (const std::vector< SamplePoint > &dataPoints, const IRtRelation &rtRel)
	Returns the chi2 of the rt-relation w.r.t.
double	calculateChi2 (const std::vector< SamplePoint > &dataPoints, const ITrRelation &trRel)
double	calculateChi2 (const std::vector< SamplePoint > &dataPoints, const IRtResolution &rtReso)
std::pair< double, double >	minMax (const std::vector< SamplePoint > &points)
	Returns the minimum & maximum values covered by the sample points.
std::pair< double, double >	interval (const std::vector< SamplePoint > &points)
	Returns the interval covered by the sample points.
Double_t	MultilayerRtDifference_ScaleFunction (Double_t *x, Double_t *par)
template<typename T>
void	clearall (T &container)
Double_t	adcfitf_skewnormal (Double_t *x, Double_t *par)
	skew normal ADC fitting
unsigned int	get_group_id (const MuonFixedId &id, const MdtRelativeTubeT0::TubeGroup &grp)
Double_t	myexp (Double_t *x, Double_t *p)
Double_t	TimeSpectrum_func (Double_t *xx, Double_t *par)
TRandom3 *	getTLSRandomGen ()
Double_t	mt_t0_fermi (Double_t *x, Double_t *par)
	The fermi function to be fitted at the rising edge of the spectrum.
Double_t	mt_tmax_fermi (Double_t *x, Double_t *par)
	The fermi function to be fitted at the trailing slope of the spectrum.
std::istream &	operator>> (std::istream &is, RtData_t_r_reso &data)
std::ostream &	operator<< (std::ostream &os, const RtData_t_r_reso &data)
static const InterfaceID	IID_IMuonCalibConditionsSource ("MuonCalib::IMuonCalibConditionsSource", 1, 0)
std::ostream &	operator<< (std::ostream &stream, const CscCalibHitBase &hit)
std::ostream &	operator<< (std::ostream &stream, const RpcCalibHitBase &hit)
std::ostream &	operator<< (std::ostream &stream, const TgcCalibHitBase &hit)
std::ostream &	operator<< (std::ostream &os, const MuonCalib::MuonFixedId &id)
std::ostream &	operator<< (std::ostream &os, const MuonCalib::MuonFixedLongId &id)
MuonFixedId	OnlineToOffline (const std::string &online_id)
static const InterfaceID	IID_IIdToFixedIdTool ("MuonCalib::IdToFixedIdTool", 1, 0)
static const InterfaceID	IID_IMooPatternForCalibrationTool ("MuonCalib::IMooPatternForCalibrationTool", 1, 0)
	Interface ID for IMooPatternForCalibrationTool.
static const InterfaceID	IID_IMuonCalibTool ("MuonCalib::IMuonCalibTool", 1, 0)
	Interface ID for IMuonCalibTool.
static const InterfaceID	IID_IRegionSelectorTool ("MuonCalib::IRegionSelectorTool", 1, 0)
	Interface ID for IRegionSelectorTool.
constexpr double	chebyshevPoly1st (const unsigned int order, const double x)
	Returns the n-th Chebyshev polynomial of first kind evaluated at x (c.f.
constexpr double	chebyshevPoly2nd (const unsigned int order, const double x)
	Returns the n-th Chebyshev polynomial of second kind evaluated at x (c.f.
constexpr double	chebyshevPoly1stPrime (const unsigned int order, const double x)
	Returns the first derivative of the n-th Chebycheb polynomial of the first kind.
constexpr double	chebyshevPoly2ndPrime (const unsigned int order, const double x)
	Returns the first derivative of the n-th Chebycheb polynomial of the first second kind.
constexpr double	chebyshevPoly1st2Prime (const unsigned int order, const double x)
	Returns the second derivative of the n-th Chebycheb polynomial of the first kind.
constexpr double	chebyshevPoly2nd2Prime (const unsigned int order, const double x)
	Returns the second derivative of the n-th Chebycheb polynomial of the first second kind.
constexpr unsigned long	factorial (const int n)
	Evaluated the n-th factorial at compile time.
constexpr unsigned long	binomial (const unsigned n, const unsigned k)
	Calculates the binomial coefficient at compile time.
template<int k>
constexpr double	pow (const double x)
	Calculate the power of a variable x at compile time.
constexpr double	pow (double x, int power)
	Calculate the power of a variable at run time.
constexpr double	legendrePoly (const unsigned l, const double x)
	Calculates the legendre polynomial of rank l at x.
constexpr double	legendreDeriv (const unsigned l, const unsigned d, const double x)
	Evaluates the n-th derivative of the l-th Legendre polynomial.
double	mapToUnitInterval (const double x, const double lowerEdge, const double upperEdge)
	Maps the number x which is in [lowEdge;upperEdge] to the interval [-1;1].
double	unitIntervalPrime (const double lowerEdge, const double upperEdge)
std::ostream &	operator<< (std::ostream &s, const CscCondParType &type)
std::ostream &	operator<< (std::ostream &s, const RpcCondParType &type)

Variables
static constexpr std::array< double, 6 >	RtScaleFunction_p {-0.00102327, 0.00582117, -0.00676815, 0.00167504, -8.67371e-05, 1.66509e-06}

Detailed Description

CscCalcPed - algorithm that finds the Cathode Strip Chamber pedestals from an RDO.

MdtCalibDbAlgR4 reads raw condition data and writes derived condition data to the condition store.

namespace to identify classes related only to muon calibration

   @class CscCondData

   @author lampen@physics.arizona.edu

   @brief Containes information for a single index value for a CSC COOL data object. 

Every value from the CSC COOL database is kept in a CscCondData object.

Typedef Documentation

CalibHitE_Ptr

using MuonCalib::CalibHitE_Ptr = std::shared_ptr<const MuonCalibHit_E>

hit information per station layer index

Definition at line 21 of file MuonCalibLayerMapping.h.

IdHitMap

using MuonCalib::IdHitMap = std::map<MuonFixedId, CalibHitE_Ptr>

hit information per identifier

Definition at line 28 of file MuonCalibLayerMapping.h.

IdHitsMap

using MuonCalib::IdHitsMap = std::map<MuonFixedId, std::vector<CalibHitE_Ptr> >

hit information per station

Definition at line 25 of file MuonCalibLayerMapping.h.

IdSet

using MuonCalib::IdSet = std::set<MuonFixedId>

set of identifiers

Definition at line 37 of file MuonCalibLayerMapping.h.

IRtRelationPtr

using MuonCalib::IRtRelationPtr = GeoModel::TransientConstSharedPtr<IRtRelation>

Definition at line 17 of file IRtRelation.h.

IRtResolutionPtr

using MuonCalib::IRtResolutionPtr = GeoModel::TransientConstSharedPtr<IRtResolution>

Definition at line 13 of file IRtResolution.h.

ITrRelationPtr

using MuonCalib::ITrRelationPtr = GeoModel::TransientConstSharedPtr<ITrRelation>

Definition at line 16 of file ITrRelation.h.

MdtBasicRegionHash

typedef IdentifierHash MuonCalib::MdtBasicRegionHash

define type MdtBasicRegionHash for the smallest possible MDT calibration region

Definition at line 26 of file NtupleStationId.h.

MdtBasicRegionId

typedef Identifier MuonCalib::MdtBasicRegionId

define type MdtBasicRegionId for the smallest possible MDT calibration region

Definition at line 24 of file NtupleStationId.h.

MdtRegionHash

typedef IdentifierHash MuonCalib::MdtRegionHash

define type MdtRegionHash

Definition at line 28 of file NtupleStationId.h.

SingleTubeFit

using MuonCalib::SingleTubeFit = MdtTubeFitContainer::SingleTubeFit

Definition at line 7 of file MdtTubeFitContainer.cxx.

SingleTubeFullInfo

using MuonCalib::SingleTubeFullInfo = MdtTubeFullInfoContainer::SingleTubeFullInfo

Definition at line 7 of file MdtTubeFullInfoContainer.cxx.

StationIndexHitsMap

using MuonCalib::StationIndexHitsMap = std::map<MuonFixedIdManipulator::StationIndex, std::vector<CalibHitE_Ptr> >

Definition at line 22 of file MuonCalibLayerMapping.h.

StationIndexSet

using MuonCalib::StationIndexSet = std::set<MuonFixedIdManipulator::StationIndex>

set with station layer index

Definition at line 34 of file MuonCalibLayerMapping.h.

StationIntersectedLayerMap

using MuonCalib::StationIntersectedLayerMap = std::map<MuonFixedId, MuonCalibSimpleHoleSearch::Result>

intersected layers in the simplified geometry per station

Definition at line 31 of file MuonCalibLayerMapping.h.

Enumeration Type Documentation

MdtCalibCreationFlags

enum MuonCalib::MdtCalibCreationFlags

Enumerator
TIME_SLEWING_CORRECTION_APPLIED
B_FIELD_CORRECTIONS_APPLIED

Definition at line 10 of file MdtCalibCreationFlags.h.

{TIME_SLEWING_CORRECTION_APPLIED=0x10, B_FIELD_CORRECTIONS_APPLIED=0x20};

MuonCalibTriggerType

enum MuonCalib::MuonCalibTriggerType

enum for all trigger type

Enumerator
L1_EM3
L1_TAU5
L1_J5
L1_XE20
L1_MBTS_1_COMM
L1_MBTS_2_COMM
L1_MU0_LOW_RPC
L1_MU6_RPC
L1_MU0_HIGH_RPC
L1_MU0_TGC_HALO
L1_MU0_TGC
L1_MU6_TGC
NUMBEROFKNOWNTRIGGERS
UNKNOWNTRIGGERTYPE

Definition at line 16 of file MuonCalibTriggerInfo.h.

                              {
        L1_EM3 = 0,
        L1_TAU5,
        L1_J5,
        L1_XE20,
        L1_MBTS_1_COMM,
        L1_MBTS_2_COMM,
        L1_MU0_LOW_RPC,
        L1_MU6_RPC,
        L1_MU0_HIGH_RPC,
        L1_MU0_TGC_HALO,
        L1_MU0_TGC,
        L1_MU6_TGC,
        NUMBEROFKNOWNTRIGGERS,
        UNKNOWNTRIGGERTYPE = 999
    };

Function Documentation

adcfitf_skewnormal()

Double_t MuonCalib::adcfitf_skewnormal ( Double_t * x, Double_t * par )

inline

skew normal ADC fitting

Definition at line 17 of file ADCMTHistos.cxx.

                                                                   {
        // par[0] = skew gauss norm
        // par[1] = skew gauss mean (i.e. mu)
        // par[2] = skew gauss sigma (i.e sigma)
        // par[3] = skew factor  (i.e. alpha)
        // Numeric constants
        Double_t invsq2pi = 1.0 / (std::sqrt(2 * M_PI));
        Double_t twoPi = 2 * M_PI;
 
        Double_t delta_value = par[3] / (std::sqrt(1. + par[3] * par[3]));
        Double_t omega_square = (par[2] * par[2]) / (1. - 4. * delta_value * delta_value / (twoPi));
        Double_t omega_value = std::sqrt(omega_square);
        Double_t xi_value = par[1] - delta_value * omega_value * 2. * invsq2pi;
        Double_t Gauss_part =
            (invsq2pi / omega_value) * std::exp(-((x[0] - xi_value) * (x[0] - xi_value)) / (2.0 * omega_square));  // phi(x)
 
        Double_t Erf_part = 0.5 * (1 + std::erf(par[3] * (x[0] - xi_value) / (omega_value)));
 
        Double_t SkewNormal_Value = par[0] * 2. * Gauss_part * Erf_part;
 
        Double_t MyGaussFuncValue = SkewNormal_Value;
 
        return (MyGaussFuncValue);
    }

binomial()

unsigned long MuonCalib::binomial ( const unsigned n, const unsigned k )

constexpr

Calculates the binomial coefficient at compile time.

Definition at line 60 of file LegendrePoly.h.

                                                                         {
        unsigned long b = factorial(n) / (factorial(k) * factorial(n-k));
        return b;
    }

calculateChi2() [1/3]

double MuonCalib::calculateChi2	(	const std::vector< SamplePoint > &	dataPoints,
		const IRtRelation &	rtRel )

Returns the chi2 of the rt-relation w.r.t.

the data points

Definition at line 102 of file SamplePointUtils.cxx.

                                                  {
        double chi2{0.};
        for (const SamplePoint& point: dataPoints){
            chi2+=std::pow((point.x2() - rtRel.radius(point.x1())) / point.error(), 2);
        }
        return chi2;
    }

calculateChi2() [2/3]

double MuonCalib::calculateChi2	(	const std::vector< SamplePoint > &	dataPoints,
		const IRtResolution &	rtReso )

Definition at line 118 of file SamplePointUtils.cxx.

                                                      {
        double chi2{0.};
        for (const SamplePoint& point: dataPoints){
            chi2+=std::pow((point.x2() - rtReso.resolution(point.x1())) / point.error(), 2);
        }
        return chi2;
    }

calculateChi2() [3/3]

double MuonCalib::calculateChi2	(	const std::vector< SamplePoint > &	dataPoints,
		const ITrRelation &	trRel )

Definition at line 110 of file SamplePointUtils.cxx.

                                                   {
        double chi2{0.};
        for (const SamplePoint& point: dataPoints){
            chi2+=std::pow((point.x2() - trRel.driftTime(point.x1()).value_or(2.*trRel.maxRadius()) ) / point.error(), 2);
        }
        return chi2;
    }

chebyshevPoly1st()

double MuonCalib::chebyshevPoly1st ( const unsigned int order, const double x )

constexpr

Returns the n-th Chebyshev polynomial of first kind evaluated at x (c.f.

https://en.wikipedia.org/wiki/Chebyshev_polynomials)

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 13 of file ChebychevPoly.h.

                                                                                {        
        double value{0.};
        switch(order) {
            case 0:
                value=1.;
                break;
            case 1:
                value = x;
                break;
            default:
                value = 2.*x*chebyshevPoly1st(order-1, x) - chebyshevPoly1st(order-2, x);
            break;
        }
        return value;
    }

chebyshevPoly1st2Prime()

double MuonCalib::chebyshevPoly1st2Prime ( const unsigned int order, const double x )

constexpr

Returns the second derivative of the n-th Chebycheb polynomial of the first kind.

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 81 of file ChebychevPoly.h.

                                                                                      {
        double value{0.};
        switch (order) {
            case 0:
            case 1:
                break;
            default:
                value = order * chebyshevPoly2ndPrime(order-1, x);
        }
        return value;
    }

chebyshevPoly1stPrime()

double MuonCalib::chebyshevPoly1stPrime ( const unsigned int order, const double x )

constexpr

Returns the first derivative of the n-th Chebycheb polynomial of the first kind.

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 49 of file ChebychevPoly.h.

                                                                                     {
        double value{0.};
        switch (order) {
            case 0:
                break;
            case 1:
                value = 1.;
                break;
            default:
                value = order * chebyshevPoly2nd(order-1, x);
        }
        return value;
    }

chebyshevPoly2nd()

double MuonCalib::chebyshevPoly2nd ( const unsigned int order, const double x )

constexpr

Returns the n-th Chebyshev polynomial of second kind evaluated at x (c.f.

https://en.wikipedia.org/wiki/Chebyshev_polynomials)

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 32 of file ChebychevPoly.h.

                                                                                 {
        double value{0.};
        switch (order) {
            case 0:
                value = 1.;
                break;
            case 1:
                value = 2.*x;
                break;
            default:
                value = 2.*chebyshevPoly1st(order, x) + chebyshevPoly2nd(order-2, x);
        }
        return value;
    }

chebyshevPoly2nd2Prime()

double MuonCalib::chebyshevPoly2nd2Prime ( const unsigned int order, const double x )

constexpr

Returns the second derivative of the n-th Chebycheb polynomial of the first second kind.

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 95 of file ChebychevPoly.h.

                                                                                      {
        double value{0.};
        switch (order) {
            case 0:
            case 1:
                break;
            default:
                value = 2.*chebyshevPoly1st2Prime(order, x) + chebyshevPoly2nd2Prime(order-2, x);
        }
        return value;
    }

chebyshevPoly2ndPrime()

double MuonCalib::chebyshevPoly2ndPrime ( const unsigned int order, const double x )

constexpr

Returns the first derivative of the n-th Chebycheb polynomial of the first second kind.

Parameters

order	of the polynomial to evalue
x	Place at which the polynomial is evaluated

Definition at line 65 of file ChebychevPoly.h.

                                                                                     {
        double value{0.};
        switch (order) {
            case 0:
                break;
            case 1:
                value = 2.;
                break;
            default:
                value = 2.*chebyshevPoly1stPrime(order, x) + chebyshevPoly2ndPrime(order-2, x);
        }
        return value;
    }

clearall()

template<typename T>

void MuonCalib::clearall ( T & container )

inline

Definition at line 83 of file MultilayerRtDifference.cxx.

                                                             {
        typename T::iterator it = container.begin();
        for (; it != container.end(); ++it) {
            delete *it;
            *it = NULL;
        }
    }

factorial()

unsigned long MuonCalib::factorial ( const int n )

constexpr

Evaluated the n-th factorial at compile time.

Definition at line 51 of file LegendrePoly.h.

                                                       {
        if (n > 1) {
            unsigned long f = n*factorial(n-1);
            return f;
        } else {
            return 1;
        }
    }

fetchDataPoints() [1/2]

std::vector< SamplePoint > MuonCalib::fetchDataPoints	(	const IRtRelation &	rtRel,
		const double	relUnc )

Constructs a list of sample points from the rt-relation.

The step-wdith between two points is taken from the rtRel bin width method and each point has the same uncertainty of 1 assigned

Parameters

rtRel

Reference of the rtRelation to transform to points.

Definition at line 19 of file SamplePointUtils.cxx.

                                                                                          {
        assert(relUnc >0);
        std::vector<SamplePoint> points{};
        const double stepWidth = rtRel.tBinWidth();
        double time = rtRel.tLower();
        while (time <= rtRel.tUpper()){
            const double r = rtRel.radius(time);
            points.emplace_back(time, r, relUnc);
            time+=stepWidth;
        }
        return points;
    }

fetchDataPoints() [2/2]

std::vector< SamplePoint > MuonCalib::fetchDataPoints	(	const IRtRelation &	rtRel,
		const IRtResolution &	resoFunc )

Constructs a list of sample points from the rt-relation.

The step-wdith between two points is taken from the rtRel bin width method and each point is weighted with the relative resolution

Parameters

rtRel	Reference of the rtRelation to transform to points.
reo	Reference to the r-t resolution function

Definition at line 31 of file SamplePointUtils.cxx.

                                                                                                {
        std::vector<SamplePoint> points{};
        const double stepWidth = rtRel.tBinWidth();
        double time = rtRel.tLower();
        while (time <= rtRel.tUpper()){
            points.emplace_back(time,rtRel.radius(time), reso.resolution(time));
            time+=stepWidth;
        }
        return points;
    }

fetchResolution()

std::vector< SamplePoint > MuonCalib::fetchResolution	(	const std::vector< SamplePoint > &	points,
		const double	uncert )

Creates a new vector of sample points where the x2 is assigned to the uncertainty and the uncertainty is replaced by a constant value.

Parameters

	points: List of data points to transform
uncert	Uncertainty to assign instead

Definition at line 50 of file SamplePointUtils.cxx.

                                                                  {
        std::vector<SamplePoint> outPoints{};
        outPoints.reserve(points.size());
        for (const SamplePoint& point: points) {
            outPoints.emplace_back(point.x1(),point.error(), uncert);
        }
        return outPoints;
    }

get_group_id()

unsigned int MuonCalib::get_group_id ( const MuonFixedId & id, const MdtRelativeTubeT0::TubeGroup & grp )

inline

Definition at line 63 of file MdtRelativeTubeT0.cxx.

                                                                                                   {
        switch (grp) {
            case MdtRelativeTubeT0::CHAMBER: return id.mdtChamberId().getIdInt(); break;
            case MdtRelativeTubeT0::MULTILAYER: return id.mdtMultilayerId().getIdInt(); break;
            case MdtRelativeTubeT0::LAYER: return 4 * (id.mdtMultilayer() - 1) + (id.mdtTubeLayer() - 1); break;
            case MdtRelativeTubeT0::MEZZ_CARD: return id.mdtMezzanine(); break;
            case MdtRelativeTubeT0::UNKNOWN: return 0;
        }
        return 0;
    }

getTLSRandomGen()

TRandom3 * MuonCalib::getTLSRandomGen

(

)

Definition at line 22 of file T0MTHistos.cxx.

    {
        static boost::thread_specific_ptr<TRandom3> rnd ATLAS_THREAD_SAFE;
        TRandom3* random = rnd.get();
        if (!random) {
            random = new TRandom3();
            rnd.reset(random);
        }
        return random;
    }

IID_IIdToFixedIdTool()

const InterfaceID MuonCalib::IID_IIdToFixedIdTool ( "MuonCalib::IdToFixedIdTool" , 1 , 0  )

static

IID_IMooPatternForCalibrationTool()

const InterfaceID MuonCalib::IID_IMooPatternForCalibrationTool ( "MuonCalib::IMooPatternForCalibrationTool" , 1 , 0  )

static

Interface ID for IMooPatternForCalibrationTool.

IID_IMuonCalibConditionsSource()

const InterfaceID MuonCalib::IID_IMuonCalibConditionsSource ( "MuonCalib::IMuonCalibConditionsSource" , 1 , 0  )

static

IID_IMuonCalibTool()

const InterfaceID MuonCalib::IID_IMuonCalibTool ( "MuonCalib::IMuonCalibTool" , 1 , 0  )

static

Interface ID for IMuonCalibTool.

IID_IRegionSelectorTool()

const InterfaceID MuonCalib::IID_IRegionSelectorTool ( "MuonCalib::IRegionSelectorTool" , 1 , 0  )

static

Interface ID for IRegionSelectorTool.

interval()

std::pair< double, double > MuonCalib::interval

(

const std::vector< SamplePoint > &

points

)

Returns the interval covered by the sample points.

Definition at line 94 of file SamplePointUtils.cxx.

                                                                           {
        double min{std::numeric_limits<double>::max()}, max{-std::numeric_limits<double>::max()};   
        for (const SamplePoint& point: points) {
            min = std::min(min, point.x1());
            max = std::max(max, point.x1());
        }
        return std::make_pair(min, max);
    }

legendreDeriv()

double MuonCalib::legendreDeriv ( const unsigned l, const unsigned d, const double x )

constexpr

Evaluates the n-th derivative of the l-th Legendre polynomial.

Parameters

x	Point of evaluation [-1;1]
l	Order of the Legendre polynomial
d	Order of the derivative

Definition at line 198 of file LegendrePoly.h.

                                                                                      {
        switch (d) {
            case 0:
                return legendrePoly(l,x);
                break;
            DERIVORDERSWITCH(l,1,x)
            DERIVORDERSWITCH(l,2,x)
            DERIVORDERSWITCH(l,3,x)
            DERIVORDERSWITCH(l,4,x)
            DERIVORDERSWITCH(l,5,x)
            default:
                return Legendre::derivativeSum(l, d, x);
        }
        return 0.;
    }

legendrePoly()

double MuonCalib::legendrePoly ( const unsigned l, const double x )

constexpr

Calculates the legendre polynomial of rank l at x.

Parameters

l	Order of the legendre polynomial
x	Point of evaluation [-1;1]

Definition at line 171 of file LegendrePoly.h.

                                                                    {
        switch (l) {
            POLYSWITCH( 0, x);
            POLYSWITCH( 1, x);
            POLYSWITCH( 2, x);
            POLYSWITCH( 3, x);
            POLYSWITCH( 4, x);
            POLYSWITCH( 5, x);
            POLYSWITCH( 6, x);
            POLYSWITCH( 7, x);
            POLYSWITCH( 8, x);
            POLYSWITCH( 9, x);
            POLYSWITCH(10, x);
            POLYSWITCH(11, x);
            POLYSWITCH(12, x);
            POLYSWITCH(13, x);
            POLYSWITCH(14, x);
            POLYSWITCH(15, x);
            POLYSWITCH(16, x);
            default:
                return Legendre::polySum(l, x);
        }
    }

mapToUnitInterval()

double MuonCalib::mapToUnitInterval ( const double x, const double lowerEdge, const double upperEdge )

inline

Maps the number x which is in [lowEdge;upperEdge] to the interval [-1;1].

Parameters

lowerEdge

Lower edge of the

Definition at line 12 of file UtilFunc.h.

                                                                                                    {
        return 2. * (x - 0.5 * (upperEdge + lowerEdge)) / (upperEdge - lowerEdge);
    }

minMax()

std::pair< double, double > MuonCalib::minMax

(

const std::vector< SamplePoint > &

points

)

Returns the minimum & maximum values covered by the sample points.

Definition at line 86 of file SamplePointUtils.cxx.

                                                                         {
        double min{std::numeric_limits<double>::max()}, max{-std::numeric_limits<double>::max()};
        for (const SamplePoint& point: points) {
            min = std::min(min, point.x2());
            max = std::max(max, point.x2());
        }        
        return std::make_pair(min,max);
    }

mt_t0_fermi()

Double_t MuonCalib::mt_t0_fermi ( Double_t * x, Double_t * par )

inline

The fermi function to be fitted at the rising edge of the spectrum.

Definition at line 34 of file T0MTHistos.cxx.

                                                            {
        // more convenient parameters
        const Double_t &t(x[0]);
        const Double_t &t_0(par[T0MTHistos::T0_PAR_NR_T0]), &T(par[T0MTHistos::T0_PAR_NR_T]), &back(par[T0MTHistos::T0_PAR_NR_BACK]),
            &A(par[T0MTHistos::T0_PAR_NR_A]);
        // the formula
        return (back + A / (1 + std::exp(-(t - t_0) / T)));
    }

mt_tmax_fermi()

Double_t MuonCalib::mt_tmax_fermi ( Double_t * x, Double_t * par )

inline

The fermi function to be fitted at the trailing slope of the spectrum.

Definition at line 44 of file T0MTHistos.cxx.

                                                              {
        // more convenient parameters
        Double_t &t(x[0]);
        Double_t &t_max(par[T0MTHistos::TMAX_PAR_NR_TMAX]), &T(par[T0MTHistos::TMAX_PAR_NR_T]), &back(par[T0MTHistos::TMAX_PAR_NR_BACK]),
            &a(par[T0MTHistos::TMAX_PAR_NR_A]), &b(par[T0MTHistos::TMAX_PAR_NR_B]), &t_0(par[T0MTHistos::TMAX_PAR_NR_T0]);
        // the formula
        return (back + (std::exp(a + b * (t - t_0))) / (1 + std::exp((t - t_max) / T)));
    }

MultilayerRtDifference_ScaleFunction()

Double_t MuonCalib::MultilayerRtDifference_ScaleFunction	(	Double_t *	x,
		Double_t *	par )

Definition at line 35 of file MultilayerRtDifference.cxx.

{ return par[0] * RtScalePolynomial(x[0]); }

myexp()

Double_t MuonCalib::myexp ( Double_t * x, Double_t * p )

inline

Definition at line 18 of file MTTmaxPatternRecognition.cxx.

{ return std::exp(p[0] + p[1] * (x[0] - p[3])) + p[2]; }

normalizeDomain()

std::vector< SamplePoint > MuonCalib::normalizeDomain

(

const std::vector< SamplePoint > &

dataPoints

)

Normalizes the domain of the samples points to the interval -1 to 1.

Definition at line 78 of file SamplePointUtils.cxx.

                                                                                     {
        const auto [minX, maxX] = interval(dataPoints);
        std::vector<SamplePoint> normedPoints{dataPoints};
        for (unsigned k = 0; k < dataPoints.size(); ++k) { 
            normedPoints[k].set_x1(mapToUnitInterval(normedPoints[k].x1(), minX, maxX)); 
        }
        return normedPoints;
    }

OnlineToOffline()

MuonFixedId MuonCalib::OnlineToOffline

(

const std::string &

online_id

)

Definition at line 13 of file OfflineOnlineIdConversion.cxx.

    {
    MuonFixedId ret(0), invalid;
    ret.set_mdt();
//minimum size of idenifier is 7
    if (online_id.size()!=7 && online_id.size()!=9)
        {
        MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
        log<<MSG::WARNING<<"Wrong length for online_id="<<online_id<<endmsg;
        return invalid;
        }
//check for A/C side
    bool c_side(false);
    if(online_id[4]!='A' && online_id[4]!='C' && online_id[4]!='B')
        {
        MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
        log<<MSG::WARNING<<"Invalid side for online_id="<<online_id<<endmsg;
        return invalid;
        }
    if(online_id[4]=='C')
        {
        c_side=true;
        }
//set station name
    std::string station_nm_string(online_id, 0, 3);
    int station_mm = MuonFixedId::stationStringToFixedStationNumber(station_nm_string);
    if (station_mm<0)
        {
        MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
        log<<MSG::WARNING<<"Invalid station name for online_id="<<online_id<<endmsg;
        return invalid;
        }
//set eta
    ret.setStationName(station_mm);
    char eta_str[2];
    char *endptr;
    eta_str[0]=online_id[3];
    eta_str[1]='\0';
    long int eta=strtol(eta_str, &endptr, 10);
    if(endptr!=&(eta_str[1]))
        {
        MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
        log<<MSG::WARNING<<"eta is not a number for online_id="<<online_id<<endmsg;
        return invalid;
        }
//set phi
    char phi_str[3];
    phi_str[0]=online_id[5];
    phi_str[1]=online_id[6];
    phi_str[2]='\0';
    long int phi=strtol(phi_str, &endptr, 10);
    if(endptr!=&(phi_str[2]))
        {
        MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
        log<<MSG::WARNING<<"phi is not a number for online_id="<<online_id<<endmsg;
        return invalid;
        }
//treat special cases
    if(phi==13 && eta>3 && station_nm_string=="BML")
        {
        eta--;
        }
    if(station_nm_string=="BOF")
        eta=(eta+1)/2;
    else if(station_nm_string=="BOG")
        eta/=2;
    else 
        {
        if((phi==1 || phi==9) && station_nm_string=="EIL")
            {
            if(eta==5) eta=4;
            else if(eta==4) eta=5;
            }
        if(phi==5 && station_nm_string=="EEL") eta=1;
        }
//convert online to offline phi 
    if(station_nm_string[2]=='L' || station_nm_string[2]=='M' || station_nm_string[2]=='R')
        {
        phi++;
        }
    phi/=2;
    ret.setStationEta(c_side?(eta*-1):eta);
    ret.setStationPhi(phi);
//set multilayer id if present
    if(online_id.size()==9)
        {
        switch(online_id[8])
            {
            case '1':
                ret.setMdtMultilayer(1);
                break;
            case '2':
                ret.setMdtMultilayer(2);
                break;
            default:
                MsgStream log(Athena::getMessageSvc(),"OnlineToOffline");
                log<<MSG::WARNING<<"Multilayer is neither 1 or 2 for online_id="<<online_id<<endmsg;
                return invalid;
            }
        return ret.mdtMultilayerId();
        }   
    return ret.mdtChamberId();
    }

operator<<() [1/9]

std::ostream & MuonCalib::operator<< ( std::ostream & os, const MuonCalib::MuonFixedId & id )

inline

Definition at line 1200 of file MuonFixedId.h.

                                                                                {
  return id.dump( os );
}

operator<<() [2/9]

std::ostream & MuonCalib::operator<< ( std::ostream & os, const MuonCalib::MuonFixedLongId & id )

inline

Definition at line 1577 of file MuonFixedLongId.h.

                                                                                    {
  return id.dump( os );
}

operator<<() [3/9]

std::ostream & MuonCalib::operator<<	(	std::ostream &	os,
		const RtData_t_r_reso &	data )

Definition at line 99 of file RtData_t_r_reso.cxx.

{ return data.write(os); }

operator<<() [4/9]

std::ostream & MuonCalib::operator<<	(	std::ostream &	os,
		const RtFullInfo &	data )

Definition at line 13 of file RtFullInfo.cxx.

{ return data.write(os); }

operator<<() [5/9]

std::ostream & MuonCalib::operator<< ( std::ostream & s, const CscCondParType & type )

inline

Definition at line 71 of file CscCondParType.h.

                                                                              {
    switch(type) {
 
      case CscCondParType::GAIN : 
        return  s << "GAIN";
      case CscCondParType::PULSE_SLOPE :
        return  s << "PULSE_SLOPE";
      case CscCondParType::RUN_SLOPE :
        return  s << "RUN_SLOPE";
      case CscCondParType::PED :
        return  s << "PED";
      case CscCondParType::NOISE : 
        return  s << "NOISE";
      case CscCondParType::THOLD : 
        return  s << "THOLD";
      case CscCondParType::PEAKT :
        return  s << "PEAKT";
      case CscCondParType::WIDTH :
        return  s << "WIDTH";
      case CscCondParType::SAT1 :
        return  s << "SAT1";
      case CscCondParType::SAT2 :
        return  s << "SAT2";
      case CscCondParType::PEAKC : 
        return s << "PEAKC";
      case CscCondParType::SAMPLE_TIME_RATIO :
        return s << "SAMPLE_TIME_RATIO";
      case CscCondParType::OCCUPANCY : 
        return s << "OCCUPANCY";
      case CscCondParType::STAT :
        return s << "STAT";
      case CscCondParType::HOT_STAT :
        return s << "HOT_STAT";
      case CscCondParType::DEAD_STAT :
        return s << "DEAD_STAT";
      case CscCondParType::PULSE_STAT :
        return s << "PULSE_STAT";
      case CscCondParType::SAT_STAT :
        return s << "SAT_STAT";
      default:
        return s << "UNKNOWN";
    };
  }

operator<<() [6/9]

std::ostream & MuonCalib::operator<< ( std::ostream & s, const RpcCondParType & type )

inline

Definition at line 60 of file RpcCondParType.h.

                                                                              {
    switch(type) {
 
      case RpcCondParType::EFF : 
        return  s << "EFF";
      case RpcCondParType::ERREFF : 
        return  s << "ERREFF";
      case RpcCondParType::RES1 : 
        return  s << "RES1";
      case RpcCondParType::RES2 : 
        return  s << "RES2";
      case RpcCondParType::RESX : 
        return  s << "RESX";
      case RpcCondParType::ERRRES1 : 
        return  s << "ERRRES1";
      case RpcCondParType::ERRRES2 : 
        return  s << "ERRRES2";
      case RpcCondParType::ERRRESX : 
        return  s << "ERRRESX";
      case RpcCondParType::TIME :
        return  s << "TIME";
      case RpcCondParType::ERRTIME :
        return  s << "ERRTIME";
      case RpcCondParType::NOISE :
        return  s << "NOISE";
      case RpcCondParType::NOISEC : 
        return  s << "NOISEC";
      case RpcCondParType::ERRNOISE :
        return  s << "ERRNOISE";
      case RpcCondParType::ERRNOISEC : 
        return  s << "ERRNOISEC";
      default:
        return s << "UNKNOWN";
    };
  }

operator<<() [7/9]

std::ostream & MuonCalib::operator<<	(	std::ostream &	stream,
		const CscCalibHitBase &	hit )

Definition at line 26 of file CscCalibHitBase.cxx.

{ return hit.dump(stream); }

operator<<() [8/9]

std::ostream & MuonCalib::operator<<	(	std::ostream &	stream,
		const RpcCalibHitBase &	hit )

Definition at line 59 of file RpcCalibHitBase.cxx.

{ return hit.dump(stream); }

operator<<() [9/9]

std::ostream & MuonCalib::operator<<	(	std::ostream &	stream,
		const TgcCalibHitBase &	hit )

Definition at line 64 of file TgcCalibHitBase.cxx.

{ return hit.dump(stream); }

operator>>() [1/2]

std::istream & MuonCalib::operator>>	(	std::istream &	is,
		RtData_t_r_reso &	data )

Definition at line 97 of file RtData_t_r_reso.cxx.

{ return data.read(is); }

operator>>() [2/2]

std::istream & MuonCalib::operator>>	(	std::istream &	is,
		RtFullInfo &	data )

Definition at line 11 of file RtFullInfo.cxx.

{ return data.read(is); }

pow() [1/2]

template<int k>

double MuonCalib::pow ( const double x )

constexpr

Calculate the power of a variable x at compile time.

Definition at line 65 of file LegendrePoly.h.

                                                          {
        if constexpr (k < 0) {
            return pow<-k>(1./x);
        } else if constexpr(k > 0) {
            return x*pow<k-1>(x);
        } else {
            return 1.;
        }
    }

pow() [2/2]

double MuonCalib::pow ( double x, int power )

constexpr

Calculate the power of a variable at run time.

Definition at line 75 of file LegendrePoly.h.

                                              {
        double res{1.};
        if (power < 0) {
            x = 1./x;
            power = - power;
        }
        for (int iter = 1; iter<=power; ++iter) {
            res*=x;
        }
        return res;
    }

resoFromRadius()

std::vector< SamplePoint > MuonCalib::resoFromRadius	(	const std::vector< SamplePoint > &	points,
		const double	uncert )

Creates a new vector of sample points where the x2 coordinate becomes the x1 coordinate and the resolution becomes x2.

Each point has the same uncertainty assigned

Parameters

points	List of rt- sample points of interest
uncert	Uncertainty oon each point

Definition at line 41 of file SamplePointUtils.cxx.

                                                                 {
        std::vector<SamplePoint> outPoints{};
        outPoints.reserve(points.size());
        for (const SamplePoint& point: points) {
            outPoints.emplace_back(point.x2(),point.error(), uncert);
        }
        return outPoints;
    }

RtScaleFunction()

float MuonCalib::RtScaleFunction	(	const float	t,
		const bool	ml2,
		const IRtRelation &	rtrelation )

Definition at line 20 of file RtScaleFunction.cxx.

                                                                                {
        if (t < rt.tLower() || !rt.hasTmaxDiff()) return 0.0;
        // apply linear scale and calculate r as input to the polinomial
        float rt_length = rt.tUpper() - rt.tLower();
        float corr_val = (t / rt_length) * rt.GetTmaxDiff() * (ml2 ? -0.5 : +0.5);
        float newt = t - corr_val;
        // keep linear scale for t>t_max
        if (newt > rt.tUpper()) return corr_val;
 
        // calculate polynomial
        float p = 0;
        float r = rt.radius(newt);
        for (int i = 5; i >= 0; i--) { p = RtScaleFunction_p[i] + r * p; }
        return p * rt.GetTmaxDiff() * (ml2 ? -0.5 : +0.5);
    }

RtScalePolynomial()

float MuonCalib::RtScalePolynomial

(

const float

r

)

Definition at line 13 of file RtScaleFunction.cxx.

                                           {
        // calculate polynomial
        float p = 0;
        for (int i = 5; i >= 0; i--) { p = RtScaleFunction_p[i] + r * p; }
        return p;
    }

swapCoordinates()

std::vector< SamplePoint > MuonCalib::swapCoordinates	(	const std::vector< SamplePoint > &	points,
		const IRtRelation &	rtRel )

Creates a new vector of samples points with x1 exchanged by x2 and vice-versa.

Each point has the same uncertainty assigned.

Parameters

points	List of rt- sample points of interest
rtRel	Reference to the rt-relation to calculate each point's uncertainty.

Definition at line 61 of file SamplePointUtils.cxx.

                                                                       {
        
        std::vector<SamplePoint> outPoints{};
        outPoints.reserve(inPoints.size());
        /*
         * Let's suppose that dY = f^{\prime} dX
         */
        for (const SamplePoint& in : inPoints) {
            const double fPrime = std::abs(rtRel.driftVelocity(in.x1()));
            outPoints.emplace_back(in.x2(), in.x1(), in.error() / (fPrime > 0 ? fPrime : 1.));
        }
        std::ranges::sort(outPoints, [](const SamplePoint& a, const SamplePoint& b) {
                                        return a.x1() < b.x1();
                                    });
        return outPoints;
    }

TimeSpectrum_func()

Double_t MuonCalib::TimeSpectrum_func ( Double_t * xx, Double_t * par )

inline

Definition at line 24 of file T0CalibrationClassic.cxx.

                                                                   {
        Double_t &x(xx[0]);
        return par[0] + (par[1] * (1 + par[2] * std::exp(-(x - par[4]) / par[3]))) /
                            ((1 + std::exp((-x + par[4]) / par[6])) * (1 + std::exp((x - par[5]) / par[7])));
    }

unitIntervalPrime()

double MuonCalib::unitIntervalPrime ( const double lowerEdge, const double upperEdge )

inline

Definition at line 15 of file UtilFunc.h.

                                                                                    {
        return 2. / (upperEdge - lowerEdge);
    } 

Variable Documentation

RtScaleFunction_p

std::array<double, 6> MuonCalib::RtScaleFunction_p {-0.00102327, 0.00582117, -0.00676815, 0.00167504, -8.67371e-05, 1.66509e-06}

staticconstexpr

Definition at line 11 of file RtScaleFunction.cxx.

{-0.00102327, 0.00582117, -0.00676815, 0.00167504, -8.67371e-05, 1.66509e-06};