TTVertexConstraint.C

Go to the documentation of this file.

#include "jbltools/kinfit/TTVertexConstraint.h"
#include "jbltools/kinfit/TrackFitObject.h"

#include<iostream>
#include<cassert>

using std::cout;
using std::endl;

TTVertexConstraint::TTVertexConstraint (const TrackFitObject& t0, 
                                    int i0,
                                    const TrackFitObject& t1,
                                    int i1,
                                    int axis
                                   )
: cachevalid(false)
{ 
  tracks[0]  = &t0;
  vnumber[0] = i0;
  tracks[1]  = &t1;
  vnumber[1] = i1;
  sign[0] = +1;
  sign[1] = -1;
  switch (axis) {
    case 1:
      factor.setValues (0, 10, 0);
      break;
    case 2:
      factor.setValues (0, 0, 10);
      break;
    default:
      factor.setValues (10, 0, 0);
  }
}

// destructor
TTVertexConstraint::~TTVertexConstraint () {}

// calculate current value of constraint function
double TTVertexConstraint::getValue() const {
  return sign[0]*(factor*tracks[0]->getVertex (vnumber[0])) + 
         sign[1]*(factor*tracks[1]->getVertex (vnumber[1]));
}

// calculate vector/array of derivatives of this contraint 
// w.r.t. to ALL parameters of all fitobjects
void TTVertexConstraint::getDerivatives(int idim, double der[]) const {
  for (int i = 0; i < 2; ++i) {
    for (int ilocal = 0; ilocal < tracks[i]->getNPar(); ilocal++) {
      if (!tracks[i]->isParamFixed(ilocal)) {
        int iglobal = tracks[i]->getGlobalParNum (ilocal);
        assert (iglobal >= 0 && iglobal < idim);
        der[iglobal] = sign[i]*(factor*tracks[i]->getVertexDerivative (vnumber[i], ilocal));
      }
    }
  }
}
  
void TTVertexConstraint::add1stDerivativesToMatrix(int idim, double *M) const {

  assert (0);

//   assert (M);
//   int kglobal = getGlobalNum();
//   assert (kglobal >= 0 && kglobal < idim);
//   
//   for (ConstFitObjectIterator i = fitobjects.begin(); i != fitobjects.end(); ++i) {
//     const ParticleFitObject *fo = *i;
//     assert (fo);
//     for (int ilocal = 0; ilocal < fo->getNPar(); ++ilocal) {
//       int iglobal = fo->getGlobalParNum (ilocal);
//       assert (iglobal >= 0 && iglobal < idim);
//       double d = fo->getDPx(ilocal);
//       M[idim*iglobal+kglobal] += d;
//       M[idim*kglobal+iglobal] += d;
//     }
//     
//   }
}
  
void TTVertexConstraint::add2ndDerivativesToMatrix(int idim, double *M, double lambda) const {

  assert (0);
}
    
// void TTVertexConstraint::addToGlobalDerMatrix (double lambda, int idim, double *M) const {
// 
//   assert (0);
//   // Add lambda*d^2 g / d x_i dx_j to global matrix
//   
//   if (lambda == 0) return;
//   
//   // d^2 g / (dx_i dx_j) = 
//   //   = sum_k,l d^2 g/(dpx_k dpx_l) * dpx_k/dx_i dpx_l/dx_j
//   //     + sum_k dg/dpx_k * d^2 px_k/(dx_i dx_j)
//   //   = sum_k,l      1              * dpx_k/dx_i dpx_l/dx_j
//   
//   // assume here that different 4-vectors always depend on 
//   // different parameters!
//   
//   if (!cachevalid) updateCache();
//   
//   int *globalParNum = new int[nparams];
//   double *der = new double[nparams];
//   
// //   ipar = 0;
// //   for (int i = 0; i < fitobjects.size(); i++) {
// //     for (int ilocal = 0; ilocal < fitobjects[i]->getNPar(); ilocal++) {
// //       int iglobal = fitobjects[i]->getGlobalParNum (ilocal);
// //       if (iglobal >= 0) {
// //         assert (ipar < nparams);
// //         globalParNum[ipar] = iglobal;
// //         der[ipar] = fitobjects[i]->getDPx (ilocal);
// //         ipar++;
// //       }
// //   }
//   
//   for (int ipar = 0; ipar < nparams; ipar++) {
//     int iglobal = globalParNum[ipar];
//     double der_i = der[ipar];
//     for (int jpar = ipar; jpar < nparams; jpar++) {
//       int jglobal = globalParNum[ipar];
//       double der_j = der[jpar];
//       double l_der_ij = lambda*der_i*der_j;
//       M[idim*iglobal+jglobal] += l_der_ij;
//       if (ipar != jpar) M[idim*jglobal+iglobal] += l_der_ij;
//     }
//   }       
// }

void TTVertexConstraint::invalidateCache() const {
  cachevalid = false;
}

void TTVertexConstraint::updateCache() const {
  cachevalid = true;
}
  

---