Ext_xp_err Class Reference

#include <Ext_xp_err.h>

Inheritance diagram for Ext_xp_err:

Ext_errmx List of all members.

Public Member Functions

 Ext_xp_err ()
 Ext_xp_err (const Ext_xp_err &xp_err)
 ~Ext_xp_err ()
void set_err (const HepSymMatrix &err, const Hep3Vector &xv, const Hep3Vector &pv, const double &q, const double &mass)
const Hep3Vector & get_x () const
const Hep3Vector & get_p () const
const double & get_q () const
double get_mass () const
bool move (const Hep3Vector &xv1, const Hep3Vector &pv1, const Hep3Vector &B, const int ms_on, const double chi_cc)
Ext_xp_erroperator= (const Ext_xp_err &xp_err)
void set_pos (const Hep3Vector &pos)
void set_mom (const Hep3Vector &mom)
void put_err (const double error[])
void put_err (const HepSymMatrix &err)
const HepSymMatrix & get_err () const
double get_plane_err (const Hep3Vector &np, const Hep3Vector &nr) const
const HepVector & get_plane_errs (const Hep3Vector &np, const Hep3Vector &nr, const Hep3Vector &nt) const
const Hep3Vector * get_tvs (const int view, const Hep3Vector &pv) const
const Hep3Vector * get_tvs (const Hep3Vector &pv) const
bool valid (bool msg) const

Protected Member Functions

void set_plane_errs (const Hep3Vector &nx, const Hep3Vector &ny, const Hep3Vector &nz) const

Protected Attributes

HepSymMatrix m_err

Private Attributes

Hep3Vector m_xv
Hep3Vector m_pv
HepMatrix m_xp_jcb
HepMatrix m_h2xp_jcb
double m_q
double m_mass2

Friends

std::ostreamoperator<< (std::ostream &s, const Ext_xp_err &xp_err)
std::ostreamoperator<< (std::ostream &s, const Ext_errmx &errmx)

Detailed Description

Definition at line 29 of file Ext_xp_err.h.


Constructor & Destructor Documentation

Ext_xp_err::Ext_xp_err (  ) 

Definition at line 34 of file Ext_xp_err.cxx.

00034                        :
00035         m_xv(3), m_pv(3), m_xp_jcb(Ndim_err,Ndim_err,0), 
00036         m_h2xp_jcb(Ndim_err,Ndim_herr,0), m_q(0), m_mass2(0){}

Ext_xp_err::Ext_xp_err ( const Ext_xp_err xp_err  ) 

Definition at line 39 of file Ext_xp_err.cxx.

00039                                               :
00040         Ext_errmx( (Ext_errmx)err ), m_xv(err.m_xv), m_pv(err.m_pv), 
00041         m_xp_jcb(err.m_xp_jcb), m_h2xp_jcb(err.m_h2xp_jcb), m_q( err.m_q ), 
00042         m_mass2( err.m_mass2 ){}

Ext_xp_err::~Ext_xp_err (  )  [inline]

Definition at line 34 of file Ext_xp_err.h.

00034 {};// Destructor


Member Function Documentation

const HepSymMatrix & Ext_errmx::get_err (  )  const [inline, inherited]

Definition at line 157 of file Ext_errmx.h.

References Ext_errmx::m_err.

Referenced by ExtSteppingAction::UserSteppingAction().

00157                                                      {
00158   return m_err;
00159 }

double Ext_xp_err::get_mass (  )  const [inline]

Definition at line 81 of file Ext_xp_err.h.

References m_mass2.

00081                                          {
00082   return sqrt(m_mass2);
00083 }

const Hep3Vector & Ext_xp_err::get_p (  )  const [inline]

Definition at line 69 of file Ext_xp_err.h.

References m_pv.

00069                                                   {
00070   return m_pv;
00071 }

double Ext_errmx::get_plane_err ( const Hep3Vector &  np,
const Hep3Vector &  nr 
) const [inherited]

Definition at line 85 of file Ext_errmx.cxx.

References Eps(), ers::error, Infinite(), and nr.

Referenced by ExtSteppingAction::UserSteppingAction().

00095 {
00096 
00097 // Check the validity of the error matrix.
00098 
00099   if( !(*this).valid( 0 ) ){
00100     //std::cout << "%WARNING at Ext_get_plane_err: You are trying to calculate"
00101 //      << " error \n           using an invalid error matrix." << std::endl;
00102   }
00103 
00104 // Construct 3 TCS axes.
00105 
00106 // x: nx --- unit vector which is perp to np and on the plane of nr and np.
00107 // y: nz x nx
00108 // z: nz( = np ) --- direction of the track.
00109 
00110   double nr_np( nr*np );
00111   double denom( 1.0 - nr_np*nr_np );
00112   double error( 0.0 );
00113 
00114   if( denom > Eps ){    // Track is not parallel to the readout direction.
00115 
00116     double fac( 1.0 / sqrt( denom ) );
00117     Hep3Vector nx( ( nr - nr_np * np ) * fac );
00118     Hep3Vector ny( np.cross( nx ) );
00119 
00120     (*this).set_plane_errs( nx, ny, np );
00121 
00122     double sigma2( m_err3( 1, 1 ) );    // Error along nx.
00123     if( sigma2 > 0 ){
00124       error = sqrt( sigma2 ) * fac;     // Error projection.
00125     }
00126 
00127   } else {      // Track is parallel to the readout direction.
00128 
00129     error = Infinite;
00130 
00131   }
00132   return( error );
00133 }

const HepVector & Ext_errmx::get_plane_errs ( const Hep3Vector &  np,
const Hep3Vector &  nr,
const Hep3Vector &  nt 
) const [inherited]

Get the 2D projected error vector on the detector plane. {itemize} np: track direction unit vector. nr: readout direction unit vector. nt: ( np x nr ) unit vector. HepVector(1)= error(sigma) along the nr. HepVector(2)= error(sigma) along the nt. {itemize}

Definition at line 140 of file Ext_errmx.cxx.

References Eps(), and nr.

00151 {
00152 
00153 // Check the validity of the error matrix.
00154 
00155   if( !(*this).valid( 1 ) ){
00156 //    std::cout << "%WARNING at Ext_get_plane_errs: You are trying to calculate"
00157 //      << " error \n           using an invalid error matrix." << std::endl;
00158   }
00159 
00160   double nr_np( nr*np );
00161   double denom_r( 1.0 - nr_np*nr_np );
00162 
00163   if( denom_r > Eps ){  // nr is not parallel to the track direction: np.
00164 
00165     double nt_np( nt*np );
00166     double denom_t( 1.0 - nt_np*nt_np );
00167     double fac_r( 1.0 / sqrt( denom_r ) );
00168     Hep3Vector nx( ( nr - nr_np * np ) * fac_r );
00169     Hep3Vector ny( np.cross( nx ) );
00170 
00171     (*this).set_plane_errs( nx, ny, np );
00172 
00173     double sigma2( m_err3( 1, 1 ) );    // Error along nx.
00174     if( sigma2 > 0 ){
00175       m_err2( 1 ) = sqrt( sigma2 ) * fac_r;     // Error projection.
00176     } else {
00177       m_err2( 1 ) = 0.0;
00178     }
00179 
00180     if( denom_t > Eps ){   // nt is not parallel to the track direction: np.
00181       double fac_t( 1.0 / sqrt( denom_t ) );
00182       sigma2 = m_err3( 2, 2 );
00183       if( sigma2 > 0 ){
00184         m_err2( 2 ) = sqrt( sigma2 ) * fac_t;   // Error projection.
00185       } else {
00186         m_err2( 2 ) = 0.0;
00187       }
00188     } else {    // nt is parallel to the track direction: np.
00189       m_err2( 2 ) = (*this).get_plane_err( np, nt );
00190     }
00191   } else {      // nr is parallel to the track direction: np.
00192     m_err2( 1 ) = (*this).get_plane_err( np, nr );
00193     m_err2( 2 ) = (*this).get_plane_err( np, nt );
00194   }
00195   return( m_err2 );
00196 }

const double & Ext_xp_err::get_q (  )  const [inline]

Definition at line 75 of file Ext_xp_err.h.

References m_q.

00075                                               {
00076   return m_q;
00077 }

const Hep3Vector * Ext_errmx::get_tvs ( const Hep3Vector &  pv  )  const [inherited]

Get the 2D projected track error perpendicular to a given vector at the current point. pv: a given vector, momentum vector, for example. {itemize} Hep3Vector(1)= error(1 sigma) along the direction which is perpendicular to pv on the plane formed by pv and z-axis. Hep3Vector(2)= error(1 sigma) along the direction which is (pv) x (HepVector(1) direction). {itemize}

Definition at line 278 of file Ext_errmx.cxx.

References nr, and unit.

00282 {
00283 
00284   Hep3Vector    np( pv.unit() );
00285   Hep3Vector    nz( 0.0, 0.0, 1.0 );
00286   Hep3Vector    nt( (nz.cross(np)).unit() );
00287   Hep3Vector    nr( nt.cross(np) );
00288 
00289   const HepVector & err_v = (*this).get_plane_errs( np, nr, nt );
00290   *m_nv         = err_v[0]*nr;
00291   *(m_nv+1)     = err_v[1]*nt;
00292   return( m_nv );
00293 
00294 }

const Hep3Vector * Ext_errmx::get_tvs ( const int  view,
const Hep3Vector &  pv 
) const [inherited]

Get 2D projected track error perpendicular to a given vector at the current point. pv: a given vector, momentum vector for example. {itemize} view=1. {itemize} Hep3Vector(1)= error(1 sigma) along the direction which is perpendicular to pv on the xy plane. Hep3Vector(2)= error(1 sigma) along the direction which is (pv) x (HepVector(1) direction). {itemize} view=2. {itemize} Hep3Vector(1)= error(1 sigma) along the direction which is perpendicular to pv on the zy plane. Hep3Vector(2)= error(1 sigma) along the direction which is (pv) x (HepVector(1) direction). {itemize} view=3. {itemize} Hep3Vector(1)= error(1 sigma) along the direction which is perpendicular to pv on the zx plane. Hep3Vector(2)= error(1 sigma) along the direction which is (pv) x (HepVector(1) direction). {itemize} {itemize}

Definition at line 215 of file Ext_errmx.cxx.

References nr.

00221 {
00222 
00223   Hep3Vector    np( pv.unit() );
00224   Hep3Vector    nr;
00225 
00226   switch( view ){
00227 
00228   case 1:       // xy view
00229 
00230     if( np.x() != 0 || np.y() != 0 ){
00231       nr.setX(  np.y() );
00232       nr.setY( -np.x() );
00233       nr = nr.unit();
00234     } else {            // Pointing to z-direction.
00235       nr.setX( 1 );
00236     }
00237     break;
00238 
00239   case 2:       // zy view
00240 
00241     if( np.y() != 0 || np.z() != 0 ){
00242       nr.setY( -np.z() );
00243       nr.setZ(  np.y() );
00244       nr = nr.unit();
00245     } else {            // Pointing to x-direction.
00246       nr.setZ( 1 );
00247     }
00248     break;
00249 
00250   case 3:       // zx view
00251 
00252     if( np.z() != 0 || np.x() != 0 ){
00253       nr.setX( -np.z() );
00254       nr.setZ(  np.x() );
00255       nr = nr.unit();
00256     } else {            // Pointing to z-direction.
00257       nr.setZ( 1 );
00258     }
00259     break;
00260   }     /* End of switch */
00261 
00262   Hep3Vector nt( np.cross( nr ) );
00263   const HepVector & err_v = (*this).get_plane_errs( np, nr, nt );
00264   *m_nv         = err_v[0]*nr;
00265   *(m_nv+1)     = err_v[1]*nt;
00266   return( m_nv );
00267 }

const Hep3Vector & Ext_xp_err::get_x (  )  const [inline]

Definition at line 63 of file Ext_xp_err.h.

References m_xv.

00063                                                   {
00064   return m_xv;
00065 }

bool Ext_xp_err::move ( const Hep3Vector &  xv1,
const Hep3Vector &  pv1,
const Hep3Vector &  B,
const int  ms_on,
const double  chi_cc 
)

Definition at line 75 of file Ext_xp_err.cxx.

References EvtCyclic3::C, Eps(), Infinite(), Ext_errmx::m_err, m_mass2, m_pv, m_q, m_xp_jcb, m_xv, and Small().

Referenced by ExtSteppingAction::UserSteppingAction().

00078 {
00079 // (Inputs)
00080 // xv1 -- Coordinate(x',y',z') after transformation.
00081 // pv1 -- Momentum(px',py',pz') after transformation.
00082 // B   -- B-field(Bx,By,Bz) at the transformation.
00083 // ms_on -- Flag to switch on/off the multiple scattering effect.
00084 //              ms_on = 0 for switch off. ms_on = 1 for switch on.
00085 // chi_cc -- Constant of Moliere theory.
00086 //
00087 // (Outputs)
00088 // return - = 1 for success, = 0 for failed.
00089 //
00090   double dx( ( xv1 - m_xv ).mag() );
00091   double dp( ( pv1 - m_pv ).mag() );
00092   double p2( m_pv.mag2() );
00093   double p_abs( sqrt( p2 ) );
00094 
00095   double p_inv;
00096   if( p_abs > Small && pv1.mag() > Small ){
00097     p_inv = 1.0 / p_abs;
00098   } else {
00099     p_inv = Infinite;
00100     return 0;
00101   }
00102 
00103   double ms_coeff( 2.557 * chi_cc );
00104   bool with_B( ( B.mag() > Small ) ? 1 : 0 );
00105   double p2inv( p_inv * p_inv );
00106   double p3inv( p2inv * p_inv );
00107   double fdx( dx * p3inv );
00108   double cx( 100.*m_q * C * fdx );//*100 due to units problem by L.L.Wang
00109   double fdp( dp * p_inv );
00110 
00111   double px(  m_pv.x() );
00112   double py(  m_pv.y() );
00113   double pz(  m_pv.z() );
00114   double px2( px * px );
00115   double py2( py * py );
00116   double pz2( pz * pz );
00117   double pxy( px * py );
00118   double pyz( py * pz );
00119   double pzx( pz * px );
00120   double Bx(  B.x() );
00121   double By(  B.y() );
00122   double Bz(  B.z() );
00123 
00124   m_xp_jcb( 1, 1 ) = 1.0;                       // dx'/dx
00125   m_xp_jcb( 1, 4 ) = fdx * ( py2 + pz2 );       // dx'/dpx
00126   m_xp_jcb( 1, 5 ) = - fdx * pxy;               // dx'/dpy
00127   m_xp_jcb( 1, 6 ) = - fdx * pzx;               // dx'/dpz
00128 
00129   m_xp_jcb( 2, 2 ) = 1.0;                       // dy'/dy
00130   m_xp_jcb( 2, 4 ) = - fdx * pxy;               // dy'/dpx
00131   m_xp_jcb( 2, 5 ) = fdx * ( pz2 + px2 );       // dy'/dpy
00132   m_xp_jcb( 2, 6 ) = - fdx * pyz;               // dy'/dpz
00133 
00134   m_xp_jcb( 3, 3 ) = 1.0;                       // dz'/dz
00135   m_xp_jcb( 3, 4 ) = - fdx * pzx;               // dz'/dpx
00136   m_xp_jcb( 3, 5 ) = - fdx * pyz;               // dz'/dpy
00137   m_xp_jcb( 3, 6 ) = fdx * ( px2 + py2 );       // dz'/dpz
00138 
00139   m_xp_jcb( 4, 4 ) = 1.0 - fdp;                 // dx'/dx energy loss
00140   m_xp_jcb( 5, 5 ) = 1.0 - fdp;                 // dy'/dy energy loss
00141   m_xp_jcb( 6, 6 ) = 1.0 - fdp;                 // dz'/dz energy loss
00142 
00143   if( with_B && m_q!=0. ){              // B != 0  and q !=0 case
00144     m_xp_jcb( 4, 4 ) += - cx * ( pxy * Bz - pzx * By );  // dpx'/dpx
00145     m_xp_jcb( 4, 5 ) = cx * ( ( pz2 + px2 ) * Bz + pyz * By );   // dpx'/dpy
00146     m_xp_jcb( 4, 6 ) = - cx * ( ( px2 + py2 ) * By + pyz * Bz ); // dpx'/dpz
00147 
00148     m_xp_jcb( 5, 4 ) = - cx * ( ( py2 + pz2 ) * Bz + pzx * Bx ); // dpy'/dpx
00149     m_xp_jcb( 5, 5 ) +=  - cx * ( pyz * Bx - pxy * Bz );         // dpy'/dpy
00150     m_xp_jcb( 5, 6 ) = cx * ( ( px2 + py2 ) * Bx + pzx * Bz );   // dpy'/dpz
00151 
00152     m_xp_jcb( 6, 4 ) = cx * ( ( py2 + pz2 ) * By + pxy * Bx );   // dpz'/dpx
00153     m_xp_jcb( 6, 5 ) = - cx * ( ( pz2 + px2 ) * Bx + pxy * By ); // dpz'/dpy
00154     m_xp_jcb( 6, 6 ) += - cx * ( pzx * By - pyz * Bx );          // dpz'/dpz
00155   }
00156 
00157 // error transformation.
00158 
00159   m_err = m_err.similarity( m_xp_jcb );
00160 
00161 // Multiple scattering.
00162 
00163   if( ms_on ){
00164     double beta_p_inv( ( m_mass2 + p2 ) / ( p2 * p2 ) ); // 1/(p*beta)**2
00165     double th2( 100000.0 * ms_coeff * ms_coeff * beta_p_inv * dx );//mutiply 100000.0 by L.L.Wang 
00166                                                                    //due to units problem 
00167     double m11( th2 * dx * dx /3.0);
00168     double m12( 0.5 * th2 * dx * p_abs );
00169     double m22( th2 * p2 );
00170 
00171     if( p_abs > Eps ){
00172       double c1( px*p_inv );
00173       double c2( py*p_inv );
00174       double c3( pz*p_inv );
00175       double c12( - c1*c2 );
00176       double c13( - c1*c3 );
00177       double c23( - c2*c3 );
00178       double s1s( 1 - c1*c1 );
00179       double s2s( 1 - c2*c2 );
00180       double s3s( 1 - c3*c3 );
00181 
00182       m_err.fast( 1, 1 ) += m11*s1s;            // error(x,x)
00183 
00184       m_err.fast( 2, 1 ) += m11*c12;            // error(y,x)
00185       m_err.fast( 2, 2 ) += m11*s2s;            // error(y,y)
00186 
00187       m_err.fast( 3, 1 ) += m11*c13;            // error(z,x)
00188       m_err.fast( 3, 2 ) += m11*c23;            // error(z,y)
00189       m_err.fast( 3, 3 ) += m11*s3s;            // error(z,z)
00190 
00191       m_err.fast( 4, 1 ) += m12*s1s;            // error(px,x)
00192       m_err.fast( 4, 2 ) += m12*c12;            // error(px,y)
00193       m_err.fast( 4, 3 ) += m12*c13;            // error(px,z)
00194       m_err.fast( 4, 4 ) += m22*s1s;            // error(px,px)
00195 
00196       m_err.fast( 5, 1 ) += m12*c12;            // error(py,x)
00197       m_err.fast( 5, 2 ) += m12*s2s;            // error(py,y)
00198       m_err.fast( 5, 3 ) += m12*c23;            // error(py,z)
00199       m_err.fast( 5, 4 ) += m22*c12;            // error(py,px)
00200       m_err.fast( 5, 5 ) += m22*s2s;            // error(py,py)
00201 
00202       m_err.fast( 6, 1 ) += m12*c13;            // error(pz,x)
00203       m_err.fast( 6, 2 ) += m12*c23;            // error(pz,y)
00204       m_err.fast( 6, 3 ) += m12*s3s;            // error(pz,z)
00205       m_err.fast( 6, 4 ) += m22*c13;            // error(pz,px)
00206       m_err.fast( 6, 5 ) += m22*c23;            // error(pz,py)
00207       m_err.fast( 6, 6 ) += m22*s3s;            // error(pz,pz)
00208     }
00209   
00210  }
00211 
00212 // Now store the new xv and pv.
00213   m_xv = xv1;
00214   m_pv = pv1;
00215   return 1;
00216 }

Ext_xp_err & Ext_xp_err::operator= ( const Ext_xp_err xp_err  ) 

Definition at line 219 of file Ext_xp_err.cxx.

References showlog::err, m_h2xp_jcb, m_mass2, m_pv, m_q, m_xp_jcb, and m_xv.

00220 {
00221   if( this != &err ){
00222     *((Ext_errmx *)this) = err;
00223     m_xv        = err.m_xv;
00224     m_pv        = err.m_pv;
00225     m_xp_jcb    = err.m_xp_jcb;
00226     m_h2xp_jcb  = err.m_h2xp_jcb;
00227     m_q         = err.m_q;
00228     m_mass2     = err.m_mass2;
00229   }
00230   return *this;
00231 }

void Ext_errmx::put_err ( const HepSymMatrix &  err  )  [inline, inherited]

Definition at line 148 of file Ext_errmx.h.

References Ext_errmx::m_err, and Ext_errmx::m_valid.

00149 {
00150   m_err = err;
00151   m_valid = 1;
00152 }

void Ext_errmx::put_err ( const double  error[]  )  [inherited]

Definition at line 45 of file Ext_errmx.cxx.

References genRecEmupikp::i, ganga-rec::j, Ext_errmx::m_err, and Ext_errmx::m_valid.

Referenced by set_err(), and ExtSteppingAction::UserSteppingAction().

00046 {
00047   int ne = 0;
00048 
00049   for( int i = 1; i <= m_err.num_col(); i++ ){
00050     for( int j = 1; j <= i; j++ ){
00051       m_err.fast( i, j ) = error[ ne++ ];
00052     }
00053   }
00054   m_valid = 1;
00055 }

void Ext_xp_err::set_err ( const HepSymMatrix &  err,
const Hep3Vector &  xv,
const Hep3Vector &  pv,
const double &  q,
const double &  mass 
)

Definition at line 47 of file Ext_xp_err.cxx.

References m_mass2, m_pv, m_q, m_xv, and Ext_errmx::put_err().

Referenced by Ext_track::Set().

00057 {
00058   Ext_errmx *errmx_ptr = (Ext_errmx *)this;
00059   errmx_ptr->put_err( err );
00060 
00061   m_xv = xv;
00062   m_pv = pv;
00063   m_q = q;
00064   m_mass2 = mass * mass;
00065 
00066 // We do NOT check the validity of the error matrix here.
00067 
00068 }

void Ext_xp_err::set_mom ( const Hep3Vector &  mom  )  [inline]

Definition at line 90 of file Ext_xp_err.h.

References m_pv.

Referenced by ExtSteppingAction::UserSteppingAction().

00091 {
00092 m_pv = mom;
00093 }

void Ext_errmx::set_plane_errs ( const Hep3Vector &  nx,
const Hep3Vector &  ny,
const Hep3Vector &  nz 
) const [protected, inherited]

Definition at line 60 of file Ext_errmx.cxx.

References Ext_errmx::m_err, Ext_errmx::m_err3, and Ext_errmx::m_R.

00062 {
00063 // Setup the rotation matrix.
00064 
00065   m_R( 1, 1 ) = nx.x();
00066   m_R( 1, 2 ) = nx.y();
00067   m_R( 1, 3 ) = nx.z();
00068   m_R( 2, 1 ) = ny.x();
00069   m_R( 2, 2 ) = ny.y();
00070   m_R( 2, 3 ) = ny.z();
00071   m_R( 3, 1 ) = nz.x();
00072   m_R( 3, 2 ) = nz.y();
00073   m_R( 3, 3 ) = nz.z();
00074 
00075 // Get the 3x3 sub matrix and Rotate the error matrix.
00076 
00077   m_err3 = (m_err.sub( 1, 3 )).similarity( m_R );
00078 
00079 }

void Ext_xp_err::set_pos ( const Hep3Vector &  pos  )  [inline]

Definition at line 85 of file Ext_xp_err.h.

References m_xv.

Referenced by ExtSteppingAction::UserSteppingAction().

00086 {
00087 m_xv = pos;
00088 }

bool Ext_errmx::valid ( bool  msg  )  const [inherited]

Definition at line 300 of file Ext_errmx.cxx.

References Ext_err_valid(), Ext_errmx::m_err, and Ext_errmx::m_valid.

00301 {
00302   if( m_valid ){
00303     if( Ext_err_valid( msg, m_err, 6 ) ){
00304       return 1;
00305     } else {
00306       m_valid = 0;
00307       return 0;
00308     }
00309   } else {
00310     return 0;
00311   }
00312 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream s,
const Ext_errmx errmx 
) [friend, inherited]

Definition at line 333 of file Ext_errmx.cxx.

00334 {
00335   s << " m_valid: " << err.m_valid << '\n'
00336         << "m_err: " << err.m_err << " m_err3: " << err.m_err3 
00337         << " m_R: " << err.m_R << " m_err2: " << err.m_err2
00338         << " *m_nv: " << *err.m_nv 
00339         << " *(m_nv+1): " << *(err.m_nv+1)
00340         << std::endl;
00341   return s;
00342 }

std::ostream& operator<< ( std::ostream s,
const Ext_xp_err xp_err 
) [friend]

Definition at line 236 of file Ext_xp_err.cxx.

00237 {
00238   s << "m_err: " << (Ext_errmx)err
00239     << std::endl
00240     << "m_xv: " << err.m_xv << std::endl << " abs(xv)= " << err.m_xv.mag()
00241     << std::endl
00242     << "m_pv: " << err.m_pv << std::endl << " abs(pv)= " << err.m_pv.mag()
00243     << std::endl
00244     << "m_xp_jcb: " << err.m_xp_jcb
00245     << std::endl
00246     << "m_h2xp_jcb: " << err.m_h2xp_jcb
00247     << std::endl
00248     << "m_q: " << err.m_q
00249     << std::endl
00250     << "m_mass: " << sqrt(err.m_mass2)
00251     << std::endl;
00252   return s;
00253 }


Member Data Documentation

HepSymMatrix Ext_errmx::m_err [protected, inherited]

Definition at line 133 of file Ext_errmx.h.

Referenced by Ext_errmx::get_err(), move(), Ext_errmx::operator=(), Ext_errmx::put_err(), Ext_errmx::set_plane_errs(), and Ext_errmx::valid().

HepMatrix Ext_xp_err::m_h2xp_jcb [private]

Definition at line 55 of file Ext_xp_err.h.

Referenced by operator=().

double Ext_xp_err::m_mass2 [private]

Definition at line 57 of file Ext_xp_err.h.

Referenced by get_mass(), move(), operator=(), and set_err().

Hep3Vector Ext_xp_err::m_pv [private]

Definition at line 53 of file Ext_xp_err.h.

Referenced by get_p(), move(), operator=(), set_err(), and set_mom().

double Ext_xp_err::m_q [private]

Definition at line 56 of file Ext_xp_err.h.

Referenced by get_q(), move(), operator=(), and set_err().

HepMatrix Ext_xp_err::m_xp_jcb [private]

Definition at line 54 of file Ext_xp_err.h.

Referenced by move(), and operator=().

Hep3Vector Ext_xp_err::m_xv [private]

Definition at line 52 of file Ext_xp_err.h.

Referenced by get_x(), move(), operator=(), set_err(), and set_pos().


Generated on Tue Nov 29 23:19:33 2016 for BOSS_7.0.2 by  doxygen 1.4.7