Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/management/include/G4AffineTransform.icc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/management/include/G4AffineTransform.icc (Version 11.3.0) and /geometry/management/include/G4AffineTransform.icc (Version 10.5)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 //
                                                   >>  27 //
                                                   >>  28 //
 26 // G4AffineTransformation Inline implementatio     29 // G4AffineTransformation Inline implementation
 27 //                                                 30 //
 28 // -------------------------------------------     31 // --------------------------------------------------------------------
 29                                                    32 
 30 inline G4AffineTransform::G4AffineTransform()      33 inline G4AffineTransform::G4AffineTransform()
 31  : rxx(1),rxy(0),rxz(0),                           34  : rxx(1),rxy(0),rxz(0),
 32    ryx(0),ryy(1),ryz(0),                           35    ryx(0),ryy(1),ryz(0),
 33    rzx(0),rzy(0),rzz(1),                           36    rzx(0),rzy(0),rzz(1),
 34    tx(0),ty(0),tz(0)                               37    tx(0),ty(0),tz(0)
 35 {}                                                 38 {}
 36                                                    39 
 37 inline G4AffineTransform::G4AffineTransform(co     40 inline G4AffineTransform::G4AffineTransform(const G4ThreeVector& tlate)
 38  : rxx(1),rxy(0),rxz(0),                           41  : rxx(1),rxy(0),rxz(0),
 39    ryx(0),ryy(1),ryz(0),                           42    ryx(0),ryy(1),ryz(0),
 40    rzx(0),rzy(0),rzz(1),                           43    rzx(0),rzy(0),rzz(1),
 41    tx(tlate.x()),ty(tlate.y()),tz(tlate.z())       44    tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
 42 {}                                                 45 {}
 43                                                    46 
 44 inline G4AffineTransform::G4AffineTransform(co     47 inline G4AffineTransform::G4AffineTransform(const G4RotationMatrix& rot)
 45  : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),      48  : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
 46    ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),      49    ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
 47    rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),      50    rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
 48    tx(0),ty(0),tz(0)                               51    tx(0),ty(0),tz(0)
 49 {}                                                 52 {}
 50                                                    53 
 51 inline G4AffineTransform::G4AffineTransform( c     54 inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix& rot,
 52                                              c     55                                              const G4ThreeVector& tlate )
 53  : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),      56  : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
 54    ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),      57    ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
 55    rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),      58    rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
 56    tx(tlate.x()),ty(tlate.y()),tz(tlate.z())       59    tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
 57 {}                                                 60 {}
 58                                                    61 
 59 inline G4AffineTransform::G4AffineTransform( c     62 inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix* rot,
 60                                              c     63                                              const G4ThreeVector& tlate )
 61  : tx(tlate.x()),ty(tlate.y()),tz(tlate.z())       64  : tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
 62 {                                                  65 {
 63   if (rot != nullptr)                          <<  66   if (rot)
 64   {                                                67   {
 65     rxx=rot->xx();rxy=rot->xy();rxz=rot->xz();     68     rxx=rot->xx();rxy=rot->xy();rxz=rot->xz();
 66     ryx=rot->yx();ryy=rot->yy();ryz=rot->yz();     69     ryx=rot->yx();ryy=rot->yy();ryz=rot->yz();
 67     rzx=rot->zx();rzy=rot->zy();rzz=rot->zz();     70     rzx=rot->zx();rzy=rot->zy();rzz=rot->zz();
 68   }                                                71   }
 69   else                                             72   else
 70   {                                                73   {
 71     rxx=1; rxy=0; rxz=0;                           74     rxx=1; rxy=0; rxz=0;
 72     ryx=0; ryy=1; ryz=0;                           75     ryx=0; ryy=1; ryz=0;
 73     rzx=0; rzy=0; rzz=1;                           76     rzx=0; rzy=0; rzz=1;
 74   }                                                77   }
 75 }                                                  78 }
 76                                                    79 
 77 inline                                             80 inline
 78 G4AffineTransform::                                81 G4AffineTransform::
 79 G4AffineTransform( const G4double prxx,const G     82 G4AffineTransform( const G4double prxx,const G4double prxy,const G4double prxz,
 80                    const G4double pryx,const G     83                    const G4double pryx,const G4double pryy,const G4double pryz,
 81                    const G4double przx,const G     84                    const G4double przx,const G4double przy,const G4double przz,
 82                    const G4double ptx,const G4     85                    const G4double ptx,const G4double pty,const G4double ptz )
 83  : rxx(prxx),rxy(prxy),rxz(prxz),                  86  : rxx(prxx),rxy(prxy),rxz(prxz),
 84    ryx(pryx),ryy(pryy),ryz(pryz),                  87    ryx(pryx),ryy(pryy),ryz(pryz),
 85    rzx(przx),rzy(przy),rzz(przz),                  88    rzx(przx),rzy(przy),rzz(przz),
 86    tx(ptx),ty(pty),tz(ptz)                         89    tx(ptx),ty(pty),tz(ptz)
 87 {}                                                 90 {}
 88                                                    91 
                                                   >>  92 inline G4AffineTransform::G4AffineTransform(const G4AffineTransform& rhs)
                                                   >>  93  : rxx(rhs.rxx),rxy(rhs.rxy),rxz(rhs.rxz),
                                                   >>  94    ryx(rhs.ryx),ryy(rhs.ryy),ryz(rhs.ryz),
                                                   >>  95    rzx(rhs.rzx),rzy(rhs.rzy),rzz(rhs.rzz),
                                                   >>  96    tx(rhs.tx),ty(rhs.ty),tz(rhs.tz)
                                                   >>  97 {}
                                                   >>  98 
 89 inline G4AffineTransform&                          99 inline G4AffineTransform&
 90 G4AffineTransform::operator = (const G4AffineT    100 G4AffineTransform::operator = (const G4AffineTransform& rhs)
 91 {                                                 101 {
 92   if (this == &rhs)  { return *this; }            102   if (this == &rhs)  { return *this; }
 93   rxx = rhs.rxx; rxy = rhs.rxy; rxz = rhs.rxz;    103   rxx = rhs.rxx; rxy = rhs.rxy; rxz = rhs.rxz; 
 94   ryx = rhs.ryx; ryy = rhs.ryy; ryz = rhs.ryz;    104   ryx = rhs.ryx; ryy = rhs.ryy; ryz = rhs.ryz; 
 95   rzx = rhs.rzx; rzy = rhs.rzy; rzz = rhs.rzz;    105   rzx = rhs.rzx; rzy = rhs.rzy; rzz = rhs.rzz; 
 96   tx = rhs.tx; ty = rhs.ty; tz = rhs.tz;          106   tx = rhs.tx; ty = rhs.ty; tz = rhs.tz;
 97   return *this;                                   107   return *this;
 98 }                                                 108 }
 99                                                   109 
                                                   >> 110 inline G4AffineTransform::~G4AffineTransform()
                                                   >> 111 {}
                                                   >> 112 
100 inline G4AffineTransform                          113 inline G4AffineTransform
101 G4AffineTransform::operator * (const G4AffineT    114 G4AffineTransform::operator * (const G4AffineTransform& tf) const
102 {                                                 115 {
103   return G4AffineTransform(rxx*tf.rxx+rxy*tf.r    116   return G4AffineTransform(rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx,
104                            rxx*tf.rxy+rxy*tf.r    117                            rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy,
105                            rxx*tf.rxz+rxy*tf.r    118                            rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz,
106                                                   119 
107                            ryx*tf.rxx+ryy*tf.r    120                            ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx,
108                            ryx*tf.rxy+ryy*tf.r    121                            ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy,
109                            ryx*tf.rxz+ryy*tf.r    122                            ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz,
110                                                   123 
111                            rzx*tf.rxx+rzy*tf.r    124                            rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx,
112                            rzx*tf.rxy+rzy*tf.r    125                            rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy,
113                            rzx*tf.rxz+rzy*tf.r    126                            rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz,
114                                                   127 
115                            tx*tf.rxx+ty*tf.ryx    128                            tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx,
116                            tx*tf.rxy+ty*tf.ryy    129                            tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty,
117                            tx*tf.rxz+ty*tf.ryz    130                            tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz);
118 }                                                 131 }
119                                                   132 
120 inline G4AffineTransform&                         133 inline G4AffineTransform&
121 G4AffineTransform::operator *= (const G4Affine    134 G4AffineTransform::operator *= (const G4AffineTransform& tf)
122 {                                                 135 {
123   // Use temporaries for `in place' compound t    136   // Use temporaries for `in place' compound transform computation
124   //                                              137   //
125   G4double nrxx=rxx*tf.rxx+rxy*tf.ryx+rxz*tf.r    138   G4double nrxx=rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx;
126   G4double nrxy=rxx*tf.rxy+rxy*tf.ryy+rxz*tf.r    139   G4double nrxy=rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy;
127   G4double nrxz=rxx*tf.rxz+rxy*tf.ryz+rxz*tf.r    140   G4double nrxz=rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz;
128                                                   141 
129   G4double nryx=ryx*tf.rxx+ryy*tf.ryx+ryz*tf.r    142   G4double nryx=ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx;
130   G4double nryy=ryx*tf.rxy+ryy*tf.ryy+ryz*tf.r    143   G4double nryy=ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy;
131   G4double nryz=ryx*tf.rxz+ryy*tf.ryz+ryz*tf.r    144   G4double nryz=ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz;
132                                                   145 
133   G4double nrzx=rzx*tf.rxx+rzy*tf.ryx+rzz*tf.r    146   G4double nrzx=rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx;
134   G4double nrzy=rzx*tf.rxy+rzy*tf.ryy+rzz*tf.r    147   G4double nrzy=rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy;
135   G4double nrzz=rzx*tf.rxz+rzy*tf.ryz+rzz*tf.r    148   G4double nrzz=rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz;
136                                                   149         
137   G4double ntx=tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+t    150   G4double ntx=tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx;
138   G4double nty=tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+t    151   G4double nty=tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty;
139   G4double ntz=tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+t    152   G4double ntz=tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz;
140                                                   153 
141   tx=ntx; ty=nty; tz=ntz;                         154   tx=ntx; ty=nty; tz=ntz;
142   rxx=nrxx; rxy=nrxy; rxz=nrxz;                   155   rxx=nrxx; rxy=nrxy; rxz=nrxz;
143   ryx=nryx; ryy=nryy; ryz=nryz;                   156   ryx=nryx; ryy=nryy; ryz=nryz;
144   rzx=nrzx; rzy=nrzy; rzz=nrzz;                   157   rzx=nrzx; rzy=nrzy; rzz=nrzz;
145                                                   158 
146   return *this;                                   159   return *this;
147 }                                                 160 }
148                                                   161 
149 inline G4AffineTransform&                         162 inline G4AffineTransform&
150 G4AffineTransform::Product( const G4AffineTran    163 G4AffineTransform::Product( const G4AffineTransform& tf1,
151                             const G4AffineTran    164                             const G4AffineTransform& tf2 )
152 {                                                 165 {
153   rxx = tf1.rxx*tf2.rxx + tf1.rxy*tf2.ryx + tf    166   rxx = tf1.rxx*tf2.rxx + tf1.rxy*tf2.ryx + tf1.rxz*tf2.rzx;
154   rxy = tf1.rxx*tf2.rxy + tf1.rxy*tf2.ryy + tf    167   rxy = tf1.rxx*tf2.rxy + tf1.rxy*tf2.ryy + tf1.rxz*tf2.rzy;
155   rxz = tf1.rxx*tf2.rxz + tf1.rxy*tf2.ryz + tf    168   rxz = tf1.rxx*tf2.rxz + tf1.rxy*tf2.ryz + tf1.rxz*tf2.rzz;
156                                                   169 
157   ryx = tf1.ryx*tf2.rxx + tf1.ryy*tf2.ryx + tf    170   ryx = tf1.ryx*tf2.rxx + tf1.ryy*tf2.ryx + tf1.ryz*tf2.rzx;
158   ryy = tf1.ryx*tf2.rxy + tf1.ryy*tf2.ryy + tf    171   ryy = tf1.ryx*tf2.rxy + tf1.ryy*tf2.ryy + tf1.ryz*tf2.rzy;
159   ryz = tf1.ryx*tf2.rxz + tf1.ryy*tf2.ryz + tf    172   ryz = tf1.ryx*tf2.rxz + tf1.ryy*tf2.ryz + tf1.ryz*tf2.rzz;
160                                                   173 
161   rzx = tf1.rzx*tf2.rxx + tf1.rzy*tf2.ryx + tf    174   rzx = tf1.rzx*tf2.rxx + tf1.rzy*tf2.ryx + tf1.rzz*tf2.rzx;
162   rzy = tf1.rzx*tf2.rxy + tf1.rzy*tf2.ryy + tf    175   rzy = tf1.rzx*tf2.rxy + tf1.rzy*tf2.ryy + tf1.rzz*tf2.rzy;
163   rzz = tf1.rzx*tf2.rxz + tf1.rzy*tf2.ryz + tf    176   rzz = tf1.rzx*tf2.rxz + tf1.rzy*tf2.ryz + tf1.rzz*tf2.rzz;
164                                                   177 
165   tx = tf1.tx*tf2.rxx + tf1.ty*tf2.ryx + tf1.t    178   tx = tf1.tx*tf2.rxx + tf1.ty*tf2.ryx + tf1.tz*tf2.rzx + tf2.tx;
166   ty = tf1.tx*tf2.rxy + tf1.ty*tf2.ryy + tf1.t    179   ty = tf1.tx*tf2.rxy + tf1.ty*tf2.ryy + tf1.tz*tf2.rzy + tf2.ty;
167   tz = tf1.tx*tf2.rxz + tf1.ty*tf2.ryz + tf1.t    180   tz = tf1.tx*tf2.rxz + tf1.ty*tf2.ryz + tf1.tz*tf2.rzz + tf2.tz;
168                                                   181 
169   return *this;                                   182   return *this;
170 }                                                 183 }
171                                                   184 
172 inline G4AffineTransform&                         185 inline G4AffineTransform&
173 G4AffineTransform::InverseProduct( const G4Aff    186 G4AffineTransform::InverseProduct( const G4AffineTransform& tf1,
174                                    const G4Aff    187                                    const G4AffineTransform& tf2 )
175 {                                                 188 {
176   if ((tf2.rxx + tf2.ryy + tf2.rzz) == 3.)        189   if ((tf2.rxx + tf2.ryy + tf2.rzz) == 3.)
177   {                                               190   {
178     rxx = tf1.rxx;                                191     rxx = tf1.rxx;
179     rxy = tf1.rxy;                                192     rxy = tf1.rxy;
180     rxz = tf1.rxz;                                193     rxz = tf1.rxz;
181                                                   194 
182     ryx = tf1.ryx;                                195     ryx = tf1.ryx;
183     ryy = tf1.ryy;                                196     ryy = tf1.ryy;
184     ryz = tf1.ryz;                                197     ryz = tf1.ryz;
185                                                   198 
186     rzx = tf1.rzx;                                199     rzx = tf1.rzx;
187     rzy = tf1.rzy;                                200     rzy = tf1.rzy;
188     rzz = tf1.rzz;                                201     rzz = tf1.rzz;
189                                                   202 
190     tx = tf1.tx - tf2.tx;                         203     tx = tf1.tx - tf2.tx;
191     ty = tf1.ty - tf2.ty;                         204     ty = tf1.ty - tf2.ty;
192     tz = tf1.tz - tf2.tz;                         205     tz = tf1.tz - tf2.tz;
193   }                                               206   }
194   else                                            207   else
195   {                                               208   {
196     G4double tf1rxx = tf1.rxx, tf1rxy = tf1.rx    209     G4double tf1rxx = tf1.rxx, tf1rxy = tf1.rxy, tf1rxz = tf1.rxz;
197     rxx = tf1rxx*tf2.rxx + tf1rxy*tf2.rxy + tf    210     rxx = tf1rxx*tf2.rxx + tf1rxy*tf2.rxy + tf1rxz*tf2.rxz;
198     rxy = tf1rxx*tf2.ryx + tf1rxy*tf2.ryy + tf    211     rxy = tf1rxx*tf2.ryx + tf1rxy*tf2.ryy + tf1rxz*tf2.ryz;
199     rxz = tf1rxx*tf2.rzx + tf1rxy*tf2.rzy + tf    212     rxz = tf1rxx*tf2.rzx + tf1rxy*tf2.rzy + tf1rxz*tf2.rzz;
200                                                   213 
201     G4double tf1ryx = tf1.ryx, tf1ryy = tf1.ry    214     G4double tf1ryx = tf1.ryx, tf1ryy = tf1.ryy, tf1ryz = tf1.ryz;
202     ryx = tf1ryx*tf2.rxx + tf1ryy*tf2.rxy + tf    215     ryx = tf1ryx*tf2.rxx + tf1ryy*tf2.rxy + tf1ryz*tf2.rxz;
203     ryy = tf1ryx*tf2.ryx + tf1ryy*tf2.ryy + tf    216     ryy = tf1ryx*tf2.ryx + tf1ryy*tf2.ryy + tf1ryz*tf2.ryz;
204     ryz = tf1ryx*tf2.rzx + tf1ryy*tf2.rzy + tf    217     ryz = tf1ryx*tf2.rzx + tf1ryy*tf2.rzy + tf1ryz*tf2.rzz;
205                                                   218 
206     G4double tf1rzx = tf1.rzx, tf1rzy = tf1.rz    219     G4double tf1rzx = tf1.rzx, tf1rzy = tf1.rzy, tf1rzz = tf1.rzz;
207     rzx = tf1rzx*tf2.rxx + tf1rzy*tf2.rxy + tf    220     rzx = tf1rzx*tf2.rxx + tf1rzy*tf2.rxy + tf1rzz*tf2.rxz;
208     rzy = tf1rzx*tf2.ryx + tf1rzy*tf2.ryy + tf    221     rzy = tf1rzx*tf2.ryx + tf1rzy*tf2.ryy + tf1rzz*tf2.ryz;
209     rzz = tf1rzx*tf2.rzx + tf1rzy*tf2.rzy + tf    222     rzz = tf1rzx*tf2.rzx + tf1rzy*tf2.rzy + tf1rzz*tf2.rzz;
210                                                   223 
211     G4double tf1_2tx = tf1.tx - tf2.tx;           224     G4double tf1_2tx = tf1.tx - tf2.tx;
212     G4double tf1_2ty = tf1.ty - tf2.ty;           225     G4double tf1_2ty = tf1.ty - tf2.ty;
213     G4double tf1_2tz = tf1.tz - tf2.tz;           226     G4double tf1_2tz = tf1.tz - tf2.tz;
214     tx = tf1_2tx*tf2.rxx + tf1_2ty*tf2.rxy + t    227     tx = tf1_2tx*tf2.rxx + tf1_2ty*tf2.rxy + tf1_2tz*tf2.rxz;
215     ty = tf1_2tx*tf2.ryx + tf1_2ty*tf2.ryy + t    228     ty = tf1_2tx*tf2.ryx + tf1_2ty*tf2.ryy + tf1_2tz*tf2.ryz;
216     tz = tf1_2tx*tf2.rzx + tf1_2ty*tf2.rzy + t    229     tz = tf1_2tx*tf2.rzx + tf1_2ty*tf2.rzy + tf1_2tz*tf2.rzz;
217   }                                               230   }
218   return *this;                                   231   return *this;
219 }                                                 232 }
220                                                   233 
221 inline G4ThreeVector                              234 inline G4ThreeVector
222 G4AffineTransform::TransformPoint(const G4Thre    235 G4AffineTransform::TransformPoint(const G4ThreeVector& vec) const
223 {                                                 236 {
224   G4double vecx = vec.x(), vecy = vec.y(), vec    237   G4double vecx = vec.x(), vecy = vec.y(), vecz = vec.z();
225   return { vecx*rxx + vecy*ryx + vecz*rzx + tx << 238   return G4ThreeVector( vecx*rxx + vecy*ryx + vecz*rzx + tx,
226            vecx*rxy + vecy*ryy + vecz*rzy + ty << 239                         vecx*rxy + vecy*ryy + vecz*rzy + ty,
227            vecx*rxz + vecy*ryz + vecz*rzz + tz << 240                         vecx*rxz + vecy*ryz + vecz*rzz + tz );
228 }                                                 241 }
229                                                   242 
230 inline G4ThreeVector                              243 inline G4ThreeVector
231 G4AffineTransform::InverseTransformPoint(const    244 G4AffineTransform::InverseTransformPoint(const G4ThreeVector& vec) const
232 {                                                 245 {
233   G4double vecx = vec.x()-tx, vecy = vec.y()-t    246   G4double vecx = vec.x()-tx, vecy = vec.y()-ty, vecz = vec.z()-tz;
234   return { vecx*rxx + vecy*rxy + vecz*rxz,     << 247   return G4ThreeVector( vecx*rxx + vecy*rxy + vecz*rxz,
235            vecx*ryx + vecy*ryy + vecz*ryz,     << 248                         vecx*ryx + vecy*ryy + vecz*ryz,
236            vecx*rzx + vecy*rzy + vecz*rzz };   << 249                         vecx*rzx + vecy*rzy + vecz*rzz );
237 }                                                 250 }
238                                                   251 
239 inline G4ThreeVector                              252 inline G4ThreeVector
240 G4AffineTransform::TransformAxis(const G4Three    253 G4AffineTransform::TransformAxis(const G4ThreeVector& axis) const
241 {                                                 254 {
242   G4double axisx = axis.x(), axisy = axis.y(),    255   G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
243   return { axisx*rxx + axisy*ryx + axisz*rzx,  << 256   return G4ThreeVector( axisx*rxx + axisy*ryx + axisz*rzx,
244            axisx*rxy + axisy*ryy + axisz*rzy,  << 257                         axisx*rxy + axisy*ryy + axisz*rzy,
245            axisx*rxz + axisy*ryz + axisz*rzz } << 258                         axisx*rxz + axisy*ryz + axisz*rzz );
246 }                                                 259 }
247                                                   260 
248 inline G4ThreeVector                              261 inline G4ThreeVector
249 G4AffineTransform::InverseTransformAxis(const     262 G4AffineTransform::InverseTransformAxis(const G4ThreeVector& axis) const
250 {                                                 263 {
251   G4double axisx = axis.x(), axisy = axis.y(),    264   G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
252   return { axisx*rxx + axisy*rxy + axisz*rxz,  << 265   return G4ThreeVector( axisx*rxx + axisy*rxy + axisz*rxz,
253            axisx*ryx + axisy*ryy + axisz*ryz,  << 266                         axisx*ryx + axisy*ryy + axisz*ryz,
254            axisx*rzx + axisy*rzy + axisz*rzz } << 267                         axisx*rzx + axisy*rzy + axisz*rzz );
255 }                                                 268 }
256                                                   269 
257 inline                                            270 inline
258 void G4AffineTransform::ApplyPointTransform(G4    271 void G4AffineTransform::ApplyPointTransform(G4ThreeVector& vec) const
259 {                                                 272 {
260   G4double vecx = vec.x(), vecy = vec.y(), vec    273   G4double vecx = vec.x(), vecy = vec.y(), vecz = vec.z();
261   vec.setX( vecx*rxx + vecy*ryx + vecz*rzx + t    274   vec.setX( vecx*rxx + vecy*ryx + vecz*rzx + tx );
262   vec.setY( vecx*rxy + vecy*ryy + vecz*rzy + t    275   vec.setY( vecx*rxy + vecy*ryy + vecz*rzy + ty );
263   vec.setZ( vecx*rxz + vecy*ryz + vecz*rzz + t    276   vec.setZ( vecx*rxz + vecy*ryz + vecz*rzz + tz );
264 }                                                 277 }
265                                                   278 
266 inline                                            279 inline
267 void G4AffineTransform::ApplyAxisTransform(G4T    280 void G4AffineTransform::ApplyAxisTransform(G4ThreeVector& axis) const
268 {                                                 281 {
269   G4double axisx = axis.x(), axisy = axis.y(),    282   G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
270   axis.setX( axisx*rxx + axisy*ryx + axisz*rzx    283   axis.setX( axisx*rxx + axisy*ryx + axisz*rzx );
271   axis.setY( axisx*rxy + axisy*ryy + axisz*rzy    284   axis.setY( axisx*rxy + axisy*ryy + axisz*rzy );
272   axis.setZ( axisx*rxz + axisy*ryz + axisz*rzz    285   axis.setZ( axisx*rxz + axisy*ryz + axisz*rzz );
273 }                                                 286 }
274                                                   287 
275 inline                                            288 inline
276 G4AffineTransform G4AffineTransform::Inverse()    289 G4AffineTransform G4AffineTransform::Inverse() const
277 {                                                 290 {
278   G4double ttx = -tx, tty = -ty, ttz = -tz;       291   G4double ttx = -tx, tty = -ty, ttz = -tz;
279   return G4AffineTransform( rxx, ryx, rzx,        292   return G4AffineTransform( rxx, ryx, rzx,
280                             rxy, ryy, rzy,        293                             rxy, ryy, rzy,
281                             rxz, ryz, rzz,        294                             rxz, ryz, rzz,
282                             ttx*rxx + tty*rxy     295                             ttx*rxx + tty*rxy + ttz*rxz,
283                             ttx*ryx + tty*ryy     296                             ttx*ryx + tty*ryy + ttz*ryz,
284                             ttx*rzx + tty*rzy     297                             ttx*rzx + tty*rzy + ttz*rzz );
285 }                                                 298 }
286                                                   299 
287 inline                                            300 inline
288 G4AffineTransform& G4AffineTransform::Invert()    301 G4AffineTransform& G4AffineTransform::Invert()
289 {                                                 302 {
290   G4double ttx = -tx, tty = -ty, ttz = -tz;       303   G4double ttx = -tx, tty = -ty, ttz = -tz;
291            tx = ttx*rxx + tty*rxy + ttz*rxz;      304            tx = ttx*rxx + tty*rxy + ttz*rxz;
292            ty = ttx*ryx + tty*ryy + ttz*ryz;      305            ty = ttx*ryx + tty*ryy + ttz*ryz;
293            tz = ttx*rzx + tty*rzy + ttz*rzz;      306            tz = ttx*rzx + tty*rzy + ttz*rzz;
294                                                   307 
295   G4double tmp1=ryx; ryx=rxy; rxy=tmp1;           308   G4double tmp1=ryx; ryx=rxy; rxy=tmp1;
296   G4double tmp2=rzx; rzx=rxz; rxz=tmp2;           309   G4double tmp2=rzx; rzx=rxz; rxz=tmp2;
297   G4double tmp3=rzy; rzy=ryz; ryz=tmp3;           310   G4double tmp3=rzy; rzy=ryz; ryz=tmp3;
298                                                   311 
299   return *this;                                   312   return *this;
300 }                                                 313 }
301                                                   314 
302 inline                                            315 inline
303 G4AffineTransform& G4AffineTransform::operator    316 G4AffineTransform& G4AffineTransform::operator +=(const G4ThreeVector& tlate)
304 {                                                 317 {
305   tx += tlate.x();                                318   tx += tlate.x();
306   ty += tlate.y();                                319   ty += tlate.y();
307   tz += tlate.z();                                320   tz += tlate.z();
308                                                   321 
309   return *this;                                   322   return *this;
310 }                                                 323 }
311                                                   324 
312 inline                                            325 inline
313 G4AffineTransform& G4AffineTransform::operator    326 G4AffineTransform& G4AffineTransform::operator -=(const G4ThreeVector& tlate)
314 {                                                 327 {
315   tx -= tlate.x();                                328   tx -= tlate.x();
316   ty -= tlate.y();                                329   ty -= tlate.y();
317   tz -= tlate.z();                                330   tz -= tlate.z();
318                                                   331 
319   return *this;                                   332   return *this;
320 }                                                 333 }
321                                                   334 
322 inline                                            335 inline
323 G4bool G4AffineTransform::operator == (const G    336 G4bool G4AffineTransform::operator == (const G4AffineTransform& tf) const
324 {                                                 337 {
325   return tx==tf.tx&&ty==tf.ty&&tz==tf.tz&&     << 338   return (tx==tf.tx&&ty==tf.ty&&tz==tf.tz&&
326          rxx==tf.rxx&&rxy==tf.rxy&&rxz==tf.rxz << 339           rxx==tf.rxx&&rxy==tf.rxy&&rxz==tf.rxz&&
327          ryx==tf.ryx&&ryy==tf.ryy&&ryz==tf.ryz << 340           ryx==tf.ryx&&ryy==tf.ryy&&ryz==tf.ryz&&
328          rzx==tf.rzx&&rzy==tf.rzy&&rzz==tf.rzz << 341           rzx==tf.rzx&&rzy==tf.rzy&&rzz==tf.rzz) ? true : false;
329 }                                                 342 }
330                                                   343 
331 inline                                            344 inline
332 G4bool G4AffineTransform::operator != (const G    345 G4bool G4AffineTransform::operator != (const G4AffineTransform& tf) const
333 {                                                 346 {
334   return tx!=tf.tx||ty!=tf.ty||tz!=tf.tz||     << 347   return (tx!=tf.tx||ty!=tf.ty||tz!=tf.tz||
335          rxx!=tf.rxx||rxy!=tf.rxy||rxz!=tf.rxz << 348           rxx!=tf.rxx||rxy!=tf.rxy||rxz!=tf.rxz||
336          ryx!=tf.ryx||ryy!=tf.ryy||ryz!=tf.ryz << 349           ryx!=tf.ryx||ryy!=tf.ryy||ryz!=tf.ryz||
337          rzx!=tf.rzx||rzy!=tf.rzy||rzz!=tf.rzz << 350           rzx!=tf.rzx||rzy!=tf.rzy||rzz!=tf.rzz) ? true : false;
338 }                                                 351 }
339                                                   352 
340 inline                                            353 inline
341 G4double G4AffineTransform::operator [] (const    354 G4double G4AffineTransform::operator [] (const G4int n) const
342 {                                                 355 {
343   G4double v = 0.0;                               356   G4double v = 0.0;
344   switch(n)                                       357   switch(n)
345   {                                               358   {
346     case 0:                                       359     case 0:
347             v=rxx;                                360             v=rxx;
348             break;                                361             break;
349     case 1:                                       362     case 1:
350             v=rxy;                                363             v=rxy;
351             break;                                364             break;
352     case 2:                                       365     case 2:
353             v=rxz;                                366             v=rxz;
354             break;                                367             break;
355     case 4:                                       368     case 4:
356             v=ryx;                                369             v=ryx;
357             break;                                370             break;
358     case 5:                                       371     case 5:
359             v=ryy;                                372             v=ryy;
360             break;                                373             break;
361     case 6:                                       374     case 6:
362             v=ryz;                                375             v=ryz;
363             break;                                376             break;
364     case 8:                                       377     case 8:
365             v=rzx;                                378             v=rzx;
366             break;                                379             break;
367     case 9:                                       380     case 9:
368             v=rzy;                                381             v=rzy;
369             break;                                382             break;
370     case 10:                                      383     case 10:
371             v=rzz;                                384             v=rzz;
372             break;                                385             break;
373     case 12:                                      386     case 12:
374             v=tx;                                 387             v=tx;
375             break;                                388             break;
376     case 13:                                      389     case 13:
377             v=ty;                                 390             v=ty;
378             break;                                391             break;
379     case 14:                                      392     case 14:
380             v=tz;                                 393             v=tz;
381             break;                                394             break;
382     case 3:                                       395     case 3:
383     case 7:                                       396     case 7:
384     case 11:                                      397     case 11:
385             break;                                398             break;
386     case 15:                                      399     case 15:
387             v=1.0;                                400             v=1.0;
388             break;                                401             break;
389   }                                               402   }
390   return v;                                       403   return v;
391 }                                                 404 }
392                                                   405 
393 inline                                            406 inline
394 G4bool G4AffineTransform::IsRotated() const       407 G4bool G4AffineTransform::IsRotated() const
395 {                                                 408 {
396   return !(rxx==1.0 && ryy==1.0 && rzz==1.0);  << 409   return (rxx==1.0 && ryy==1.0 && rzz==1.0) ? false : true;
397 }                                                 410 }
398                                                   411 
399 inline                                            412 inline 
400 G4bool G4AffineTransform::IsTranslated() const    413 G4bool G4AffineTransform::IsTranslated() const
401 {                                                 414 {
402   return (tx != 0.0) || (ty != 0.0) || (tz !=  << 415   return (tx || ty || tz) ? true:false;
403 }                                                 416 }
404                                                   417 
405 inline G4RotationMatrix G4AffineTransform::Net    418 inline G4RotationMatrix G4AffineTransform::NetRotation() const
406 {                                                 419 {
407   return G4Rep3x3(rxx,rxy,rxz,                    420   return G4Rep3x3(rxx,rxy,rxz,
408                   ryx,ryy,ryz,                    421                   ryx,ryy,ryz,
409                   rzx,rzy,rzz);                   422                   rzx,rzy,rzz);
410 }                                                 423 }
411                                                   424 
412 inline G4RotationMatrix G4AffineTransform::Inv    425 inline G4RotationMatrix G4AffineTransform::InverseNetRotation() const
413 {                                                 426 {
414   return G4Rep3x3(rxx,ryx,rzx,                    427   return G4Rep3x3(rxx,ryx,rzx,
415                   rxy,ryy,rzy,                    428                   rxy,ryy,rzy,
416                   rxz,ryz,rzz);                   429                   rxz,ryz,rzz);
417 }                                                 430 }
418                                                   431 
419 inline                                            432 inline
420 G4ThreeVector G4AffineTransform::NetTranslatio    433 G4ThreeVector G4AffineTransform::NetTranslation() const
421 {                                                 434 {
422   return {tx,ty,tz};                           << 435   return G4ThreeVector(tx,ty,tz);
423 }                                                 436 }
424                                                   437 
425 inline                                            438 inline
426 G4ThreeVector G4AffineTransform::InverseNetTra    439 G4ThreeVector G4AffineTransform::InverseNetTranslation() const
427 {                                                 440 {
428   G4double ttx = -tx, tty = -ty, ttz = -tz;       441   G4double ttx = -tx, tty = -ty, ttz = -tz;
429   G4double invtx = ttx*rxx + tty*rxy + ttz*rxz    442   G4double invtx = ttx*rxx + tty*rxy + ttz*rxz;
430   G4double invty = ttx*ryx + tty*ryy + ttz*ryz    443   G4double invty = ttx*ryx + tty*ryy + ttz*ryz;
431   G4double invtz = ttx*rzx + tty*rzy + ttz*rzz    444   G4double invtz = ttx*rzx + tty*rzy + ttz*rzz;
432   return {invtx,invty,invtz};                  << 445   return G4ThreeVector(invtx,invty,invtz);
433 }                                                 446 }
434                                                   447 
435 inline                                            448 inline 
436 void G4AffineTransform::SetNetRotation(const G    449 void G4AffineTransform::SetNetRotation(const G4RotationMatrix& rot)
437 {                                                 450 {
438   rxx=rot.xx();                                   451   rxx=rot.xx();
439   rxy=rot.xy();                                   452   rxy=rot.xy();
440   rxz=rot.xz();                                   453   rxz=rot.xz();
441   ryx=rot.yx();                                   454   ryx=rot.yx();
442   ryy=rot.yy();                                   455   ryy=rot.yy();
443   ryz=rot.yz();                                   456   ryz=rot.yz();
444   rzx=rot.zx();                                   457   rzx=rot.zx();
445   rzy=rot.zy();                                   458   rzy=rot.zy();
446   rzz=rot.zz();                                   459   rzz=rot.zz();
447 }                                                 460 }
448                                                   461 
449 inline                                            462 inline
450 void G4AffineTransform::SetNetTranslation(cons    463 void G4AffineTransform::SetNetTranslation(const G4ThreeVector& tlate)
451 {                                                 464 {
452   tx=tlate.x();                                   465   tx=tlate.x();
453   ty=tlate.y();                                   466   ty=tlate.y();
454   tz=tlate.z();                                   467   tz=tlate.z();
455 }                                                 468 }
456                                                   469 
457 inline                                            470 inline
458 G4AffineTransform::operator G4Transform3D () c    471 G4AffineTransform::operator G4Transform3D () const
459 {                                                 472 {
460   return G4Transform3D(NetRotation().inverse()    473   return G4Transform3D(NetRotation().inverse(),NetTranslation());
461 }                                                 474 }
462                                                   475 
463 inline                                            476 inline
464 std::ostream& operator << (std::ostream& os, c    477 std::ostream& operator << (std::ostream& os, const G4AffineTransform& transf)
465 {                                                 478 {
466   std::streamsize oldPrec = os.precision(6);      479   std::streamsize oldPrec = os.precision(6);
467   G4double DeviationTolerance = 1.0e-05;          480   G4double DeviationTolerance = 1.0e-05;
468                                                   481 
469   G4double diagDeviation = 0.0;                   482   G4double diagDeviation = 0.0;
470   G4double offdDeviationUL = 0.0;                 483   G4double offdDeviationUL = 0.0;
471   G4double offdDeviationDR = 0.0;                 484   G4double offdDeviationDR = 0.0;
472   G4double offdDeviation = 0.0;                   485   G4double offdDeviation = 0.0;
473                                                   486 
474   os << "  Transformation: " << G4endl;           487   os << "  Transformation: " << G4endl;
475                                                   488 
476   // double  a = std::max ( 1, 2, 3 ) ;           489   // double  a = std::max ( 1, 2, 3 ) ;
477                                                   490 
478   G4bool UnitTr = ! transf.IsRotated();           491   G4bool UnitTr = ! transf.IsRotated();
479   diagDeviation = std::max( std::fabs( transf[    492   diagDeviation = std::max( std::fabs( transf[0] - 1.0 ) ,   //  |rxx - 1|
480                             std::fabs( transf[    493                             std::fabs( transf[5] - 1.0 ) );  //  |ryy - 1|
481   diagDeviation = std::max( diagDeviation,        494   diagDeviation = std::max( diagDeviation,
482                             std::fabs( transf[    495                             std::fabs( transf[10] - 1.0 ) ); //  |rzz - 1|
483                                                   496   
484   offdDeviationUL = std::max( std::fabs( trans    497   offdDeviationUL = std::max( std::fabs( transf[1] ) ,       //  |rxy|
485                               std::fabs( trans    498                               std::fabs( transf[2] ) );      //  |rxz|
486   offdDeviationUL = std::max( offdDeviationUL,    499   offdDeviationUL = std::max( offdDeviationUL, 
487                               std::fabs( trans    500                               std::fabs( transf[4] ) );      //  |ryx|
488                                                   501   
489   offdDeviationDR = std::max( std::fabs( trans    502   offdDeviationDR = std::max( std::fabs( transf[6] ) ,       //  |ryz|
490                               std::fabs( trans    503                               std::fabs( transf[8] ) );      //  |rzx|
491   offdDeviationDR = std::max( offdDeviationDR,    504   offdDeviationDR = std::max( offdDeviationDR, 
492                               std::fabs( trans    505                               std::fabs( transf[9] ) );      //  |rzy|
493   offdDeviation = std::max( offdDeviationUL, o    506   offdDeviation = std::max( offdDeviationUL, offdDeviationDR );
494                                                   507 
495   if( UnitTr || std::max(diagDeviation, offdDe    508   if( UnitTr || std::max(diagDeviation, offdDeviation) < DeviationTolerance )
496   {                                               509   {
497      os << "    UNIT  Rotation " << G4endl;       510      os << "    UNIT  Rotation " << G4endl;
498   }                                               511   }
499   else                                            512   else
500   {                                               513   {
501      os << "rx/x,y,z: "                           514      os << "rx/x,y,z: "
502         << transf[0]  << " " << transf[1] << "    515         << transf[0]  << " " << transf[1] << " " << transf[2] << G4endl
503         << "ry/x,y,z: "                           516         << "ry/x,y,z: "
504         << transf[4]  << " " << transf[5] << "    517         << transf[4]  << " " << transf[5] << " " << transf[6] << G4endl
505         << "rz/x,y,z: "                           518         << "rz/x,y,z: "
506         << transf[8]  << " " << transf[9] << "    519         << transf[8]  << " " << transf[9] << " " << transf[10] << G4endl;
507   }                                               520   }
508                                                   521 
509   os << "tr/x,y,z: " << transf[12]  << " " <<     522   os << "tr/x,y,z: " << transf[12]  << " " << transf[13] << " " << transf[14]
510      << G4endl;                                   523      << G4endl;
511                                                   524   
512   os.precision(oldPrec);                          525   os.precision(oldPrec);
513                                                   526 
514   return os;                                      527   return os;
515 }                                                 528 }
516                                                   529