TMBSecondaryVertex.cpp

Go to the documentation of this file.

//                                                                      //
// TMBTree Secondary vertex class                                         //
//                                                                      //

#include <cmath>
#include "tmb_tree/TMBSecondaryVertex.hpp"

using std::sqrt;
using std::abs;

ClassImp(TMBSecondaryVertex);

// Default constructor.

TMBSecondaryVertex::TMBSecondaryVertex()
{}

// Initializing constructor.

TMBSecondaryVertex::
TMBSecondaryVertex(Float_t vertexx, Float_t vertexy, Float_t vertexz,
                   Float_t covxx, Float_t covyy, Float_t covzz, 
                   Float_t covxy, Float_t covxz, Float_t covyz,
                   Float_t chisq, const TRefArray* tracks,
                   const TMBLorentzVector& smoothed_momentum,
                   const TRef& primary_vertex) :
  TMBVertex(vertexx, vertexy, vertexz,
            covxx, covyy, covzz, 
            covxy, covxz, covyz,
            chisq, tracks),
  _primary_vertex(primary_vertex)
{
  *static_cast<TMBLorentzVector*>(this) = smoothed_momentum;
}

// Fill transient attributes.

void TMBSecondaryVertex::fill_pv_attributes() const
{
  if(_pv_pos.empty()) {

    // Get primary vertex object.

    assert(_primary_vertex.IsValid());
    const TMBPrimaryVertex& pv = GetPrimaryVertex();

    _pv_pos.resize(3);
    _pv_pos[0] = pv.vx();
    _pv_pos[1] = pv.vy();
    _pv_pos[2] = pv.vz();

    _pv_err.resize(6);
    _pv_err[0] = pv.sigxx();
    _pv_err[1] = pv.sigxy();
    _pv_err[2] = pv.sigyy();
    _pv_err[3] = pv.sigxz();
    _pv_err[4] = pv.sigyz();
    _pv_err[5] = pv.sigzz();

    // Displacement vector and error matrix.

    double dx = vx() - _pv_pos[0];
    double dy = vy() - _pv_pos[1];
    double dz = vz() - _pv_pos[2];

    double exx = sigxx() + _pv_err[0];
    double exy = sigxy() + _pv_err[1];
    double eyy = sigyy() + _pv_err[2];
    double exz = sigxz() + _pv_err[3];
    double eyz = sigyz() + _pv_err[4];
    double ezz = sigzz() + _pv_err[5];

    // Decay length.

    double dxy2 = dx*dx + dy*dy;
    _decay_len_xy = sqrt(dxy2);
    _decay_len_z = dz;
    double dxyz2 = dxy2 + dz*dz;
    _decay_len_xyz = sqrt(dxyz2);

    // Transverse decay length significance.

    _decay_sig_xy = 0.;
    double bxy2 = exx*eyy - exy*exy;
    if(bxy2 > 0) {
      double axy2 = dx*dx*eyy - 2.*dx*dy*exy + dy*dy*exx;
      _decay_sig_xy =  sqrt(axy2 / bxy2);
    }

    // Z decay length significance.

    _decay_sig_z =  abs(dz) / sqrt(ezz);

    // 3D decay length significance.

    _decay_sig_xyz = 0.;
    double bxyz2 = 
      exx*eyy*ezz + 2.*exy*eyz*exz - exx*eyz*eyz - eyy*exz*exz - ezz*exy*exy;
    if(bxyz2 > 0) {
      double axyz2 = 
        dx*dx * (eyy*ezz - eyz*eyz) 
        + dy*dy * (exx*ezz - exz*exz) 
        + dz*dz * (exx*eyy - exy*exy)
        + 2.*dx*dy * (exz*eyz - ezz*exy)
        + 2.*dx*dz * (exy*eyz - eyy*exz)
        + 2.*dy*dz * (exy*exz - exx*eyz);
      _decay_sig_xyz = sqrt(axyz2 / bxyz2);
    }

    // Colinearity.

    double p_dot_d = dx*Px() + dy*Py() + dz*Pz();
    _colinearity = p_dot_d / (P() * _decay_len_xyz);

    // Make transverse and 3D decay lengths negative if the colinearity is 
    // negative.

    if(_colinearity < 0) {
      _decay_len_xy = -_decay_len_xy;
      _decay_len_xyz = -_decay_len_xyz;
    }
  }
}

---