Base

Description

Base functor for any Double Crystal Ball function

The idea is manyfold:

• store the values of the parameters and of the intermediate steps of the calculation for potential debugging
• keep the same structure for the distribution itself as well as for the integral of for the derivative

#include <DoubleCrystalBall.h>

Inheritance diagram for Base:

Public Member Functions
double	Z (double x)
void	SetParameters (double *p)
virtual void	Eval (double *x)=0
double	operator() (double *x, double *p)
	Base (TF1 *f=nullptr)
void	dump ()
virtual	~Base ()=default

Public Attributes
double	N
double	mu
double	sigma
double	kL
double	nL
double	kR
double	nR
double	AL
double	AR
double	BL
double	BR
double	z
double	aR
double	aL
double	expaR2
double	expaL2
double	CR
double	CL
double	DD
double	K
double	result

Constructor & Destructor Documentation

Base()

Base

(

TF1 *

f = nullptr

)

If a TF1 is given, then the parameters are taken from f.

                   :
    N(1), mu(0), sigma(1), kL(-dinf), nL(2), kR(dinf), nR(2), // basic parameters
    z(0), aR(dinf), aL(-dinf), // normalised parameters
    expaR2(0), expaL2(0), // values of core at transition points
    CR(0), CL(0), DD(sqrt(2*M_PI)), // normalisation
    result(0)
{
    if (f == nullptr) return;
    assert(f->GetNpar() == 7);
    double * p = f->GetParameters();
    SetParameters(p);
}

~Base()

virtual ~Base ( )

virtualdefault

Default destructor will be taken from the daughter class.

Member Function Documentation

dump()

void dump

(

)

Just dump all internal parameters AND the last result.

{
    cout << setw(10) << N
         << setw(10) << mu
         << setw(10) << sigma
         << setw(10) << kL
         << setw(10) << nL
         << setw(10) << kR
         << setw(10) << nR
 
         << setw(10) << z
         << setw(10) << aR
         << setw(10) << aL
 
         << setw(10) << expaR2
         << setw(10) << expaL2
 
         << setw(10) << CR
         << setw(10) << CL
         << setw(10) << DD
 
         << setw(10) << result
 
         << endl;
}

Eval()

virtual void Eval ( double *  x )

pure virtual

Virtual method to calculate the value of the function, given the internal set of parameters and the value of x given as parameter.

Implemented in DLog, Integral, and Distribution.

operator()()

double operator()	(	double *	x,
		double *	p
	)

Standard form as requested from ROOT TF1 objects.

{
    SetParameters(p); // store all parameters (also for external use)
    z = Z(*x);
    Eval(x); // this changes according to the derived class
    return result;
}

SetParameters()

void SetParameters

(

double *

p

)

Retrieves the parameters from p and calculate all intermediate steps of the calculation.

{
    N = p[0];
    mu = p[1];
    sigma = max(1e-8,abs(p[2]));
    assert(sigma > 0);
    kL = min(mu-1e-8,p[3]);
    nL = max(1+deps,p[4]);
    kR = max(mu+1e-8,p[5]);
    nR = max(1+deps,p[6]);
 
    aR = abs(Z(kR));
    aL = abs(Z(kL));
 
    expaR2 = exp(-pow(aR,2)/2.);
    expaL2 = exp(-pow(aL,2)/2.);
 
    AR = pow(nR/aR,nR) * expaR2;
    AL = pow(nL/aL,nL) * expaL2;
    BR =     nR/aR    - aR;
    BL =     nL/aL    + aL;
    // these parameters are usually used in the analytical formula
    // e.g. on Wikipedia
    // but in practice the n^n factor can get too large
    // therefore we actually do not use them in practice
    // but we still calculate them 
 
    CR = nR * expaR2 / (aR*(nR-1));
    CL = nL * expaL2 / (aL*(nL-1));
    DD = sqrt(M_PI/2.)*(erf(aR/sqrt(2)) + erf(aL/sqrt(2)));
    K = CR + CL + DD;
}

Z()

double Z ( double  x )

inline

Calculate the normalised version of x for Gaussian core.

    {
        return (x-mu)/sigma;
    }

Member Data Documentation

AL

double AL

LHS tail normalisation.

aL

double aL

normalised LHS turn-on point

AR

double AR

RHS tail normalisation.

aR

double aR

normalised RHS turn-on point

BL

double BL

LHS offset.

BR

double BR

RHS offset.

CL

double CL

area in LHS tail

CR

double CR

area in RHS tail

DD

double DD

area in core

expaL2

double expaL2

value of core at normalised LHS turn-on point

expaR2

double expaR2

value of core at normalised RHS turn-on point

K

double K

total normalisation

kL

double kL

LHS turn-on point.

kR

double kR

RHS turn-on point.

mu

double mu

mean

N

double N

global normalisation (best is to fix it to one)

nL

double nL

LHS power.

nR

double nR

RHS power.

result

double result

store last evaludation

sigma

double sigma

width

z

double z

normalised resolution

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JEC/interface/DoubleCrystalBall.h
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JEC/src/DoubleCrystalBall.cc