GblData.cpp

Go to the documentation of this file.

/*
 * GblData.cpp
 *
 *  Created on: Aug 18, 2011
 *      Author: kleinwrt
 */

#include "GblData.h"


GblData::GblData(unsigned int aLabel, double aValue, double aPrec) :
                theLabel(aLabel), theValue(aValue), thePrecision(aPrec), theDownWeight(
                                1.), thePrediction(0.), theParameters(), theDerivatives(), globalLabels(), globalDerivatives() {

}

GblData::~GblData() {
}


void GblData::addDerivatives(unsigned int iRow,
                const std::vector<unsigned int> &labDer, const SMatrix55 &matDer,
                unsigned int iOff, const TMatrixD &derLocal,
                const std::vector<int> &labGlobal, const TMatrixD &derGlobal,
                unsigned int extOff, const TMatrixD &extDer) {

        unsigned int nParMax = 5 + derLocal.GetNcols() + extDer.GetNcols();
        theParameters.reserve(nParMax); // have to be sorted
        theDerivatives.reserve(nParMax);

        for (int i = 0; i < derLocal.GetNcols(); ++i) // local derivatives
                        {
                if (derLocal(iRow - iOff, i)) {
                        theParameters.push_back(i + 1);
                        theDerivatives.push_back(derLocal(iRow - iOff, i));
                }
        }

        for (int i = 0; i < extDer.GetNcols(); ++i) // external derivatives
                        {
                if (extDer(iRow - iOff, i)) {
                        theParameters.push_back(extOff + i + 1);
                        theDerivatives.push_back(extDer(iRow - iOff, i));
                }
        }

        for (unsigned int i = 0; i < 5; ++i) // curvature, offset derivatives
                        {
                if (labDer[i] and matDer(iRow, i)) {
                        theParameters.push_back(labDer[i]);
                        theDerivatives.push_back(matDer(iRow, i));
                }
        }

        globalLabels = labGlobal;
        for (int i = 0; i < derGlobal.GetNcols(); ++i) // global derivatives
                globalDerivatives.push_back(derGlobal(iRow - iOff, i));
}


void GblData::addDerivatives(unsigned int iRow,
                const std::vector<unsigned int> &labDer, const SMatrix27 &matDer,
                unsigned int extOff, const TMatrixD &extDer) {

        unsigned int nParMax = 7 + extDer.GetNcols();
        theParameters.reserve(nParMax); // have to be sorted
        theDerivatives.reserve(nParMax);

        for (int i = 0; i < extDer.GetNcols(); ++i) // external derivatives
                        {
                if (extDer(iRow, i)) {
                        theParameters.push_back(extOff + i + 1);
                        theDerivatives.push_back(extDer(iRow, i));
                }
        }

        for (unsigned int i = 0; i < 7; ++i) // curvature, offset derivatives
                        {
                if (labDer[i] and matDer(iRow, i)) {
                        theParameters.push_back(labDer[i]);
                        theDerivatives.push_back(matDer(iRow, i));
                }
        }
}


void GblData::addDerivatives(const std::vector<unsigned int> &index,
                const std::vector<double> &derivatives) {
        for (unsigned int i = 0; i < derivatives.size(); ++i) // any derivatives
                        {
                if (derivatives[i]) {
                        theParameters.push_back(index[i]);
                        theDerivatives.push_back(derivatives[i]);
                }
        }
}

void GblData::setPrediction(const VVector &aVector) {

        thePrediction = 0.;
        for (unsigned int i = 0; i < theDerivatives.size(); ++i) {
                thePrediction += theDerivatives[i] * aVector(theParameters[i] - 1);
        }
}


double GblData::setDownWeighting(unsigned int aMethod) {

        double aWeight = 1.;
        double scaledResidual = fabs(theValue - thePrediction) * sqrt(thePrecision);
        if (aMethod == 1) // Tukey
                        {
                if (scaledResidual < 4.6851) {
                        aWeight = (1.0 - 0.045558 * scaledResidual * scaledResidual);
                        aWeight *= aWeight;
                } else {
                        aWeight = 0.;
                }
        } else if (aMethod == 2) //Huber
                        {
                if (scaledResidual >= 1.345) {
                        aWeight = 1.345 / scaledResidual;
                }
        } else if (aMethod == 3) //Cauchy
                        {
                aWeight = 1.0 / (1.0 + (scaledResidual * scaledResidual / 5.6877));
        }
        theDownWeight = aWeight;
        return aWeight;
}


double GblData::getChi2() const {
        double aDiff = theValue - thePrediction;
        return aDiff * aDiff * thePrecision * theDownWeight;
}

void GblData::printData() const {

        std::cout << " meas. " << theLabel << "," << theValue << "," << thePrecision
                        << std::endl;
        std::cout << " param " << theParameters.size() << ":";
        for (unsigned int i = 0; i < theParameters.size(); ++i) {
                std::cout << " " << theParameters[i];
        }
        std::cout << std::endl;
        std::cout << " deriv " << theDerivatives.size() << ":";
        for (unsigned int i = 0; i < theDerivatives.size(); ++i) {
                std::cout << " " << theDerivatives[i];
        }
        std::cout << std::endl;
}


void GblData::getLocalData(double &aValue, double &aWeight,
                std::vector<unsigned int>* &indLocal, std::vector<double>* &derLocal) {

        aValue = theValue;
        aWeight = thePrecision * theDownWeight;
        indLocal = &theParameters;
        derLocal = &theDerivatives;
}


void GblData::getAllData(float &fValue, float &fErr,
                std::vector<unsigned int>* &indLocal, std::vector<double>* &derLocal,
                std::vector<int>* &labGlobal, std::vector<double>* &derGlobal) {
        fValue = theValue;
        fErr = 1.0 / sqrt(thePrecision);
        indLocal = &theParameters;
        derLocal = &theDerivatives;
        labGlobal = &globalLabels;
        derGlobal = &globalDerivatives;
}


void GblData::getResidual(double &aResidual, double &aVariance,
                double &aDownWeight, std::vector<unsigned int>* &indLocal,
                std::vector<double>* &derLocal) {
        aResidual = theValue - thePrediction;
        aVariance = 1.0 / thePrecision;
        aDownWeight = theDownWeight;
        indLocal = &theParameters;
        derLocal = &theDerivatives;
}