MultipleScatteringParametrisation Class Reference

#include <MultipleScatteringParametrisation.h>

Public Types
enum	Consecutive { notAssumeConsecutive, useConsecutive }
enum	X0Source { useDetLayer = 0, useX0AtEta = 1, useX0DataAveraged = 2 }

Public Member Functions
void	init (const DetLayer *layer, const edm::EventSetup &iSetup, X0Source x0source=useX0AtEta)
	MultipleScatteringParametrisation ()
	MultipleScatteringParametrisation (const DetLayer *layer, const edm::EventSetup &iSetup, X0Source x0source=useX0AtEta)
float	operator() (float pt, const PixelRecoPointRZ &point1, const PixelRecoPointRZ &point2, Consecutive consecutive=notAssumeConsecutive, float transverseIP=0.) const
float	operator() (float pT, const PixelRecoPointRZ &pointV, const PixelRecoPointRZ &pointO, int ol) const
float	operator() (float pt, float cotTheta, const PixelRecoPointRZ &point, float transverseIP=0.) const
float	operator() (float pt, float cotTheta, const PixelRecoPointRZ &point, int ol) const
float	operator() (float pt, float cotTheta, float transverseIP=0.) const

Static Public Member Functions
static void	initKeepers (const edm::EventSetup &iSetup)

Private Attributes
MSLayer	theLayer
const MSLayersKeeper *	theLayerKeeper = nullptr

Static Private Attributes
static const float	x0ToSigma = 0.0136f

Detailed Description

Parametrisation of multiple scattering sigma in tracker.

Definition at line 16 of file MultipleScatteringParametrisation.h.

Member Enumeration Documentation

Consecutive

enum MultipleScatteringParametrisation::Consecutive

Enumerator
notAssumeConsecutive
useConsecutive

Definition at line 21 of file MultipleScatteringParametrisation.h.

{ notAssumeConsecutive, useConsecutive };

X0Source

enum MultipleScatteringParametrisation::X0Source

Enumerator
useDetLayer
useX0AtEta
useX0DataAveraged

Definition at line 20 of file MultipleScatteringParametrisation.h.

{ useDetLayer = 0, useX0AtEta = 1, useX0DataAveraged = 2 };

Constructor & Destructor Documentation

MultipleScatteringParametrisation() [1/2]

MultipleScatteringParametrisation::MultipleScatteringParametrisation ( )

inline

Definition at line 23 of file MultipleScatteringParametrisation.h.

{}

MultipleScatteringParametrisation() [2/2]

MultipleScatteringParametrisation::MultipleScatteringParametrisation ( const DetLayer *  layer, const edm::EventSetup &  iSetup, X0Source  x0source = useX0AtEta  )

inline

Definition at line 25 of file MultipleScatteringParametrisation.h.

                                                                    {
    init(layer, iSetup, x0source);
  }

References init(), and phase1PixelTopology::layer.

Member Function Documentation

init()

void MultipleScatteringParametrisation::init	(	const DetLayer *	layer,
		const edm::EventSetup &	iSetup,
		X0Source	x0source = useX0AtEta
	)

Definition at line 57 of file MultipleScatteringParametrisation.cc.

                                                                                                                  {
  theLayerKeeper = keepers(x0Source);
 
  // FIXME not thread safe: move elsewhere...
  initKeepers(iSetup);
 
  if (!layer)
    return;
  theLayer = theLayerKeeper->layer(layer);
}

References phase1PixelTopology::layer.

Referenced by MultipleScatteringParametrisation().

initKeepers()

void MultipleScatteringParametrisation::initKeepers ( const edm::EventSetup &  iSetup )

static

Definition at line 53 of file MultipleScatteringParametrisation.cc.

{ keepers.init(iSetup); }

References MSLayersKeeper::init().

operator()() [1/5]

float MultipleScatteringParametrisation::operator()	(	float	pt,
		const PixelRecoPointRZ &	point1,
		const PixelRecoPointRZ &	point2,
		Consecutive	consecutive = notAssumeConsecutive,
		float	transverseIP = 0.
	)		const

MS sigma at the layer for which parametrisation is initialised; particle assumed to be measured at point1 and point2, it is assumed that layer is between point1 and point2. layer by layer contribution is calculated

Definition at line 102 of file MultipleScatteringParametrisation.cc.

                                                                     {
  PixelRecoLineRZ lineIO(pointI, pointO, tip);
  PixelRecoPointRZ pointM = theLayer.crossing(lineIO).first;
  float cotTheta = lineIO.cotLine();
 
  if (consecutive == useConsecutive) {
    float dist = fabs((pointO.r() - pointM.r()) * (pointM.r() - pointI.r()) / (pointO.r() - pointI.r()));
    return x0ToSigma * sqrt(theLayer.x0(cotTheta)) * dist / pT;
  } else {
    const MSLayersAtAngle &layersAtEta = theLayerKeeper->layers(cotTheta);
    float sumX0D = layersAtEta.sumX0D(pointI, pointM, pointO);
    return x0ToSigma * sumX0D / pT;
  }
}

References PixelRecoLineRZ::cotLine(), PVValHelper::pT, PixelRecoPointRZ::r(), mathSSE::sqrt(), MSLayersAtAngle::sumX0D(), and qcdUeDQM_cfi::tip.

operator()() [2/5]

float MultipleScatteringParametrisation::operator()	(	float	pT,
		const PixelRecoPointRZ &	pointV,
		const PixelRecoPointRZ &	pointO,
		int	ol
	)		const

Definition at line 121 of file MultipleScatteringParametrisation.cc.

                                                                  {
  PixelRecoLineRZ lineIO(pointV, pointO);
  PixelRecoPointRZ pointI = theLayer.crossing(lineIO).first;
  float cotTheta = lineIO.cotLine();
 
  const MSLayersAtAngle &layersAtEta = theLayerKeeper->layers(cotTheta);
  float sumX0D = layersAtEta.sumX0D(pointV.z(), theLayer.seqNum(), ol, pointI, pointO);
  return x0ToSigma * sumX0D / pT;
}

References PixelRecoLineRZ::cotLine(), PVValHelper::pT, MSLayersAtAngle::sumX0D(), and PixelRecoPointRZ::z().

operator()() [3/5]

float MultipleScatteringParametrisation::operator()	(	float	pt,
		float	cotTheta,
		const PixelRecoPointRZ &	point,
		float	transverseIP = 0.
	)		const

MS sigma at the layer for which parametrisation is initialised; particle assumed to come from constraint point (inner to layer). layer by layer contribution is calculated

Definition at line 75 of file MultipleScatteringParametrisation.cc.

                                                                     {
  PixelRecoLineRZ lineIO(pointI, cotTheta, tip);
  PixelRecoPointRZ pointO = theLayer.crossing(lineIO).first;
 
  const MSLayersAtAngle &layersAtEta = theLayerKeeper->layers(cotTheta);
 
  float sumX0D = layersAtEta.sumX0D(pointI, pointO);
  return x0ToSigma * sumX0D / pT;
}

References PVValHelper::pT, MSLayersAtAngle::sumX0D(), and qcdUeDQM_cfi::tip.

operator()() [4/5]

float MultipleScatteringParametrisation::operator()	(	float	pt,
		float	cotTheta,
		const PixelRecoPointRZ &	point,
		int	ol
	)		const

Definition at line 88 of file MultipleScatteringParametrisation.cc.

                                                                  {
  PixelRecoLineRZ lineIO(pointI, cotTheta);
  PixelRecoPointRZ pointO = theLayer.crossing(lineIO).first;
 
  const MSLayersAtAngle &layersAtEta = theLayerKeeper->layers(cotTheta);
 
  float sumX0D = layersAtEta.sumX0D(il, theLayer.seqNum(), pointI, pointO);
  return x0ToSigma * sumX0D / pT;
}

References PVValHelper::pT, and MSLayersAtAngle::sumX0D().

operator()() [5/5]

float MultipleScatteringParametrisation::operator()	(	float	pt,
		float	cotTheta,
		float	transverseIP = 0.
	)		const

MS sigma at the layer for which parametrisation is initialised; particle assumed to come from nominal vertex, "fast" methods called

Definition at line 69 of file MultipleScatteringParametrisation.cc.

                                                                                         {
  float sumX0D = theLayer.sumX0D(cotTheta);
  return x0ToSigma * sumX0D / pT;
}

References PVValHelper::pT.

Member Data Documentation

theLayer

MSLayer MultipleScatteringParametrisation::theLayer

private

Definition at line 57 of file MultipleScatteringParametrisation.h.

theLayerKeeper

const MSLayersKeeper* MultipleScatteringParametrisation::theLayerKeeper = nullptr

private

Definition at line 58 of file MultipleScatteringParametrisation.h.

x0ToSigma

const float MultipleScatteringParametrisation::x0ToSigma = 0.0136f

staticprivate

Definition at line 59 of file MultipleScatteringParametrisation.h.