CMSSW Reference Manual

enum MultipleScatteringParametrisation::Consecutive

Enumerator:

notAssumeConsecutive
useConsecutive

Definition at line 23 of file MultipleScatteringParametrisation.h.

00023 { notAssumeConsecutive, useConsecutive };

enum MultipleScatteringParametrisation::X0Source

Enumerator:

useDetLayer
useX0AtEta
useX0DataAveraged

Definition at line 22 of file MultipleScatteringParametrisation.h.

00022 { useDetLayer, useX0AtEta, useX0DataAveraged };

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

Definition at line 26 of file MultipleScatteringParametrisation.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), MSLayersKeeper::init(), MSLayersKeeper::layer(), theLayer, theLayerKeeper, useDetLayer, useX0AtEta, and useX0DataAveraged.

00028 {
00029   switch (x0Source) {
00030   case useX0AtEta: { 
00031     static MSLayersKeeperX0AtEta x0AtEta; 
00032     theLayerKeeper = &x0AtEta;
00033     break;
00034   }
00035   case useX0DataAveraged: {
00036     static MSLayersKeeperX0Averaged x0Averaged;
00037     theLayerKeeper = &x0Averaged;
00038     break;
00039   }
00040 
00041   case useDetLayer: {
00042     static MSLayersKeeperX0DetLayer x0DetLayer;
00043     theLayerKeeper = &x0DetLayer;
00044     break;
00045   }
00046   default:
00047     cout << "** MultipleScatteringParametrisation ** wrong x0Source"<<endl;
00048     return;
00049   }
00050   theLayerKeeper->init(iSetup);
00051   if (!layer) return;
00052   theLayer = theLayerKeeper->layer(layer);
00053 }

float MultipleScatteringParametrisation::operator()	(	float	pt,
		const PixelRecoPointRZ &	point1,
		const PixelRecoPointRZ &	point2,
		Consecutive	consecutive = `notAssumeConsecutive`
	)			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 84 of file MultipleScatteringParametrisation.cc.

References PixelRecoLineRZ::cotLine(), MSLayer::crossing(), dist(), MSLayersKeeper::layers(), PixelRecoPointRZ::r(), funct::sqrt(), MSLayersAtAngle::sumX0D(), theLayer, theLayerKeeper, useConsecutive, MSLayer::x0(), and x0ToSigma.

00089 {   
00090 //   static TimingReport::Item * theTimer =
00091 //       initTiming("MultScattering 2p constraint",5);
00092 //   TimeMe tm( *theTimer, false);
00093 
00094 
00095   PixelRecoLineRZ lineIO(pointI, pointO);
00096   PixelRecoPointRZ pointM = theLayer.crossing(lineIO).first;
00097   float cotTheta = lineIO.cotLine();
00098 
00099   if (consecutive==useConsecutive) {
00100     float dist = fabs(  (pointO.r()-pointM.r())
00101                       * (pointM.r()-pointI.r())
00102                       / (pointO.r()-pointI.r()) );
00103     return  x0ToSigma * sqrt(theLayer.x0(cotTheta)) * dist /pT;
00104   } else {
00105     const MSLayersAtAngle & layersAtEta = theLayerKeeper->layers(cotTheta);
00106     float sumX0D = layersAtEta.sumX0D(pointI, pointM, pointO);
00107     return x0ToSigma * sumX0D /pT;
00108   }
00109 }

float MultipleScatteringParametrisation::operator()	(	float	pt,
		float	cotTheta,
		const PixelRecoPointRZ &	point
	)			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 67 of file MultipleScatteringParametrisation.cc.

References MSLayer::crossing(), MSLayersKeeper::layers(), MSLayersAtAngle::sumX0D(), theLayer, theLayerKeeper, and x0ToSigma.

00069 {
00070 //   static TimingReport::Item * theTimer =
00071 //       initTiming("MultScattering 1p constraint",5);
00072 //   TimeMe tm( *theTimer, false);
00073 
00074   PixelRecoLineRZ lineIO(pointI,cotTheta);
00075   PixelRecoPointRZ pointO = theLayer.crossing(lineIO).first;
00076 
00077   const MSLayersAtAngle & layersAtEta = theLayerKeeper->layers(cotTheta);
00078   
00079   float sumX0D = layersAtEta.sumX0D(pointI, pointO);
00080   return x0ToSigma * sumX0D /pT;
00081 }

float MultipleScatteringParametrisation::operator()	(	float	pt,
		float	cotTheta
	)			const

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

Definition at line 56 of file MultipleScatteringParametrisation.cc.

References MSLayer::sumX0D(), theLayer, and x0ToSigma.

00058 {
00059 //   static TimingReport::Item * theTimer =
00060 //      initTiming("MultScattering from vertex",5);
00061 //   TimeMe tm( *theTimer, false);
00062   float sumX0D = theLayer.sumX0D(cotTheta); 
00063   return x0ToSigma * sumX0D /pT;
00064 }

MSLayer MultipleScatteringParametrisation::theLayer [private]

Definition at line 52 of file MultipleScatteringParametrisation.h.

Referenced by MultipleScatteringParametrisation(), and operator()().

MSLayersKeeper* MultipleScatteringParametrisation::theLayerKeeper [private]

Definition at line 53 of file MultipleScatteringParametrisation.h.

Referenced by MultipleScatteringParametrisation(), and operator()().

const float MultipleScatteringParametrisation::x0ToSigma = 0.0136 [static, private]

Definition at line 54 of file MultipleScatteringParametrisation.h.

Referenced by operator()().

MultipleScatteringParametrisation Class Reference

Public Types

Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Types
enum	Consecutive { notAssumeConsecutive, useConsecutive }
enum	X0Source { useDetLayer, useX0AtEta, useX0DataAveraged }
Public Member Functions
	MultipleScatteringParametrisation (const DetLayer *layer, const edm::EventSetup &iSetup, X0Source x0source=useX0AtEta)
float	operator() (float pt, const PixelRecoPointRZ &point1, const PixelRecoPointRZ &point2, Consecutive consecutive=notAssumeConsecutive) 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.
float	operator() (float pt, float cotTheta, const PixelRecoPointRZ &point) const
	MS sigma at the layer for which parametrisation is initialised; particle assumed to come from constraint point (inner to layer).
float	operator() (float pt, float cotTheta) const
	MS sigma at the layer for which parametrisation is initialised; particle assumed to come from nominal vertex, "fast" methods called.
Private Attributes
MSLayer	theLayer
MSLayersKeeper *	theLayerKeeper
Static Private Attributes
static const float	x0ToSigma = 0.0136