ROOT logo

// from ROOT
#include "TMath.h"
#include "TString.h"
#include "TVector3.h"

// from hydra
#include "hades.h"
#include "hcategory.h"
#include "hcategorymanager.h"
#include "hmdccal2par.h"
#include "hmdccal2parsim.h"
#include "hmdctrackgdef.h"
#include "hmdctrackgfield.h"
#include "hphysicsconstants.h"
#include "hruntimedb.h"
#include "hmdcsizescells.h"

#include "hkalgeomtools.h"
#include "hkalmatrixtools.h"
#include "hkalplane.h"
#include "hkalifilt.h"

// C/C++ libraries
#include <iostream>
using namespace std;

//_HADES_CLASS_DESCRIPTION
///////////////////////////////////////////////////////////////////////////////
//
// This class is responsible for the Kalman filter.
//
// The Kalman filter is started via the 
// Bool_t fitTrack(const TObjArray &hits,  const TVectorD &iniStateVec,
//                 const TMatrixD &iniCovMat)
// function. It needs a series of measurement points (an array of class
// HKalMdcHit) and initial estimations for the track state and covariance
// matrix as input.
//
// It will then make an estimation for the initial track state based on the
// measurement hits and fill the covariance matrix with large values.
// The function will return a boolean to indicate whether problems (high chi^2
// or unrealistic track parameters) were encountered during track fitting.
//
// Track propagation will be done with the Runge-Kutta method.
//
// After the Kalman filter is done, a measurement site may be eliminated
// from the calculation with the function
// excludeSite(Int_t iSite)
//
//
// Several options for the Kalman filter may be set:
// setNumIterations(Int_t kalRuns)
// Number of iterations. After each iteration the Kalman filter will use the
// result of the previous iteration as starting value.
// Default is 1.
//
// setDirection(Bool_t dir)
// Propagation direction (kIterForward, kIterBackward). Direction will switch
// after each iteration.
// Default is forward direction.
//
// setSmoothing(Bool_t smooth)
// Smooth or don't smooth track states after filter. Smoothing attempts to
// improve the filtered track states by using the results of all subsequent
// as well.
// Default is on.
//
// setRotation(Kalman::kalRotateOptions rotate)
// kNoRot: No coordinate transformation. Not recommended for high track angles
//         (> 30°).
// kVarRot (default): Tilt the coordinate system along the initial track
//                    direction to avoid large values for the track state
//                    parameters tx or ty.
//
// setDoEnerLoss(Bool_t dedx)
// setDoMultScat(Bool_t ms)
// Include energy or multiple scattering in the Kalman filter.
// Default is on.
//
// setConstField(Bool_t constField)
// setFieldVector(const TVector3 &B)
// Tells the Kalman filter to use a constant magnetic field instead of the
// field map.
// Field vector must be in Tesla.
// Default is off.
//
// setFilterMethod(Kalman::filtMethod type)
// Changes which formulation of the Kalman equations to use. The formulations
// differ in speed and numerical stability. See the description of the
// functions named filter... for details.
//
// Notation:
// a: track state vector
// m: measurement vector
// r: residual of the measurement vector and the predicted measurement
// f(a): propagation function: Propagate track state a to the next
//       detector.
// h(a): projection function that calculates a measurement vector from
//       track state v
// F: Jacobian of f(a)
// H: Jacobian of h(a)
// C: covariance matrix of the track state
// Q: covariance matrix of the process noise
// V: covariance matrix of the measurement errors
//
//-----------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////

ClassImp (HKalIFilt)

//  -----------------------------------
//  Ctors and Dtor
//  -----------------------------------

HKalIFilt::HKalIFilt(Int_t n, Int_t measDim, Int_t stateDim,
                       HMdcTrackGField *fMap, Double_t fpol)
    : TObject(), iniStateVec(stateDim), svVertex(stateDim), svMeta(stateDim) {
    // Constructor for a Kalman system.
    //
    // Input:
    // n:        the maximum number of measurement sites in a track.
    // measDim:  the dimension of a measurement vector (must be the same for
    //           all tracks)
    // stateDim: the dimension of the track state vector (must be the same for all
    //           tracks)
    // fMap:     pointer to field map.
    // fpol:     field scaling factor * polarity.
    // chiMax:   the maximum chi^2 where a track is still accepted.

    betaInput    = -1.;
    nMaxSites    = n;
    nHitsInTrack = n;
    nSites       = n;

    sites = new HKalTrackSite* [nSites];
    for(Int_t i = 0; i < nSites; i++) {
        sites[i] = new HKalTrackSite(measDim, stateDim);
    }

    setFieldMap(fMap, fpol);
    trackNum         = 0;
    pid              = -1;

    setPrintWarnings(kFALSE);
    setPrintErrors(kFALSE);
    bFillPointArrays = kFALSE;

    nCondErrs        = 0;
    nCovSymErrs      = 0;
    nCovPosDefErrs   = 0;

    setNumIterations(1);
    setDirection(kIterForward);
    setSmoothing(kTRUE);
    setFilterMethod(Kalman::kKalConv);
    setDoEnerLoss(kTRUE);
    setDoMultScat(kTRUE);

    setRotation(Kalman::kVarRot);
    pRotMat = new TRotation();
    trackPropagator.setRotationMatrix(pRotMat);

    pointsTrack.SetOwner();
    fieldTrack.SetOwner();
}

HKalIFilt::~HKalIFilt() {

    //?
#if kalDebug > 0
    cout<<"Covariance symmetry errors: "<<nCovSymErrs
        <<", pos. def. errors: "<<nCovPosDefErrs
        <<", covariance ill-conditioned: "<<nCondErrs<<endl;
#endif
    delete sites;
    delete pRotMat;
}

//  -----------------------------------
//  Implementation of protected methods
//  -----------------------------------

Bool_t HKalIFilt::checkSitePreFilter(Int_t iSite) const {
    // Checks for potential issues when site with index iSite is filtered.

    HKalTrackSite *site = getSite(iSite);

#if kalDebug > 1
    cout<<"#### Filtering site "<<iSite<<" ####"<<endl;
#endif

    const TMatrixD &predCov = site->getStateCovMat(Kalman::kPredicted);

#if kalDebug > 0
    Int_t nRows, nCols;

    Int_t mdim = getMeasDim();
    Int_t sdim = getStateDim();

    // Check dimensions.
    const TVectorD &predState = site->getStateVec(Kalman::kPredicted);
    nRows = predState.GetNrows();
    if(nRows != sdim) {
	Error(Form("Filter site %i.", iSite),
	      Form("State vector from prediction must have dimension %i, but has dimension %i",
		   nRows, sdim));
        exit(1);
    }

    const TVectorD &measVec = getHitVec(site);
    nRows = measVec.GetNrows();
    if(nRows != mdim) {
	Error(Form("Filter site %i.", iSite),
	      Form("Measurement vector must have dimension %i, but has dimension %i",
		   nRows, mdim));
        exit(1);
    }

    const TMatrixD &errMat = getHitErrMat(site);
    nRows = errMat.GetNrows();
    nCols = errMat.GetNcols();
    if(nRows != mdim || nCols != mdim) {
	Error(Form("Filter site %i.", iSite),
	      Form("Measurement error matrix is %ix%i, but must be %ix%i matrix.",
		   nRows, nCols, mdim, mdim ));
        exit(1);
    }

    // Check covariance matrix.
    if(!checkCovMat(predCov)) {
	Warning("filter()",
		Form("Errors found in predicted covariance matrix for site %i.",
		     iSite));
    }

#endif

    if(!HKalMatrixTools::checkValidElems(predCov)) {
        if(bPrintErr) {
	    Error("filter()",
		  Form("Predicted covariance matrix for site %i contains INFs or NaNs.",
		       iSite));
        }
        return kFALSE;
    }

    if(!site->getIsActive()) {
        if(bPrintErr) {
            Error("filter()", Form("Site number %i is inactive.", iSite));
        }
        return kFALSE;
    }
    return kTRUE;
}

void HKalIFilt::filterConventional(Int_t iSite) {
    // Filter a site using the conventional formulation of the Kalman filter
    // equations.
    //
    // C_k = (I - K_k * H_k) * C^{k-1}_k
    // K_k = C^{k-1}_k * H^T_k * (V_k + H_k * C^{k-1}_k * H^T_k)^-1
    //
    // These are simpler equations compared to the Joseph or Swerling
    // forumations. Only one inversion of a matrix with the dimension of the
    // measurement vector is neccessary. However, the updated covariance
    // matrix may not be positive definite due to numerical computing problems.

    // sector or virtual layer coordinates
    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site = getSite(iSite);

    // Predicted state vector for this site.
    const TVectorD &predState = site->getStateVec(Kalman::kPredicted, sys);    // a^k-1_k
    TVectorD projMeasVec(getMeasDim());
    // Expected measurement vector.
    // h_k(a^k-1_k)
    calcMeasVecFromState(projMeasVec, site, Kalman::kPredicted, sys);

    // Residual of measurement vector and expected measurement vector.
    TVectorD residual = getHitVec(site) - projMeasVec;

    const TMatrixD &predCov    = site->getStateCovMat(Kalman::kPredicted, sys); // C^{k-1}_k
    const TMatrixD &errMat     = getHitErrMat(site);                               // V_k
    const TMatrixD &fProj      = site->getStateProjMat(Kalman::kFiltered, sys); // H_k
    const TMatrixD  fProjTrans = TMatrixD(TMatrixD::kTransposed, fProj);

    // Component of the Kalman gain that needs to be inverted.
    TMatrixD R = errMat + fProj * predCov * fProjTrans;

#if kalDebug > 0
    if(!HKalMatrixTools::checkCond(R)) {
        nCondErrs++;
        if(bPrintWarn) {
	    Warning("filterConventional()",
		    "Matrix is ill-conditioned for inversion.");
        }
    }
#endif

    // Calc Kalman gain matrix.
    //       K_k        = C^{k-1}_k * H^T_k      * (V_k + H_k * C^{k-1}_k * H^T_k)^-1
    TMatrixD kalmanGain = predCov   * fProjTrans * R.Invert();

    //                 (I - K_k * H_k)
    TMatrixD covUpdate(TMatrixD(TMatrixD::kUnit,
				TMatrixD(getStateDim(sys),getStateDim(sys))) -
		       kalmanGain * fProj);
    //       C_k     = (I - K_k * H_k) * C^{k-1}_k
    TMatrixD filtCov = covUpdate       * predCov;

#if kalDebug > 0
    Int_t asymCells = HKalMatrixTools::checkSymmetry(filtCov, 1.e-9);
    if(asymCells > 0) {
        nCovSymErrs += asymCells;
        if(bPrintWarn) {
	    Warning("filterConventional()",
		    "Covariance matrix for filter step is not symmetric.");
        }
    }
    if(!HKalMatrixTools::isPosDef(filtCov)) {
        nCovPosDefErrs++;
        if(bPrintWarn) {
	    Warning("filterConventional()",
		    "Covariance for the filtered state is not positive definite.");
        }
    }
#endif

    if(!filtCov.IsSymmetric()) {
        if(!HKalMatrixTools::makeSymmetric(filtCov)) {
            if(bPrintWarn) {
		Warning("filterConventional()",
			"Covariance matrix for filter step is not close to being symmetric.");
            }
        }
    }

    site->setStateCovMat(Kalman::kFiltered, filtCov, sys);

    // Calculate filtered state vector.
    //       a_k       = a^k-1_k   + K_k        * (m_k     - h_k(a^k-1_k) )
    TVectorD filtState = predState + kalmanGain * residual;
    site->setStateVec(Kalman::kFiltered, filtState, sys);

#if kalDebug > 2
    if(sys == Kalman::kSecCoord) {
        cout<<"Filtering in sector coordinates."<<endl;
    }
    if(sys == Kalman::kLayCoord) {
        cout<<"Filtering in virtual layer coordinates."<<endl;
    }
    cout<<"Filter with conventional Kalman equations."<<endl;
    cout<<"Expected state vector:"<<endl;
    predState.Print();
    cout<<"Expected measurement:"<<endl;
    projMeasVec.Print();
    cout<<"Measurement vector:"<<endl;
    getHitVec(site).Print();
    cout<<"Filtered state vector:"<<endl;
    filtState.Print();
    cout<<"Filtered covariance:"<<endl;
    filtCov.Print();
#endif
#if kalDebug > 3
    cout<<"Covariance from prediction:"<<endl;
    predCov.Print();
    cout<<"Measurement error matrix:"<<endl;
    errMat.Print();
    cout<<"Projector matrix:"<<endl;
    fProj.Print();
    cout<<"Kalman gain:"<<endl;
    kalmanGain.Print();
#endif
}

void HKalIFilt::filterJoseph(Int_t iSite) {
    // This filter method uses the Joseph stabilized update of the covariance
    // matrix.
    //
    // K_k = C^k-1_k * H^T * (V_k + H_k * C^k-1_k * H_k^T)^-1
    // C^k = (I - K_k * H) * C^k-1_k * (I - K_k * H)^T + K_k * V_k * K_k^T
    //
    // This method is numerically more stable than the conventional or
    // Swerling formulations of the Kalman equations.
    // It guarantees that the updated covariance matrix is positive definite
    // if the covariance from the prediction step and the measurement noise
    // covariance are also positive definite.

    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site  = getSite(iSite);

    // Predicted state vector for this site.
    // a^k-1_k
    const TVectorD &predState  = site->getStateVec(kPredicted, sys);
    TVectorD projMeasVec(getMeasDim());
    // Expected measurement vector.
    // h_k(a^k-1_k)
    calcMeasVecFromState(projMeasVec, site, Kalman::kPredicted, sys);

    // Residual of measurement vector and expected measurement vector.
    TVectorD residual = getHitVec(site) - projMeasVec;

    const TMatrixD &errMat     = getHitErrMat(site);                               // V_k
    const TMatrixD &predCov    = site->getStateCovMat(Kalman::kPredicted, sys); // C^k-1_k
    const TMatrixD &fProj      = site->getStateProjMat(Kalman::kFiltered, sys); // H_k
    const TMatrixD  fProjTrans = TMatrixD(TMatrixD::kTransposed, fProj);

    TMatrixD R(errMat + fProj * predCov * fProjTrans);

#if kalDebug > 0
    if(!HKalMatrixTools::checkCond(R)) {
        nCondErrs++;
        if(bPrintWarn) {
	    Warning("filterJospeh()",
		    "Matrix is ill-conditioned for inversion.");
        }
    }
#endif

    //       K_k        = C^k-1_k * H^T        * (V_k + H_k * C^k-1_k * H_k^T)^-1
    TMatrixD kalmanGain = predCov * fProjTrans * R.Invert();

    //                (I - K_k * H_k)
    TMatrixD covUpdate(TMatrixD(TMatrixD::kUnit,
				TMatrixD(getStateDim(sys),getStateDim(sys))) -
		       kalmanGain * fProj);
    TMatrixD covUpdateT(TMatrixD::kTransposed, covUpdate);
    //       C^k     = (I - K_k * H) * C^k-1_k * (I - K_k * H)^T + 
    TMatrixD filtCov = covUpdate     * predCov * covUpdateT      +
        // K_k     * V_k    * K_k^T
	kalmanGain * errMat * TMatrixD(TMatrixD::kTransposed, kalmanGain);

#if kalDebug > 0
    Int_t asymCells = HKalMatrixTools::checkSymmetry(filtCov, 1.e-9);
    if(asymCells > 0) {
        nCovSymErrs += asymCells;
        if(bPrintWarn) {
	    Warning("filterJoseph()",
		    "Covariance matrix for filter step is not symmetric.");
        }
    }
    if(!HKalMatrixTools::isPosDef(filtCov)) {
        nCovPosDefErrs++;
        if(bPrintWarn) {
	    Warning("filterJoseph()",
		    "Covariance for the filtered state is not positive definite.");
        }
    }
#endif

    if(!filtCov.IsSymmetric()) {
        if(!HKalMatrixTools::makeSymmetric(filtCov)) {
            if(bPrintWarn) {
		Warning("filterJoseph()",
			"Covariance matrix for filter step is not close to being symmetric.");
            }
        }
    }

    site->setStateCovMat(kFiltered, filtCov, sys);

    // Calculate filtered state vector.
    //       a_k       = a^k-1_k   + K_k        * (m_k - h_k(a^k-1_k) )
    TVectorD filtState = predState + kalmanGain * residual;
    site->setStateVec(kFiltered, filtState, sys);

#if kalDebug > 2
    if(sys == Kalman::kSecCoord) {
        cout<<"Filtering in sector coordinates."<<endl;
    }
    if(sys == Kalman::kLayCoord) {
        cout<<"Filtering in virtual layer coordinates."<<endl;
    }
    cout<<"Filter with Joseph-stabilized Kalman equations."<<endl;
    cout<<"Expected state vector:"<<endl;
    predState.Print();
    cout<<"Expected measurement:"<<endl;
    projMeasVec.Print();
    cout<<"Measurement vector:"<<endl;
    getHitVec(site).Print();
    cout<<"Filtered state vector:"<<endl;
    filtState.Print();
    cout<<"Filtered covariance:"<<endl;
    filtCov.Print();
#endif
#if kalDebug > 3
    cout<<"Covariance from prediction:"<<endl;
    predCov.Print();
    cout<<"Measurement error matrix:"<<endl;
    errMat.Print();
    cout<<"Projector matrix:"<<endl;
    fProj.Print();
    cout<<"Kalman gain:"<<endl;
    kalmanGain.Print();
#endif
}

void HKalIFilt::filterSequential(Int_t iSite) {
    // Implements the sequential Kalman filter..
    // May only be used if:
    // the measurement noise matrix is diagonal or it is constant
    // and the projection function is h(a) = H * a.
    //
    // The advantage of this method is that is avoids matrix inversions.

    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site = getSite(iSite);

    Int_t sdim = getStateDim();
    Int_t mdim = getMeasDim();

    const TMatrixD &errMat    = getHitErrMat(site);
    const TVectorD &measVec   = getHitVec(site);

    TMatrixD filtCov   = site->getStateCovMat(Kalman::kPredicted, sys);
    TVectorD filtState = site->getStateVec(Kalman::kPredicted, sys);

    const TMatrixD &fProj   = site->getStateProjMat(Kalman::kFiltered, sys);

#if kalDebug > 2
    if(sys == Kalman::kSecCoord) {
        cout<<"Filtering in sector coordinates."<<endl;
    }
    if(sys == Kalman::kLayCoord) {
        cout<<"Filtering in virtual layer coordinates."<<endl;
    }
    cout<<"Filter with sequential Kalman filter."<<endl;
    cout<<"Expected state vector:"<<endl;
    filtState.Print();
    cout<<"Expected measurement:"<<endl;
    (fProj * filtState).Print();
    cout<<"Measurement vector:"<<endl;
    getHitVec(site).Print();
#endif
#if kalDebug > 3
    cout<<"Measurement error matrix:"<<endl;
    errMat.Print();
    cout<<"Projector matrix:"<<endl;
    fProj.Print();
#endif

    TMatrixD kalmanGain(sdim, 1);
    TMatrixD I(sdim, sdim);
    I.UnitMatrix();

    Double_t hrow[sdim];
    TMatrixD H(1, sdim);
    TMatrixD Ht(sdim, 1);

    // The main idea of the sequential filter is to process the components of
    // the measurement vector one at a time.
    //
    // Literature:
    // Optimal State Estimation
    // by Dan Simon
    // Chapter 6.1.: Sequential Kalman filtering

    for(Int_t iMeas = 0; iMeas < mdim; iMeas++) {
        fProj.ExtractRow(iMeas, 0, hrow);
        H .Use(0, 0, 0, H.GetNcols()-1, hrow);
        Ht.Use(0, Ht.GetNrows()-1, 0, 0, hrow);

        Double_t alpha = (H * filtCov * Ht)(0,0) + errMat(iMeas, iMeas);
        kalmanGain = (1./alpha) * filtCov * Ht;
        Double_t residual = (measVec(iMeas) - (H * filtState)(0));
        for(Int_t i = 0; i < filtState.GetNrows(); i++) {
            filtState(i) += kalmanGain(i, 0) * residual;
        }
        filtCov = (I - kalmanGain * H) * filtCov;
    }

    if(!filtCov.IsSymmetric()) {
        if(!HKalMatrixTools::makeSymmetric(filtCov)) {
            if(bPrintWarn) {
		Warning("filterJoseph()",
			"Covariance matrix for filter step is not close to being symmetric.");
            }
        }
    }

    // Store results.
    site->setStateCovMat(Kalman::kFiltered, filtCov, sys);
    site->setStateVec(Kalman::kFiltered, filtState, sys);

#if kalDebug > 2
    cout<<"Filtered state vector:"<<endl;
    filtState.Print();
    cout<<"Filtered covariance:"<<endl;
    filtCov.Print();
#endif
}

void HKalIFilt::filterSwerling(Int_t iSite) {
    // Swerling calculation of covariance matrix for filtered state and the
    // Kalman gain matrix.
    //
    // C_k = [ (C^k-1_k)^-1 + H^T_k * (V_k)^-1 * H_k ]^-1
    // K_k = C_k * H^T_k * (V_k)^-1
    //
    // This form requires two inversions of matrices with the dimension of the
    // state vector and one inversion of a matrix with the dimension of the
    // measurement vector. It can be more efficient if the dimension of the
    // state vector is small.

    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site  = getSite(iSite);

    // Predicted state vector for this site.
    // a^k-1_k
    const TVectorD &predState  = site->getStateVec(kPredicted, sys);

    TVectorD projMeasVec(getMeasDim());
    // Expected measurement vector.
    // h_k(a^k-1_k)
    calcMeasVecFromState(projMeasVec, site, Kalman::kPredicted, sys);

    // Residual of measurement vector and expected measurement vector.
    TVectorD residual = getHitVec(site) - projMeasVec;

    // C^k-1_k
    const TMatrixD &predCov = site->getStateCovMat(Kalman::kPredicted, sys);
#if kalDebug > 0
    if(!HKalMatrixTools::checkCond(predCov)) {
        nCondErrs++;
        if(bPrintWarn) {
	    Warning("filterSwerling()",
		    "Matrix is ill-conditioned for inversion.");
        }
    }
#endif
    const TMatrixD  predCovInv(TMatrixD::kInverted, predCov);

     // (V_k)^-1
    const TMatrixD errInv(TMatrixD::kInverted, getHitErrMat(site));

    // H_k
    const TMatrixD &fProj   = site->getStateProjMat(Kalman::kFiltered, sys);
    const TMatrixD fProjTrans = TMatrixD(TMatrixD::kTransposed, fProj);

    //       C_k        = [                          
    TMatrixD filtCov    = TMatrixD(TMatrixD::kInverted,
                              // (C^k-1_k)^-1 + H^T_k      * (V_k)^-1 * H_k]^-1
				   predCovInv + fProjTrans * errInv   * fProj);

#if kalDebug > 0
    Int_t asymCells = HKalMatrixTools::checkSymmetry(filtCov, 1.e-9);
    if(asymCells > 0) {
        nCovSymErrs += asymCells;
        if(bPrintWarn) {
	    Warning("filterSwerling()",
		    "Covariance matrix for filter step is not symmetric.");
        }
    }
    if(!HKalMatrixTools::isPosDef(filtCov)) {
        nCovPosDefErrs++;
        if(bPrintWarn) {
	    Warning("filterSwerling()",
		    "Covariance for the filtered state is not positive definite.");
        }
    }
#endif

    if(!filtCov.IsSymmetric()) {
        if(!HKalMatrixTools::makeSymmetric(filtCov)) {
            if(bPrintWarn) {
		Warning("filterSwerling()",
			"Covariance matrix for filter step is not close to being symmetric.");
            }
        }
    }

    site->setStateCovMat(kFiltered, filtCov, sys);

    // Kalman gain matrix.
    //       K_k        = C_k     * H^T_k      * G_k
    TMatrixD kalmanGain = filtCov * fProjTrans * errInv;

    // Calculate filtered state vector.
    //       a_k       = a^k-1_k   + K_k        * (m_k - h_k(a^k-1_k) )
    TVectorD filtState = predState + kalmanGain * residual;
    site->setStateVec(kFiltered, filtState, sys);

#if kalDebug > 2
    if(sys == Kalman::kSecCoord) {
        cout<<"Filtering in sector coordinates."<<endl;
    }
    if(sys == Kalman::kLayCoord) {
        cout<<"Filtering in virtual layer coordinates."<<endl;
    }
    cout<<"Filter with Swerling Kalman equations."<<endl;
    cout<<"Expected state vector:"<<endl;
    predState.Print();
    cout<<"Expected measurement:"<<endl;
    projMeasVec.Print();
    cout<<"Measurement vector:"<<endl;
    getHitVec(site).Print();
    cout<<"Filtered state vector:"<<endl;
    filtState.Print();
    cout<<"Filtered covariance:"<<endl;
    filtCov.Print();
#endif
#if kalDebug > 3
    cout<<"Covariance from prediction:"<<endl;
    predCov.Print();
    cout<<"Measurement error matrix:"<<endl;
    getHitErrMat(site).Print();
    cout<<"Projector matrix:"<<endl;
    fProj.Print();
    cout<<"Kalman gain:"<<endl;
    kalmanGain.Print();
#endif

}

void HKalIFilt::filterUD(Int_t iSite) {
    // Update of the covariance matrix and state vector for the filter step
    // using the U-D filter. A UD decomposition of the covariance matrix
    // is used and only the U and D matrices are propagated.
    //
    // This method increases the numerical precision of the Kalman filter.
    // It cannot be used together with the annealing filter.
    //
    // Literature:
    // Optimal State Estimation: Kalman, H infinity and Nonlinear Approaches
    // Chapter 6.4: U-D filtering
    // Dan Simon
    //
    // Kalman Filtering: Theory and Practice using MATLAB, 3rd edition
    // Chapter 6.5: Square Root and UD Filters
    // Mohinder S. Grewal, Angus P. Andrews
    //
    // G. J. Bierman, Factorization Methods for Discrete Sequential Estimation,
    // Academic Press, New York 1977

    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site = getSite(iSite);
    Int_t sdim = getStateDim(sys);
    Int_t mdim = getMeasDim();

    const TVectorD &measVec   = getHitVec(site); // m_k
    const TMatrixD &errMat    = getHitErrMat(site); // V_k

    TVectorD projMeasVec(getMeasDim());
    const TVectorD &predState = site->getStateVec(Kalman::kPredicted, sys);
    // Expected measurement vector.
    // h_k(a^k-1_k)
    calcMeasVecFromState(projMeasVec, site, Kalman::kPredicted, sys);

    // Residual.
    TVectorD resVec = measVec - projMeasVec;

    // Extract the U and D matrices.
    const TMatrixD &predCov   = site->getStateCovMat(Kalman::kPredicted, sys);
    TMatrixD U(sdim, sdim);
    TMatrixD D(sdim, sdim);
    HKalMatrixTools::resolveUD(U, D, predCov);

    // H_k
    const TMatrixD &fProj   = site->getStateProjMat(Kalman::kFiltered, sys);

    TVectorD filtState = predState;

    // Algorithm from the CD supplied with Grewal's and Andrews' book
    // Kalman Filtering: Theory and Practice Using Matlab.
    // Chapter 6, File: bierman.m

    // Process one component of the measurement vector at at time.
    for(Int_t iMeas = 0; iMeas < mdim; iMeas++) {
        // Get row number iMeas from the projector matrix.
        Double_t hrow[sdim];
        fProj.ExtractRow(iMeas, 0, hrow);
        TMatrixD H(1, sdim, hrow);

        Double_t residual = measVec(iMeas) - (H * filtState)(0);

        // U^T * H^T
        TMatrixD UtHt(TMatrixD(TMatrixD::kTransposed, U) * H.Transpose(H));

        TVectorD kalmanGain(sdim, (D * UtHt).GetMatrixArray());

        Double_t alpha = errMat(iMeas, iMeas);
        Double_t gamma = 1. / alpha;

        // Calculate U,D factors of covariance matrix and the Kalman gain.
        for(Int_t j = 0; j < sdim; j++) {
            Double_t beta = alpha;
            alpha += UtHt(j,0) * kalmanGain(j);
            Double_t lambda = - UtHt(j,0) * gamma;
            gamma = 1. / alpha;
            D(j,j) = beta * gamma * D(j,j);

            for(Int_t i = 0; i < j; i++) {
                beta = U(i,j);
                U(i,j) = beta + kalmanGain(i) * lambda;
                kalmanGain(i) += kalmanGain(j) * beta;
            }
        }
        kalmanGain *= gamma * residual;
        filtState = filtState + kalmanGain;
    }

#if kalDebug > 0
    if(!HKalMatrixTools::isPosDef(D)) {
        nCovPosDefErrs++;
        if(bPrintWarn) {
	    Warning("filterUD()",
		    "D-matrix for the filtered state is not positive definite.");
        }
    }
#endif

    // Store the U and D factors of the covariance matrix in a single matrix.
    // The diagonal elements of U are always 1. Replace them with the
    // elements of D.
    for(Int_t i = 0; i < D.GetNrows(); i++) {
        U(i,i) = D(i,i);
    }

    site->setStateCovMat(Kalman::kFiltered, U, sys);
    site->setStateVec(Kalman::kFiltered, filtState, sys);

#if kalDebug > 2
    if(sys == Kalman::kSecCoord) {
        cout<<"Filtering in sector coordinates."<<endl;
    }
    if(sys == Kalman::kLayCoord) {
        cout<<"Filtering in virtual layer coordinates."<<endl;
    }
    cout<<"Filter with UD Kalman equations."<<endl;
    cout<<"Expected state vector:"<<endl;
    predState.Print();
    cout<<"Expected measurement:"<<endl;
    projMeasVec.Print();
    cout<<"Measurement vector:"<<endl;
    getHitVec(site).Print();
    cout<<"Filtered state vector:"<<endl;
    filtState.Print();
    cout<<"U and D factors of filtered covariance:"<<endl;
    U.Print();
#endif
#if kalDebug > 3
    cout<<"U and D factors of covariance from prediction:"<<endl;
    predCov.Print();
    cout<<"Measurement error matrix:"<<endl;
    errMat.Print();
    cout<<"Projector matrix:"<<endl;
    fProj.Print();
#endif

}

void HKalIFilt::propagateCovConv(Int_t iFromSite, Int_t iToSite) {
    // Propagate the covariance matrix between measurement sites.
    // Must not be called before propagateTrack().
    // When applying the UD filter use propagateCovUD() function instead.
    //
    // iFromSite:  index of measurement site to start propagation from.
    // iToSite:    index of measurement site to propagate to (will be modified).

    HKalTrackSite *fromSite = getSite(iFromSite);
    HKalTrackSite *toSite   = getSite(iToSite);

    const TMatrixD &covMatFromSite = fromSite->getStateCovMat(kFiltered);              // C_k-1
#if kalDebug > 0
    Int_t nRows = covMatFromSite.GetNrows();
    Int_t nCols = covMatFromSite.GetNcols();
    if(nRows != getStateDim() || nCols != getStateDim()) {
	Error(Form("Prediction to site %i.", iToSite),
	      Form("Covariance matrix is %ix%i, but must be %ix%i matrix.",
		   nRows, nCols, getStateDim(), getStateDim()));
        exit(1);
    }
#endif
    const TMatrixD &propMatFromSite = fromSite->getStatePropMat(Kalman::kFiltered);
    const TMatrixD &procMatFromSite = fromSite->getStateProcMat(Kalman::kFiltered);

    TMatrixD propMatFromSiteTrans = TMatrixD(TMatrixD::kTransposed, propMatFromSite); // F_k-1

    //       C^k-1_k      = F_k-1           * C_k-1          *
    TMatrixD covMatToSite = propMatFromSite * covMatFromSite *
        // F^T_k-1           + Q_k-1
	propMatFromSiteTrans + procMatFromSite;
    if(!covMatToSite.IsSymmetric()) {
        if(!HKalMatrixTools::makeSymmetric(covMatToSite)) {
            if(bPrintWarn) {
		Warning("predictAndFilter2DHits()",
			"Covariance matrix for prediction is not close to being symmetric.");
            }
        }
    }
    toSite->setStateCovMat(Kalman::kPredicted, covMatToSite);
}

void HKalIFilt::propagateCovUD(Int_t iFromSite, Int_t iToSite) {
    // Update of the covariance matrix' U and D factors after the prediction
    // step.
    //
    // iFromSite:  index of measurement site to start propagation from.
    // iToSite:    index of measurement site to propagate to (will be modified).
    //
    // Only the matrix upper triangular U with the elements of D on its
    // diagonal are stored in the site.
    //
    // Literature:
    // Kalman Filtering: Theory and Practice using MATLAB, 3rd edition
    // Chapter 6.5: Square Root and UD Filters
    // Mohinder S. Grewal, Angus P. Andrews
    // and
    // Catherine L. Thornton, Triangular covariance factorizations for Kalman filtering,
    // Ph.D. thesis, University of California at Los Angeles, 1976

    HKalTrackSite *fromSite = getSite(iFromSite);
    HKalTrackSite *toSite   = getSite(iToSite);

    Int_t sdim = getStateDim();

    TMatrixD Uin(sdim, sdim);
    TMatrixD Din(sdim, sdim);
    const TMatrixD &covPrev = fromSite->getStateCovMat(Kalman::kFiltered);
    HKalMatrixTools::resolveUD(Uin, Din, covPrev);
    TMatrixD predCov(sdim, sdim);

    const TMatrixD &fProp = fromSite->getStatePropMat(Kalman::kFiltered);
    TMatrixD propU = fProp * Uin;

    TMatrixD  fProc       = fromSite->getStateProcMat(Kalman::kFiltered);

    TMatrixD UQ(fProc.GetNrows(), fProc.GetNcols());
    TMatrixD DQ(fProc.GetNrows(), fProc.GetNcols());
    HKalMatrixTools::resolveUD(UQ, DQ, fProc);

#if kalDebug > 0
    if(fProp.GetNrows() != covPrev.GetNrows() ||
       fProp.GetNcols() != covPrev.GetNcols()) {
        Error("covUpdateUD()",
              Form("Dimensions of covariance and propagator matrix do not match. Covariance is a %ix%i matrix while propagator is %ix%i.",
		   covPrev.GetNrows(), covPrev.GetNcols(),
		   fProp.GetNrows(), fProp.GetNcols()));
    }
    if(fProc.GetNrows() != covPrev.GetNrows() || fProc.GetNcols() != covPrev.GetNcols()) {
        Error("covUpdateUD()",
              Form("Dimensions of covariance and process noise matrix do not match. Covariance is a %ix%i matrix while process noise is %ix%i.",
		   covPrev.GetNrows(), covPrev.GetNcols(),
		   fProc.GetNrows(), fProc.GetNcols()));
    }
#endif

    for(Int_t i = sdim - 1; i >= 0; i--) {
        Double_t sigma = 0.;
        for(Int_t j = 0; j < sdim; j++) {
            sigma += propU(i,j) * Din(j,j) * propU(i,j);
            sigma += UQ(i,j) * DQ(j,j) * UQ(i,j);
        }
        predCov(i,i) = sigma;
        for(Int_t j = 0; j < i; j++) {
            sigma = 0.;
            for(Int_t k = 0; k < sdim; k++) {
                sigma += propU(i,k) * Din(k,k) * propU(j,k);
                sigma += UQ(i,k) * fProc(k,k) * UQ(j,k);
            }
            predCov(j,i) = sigma / predCov(i,i);
            for(Int_t k = 0; k < sdim; k++) {
                propU(j,k) -= predCov(j,i) * propU(i,k);
            }
            for(Int_t k = 0; k < sdim; k++) {
                UQ(j,k) -= predCov(j,i) * UQ(i,k);
            }
        }
    }

    toSite->setStateCovMat(Kalman::kPredicted, predCov);
}

Bool_t HKalIFilt::propagateTrack(Int_t iFromSite, Int_t iToSite) {
    // Propagates the track between measurement sites.
    //
    // iFromSite:  index of measurement site to start propagation from.
    // iToSite:    index of measurement site to propagate to (will be modified).

    HKalTrackSite *fromSite = getSite(iFromSite);
    HKalTrackSite *toSite  = getSite(iToSite);

    Bool_t propagationOk = kTRUE;

    // a_(k-1): filtered state vector of current site
    const TVectorD   &filtStateFromSite   = fromSite->getStateVec(kFiltered);
    // Plane to propagate from.
    const HKalMdcMeasLayer &planeFromSite = fromSite->getHitMeasLayer();
    // Plane to propagate to.
    const HKalMdcMeasLayer &planeToSite   = toSite  ->getHitMeasLayer();

    Int_t sdim = getStateDim();

#if kalDebug > 0
    Int_t nRows;
    nRows = filtStateFromSite.GetNrows();
    if(nRows != sdim) {
        if(bPrintErr) {
	    Error("propagateTrack()",
		  Form("Filtered state vector of site %i must have dimension %i, but has dimension %i",
		       iFromSite, nRows, sdim));
        }
        return kFALSE;
    }
#endif

    // a^(k-1)_k: predicted state for next site, to be calculated
    TVectorD predStateToSite(sdim);
    // F_k-1: propagation matrix, to be calculated
    TMatrixD propMatFromSite(sdim, sdim);
    // Q_k-1: process noise matrix, to be calculated
    TMatrixD procMatFromSite(sdim, sdim);

    // Propagate track to next measurement site. Calculate the expected state
    // vector a^(k-1)_k = f(a_k-1), the Jacobian F_k-1 and process noise
    // covariance Q_k-1.
    if(!trackPropagator.propagateToPlane(propMatFromSite, procMatFromSite,
                                         predStateToSite, filtStateFromSite,
                                         planeFromSite, planeToSite,
                                         planeFromSite, planeToSite,
                                         pid, getDirection())) {
        if(bPrintErr) {
	    Error("propagateTrack()",
		  Form("Propagation from measurement site %i in sec %i/mod %i/lay %i to site %i in sec %i/mod %i/lay %i failed. Skipping this site.",
		       iFromSite, planeFromSite.getSector(),
		       planeFromSite.getModule(), planeFromSite.getLayer(),
		       iToSite,   planeToSite.getSector(),
		       planeToSite.getModule(),   planeToSite.getLayer()));
        }
        toSite->setActive(kFALSE);
        return kFALSE;
    }

    // Fill arrays with RK stepping points.
    if(bFillPointArrays) {
        const TObjArray &pointsTrk = trackPropagator.getPointsTrack();
        for(Int_t i = 0; i < pointsTrk.GetEntries(); i++) {
            pointsTrack.Add(pointsTrk.At(i));
        }
        const TObjArray &fieldTrk = trackPropagator.getFieldTrack();
        for(Int_t i = 0; i < fieldTrk.GetEntries(); i++) {
            fieldTrack.Add(fieldTrk.At(i));
        }
    }

    trackLength += trackPropagator.getTrackLength();

    // Store propagation results.
    // -----------
    // a^(k-1)_k = f(a_k-1), store prediction for next site
    toSite  ->setStateVec(kPredicted, predStateToSite);
    // F_k-1, store propagator matrix
    fromSite->setStatePropMat(kFiltered, propMatFromSite);

    if(filtType == Kalman::kKalUD) {
        if(!HKalMatrixTools::decomposeUD(procMatFromSite)) {
	    Warning("predictAndFilter2DHits()",
		    "Could not decompose process noise into UD factors.");
        }
    }
    // Q_k-1, store process noise covariance
    fromSite->setStateProcMat(kFiltered, procMatFromSite);

    toSite->setEnergyLoss(fromSite->getEnergyLoss() +
			  trackPropagator.getEnergyLoss());
    // -----------

    return propagationOk;
}

void HKalIFilt::updateChi2Filter(Int_t iSite) {
    // Update chi^2 after having filtered site number iSite.

    Kalman::coordSys sys = getFilterInCoordSys();
    HKalTrackSite *site = getSite(iSite);

    Int_t mdim = getMeasDim();

    // Residual between predicted and filtered state vectors.
    const TVectorD &predState = site->getStateVec(Kalman::kPredicted, sys);
    const TVectorD &filtState = site->getStateVec(Kalman::kFiltered, sys);
    TVectorD diffPredFilt = filtState - predState;
    // Need a TMatrixD object later.
    // (a_k - a^k-1_k )^T
    TMatrixD diffPredFiltTrans(1, getStateDim(sys),
			       diffPredFilt.GetMatrixArray());

    // C^k-1_k
    TMatrixD predCov   = site->getStateCovMat(Kalman::kPredicted, sys);
    if(filtType == Kalman::kKalUD) {
        Int_t sdim = getStateDim(sys);
        TMatrixD U(sdim, sdim);
        TMatrixD D(sdim, sdim);
        HKalMatrixTools::resolveUD(U, D, predCov);
        predCov = U * D * TMatrixD(TMatrixD::kTransposed, U);
    }
    TMatrixD predCovInv(TMatrixD::kInverted, predCov);

    const TMatrixD &errMat    = getHitErrMat(site); // V_k

    const TMatrixD  errInv(TMatrixD::kInverted, errMat);

    TVectorD projFiltMeasVec(mdim);
    // Expected measurement from filter step.
    calcMeasVecFromState(projFiltMeasVec, site, Kalman::kFiltered, sys);

    TVectorD diffMeasFilt = getHitVec(site) - projFiltMeasVec;

    // Transform TVectorD objects into matrices for later matrix multiplications.
    // (m_k - a_k )^T.
    TMatrixD diffMeasFiltTrans(1, mdim , diffMeasFilt.GetMatrixArray());

    // Update chi2.
    //                 (a_k - a^k-1_k  )^T * (C^k-1_k)^-1 * (a_k - a^k-1_k)
    Double_t chi2Inc = (diffPredFiltTrans  * predCovInv   * diffPredFilt  )(0)+
                   //  (m_k - h_k(a_k))^T  * (V_k)^-1     * (m_k - h_k(a_k)   )
                       (diffMeasFiltTrans  * errInv       * diffMeasFilt  )(0);

    site->setChi2(chi2Inc);

    chi2 += chi2Inc;

#if kalDebug > 2
    cout<<"Site "<<iSite<<" added "<<chi2Inc<<" to chi2."<<endl;
    cout<<"Residual predicted - filtered state vectors: "<<endl;
    diffPredFilt.Print();
    cout<<"Residual measurement - measurement from filtered state: "<<endl;
    diffMeasFilt.Print();
#endif
}

void HKalIFilt::newTrack(const TObjArray &hits, const TVectorD &iniSv,
			 const TMatrixD &iniCovMat, Int_t pId) {
    // Reset data members to fit a new track.
    //
    // Input:
    // hits:        the array with the measurement hits. Elements must be of
    //              class HKalMdcHit.
    // iniStateVec: initial track state that the filter will use.
    // iniCovMat:   initial covariance matrix that the filter will use.
    // pId:         Geant particle id.
    // momGeant:    Geant momentum that will be written in the output tree.
    //              Ignore if this is not simulation data.
    bTrackAccepted = kTRUE;
    chi2 = 0.;
    fieldTrack.Clear();
    pointsTrack.Clear();
    trackLength = 0.;
    trackLengthAtLastMdc = 0.;
    trackPropagator.Clear();

    if(iniStateVec.GetNrows() != iniSv.GetNrows()) {
        iniStateVec.ResizeTo(iniSv.GetNrows());
        if(bPrintWarn) {
            Warning("fitTrack()", Form("Passed initial state vector has dimension %i. Class member of HKalIFilt has dimension %i.",
                                       iniSv.GetNrows(), iniStateVec.GetNrows()));
        }
    }
    iniStateVec = iniSv;

    // Add new hits to measurement sites.
    updateSites(hits);
    trackNum++;
    pid = pId;

    // Depending on the direction for propagation, set the index of the first
    // site (istart) and last site (igoal).
    // idir: increment (forward propagation) or decrement (backward
    // propagation) sites indices.
    Int_t fromSite; //, toSite; //unused
    if(getDirection() == kIterForward) {
        fromSite = 0;
       // toSite   = getNsites() - 1;  //unused
    } else {
        fromSite = getNsites() - 1;
        //toSite   = 0;                //unused
    }

    // Store the state vector and covariance matrix for the first site.
    HKalTrackSite *first = getSite(fromSite);

    first->setStateVec   (kPredicted, iniStateVec);
    first->setStateVec   (kFiltered,  iniStateVec);
    if(filtType == Kalman::kKalUD) {
        TMatrixD iniCovUD = iniCovMat;
        if(!HKalMatrixTools::decomposeUD(iniCovUD)) {
            Warning("fitTrack()","Could not decompose initial covariance matrix into UD factors.");
        }
        first->setStateCovMat(kPredicted, iniCovUD);
        first->setStateCovMat(kFiltered , iniCovUD);
    } else {
        first->setStateCovMat(kPredicted, iniCovMat);
        first->setStateCovMat(kFiltered , iniCovMat);
    }

    first->transSecToVirtLay(Kalman::kPredicted, (filtType == kKalUD));
    first->transSecToVirtLay(Kalman::kFiltered, (filtType == kKalUD));

    // Tilt coordinate system.
    // There are three options:
    // 1. kNoRot:
    //    Don't tilt the coordinate system.
    // 2. kVarRot:
    //    Tilt the coordinate system so that the z-axis will always
    //    point in the initial track direction. Assuming track curvature
    //    is not large this ensures that the track state parameters
    //    tx = tan(p_x / p_z) and ty = tan(p_y / p_z) remain small.
    //    Angles close to 90° would result in large values for tx and ty
    //    due to the tangens and poor results for the Kalman filter.
    if(rotCoords == Kalman::kVarRot) {
        // Calculate rotation matrix depending on track direction.
        TVector3 dir;
        HKalTrackState::calcDir(dir, iniStateVec);
        Double_t rotXangle = dir.Theta();
        Double_t rotYangle = - TMath::Pi()/2 + dir.Phi();
        setRotationAngles(rotXangle, rotYangle);
    }
    if(rotCoords == Kalman::kVarRot) {
        // Rotate coordinates of all sites.
        transformFromSectorToTrack();
    }
}

//  -----------------------------------
//  Implementation of public methods
//  -----------------------------------

Bool_t HKalIFilt::calcMeasVecFromState(TVectorD &projMeasVec,
				       HKalTrackSite const * const site,
				       Kalman::kalFilterTypes stateType,
				       Kalman::coordSys sys) const {
    // Implements the projection function h(a) that calculates a measurement
    // vector from a track state.
    //
    // Output:
    // projMeasVec: The calculated measurement vector.
    // Input:
    // site:      Pointer to current site of the track.
    // stateType: Which state (predicted, filtered, smoothed) to project on a
    //            measurement vector.
    // sys:       Coordinate system to use (sector or virtual layer coordinates)

#if kalDebug > 0
    Int_t mdim = getMeasDim();
    if(projMeasVec.GetNrows() != mdim) {
	Warning("calcMeasVec", Form("Needed to resize TVectorD. Dimension of measurement vector (%i) does not match that of function parameter (%i).", mdim, projMeasVec.GetNrows()));
        projMeasVec.ResizeTo(mdim);
    }
#endif

    const TVectorD &sv = site->getStateVec(stateType, sys);

    projMeasVec = site->getStateProjMat() * sv;

    return kTRUE;
}

Bool_t HKalIFilt::checkCovMat(const TMatrixD &fCov) const {
    // Covariance matrices must be positive definite, i.e. symmetric and
    // all its eigenvalues are real and positive. Returns true if this
    // is the case.

    Bool_t   bCovOk  = kTRUE;

    // Diagonal elements should not be zero.
    for(Int_t i = 0; i < fCov.GetNrows(); i++) {
        if(fCov(i, i) == 0.) {
            if(bPrintWarn) {
		Warning("checkCovMat()",
			"A diagonal elment of the covariance matrix is 0.");
            }
            bCovOk = kFALSE;
        }
    }

    // Covariance matrix should be symmetric.
    if(filtType != Kalman::kKalUD) {
        if(!fCov.IsSymmetric()) {
            if(bPrintWarn) {
                Warning("checkCovMat()", "Covariance matrix is not symmetric.");
            }
            bCovOk = kFALSE;
        }
    }

    if(filtType != Kalman::kKalUD) {
        if(!HKalMatrixTools::isPosDef(fCov)) {
            if(bPrintWarn) {
		Warning("checkCovMat()",
			"Covariance matrix is not positive definite.");
            }
            bCovOk = kFALSE;
        }
    } else {
        TMatrixD U(fCov.GetNrows(), fCov.GetNcols());
        TMatrixD D(fCov.GetNrows(), fCov.GetNcols());
        HKalMatrixTools::resolveUD(U, D, fCov);
        TMatrixD UD = U * D * TMatrixD(TMatrixD::kTransposed, U);
        if(!HKalMatrixTools::isPosDef(UD)) {
            if(bPrintWarn) {
		Warning("checkCovMat()",
			"Covariance matrix is not positive definite.");
            }
            bCovOk = kFALSE;
        }
    }

    return bCovOk;
}

Bool_t HKalIFilt::excludeSite(Int_t iSite) {
    // Exclude a site from the measurement. Requires that prediction, filtering and smoothing
    // has been done before. If smoothing has been disabled it will be done in this function.
    // iSite: index in sites array of the site to exclude

    Kalman::coordSys sys = getFilterInCoordSys();

    if(iSite < 0 || iSite > getNsites() - 1) {
        Warning("excludeSite()", "Invalid site index.");
        return kFALSE;
    }

    // Transform state vector from sector to track coordinates.
    if(rotCoords == Kalman::kVarRot) {
        transformFromSectorToTrack();
    }

    // Do smoothing including site k if it hasn't been done before.
    if(!bDoSmooth) {
        if(!smooth()) {
            if(bPrintErr) {
		Error("excludeSite()",
		      Form("Cannot exclude site %i. Smoothing of track failed.", iSite));
            }
            return kFALSE;
        }
    }

    HKalTrackSite* exSite = getSite(iSite);                           // Site k to exclude.

    if(!exSite->getIsActive()) {
        if(bPrintErr) {
	    Error("excludeSite()",
		  Form("Attempted to exclude inactive site number %i.", iSite));
        }
        return kFALSE;
    }

    if(getFilterInCoordSys() == Kalman::kLayCoord &&
       exSite->getNcompetitors() > 2) {
	Error("excludeSite()",
	      "This function does not work with competing wire measurements.");
	return kFALSE;
    }


    // Smoothed state vector of site to exclude.
    TVectorD exSmooState  = exSite->getStateVec(kSmoothed, sys);       // a^n_k

    // Covariance and inverse covariance from smoothing step.
    TMatrixD exSmooCov    = exSite->getStateCovMat(kSmoothed, sys);    // C^n_k
    TMatrixD exSmooCovInv = TMatrixD(TMatrixD::kInverted, exSmooCov);  // (C^n_k)^-1

    // Measurement and inverse measurement matrices.
    TMatrixD exErr        = getHitErrMat(exSite);                      // V_k
    TMatrixD exErrInv     = TMatrixD(TMatrixD::kInverted, exErr);      // G_k

    // Measurement vector.
    TVectorD exMeasVec    = getHitVec(exSite);                         // m_k

    const TMatrixD &fProj = exSite->getStateProjMat(Kalman::kFiltered, sys); // H_k47
    const TMatrixD fProjTrans = TMatrixD(TMatrixD::kTransposed, fProj);

    // Calculate a measurement vector from smoothed state vector.
    TVectorD exSmooProjMeasVec(getMeasDim());
    calcMeasVecFromState(exSmooProjMeasVec, exSite, Kalman::kSmoothed,
			 Kalman::kSecCoord); //? daf?

    //                             - V_k   + H_k   * C^n_k     * H_k
    TMatrixD kalmanGainHelper = -1.* exErr + fProj * exSmooCov * fProj;
    //       K^n*_k     = C^n_k     * H^T_k      *
    TMatrixD kalmanGain = exSmooCov * fProjTrans *
        //      (- V_k   + H_k   * C^n_k     * H_k    )^-1
	TMatrixD(TMatrixD::kInverted, kalmanGainHelper);

    // Inverse filter: calculate new state vector at site k excluding
    // measurement at this site.
    //       a^n*_k         = a^n_k       + K^n*_k     * (m_k       - h_k(a^n_k)   )
    TVectorD exInvFiltState = exSmooState + kalmanGain * (exMeasVec - exSmooProjMeasVec);
    exSite->setStateVec(kInvFiltered, exInvFiltState, sys);

    // Calculate new covariance at site k.
    //       C^n*_k       =         (
    TMatrixD exInvFiltCov = TMatrixD(TMatrixD::kInverted,
    //                               (C^n_k)^-1   - H^T_k      * G_k      * H_k  )^-1
				     exSmooCovInv - fProjTrans * exErrInv * fProj);
    exSite->setStateCovMat(kInvFiltered, exInvFiltCov, sys);

    // Update chi^2.
    TVectorD projMeasVecInvFilt(getMeasDim());
    calcMeasVecFromState(projMeasVecInvFilt, exSite,
			 Kalman::kInvFiltered, Kalman::kSecCoord); //? daf?

    // Transform TVectorD objects into column vectors for matrix multiplication.
    // (a^n*_k - a^n_k)^T
    TMatrixD diffStateTrans(1, getStateDim(),
			    (exInvFiltState - exSmooState).GetMatrixArray());
    // (m_k - h_k(a^n*_k). Transposed residual.
    TMatrixD resTrans(1, getMeasDim(),
		      (exMeasVec - projMeasVecInvFilt).GetMatrixArray());

    //        (a^n*_k - a^n_k)^T    * (C^n_k)^-1 * (a^n*_k         - a^n_k      )
    chi2 -=   (diffStateTrans       * exSmooCov  * (exInvFiltState - exSmooState)  )(0)
    //        (m_k - h_k(a^n*_k))^T * G          * (m_k       - h_k(a^n*_k)       )
            - (resTrans             * exErrInv   * (exMeasVec - projMeasVecInvFilt))(0);

    // Transform state vectors back from track to sector coordinates.
    if(rotCoords == Kalman::kVarRot) {
        transformFromTrackToSector();
    }

    exSite->transVirtLayToSec(Kalman::kInvFiltered, 0);

    return kTRUE;
}

Bool_t HKalIFilt::filter(Int_t iSite) {
    // Run the filter step in Kalman filter for a site.
    // Must be called after the prediction step.
    // Different Kalman filter equations are used as set by setFilterMethod().
    // iSite: index of site to filter

    switch(filtType) {
    case Kalman::kKalConv:
        filterConventional(iSite);
        break;
    case Kalman::kKalJoseph:
        filterJoseph(iSite);
        break;
    case Kalman::kKalUD:
        filterUD(iSite);
        break;
    case Kalman::kKalSeq:
        filterSequential(iSite);
        break;
    case Kalman::kKalSwer:
        filterSwerling(iSite);
        break;
    default:
        filterConventional(iSite);
        break;
    }

    return kTRUE;
}

Bool_t HKalIFilt::fitTrack(const TObjArray &hits, const TVectorD &iniSv,
			   const TMatrixD &iniCovMat, Int_t pId) {
    // Runs the Kalman filter over a set of measurement hits.
    // Returns false if the Kalman filter encountered problems during
    // track fitting or the chi^2 is too high.
    //
    // Input:
    // hits:        the array with the measurement hits. Elements must be of
    //              class HKalMdcHit.
    // iniStateVec: initial track state that the filter will use.
    // iniCovMat:   initial covariance matrix that the filter will use.
    // pId:         Geant particle id.
    // momGeant:    Geant momentum that will be written in the output tree.
    //              Ignore if this is not simulation data.

#if kalDebug > 1
    cout<<"******************************"<<endl;
    cout<<"**** Fit track number "<<trackNum<<" ****"<<endl;
    cout<<"******************************"<<endl;
#endif
#if kalDebug > 2
    cout<<"Initial state vector:"<<endl;
    iniSv.Print();
    cout<<"Initial covariance:"<<endl;
    iniCovMat.Print();
    cout<<"Initial particle hypothesis: "<<pId<<endl;
#endif

    newTrack(hits, iniSv, iniCovMat, pId);
    if(getNsites() == 0) {
	if(bPrintWarn) {
            Warning("fitTrack()", "Track contained no measurements.");
	}
        return kFALSE;
    }

    // Propagation dir may change when doing several Kalman Filter iterations.
    Bool_t orgDirection = getDirection();

    Int_t fromSite, toSite;
    if(getDirection() == kIterForward) {
        fromSite = 0;
        toSite   = getNsites() - 1;
    } else {
        fromSite = getNsites() - 1;
        toSite   = 0;
    }

    // Fit with standard Kalman Filter.
    for(Int_t i = 0; i < nKalRuns; i++) {
        chi2 = 0.;

        bTrackAccepted &= runFilter(fromSite, toSite);

        if(i < nKalRuns-1) { // At least one more iteration to do.
	    // Set the filtered state of the last site from the previous
	    // iteration as the prediction for the next iteration.
            getSite(toSite)->setStateVec(kPredicted, getSite(toSite)->getStateVec(kFiltered));
            //getSite(toSite)->setStateCovMat(kPredicted , getSite(toSite)->getStateCovMat(kFiltered));

            // Change propagation direction in each iteration.
            setDirection(!direction);
            Int_t oldTo = toSite;
            toSite      = fromSite;
            fromSite    = oldTo;
        }
    }

    // Do smoothing.
    if(bDoSmooth) {
	if(!smooth()) {
	    if(getPrintErr()) {
                Error("fitTrack()", "Smoothing track failed.");
	    }
            bTrackAccepted = kFALSE;
	}
    }

    // Direction changes when running Kalman Filter with several iterations.
    // Restore original direction passed by user.
    setDirection(orgDirection);

    // Transform hit and state vectors from track back to sector coordinates.
    if(rotCoords == Kalman::kVarRot) {
        transformFromTrackToSector();
    }

    setTrackLengthAtLastMdc(trackLength);

#if kalDebug > 1
    if(bTrackAccepted) {
        cout<<"**** Fitted track ****"<<endl;
    } else {
        cout<<"**** Errors during track fitting ****"<<endl;
    }
#endif

    if(!bTrackAccepted) chi2 = -1.F;

    return bTrackAccepted;
}

Bool_t HKalIFilt::propagate(Int_t iFromSite, Int_t iToSite) {
    // Propagates the track to the next measurement site and update
    // covariance matrices.
    //
    // iFromSite:  index of measurement site to start propagation from.
    // iToSite:    index of measurement site to propagate to.

    if(!propagateTrack(iFromSite, iToSite)) {
        return kFALSE;
    }

    if(filtType == Kalman::kKalUD) {
        propagateCovUD(iFromSite, iToSite);
    } else {
        propagateCovConv(iFromSite, iToSite);
    }
    return kTRUE;
}

Bool_t HKalIFilt::propagateToPlane(TVectorD& svTo, const TVectorD &svFrom,
				   const HKalMdcMeasLayer &measLayFrom,
				   const HKalMdcMeasLayer &measLayTo,
                                   Int_t pid, Bool_t dir) {
    Int_t sdim = svTo.GetNrows();
    TMatrixD F(sdim, sdim);
    TMatrixD Q(sdim, sdim);

    return trackPropagator.propagateToPlane(F, Q,
                                            svTo, svFrom,
                                            measLayFrom, measLayTo,
                                            measLayFrom, measLayTo,
                                            pid, dir);

}

Bool_t HKalIFilt::runFilter(Int_t iFromSite, Int_t toSite) {
    // Do the prediction and filter steps of the Kalman filter by propagating
    // the track between the measurement sites iFromSite and toSite.
    //
    // iFromSite: index of track site to start propagation from
    // toSite:   index of track site to propagate to.

    HKalTrackSite *fromSite = getSite(iFromSite);
    if(!fromSite) {
	return kFALSE;
    }

    if(!calcProjector(iFromSite)) {
	if(getPrintErr()) {
	    Error("runFilter()",
		  Form("Bad projector matrix for site %i.", iFromSite));
	}
        return kFALSE;
    }

    Bool_t trackOk = kTRUE;

    Int_t iDir;
    if(iFromSite < toSite) { // propagate in forward direction
        iDir = +1;
    } else {                // propagate in backward direction
        iDir = -1;
    }

    // Search for first active measurement site.
    Int_t iCurSite  = iFromSite;        // Index of current site k-1.
    while(!getSite(iCurSite)->getIsActive()) {
        iCurSite += iDir;
        if((iDir < 0 && iCurSite < toSite) || (iDir > 0 && iCurSite > toSite)) {
            if(bPrintErr) {
		Error("predictAndFilter2DHits()",
		      Form("No two valid sites between %i and %i.", iFromSite, toSite));
            }
            return kFALSE;
        }
    }

    Int_t iNextSite = iCurSite + iDir; // Index of next site k.

    while((iDir > 0 && iNextSite <= toSite) ||
	  (iDir < 0 && iNextSite >= toSite)) {

        HKalTrackSite *nextSite  = getSite(iNextSite);

#if kalDebug > 1
        HKalTrackSite *curSite  = getSite(iCurSite);
	cout<<"##### Prediction from site "<<iCurSite<<" at "
	    <<curSite->getSector()<<" / "<<curSite->getModule()<<" / "
	    <<curSite->getLayer()
	    <<" to site "<<iNextSite<<" at "
	    <<nextSite->getSector()<<" / "<<nextSite->getModule()<<" / "
	    <<nextSite->getLayer()
            <<" #####"<<endl;
#endif

        // Skip inactive sites.
        if(!nextSite->getIsActive()) {
            iNextSite += iDir;
            continue;
        }

        if(!propagate(iCurSite, iNextSite)) {
            // Propagation failed. Skip one site and try again.
            iNextSite += iDir;
            continue;
        }

        if(!calcProjector(iNextSite)) {
            if(getPrintErr()) {
		Error("runFilter()",
		      Form("Errors calculating projector matrix for site %i.",
			   iNextSite));
            }
            nextSite->setActive(kFALSE);
            return kFALSE;
        }

        if(!checkSitePreFilter(iNextSite)) {
            if(getPrintErr()) {
		Error("runFilter()",
		      Form("Unable to filter site %i.", iNextSite));
            }
            nextSite->setActive(kFALSE);
            return kFALSE;
        }

        // Filter next site and calculate new chi2.
        if(!filter(iNextSite)) {
            if(bPrintErr) {
		Error("runFilter()",
		      Form("Failed to filter site %i. Skipping this site.", iNextSite));
            }
            trackOk = kFALSE;
            nextSite->setActive(kFALSE);
        } else {
            updateChi2Filter(iNextSite);
            iCurSite = iNextSite;
        }
        iNextSite += iDir;

    } // end loop through sites

    return trackOk;
}

Bool_t HKalIFilt::smooth() {
    // Implements the smoother by Rauch, Tung and Striebel for the Kalman filter.
    // Requires that the prediction and filter steps for all measurement
    // sites have been executed before.

    if(filtType == Kalman::kKalUD) {
        // Transform covariances from UD format.
        for(Int_t iSite = 0; iSite < getNsites(); iSite++) {
            HKalTrackSite *site = getSite(iSite);
            TMatrixD cov = site->getStateCovMat(Kalman::kPredicted);
            TMatrixD U(cov.GetNrows(), cov.GetNcols());
            TMatrixD D(cov.GetNrows(), cov.GetNcols());
            HKalMatrixTools::resolveUD(U, D, cov);
            cov = U * D * TMatrixD(TMatrixD::kTransposed, U);
            site->setStateCovMat(Kalman::kPredicted, cov);

            cov = site->getStateCovMat(kFiltered);
            HKalMatrixTools::resolveUD(U, D, cov);
            cov = U * D * TMatrixD(TMatrixD::kTransposed, U);
            site->setStateCovMat(Kalman::kFiltered, cov);
        }
    }

    Int_t iStartSite, iGoalSite, iDir;
    // For smoothing, iterate through the sites in opposite direction as in
    // the prediction/filter steps.
    Bool_t dir = getDirection();
    if(dir == kIterForward) {
        iStartSite = getNsites() - 1;
        iGoalSite  = 0;
        iDir       = -1;
    } else {
        iStartSite = 0;
        iGoalSite  = getNsites() - 1;
        iDir       = +1;
    }

    // The result of filtering for the last site coincides with that of
    // smoothing.
    HKalTrackSite *cur = getSite(iStartSite);
    cur->setStateVec   (kSmoothed,    cur->getStateVec(kFiltered));
    cur->setStateCovMat(kSmoothed,    cur->getStateCovMat(kFiltered));
    cur->setStateCovMat(kInvFiltered, cur->getStateCovMat(kFiltered));
    iStartSite += iDir;

    Int_t iSite = iStartSite;
    while((dir == kIterBackward && iSite <= iGoalSite) ||
	  (dir == kIterForward && iSite >= iGoalSite)) {
        // Site k to be smoothed in this step.
	HKalTrackSite* cur     = getSite(iSite);
        if(!cur->getIsActive()) { // Skip inactive sites.
            iSite += iDir;
            continue;
        }

#if kalDebug > 1
        cout<<"**** Smoothing site "<<iSite<<" **** "<<endl;
#endif
        // Site k+1 that has been smoothed in the previous step.
	Int_t iPreSite = iSite - iDir;
        HKalTrackSite* pre = getSite(iPreSite);
        while(!pre->getIsActive()) { // Skip inactive sites.
            iPreSite -= iDir;
            if(iPreSite < 0 || iPreSite >= getNsites()) {
                if(bPrintWarn) {
                    Warning("smoothAll()", Form("No active site found to smooth site number %i.", iSite));
                }
                return kFALSE;
            }
            pre = getSite(iPreSite);
        }

        // Predicted state vector of site k+1.
        const TVectorD &prePredState  = pre->getStateVec    (kPredicted);          // a^k_k+1

        // Smoothed state vector of site k+1.
        const TVectorD &preSmooState  = pre->getStateVec    (kSmoothed);           // a^n_k+1

        // Filtered state vector of site k.
        const TVectorD &curFiltState  = cur->getStateVec    (kFiltered);           // a_k

        // Covariance from filter step for site k.
        const TMatrixD &curFiltCov    = cur->getStateCovMat (kFiltered);           // C_k

        // Covariance and inverted covariance from prediction for site k+1.
        const TMatrixD &prePredCov    = pre->getStateCovMat (kPredicted);          // C^k_k+1
        const TMatrixD  prePredCovInv = TMatrixD(TMatrixD::kInverted, prePredCov); // (C^k_k-1)^-1

        // Propagator and transposed propagator from predicion for site k.
        const TMatrixD &curProp       = cur->getStatePropMat(kFiltered);           // F_k
        const TMatrixD  curPropTrans  = TMatrixD(TMatrixD::kTransposed, curProp);  // F^T_k

        // Covariance from smoothing step for site k+1.
        const TMatrixD &preSmooCov    = pre->getStateCovMat (kSmoothed);           // C^n_k+1

        // Gain matrix for smoothing.
        //       A_k          = C_k        * F^T_k        * (C^k_k+1)^-1
        TMatrixD smootherGain = curFiltCov * curPropTrans * prePredCovInv;

        // Calculate residual of smoothed and prediction.
        TVectorD residual = preSmooState - prePredState;

	// z-coordinate is not a degree of freedom since track must always be
	// on a layer.
        if(residual.GetNrows() > 5) {
            residual(kIdxZ0) = 0.;
        }

        //       a^n_k        = a_k          + A_k          * (a^n_k+1 - a^k_k+1)
        TVectorD curSmooState = curFiltState + smootherGain * residual;

#if kalDebug > 2
        cout<<"Residual"<<endl;
        residual.Print();
        cout<<"Smoother gain matrix "<<endl;
        smootherGain.Print();
	cout<<"Filtered State:"<<endl;
        curFiltState.Print();
	cout<<"Smoothed State:"<<endl;
        curSmooState.Print();
#endif

	cur->setStateVec(kSmoothed,    curSmooState);
        // Inverse filtering works with smoothed states.
	cur->setStateVec(kInvFiltered, curSmooState);

	// Calculate covariance for smoothed state. Needed for possible
	// inverse filtering.
        //       C^n_k      = C_k        + 
	TMatrixD curSmooCov = curFiltCov +
            // A_k       * (C^n_k-1    - C^k_k+1   ) *
	    smootherGain * (preSmooCov - prePredCov) *
            //  A^T_k
	    TMatrixD(TMatrixD::kTransposed, smootherGain);
        cur->setStateCovMat(kSmoothed,    curSmooCov);
        cur->setStateCovMat(kInvFiltered, curSmooCov);

	// Need the smoothing results in virt. layer coordinates for
	// inverse filtering.
        if(getFilterInCoordSys() == Kalman::kLayCoord) {
            cur->transSecToVirtLay(kSmoothed, 0);
        }

        iSite += iDir;
    }

    return kTRUE;
}

void HKalIFilt::sortHits() {
    // Sort the competitors in each site by weight.

    for(Int_t iSite = 0; iSite < getNsites(); iSite++) {
        getSite(iSite)->sortHits();
    }
}

Bool_t HKalIFilt::traceToVertex() {

    HKalTrackSite *fromSite = getSite(0);

    Int_t sec = fromSite->getSector();
    Int_t mod = fromSite->getModule();
    // Vertex in module coordinate system.
    Double_t xVertex = 0.;
    Double_t yVertex = 0.;
    Double_t zVertex = -500.;
    if(mod == 1) zVertex = -650;
    if(mod > 2) {
        if(getPrintErr()) {
            Error("traceToVertex", "No inner segment.");
        }
        return kFALSE;
    }
    HGeomVector vertex(xVertex, yVertex, zVertex);

    HMdcSizesCells *fSizesCells = HMdcSizesCells::getExObject();  // check if is already there
    if(!fSizesCells) {
	fSizesCells = HMdcSizesCells::getObject();
	fSizesCells->initContainer();
    }

    // Transform vertex coordinates to sector system.
    HMdcSizesCellsMod &fSizesCellsMod = (*fSizesCells)[sec][mod];
    vertex = fSizesCellsMod.getSecTrans()->transFrom(vertex);
    TVector3 pointForVertexRec(vertex.getX(), vertex.getY(), vertex.getZ());

    const TVectorD         &svFrom    = fromSite->getStateVec(Kalman::kSmoothed);
    const HKalMdcMeasLayer &planeFrom = fromSite->getHitMeasLayer();

    HKalMdcMeasLayer planeVertex(pointForVertexRec, planeFrom.getNormal(),
                                 planeFrom.getMaterialPtr(kFALSE),
                                 planeFrom.getMaterialPtr(kFALSE),
                                 -1, sec, 0, 1, 0.);

    Int_t sdim = getStateDim();

#if metaDebug > 0
    Int_t nRows = svFrom.GetNrows();
    if(nRows != sdim) {
        if(bPrintErr) {
	    Error("traceToVertex()",
		  Form("Smoothed state vector of site %i must have dimension %i, but has dimension %i", 0, nRows, sdim));
        }
        return kFALSE;
    }

    if(!bDoSmooth) {
        if(getPrintErr()) {
	    Error("traceToVertex()",
		  "Cannot trace to vertex without doing smoothing.");
        }
        return kFALSE;
    }
#endif

    // Dummy matrices.
    TMatrixD F(sdim, sdim);
    TMatrixD Q(sdim, sdim);

    // Propagate track to vertex.
    if(!trackPropagator.propagateToPlane(F, Q,
                                         svVertex, svFrom,
                                         planeFrom, planeVertex,
                                         planeFrom, planeVertex,
                                         pid, kIterBackward)) {
        if(getPrintErr()) {
	    Error("traceToVertex()",
		  "Failed propagation of smoothed track to vertex.");
        }
        return kFALSE;
    }

    TVector3 posVertex;
    HKalTrackState::calcPosAtPlane(posVertex, planeVertex, svVertex);

    HMdcSizesCellsSec& fSCSec = (*fSizesCells)[sec];
    const HGeomVector& target = fSCSec.getTargetMiddlePoint();

    //?
    Double_t dist = TMath::Sqrt(TMath::Power(target.getX() - posVertex.X(), 2.) +
                                TMath::Power(target.getY() - posVertex.Y(), 2.) +
                                TMath::Power(target.getZ() - posVertex.Z(), 2.));
#if metaDebug > 2
    cout<<"Tracklength from target to first MDC: "
	<<trackPropagator.getTrackLength()<<", dist correction :"<<dist<<endl;
#endif
#if metaDebug > 3
    cout<<"Position at target: "<<endl;
    posVertex.Print();
#endif
    trackLength += dist + trackPropagator.getTrackLength();
    setTrackLengthAtLastMdc(trackLength);

    return kTRUE;
}

Bool_t HKalIFilt::traceToMeta(const TVector3& metaHit, const TVector3& metaNormVec) {
    // Propagates the track from the last fitted MDC position till track intersection
    // with META plane (is defined by META-hit and normal vector to rod's plane.
    // Should only be called after having filtered all sites.
    //
    // Input:
    // metaHit:
    // metaNormVec:

    HKalTrackSite *fromSite = getSite(getNsites() - 1);

    trackLength = trackLengthAtLastMdc;

    Int_t sdim = getStateDim();
    TMatrixD F(sdim, sdim);
    TMatrixD Q(sdim, sdim);

    const TVectorD         &svFrom    = fromSite->getStateVec(Kalman::kSmoothed);
    const HKalMdcMeasLayer &planeFrom = fromSite->getHitMeasLayer();

    HKalMdcMeasLayer planeMeta(metaHit, metaNormVec,
			       planeFrom.getMaterialPtr(kFALSE),
			       planeFrom.getMaterialPtr(kFALSE),
			       fromSite->getModule(), fromSite->getSector(),
			       0, 1, 0);

    if(!trackPropagator.propagateToPlane(F, Q,
                                         svMeta, svFrom,
                                         planeFrom, planeMeta,
                                         planeFrom, planeMeta,
                                         pid, kIterForward)) {
        if(getPrintErr()) {
	    Error("traceToMeta()",
		  "Failed propagation of smoothed track to Meta.");
        }
        return kFALSE;
    }

    HKalTrackState::calcPosAtPlane(posMeta, planeMeta, svMeta);

    trackLength += trackPropagator.getTrackLength();

#if metaDebug > 1
    cout<<"Kalman filter: trace to Meta hit ("<<metaHit.X()<<"/"<<metaHit.Y()
	<<"/"<<metaHit.Z()<<")"
	<<" with normal vector ("<<metaNormVec.X()<<"/"<<metaNormVec.Y()
	<<"/"<<metaNormVec.Z()<<")."<<endl;
#endif
#if metaDebug > 2
    cout<<"Distance last MDC to Meta: "<<trackPropagator.getTrackLength()<<endl;
#endif
#if metaDebug > 3
    cout<<"State at Meta: "<<endl;
    svMeta.Print();
    cout<<"Reconstructed pos at Meta: ("<<posMeta.X()<<"/"<<posMeta.Y()
	<<"/"<<posMeta.Z()<<")"<<endl;
#endif

    return kTRUE;
}


void HKalIFilt::transformFromSectorToTrack() {
    // Transform all sites using the Kalman system's rotation matrix.

#if kalDebug > 0
    if(pRotMat->IsIdentity()) {
	Warning("transformFromSectorToTrack()",
		"Transformation matrix has not been set.");
    }
#endif
    for(Int_t i = 0; i < getNsites(); i++) {
        getSite(i)->transform(*pRotMat);
    }
}

void HKalIFilt::transformFromTrackToSector() {
    // Transform all sites using the inverse rotation matrix stored in the
    // Kalman system. This will transform the sites back to sector coordinates
    // after a call of transformFromSectorToTrack() and if the rotation matrix
    // has not been modified in the meantime.

    TRotation rotInv = pRotMat->Inverse();
    // Rotate back sites.
    for(Int_t i = 0; i < getNsites(); i++) {
        getSite(i)->transform(rotInv);
    }

    // Rotate back points from propagation.

    for(Int_t i = 0; i < pointsTrack.GetEntries(); i++) {

#if kalDebug > 0
        if(!pointsTrack.At(i)->InheritsFrom("TVector3")) {
	    Error("transformFromTrackToSector()",
		  Form("Object at index %i in trackPoints array is of class %s. Expected class is TVector3.",
		       i, pointsTrack.At(i)->ClassName()));
            return;
        }
#endif

        ((TVector3*)pointsTrack.At(i))->Transform(rotInv);
    }
}

void HKalIFilt::updateSites(const TObjArray &hits) {
    // Replace sites of the Kalman system with new hits.
    // hits: array with new measurement hits. Must be of class HKalMdcHit.

    for(Int_t i = 0; i < getNsites(); i++) {
        getSite(i)->clearHits();
        getSite(i)->setActive(kTRUE);
    }

    Int_t iHit  = 0;
    Int_t iSite = 0;

    while(iHit < hits.GetEntries() - 1) {
#if kalDebug > 0
        if(!hits.At(iHit)->InheritsFrom("HKalMdcHit")) {
	    Error("updateSites()",
		  Form("Object at index %i in hits array is of class %s. Expected class is HKalMdcHit.",
		       iHit, hits.At(iHit)->ClassName()));
            exit(1);
        }
#endif

        HKalMdcHit *hit     = (HKalMdcHit*)hits.At(iHit);
        HKalMdcHit *nexthit = (HKalMdcHit*)hits.At(iHit + 1);

        // Don't store competing hits.
	if(!hit->areCompetitors(*hit, *nexthit)) {
            getSite(iSite)->addHit(hit);
            iSite++;
        }
        iHit++;
    }

    // Add last hit in array to a site.
    HKalMdcHit *lastHit = (HKalMdcHit*)hits.At(hits.GetEntries()-1);
    // Don't store competing hits.
    if(hits.GetEntries() > 1) {
        HKalMdcHit *secondLastHit = (HKalMdcHit*)hits.At(hits.GetEntries()-2);
        if(!lastHit->areCompetitors(*lastHit, *secondLastHit)) {
	    getSite(iSite)->addHit(lastHit);
            iSite++;
        }
    } else {
	getSite(iSite)->addHit(lastHit);
        iSite++;
    }

    nSites = iSite;
    nHitsInTrack = hits.GetEntries();
#if kalDebug > 1
    cout<<"New track has "<<nSites<<" measurement sites."<<endl;
#endif
}

TMatrixD const& HKalIFilt::getHitErrMat(HKalTrackSite* const site) const {
    // Returns the measurement error of site.
    //
    // Input:
    // site: measurement site.

    return site->getErrMat(0);
}

TVectorD const& HKalIFilt::getHitVec(HKalTrackSite* const site) const {
    // Returns the measurement vector of measurement site.
    //
    // Input:
    // site: measurement site.

    return site->getHitVec(0);
}

void HKalIFilt::getMetaPos(Double_t &x, Double_t &y, Double_t &z) const {
    x = posMeta.X();
    y = posMeta.Y();
    z = posMeta.Z();
}

void HKalIFilt::getVertexPos(Double_t &x, Double_t &y, Double_t &z) const {
    x = posVertex.X();
    y = posVertex.Y();
    z = posVertex.Z();
}

Double_t HKalIFilt::getNdf() const {
    // Returns number degrees of freedom, i.e. number of experimental points
    // minus number of parameters that are estimated.

    return getNsites() * getMeasDim() - getStateDim();
}

void HKalIFilt::setPrintErrors(Bool_t print) {
    // Print or suppress error messages.
    bPrintErr = print;
    trackPropagator.setPrintErrors(print);
}

void HKalIFilt::setPrintWarnings(Bool_t print) {
    // Print or suppress warning messages.
    bPrintWarn = print;
    trackPropagator.setPrintWarnings(print);
}

void HKalIFilt::setRotation(Kalman::kalRotateOptions rotate) {
    // Set options for the Kalman filter.
    // kalRotateOptions: Tilt coordinate system.
    // There are (approximately) three options:
    // 1. kNoRot:
    //    Don't tilt the coordinate system.
    // 2. kVarRot:
    //    Tilt the coordinate system so that the z-axis will always
    //    point in the initial track direction. Assuming track curvature
    //    is not large this ensures that the track state parameters
    //    tx = tan(p_x / p_z) and ty = tan(p_y / p_z) remain small.
    //    Angles close to 90° would result in large values for tx and ty
    //    due to the tangens and poor results for the Kalman filter.

    rotCoords = rotate;
    if( rotCoords == kVarRot) {
        trackPropagator.setRotateBfieldVecs(kTRUE);
    } else {
        trackPropagator.setRotateBfieldVecs(kFALSE);
    }
}

void HKalIFilt::setRotationAngles(Double_t rotXangle, Double_t rotYangle) {
    // Set the rotation matrix.
    // rotXangle: rotation angle around x axis in radians.
    // rotYangle: rotation angle around y axis in radians.
    pRotMat->SetToIdentity();
    pRotMat->RotateX(rotXangle);
    pRotMat->RotateY(rotYangle);
}
 hkalifilt.cc:1
 hkalifilt.cc:2
 hkalifilt.cc:3
 hkalifilt.cc:4
 hkalifilt.cc:5
 hkalifilt.cc:6
 hkalifilt.cc:7
 hkalifilt.cc:8
 hkalifilt.cc:9
 hkalifilt.cc:10
 hkalifilt.cc:11
 hkalifilt.cc:12
 hkalifilt.cc:13
 hkalifilt.cc:14
 hkalifilt.cc:15
 hkalifilt.cc:16
 hkalifilt.cc:17
 hkalifilt.cc:18
 hkalifilt.cc:19
 hkalifilt.cc:20
 hkalifilt.cc:21
 hkalifilt.cc:22
 hkalifilt.cc:23
 hkalifilt.cc:24
 hkalifilt.cc:25
 hkalifilt.cc:26
 hkalifilt.cc:27
 hkalifilt.cc:28
 hkalifilt.cc:29
 hkalifilt.cc:30
 hkalifilt.cc:31
 hkalifilt.cc:32
 hkalifilt.cc:33
 hkalifilt.cc:34
 hkalifilt.cc:35
 hkalifilt.cc:36
 hkalifilt.cc:37
 hkalifilt.cc:38
 hkalifilt.cc:39
 hkalifilt.cc:40
 hkalifilt.cc:41
 hkalifilt.cc:42
 hkalifilt.cc:43
 hkalifilt.cc:44
 hkalifilt.cc:45
 hkalifilt.cc:46
 hkalifilt.cc:47
 hkalifilt.cc:48
 hkalifilt.cc:49
 hkalifilt.cc:50
 hkalifilt.cc:51
 hkalifilt.cc:52
 hkalifilt.cc:53
 hkalifilt.cc:54
 hkalifilt.cc:55
 hkalifilt.cc:56
 hkalifilt.cc:57
 hkalifilt.cc:58
 hkalifilt.cc:59
 hkalifilt.cc:60
 hkalifilt.cc:61
 hkalifilt.cc:62
 hkalifilt.cc:63
 hkalifilt.cc:64
 hkalifilt.cc:65
 hkalifilt.cc:66
 hkalifilt.cc:67
 hkalifilt.cc:68
 hkalifilt.cc:69
 hkalifilt.cc:70
 hkalifilt.cc:71
 hkalifilt.cc:72
 hkalifilt.cc:73
 hkalifilt.cc:74
 hkalifilt.cc:75
 hkalifilt.cc:76
 hkalifilt.cc:77
 hkalifilt.cc:78
 hkalifilt.cc:79
 hkalifilt.cc:80
 hkalifilt.cc:81
 hkalifilt.cc:82
 hkalifilt.cc:83
 hkalifilt.cc:84
 hkalifilt.cc:85
 hkalifilt.cc:86
 hkalifilt.cc:87
 hkalifilt.cc:88
 hkalifilt.cc:89
 hkalifilt.cc:90
 hkalifilt.cc:91
 hkalifilt.cc:92
 hkalifilt.cc:93
 hkalifilt.cc:94
 hkalifilt.cc:95
 hkalifilt.cc:96
 hkalifilt.cc:97
 hkalifilt.cc:98
 hkalifilt.cc:99
 hkalifilt.cc:100
 hkalifilt.cc:101
 hkalifilt.cc:102
 hkalifilt.cc:103
 hkalifilt.cc:104
 hkalifilt.cc:105
 hkalifilt.cc:106
 hkalifilt.cc:107
 hkalifilt.cc:108
 hkalifilt.cc:109
 hkalifilt.cc:110
 hkalifilt.cc:111
 hkalifilt.cc:112
 hkalifilt.cc:113
 hkalifilt.cc:114
 hkalifilt.cc:115
 hkalifilt.cc:116
 hkalifilt.cc:117
 hkalifilt.cc:118
 hkalifilt.cc:119
 hkalifilt.cc:120
 hkalifilt.cc:121
 hkalifilt.cc:122
 hkalifilt.cc:123
 hkalifilt.cc:124
 hkalifilt.cc:125
 hkalifilt.cc:126
 hkalifilt.cc:127
 hkalifilt.cc:128
 hkalifilt.cc:129
 hkalifilt.cc:130
 hkalifilt.cc:131
 hkalifilt.cc:132
 hkalifilt.cc:133
 hkalifilt.cc:134
 hkalifilt.cc:135
 hkalifilt.cc:136
 hkalifilt.cc:137
 hkalifilt.cc:138
 hkalifilt.cc:139
 hkalifilt.cc:140
 hkalifilt.cc:141
 hkalifilt.cc:142
 hkalifilt.cc:143
 hkalifilt.cc:144
 hkalifilt.cc:145
 hkalifilt.cc:146
 hkalifilt.cc:147
 hkalifilt.cc:148
 hkalifilt.cc:149
 hkalifilt.cc:150
 hkalifilt.cc:151
 hkalifilt.cc:152
 hkalifilt.cc:153
 hkalifilt.cc:154
 hkalifilt.cc:155
 hkalifilt.cc:156
 hkalifilt.cc:157
 hkalifilt.cc:158
 hkalifilt.cc:159
 hkalifilt.cc:160
 hkalifilt.cc:161
 hkalifilt.cc:162
 hkalifilt.cc:163
 hkalifilt.cc:164
 hkalifilt.cc:165
 hkalifilt.cc:166
 hkalifilt.cc:167
 hkalifilt.cc:168
 hkalifilt.cc:169
 hkalifilt.cc:170
 hkalifilt.cc:171
 hkalifilt.cc:172
 hkalifilt.cc:173
 hkalifilt.cc:174
 hkalifilt.cc:175
 hkalifilt.cc:176
 hkalifilt.cc:177
 hkalifilt.cc:178
 hkalifilt.cc:179
 hkalifilt.cc:180
 hkalifilt.cc:181
 hkalifilt.cc:182
 hkalifilt.cc:183
 hkalifilt.cc:184
 hkalifilt.cc:185
 hkalifilt.cc:186
 hkalifilt.cc:187
 hkalifilt.cc:188
 hkalifilt.cc:189
 hkalifilt.cc:190
 hkalifilt.cc:191
 hkalifilt.cc:192
 hkalifilt.cc:193
 hkalifilt.cc:194
 hkalifilt.cc:195
 hkalifilt.cc:196
 hkalifilt.cc:197
 hkalifilt.cc:198
 hkalifilt.cc:199
 hkalifilt.cc:200
 hkalifilt.cc:201
 hkalifilt.cc:202
 hkalifilt.cc:203
 hkalifilt.cc:204
 hkalifilt.cc:205
 hkalifilt.cc:206
 hkalifilt.cc:207
 hkalifilt.cc:208
 hkalifilt.cc:209
 hkalifilt.cc:210
 hkalifilt.cc:211
 hkalifilt.cc:212
 hkalifilt.cc:213
 hkalifilt.cc:214
 hkalifilt.cc:215
 hkalifilt.cc:216
 hkalifilt.cc:217
 hkalifilt.cc:218
 hkalifilt.cc:219
 hkalifilt.cc:220
 hkalifilt.cc:221
 hkalifilt.cc:222
 hkalifilt.cc:223
 hkalifilt.cc:224
 hkalifilt.cc:225
 hkalifilt.cc:226
 hkalifilt.cc:227
 hkalifilt.cc:228
 hkalifilt.cc:229
 hkalifilt.cc:230
 hkalifilt.cc:231
 hkalifilt.cc:232
 hkalifilt.cc:233
 hkalifilt.cc:234
 hkalifilt.cc:235
 hkalifilt.cc:236
 hkalifilt.cc:237
 hkalifilt.cc:238
 hkalifilt.cc:239
 hkalifilt.cc:240
 hkalifilt.cc:241
 hkalifilt.cc:242
 hkalifilt.cc:243
 hkalifilt.cc:244
 hkalifilt.cc:245
 hkalifilt.cc:246
 hkalifilt.cc:247
 hkalifilt.cc:248
 hkalifilt.cc:249
 hkalifilt.cc:250
 hkalifilt.cc:251
 hkalifilt.cc:252
 hkalifilt.cc:253
 hkalifilt.cc:254
 hkalifilt.cc:255
 hkalifilt.cc:256
 hkalifilt.cc:257
 hkalifilt.cc:258
 hkalifilt.cc:259
 hkalifilt.cc:260
 hkalifilt.cc:261
 hkalifilt.cc:262
 hkalifilt.cc:263
 hkalifilt.cc:264
 hkalifilt.cc:265
 hkalifilt.cc:266
 hkalifilt.cc:267
 hkalifilt.cc:268
 hkalifilt.cc:269
 hkalifilt.cc:270
 hkalifilt.cc:271
 hkalifilt.cc:272
 hkalifilt.cc:273
 hkalifilt.cc:274
 hkalifilt.cc:275
 hkalifilt.cc:276
 hkalifilt.cc:277
 hkalifilt.cc:278
 hkalifilt.cc:279
 hkalifilt.cc:280
 hkalifilt.cc:281
 hkalifilt.cc:282
 hkalifilt.cc:283
 hkalifilt.cc:284
 hkalifilt.cc:285
 hkalifilt.cc:286
 hkalifilt.cc:287
 hkalifilt.cc:288
 hkalifilt.cc:289
 hkalifilt.cc:290
 hkalifilt.cc:291
 hkalifilt.cc:292
 hkalifilt.cc:293
 hkalifilt.cc:294
 hkalifilt.cc:295
 hkalifilt.cc:296
 hkalifilt.cc:297
 hkalifilt.cc:298
 hkalifilt.cc:299
 hkalifilt.cc:300
 hkalifilt.cc:301
 hkalifilt.cc:302
 hkalifilt.cc:303
 hkalifilt.cc:304
 hkalifilt.cc:305
 hkalifilt.cc:306
 hkalifilt.cc:307
 hkalifilt.cc:308
 hkalifilt.cc:309
 hkalifilt.cc:310
 hkalifilt.cc:311
 hkalifilt.cc:312
 hkalifilt.cc:313
 hkalifilt.cc:314
 hkalifilt.cc:315
 hkalifilt.cc:316
 hkalifilt.cc:317
 hkalifilt.cc:318
 hkalifilt.cc:319
 hkalifilt.cc:320
 hkalifilt.cc:321
 hkalifilt.cc:322
 hkalifilt.cc:323
 hkalifilt.cc:324
 hkalifilt.cc:325
 hkalifilt.cc:326
 hkalifilt.cc:327
 hkalifilt.cc:328
 hkalifilt.cc:329
 hkalifilt.cc:330
 hkalifilt.cc:331
 hkalifilt.cc:332
 hkalifilt.cc:333
 hkalifilt.cc:334
 hkalifilt.cc:335
 hkalifilt.cc:336
 hkalifilt.cc:337
 hkalifilt.cc:338
 hkalifilt.cc:339
 hkalifilt.cc:340
 hkalifilt.cc:341
 hkalifilt.cc:342
 hkalifilt.cc:343
 hkalifilt.cc:344
 hkalifilt.cc:345
 hkalifilt.cc:346
 hkalifilt.cc:347
 hkalifilt.cc:348
 hkalifilt.cc:349
 hkalifilt.cc:350
 hkalifilt.cc:351
 hkalifilt.cc:352
 hkalifilt.cc:353
 hkalifilt.cc:354
 hkalifilt.cc:355
 hkalifilt.cc:356
 hkalifilt.cc:357
 hkalifilt.cc:358
 hkalifilt.cc:359
 hkalifilt.cc:360
 hkalifilt.cc:361
 hkalifilt.cc:362
 hkalifilt.cc:363
 hkalifilt.cc:364
 hkalifilt.cc:365
 hkalifilt.cc:366
 hkalifilt.cc:367
 hkalifilt.cc:368
 hkalifilt.cc:369
 hkalifilt.cc:370
 hkalifilt.cc:371
 hkalifilt.cc:372
 hkalifilt.cc:373
 hkalifilt.cc:374
 hkalifilt.cc:375
 hkalifilt.cc:376
 hkalifilt.cc:377
 hkalifilt.cc:378
 hkalifilt.cc:379
 hkalifilt.cc:380
 hkalifilt.cc:381
 hkalifilt.cc:382
 hkalifilt.cc:383
 hkalifilt.cc:384
 hkalifilt.cc:385
 hkalifilt.cc:386
 hkalifilt.cc:387
 hkalifilt.cc:388
 hkalifilt.cc:389
 hkalifilt.cc:390
 hkalifilt.cc:391
 hkalifilt.cc:392
 hkalifilt.cc:393
 hkalifilt.cc:394
 hkalifilt.cc:395
 hkalifilt.cc:396
 hkalifilt.cc:397
 hkalifilt.cc:398
 hkalifilt.cc:399
 hkalifilt.cc:400
 hkalifilt.cc:401
 hkalifilt.cc:402
 hkalifilt.cc:403
 hkalifilt.cc:404
 hkalifilt.cc:405
 hkalifilt.cc:406
 hkalifilt.cc:407
 hkalifilt.cc:408
 hkalifilt.cc:409
 hkalifilt.cc:410
 hkalifilt.cc:411
 hkalifilt.cc:412
 hkalifilt.cc:413
 hkalifilt.cc:414
 hkalifilt.cc:415
 hkalifilt.cc:416
 hkalifilt.cc:417
 hkalifilt.cc:418
 hkalifilt.cc:419
 hkalifilt.cc:420
 hkalifilt.cc:421
 hkalifilt.cc:422
 hkalifilt.cc:423
 hkalifilt.cc:424
 hkalifilt.cc:425
 hkalifilt.cc:426
 hkalifilt.cc:427
 hkalifilt.cc:428
 hkalifilt.cc:429
 hkalifilt.cc:430
 hkalifilt.cc:431
 hkalifilt.cc:432
 hkalifilt.cc:433
 hkalifilt.cc:434
 hkalifilt.cc:435
 hkalifilt.cc:436
 hkalifilt.cc:437
 hkalifilt.cc:438
 hkalifilt.cc:439
 hkalifilt.cc:440
 hkalifilt.cc:441
 hkalifilt.cc:442
 hkalifilt.cc:443
 hkalifilt.cc:444
 hkalifilt.cc:445
 hkalifilt.cc:446
 hkalifilt.cc:447
 hkalifilt.cc:448
 hkalifilt.cc:449
 hkalifilt.cc:450
 hkalifilt.cc:451
 hkalifilt.cc:452
 hkalifilt.cc:453
 hkalifilt.cc:454
 hkalifilt.cc:455
 hkalifilt.cc:456
 hkalifilt.cc:457
 hkalifilt.cc:458
 hkalifilt.cc:459
 hkalifilt.cc:460
 hkalifilt.cc:461
 hkalifilt.cc:462
 hkalifilt.cc:463
 hkalifilt.cc:464
 hkalifilt.cc:465
 hkalifilt.cc:466
 hkalifilt.cc:467
 hkalifilt.cc:468
 hkalifilt.cc:469
 hkalifilt.cc:470
 hkalifilt.cc:471
 hkalifilt.cc:472
 hkalifilt.cc:473
 hkalifilt.cc:474
 hkalifilt.cc:475
 hkalifilt.cc:476
 hkalifilt.cc:477
 hkalifilt.cc:478
 hkalifilt.cc:479
 hkalifilt.cc:480
 hkalifilt.cc:481
 hkalifilt.cc:482
 hkalifilt.cc:483
 hkalifilt.cc:484
 hkalifilt.cc:485
 hkalifilt.cc:486
 hkalifilt.cc:487
 hkalifilt.cc:488
 hkalifilt.cc:489
 hkalifilt.cc:490
 hkalifilt.cc:491
 hkalifilt.cc:492
 hkalifilt.cc:493
 hkalifilt.cc:494
 hkalifilt.cc:495
 hkalifilt.cc:496
 hkalifilt.cc:497
 hkalifilt.cc:498
 hkalifilt.cc:499
 hkalifilt.cc:500
 hkalifilt.cc:501
 hkalifilt.cc:502
 hkalifilt.cc:503
 hkalifilt.cc:504
 hkalifilt.cc:505
 hkalifilt.cc:506
 hkalifilt.cc:507
 hkalifilt.cc:508
 hkalifilt.cc:509
 hkalifilt.cc:510
 hkalifilt.cc:511
 hkalifilt.cc:512
 hkalifilt.cc:513
 hkalifilt.cc:514
 hkalifilt.cc:515
 hkalifilt.cc:516
 hkalifilt.cc:517
 hkalifilt.cc:518
 hkalifilt.cc:519
 hkalifilt.cc:520
 hkalifilt.cc:521
 hkalifilt.cc:522
 hkalifilt.cc:523
 hkalifilt.cc:524
 hkalifilt.cc:525
 hkalifilt.cc:526
 hkalifilt.cc:527
 hkalifilt.cc:528
 hkalifilt.cc:529
 hkalifilt.cc:530
 hkalifilt.cc:531
 hkalifilt.cc:532
 hkalifilt.cc:533
 hkalifilt.cc:534
 hkalifilt.cc:535
 hkalifilt.cc:536
 hkalifilt.cc:537
 hkalifilt.cc:538
 hkalifilt.cc:539
 hkalifilt.cc:540
 hkalifilt.cc:541
 hkalifilt.cc:542
 hkalifilt.cc:543
 hkalifilt.cc:544
 hkalifilt.cc:545
 hkalifilt.cc:546
 hkalifilt.cc:547
 hkalifilt.cc:548
 hkalifilt.cc:549
 hkalifilt.cc:550
 hkalifilt.cc:551
 hkalifilt.cc:552
 hkalifilt.cc:553
 hkalifilt.cc:554
 hkalifilt.cc:555
 hkalifilt.cc:556
 hkalifilt.cc:557
 hkalifilt.cc:558
 hkalifilt.cc:559
 hkalifilt.cc:560
 hkalifilt.cc:561
 hkalifilt.cc:562
 hkalifilt.cc:563
 hkalifilt.cc:564
 hkalifilt.cc:565
 hkalifilt.cc:566
 hkalifilt.cc:567
 hkalifilt.cc:568
 hkalifilt.cc:569
 hkalifilt.cc:570
 hkalifilt.cc:571
 hkalifilt.cc:572
 hkalifilt.cc:573
 hkalifilt.cc:574
 hkalifilt.cc:575
 hkalifilt.cc:576
 hkalifilt.cc:577
 hkalifilt.cc:578
 hkalifilt.cc:579
 hkalifilt.cc:580
 hkalifilt.cc:581
 hkalifilt.cc:582
 hkalifilt.cc:583
 hkalifilt.cc:584
 hkalifilt.cc:585
 hkalifilt.cc:586
 hkalifilt.cc:587
 hkalifilt.cc:588
 hkalifilt.cc:589
 hkalifilt.cc:590
 hkalifilt.cc:591
 hkalifilt.cc:592
 hkalifilt.cc:593
 hkalifilt.cc:594
 hkalifilt.cc:595
 hkalifilt.cc:596
 hkalifilt.cc:597
 hkalifilt.cc:598
 hkalifilt.cc:599
 hkalifilt.cc:600
 hkalifilt.cc:601
 hkalifilt.cc:602
 hkalifilt.cc:603
 hkalifilt.cc:604
 hkalifilt.cc:605
 hkalifilt.cc:606
 hkalifilt.cc:607
 hkalifilt.cc:608
 hkalifilt.cc:609
 hkalifilt.cc:610
 hkalifilt.cc:611
 hkalifilt.cc:612
 hkalifilt.cc:613
 hkalifilt.cc:614
 hkalifilt.cc:615
 hkalifilt.cc:616
 hkalifilt.cc:617
 hkalifilt.cc:618
 hkalifilt.cc:619
 hkalifilt.cc:620
 hkalifilt.cc:621
 hkalifilt.cc:622
 hkalifilt.cc:623
 hkalifilt.cc:624
 hkalifilt.cc:625
 hkalifilt.cc:626
 hkalifilt.cc:627
 hkalifilt.cc:628
 hkalifilt.cc:629
 hkalifilt.cc:630
 hkalifilt.cc:631
 hkalifilt.cc:632
 hkalifilt.cc:633
 hkalifilt.cc:634
 hkalifilt.cc:635
 hkalifilt.cc:636
 hkalifilt.cc:637
 hkalifilt.cc:638
 hkalifilt.cc:639
 hkalifilt.cc:640
 hkalifilt.cc:641
 hkalifilt.cc:642
 hkalifilt.cc:643
 hkalifilt.cc:644
 hkalifilt.cc:645
 hkalifilt.cc:646
 hkalifilt.cc:647
 hkalifilt.cc:648
 hkalifilt.cc:649
 hkalifilt.cc:650
 hkalifilt.cc:651
 hkalifilt.cc:652
 hkalifilt.cc:653
 hkalifilt.cc:654
 hkalifilt.cc:655
 hkalifilt.cc:656
 hkalifilt.cc:657
 hkalifilt.cc:658
 hkalifilt.cc:659
 hkalifilt.cc:660
 hkalifilt.cc:661
 hkalifilt.cc:662
 hkalifilt.cc:663
 hkalifilt.cc:664
 hkalifilt.cc:665
 hkalifilt.cc:666
 hkalifilt.cc:667
 hkalifilt.cc:668
 hkalifilt.cc:669
 hkalifilt.cc:670
 hkalifilt.cc:671
 hkalifilt.cc:672
 hkalifilt.cc:673
 hkalifilt.cc:674
 hkalifilt.cc:675
 hkalifilt.cc:676
 hkalifilt.cc:677
 hkalifilt.cc:678
 hkalifilt.cc:679
 hkalifilt.cc:680
 hkalifilt.cc:681
 hkalifilt.cc:682
 hkalifilt.cc:683
 hkalifilt.cc:684
 hkalifilt.cc:685
 hkalifilt.cc:686
 hkalifilt.cc:687
 hkalifilt.cc:688
 hkalifilt.cc:689
 hkalifilt.cc:690
 hkalifilt.cc:691
 hkalifilt.cc:692
 hkalifilt.cc:693
 hkalifilt.cc:694
 hkalifilt.cc:695
 hkalifilt.cc:696
 hkalifilt.cc:697
 hkalifilt.cc:698
 hkalifilt.cc:699
 hkalifilt.cc:700
 hkalifilt.cc:701
 hkalifilt.cc:702
 hkalifilt.cc:703
 hkalifilt.cc:704
 hkalifilt.cc:705
 hkalifilt.cc:706
 hkalifilt.cc:707
 hkalifilt.cc:708
 hkalifilt.cc:709
 hkalifilt.cc:710
 hkalifilt.cc:711
 hkalifilt.cc:712
 hkalifilt.cc:713
 hkalifilt.cc:714
 hkalifilt.cc:715
 hkalifilt.cc:716
 hkalifilt.cc:717
 hkalifilt.cc:718
 hkalifilt.cc:719
 hkalifilt.cc:720
 hkalifilt.cc:721
 hkalifilt.cc:722
 hkalifilt.cc:723
 hkalifilt.cc:724
 hkalifilt.cc:725
 hkalifilt.cc:726
 hkalifilt.cc:727
 hkalifilt.cc:728
 hkalifilt.cc:729
 hkalifilt.cc:730
 hkalifilt.cc:731
 hkalifilt.cc:732
 hkalifilt.cc:733
 hkalifilt.cc:734
 hkalifilt.cc:735
 hkalifilt.cc:736
 hkalifilt.cc:737
 hkalifilt.cc:738
 hkalifilt.cc:739
 hkalifilt.cc:740
 hkalifilt.cc:741
 hkalifilt.cc:742
 hkalifilt.cc:743
 hkalifilt.cc:744
 hkalifilt.cc:745
 hkalifilt.cc:746
 hkalifilt.cc:747
 hkalifilt.cc:748
 hkalifilt.cc:749
 hkalifilt.cc:750
 hkalifilt.cc:751
 hkalifilt.cc:752
 hkalifilt.cc:753
 hkalifilt.cc:754
 hkalifilt.cc:755
 hkalifilt.cc:756
 hkalifilt.cc:757
 hkalifilt.cc:758
 hkalifilt.cc:759
 hkalifilt.cc:760
 hkalifilt.cc:761
 hkalifilt.cc:762
 hkalifilt.cc:763
 hkalifilt.cc:764
 hkalifilt.cc:765
 hkalifilt.cc:766
 hkalifilt.cc:767
 hkalifilt.cc:768
 hkalifilt.cc:769
 hkalifilt.cc:770
 hkalifilt.cc:771
 hkalifilt.cc:772
 hkalifilt.cc:773
 hkalifilt.cc:774
 hkalifilt.cc:775
 hkalifilt.cc:776
 hkalifilt.cc:777
 hkalifilt.cc:778
 hkalifilt.cc:779
 hkalifilt.cc:780
 hkalifilt.cc:781
 hkalifilt.cc:782
 hkalifilt.cc:783
 hkalifilt.cc:784
 hkalifilt.cc:785
 hkalifilt.cc:786
 hkalifilt.cc:787
 hkalifilt.cc:788
 hkalifilt.cc:789
 hkalifilt.cc:790
 hkalifilt.cc:791
 hkalifilt.cc:792
 hkalifilt.cc:793
 hkalifilt.cc:794
 hkalifilt.cc:795
 hkalifilt.cc:796
 hkalifilt.cc:797
 hkalifilt.cc:798
 hkalifilt.cc:799
 hkalifilt.cc:800
 hkalifilt.cc:801
 hkalifilt.cc:802
 hkalifilt.cc:803
 hkalifilt.cc:804
 hkalifilt.cc:805
 hkalifilt.cc:806
 hkalifilt.cc:807
 hkalifilt.cc:808
 hkalifilt.cc:809
 hkalifilt.cc:810
 hkalifilt.cc:811
 hkalifilt.cc:812
 hkalifilt.cc:813
 hkalifilt.cc:814
 hkalifilt.cc:815
 hkalifilt.cc:816
 hkalifilt.cc:817
 hkalifilt.cc:818
 hkalifilt.cc:819
 hkalifilt.cc:820
 hkalifilt.cc:821
 hkalifilt.cc:822
 hkalifilt.cc:823
 hkalifilt.cc:824
 hkalifilt.cc:825
 hkalifilt.cc:826
 hkalifilt.cc:827
 hkalifilt.cc:828
 hkalifilt.cc:829
 hkalifilt.cc:830
 hkalifilt.cc:831
 hkalifilt.cc:832
 hkalifilt.cc:833
 hkalifilt.cc:834
 hkalifilt.cc:835
 hkalifilt.cc:836
 hkalifilt.cc:837
 hkalifilt.cc:838
 hkalifilt.cc:839
 hkalifilt.cc:840
 hkalifilt.cc:841
 hkalifilt.cc:842
 hkalifilt.cc:843
 hkalifilt.cc:844
 hkalifilt.cc:845
 hkalifilt.cc:846
 hkalifilt.cc:847
 hkalifilt.cc:848
 hkalifilt.cc:849
 hkalifilt.cc:850
 hkalifilt.cc:851
 hkalifilt.cc:852
 hkalifilt.cc:853
 hkalifilt.cc:854
 hkalifilt.cc:855
 hkalifilt.cc:856
 hkalifilt.cc:857
 hkalifilt.cc:858
 hkalifilt.cc:859
 hkalifilt.cc:860
 hkalifilt.cc:861
 hkalifilt.cc:862
 hkalifilt.cc:863
 hkalifilt.cc:864
 hkalifilt.cc:865
 hkalifilt.cc:866
 hkalifilt.cc:867
 hkalifilt.cc:868
 hkalifilt.cc:869
 hkalifilt.cc:870
 hkalifilt.cc:871
 hkalifilt.cc:872
 hkalifilt.cc:873
 hkalifilt.cc:874
 hkalifilt.cc:875
 hkalifilt.cc:876
 hkalifilt.cc:877
 hkalifilt.cc:878
 hkalifilt.cc:879
 hkalifilt.cc:880
 hkalifilt.cc:881
 hkalifilt.cc:882
 hkalifilt.cc:883
 hkalifilt.cc:884
 hkalifilt.cc:885
 hkalifilt.cc:886
 hkalifilt.cc:887
 hkalifilt.cc:888
 hkalifilt.cc:889
 hkalifilt.cc:890
 hkalifilt.cc:891
 hkalifilt.cc:892
 hkalifilt.cc:893
 hkalifilt.cc:894
 hkalifilt.cc:895
 hkalifilt.cc:896
 hkalifilt.cc:897
 hkalifilt.cc:898
 hkalifilt.cc:899
 hkalifilt.cc:900
 hkalifilt.cc:901
 hkalifilt.cc:902
 hkalifilt.cc:903
 hkalifilt.cc:904
 hkalifilt.cc:905
 hkalifilt.cc:906
 hkalifilt.cc:907
 hkalifilt.cc:908
 hkalifilt.cc:909
 hkalifilt.cc:910
 hkalifilt.cc:911
 hkalifilt.cc:912
 hkalifilt.cc:913
 hkalifilt.cc:914
 hkalifilt.cc:915
 hkalifilt.cc:916
 hkalifilt.cc:917
 hkalifilt.cc:918
 hkalifilt.cc:919
 hkalifilt.cc:920
 hkalifilt.cc:921
 hkalifilt.cc:922
 hkalifilt.cc:923
 hkalifilt.cc:924
 hkalifilt.cc:925
 hkalifilt.cc:926
 hkalifilt.cc:927
 hkalifilt.cc:928
 hkalifilt.cc:929
 hkalifilt.cc:930
 hkalifilt.cc:931
 hkalifilt.cc:932
 hkalifilt.cc:933
 hkalifilt.cc:934
 hkalifilt.cc:935
 hkalifilt.cc:936
 hkalifilt.cc:937
 hkalifilt.cc:938
 hkalifilt.cc:939
 hkalifilt.cc:940
 hkalifilt.cc:941
 hkalifilt.cc:942
 hkalifilt.cc:943
 hkalifilt.cc:944
 hkalifilt.cc:945
 hkalifilt.cc:946
 hkalifilt.cc:947
 hkalifilt.cc:948
 hkalifilt.cc:949
 hkalifilt.cc:950
 hkalifilt.cc:951
 hkalifilt.cc:952
 hkalifilt.cc:953
 hkalifilt.cc:954
 hkalifilt.cc:955
 hkalifilt.cc:956
 hkalifilt.cc:957
 hkalifilt.cc:958
 hkalifilt.cc:959
 hkalifilt.cc:960
 hkalifilt.cc:961
 hkalifilt.cc:962
 hkalifilt.cc:963
 hkalifilt.cc:964
 hkalifilt.cc:965
 hkalifilt.cc:966
 hkalifilt.cc:967
 hkalifilt.cc:968
 hkalifilt.cc:969
 hkalifilt.cc:970
 hkalifilt.cc:971
 hkalifilt.cc:972
 hkalifilt.cc:973
 hkalifilt.cc:974
 hkalifilt.cc:975
 hkalifilt.cc:976
 hkalifilt.cc:977
 hkalifilt.cc:978
 hkalifilt.cc:979
 hkalifilt.cc:980
 hkalifilt.cc:981
 hkalifilt.cc:982
 hkalifilt.cc:983
 hkalifilt.cc:984
 hkalifilt.cc:985
 hkalifilt.cc:986
 hkalifilt.cc:987
 hkalifilt.cc:988
 hkalifilt.cc:989
 hkalifilt.cc:990
 hkalifilt.cc:991
 hkalifilt.cc:992
 hkalifilt.cc:993
 hkalifilt.cc:994
 hkalifilt.cc:995
 hkalifilt.cc:996
 hkalifilt.cc:997
 hkalifilt.cc:998
 hkalifilt.cc:999
 hkalifilt.cc:1000
 hkalifilt.cc:1001
 hkalifilt.cc:1002
 hkalifilt.cc:1003
 hkalifilt.cc:1004
 hkalifilt.cc:1005
 hkalifilt.cc:1006
 hkalifilt.cc:1007
 hkalifilt.cc:1008
 hkalifilt.cc:1009
 hkalifilt.cc:1010
 hkalifilt.cc:1011
 hkalifilt.cc:1012
 hkalifilt.cc:1013
 hkalifilt.cc:1014
 hkalifilt.cc:1015
 hkalifilt.cc:1016
 hkalifilt.cc:1017
 hkalifilt.cc:1018
 hkalifilt.cc:1019
 hkalifilt.cc:1020
 hkalifilt.cc:1021
 hkalifilt.cc:1022
 hkalifilt.cc:1023
 hkalifilt.cc:1024
 hkalifilt.cc:1025
 hkalifilt.cc:1026
 hkalifilt.cc:1027
 hkalifilt.cc:1028
 hkalifilt.cc:1029
 hkalifilt.cc:1030
 hkalifilt.cc:1031
 hkalifilt.cc:1032
 hkalifilt.cc:1033
 hkalifilt.cc:1034
 hkalifilt.cc:1035
 hkalifilt.cc:1036
 hkalifilt.cc:1037
 hkalifilt.cc:1038
 hkalifilt.cc:1039
 hkalifilt.cc:1040
 hkalifilt.cc:1041
 hkalifilt.cc:1042
 hkalifilt.cc:1043
 hkalifilt.cc:1044
 hkalifilt.cc:1045
 hkalifilt.cc:1046
 hkalifilt.cc:1047
 hkalifilt.cc:1048
 hkalifilt.cc:1049
 hkalifilt.cc:1050
 hkalifilt.cc:1051
 hkalifilt.cc:1052
 hkalifilt.cc:1053
 hkalifilt.cc:1054
 hkalifilt.cc:1055
 hkalifilt.cc:1056
 hkalifilt.cc:1057
 hkalifilt.cc:1058
 hkalifilt.cc:1059
 hkalifilt.cc:1060
 hkalifilt.cc:1061
 hkalifilt.cc:1062
 hkalifilt.cc:1063
 hkalifilt.cc:1064
 hkalifilt.cc:1065
 hkalifilt.cc:1066
 hkalifilt.cc:1067
 hkalifilt.cc:1068
 hkalifilt.cc:1069
 hkalifilt.cc:1070
 hkalifilt.cc:1071
 hkalifilt.cc:1072
 hkalifilt.cc:1073
 hkalifilt.cc:1074
 hkalifilt.cc:1075
 hkalifilt.cc:1076
 hkalifilt.cc:1077
 hkalifilt.cc:1078
 hkalifilt.cc:1079
 hkalifilt.cc:1080
 hkalifilt.cc:1081
 hkalifilt.cc:1082
 hkalifilt.cc:1083
 hkalifilt.cc:1084
 hkalifilt.cc:1085
 hkalifilt.cc:1086
 hkalifilt.cc:1087
 hkalifilt.cc:1088
 hkalifilt.cc:1089
 hkalifilt.cc:1090
 hkalifilt.cc:1091
 hkalifilt.cc:1092
 hkalifilt.cc:1093
 hkalifilt.cc:1094
 hkalifilt.cc:1095
 hkalifilt.cc:1096
 hkalifilt.cc:1097
 hkalifilt.cc:1098
 hkalifilt.cc:1099
 hkalifilt.cc:1100
 hkalifilt.cc:1101
 hkalifilt.cc:1102
 hkalifilt.cc:1103
 hkalifilt.cc:1104
 hkalifilt.cc:1105
 hkalifilt.cc:1106
 hkalifilt.cc:1107
 hkalifilt.cc:1108
 hkalifilt.cc:1109
 hkalifilt.cc:1110
 hkalifilt.cc:1111
 hkalifilt.cc:1112
 hkalifilt.cc:1113
 hkalifilt.cc:1114
 hkalifilt.cc:1115
 hkalifilt.cc:1116
 hkalifilt.cc:1117
 hkalifilt.cc:1118
 hkalifilt.cc:1119
 hkalifilt.cc:1120
 hkalifilt.cc:1121
 hkalifilt.cc:1122
 hkalifilt.cc:1123
 hkalifilt.cc:1124
 hkalifilt.cc:1125
 hkalifilt.cc:1126
 hkalifilt.cc:1127
 hkalifilt.cc:1128
 hkalifilt.cc:1129
 hkalifilt.cc:1130
 hkalifilt.cc:1131
 hkalifilt.cc:1132
 hkalifilt.cc:1133
 hkalifilt.cc:1134
 hkalifilt.cc:1135
 hkalifilt.cc:1136
 hkalifilt.cc:1137
 hkalifilt.cc:1138
 hkalifilt.cc:1139
 hkalifilt.cc:1140
 hkalifilt.cc:1141
 hkalifilt.cc:1142
 hkalifilt.cc:1143
 hkalifilt.cc:1144
 hkalifilt.cc:1145
 hkalifilt.cc:1146
 hkalifilt.cc:1147
 hkalifilt.cc:1148
 hkalifilt.cc:1149
 hkalifilt.cc:1150
 hkalifilt.cc:1151
 hkalifilt.cc:1152
 hkalifilt.cc:1153
 hkalifilt.cc:1154
 hkalifilt.cc:1155
 hkalifilt.cc:1156
 hkalifilt.cc:1157
 hkalifilt.cc:1158
 hkalifilt.cc:1159
 hkalifilt.cc:1160
 hkalifilt.cc:1161
 hkalifilt.cc:1162
 hkalifilt.cc:1163
 hkalifilt.cc:1164
 hkalifilt.cc:1165
 hkalifilt.cc:1166
 hkalifilt.cc:1167
 hkalifilt.cc:1168
 hkalifilt.cc:1169
 hkalifilt.cc:1170
 hkalifilt.cc:1171
 hkalifilt.cc:1172
 hkalifilt.cc:1173
 hkalifilt.cc:1174
 hkalifilt.cc:1175
 hkalifilt.cc:1176
 hkalifilt.cc:1177
 hkalifilt.cc:1178
 hkalifilt.cc:1179
 hkalifilt.cc:1180
 hkalifilt.cc:1181
 hkalifilt.cc:1182
 hkalifilt.cc:1183
 hkalifilt.cc:1184
 hkalifilt.cc:1185
 hkalifilt.cc:1186
 hkalifilt.cc:1187
 hkalifilt.cc:1188
 hkalifilt.cc:1189
 hkalifilt.cc:1190
 hkalifilt.cc:1191
 hkalifilt.cc:1192
 hkalifilt.cc:1193
 hkalifilt.cc:1194
 hkalifilt.cc:1195
 hkalifilt.cc:1196
 hkalifilt.cc:1197
 hkalifilt.cc:1198
 hkalifilt.cc:1199
 hkalifilt.cc:1200
 hkalifilt.cc:1201
 hkalifilt.cc:1202
 hkalifilt.cc:1203
 hkalifilt.cc:1204
 hkalifilt.cc:1205
 hkalifilt.cc:1206
 hkalifilt.cc:1207
 hkalifilt.cc:1208
 hkalifilt.cc:1209
 hkalifilt.cc:1210
 hkalifilt.cc:1211
 hkalifilt.cc:1212
 hkalifilt.cc:1213
 hkalifilt.cc:1214
 hkalifilt.cc:1215
 hkalifilt.cc:1216
 hkalifilt.cc:1217
 hkalifilt.cc:1218
 hkalifilt.cc:1219
 hkalifilt.cc:1220
 hkalifilt.cc:1221
 hkalifilt.cc:1222
 hkalifilt.cc:1223
 hkalifilt.cc:1224
 hkalifilt.cc:1225
 hkalifilt.cc:1226
 hkalifilt.cc:1227
 hkalifilt.cc:1228
 hkalifilt.cc:1229
 hkalifilt.cc:1230
 hkalifilt.cc:1231
 hkalifilt.cc:1232
 hkalifilt.cc:1233
 hkalifilt.cc:1234
 hkalifilt.cc:1235
 hkalifilt.cc:1236
 hkalifilt.cc:1237
 hkalifilt.cc:1238
 hkalifilt.cc:1239
 hkalifilt.cc:1240
 hkalifilt.cc:1241
 hkalifilt.cc:1242
 hkalifilt.cc:1243
 hkalifilt.cc:1244
 hkalifilt.cc:1245
 hkalifilt.cc:1246
 hkalifilt.cc:1247
 hkalifilt.cc:1248
 hkalifilt.cc:1249
 hkalifilt.cc:1250
 hkalifilt.cc:1251
 hkalifilt.cc:1252
 hkalifilt.cc:1253
 hkalifilt.cc:1254
 hkalifilt.cc:1255
 hkalifilt.cc:1256
 hkalifilt.cc:1257
 hkalifilt.cc:1258
 hkalifilt.cc:1259
 hkalifilt.cc:1260
 hkalifilt.cc:1261
 hkalifilt.cc:1262
 hkalifilt.cc:1263
 hkalifilt.cc:1264
 hkalifilt.cc:1265
 hkalifilt.cc:1266
 hkalifilt.cc:1267
 hkalifilt.cc:1268
 hkalifilt.cc:1269
 hkalifilt.cc:1270
 hkalifilt.cc:1271
 hkalifilt.cc:1272
 hkalifilt.cc:1273
 hkalifilt.cc:1274
 hkalifilt.cc:1275
 hkalifilt.cc:1276
 hkalifilt.cc:1277
 hkalifilt.cc:1278
 hkalifilt.cc:1279
 hkalifilt.cc:1280
 hkalifilt.cc:1281
 hkalifilt.cc:1282
 hkalifilt.cc:1283
 hkalifilt.cc:1284
 hkalifilt.cc:1285
 hkalifilt.cc:1286
 hkalifilt.cc:1287
 hkalifilt.cc:1288
 hkalifilt.cc:1289
 hkalifilt.cc:1290
 hkalifilt.cc:1291
 hkalifilt.cc:1292
 hkalifilt.cc:1293
 hkalifilt.cc:1294
 hkalifilt.cc:1295
 hkalifilt.cc:1296
 hkalifilt.cc:1297
 hkalifilt.cc:1298
 hkalifilt.cc:1299
 hkalifilt.cc:1300
 hkalifilt.cc:1301
 hkalifilt.cc:1302
 hkalifilt.cc:1303
 hkalifilt.cc:1304
 hkalifilt.cc:1305
 hkalifilt.cc:1306
 hkalifilt.cc:1307
 hkalifilt.cc:1308
 hkalifilt.cc:1309
 hkalifilt.cc:1310
 hkalifilt.cc:1311
 hkalifilt.cc:1312
 hkalifilt.cc:1313
 hkalifilt.cc:1314
 hkalifilt.cc:1315
 hkalifilt.cc:1316
 hkalifilt.cc:1317
 hkalifilt.cc:1318
 hkalifilt.cc:1319
 hkalifilt.cc:1320
 hkalifilt.cc:1321
 hkalifilt.cc:1322
 hkalifilt.cc:1323
 hkalifilt.cc:1324
 hkalifilt.cc:1325
 hkalifilt.cc:1326
 hkalifilt.cc:1327
 hkalifilt.cc:1328
 hkalifilt.cc:1329
 hkalifilt.cc:1330
 hkalifilt.cc:1331
 hkalifilt.cc:1332
 hkalifilt.cc:1333
 hkalifilt.cc:1334
 hkalifilt.cc:1335
 hkalifilt.cc:1336
 hkalifilt.cc:1337
 hkalifilt.cc:1338
 hkalifilt.cc:1339
 hkalifilt.cc:1340
 hkalifilt.cc:1341
 hkalifilt.cc:1342
 hkalifilt.cc:1343
 hkalifilt.cc:1344
 hkalifilt.cc:1345
 hkalifilt.cc:1346
 hkalifilt.cc:1347
 hkalifilt.cc:1348
 hkalifilt.cc:1349
 hkalifilt.cc:1350
 hkalifilt.cc:1351
 hkalifilt.cc:1352
 hkalifilt.cc:1353
 hkalifilt.cc:1354
 hkalifilt.cc:1355
 hkalifilt.cc:1356
 hkalifilt.cc:1357
 hkalifilt.cc:1358
 hkalifilt.cc:1359
 hkalifilt.cc:1360
 hkalifilt.cc:1361
 hkalifilt.cc:1362
 hkalifilt.cc:1363
 hkalifilt.cc:1364
 hkalifilt.cc:1365
 hkalifilt.cc:1366
 hkalifilt.cc:1367
 hkalifilt.cc:1368
 hkalifilt.cc:1369
 hkalifilt.cc:1370
 hkalifilt.cc:1371
 hkalifilt.cc:1372
 hkalifilt.cc:1373
 hkalifilt.cc:1374
 hkalifilt.cc:1375
 hkalifilt.cc:1376
 hkalifilt.cc:1377
 hkalifilt.cc:1378
 hkalifilt.cc:1379
 hkalifilt.cc:1380
 hkalifilt.cc:1381
 hkalifilt.cc:1382
 hkalifilt.cc:1383
 hkalifilt.cc:1384
 hkalifilt.cc:1385
 hkalifilt.cc:1386
 hkalifilt.cc:1387
 hkalifilt.cc:1388
 hkalifilt.cc:1389
 hkalifilt.cc:1390
 hkalifilt.cc:1391
 hkalifilt.cc:1392
 hkalifilt.cc:1393
 hkalifilt.cc:1394
 hkalifilt.cc:1395
 hkalifilt.cc:1396
 hkalifilt.cc:1397
 hkalifilt.cc:1398
 hkalifilt.cc:1399
 hkalifilt.cc:1400
 hkalifilt.cc:1401
 hkalifilt.cc:1402
 hkalifilt.cc:1403
 hkalifilt.cc:1404
 hkalifilt.cc:1405
 hkalifilt.cc:1406
 hkalifilt.cc:1407
 hkalifilt.cc:1408
 hkalifilt.cc:1409
 hkalifilt.cc:1410
 hkalifilt.cc:1411
 hkalifilt.cc:1412
 hkalifilt.cc:1413
 hkalifilt.cc:1414
 hkalifilt.cc:1415
 hkalifilt.cc:1416
 hkalifilt.cc:1417
 hkalifilt.cc:1418
 hkalifilt.cc:1419
 hkalifilt.cc:1420
 hkalifilt.cc:1421
 hkalifilt.cc:1422
 hkalifilt.cc:1423
 hkalifilt.cc:1424
 hkalifilt.cc:1425
 hkalifilt.cc:1426
 hkalifilt.cc:1427
 hkalifilt.cc:1428
 hkalifilt.cc:1429
 hkalifilt.cc:1430
 hkalifilt.cc:1431
 hkalifilt.cc:1432
 hkalifilt.cc:1433
 hkalifilt.cc:1434
 hkalifilt.cc:1435
 hkalifilt.cc:1436
 hkalifilt.cc:1437
 hkalifilt.cc:1438
 hkalifilt.cc:1439
 hkalifilt.cc:1440
 hkalifilt.cc:1441
 hkalifilt.cc:1442
 hkalifilt.cc:1443
 hkalifilt.cc:1444
 hkalifilt.cc:1445
 hkalifilt.cc:1446
 hkalifilt.cc:1447
 hkalifilt.cc:1448
 hkalifilt.cc:1449
 hkalifilt.cc:1450
 hkalifilt.cc:1451
 hkalifilt.cc:1452
 hkalifilt.cc:1453
 hkalifilt.cc:1454
 hkalifilt.cc:1455
 hkalifilt.cc:1456
 hkalifilt.cc:1457
 hkalifilt.cc:1458
 hkalifilt.cc:1459
 hkalifilt.cc:1460
 hkalifilt.cc:1461
 hkalifilt.cc:1462
 hkalifilt.cc:1463
 hkalifilt.cc:1464
 hkalifilt.cc:1465
 hkalifilt.cc:1466
 hkalifilt.cc:1467
 hkalifilt.cc:1468
 hkalifilt.cc:1469
 hkalifilt.cc:1470
 hkalifilt.cc:1471
 hkalifilt.cc:1472
 hkalifilt.cc:1473
 hkalifilt.cc:1474
 hkalifilt.cc:1475
 hkalifilt.cc:1476
 hkalifilt.cc:1477
 hkalifilt.cc:1478
 hkalifilt.cc:1479
 hkalifilt.cc:1480
 hkalifilt.cc:1481
 hkalifilt.cc:1482
 hkalifilt.cc:1483
 hkalifilt.cc:1484
 hkalifilt.cc:1485
 hkalifilt.cc:1486
 hkalifilt.cc:1487
 hkalifilt.cc:1488
 hkalifilt.cc:1489
 hkalifilt.cc:1490
 hkalifilt.cc:1491
 hkalifilt.cc:1492
 hkalifilt.cc:1493
 hkalifilt.cc:1494
 hkalifilt.cc:1495
 hkalifilt.cc:1496
 hkalifilt.cc:1497
 hkalifilt.cc:1498
 hkalifilt.cc:1499
 hkalifilt.cc:1500
 hkalifilt.cc:1501
 hkalifilt.cc:1502
 hkalifilt.cc:1503
 hkalifilt.cc:1504
 hkalifilt.cc:1505
 hkalifilt.cc:1506
 hkalifilt.cc:1507
 hkalifilt.cc:1508
 hkalifilt.cc:1509
 hkalifilt.cc:1510
 hkalifilt.cc:1511
 hkalifilt.cc:1512
 hkalifilt.cc:1513
 hkalifilt.cc:1514
 hkalifilt.cc:1515
 hkalifilt.cc:1516
 hkalifilt.cc:1517
 hkalifilt.cc:1518
 hkalifilt.cc:1519
 hkalifilt.cc:1520
 hkalifilt.cc:1521
 hkalifilt.cc:1522
 hkalifilt.cc:1523
 hkalifilt.cc:1524
 hkalifilt.cc:1525
 hkalifilt.cc:1526
 hkalifilt.cc:1527
 hkalifilt.cc:1528
 hkalifilt.cc:1529
 hkalifilt.cc:1530
 hkalifilt.cc:1531
 hkalifilt.cc:1532
 hkalifilt.cc:1533
 hkalifilt.cc:1534
 hkalifilt.cc:1535
 hkalifilt.cc:1536
 hkalifilt.cc:1537
 hkalifilt.cc:1538
 hkalifilt.cc:1539
 hkalifilt.cc:1540
 hkalifilt.cc:1541
 hkalifilt.cc:1542
 hkalifilt.cc:1543
 hkalifilt.cc:1544
 hkalifilt.cc:1545
 hkalifilt.cc:1546
 hkalifilt.cc:1547
 hkalifilt.cc:1548
 hkalifilt.cc:1549
 hkalifilt.cc:1550
 hkalifilt.cc:1551
 hkalifilt.cc:1552
 hkalifilt.cc:1553
 hkalifilt.cc:1554
 hkalifilt.cc:1555
 hkalifilt.cc:1556
 hkalifilt.cc:1557
 hkalifilt.cc:1558
 hkalifilt.cc:1559
 hkalifilt.cc:1560
 hkalifilt.cc:1561
 hkalifilt.cc:1562
 hkalifilt.cc:1563
 hkalifilt.cc:1564
 hkalifilt.cc:1565
 hkalifilt.cc:1566
 hkalifilt.cc:1567
 hkalifilt.cc:1568
 hkalifilt.cc:1569
 hkalifilt.cc:1570
 hkalifilt.cc:1571
 hkalifilt.cc:1572
 hkalifilt.cc:1573
 hkalifilt.cc:1574
 hkalifilt.cc:1575
 hkalifilt.cc:1576
 hkalifilt.cc:1577
 hkalifilt.cc:1578
 hkalifilt.cc:1579
 hkalifilt.cc:1580
 hkalifilt.cc:1581
 hkalifilt.cc:1582
 hkalifilt.cc:1583
 hkalifilt.cc:1584
 hkalifilt.cc:1585
 hkalifilt.cc:1586
 hkalifilt.cc:1587
 hkalifilt.cc:1588
 hkalifilt.cc:1589
 hkalifilt.cc:1590
 hkalifilt.cc:1591
 hkalifilt.cc:1592
 hkalifilt.cc:1593
 hkalifilt.cc:1594
 hkalifilt.cc:1595
 hkalifilt.cc:1596
 hkalifilt.cc:1597
 hkalifilt.cc:1598
 hkalifilt.cc:1599
 hkalifilt.cc:1600
 hkalifilt.cc:1601
 hkalifilt.cc:1602
 hkalifilt.cc:1603
 hkalifilt.cc:1604
 hkalifilt.cc:1605
 hkalifilt.cc:1606
 hkalifilt.cc:1607
 hkalifilt.cc:1608
 hkalifilt.cc:1609
 hkalifilt.cc:1610
 hkalifilt.cc:1611
 hkalifilt.cc:1612
 hkalifilt.cc:1613
 hkalifilt.cc:1614
 hkalifilt.cc:1615
 hkalifilt.cc:1616
 hkalifilt.cc:1617
 hkalifilt.cc:1618
 hkalifilt.cc:1619
 hkalifilt.cc:1620
 hkalifilt.cc:1621
 hkalifilt.cc:1622
 hkalifilt.cc:1623
 hkalifilt.cc:1624
 hkalifilt.cc:1625
 hkalifilt.cc:1626
 hkalifilt.cc:1627
 hkalifilt.cc:1628
 hkalifilt.cc:1629
 hkalifilt.cc:1630
 hkalifilt.cc:1631
 hkalifilt.cc:1632
 hkalifilt.cc:1633
 hkalifilt.cc:1634
 hkalifilt.cc:1635
 hkalifilt.cc:1636
 hkalifilt.cc:1637
 hkalifilt.cc:1638
 hkalifilt.cc:1639
 hkalifilt.cc:1640
 hkalifilt.cc:1641
 hkalifilt.cc:1642
 hkalifilt.cc:1643
 hkalifilt.cc:1644
 hkalifilt.cc:1645
 hkalifilt.cc:1646
 hkalifilt.cc:1647
 hkalifilt.cc:1648
 hkalifilt.cc:1649
 hkalifilt.cc:1650
 hkalifilt.cc:1651
 hkalifilt.cc:1652
 hkalifilt.cc:1653
 hkalifilt.cc:1654
 hkalifilt.cc:1655
 hkalifilt.cc:1656
 hkalifilt.cc:1657
 hkalifilt.cc:1658
 hkalifilt.cc:1659
 hkalifilt.cc:1660
 hkalifilt.cc:1661
 hkalifilt.cc:1662
 hkalifilt.cc:1663
 hkalifilt.cc:1664
 hkalifilt.cc:1665
 hkalifilt.cc:1666
 hkalifilt.cc:1667
 hkalifilt.cc:1668
 hkalifilt.cc:1669
 hkalifilt.cc:1670
 hkalifilt.cc:1671
 hkalifilt.cc:1672
 hkalifilt.cc:1673
 hkalifilt.cc:1674
 hkalifilt.cc:1675
 hkalifilt.cc:1676
 hkalifilt.cc:1677
 hkalifilt.cc:1678
 hkalifilt.cc:1679
 hkalifilt.cc:1680
 hkalifilt.cc:1681
 hkalifilt.cc:1682
 hkalifilt.cc:1683
 hkalifilt.cc:1684
 hkalifilt.cc:1685
 hkalifilt.cc:1686
 hkalifilt.cc:1687
 hkalifilt.cc:1688
 hkalifilt.cc:1689
 hkalifilt.cc:1690
 hkalifilt.cc:1691
 hkalifilt.cc:1692
 hkalifilt.cc:1693
 hkalifilt.cc:1694
 hkalifilt.cc:1695
 hkalifilt.cc:1696
 hkalifilt.cc:1697
 hkalifilt.cc:1698
 hkalifilt.cc:1699
 hkalifilt.cc:1700
 hkalifilt.cc:1701
 hkalifilt.cc:1702
 hkalifilt.cc:1703
 hkalifilt.cc:1704
 hkalifilt.cc:1705
 hkalifilt.cc:1706
 hkalifilt.cc:1707
 hkalifilt.cc:1708
 hkalifilt.cc:1709
 hkalifilt.cc:1710
 hkalifilt.cc:1711
 hkalifilt.cc:1712
 hkalifilt.cc:1713
 hkalifilt.cc:1714
 hkalifilt.cc:1715
 hkalifilt.cc:1716
 hkalifilt.cc:1717
 hkalifilt.cc:1718
 hkalifilt.cc:1719
 hkalifilt.cc:1720
 hkalifilt.cc:1721
 hkalifilt.cc:1722
 hkalifilt.cc:1723
 hkalifilt.cc:1724
 hkalifilt.cc:1725
 hkalifilt.cc:1726
 hkalifilt.cc:1727
 hkalifilt.cc:1728
 hkalifilt.cc:1729
 hkalifilt.cc:1730
 hkalifilt.cc:1731
 hkalifilt.cc:1732
 hkalifilt.cc:1733
 hkalifilt.cc:1734
 hkalifilt.cc:1735
 hkalifilt.cc:1736
 hkalifilt.cc:1737
 hkalifilt.cc:1738
 hkalifilt.cc:1739
 hkalifilt.cc:1740
 hkalifilt.cc:1741
 hkalifilt.cc:1742
 hkalifilt.cc:1743
 hkalifilt.cc:1744
 hkalifilt.cc:1745
 hkalifilt.cc:1746
 hkalifilt.cc:1747
 hkalifilt.cc:1748
 hkalifilt.cc:1749
 hkalifilt.cc:1750
 hkalifilt.cc:1751
 hkalifilt.cc:1752
 hkalifilt.cc:1753
 hkalifilt.cc:1754
 hkalifilt.cc:1755
 hkalifilt.cc:1756
 hkalifilt.cc:1757
 hkalifilt.cc:1758
 hkalifilt.cc:1759
 hkalifilt.cc:1760
 hkalifilt.cc:1761
 hkalifilt.cc:1762
 hkalifilt.cc:1763
 hkalifilt.cc:1764
 hkalifilt.cc:1765
 hkalifilt.cc:1766
 hkalifilt.cc:1767
 hkalifilt.cc:1768
 hkalifilt.cc:1769
 hkalifilt.cc:1770
 hkalifilt.cc:1771
 hkalifilt.cc:1772
 hkalifilt.cc:1773
 hkalifilt.cc:1774
 hkalifilt.cc:1775
 hkalifilt.cc:1776
 hkalifilt.cc:1777
 hkalifilt.cc:1778
 hkalifilt.cc:1779
 hkalifilt.cc:1780
 hkalifilt.cc:1781
 hkalifilt.cc:1782
 hkalifilt.cc:1783
 hkalifilt.cc:1784
 hkalifilt.cc:1785
 hkalifilt.cc:1786
 hkalifilt.cc:1787
 hkalifilt.cc:1788
 hkalifilt.cc:1789
 hkalifilt.cc:1790
 hkalifilt.cc:1791
 hkalifilt.cc:1792
 hkalifilt.cc:1793
 hkalifilt.cc:1794
 hkalifilt.cc:1795
 hkalifilt.cc:1796
 hkalifilt.cc:1797
 hkalifilt.cc:1798
 hkalifilt.cc:1799
 hkalifilt.cc:1800
 hkalifilt.cc:1801
 hkalifilt.cc:1802
 hkalifilt.cc:1803
 hkalifilt.cc:1804
 hkalifilt.cc:1805
 hkalifilt.cc:1806
 hkalifilt.cc:1807
 hkalifilt.cc:1808
 hkalifilt.cc:1809
 hkalifilt.cc:1810
 hkalifilt.cc:1811
 hkalifilt.cc:1812
 hkalifilt.cc:1813
 hkalifilt.cc:1814
 hkalifilt.cc:1815
 hkalifilt.cc:1816
 hkalifilt.cc:1817
 hkalifilt.cc:1818
 hkalifilt.cc:1819
 hkalifilt.cc:1820
 hkalifilt.cc:1821
 hkalifilt.cc:1822
 hkalifilt.cc:1823
 hkalifilt.cc:1824
 hkalifilt.cc:1825
 hkalifilt.cc:1826
 hkalifilt.cc:1827
 hkalifilt.cc:1828
 hkalifilt.cc:1829
 hkalifilt.cc:1830
 hkalifilt.cc:1831
 hkalifilt.cc:1832
 hkalifilt.cc:1833
 hkalifilt.cc:1834
 hkalifilt.cc:1835
 hkalifilt.cc:1836
 hkalifilt.cc:1837
 hkalifilt.cc:1838
 hkalifilt.cc:1839
 hkalifilt.cc:1840
 hkalifilt.cc:1841
 hkalifilt.cc:1842
 hkalifilt.cc:1843
 hkalifilt.cc:1844
 hkalifilt.cc:1845
 hkalifilt.cc:1846
 hkalifilt.cc:1847
 hkalifilt.cc:1848
 hkalifilt.cc:1849
 hkalifilt.cc:1850
 hkalifilt.cc:1851
 hkalifilt.cc:1852
 hkalifilt.cc:1853
 hkalifilt.cc:1854
 hkalifilt.cc:1855
 hkalifilt.cc:1856
 hkalifilt.cc:1857
 hkalifilt.cc:1858
 hkalifilt.cc:1859
 hkalifilt.cc:1860
 hkalifilt.cc:1861
 hkalifilt.cc:1862
 hkalifilt.cc:1863
 hkalifilt.cc:1864
 hkalifilt.cc:1865
 hkalifilt.cc:1866
 hkalifilt.cc:1867
 hkalifilt.cc:1868
 hkalifilt.cc:1869
 hkalifilt.cc:1870
 hkalifilt.cc:1871
 hkalifilt.cc:1872
 hkalifilt.cc:1873
 hkalifilt.cc:1874
 hkalifilt.cc:1875
 hkalifilt.cc:1876
 hkalifilt.cc:1877
 hkalifilt.cc:1878
 hkalifilt.cc:1879
 hkalifilt.cc:1880
 hkalifilt.cc:1881
 hkalifilt.cc:1882
 hkalifilt.cc:1883
 hkalifilt.cc:1884
 hkalifilt.cc:1885
 hkalifilt.cc:1886
 hkalifilt.cc:1887
 hkalifilt.cc:1888
 hkalifilt.cc:1889
 hkalifilt.cc:1890
 hkalifilt.cc:1891
 hkalifilt.cc:1892
 hkalifilt.cc:1893
 hkalifilt.cc:1894
 hkalifilt.cc:1895
 hkalifilt.cc:1896
 hkalifilt.cc:1897
 hkalifilt.cc:1898
 hkalifilt.cc:1899
 hkalifilt.cc:1900
 hkalifilt.cc:1901
 hkalifilt.cc:1902
 hkalifilt.cc:1903
 hkalifilt.cc:1904
 hkalifilt.cc:1905
 hkalifilt.cc:1906
 hkalifilt.cc:1907
 hkalifilt.cc:1908
 hkalifilt.cc:1909
 hkalifilt.cc:1910
 hkalifilt.cc:1911
 hkalifilt.cc:1912
 hkalifilt.cc:1913
 hkalifilt.cc:1914
 hkalifilt.cc:1915
 hkalifilt.cc:1916
 hkalifilt.cc:1917
 hkalifilt.cc:1918
 hkalifilt.cc:1919
 hkalifilt.cc:1920
 hkalifilt.cc:1921
 hkalifilt.cc:1922
 hkalifilt.cc:1923
 hkalifilt.cc:1924
 hkalifilt.cc:1925
 hkalifilt.cc:1926
 hkalifilt.cc:1927
 hkalifilt.cc:1928
 hkalifilt.cc:1929
 hkalifilt.cc:1930
 hkalifilt.cc:1931
 hkalifilt.cc:1932
 hkalifilt.cc:1933
 hkalifilt.cc:1934
 hkalifilt.cc:1935
 hkalifilt.cc:1936
 hkalifilt.cc:1937
 hkalifilt.cc:1938
 hkalifilt.cc:1939
 hkalifilt.cc:1940
 hkalifilt.cc:1941
 hkalifilt.cc:1942
 hkalifilt.cc:1943
 hkalifilt.cc:1944
 hkalifilt.cc:1945
 hkalifilt.cc:1946
 hkalifilt.cc:1947
 hkalifilt.cc:1948
 hkalifilt.cc:1949
 hkalifilt.cc:1950
 hkalifilt.cc:1951
 hkalifilt.cc:1952
 hkalifilt.cc:1953
 hkalifilt.cc:1954
 hkalifilt.cc:1955
 hkalifilt.cc:1956
 hkalifilt.cc:1957
 hkalifilt.cc:1958
 hkalifilt.cc:1959
 hkalifilt.cc:1960
 hkalifilt.cc:1961
 hkalifilt.cc:1962
 hkalifilt.cc:1963
 hkalifilt.cc:1964
 hkalifilt.cc:1965
 hkalifilt.cc:1966
 hkalifilt.cc:1967
 hkalifilt.cc:1968
 hkalifilt.cc:1969
 hkalifilt.cc:1970
 hkalifilt.cc:1971
 hkalifilt.cc:1972
 hkalifilt.cc:1973
 hkalifilt.cc:1974
 hkalifilt.cc:1975
 hkalifilt.cc:1976
 hkalifilt.cc:1977
 hkalifilt.cc:1978
 hkalifilt.cc:1979
 hkalifilt.cc:1980
 hkalifilt.cc:1981
 hkalifilt.cc:1982
 hkalifilt.cc:1983
 hkalifilt.cc:1984
 hkalifilt.cc:1985
 hkalifilt.cc:1986
 hkalifilt.cc:1987
 hkalifilt.cc:1988
 hkalifilt.cc:1989
 hkalifilt.cc:1990
 hkalifilt.cc:1991
 hkalifilt.cc:1992
 hkalifilt.cc:1993
 hkalifilt.cc:1994
 hkalifilt.cc:1995
 hkalifilt.cc:1996
 hkalifilt.cc:1997
 hkalifilt.cc:1998
 hkalifilt.cc:1999
 hkalifilt.cc:2000
 hkalifilt.cc:2001
 hkalifilt.cc:2002
 hkalifilt.cc:2003
 hkalifilt.cc:2004
 hkalifilt.cc:2005
 hkalifilt.cc:2006
 hkalifilt.cc:2007
 hkalifilt.cc:2008
 hkalifilt.cc:2009
 hkalifilt.cc:2010
 hkalifilt.cc:2011
 hkalifilt.cc:2012
 hkalifilt.cc:2013
 hkalifilt.cc:2014
 hkalifilt.cc:2015
 hkalifilt.cc:2016
 hkalifilt.cc:2017
 hkalifilt.cc:2018
 hkalifilt.cc:2019
 hkalifilt.cc:2020
 hkalifilt.cc:2021
 hkalifilt.cc:2022
 hkalifilt.cc:2023
 hkalifilt.cc:2024
 hkalifilt.cc:2025
 hkalifilt.cc:2026
 hkalifilt.cc:2027
 hkalifilt.cc:2028
 hkalifilt.cc:2029
 hkalifilt.cc:2030
 hkalifilt.cc:2031
 hkalifilt.cc:2032
 hkalifilt.cc:2033
 hkalifilt.cc:2034
 hkalifilt.cc:2035
 hkalifilt.cc:2036
 hkalifilt.cc:2037
 hkalifilt.cc:2038
 hkalifilt.cc:2039
 hkalifilt.cc:2040
 hkalifilt.cc:2041
 hkalifilt.cc:2042
 hkalifilt.cc:2043
 hkalifilt.cc:2044
 hkalifilt.cc:2045
 hkalifilt.cc:2046
 hkalifilt.cc:2047
 hkalifilt.cc:2048
 hkalifilt.cc:2049
 hkalifilt.cc:2050
 hkalifilt.cc:2051
 hkalifilt.cc:2052
 hkalifilt.cc:2053
 hkalifilt.cc:2054
 hkalifilt.cc:2055
 hkalifilt.cc:2056
 hkalifilt.cc:2057
 hkalifilt.cc:2058
 hkalifilt.cc:2059
 hkalifilt.cc:2060
 hkalifilt.cc:2061
 hkalifilt.cc:2062
 hkalifilt.cc:2063
 hkalifilt.cc:2064
 hkalifilt.cc:2065
 hkalifilt.cc:2066
 hkalifilt.cc:2067
 hkalifilt.cc:2068
 hkalifilt.cc:2069
 hkalifilt.cc:2070
 hkalifilt.cc:2071
 hkalifilt.cc:2072
 hkalifilt.cc:2073
 hkalifilt.cc:2074
 hkalifilt.cc:2075
 hkalifilt.cc:2076
 hkalifilt.cc:2077
 hkalifilt.cc:2078
 hkalifilt.cc:2079
 hkalifilt.cc:2080
 hkalifilt.cc:2081
 hkalifilt.cc:2082
 hkalifilt.cc:2083
 hkalifilt.cc:2084
 hkalifilt.cc:2085
 hkalifilt.cc:2086
 hkalifilt.cc:2087
 hkalifilt.cc:2088
 hkalifilt.cc:2089
 hkalifilt.cc:2090
 hkalifilt.cc:2091
 hkalifilt.cc:2092
 hkalifilt.cc:2093
 hkalifilt.cc:2094
 hkalifilt.cc:2095
 hkalifilt.cc:2096
 hkalifilt.cc:2097
 hkalifilt.cc:2098
 hkalifilt.cc:2099
 hkalifilt.cc:2100
 hkalifilt.cc:2101
 hkalifilt.cc:2102
 hkalifilt.cc:2103
 hkalifilt.cc:2104
 hkalifilt.cc:2105
 hkalifilt.cc:2106
 hkalifilt.cc:2107
 hkalifilt.cc:2108
 hkalifilt.cc:2109
 hkalifilt.cc:2110
 hkalifilt.cc:2111
 hkalifilt.cc:2112
 hkalifilt.cc:2113
 hkalifilt.cc:2114
 hkalifilt.cc:2115
 hkalifilt.cc:2116
 hkalifilt.cc:2117
 hkalifilt.cc:2118
 hkalifilt.cc:2119
 hkalifilt.cc:2120
 hkalifilt.cc:2121
 hkalifilt.cc:2122
 hkalifilt.cc:2123
 hkalifilt.cc:2124
 hkalifilt.cc:2125
 hkalifilt.cc:2126
 hkalifilt.cc:2127
 hkalifilt.cc:2128
 hkalifilt.cc:2129
 hkalifilt.cc:2130
 hkalifilt.cc:2131
 hkalifilt.cc:2132
 hkalifilt.cc:2133
 hkalifilt.cc:2134
 hkalifilt.cc:2135
 hkalifilt.cc:2136
 hkalifilt.cc:2137
 hkalifilt.cc:2138
 hkalifilt.cc:2139
 hkalifilt.cc:2140
 hkalifilt.cc:2141
 hkalifilt.cc:2142
 hkalifilt.cc:2143
 hkalifilt.cc:2144
 hkalifilt.cc:2145
 hkalifilt.cc:2146
 hkalifilt.cc:2147
 hkalifilt.cc:2148
 hkalifilt.cc:2149
 hkalifilt.cc:2150
 hkalifilt.cc:2151
 hkalifilt.cc:2152
 hkalifilt.cc:2153
 hkalifilt.cc:2154
 hkalifilt.cc:2155
 hkalifilt.cc:2156
 hkalifilt.cc:2157
 hkalifilt.cc:2158
 hkalifilt.cc:2159
 hkalifilt.cc:2160
 hkalifilt.cc:2161
 hkalifilt.cc:2162
 hkalifilt.cc:2163
 hkalifilt.cc:2164
 hkalifilt.cc:2165
 hkalifilt.cc:2166
 hkalifilt.cc:2167
 hkalifilt.cc:2168
 hkalifilt.cc:2169
 hkalifilt.cc:2170
 hkalifilt.cc:2171
 hkalifilt.cc:2172
 hkalifilt.cc:2173
 hkalifilt.cc:2174
 hkalifilt.cc:2175
 hkalifilt.cc:2176
 hkalifilt.cc:2177
 hkalifilt.cc:2178
 hkalifilt.cc:2179
 hkalifilt.cc:2180
 hkalifilt.cc:2181
 hkalifilt.cc:2182
 hkalifilt.cc:2183
 hkalifilt.cc:2184
 hkalifilt.cc:2185
 hkalifilt.cc:2186
 hkalifilt.cc:2187
 hkalifilt.cc:2188
 hkalifilt.cc:2189
 hkalifilt.cc:2190
 hkalifilt.cc:2191
 hkalifilt.cc:2192
 hkalifilt.cc:2193
 hkalifilt.cc:2194
 hkalifilt.cc:2195
 hkalifilt.cc:2196
 hkalifilt.cc:2197
 hkalifilt.cc:2198
 hkalifilt.cc:2199