#include <RoccoR.h>

Collaboration diagram for RocRes:

Classes
struct	ResParams

Public Types
enum	TYPE { MC, Data, Extra }

Public Member Functions
	RocRes ()

int	etaBin (double x) const

int	trkBin (double x, int h, TYPE T=MC) const

void	reset ()

double	rndm (int H, int F, double v) const

double	Sigma (double pt, int H, int F) const

double	kSpread (double gpt, double rpt, double eta, int nlayers, double w) const

double	kSpread (double gpt, double rpt, double eta) const

double	kSmear (double pt, double eta, TYPE type, double v, double u) const

double	kSmear (double pt, double eta, TYPE type, double v, double u, int n) const

double	kExtra (double pt, double eta, int nlayers, double u, double w) const

double	kExtra (double pt, double eta, int nlayers, double u) const

Public Attributes
int	NETA

int	NTRK

int	NMIN

std::vector< ResParams >	resol

Member Enumeration Documentation

◆ TYPE

enum TYPE

Enumerator
MC
Data
Extra

89 {MC, Data, Extra};

Constructor & Destructor Documentation

◆ RocRes()

RocRes ( )

               {
     reset();
 }

Member Function Documentation

◆ etaBin()

int etaBin ( double x ) const

                                   {
     double abseta=fabs(eta);
     for(int i=0; i<NETA-1; ++i) if(abseta<resol[i+1].eta) return i;
     return NETA-1;
 }

◆ kExtra() [1/2]

double kExtra	(	double	pt,
		double	eta,
		int	nlayers,
		double	u
	)		const

                                                                  {
     int H = etaBin(fabs(eta));
     int F = n>NMIN ? n-NMIN : 0;
     const ResParams &rp = resol[H];
     double d = rp.kRes[Data];
     double m = rp.kRes[MC];
     double x = d>m ? sqrt(d*d-m*m) * Sigma(pt, H, F) * rp.cb[F].invcdf(u) : 0;
     if(x<=-1) return 1.0;
     return 1.0/(1.0 + x); 
 }

◆ kExtra() [2/2]

double kExtra	(	double	pt,
		double	eta,
		int	nlayers,
		double	u,
		double	w
	)		const

                                                                            {
     int H = etaBin(fabs(eta));
     int F = n>NMIN ? n-NMIN : 0;
     const ResParams &rp = resol[H];
     double v = rp.nTrk[MC][F]+(rp.nTrk[MC][F+1]-rp.nTrk[MC][F])*w;
     int D = trkBin(v, H, Data);
     double RD = rp.kRes[Data]*Sigma(pt, H, D);
     double RM = rp.kRes[MC]*Sigma(pt, H, F);
     double x = RD>RM ? sqrt(RD*RD-RM*RM)*rp.cb[F].invcdf(u) : 0;
     if(x<=-1) return 1.0;
     return 1.0/(1.0 + x); 
 }

◆ kSmear() [1/2]

double kSmear	(	double	pt,
		double	eta,
		TYPE	type,
		double	v,
		double	u
	)		const

                                                                                {
     int H = etaBin(fabs(eta));
     int F = trkBin(v, H); 
     const ResParams &rp = resol[H];
     double x = rp.kRes[type] * Sigma(pt, H, F) * rp.cb[F].invcdf(u);
     return 1.0/(1.0+x);
 }

◆ kSmear() [2/2]

double kSmear	(	double	pt,
		double	eta,
		TYPE	type,
		double	v,
		double	u,
		int	n
	)		const

                                                                                       {
     int H = etaBin(fabs(eta));
     int F = n-NMIN;
     if(type==Data) F = trkBin(rndm(H, F, w), H, Data);
     const ResParams &rp = resol[H];
     double x = rp.kRes[type] * Sigma(pt, H, F) * rp.cb[F].invcdf(u);
     return 1.0/(1.0+x);
 }

◆ kSpread() [1/2]

double kSpread	(	double	gpt,
		double	rpt,
		double	eta
	)		const

                                                               {
     int H = etaBin(fabs(eta));
     const auto &k = resol[H].kRes;
     double x = gpt/rpt;
     return x / (1.0 + (x-1.0)*k[Data]/k[MC]);
 }

◆ kSpread() [2/2]

double kSpread	(	double	gpt,
		double	rpt,
		double	eta,
		int	nlayers,
		double	w
	)		const

                                                                                {
     int H = etaBin(fabs(eta));
     int F = n>NMIN ? n-NMIN : 0;
     double v = rndm(H, F, w);
     int D = trkBin(v, H, Data);
     double kold = gpt / rpt;
     const ResParams &rp = resol[H];
     double u = rp.cb[F].cdf( (kold-1.0)/rp.kRes[MC]/Sigma(gpt,H,F) ); 
     double knew = 1.0 + rp.kRes[Data]*Sigma(gpt,H,D)*rp.cb[D].invcdf(u);
  
     if(knew<0) return 1.0;
     return kold/knew;
 }

◆ reset()

void reset ( )

                   {
     NETA=0;
     NTRK=0;
     NMIN=0;
     std::vector<ResParams>().swap(resol);
 }

◆ rndm()

double rndm	(	int	H,
		int	F,
		double	v
	)		const

                                                {
     const ResParams &rp = resol[H];
     return rp.nTrk[MC][F]+(rp.nTrk[MC][F+1]-rp.nTrk[MC][F])*w; 
 }

◆ Sigma()

double Sigma	(	double	pt,
		int	H,
		int	F
	)		const

                                                  {
     double dpt=pt-45;
     const ResParams &rp = resol[H];
     return rp.rsPar[0][F] + rp.rsPar[1][F]*dpt + rp.rsPar[2][F]*dpt*dpt;
 }

◆ trkBin()

int trkBin	(	double	x,
		int	h,
		TYPE	T = `MC`
	)		const

                                                {
     for(int i=0; i<NTRK-1; ++i) if(x<resol[h].nTrk[T][i+1]) return i;
     return NTRK-1;
 }

Member Data Documentation

◆ NETA

int NETA

◆ NMIN

int NMIN

◆ NTRK

int NTRK

◆ resol

std::vector<ResParams> resol

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

/builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Muons/interface/RoccoR.h
/builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Muons/src/RoccoR.cc

Classes

Public Types

Public Member Functions

Public Attributes