GblData.h

Go to the documentation of this file.

/*
 * GblData.h
 *
 *  Created on: Aug 18, 2011
 *      Author: kleinwrt
 */
 
#ifndef GBLDATA_H_
#define GBLDATA_H_
 
#include<iostream>
#include<vector>
#include <array>
#include<math.h>
#include "VMatrix.h"
 
#include <Eigen/Core>
 
namespace gbl {
 
typedef Eigen::Matrix<double, 5, 5> Matrix5d;
typedef Eigen::Matrix<double, 2, 7> Matrix27d;
 
enum dataBlockType {
        None, InternalMeasurement, InternalKink, ExternalSeed, ExternalMeasurement
};
 
 
class GblData {
public:
        GblData(unsigned int aLabel, dataBlockType aType, double aMeas,
                        double aPrec, unsigned int aTraj = 0, unsigned int aPoint = 0);
        GblData(const GblData&) = default;
        GblData& operator=(const GblData&) = default;
        GblData(GblData&&) = default;
        GblData& operator=(GblData&&) = default;
        virtual ~GblData();
 
 
        template<typename LocalDerivative, typename ExtDerivative>
        void addDerivatives(unsigned int iRow,
                        const std::array<unsigned int, 5>& labDer, const Matrix5d &matDer,
                        unsigned int iOff,
                        const Eigen::MatrixBase<LocalDerivative>& derLocal,
                        unsigned int extOff,
                        const Eigen::MatrixBase<ExtDerivative>& extDer);
 
 
        template<typename ExtDerivative>
        void addDerivatives(unsigned int iRow,
                        const std::array<unsigned int, 7>& labDer, const Matrix27d &matDer,
                        unsigned int extOff,
                        const Eigen::MatrixBase<ExtDerivative>& extDer);
 
        void addDerivatives(const std::vector<unsigned int> &index,
                        const std::vector<double> &derivatives);
 
        void setPrediction(const VVector &aVector);
        double setDownWeighting(unsigned int aMethod);
        double getChi2() const;
        void printData() const;
        unsigned int getLabel() const;
        dataBlockType getType() const;
        unsigned int getNumSimple() const;
        void getLocalData(double &aValue, double &aWeight, unsigned int &numLocal,
                        unsigned int* &indLocal, double* &derLocal);
        void getAllData(double &aValue, double &aErr, unsigned int &numLocal,
                        unsigned int* &indLocal, double* &derLocal, unsigned int &aTraj,
                        unsigned int &aPoint, unsigned int &aRow);
        void getResidual(double &aResidual, double &aVariance, double &aDownWeight,
                        unsigned int &numLocal, unsigned int* &indLocal, double* &derLocal);
 
private:
        unsigned int theLabel; 
        unsigned int theRow; 
        dataBlockType theType; 
        double theValue; 
        double thePrecision; 
        unsigned int theTrajectory; 
        unsigned int thePoint; 
        unsigned int theDWMethod; 
        double theDownWeight; 
        double thePrediction; 
        // standard local parameters (curvature, offsets), fixed size
        unsigned int theNumLocal; 
        unsigned int theParameters[7]; 
        double theDerivatives[7]; 
        // more local parameters, dynamic size
        std::vector<unsigned int> moreParameters; 
        std::vector<double> moreDerivatives; 
};
 
template<typename LocalDerivative, typename ExtDerivative>
void GblData::addDerivatives(unsigned int iRow,
                const std::array<unsigned int, 5>& labDer, const Matrix5d &matDer,
                unsigned int iOff, const Eigen::MatrixBase<LocalDerivative>& derLocal,
                unsigned int extOff, const Eigen::MatrixBase<ExtDerivative>& extDer) {
 
        unsigned int nParMax = 5 + derLocal.cols() + extDer.cols();
        theRow = iRow - iOff;
        if (nParMax > 7) {
                // dynamic data block size
                moreParameters.reserve(nParMax); // have to be sorted
                moreDerivatives.reserve(nParMax);
 
                for (int i = 0; i < derLocal.cols(); ++i) // local derivatives
                                {
                        if (derLocal(iRow - iOff, i)) {
                                moreParameters.push_back(i + 1);
                                moreDerivatives.push_back(derLocal(iRow - iOff, i));
                        }
                }
 
                for (int i = 0; i < extDer.cols(); ++i) // external derivatives
                                {
                        if (extDer(iRow - iOff, i)) {
                                moreParameters.push_back(extOff + i + 1);
                                moreDerivatives.push_back(extDer(iRow - iOff, i));
                        }
                }
 
                for (size_t i = 0; i < labDer.size(); ++i) // curvature, offset derivatives
                                {
                        if (labDer[i] and matDer(iRow, i)) {
                                moreParameters.push_back(labDer[i]);
                                moreDerivatives.push_back(matDer(iRow, i));
                        }
                }
        } else {
                // simple (static)  data block
                for (int i = 0; i < derLocal.cols(); ++i) // local derivatives
                                {
                        if (derLocal(iRow - iOff, i)) {
                                theParameters[theNumLocal] = i + 1;
                                theDerivatives[theNumLocal] = derLocal(iRow - iOff, i);
                                theNumLocal++;
                        }
                }
 
                for (int i = 0; i < extDer.cols(); ++i) // external derivatives
                                {
                        if (extDer(iRow - iOff, i)) {
                                theParameters[theNumLocal] = extOff + i + 1;
                                theDerivatives[theNumLocal] = extDer(iRow - iOff, i);
                                theNumLocal++;
                        }
                }
                for (size_t i = 0; i < labDer.size(); ++i) // curvature, offset derivatives
                                {
                        if (labDer[i] and matDer(iRow, i)) {
                                theParameters[theNumLocal] = labDer[i];
                                theDerivatives[theNumLocal] = matDer(iRow, i);
                                theNumLocal++;
                        }
                }
        }
}
 
template<typename ExtDerivative>
void GblData::addDerivatives(unsigned int iRow,
                const std::array<unsigned int, 7>& labDer, const Matrix27d &matDer,
                unsigned int extOff, const Eigen::MatrixBase<ExtDerivative>& extDer) {
 
        unsigned int nParMax = 7 + extDer.cols();
        theRow = iRow;
        if (nParMax > 7) {
                // dynamic data block size
                moreParameters.reserve(nParMax); // have to be sorted
                moreDerivatives.reserve(nParMax);
 
                for (int i = 0; i < extDer.cols(); ++i) // external derivatives
                                {
                        if (extDer(iRow, i)) {
                                moreParameters.push_back(extOff + i + 1);
                                moreDerivatives.push_back(extDer(iRow, i));
                        }
                }
 
                for (size_t i = 0; i < labDer.size(); ++i) // curvature, offset derivatives
                                {
                        if (labDer[i] and matDer(iRow, i)) {
                                moreParameters.push_back(labDer[i]);
                                moreDerivatives.push_back(matDer(iRow, i));
                        }
                }
        } else {
                // simple (static) data block
                for (size_t i = 0; i < labDer.size(); ++i) // curvature, offset derivatives
                                {
                        if (labDer[i] and matDer(iRow, i)) {
                                theParameters[theNumLocal] = labDer[i];
                                theDerivatives[theNumLocal] = matDer(iRow, i);
                                theNumLocal++;
                        }
                }
        }
}
 
}
 
#endif /* GBLDATA_H_ */