TwoTrackMassKinematicConstraint Class Reference

#include <TwoTrackMassKinematicConstraint.h>

Inheritance diagram for TwoTrackMassKinematicConstraint:

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

Private Attributes
ParticleMass	mass

Detailed Description

Class implementing the total mass of 2 tracks constraint. I.e. 2 first particles out of four passed form a given mass

Warning: the tracks to constraint should be 1st and 2nd from the beginning of the vector.

Definition at line 21 of file TwoTrackMassKinematicConstraint.h.

Constructor & Destructor Documentation

TwoTrackMassKinematicConstraint::TwoTrackMassKinematicConstraint ( ParticleMass &  ms )

inline

Definition at line 24 of file TwoTrackMassKinematicConstraint.h.

Referenced by clone().

                                                  :mass(ms)
 {}

Member Function Documentation

virtual TwoTrackMassKinematicConstraint* TwoTrackMassKinematicConstraint::clone ( void  ) const

inlinevirtual

Implements MultiTrackKinematicConstraint.

Definition at line 58 of file TwoTrackMassKinematicConstraint.h.

References TwoTrackMassKinematicConstraint().

{return new TwoTrackMassKinematicConstraint(*this);}

int TwoTrackMassKinematicConstraint::numberOfEquations ( ) const

virtual

Number of equations per track used for the fit

Implements MultiTrackKinematicConstraint.

Definition at line 128 of file TwoTrackMassKinematicConstraint.cc.

{return 1;}

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

virtual

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

Implements MultiTrackKinematicConstraint.

Definition at line 39 of file TwoTrackMassKinematicConstraint.cc.

References reco::e1, reco::e2, p1, p2, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

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

 AlgebraicMatrix res(1,n_st*7,0);
 
  double a_1 = -states[0].particleCharge() * states[0].magneticField()->inInverseGeV(states[0].globalPosition()).z();
  double a_2 = -states[1].particleCharge() * states[1].magneticField()->inInverseGeV(states[1].globalPosition()).z();
 
 AlgebraicVector7 p1 = states[0].kinematicParameters().vector();
 AlgebraicVector7 p2 = states[1].kinematicParameters().vector();
 
 double p1vx = p1(3) - a_1*(point.y() - p1(1));
 double p1vy = p1(4) + a_1*(point.x() - p1(0));
 double p1vz = p1(5);
 ParticleMass m1 = p1(6);
 
 double p2vx = p2(3) - a_2*(point.y() - p2(1));
 double p2vy = p2(4) + a_2*(point.x() - p2(0)); 
 double p2vz = p2(5);
 ParticleMass m2 = p2(6);
 
 double e1 = sqrt(p1(3)*p1(3)+p1(4)*p1(4)+p1(5)*p1(5)+m1*m1);
 double e2 = sqrt(p2(3)*p2(3)+p2(4)*p2(4)+p2(5)*p2(5)+m2*m2);


//x1 and x2 derivatives: 1st and 8th elements 
 res(1,1) = 2*a_1*(p2vy + p1vy);
 res(1,8) = 2*a_2*(p2vy + p1vy);

//y1 and y2 derivatives: 2nd and 9th elements:
 res(1,2) = -2*a_1*(p1vx + p2vx);
 res(1,9) = -2*a_2*(p2vx + p1vx);
 
//z1 and z2 components: 3d and 10th elmnets stay 0:
 res(1,3)  = 0.;
 res(1,10) = 0.;
 
//px1 and px2 components: 4th and 11th elements: 
 res(1,4)  = 2*(1+e2/e1)*p1(3) - 2*(p1vx + p2vx);
 res(1,11) = 2*(1+e1/e2)*p2(3) - 2*(p1vx + p2vx);

//py1 and py2 components: 5th and 12 elements:
  res(1,5)  = 2*(1+e2/e1)*p1(4) - 2*(p1vy + p2vy);
  res(1,12) = 2*(1+e1/e2)*p2(4) - 2*(p2vy + p1vy);
 
//pz1 and pz2 components: 6th and 13 elements:
 res(1,6)  = 2*(1+e2/e1)*p1(5)- 2*(p1vz + p2vz);
 res(1,13) = 2*(1+e1/e2)*p2(5)- 2*(p2vz + p1vz);
 
//mass components: 7th and 14th elements:
 res(1,7)  = 2*m1*(1+e2/e1);
 res(1,14) = 2*m2*(1+e1/e2);

  return res;
}           

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

virtual

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

Implements MultiTrackKinematicConstraint.

Definition at line 98 of file TwoTrackMassKinematicConstraint.cc.

References p1, p2, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

{
 AlgebraicMatrix res(1,3,0);
 if(states.size()<2) throw VertexException("TwoTrackMassKinematicConstraint::<2 states passed");

  double a_1 = -states[0].particleCharge() * states[0].magneticField()->inInverseGeV(states[0].globalPosition()).z();
  double a_2 = -states[1].particleCharge() * states[1].magneticField()->inInverseGeV(states[1].globalPosition()).z();
 
 AlgebraicVector7 p1 = states[0].kinematicParameters().vector();
 AlgebraicVector7 p2 = states[1].kinematicParameters().vector();
 
 double p1vx = p1(3) - a_1*(point.y() - p1(1));
 double p1vy = p1(4) + a_1*(point.x() - p1(0));
 
 double p2vx = p2(3) - a_2*(point.y() - p2(1));
 double p2vy = p2(4) + a_2*(point.x() - p2(0)); 
 
//xv component
 res(1,1) = -2*(p1vy + p2vy)*(a_1+a_2);

//yv component
 res(1,2) = 2*(p1vx + p2vx)*(a_1+a_2);

//zv component 
 res(1,3) = 0.; 
 
 return res;
}                   

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

virtual

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

Implements MultiTrackKinematicConstraint.

Definition at line 5 of file TwoTrackMassKinematicConstraint.cc.

References mass, p1, p2, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

{ 
 if(states.size()<2) throw VertexException("TwoTrackMassKinematicConstraint::<2 states passed");

 AlgebraicVector res(1,0);
 
 double a_1 = -states[0].particleCharge() * states[0].magneticField()->inInverseGeV(states[0].globalPosition()).z();
 double a_2 = -states[1].particleCharge() * states[1].magneticField()->inInverseGeV(states[1].globalPosition()).z();

 AlgebraicVector7 p1 = states[0].kinematicParameters().vector();
 AlgebraicVector7 p2 = states[1].kinematicParameters().vector();
 
 double p1vx = p1(3) - a_1*(point.y() - p1(1));
 double p1vy = p1(4) + a_1*(point.x() - p1(0));
 double p1vz = p1(5);
 ParticleMass m1 = p1(6);
 
 double p2vx = p2(3) - a_2*(point.y() - p2(1));
 double p2vy = p2(4) + a_2*(point.x() - p2(0)); 
 double p2vz = p2(5);
 ParticleMass m2 = p2(6);
 
 double j_energy = sqrt(p1(3)*p1(3)+p1(4)*p1(4)+p1(5)*p1(5)+m1*m1)+
                  sqrt(p2(3)*p2(3)+p2(4)*p2(4)+p2(5)*p2(5)+m2*m2)  ;
 
               
 double j_m = (p1vx+p2vx)*(p1vx+p2vx) + (p1vy+p2vy)*(p1vy+p2vy) +
             (p1vz+p2vz)*(p1vz+p2vz);               

 res(1)  = j_energy*j_energy - j_m - mass*mass;
 return res;
}           

Member Data Documentation

ParticleMass TwoTrackMassKinematicConstraint::mass

private

Definition at line 63 of file TwoTrackMassKinematicConstraint.h.

Referenced by value().