/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/RecoVertex/BeamSpotProducer/src/FcnBeamSpotFitPV.cc

Go to the documentation of this file.

#include "RecoVertex/BeamSpotProducer/interface/FcnBeamSpotFitPV.h"
#include "Math/SVector.h"
#include "Math/SMatrix.h"
// #include "Math/SMatrixDfwd.h"
//#include "FWCore/MessageLogger/interface/MessageLogger.h"

using namespace std;

//
// constructor from vertex data
//
FcnBeamSpotFitPV::FcnBeamSpotFitPV(const vector<BeamSpotFitPVData>& data) : 
  data_(data), errorDef_(1.) { 
  //
  // default: no additional cuts
  //
  lowerLimits_[0] = lowerLimits_[1] = lowerLimits_[2] = -1.e30;
  upperLimits_[0] = upperLimits_[1] = upperLimits_[2] =  1.e30;
}

void 
FcnBeamSpotFitPV::setLimits (float xmin, float xmax,
                          float ymin, float ymax,
                          float zmin, float zmax) 
{
  lowerLimits_[0] = xmin;
  lowerLimits_[1] = ymin;
  lowerLimits_[2] = zmin;
  upperLimits_[0] = xmax;
  upperLimits_[1] = ymax;
  upperLimits_[2] = zmax;
}

unsigned int
FcnBeamSpotFitPV::nrOfVerticesUsed () const
{
  //
  // count vertices imposing the current limits
  //
  unsigned int nVtx = 0;
  double v1(0);
  double v2(0);
  double v3(0);
  for ( vector<BeamSpotFitPVData>::const_iterator ipv=data_.begin();
        ipv!=data_.end(); ++ipv ) {
    v1 = (*ipv).position[0];
    if ( v1<lowerLimits_[0] || v1>upperLimits_[0] )  continue;
    v2 = (*ipv).position[1];
    if ( v2<lowerLimits_[1] || v2>upperLimits_[1] )  continue;
    v3 = (*ipv).position[2];
    if ( v3<lowerLimits_[2] || v3>upperLimits_[2] )  continue;

    ++nVtx;
  }

  return nVtx;
}

double
FcnBeamSpotFitPV::operator() (const std::vector<double>& pars) const
{
  //
  // fit parameters
  //
  double vb1 = pars[0];
  double vb2 = pars[1];
  double vb3 = pars[2];
  double sigb1 = pars[3]; 
  double corrb12 = pars[4];
  double sigb2 = pars[5];
  double dxdz = pars[6];
  double dydz = pars[7];
  double sigb3 = pars[8];
  double escale = pars[9];
  //
  // covariance matrix of the beamspot distribution
  //
  typedef ROOT::Math::SVector<double,3> Vector3D;
  typedef ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> > Matrix3D;
  Matrix3D covb;
  double varb1 = sigb1*sigb1;
  double varb2 = sigb2*sigb2;
  double varb3 = sigb3*sigb3;
// parametrisation: rotation (dx/dz, dy/dz); covxy
  covb(0,0) = varb1;
  covb(1,0) = covb(0,1) = corrb12*sigb1*sigb2;
  covb(1,1) = varb2;
  covb(2,0) = covb(0,2) = dxdz*(varb3-varb1)-dydz*covb(1,0);
  covb(2,1) = covb(1,2) = dydz*(varb3-varb2)-dxdz*covb(1,0);
  covb(2,2) = varb3;

  //
  // calculation of the likelihood function
  //
  double sumLL(0);
  double v1(0);
  double v2(0);
  double v3(0);
  double ev1(0);
  double corr12(0);
  double ev2(0);
  double corr13(0);
  double corr23(0);
  double ev3(0);
  //
  // vertex - beamspot difference and total covariance matrix
  //
  Vector3D dv;
  Matrix3D cov;
  Matrix3D wgt;
  //
  // iteration over vertices
  //
  for ( vector<BeamSpotFitPVData>::const_iterator ipv=data_.begin();
        ipv!=data_.end(); ++ipv ) {
    //
    // additional selection
    //
    v1 = (*ipv).position[0];
    if ( v1<lowerLimits_[0] || v1>upperLimits_[0] )  continue;
    v2 = (*ipv).position[1];
    if ( v2<lowerLimits_[1] || v2>upperLimits_[1] )  continue;
    v3 = (*ipv).position[2];
    if ( v3<lowerLimits_[2] || v3>upperLimits_[2] )  continue;
    //
    // vertex errors (after scaling) and correlations
    //
    ev1 = (*ipv).posError[0];
    corr12 = (*ipv).posCorr[0];
    ev2 = (*ipv).posError[1];
    corr13 = (*ipv).posCorr[1];
    corr23 = (*ipv).posCorr[2];
    ev3 = (*ipv).posError[2];
    ev1 *= escale;
    ev2 *= escale;
    ev3 *= escale;
    //
    // vertex covariance matrix
    //
    cov(0,0) = ev1*ev1;
    cov(1,0) = cov(0,1) = ev1*ev2*corr12;
    cov(1,1) = ev2*ev2;
    cov(2,0) = cov(0,2) = ev1*ev3*corr13;
    cov(2,1) = cov(1,2) = ev2*ev3*corr23;
    cov(2,2) = ev3*ev3;
    //
    // total covariance and weight matrix
    //
    cov += covb;
    int ifail;
    wgt = cov.Inverse(ifail);
    if ( ifail ) {
      //edm::LogWarning("FcnBeamSpotFitPV") 
      cout << "Inversion failed" << endl;
      return -1.e30;
    }
    //
    // difference of vertex and beamspot positions
    //
    dv(0) = v1 - vb1;
    dv(1) = v2 - vb2;
    dv(2) = v3 - vb3;
    //
    // exponential term and normalization
    // (neglecting the additional cut)
    //
    sumLL += ROOT::Math::Similarity(dv,wgt);
    double det;
    cov.Det2(det);
    sumLL += log(det);
  }

  return sumLL;
}