#include <Ext_xp_err.h>
Inheritance diagram for Ext_xp_err:
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_err & | operator= (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::ostream & | operator<< (std::ostream &s, const Ext_xp_err &xp_err) |
std::ostream & | operator<< (std::ostream &s, const Ext_errmx &errmx) |
Definition at line 29 of file Ext_xp_err.h.
Ext_xp_err::Ext_xp_err | ( | ) |
Ext_xp_err::Ext_xp_err | ( | const Ext_xp_err & | xp_err | ) |
Ext_xp_err::~Ext_xp_err | ( | ) | [inline] |
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] |
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.
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] |
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.
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] |
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] |
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().
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 }
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 }
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] |
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] |
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().