00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092 #include <math.h>
00093 #include <float.h>
00094 #include <iostream>
00095 #include "DedxCorrecSvc/Dedx_Helix.h"
00096 #include "CLHEP/Matrix/Matrix.h"
00097 #include "GaudiKernel/StatusCode.h"
00098 #include "GaudiKernel/IInterface.h"
00099 #include "GaudiKernel/Kernel.h"
00100 #include "GaudiKernel/Service.h"
00101 #include "GaudiKernel/Kernel.h"
00102 #include "GaudiKernel/ISvcLocator.h"
00103 #include "GaudiKernel/SvcFactory.h"
00104 #include "GaudiKernel/IDataProviderSvc.h"
00105 #include "GaudiKernel/Bootstrap.h"
00106 #include "GaudiKernel/MsgStream.h"
00107 #include "GaudiKernel/SmartDataPtr.h"
00108 #include "GaudiKernel/IMessageSvc.h"
00109 #include "GaudiKernel/IPartPropSvc.h"
00110
00111 #include "GaudiKernel/SmartDataPtr.h"
00112
00113
00114 const double
00115 M_PI2 = 2. * M_PI;
00116
00117 const double
00118 M_PI4 = 4. * M_PI;
00119
00120 const double
00121 M_PI8 = 8. * M_PI;
00122
00123 const double
00124 Dedx_Helix::ConstantAlpha = -333.564095;
00125
00126 Dedx_Helix::Dedx_Helix(const HepPoint3D & pivot,
00127 const HepVector & a,
00128 const HepSymMatrix & Ea)
00129 :
00130
00131 m_pivot(pivot),
00132 m_a(a),
00133 m_matrixValid(true),
00134 m_Ea(Ea) {
00135
00136 StatusCode scmgn = Gaudi::svcLocator()->service("MagneticFieldSvc",m_pmgnIMF);
00137 if(scmgn!=StatusCode::SUCCESS) {
00138
00139 std::cout<< "Unable to open Magnetic field service"<<std::endl;
00140 }
00141 m_bField = 10000*(m_pmgnIMF->getReferField());
00142 m_alpha = 10000. / 2.99792458 / m_bField;
00143
00144 updateCache();
00145 }
00146
00147 Dedx_Helix::Dedx_Helix(const HepPoint3D & pivot,
00148 const HepVector & a)
00149 :
00150
00151 m_pivot(pivot),
00152 m_a(a),
00153 m_matrixValid(false),
00154 m_Ea(HepSymMatrix(5,0)) {
00155 StatusCode scmgn = Gaudi::svcLocator()->service ("MagneticFieldSvc",m_pmgnIMF);
00156 if(scmgn!=StatusCode::SUCCESS) {
00157
00158 std::cout<< "Unable to open Magnetic field service"<<std::endl;
00159 }
00160 m_bField = 10000*(m_pmgnIMF->getReferField());
00161 m_alpha = 10000. / 2.99792458 / m_bField;
00162
00163
00164 updateCache();
00165 }
00166
00167 Dedx_Helix::Dedx_Helix(const HepPoint3D & position,
00168 const Hep3Vector & momentum,
00169 double charge)
00170 :
00171
00172 m_pivot(position),
00173 m_a(HepVector(5,0)),
00174 m_matrixValid(false),
00175 m_Ea(HepSymMatrix(5,0)) {
00176 StatusCode scmgn = Gaudi::svcLocator()->service ("MagneticFieldSvc",m_pmgnIMF);
00177 if(scmgn!=StatusCode::SUCCESS) {
00178
00179 std::cout<< "Unable to open Magnetic field service"<<std::endl;
00180 }
00181 m_bField = 10000*(m_pmgnIMF->getReferField());
00182 m_alpha = 10000. / 2.99792458 / m_bField;
00183
00184 m_a[0] = 0.;
00185 m_a[1] = fmod(atan2(- momentum.x(), momentum.y())
00186 + M_PI4, M_PI2);
00187 m_a[3] = 0.;
00188 double perp(momentum.perp());
00189 if (perp != 0.0) {
00190 m_a[2] = charge / perp;
00191 m_a[4] = momentum.z() / perp;
00192 }
00193 else {
00194 m_a[2] = charge * (DBL_MAX);
00195 if (momentum.z() >= 0) {
00196 m_a[4] = (DBL_MAX);
00197 } else {
00198 m_a[4] = -(DBL_MAX);
00199 }
00200 }
00201
00202 updateCache();
00203 }
00204
00205 Dedx_Helix::~Dedx_Helix() {
00206 }
00207
00208 HepPoint3D
00209 Dedx_Helix::x(double phi) const {
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222 double x = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] +phi));
00223 double y = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] +phi));
00224 double z = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
00225
00226 return HepPoint3D(x, y, z);
00227 }
00228
00229 double *
00230 Dedx_Helix::x(double phi, double p[3]) const {
00231
00232
00233
00234
00235
00236
00237
00238
00239 p[0] = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi));
00240 p[1] = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi));
00241 p[2] = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
00242
00243 return p;
00244 }
00245
00246 HepPoint3D
00247 Dedx_Helix::x(double phi, HepSymMatrix & Ex) const {
00248 double x = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] +phi));
00249 double y = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] +phi));
00250 double z = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261 if (m_matrixValid) Ex = m_Ea.similarity(delXDelA(phi));
00262 else Ex = m_Ea;
00263
00264 return HepPoint3D(x, y, z);
00265 }
00266
00267 Hep3Vector
00268 Dedx_Helix::momentum(double phi) const {
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279 double pt = fabs(m_pt);
00280 double px = - pt * sin(m_ac[1] + phi);
00281 double py = pt * cos(m_ac[1] + phi);
00282 double pz = pt * m_ac[4];
00283
00284 return Hep3Vector(px, py, pz);
00285 }
00286
00287 Hep3Vector
00288 Dedx_Helix::momentum(double phi, HepSymMatrix & Em) const {
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299 double pt = fabs(m_pt);
00300 double px = - pt * sin(m_ac[1] + phi);
00301 double py = pt * cos(m_ac[1] + phi);
00302 double pz = pt * m_ac[4];
00303
00304 if (m_matrixValid) Em = m_Ea.similarity(delMDelA(phi));
00305 else Em = m_Ea;
00306
00307 return Hep3Vector(px, py, pz);
00308 }
00309
00310 HepLorentzVector
00311 Dedx_Helix::momentum(double phi, double mass) const {
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323 double pt = fabs(m_pt);
00324 double px = - pt * sin(m_ac[1] + phi);
00325 double py = pt * cos(m_ac[1] + phi);
00326 double pz = pt * m_ac[4];
00327 double E = sqrt(pt*pt*(1.+m_ac[4]*m_ac[4])+mass*mass);
00328
00329 return HepLorentzVector(px, py, pz, E);
00330 }
00331
00332
00333 HepLorentzVector
00334 Dedx_Helix::momentum(double phi, double mass, HepSymMatrix & Em) const {
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346 double pt = fabs(m_pt);
00347 double px = - pt * sin(m_ac[1] + phi);
00348 double py = pt * cos(m_ac[1] + phi);
00349 double pz = pt * m_ac[4];
00350 double E = sqrt(pt*pt*(1.+m_ac[4]*m_ac[4])+mass*mass);
00351
00352 if (m_matrixValid) Em = m_Ea.similarity(del4MDelA(phi,mass));
00353 else Em = m_Ea;
00354
00355 return HepLorentzVector(px, py, pz, E);
00356 }
00357
00358 HepLorentzVector
00359 Dedx_Helix::momentum(double phi,
00360 double mass,
00361 HepPoint3D & x,
00362 HepSymMatrix & Emx) const {
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374 double pt = fabs(m_pt);
00375 double px = - pt * sin(m_ac[1] + phi);
00376 double py = pt * cos(m_ac[1] + phi);
00377 double pz = pt * m_ac[4];
00378 double E = sqrt(pt * pt * (1. + m_ac[4] * m_ac[4]) + mass * mass);
00379
00380 x.setX(m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi)));
00381 x.setY(m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi)));
00382 x.setZ(m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi);
00383
00384 if (m_matrixValid) Emx = m_Ea.similarity(del4MXDelA(phi,mass));
00385 else Emx = m_Ea;
00386
00387 return HepLorentzVector(px, py, pz, E);
00388 }
00389
00390
00391 const HepPoint3D &
00392 Dedx_Helix::pivot(const HepPoint3D & newPivot) {
00393 const double & dr = m_ac[0];
00394 const double & phi0 = m_ac[1];
00395 const double & kappa = m_ac[2];
00396 const double & dz = m_ac[3];
00397 const double & tanl = m_ac[4];
00398
00399 double rdr = dr + m_r;
00400 double phi = fmod(phi0 + M_PI4, M_PI2);
00401 double csf0 = cos(phi);
00402 double snf0 = (1. - csf0) * (1. + csf0);
00403 snf0 = sqrt((snf0 > 0.) ? snf0 : 0.);
00404 if(phi > M_PI) snf0 = - snf0;
00405
00406 double xc = m_pivot.x() + rdr * csf0;
00407 double yc = m_pivot.y() + rdr * snf0;
00408 double csf, snf;
00409 if(m_r != 0.0) {
00410 csf = (xc - newPivot.x()) / m_r;
00411 snf = (yc - newPivot.y()) / m_r;
00412 double anrm = sqrt(csf * csf + snf * snf);
00413 if(anrm != 0.0) {
00414 csf /= anrm;
00415 snf /= anrm;
00416 phi = atan2(snf, csf);
00417 } else {
00418 csf = 1.0;
00419 snf = 0.0;
00420 phi = 0.0;
00421 }
00422 } else {
00423 csf = 1.0;
00424 snf = 0.0;
00425 phi = 0.0;
00426 }
00427 double phid = fmod(phi - phi0 + M_PI8, M_PI2);
00428 if(phid > M_PI) phid = phid - M_PI2;
00429 double drp = (m_pivot.x() + dr * csf0 + m_r * (csf0 - csf) - newPivot.x())
00430 * csf
00431 + (m_pivot.y() + dr * snf0 + m_r * (snf0 - snf) - newPivot.y()) * snf;
00432 double dzp = m_pivot.z() + dz - m_r * tanl * phid - newPivot.z();
00433
00434 HepVector ap(5);
00435 ap[0] = drp;
00436 ap[1] = fmod(phi + M_PI4, M_PI2);
00437 ap[2] = kappa;
00438 ap[3] = dzp;
00439 ap[4] = tanl;
00440
00441
00442 if (m_matrixValid) m_Ea = m_Ea.similarity(delApDelA(ap));
00443
00444 m_a = ap;
00445 m_pivot = newPivot;
00446
00447
00448 updateCache();
00449 return m_pivot;
00450 }
00451
00452 void
00453 Dedx_Helix::set(const HepPoint3D & pivot,
00454 const HepVector & a,
00455 const HepSymMatrix & Ea) {
00456 m_pivot = pivot;
00457 m_a = a;
00458 m_Ea = Ea;
00459 m_matrixValid = true;
00460 updateCache();
00461 }
00462
00463 Dedx_Helix &
00464 Dedx_Helix::operator = (const Dedx_Helix & i) {
00465 if (this == & i) return * this;
00466
00467 m_bField = i.m_bField;
00468 m_alpha = i.m_alpha;
00469 m_pivot = i.m_pivot;
00470 m_a = i.m_a;
00471 m_Ea = i.m_Ea;
00472 m_matrixValid = i.m_matrixValid;
00473
00474 m_center = i.m_center;
00475 m_cp = i.m_cp;
00476 m_sp = i.m_sp;
00477 m_pt = i.m_pt;
00478 m_r = i.m_r;
00479 m_ac[0] = i.m_ac[0];
00480 m_ac[1] = i.m_ac[1];
00481 m_ac[2] = i.m_ac[2];
00482 m_ac[3] = i.m_ac[3];
00483 m_ac[4] = i.m_ac[4];
00484
00485 return * this;
00486 }
00487
00488 void
00489 Dedx_Helix::updateCache(void) {
00490
00491
00492
00493
00494
00495
00496
00497 m_ac[0] = m_a[0];
00498 m_ac[1] = m_a[1];
00499 m_ac[2] = m_a[2];
00500 m_ac[3] = m_a[3];
00501 m_ac[4] = m_a[4];
00502
00503 m_cp = cos(m_ac[1]);
00504 m_sp = sin(m_ac[1]);
00505 if (m_ac[2] != 0.0) {
00506 m_pt = 1. / m_ac[2];
00507 m_r = m_alpha / m_ac[2];
00508 }
00509 else {
00510 m_pt = (DBL_MAX);
00511 m_r = (DBL_MAX);
00512 }
00513
00514 double x = m_pivot.x() + (m_ac[0] + m_r) * m_cp;
00515 double y = m_pivot.y() + (m_ac[0] + m_r) * m_sp;
00516 m_center.setX(x);
00517 m_center.setY(y);
00518 m_center.setZ(0.);
00519 }
00520
00521 HepMatrix
00522 Dedx_Helix::delApDelA(const HepVector & ap) const {
00523
00524
00525
00526
00527
00528 HepMatrix dApDA(5,5,0);
00529
00530 const double & dr = m_ac[0];
00531 const double & phi0 = m_ac[1];
00532 const double & cpa = m_ac[2];
00533 const double & dz = m_ac[3];
00534 const double & tnl = m_ac[4];
00535
00536 double drp = ap[0];
00537 double phi0p = ap[1];
00538 double cpap = ap[2];
00539 double dzp = ap[3];
00540 double tnlp = ap[4];
00541
00542 double rdr = m_r + dr;
00543 double rdrpr;
00544 if ((m_r + drp) != 0.0) {
00545 rdrpr = 1. / (m_r + drp);
00546 } else {
00547 rdrpr = (DBL_MAX);
00548 }
00549
00550
00551 double csfd = cos(phi0p - phi0);
00552 double snfd = sin(phi0p - phi0);
00553 double phid = fmod(phi0p - phi0 + M_PI8, M_PI2);
00554 if (phid > M_PI) phid = phid - M_PI2;
00555
00556 dApDA[0][0] = csfd;
00557 dApDA[0][1] = rdr*snfd;
00558 if(cpa!=0.0) {
00559 dApDA[0][2] = (m_r/cpa)*( 1.0 - csfd );
00560 } else {
00561 dApDA[0][2] = (DBL_MAX);
00562 }
00563
00564 dApDA[1][0] = - rdrpr*snfd;
00565 dApDA[1][1] = rdr*rdrpr*csfd;
00566 if(cpa!=0.0) {
00567 dApDA[1][2] = (m_r/cpa)*rdrpr*snfd;
00568 } else {
00569 dApDA[1][2] = (DBL_MAX);
00570 }
00571
00572 dApDA[2][2] = 1.0;
00573
00574 dApDA[3][0] = m_r*rdrpr*tnl*snfd;
00575 dApDA[3][1] = m_r*tnl*(1.0 - rdr*rdrpr*csfd);
00576 if(cpa!=0.0) {
00577 dApDA[3][2] = (m_r/cpa)*tnl*(phid - m_r*rdrpr*snfd);
00578 } else {
00579 dApDA[3][2] = (DBL_MAX);
00580 }
00581 dApDA[3][3] = 1.0;
00582 dApDA[3][4] = - m_r*phid;
00583
00584 dApDA[4][4] = 1.0;
00585
00586 return dApDA;
00587 }
00588
00589 HepMatrix
00590 Dedx_Helix::delXDelA(double phi) const {
00591
00592
00593
00594
00595
00596
00597 HepMatrix dXDA(3,5,0);
00598
00599 const double & dr = m_ac[0];
00600 const double & phi0 = m_ac[1];
00601 const double & cpa = m_ac[2];
00602 const double & dz = m_ac[3];
00603 const double & tnl = m_ac[4];
00604
00605 double cosf0phi = cos(phi0 + phi);
00606 double sinf0phi = sin(phi0 + phi);
00607
00608 dXDA[0][0] = m_cp;
00609 dXDA[0][1] = - dr * m_sp + m_r * (- m_sp + sinf0phi);
00610 if(cpa!=0.0) {
00611 dXDA[0][2] = - (m_r / cpa) * (m_cp - cosf0phi);
00612 } else {
00613 dXDA[0][2] = (DBL_MAX);
00614 }
00615
00616
00617
00618 dXDA[1][0] = m_sp;
00619 dXDA[1][1] = dr * m_cp + m_r * (m_cp - cosf0phi);
00620 if(cpa!=0.0) {
00621 dXDA[1][2] = - (m_r / cpa) * (m_sp - sinf0phi);
00622 } else {
00623 dXDA[1][2] = (DBL_MAX);
00624 }
00625
00626
00627
00628
00629
00630 if(cpa!=0.0) {
00631 dXDA[2][2] = (m_r / cpa) * tnl * phi;
00632 } else {
00633 dXDA[2][2] = (DBL_MAX);
00634 }
00635 dXDA[2][3] = 1.0;
00636 dXDA[2][4] = - m_r * phi;
00637
00638 return dXDA;
00639 }
00640
00641
00642
00643 HepMatrix
00644 Dedx_Helix::delMDelA(double phi) const {
00645
00646
00647
00648
00649
00650
00651 HepMatrix dMDA(3,5,0);
00652
00653 const double & phi0 = m_ac[1];
00654 const double & cpa = m_ac[2];
00655 const double & tnl = m_ac[4];
00656
00657 double cosf0phi = cos(phi0+phi);
00658 double sinf0phi = sin(phi0+phi);
00659
00660 double rho;
00661 if(cpa != 0.)rho = 1./cpa;
00662 else rho = (DBL_MAX);
00663
00664 double charge = 1.;
00665 if(cpa < 0.)charge = -1.;
00666
00667 dMDA[0][1] = -fabs(rho)*cosf0phi;
00668 dMDA[0][2] = charge*rho*rho*sinf0phi;
00669
00670 dMDA[1][1] = -fabs(rho)*sinf0phi;
00671 dMDA[1][2] = -charge*rho*rho*cosf0phi;
00672
00673 dMDA[2][2] = -charge*rho*rho*tnl;
00674 dMDA[2][4] = fabs(rho);
00675
00676 return dMDA;
00677 }
00678
00679
00680 HepMatrix
00681 Dedx_Helix::del4MDelA(double phi, double mass) const {
00682
00683
00684
00685
00686
00687
00688 HepMatrix d4MDA(4,5,0);
00689
00690 double phi0 = m_ac[1];
00691 double cpa = m_ac[2];
00692 double tnl = m_ac[4];
00693
00694 double cosf0phi = cos(phi0+phi);
00695 double sinf0phi = sin(phi0+phi);
00696
00697 double rho;
00698 if(cpa != 0.)rho = 1./cpa;
00699 else rho = (DBL_MAX);
00700
00701 double charge = 1.;
00702 if(cpa < 0.)charge = -1.;
00703
00704 double E = sqrt(rho*rho*(1.+tnl*tnl)+mass*mass);
00705
00706 d4MDA[0][1] = -fabs(rho)*cosf0phi;
00707 d4MDA[0][2] = charge*rho*rho*sinf0phi;
00708
00709 d4MDA[1][1] = -fabs(rho)*sinf0phi;
00710 d4MDA[1][2] = -charge*rho*rho*cosf0phi;
00711
00712 d4MDA[2][2] = -charge*rho*rho*tnl;
00713 d4MDA[2][4] = fabs(rho);
00714
00715 if (cpa != 0.0 && E != 0.0) {
00716 d4MDA[3][2] = (-1.-tnl*tnl)/(cpa*cpa*cpa*E);
00717 d4MDA[3][4] = tnl/(cpa*cpa*E);
00718 } else {
00719 d4MDA[3][2] = (DBL_MAX);
00720 d4MDA[3][4] = (DBL_MAX);
00721 }
00722 return d4MDA;
00723 }
00724
00725
00726 HepMatrix
00727 Dedx_Helix::del4MXDelA(double phi, double mass) const {
00728
00729
00730
00731
00732
00733
00734 HepMatrix d4MXDA(7,5,0);
00735
00736 const double & dr = m_ac[0];
00737 const double & phi0 = m_ac[1];
00738 const double & cpa = m_ac[2];
00739 const double & dz = m_ac[3];
00740 const double & tnl = m_ac[4];
00741
00742 double cosf0phi = cos(phi0+phi);
00743 double sinf0phi = sin(phi0+phi);
00744
00745 double rho;
00746 if(cpa != 0.)rho = 1./cpa;
00747 else rho = (DBL_MAX);
00748
00749 double charge = 1.;
00750 if(cpa < 0.)charge = -1.;
00751
00752 double E = sqrt(rho * rho * (1. + tnl * tnl) + mass * mass);
00753
00754 d4MXDA[0][1] = - fabs(rho) * cosf0phi;
00755 d4MXDA[0][2] = charge * rho * rho * sinf0phi;
00756
00757 d4MXDA[1][1] = - fabs(rho) * sinf0phi;
00758 d4MXDA[1][2] = - charge * rho * rho * cosf0phi;
00759
00760 d4MXDA[2][2] = - charge * rho * rho * tnl;
00761 d4MXDA[2][4] = fabs(rho);
00762
00763 if (cpa != 0.0 && E != 0.0) {
00764 d4MXDA[3][2] = (- 1. - tnl * tnl) / (cpa * cpa * cpa * E);
00765 d4MXDA[3][4] = tnl / (cpa * cpa * E);
00766 } else {
00767 d4MXDA[3][2] = (DBL_MAX);
00768 d4MXDA[3][4] = (DBL_MAX);
00769 }
00770
00771 d4MXDA[4][0] = m_cp;
00772 d4MXDA[4][1] = - dr * m_sp + m_r * (- m_sp + sinf0phi);
00773 if (cpa != 0.0) {
00774 d4MXDA[4][2] = - (m_r / cpa) * (m_cp - cosf0phi);
00775 } else {
00776 d4MXDA[4][2] = (DBL_MAX);
00777 }
00778
00779 d4MXDA[5][0] = m_sp;
00780 d4MXDA[5][1] = dr * m_cp + m_r * (m_cp - cosf0phi);
00781 if (cpa != 0.0) {
00782 d4MXDA[5][2] = - (m_r / cpa) * (m_sp - sinf0phi);
00783
00784 d4MXDA[6][2] = (m_r / cpa) * tnl * phi;
00785 } else {
00786 d4MXDA[5][2] = (DBL_MAX);
00787
00788 d4MXDA[6][2] = (DBL_MAX);
00789 }
00790
00791 d4MXDA[6][3] = 1.;
00792 d4MXDA[6][4] = - m_r * phi;
00793
00794 return d4MXDA;
00795 }
00796
00797 void
00798 Dedx_Helix::ignoreErrorMatrix(void) {
00799 m_matrixValid = false;
00800 m_Ea *= 0.;
00801 }