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