VertexKinematicConstraint Class Reference

#include <VertexKinematicConstraint.h>

Inheritance diagram for VertexKinematicConstraint:

Public Member Functions
VertexKinematicConstraint *	clone () const override
int	numberOfEquations () const override
AlgebraicMatrix	parametersDerivative (const std::vector< KinematicState > &states, const GlobalPoint &point) const override
AlgebraicMatrix	positionDerivative (const std::vector< KinematicState > &states, const GlobalPoint &point) const override
AlgebraicVector	value (const std::vector< KinematicState > &states, const GlobalPoint &point) const override
	VertexKinematicConstraint ()
	~VertexKinematicConstraint () override
Public Member Functions inherited from MultiTrackKinematicConstraint
	MultiTrackKinematicConstraint ()
virtual	~MultiTrackKinematicConstraint ()

Detailed Description

Class implementing the vertexing constraint for extended cartesian parametrization (x,y,z,p_x,p_y,p_z,m). The equations and derivatives in general follow the P.Avery's "Applied Fitting Theory-VI" CBX 98-37

Definition at line 14 of file VertexKinematicConstraint.h.

Constructor & Destructor Documentation

VertexKinematicConstraint::VertexKinematicConstraint

(

)

Definition at line 5 of file VertexKinematicConstraint.cc.

Referenced by clone().

{}

VertexKinematicConstraint::~VertexKinematicConstraint ( )

override

Definition at line 7 of file VertexKinematicConstraint.cc.

{}

Member Function Documentation

VertexKinematicConstraint* VertexKinematicConstraint::clone ( void  ) const

inlineoverridevirtual

Implements MultiTrackKinematicConstraint.

Definition at line 47 of file VertexKinematicConstraint.h.

References VertexKinematicConstraint().

{ return new VertexKinematicConstraint(*this); }

int VertexKinematicConstraint::numberOfEquations ( ) const

overridevirtual

Number of equations per track used for the fit

Implements MultiTrackKinematicConstraint.

Definition at line 160 of file VertexKinematicConstraint.cc.

{ return 2; }

AlgebraicMatrix VertexKinematicConstraint::parametersDerivative ( const std::vector< KinematicState > &  states, const GlobalPoint &  point  ) const

overridevirtual

Returns a matrix of derivatives of constraint equations w.r.t. particle parameters

Implements MultiTrackKinematicConstraint.

Definition at line 50 of file VertexKinematicConstraint.cc.

References CommonMethods::delta(), mps_fire::i, isotrackApplyRegressor::k, visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, pileupDistInMC::num, DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::transverse(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by KinematicConstrainedVertexUpdator::update().

                                                                                                {
  int num = states.size();
  if (num < 2)
    throw VertexException("VertexKinematicConstraint::<2 states passed");
  AlgebraicMatrix jac_d(2 * num, 7 * num);
  int num_r = 0;
  for (std::vector<KinematicState>::const_iterator i = states.begin(); i != states.end(); i++) {
    AlgebraicMatrix el_part_d(2, 7, 0);
    TrackCharge ch = i->particleCharge();
    GlobalVector mom = i->globalMomentum();
    GlobalPoint pos = i->globalPosition();
    double d_x = point.x() - pos.x();
    double d_y = point.y() - pos.y();
    double pt = mom.transverse();

    if (ch != 0) {
      //charged particle
      double a_i = -ch * i->magneticField()->inInverseGeV(pos).z();

      double pvx = mom.x() - a_i * d_y;
      double pvy = mom.y() + a_i * d_x;
      double pvt = sqrt(pvx * pvx + pvy * pvy);
      double novera = (d_x * mom.x() + d_y * mom.y());
      double n = a_i * novera;
      double m = (pvx * mom.x() + pvy * mom.y());
      double k = -mom.z() / (pvt * pvt * pt * pt);
      double delta = atan2(n, m);

      //D Jacobian matrix
      el_part_d(1, 1) = mom.y() + a_i * d_x;
      el_part_d(1, 2) = -mom.x() + a_i * d_y;
      el_part_d(2, 1) = -k * (m * mom.x() - n * mom.y());
      el_part_d(2, 2) = -k * (m * mom.y() + n * mom.x());
      el_part_d(2, 3) = -1.;
      el_part_d(1, 4) = d_y;
      el_part_d(1, 5) = -d_x;
      el_part_d(2, 4) = k * (m * d_x - novera * (2 * mom.x() - a_i * d_y));
      el_part_d(2, 5) = k * (m * d_y - novera * (2 * mom.y() + a_i * d_x));
      el_part_d(2, 6) = -delta / a_i;
      jac_d.sub(num_r * 2 + 1, num_r * 7 + 1, el_part_d);
    } else {
      //neutral particle
      el_part_d(1, 1) = mom.y();
      el_part_d(1, 2) = -mom.x();
      el_part_d(2, 1) = mom.x() * mom.z() / (pt * pt);
      el_part_d(2, 2) = mom.y() * mom.z() / (pt * pt);
      el_part_d(2, 3) = -1.;
      el_part_d(1, 4) = d_y;
      el_part_d(1, 5) = -d_x;
      el_part_d(2, 4) =
          2 * (d_x * mom.x() + d_y * mom.y()) * mom.x() * mom.z() / (pt * pt * pt * pt) - mom.z() * d_x / (pt * pt);
      el_part_d(2, 5) =
          2 * (d_x * mom.x() + d_y * mom.y()) * mom.y() * mom.z() / (pt * pt * pt * pt) - mom.z() * d_y / (pt * pt);
      el_part_d(2, 6) = -(d_x * mom.x() + d_y * mom.y()) / (pt * pt);
      jac_d.sub(num_r * 2 + 1, num_r * 7 + 1, el_part_d);
    }
    num_r++;
  }
  return jac_d;
}

AlgebraicMatrix VertexKinematicConstraint::positionDerivative ( const std::vector< KinematicState > &  states, const GlobalPoint &  point  ) const

overridevirtual

Returns a matrix of derivatives of constraint equations w.r.t. vertex position

Implements MultiTrackKinematicConstraint.

Definition at line 112 of file VertexKinematicConstraint.cc.

References mps_fire::i, isotrackApplyRegressor::k, visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, pileupDistInMC::num, DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::transverse(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by KinematicConstrainedVertexUpdator::update().

                                                                                              {
  int num = states.size();
  if (num < 2)
    throw VertexException("VertexKinematicConstraint::<2 states passed");
  AlgebraicMatrix jac_e(2 * num, 3);
  int num_r = 0;
  for (std::vector<KinematicState>::const_iterator i = states.begin(); i != states.end(); i++) {
    AlgebraicMatrix el_part_e(2, 3, 0);
    TrackCharge ch = i->particleCharge();
    GlobalVector mom = i->globalMomentum();
    GlobalPoint pos = i->globalPosition();
    double d_x = point.x() - pos.x();
    double d_y = point.y() - pos.y();
    double pt = mom.transverse();

    if (ch != 0) {
      //charged particle
      double a_i = -ch * i->magneticField()->inInverseGeV(pos).z();

      double pvx = mom.x() - a_i * d_y;
      double pvy = mom.y() + a_i * d_x;
      double pvt = sqrt(pvx * pvx + pvy * pvy);
      double n = a_i * (d_x * mom.x() + d_y * mom.y());
      double m = (pvx * mom.x() + pvy * mom.y());
      double k = -mom.z() / (pvt * pvt * pt * pt);

      //E jacobian matrix
      el_part_e(1, 1) = -(mom.y() + a_i * d_x);
      el_part_e(1, 2) = mom.x() - a_i * d_y;
      el_part_e(2, 1) = k * (m * mom.x() - n * mom.y());
      el_part_e(2, 2) = k * (m * mom.y() + n * mom.x());
      el_part_e(2, 3) = 1;
      jac_e.sub(2 * num_r + 1, 1, el_part_e);
    } else {
      //neutral particle
      el_part_e(1, 1) = -mom.y();
      el_part_e(1, 2) = mom.x();
      el_part_e(2, 1) = -mom.x() * mom.z() / (pt * pt);
      el_part_e(2, 2) = -mom.y() * mom.z() / (pt * pt);
      el_part_e(2, 3) = 1;
      jac_e.sub(2 * num_r + 1, 1, el_part_e);
    }
    num_r++;
  }
  return jac_e;
}

AlgebraicVector VertexKinematicConstraint::value ( const std::vector< KinematicState > &  states, const GlobalPoint &  point  ) const

overridevirtual

Returns a vector of values of constraint equations at the point where the input particles are defined.

Implements MultiTrackKinematicConstraint.

Definition at line 9 of file VertexKinematicConstraint.cc.

References CommonMethods::delta(), mps_fire::i, visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, pileupDistInMC::num, DiDispStaMuonMonitor_cfi::pt, PV3DBase< T, PVType, FrameType >::transverse(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by Types.int32::__nonzero__(), Types.uint32::__nonzero__(), Types.int64::__nonzero__(), Types.uint64::__nonzero__(), Types.double::__nonzero__(), Types.bool::__nonzero__(), Types.string::__nonzero__(), Types.string::configValue(), Types.FileInPath::configValue(), Types.int32::insertInto(), Types.uint32::insertInto(), Types.int64::insertInto(), Types.uint64::insertInto(), Types.double::insertInto(), Types.bool::insertInto(), Types.string::insertInto(), Types.FileInPath::insertInto(), Types.vint32::insertInto(), Types.vuint32::insertInto(), Types.vint64::insertInto(), Types.vuint64::insertInto(), Types.vdouble::insertInto(), Types.vbool::insertInto(), Types.vstring::insertInto(), and KinematicConstrainedVertexUpdator::update().

                                                                                 {
  int num = states.size();
  if (num < 2)
    throw VertexException("VertexKinematicConstraint::<2 states passed");

  //it is 2 equations per track
  AlgebraicVector vl(2 * num, 0);
  int num_r = 0;
  for (std::vector<KinematicState>::const_iterator i = states.begin(); i != states.end(); i++) {
    TrackCharge ch = i->particleCharge();
    GlobalVector mom = i->globalMomentum();
    GlobalPoint pos = i->globalPosition();
    double d_x = point.x() - pos.x();
    double d_y = point.y() - pos.y();
    double d_z = point.z() - pos.z();
    double pt = mom.transverse();

    if (ch != 0) {
      //charged particle
      double a_i = -ch * i->magneticField()->inInverseGeV(pos).z();

      double pvx = mom.x() - a_i * d_y;
      double pvy = mom.y() + a_i * d_x;
      double n = a_i * (d_x * mom.x() + d_y * mom.y());
      double m = (pvx * mom.x() + pvy * mom.y());
      double delta = atan2(n, m);

      //vector of values
      vl(num_r * 2 + 1) = d_y * mom.x() - d_x * mom.y() - a_i * (d_x * d_x + d_y * d_y) / 2;
      vl(num_r * 2 + 2) = d_z - mom.z() * delta / a_i;
    } else {
      //neutral particle
      vl(num_r * 2 + 1) = d_y * mom.x() - d_x * mom.y();
      vl(num_r * 2 + 2) = d_z - mom.z() * (d_x * mom.x() + d_y * mom.y()) / (pt * pt);
    }
    num_r++;
  }
  return vl;
}