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

Namespaces
	Legendre

Classes
class	AdaptiveResidualSmoothing

class	ADCMTHistos

class	BaseFunction

class	BaseFunctionFitter

class	BFieldCorFunc

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	CalibrationFileIOTool

class	CalibrationOracleFileIOTool

class	CalibrationTeeIOTool

class	CalibRtDbOperations

class	CalibT0DbOperations

class	ChebyshevPolynomial

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

class	CscCondData

class	CscCondDataCollection

class	CscCondDataCollectionBase

class	CscCondDataContainer

class	CscCondParType

class	CurvedCandidateFinder

class	CurvedLine

class	CurvedPatRec

class	DataBin

class	DataPoint

class	DCSLFitter

class	EventHandler

class	FixedIdDecoder

class	GlobalTimeFitter

class	HistogramId

class	ICalibPatternSelector

class	ICalibrationIOTool

class	ICalibSegmentPreparationTool

class	IConditionsStorage

class	IdToFixedIdTool

class	IIdToFixedIdTool

class	IMdtBackgroundCorFunc
	generic interface for cavern background correction functions More...

class	IMdtBFieldCorFunc
	generic interface for b-field correction functions More...

class	IMdtCalibration

class	IMdtCalibrationOutput

class	IMdtPatRecFitter

class	IMdtSegmentFitter

class	IMdtSegmentSelector

class	IMdtSlewCorFunc
	generic interface for slewing correction functions More...

class	IMdtTempCorFunc
	generic interface for temperature correction functions More...

class	IMooPatternForCalibrationTool

class	IMuonCalibConditionsSource

class	IMuonCalibTool

class	IndexSet

class	INtupleCalibrationTool

class	IRegionSelectorTool

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

class	ITrRelation

class	LegendrePolynomial

class	LocalSegmentResolver

class	LocalToPrecision
	Provides transformation between local and presicion reference frames. More...

class	MdtCalibDataContainer

class	MdtCalibEventLoop

class	MdtCalibHitBase

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

class	MuCCaFitterImplementation

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	MuonCalibCylinder

class	MuonCalibDbCalibrationSource

class	MuonCalibDefaultCalibrationSource

class	MuonCalibDisk

class	MuonCalibEvent

class	MuonCalibEvent_E

class	MuonCalibEventInfo

class	MuonCalibExtendedRawHits

class	MuonCalibExtendedSegment

class	MuonCalibExtendedTrack

struct	MuonCalibExtendedTrackOverlap

class	MuonCalibHit_E

class	MuonCalibHole_E

class	MuonCalibMdtTruthHit

class	MuonCalibMUCTPI
	Simplified class designed to store information from MuCTPi processor. More...

class	MuonCalibPattern

class	MuonCalibRawCscHit

class	MuonCalibRawHitAssociationMap

class	MuonCalibRawHitCollection

class	MuonCalibRawMdtHit

class	MuonCalibRawRpcCoin

class	MuonCalibRawRpcHit

class	MuonCalibRawRpcTriggerHit

class	MuonCalibRawTgcCoin

class	MuonCalibRawTgcHit

class	MuonCalibRawTriggerHitCollection

class	MuonCalibRpcSectorLogic
	Simplified class designed to store information from RpcSectorLogic. More...

class	MuonCalibRpcTruthHit

class	MuonCalibSegment

class	MuonCalibSelector

class	MuonCalibSimpleGeometry

class	MuonCalibSimpleHoleSearch

class	MuonCalibSLPropagator
	straight line propagator More...

class	MuonCalibSurface

class	MuonCalibTgcTruthHit

class	MuonCalibTrack_E

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

class	MuonCalibTruthCollection

class	MuonFixedId

class	MuonFixedIdManipulator

class	MuonFixedIdPrinter

class	MuonFixedLongId

class	MuonSegmentReader

class	MuonSegmentToCalibSegment

class	NtupleStationId

class	PolygonBase

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

class	RpcCondParType

class	RpcOnlineDBEntry
	representation of an online db entry (masked chans) in rpc cond db. More...

class	RtCalibrationAnalytic

class	RtCalibrationCurved

class	RtCalibrationIntegration

class	RtCalibrationOutput

class	RtChebyshev

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

class	RtFullInfo
	addiitonal information used in validation of a rt-relation More...

class	RtLegendre

class	RtParabolicExtrapolation

class	RtRelationLookUp
	Equidistant look up table for rt-relations with the time as key. More...

class	RtResolutionChebyshev

class	RtResolutionFromPoints

class	RtResolutionLookUp
	Equidistant look up table for resolution tables with the time as key. More...

class	RtSimplePolynomial

class	RtSpline

class	SamplePoint

class	SimpleMdtSegmentSelector

class	SimplePatternSelector

class	SimplePolynomial

class	StraightPatRec

class	T0CalibrationClassic

class	T0CalibrationMT

class	T0CalibrationOutput

class	T0ClassicHistos

class	T0ClassicSettings

class	T0MTHistos

class	T0MTSettings

class	T0MTSettingsT0

class	T0MTSettingsTMax

class	T0Refinement

class	TgcCalibHitBase

class	TrChebyshev

class	TrLegendre

class	TrRelationLookUp

class	TrSimplePolynomial

class	TubeDataFromFile

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

class	VariableBinwidthHistogram

class	VariableBinwidthHistogramBin

class	VBHBinPtrSrt

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

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

using	IdHitsMap = std::map< MuonFixedId, std::vector< CalibHitE_Ptr > >
	hit information per station More...

using	IdHitMap = std::map< MuonFixedId, CalibHitE_Ptr >
	hit information per identifier More...

using	StationIntersectedLayerMap = std::map< MuonFixedId, MuonCalibSimpleHoleSearch::Result >
	intersected layers in the simplified geometry per station More...

using	StationIndexSet = std::set< MuonFixedIdManipulator::StationIndex >
	set with station layer index More...

using	IdSet = std::set< MuonFixedId >
	set of identifiers More...

typedef Identifier	MdtBasicRegionId
	define type MdtBasicRegionId for the smallest possible MDT calibration region More...

typedef IdentifierHash	MdtBasicRegionHash
	define type MdtBasicRegionHash for the smallest possible MDT calibration region More...

typedef IdentifierHash	MdtRegionHash
	define type MdtRegionHash More...

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

std::vector< SamplePoint >	fetchDataPoints (const IRtRelation &rtRel, const IRtResolution &resoFunc)
	Constructs a list of sample points from the rt-relation. More...

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

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

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

std::vector< SamplePoint >	normalizeDomain (const std::vector< SamplePoint > &dataPoints)
	Normalizes the domain of the samples points to the interval -1 to 1. More...

double	calculateChi2 (const std::vector< SamplePoint > &dataPoints, const IRtRelation &rtRel)
	Returns the chi2 of the rt-relation w.r.t. More...

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

std::pair< double, double >	interval (const std::vector< SamplePoint > &points)
	Returns the interval covered by the sample points. More...

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

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

Double_t	mt_tmax_fermi (Double_t x, Double_t par)
	The fermi function to be fitted at the trailing slope of the spectrum. More...

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

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

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)

constexpr double	chebyshevPoly1st (const unsigned int order, const double x)
	Returns the n-th Chebyshev polynomial of first kind evaluated at x (c.f. More...

constexpr double	chebyshevPoly2nd (const unsigned int order, const double x)
	Returns the n-th Chebyshev polynomial of second kind evaluated at x (c.f. More...

constexpr double	chebyshevPoly1stPrime (const unsigned int order, const double x)
	Returns the first derivative of the n-th Chebycheb polynomial of the first kind. More...

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

constexpr double	chebyshevPoly1st2Prime (const unsigned int order, const double x)
	Returns the second derivative of the n-th Chebycheb polynomial of the first kind. More...

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

constexpr unsigned long	factorial (const int n)
	Evaluated the n-th factorial at compile time. More...

constexpr unsigned long	binomial (const unsigned n, const unsigned k)
	Calculates the binomial coefficient at compile time. More...

template<int k>
constexpr double	pow (const double x)
	Calculate the power of a variable x at compile time. More...

constexpr double	pow (double x, int power)
	Calculate the power of a variable at run time. More...

constexpr double	legendrePoly (const unsigned l, const double x)
	Calculates the legendre polynomial of rank l at x. More...

constexpr double	legendreDeriv (const unsigned l, const unsigned d, const double x)
	Evaluates the n-th derivative of the l-th Legendre polynomial. More...

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

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)

Detailed Description

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

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 = typedef std::shared_ptr<const MuonCalibHit_E>

hit information per station layer index

Definition at line 20 of file MuonCalibLayerMapping.h.

◆ IdHitMap

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

hit information per identifier

Definition at line 27 of file MuonCalibLayerMapping.h.

◆ IdHitsMap

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

hit information per station

Definition at line 24 of file MuonCalibLayerMapping.h.

◆ IdSet

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

set of identifiers

Definition at line 36 of file MuonCalibLayerMapping.h.

◆ IRtRelationPtr

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

Definition at line 17 of file IRtRelation.h.

◆ IRtResolutionPtr

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

Definition at line 13 of file IRtResolution.h.

◆ ITrRelationPtr

using MuonCalib::ITrRelationPtr = typedef 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 = typedef MdtTubeFitContainer::SingleTubeFit

Definition at line 7 of file MdtTubeFitContainer.cxx.

◆ SingleTubeFullInfo

using MuonCalib::SingleTubeFullInfo = typedef MdtTubeFullInfoContainer::SingleTubeFullInfo

Definition at line 7 of file MdtTubeFullInfoContainer.cxx.

◆ StationIndexHitsMap

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

Definition at line 21 of file MuonCalibLayerMapping.h.

◆ StationIndexSet

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

set with station layer index

Definition at line 33 of file MuonCalibLayerMapping.h.

◆ StationIntersectedLayerMap

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

intersected layers in the simplified geometry per station

Definition at line 30 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.

10 {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()

constexpr 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 100 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 116 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 108 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()

constexpr 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()

constexpr 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()

constexpr 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()

constexpr 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()

constexpr 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()

constexpr 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()

constexpr 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 17 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 29 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 48 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;
     }

◆ interval()

std::pair< double, double > MuonCalib::interval ( const std::vector< SamplePoint > & points )

Returns the interval covered by the sample points.

Definition at line 92 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()

constexpr 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()

constexpr 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 84 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.

35 { 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.

18 { 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 76 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.

99 { 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.

13 { 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.

26 { return hit.dump(stream); }

◆ operator<<() [8/9]

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

Definition at line 61 of file RpcCalibHitBase.cxx.

◆ operator<<() [9/9]

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

Definition at line 70 of file TgcCalibHitBase.cxx.

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

97 { return data.read(is); }

◆ operator>>() [2/2]

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

Definition at line 11 of file RtFullInfo.cxx.

11 { return data.read(is); }

◆ pow() [1/2]

template<int k>

constexpr 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]

constexpr 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 39 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 59 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);
     } 

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ CalibHitE_Ptr

◆ IdHitMap

◆ IdHitsMap

◆ IdSet

◆ IRtRelationPtr

◆ IRtResolutionPtr

◆ ITrRelationPtr

◆ MdtBasicRegionHash

◆ MdtBasicRegionId

◆ MdtRegionHash

◆ SingleTubeFit

◆ SingleTubeFullInfo

◆ StationIndexHitsMap

◆ StationIndexSet

◆ StationIntersectedLayerMap

Enumeration Type Documentation

◆ MdtCalibCreationFlags

◆ MuonCalibTriggerType

Function Documentation

◆ adcfitf_skewnormal()

◆ binomial()

◆ calculateChi2() [1/3]

◆ calculateChi2() [2/3]

◆ calculateChi2() [3/3]

◆ chebyshevPoly1st()

◆ chebyshevPoly1st2Prime()

◆ chebyshevPoly1stPrime()

◆ chebyshevPoly2nd()

◆ chebyshevPoly2nd2Prime()

◆ chebyshevPoly2ndPrime()

◆ clearall()

◆ factorial()

◆ fetchDataPoints() [1/2]

◆ fetchDataPoints() [2/2]

◆ fetchResolution()

◆ get_group_id()

◆ getTLSRandomGen()

◆ interval()

◆ legendreDeriv()

◆ legendrePoly()

◆ mapToUnitInterval()

◆ minMax()

◆ mt_t0_fermi()

◆ mt_tmax_fermi()

◆ MultilayerRtDifference_ScaleFunction()

◆ myexp()

◆ normalizeDomain()

◆ OnlineToOffline()

◆ operator<<() [1/9]

◆ operator<<() [2/9]

◆ operator<<() [3/9]

◆ operator<<() [4/9]

◆ operator<<() [5/9]

◆ operator<<() [6/9]

◆ operator<<() [7/9]

◆ operator<<() [8/9]

◆ operator<<() [9/9]

◆ operator>>() [1/2]

◆ operator>>() [2/2]

◆ pow() [1/2]

◆ pow() [2/2]

◆ resoFromRadius()

◆ RtScaleFunction()

◆ RtScalePolynomial()

◆ swapCoordinates()

◆ TimeSpectrum_func()

◆ unitIntervalPrime()