---

Helix.cpp

Go to the documentation of this file.

#include "Helix.h"
#include <iomanip.h>
//-----------------------------------------------------------------------
// Helix member functions
//-----------------------------------------------------------------------

// default constructor
Helix::Helix() {
  HepSymMatrix temp(5,0);
  _cov_matrix.assign(temp);
}

//-----------------------------------------------------------------------
// construct Helix from a track
Helix::Helix(QvecBase* track) {
  HepSymMatrix temp(5,0);
  _cov_matrix.assign(temp);

  _charge =  track->QCH(); 
  _mass   = track->QM(); 

  // Get helix parameters ...

  // -- ordinary charged tracks
  if (track->TYPE() == TRACK || track->TYPE() == EFLOW ) { 

    QvecBase* ptrk = track;
    if (track->TYPE() == EFLOW) ptrk = ((AlEflw*) track)->getTrack();

    _IR = ((AlTrack*) ptrk)->IR();
    _TL = ((AlTrack*) ptrk)->TL(); 
    _P0 = ((AlTrack*) ptrk)->P0();
    _D0 = ((AlTrack*) ptrk)->D0();
    _Z0 = ((AlTrack*) ptrk)->Z0();

    int j = 0;
    for (int m = 1; m <= 5; m++) {
      for (int n = 1; n <= m; n++) { 
        _cov_matrix(m,n) = ((AlTrack*) ptrk)->EM(++j);  
      }      
    } 


  } else if (track->TYPE() == USERTRACK) {
    // -- User tracks
    //
    // For the time being, the YTOP auxilary routine YTPAR is being used to calculate 
    // the helix parameters (sorry, yet another FORTRAN wrapper)

    //>>>>>
    cout << "Helix::Helix: user track !" << endl;


    QvecBase* ptrk = track;

    // 4-momentum vector and mass
    float psum[5];
    psum[0] = track->QX();
    psum[1] = track->QY();
    psum[2] = track->QZ();
    psum[3] = sqrt(_mass*_mass + psum[0]*psum[0] +
                      psum[1]*psum[1] + psum[2]*psum[2]);
    psum[4] = _mass;

    // covariance matrix momentum
    float vpsum[10];
    for (int j = 0; j < 10; j++) {
      vpsum[j] = ((AlUserTrack*)ptrk)->SIG(j);  
    } 
    
    // vertex position 
    float vini[3];
    QvrtBase* end_vertex = ((AlUserTrack*)ptrk)->getEndVertex();
    vini[0] = ((AlUsrVertex*) end_vertex)->QX();
    vini[1] = ((AlUsrVertex*) end_vertex)->QY();
    vini[2] = ((AlUsrVertex*) end_vertex)->QZ();

    // covariance matrix vertex
    float vvini[6];
    int j = 0;
    for (int m = 1; m <= 3; m++) {
      for (int n = 1; n <= m; n++) {
        vvini[j++] = ((AlUsrVertex*) end_vertex)->QVEM(m,n);
      }
    } 

    // correlation momentum-vertex
    float vpsvi[9];
    j = 0;
    for (int m = 0; m < 3; m++) {
      for (int n = 0; n < 3; n++) {
        vpsvi[j++]= ((AlUserTrack*)ptrk)->corrMatrix(m+1, n+1);
      }
    }

    float trackpar[5];
    float vtrackpar[15];

    // call FORTRAN routine
    int ifail =  w_YTPAR(_charge, vini, vvini, psum, vpsum, vpsvi, trackpar, vtrackpar); 


  } else {
    cerr << "***** Helix::Helix: WARNING: Don\'t know tracks of type " << 
      int(track->TYPE()) << ". Track ignored !!" << endl;
  }

}

//-----------------------------------------------------------------------
// set helix parameters according to a track
void Helix::setTrackParameters(QvecBase* track) {
  HepSymMatrix temp(5,0);
  _cov_matrix.assign(temp);


  _charge = track->QCH();
  _mass   = track->QM(); 

  // Get helix parameters ...
  //
  // ---  ALPHA charged track  ---
  //
  if (track->TYPE() == TRACK || track->TYPE() == EFLOW ) {

    QvecBase* ptrk = track;
    if (track->TYPE() == EFLOW) ptrk = ((AlEflw*) track)->getTrack();

    _IR = ((AlTrack*)ptrk)->IR();
    _TL = ((AlTrack*)ptrk)->TL(); 
    _P0 = ((AlTrack*)ptrk)->P0();
    _D0 = ((AlTrack*)ptrk)->D0();
    _Z0 = ((AlTrack*)ptrk)->Z0();

    int j = 0;
    for (int m = 1; m <= 5; m++) {
      for (int n = 1; n <= m; n++) { 
        _cov_matrix(m,n) = ((AlTrack*)ptrk)->EM(++j);  
      }      
    } 

  } else if (track->TYPE() == USERTRACK) {
    //
    // --- User track  ---
    //
    // For the time being, the YTOP auxilary routine YTPAR is being used to calculate 
    // the track parameters (sorry, yet another FORTRAN wrapper)

    // 4-momentum vector and mass
    float psum[5];
    psum[0] = track->QX();
    psum[1] = track->QY();
    psum[2] = track->QZ();

    // covariance matrix momentum
    float vpsum[10];
    for (int j = 1; j <= 10; j++) {
      vpsum[j-1] = ((AlUserTrack*)track)->SIG(j);  
    } 

    // initial vertex position (here: the track's end vertex) 
    float vini[3];
    QvrtBase* end_vertex = ((AlUserTrack*)track)->getEndVertex();
    vini[0] = ((AlUsrVertex*) end_vertex)->QX();
    vini[1] = ((AlUsrVertex*) end_vertex)->QY();
    vini[2] = ((AlUsrVertex*) end_vertex)->QZ();

    // covariance matrix vertex
    float vvini[6];
    int j = 0;
    for (int m = 1; m <= 3; m++) {
      for (int n = 1; n <= m; n++) {
        vvini[j++] = ((AlUsrVertex*) end_vertex)->QVEM(m,n);
      }
    } 

    // correlation momentum-vertex (seems to be useless for neutral tracks)
    float vpsvi[9];
    j = 0;
    for (int m = 0; m < 3; m++) {
      for (int n = 0; n < 3; n++) {
        vpsvi[j++]= ((AlUserTrack*)track)->corrMatrix(m+1, n+1);
      }
    }

    float trackpar[5];
    float vtrackpar[15];

    /*
      cout << "Input YTPAR" << endl;
      cout << "charge:" << _charge << endl;
      cout << "vini:  " << setprecision(5) << vini[0] << "  " << vini[1] << "  " << vini[2] << endl; 
      cout << "vvini: " << setprecision(5) << vvini[0] << vvini[1] << vvini[2] << endl;
      cout << "       " << setprecision(5) << vvini[3] << vvini[4] << endl;
      cout << "       " << setprecision(5) << vvini[5] << endl;
      cout << "psum:  " << setprecision(5) << psum[0] << "  " << psum[1] << "  " 
      << psum[2] << "  "<< psum[3] << "  " << psum[4] << endl;
      cout << "vpsum: " << endl;
      for (int i = 0; i < 10; i ++ ) cout << setprecision(5) << vpsum[i] << endl;
      cout << "vpsvi: " << endl;
      for (int i = 0; i < 9; i ++ ) cout << setprecision(5) << vpsvi[i] << endl;
      cout << endl;
    */

    // call FORTRAN wrapper
    int ifail =  w_YTPAR(_charge, vini, vvini, psum, vpsum, vpsvi, trackpar, vtrackpar); 

    _IR = trackpar[0];
    _TL = trackpar[1];
    _P0 = trackpar[2];
    _D0 = trackpar[3];
    _Z0 = trackpar[4];

    j = 0;
    for (int m = 1; m <= 5; m++) {
      for (int n = 1; n <= m; n++) { 
        _cov_matrix(m,n) = vtrackpar[j++];  
      }      
    } 

    /*
      cout << "Helix::setTrackParameters: track parameters from YTPAR:" << endl;
      cout << _IR << ", " << _TL << ", "<< _P0 << ", "<< _D0 << ", "<< _Z0 << endl;
      cout << "cov_matrix:" << endl;
      for (int m = 1; m <= 5; m++) {
      for (int n = 1; n <= m; n++) { 
      cout << setprecision(5) <<  _cov_matrix(m,n) << ", ";  
      }      
      cout << endl;
      }  
      cout << "charge: " << _charge << endl;
      cout << "mass: " << _mass << endl;
    */

  } else {
    cerr << "***** Helix::setTrackParameters: WARNING: Don\'t know tracks of type " << 
      int(track->TYPE()) << ". Track ignored !!" << endl;
  }
 
}
 

//-----------------------------------------------------------------------
// YTPAR wrapper (part of YTOP vertex fitting package)
int Helix::w_YTPAR(float charge, float vini[3], float vvini[6], float psum[5], float vpsum[10], 
                    float vpsvi[9], float trackpar[5], float vtrackpar[15]) {

   
  int ifail;
  W_YTPAR(charge, vini, vvini, psum, vpsum, vpsvi, trackpar, vtrackpar, ifail);

  return ifail;
}

---