Greta< Log, Exp >

Description

template<double(*)(double) Log = log, double(*)(double) Exp = exp>
struct DAS::Greta< Log, Exp >

Motto: "Greta should not fail"

Automated fitter for steeply falling p_T spectrum.

#include <Greta.h>

Public Member Functions
	Greta (int d, double mi, double Ma)
double	normalise (const double *x) const
double	operator() (const double *x, const double *p) const
const char *	formula ()

Static Public Member Functions
static double	T (double x, int i)
static const char *	T (const char *x, int i)
static const char *	formula (double mi, double Ma, int deg)

Public Attributes
const int	degree
const int	npars
const double	m
const double	M

Constructor & Destructor Documentation

Greta()

Greta ( int  d, double  mi, double  Ma  )

inline

Constructor

min and max are used to transform the variable into [-1,1]

                                        :
        degree(d), npars(d+1), m(mi), M(Ma)
    { }

Member Function Documentation

formula() [1/2]

const char* formula ( )

inline

    {
        return formula(m, M, degree);
    }

formula() [2/2]

static const char* formula ( double  mi, double  Ma, int  deg  )

inlinestatic

    {
        TString result = "[2]"; 
        TString nx = "(-1+2*(log(x)-log([0]))/(log([1])-log([0])))";
        for (int i = 1; i <= deg; ++i) 
            result += Form("+[%d]*%s", i+2, T(nx, i));
        result = "exp(" + result + ")";
        return result.Data();
    }

normalise()

double normalise ( const double *  x ) const

inline

    {
        return -1 + 2* (Log(*x) - Log(m)) / (Log(M) - Log(m));
    }

operator()()

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

inline

    {
        double nx = normalise(x);
        double result = 0;
        for (int i = 0; i <= degree; ++i)
            result += p[i]*T(nx,i);
            //result += p[i]*pow(nx,i);
        return Exp(result);
    }

T() [1/2]

static const char* T ( const char *  x, int  i  )

inlinestatic

    {
        if (i == 0) return Form("1.");
        if (i == 1) return x;
        const char * t1 = T(x, i-1), * t2 = T(x, i-2);
        return Form("2*%s*%s-%s", x, t1, t2);
    }

T() [2/2]

static double T ( double  x, int  i  )

inlinestatic

Chebyshev of first kind.

    {
        if (i == 0) return 1.;
        if (i == 1) return x;
        return 2*x*T(x, i-1)-T(x, i-2);
    }

Member Data Documentation

degree

const int degree

M

const double M

m

const double m

npars

const int npars

---

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

• interface/Greta.h