PhysicsTools::LeastSquares Class Reference

#include <LeastSquares.h>

Public Member Functions
void	add (const std::vector< double > &values, double dest, double weight=1.0)
void	add (const LeastSquares &other, double weight=1.0)
void	calculate ()
const TMatrixDSym &	getCoefficients () const
double	getConstant () const
const TMatrixDSym &	getCorrelations () const
const TMatrixDSym &	getCovariance () const
std::vector< double >	getMeans () const
const TMatrixD &	getRotation ()
unsigned int	getSize () const
std::vector< double >	getWeights () const
	LeastSquares (unsigned int n)
void	load (XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *elem)
XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *	save (XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc) const
virtual	~LeastSquares ()

Static Public Member Functions
static TVectorD	solveFisher (const TMatrixDSym &coeffs)
static TMatrixD	solveRotation (const TMatrixDSym &covar, TVectorD &trace)

Private Attributes
TMatrixDSym	coeffs
TMatrixDSym	corr
TMatrixDSym	covar
const unsigned int	n
TMatrixD	rotation
TVectorD	trace
TVectorD	variance
TVectorD	weights

Detailed Description

Definition at line 14 of file LeastSquares.h.

Constructor & Destructor Documentation

PhysicsTools::LeastSquares::LeastSquares

(

unsigned int

n

)

Definition at line 22 of file LeastSquares.cc.

                                         :
    coeffs(n + 2), covar(n + 1), corr(n + 1), rotation(n, n),
    weights(n + 1), variance(n + 1), trace(n), n(n)
{
}

PhysicsTools::LeastSquares::~LeastSquares ( )

virtual

Definition at line 28 of file LeastSquares.cc.

{
}

Member Function Documentation

void PhysicsTools::LeastSquares::add	(	const std::vector< double > &	values,
		double	dest,
		double	weight = 1.0
	)

Definition at line 32 of file LeastSquares.cc.

References coeffs, i, j, n, and CommonMethods::weight().

{
    if (values.size() != n)
        throw cms::Exception("LeastSquares")
            << "add(): invalid array size!" << std::endl;

    for(unsigned int i = 0; i < n; i++) {
        for(unsigned int j = 0; j < n; j++)
            coeffs(i, j) += values[i] * values[j] * weight;

        coeffs(n, i) += values[i] * dest * weight;
        coeffs(i, n) += values[i] * dest * weight;
        coeffs(n + 1, i) += values[i] * weight;
        coeffs(i, n + 1) += values[i] * weight;
    } 

    coeffs(n, n) += dest * dest * weight;
    coeffs(n + 1, n) += dest * weight;
    coeffs(n, n + 1) += dest * weight;
    coeffs(n + 1, n + 1) += weight;
}

void PhysicsTools::LeastSquares::add	(	const LeastSquares &	other,
		double	weight = 1.0
	)

Definition at line 55 of file LeastSquares.cc.

References coeffs, getSize(), and n.

{
    if (other.getSize() != n)
        throw cms::Exception("LeastSquares")
            << "add(): invalid array size!" << std::endl;

    coeffs += weight * other.coeffs;
}

void PhysicsTools::LeastSquares::calculate

(

)

Definition at line 87 of file LeastSquares.cc.

References trackerHits::c, coeffs, corr, covar, i, j, N, n, rotation, solveFisher(), solveRotation(), mathSSE::sqrt(), trace, v, variance, w(), and weights.

{
    double N = coeffs(n + 1, n + 1);

    for(unsigned int i = 0; i <= n; i++) {
        double M = coeffs(n + 1, i);
        for(unsigned int j = 0; j <= n; j++)
            covar(i, j) = coeffs(i, j) * N - M * coeffs(n + 1, j);
    }

    for(unsigned int i = 0; i <= n; i++) {
        double c = covar(i, i);
        variance[i] = c > 0.0 ? std::sqrt(c) : 0.0;
    }

    for(unsigned int i = 0; i <= n; i++) {
        double M = variance[i];
        for(unsigned int j = 0; j <= n; j++) {
            double v = M * variance[j];
            double w = covar(i, j);

            corr(i, j) = (v >= 1.0e-9) ? (w / v) : (i == j);
        }
    }

    weights = solveFisher(coeffs);
    rotation = solveRotation(covar, trace);
}

const TMatrixDSym& PhysicsTools::LeastSquares::getCoefficients ( ) const

inline

Definition at line 30 of file LeastSquares.h.

References coeffs.

{ return coeffs; }

double PhysicsTools::LeastSquares::getConstant

(

)

const

Definition at line 139 of file LeastSquares.cc.

References n, and weights.

{
    return weights[n];
}

const TMatrixDSym& PhysicsTools::LeastSquares::getCorrelations ( ) const

inline

Definition at line 32 of file LeastSquares.h.

References corr.

{ return corr; }

const TMatrixDSym& PhysicsTools::LeastSquares::getCovariance ( ) const

inline

Definition at line 31 of file LeastSquares.h.

References covar.

{ return covar; }

std::vector< double > PhysicsTools::LeastSquares::getMeans

(

)

const

Definition at line 127 of file LeastSquares.cc.

References coeffs, i, N, n, and python.entryComment::results.

{
    std::vector<double> results;
    results.reserve(n);

    double N = coeffs(n + 1, n + 1);
    for(unsigned int i = 0; i < n; i++)
        results.push_back(coeffs(n + 1, i) / N);

    return results;
}

const TMatrixD& PhysicsTools::LeastSquares::getRotation ( )

inline

Definition at line 33 of file LeastSquares.h.

References rotation.

{ return rotation; }

unsigned int PhysicsTools::LeastSquares::getSize ( ) const

inline

Definition at line 29 of file LeastSquares.h.

References n.

Referenced by add().

{ return n; }

std::vector< double > PhysicsTools::LeastSquares::getWeights

(

)

const

Definition at line 116 of file LeastSquares.cc.

References i, n, python.entryComment::results, and weights.

{
    std::vector<double> results;
    results.reserve(n);
    
    for(unsigned int i = 0; i < n; i++)
        results.push_back(weights[i]);
    
    return results;
}

void PhysicsTools::LeastSquares::load

(

XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *

elem

)

Definition at line 280 of file LeastSquares.cc.

References trackerHits::c, coeffs, corr, covar, HTMLExport::elem(), edm::hlt::Exception, i, PhysicsTools::loadMatrix(), PhysicsTools::loadVector(), N, n, python.Node::node, pos, rotation, mathSSE::sqrt(), tmp, trace, v, variance, BeamSplash_cfg::version, w(), and weights.

{
    if (std::strcmp(XMLSimpleStr(elem->getNodeName()),
                                 "LinearAnalysis") != 0)
        throw cms::Exception("LeastSquares")
            << "Expected LinearAnalysis in data file."
            << std::endl;

    unsigned int version = XMLDocument::readAttribute<unsigned int>(
                            elem, "version", 1);

    enum Position {
        POS_COEFFS, POS_COVAR, POS_CORR, POS_ROTATION,
        POS_SUMS, POS_WEIGHTS, POS_VARIANCE, POS_TRACE, POS_DONE
    } pos = POS_COEFFS;

    for(DOMNode *node = elem->getFirstChild();
        node; node = node->getNextSibling()) {
        if (node->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        DOMElement *elem = static_cast<DOMElement*>(node);

        switch(pos) {
            case POS_COEFFS:
            if (version < 2) {
                loadMatrix(elem, n + 1, coeffs);
                coeffs.ResizeTo(n + 2, n + 2);
                for(unsigned int i = 0; i <= n; i++) {
                    coeffs(n + 1, i) = coeffs(n, i);
                    coeffs(i, n + 1) = coeffs(i, n);
                }
                coeffs(n + 1, n + 1) = coeffs(n + 1, n);
            } else
                loadMatrix(elem, n + 2, coeffs);
            break;
            case POS_COVAR:
            if (version < 2)
                loadMatrix(elem, n, covar);
            else
                loadMatrix(elem, n + 1, covar);
            break;
            case POS_CORR:
            if (version < 2)
                loadMatrix(elem, n, corr);
            else
                loadMatrix(elem, n + 1, corr);
            break;
            case POS_ROTATION:
            loadMatrix(elem, n, rotation);
            break;
            case POS_SUMS:
            if (version < 2) {
                TVectorD tmp(n + 1);
                loadVector(elem, n + 1, tmp);

                double M = coeffs(n + 1, n);
                double N = coeffs(n + 1, n + 1);

                for(unsigned int i = 0; i <= n; i++) {
                    double v = coeffs(n, i) * N -
                               M * coeffs(n + 1, i);
                    double w = coeffs(n, i) * N - v;

                    covar(n, i) = w;
                    covar(i, n) = w;
                }

                break;
            } else
                pos = (Position)(pos + 1);
            case POS_WEIGHTS:
            loadVector(elem, n + 1, weights);
            break;
            case POS_VARIANCE:
            if (version < 2) {
                loadVector(elem, n, variance);

                double M = covar(n, n);
                M = M > 0.0 ? std::sqrt(M) : 0.0;
                variance[n] = M;

                for(unsigned int i = 0; i <= n; i++) {
                    double v = M * variance[i];
                    double w = covar(n, i);
                    double c = (v >= 1.0e-9)
                            ? (w / v) : (i == n);

                    corr(n, i) = c;
                    corr(i, n) = c;
                }
            } else
                loadVector(elem, n + 1, variance);
            break;
            case POS_TRACE:
            loadVector(elem, n, trace);
            break;
            default:
            throw cms::Exception("LeastSquares")
                << "Superfluous content in data file."
                << std::endl;
        }

        pos = (Position)(pos + 1);
    }

    if (pos != POS_DONE)
        throw cms::Exception("LeastSquares")
            << "Missing objects in data file."
            << std::endl;
}

DOMElement * PhysicsTools::LeastSquares::save

(

XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *

doc

)

const

Definition at line 392 of file LeastSquares.cc.

References coeffs, corr, covar, n, dbtoconf::root, rotation, PhysicsTools::saveMatrix(), PhysicsTools::saveVector(), trace, variance, and weights.

{
    DOMElement *root = doc->createElement(XMLUniStr("LinearAnalysis"));
    XMLDocument::writeAttribute<unsigned int>(root, "version", 2);
    XMLDocument::writeAttribute<unsigned int>(root, "size", n);

    root->appendChild(saveMatrix(doc, n + 2, coeffs));
    root->appendChild(saveMatrix(doc, n + 1, covar));
    root->appendChild(saveMatrix(doc, n + 1, corr));
    root->appendChild(saveMatrix(doc, n, rotation));
    root->appendChild(saveVector(doc, n + 1, weights));
    root->appendChild(saveVector(doc, n + 1, variance));
    root->appendChild(saveVector(doc, n, trace));

    return root;
}

TVectorD PhysicsTools::LeastSquares::solveFisher ( const TMatrixDSym &  coeffs )

static

Definition at line 64 of file LeastSquares.cc.

References coeffs, n, convertSQLiteXML::ok, and tmp.

Referenced by calculate().

{
    unsigned int n = coeffs.GetNrows() - 2;

    TMatrixDSym tmp;
    coeffs.GetSub(0, n, tmp);
    tmp[n] = TVectorD(n + 1, coeffs[n + 1].GetPtr());
    tmp(n, n) = coeffs(n + 1, n + 1);

    TDecompSVD decCoeffs(tmp);
    bool ok;
    return decCoeffs.Solve(TVectorD(n + 1, coeffs[n].GetPtr()), ok);
}

TMatrixD PhysicsTools::LeastSquares::solveRotation ( const TMatrixDSym &  covar, TVectorD &  trace  )

static

Definition at line 78 of file LeastSquares.cc.

References tmp.

Referenced by calculate().

{
    TMatrixDSym tmp;
    covar.GetSub(0, covar.GetNrows() - 2, tmp);
    TDecompSVD decCovar(tmp);
    trace = decCovar.GetSig();
    return decCovar.GetU();
}

Member Data Documentation

TMatrixDSym PhysicsTools::LeastSquares::coeffs

private

Definition at line 44 of file LeastSquares.h.

Referenced by add(), calculate(), getCoefficients(), getMeans(), load(), save(), and solveFisher().

TMatrixDSym PhysicsTools::LeastSquares::corr

private

Definition at line 46 of file LeastSquares.h.

Referenced by calculate(), getCorrelations(), load(), and save().

TMatrixDSym PhysicsTools::LeastSquares::covar

private

Definition at line 45 of file LeastSquares.h.

Referenced by calculate(), getCovariance(), load(), and save().

const unsigned int PhysicsTools::LeastSquares::n

private

Definition at line 51 of file LeastSquares.h.

Referenced by add(), calculate(), getConstant(), getMeans(), getSize(), getWeights(), load(), save(), and solveFisher().

TMatrixD PhysicsTools::LeastSquares::rotation

private

Definition at line 47 of file LeastSquares.h.

Referenced by calculate(), getRotation(), load(), and save().

TVectorD PhysicsTools::LeastSquares::trace

private

Definition at line 50 of file LeastSquares.h.

Referenced by calculate(), load(), and save().

TVectorD PhysicsTools::LeastSquares::variance

private

Definition at line 49 of file LeastSquares.h.

Referenced by calculate(), load(), and save().

TVectorD PhysicsTools::LeastSquares::weights

private

Definition at line 48 of file LeastSquares.h.

Referenced by calculate(), getConstant(), getWeights(), load(), and save().