Correlator< FunctionalForm >

Description

template<typename FunctionalForm>
struct Step::Correlator< FunctionalForm >

A class to account for the correlations when fitting.

#include <Step.h>

Collaboration diagram for Correlator< FunctionalForm >:

Public Member Functions
	Correlator (TH1 *h, TH2 *hcov, int im, int iM, FunctionalForm &ff, std::ostream &Stream=std::cout)
double	operator() (const double *p)
void	SetReplica (UInt_t seed)
void	UnsetReplica ()

Public Attributes
const int	n
TVectorD	c
TVectorD	e
TVectorD	v
TVectorD	w
TVectorD	s
TMatrixD	cov
TMatrixD	rot
TMatrixD	invcov
FunctionalForm &	f
std::ostream &	stream

Constructor & Destructor Documentation

Correlator()

Correlator ( TH1 *  h, TH2 *  hcov, int  im, int  iM, FunctionalForm &  ff, std::ostream &  Stream = std::cout  )

inline

Constructor

Performs first sanity checks, then converts histograms to vector/matrix.

Parameters

h	input histogram (normalised to bin width if appropriate)
hcov	covariance histogram
im	first bin where to start the fit
iM	last bin where to stop the fit
ff	fit function
Stream	stream (e.g. `cout`)

              :
        n(iM-im+1), c(n), e(n+1), v(n), w(n), s(n), cov(n,n), rot(n,n), invcov(n,n), f(ff), stream(Stream)
    {
        using namespace std;
 
        // sanity checks
 
        if (verbose)
            stream << "n = " << n << '\n';
 
        if (verbose)
            stream << "Checking histogram\n";
        for (int i = im; i <= iM; ++i) {
            auto content = h->GetBinContent(i);
            if (verbose)
                stream << setw(3) << i
                       << setw(12) << h->GetBinCenter(i)
                       << setw(12) << content << '\n';
            assert(isnormal(content));
        }
 
        if (hcov != nullptr) {
            if (verbose)
                stream << "Checking covariance\n";
            for (int i = im; i <= iM; ++i)
            for (int j = im; j <= iM; ++j) {
                auto content = hcov->GetBinContent(i,j);
                if (verbose) {
                    stream << setw(12) << content;
                    if (j == iM) stream << '\n';
                }
                assert(isfinite(content));
            }
        }
 
        // conversion for matrix algebra
 
        int shift = im;
        if (verbose)
            stream << "Converting from histograms to vector and matrix (shift = " << shift << "):";
        for (int i = 0; i < n; ++i) {
            e(i) = h->GetBinLowEdge(i+shift);
            c(i) = h->GetBinCenter (i+shift);
            v(i) = h->GetBinContent(i+shift);
            if (verbose)
                stream << '\n' << setw(5) << i << setw(10) << c(i) << setw(15) << v(i) << setw(15);
            assert(abs(v(i)) > 0);
            for (int j = 0; j < n; ++j) {
                cov(i,j) = hcov != nullptr ? hcov->GetBinContent(i+shift,j+shift)
                                  : i == j ? pow(h->GetBinError(i+shift),2) : 0;
                if (i == j && verbose) stream << (100*sqrt(cov(i,j))/v(i)) << '%';
            }
        }
        e(n) = h->GetBinLowEdge(n+shift);
        if (verbose)
            stream << '\n';
 
        if (!cov.IsSymmetric()) {
            if (verbose)
                stream << "Forcing to be symmetric\n";
 
            auto cov2 = cov;
            cov2.T();
            cov += cov2;
            cov *= 0.5;
            assert(cov.IsSymmetric());
        }
 
        // preparing variables for replicas
        w = v;
        rot = cov.EigenVectors(s); // `s` will be modified here, but will be overwritten later
        if (verbose)
            stream << "Getting eigenvalues, expect different columns only in case of non-zero bin-to-bin correlations:";
        for (int k = 0; k < n; ++k) {
            if (verbose)
                stream << '\n' << setw(5) << k << setw(15) << s[k] << setw(15) << cov(k,k);
            s(k) = sqrt(s(k)); // to be used as input of `TRandom3::Gaus()`
            assert(s[k] > 0);
        }
        if (verbose)
            stream << '\n';
 
        // inverting
        if (verbose)
            stream << "Inverting...\n";
        TDecompSVD svd(cov);
        svd.SetTol(eps);
        bool status = false;
        invcov = svd.Invert(status);
        assert(status);
 
        if (verbose)
            stream << "Ready to fit\n";
    }

Member Function Documentation

operator()()

double operator() ( const double *  p )

inline

operator overloading for the functor to be used with ROOT::Math::Minimizer

    {
        auto r = w;
        for (int i = 0; i < n; ++i) {
            auto y0 = f(&e(i), p),
                 y1 = f(&c(i), p),
                 y2 = f(&e(i+1), p);
            r(i) -= (y0+4*y1+y2)/6;
        }
        return r * (invcov * r);
    }

SetReplica()

void SetReplica ( UInt_t  seed )

inline

    {
        TRandom3 r(seed);
 
        TVectorD d(n);
        for (int k = 0; k < n; ++k)
            d(k) = r.Gaus(0, s(k));
 
        w = v + rot*d;
    }

UnsetReplica()

void UnsetReplica ( )

inline

    {
        w = v;
    }

Member Data Documentation

c

TVectorD c

bin center

cov

TMatrixD cov

covariance matrix

e

TVectorD e

bin edge

f

FunctionalForm& f

fit function

invcov

TMatrixD invcov

inverse of covariance matrix

n

const int n

#bins

rot

TMatrixD rot

rotation matrix

s

TVectorD s

sqrt(eigenvalues)

stream

std::ostream& stream

stream (e.g. cout or file)

v

TVectorD v

xsection value

w

TVectorD w

replica

---

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

• interface/Step.h