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 "Alignment/ReferenceTrajectories/interface/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 TrafoDerivative>
    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 nLocal,
                        const Eigen::MatrixBase<TrafoDerivative>& derTrans);
                        template <typename TrafoDerivative>
                        void addDerivatives(unsigned int iRow,
                                            const std::array<unsigned int, 7>& labDer, const Matrix27d &matDer,
                                            unsigned int nLocal,
                                            const Eigen::MatrixBase<TrafoDerivative>& derTrans);
    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; 
    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 TrafoDerivative>
  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<TrafoDerivative>& 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 TrafoDerivative>
  void GblData::addDerivatives(unsigned int iRow,
                               const std::array<unsigned int, 7>& labDer,
                               const Matrix27d &matDer,
                               unsigned int extOff,
                               const Eigen::MatrixBase<TrafoDerivative>& 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_ */