CbmLitLineTrackExtrapolator.cxx

Go to the documentation of this file.

/* Copyright (C) 2007-2017 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev [committer], Timur Ablyazimov */
 
#include "propagation/CbmLitLineTrackExtrapolator.h"
 
#include "data/CbmLitTrackParam.h"
 
CbmLitLineTrackExtrapolator::CbmLitLineTrackExtrapolator() {}
 
CbmLitLineTrackExtrapolator::~CbmLitLineTrackExtrapolator() {}
 
LitStatus CbmLitLineTrackExtrapolator::Extrapolate(const CbmLitTrackParam* parIn, CbmLitTrackParam* parOut,
                                                   litfloat zOut, std::vector<litfloat>* F)
{
  *parOut = *parIn;
  return Extrapolate(parOut, zOut, F);
}
 
LitStatus CbmLitLineTrackExtrapolator::Extrapolate(CbmLitTrackParam* par, litfloat zOut, std::vector<litfloat>* F)
{
  litfloat X[6] = {par->GetX(), par->GetY(), par->GetTx(), par->GetTy(), par->GetQp(), par->GetTime()};
 
  litfloat dz = zOut - par->GetZ();
 
  //transport state vector F*X*F.T()
  X[0] = X[0] + dz * X[2];
  X[1] = X[1] + dz * X[3];
 
  par->SetX(X[0]);
  par->SetY(X[1]);
 
  std::vector<litfloat> C = par->GetCovMatrix();
  litfloat txSq           = std::pow(X[2], 2);
  litfloat tySq           = std::pow(X[3], 2);
  litfloat timeCoeff      = dz / std::sqrt(1 + txSq + tySq) / CbmLitTrackParam::fSpeedOfLight;
  litfloat dttx           = X[2] * timeCoeff;
  litfloat dttxz          = dttx * dz;
  litfloat dtty           = X[3] * timeCoeff;
  litfloat dttyz          = dtty * dz;
  //transport covariance matrix F*C*F.T()
  litfloat t3  = C[2] + dz * C[11];
  litfloat t7  = dz * C[12];
  litfloat t8  = C[3] + t7;
  litfloat t19 = C[8] + dz * C[15];
  C[0]         = C[0] + dz * C[2] + t3 * dz;
  C[1]         = C[1] + dz * C[7] + t8 * dz;
  C[2]         = t3;
  C[3]         = t8;
  C[4]         = C[4] + dz * C[13];
  C[5]         = C[5] + dz * C[14] + dttx * dttxz * C[11] + dttyz * C[12] + dttx * C[2] + dtty * C[3];
  C[6]         = C[6] + dz * C[8] + t19 * dz;
  C[7]         = C[7] + t7;
  C[8]         = t19;
  C[9]         = C[9] + dz * C[16];
  C[10]        = C[10] + dz * C[17] + dttxz * C[12] + dttyz * C[15] + dttx * C[7] + dtty * C[8];
  C[14]        = C[14] + dttx * C[11] + dtty * C[12];
  C[17]        = C[17] + dttx * C[12] + dtty * C[15];
  C[19]        = C[19] + dttx * C[13] + dtty * C[16];
  C[20] = C[20] + 2 * dttx * dtty * C[12] + dttx * C[14] + dtty * C[17] + dttx * dttx * C[11] + dtty * dtty * C[15];
 
  par->SetCovMatrix(C);
  par->SetZ(zOut);
  par->SetTime(par->GetTime()
               + std::sqrt(1 + std::pow(X[2], 2) + std::pow(X[3], 2)) * dz / CbmLitTrackParam::fSpeedOfLight);
 
  // Transport matrix calculation
  if (F != NULL) {
    F->assign(36, 0.);
    (*F)[0]  = 1.;
    (*F)[7]  = 1.;
    (*F)[14] = 1.;
    (*F)[21] = 1.;
    (*F)[28] = 1.;
    (*F)[35] = 1.;
    (*F)[2]  = dz;
    (*F)[9]  = dz;
    (*F)[32] = dttx;
    (*F)[33] = dtty;
  }
 
  return kLITSUCCESS;
}