| 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 //
26 // G4ParameterisationBox[X/Y/Z] implementation << 23 //
>> 24 // $Id: G4ParameterisationBox.cc,v 1.7 2004/05/17 07:20:40 gcosmo Exp $
>> 25 // GEANT4 tag $Name: geant4-06-02 $
>> 26 //
>> 27 // class G4ParameterisationBox Implementation file
27 // 28 //
28 // 26.05.03 - P.Arce, Initial version 29 // 26.05.03 - P.Arce, Initial version
29 // 08.04.04 - I.Hrivnacova, Implemented reflec 30 // 08.04.04 - I.Hrivnacova, Implemented reflection
30 // 21.04.10 - M.Asai, Added gaps <<
31 // ------------------------------------------- 31 // --------------------------------------------------------------------
32 32
33 #include "G4ParameterisationBox.hh" 33 #include "G4ParameterisationBox.hh"
34 34
35 #include <iomanip> 35 #include <iomanip>
36 #include "G4ThreeVector.hh" 36 #include "G4ThreeVector.hh"
37 #include "G4Transform3D.hh" 37 #include "G4Transform3D.hh"
38 #include "G4RotationMatrix.hh" 38 #include "G4RotationMatrix.hh"
39 #include "G4VPhysicalVolume.hh" 39 #include "G4VPhysicalVolume.hh"
40 #include "G4ReflectedSolid.hh" 40 #include "G4ReflectedSolid.hh"
41 #include "G4Box.hh" 41 #include "G4Box.hh"
42 42
43 //-------------------------------------------- 43 //--------------------------------------------------------------------------
44 G4VParameterisationBox:: 44 G4VParameterisationBox::
45 G4VParameterisationBox( EAxis axis, G4int nDiv 45 G4VParameterisationBox( EAxis axis, G4int nDiv, G4double width,
46 G4double offset, G4VSo 46 G4double offset, G4VSolid* msolid,
47 DivisionType divType ) 47 DivisionType divType )
48 : G4VDivisionParameterisation( axis, nDiv, 48 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
49 { 49 {
50 auto msol = (G4Box*)(msolid); << 50 G4Box* msol = (G4Box*)(msolid);
51 if (msolid->GetEntityType() == "G4ReflectedS 51 if (msolid->GetEntityType() == "G4ReflectedSolid")
52 { 52 {
53 // Get constituent solid 53 // Get constituent solid
54 G4VSolid* mConstituentSolid 54 G4VSolid* mConstituentSolid
55 = ((G4ReflectedSolid*)msolid)->GetConst 55 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
56 msol = (G4Box*)(mConstituentSolid); 56 msol = (G4Box*)(mConstituentSolid);
57 fmotherSolid = msol; 57 fmotherSolid = msol;
58 fReflectedSolid = true; 58 fReflectedSolid = true;
59 } 59 }
60 } 60 }
61 61
62 //-------------------------------------------- 62 //--------------------------------------------------------------------------
63 G4VParameterisationBox::~G4VParameterisationBo << 63 G4VParameterisationBox::~G4VParameterisationBox()
>> 64 {
>> 65 }
64 66
65 //-------------------------------------------- 67 //--------------------------------------------------------------------------
66 G4ParameterisationBoxX:: 68 G4ParameterisationBoxX::
67 G4ParameterisationBoxX( EAxis axis, G4int nDiv 69 G4ParameterisationBoxX( EAxis axis, G4int nDiv, G4double width,
68 G4double offset, G4VSo 70 G4double offset, G4VSolid* msolid,
69 DivisionType divType ) 71 DivisionType divType )
70 : G4VParameterisationBox( axis, nDiv, width 72 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
71 { 73 {
72 CheckParametersValidity(); 74 CheckParametersValidity();
73 SetType( "DivisionBoxX" ); 75 SetType( "DivisionBoxX" );
74 76
75 auto mbox = (G4Box*)(fmotherSolid); << 77 G4Box* mbox = (G4Box*)(fmotherSolid);
76 if( divType == DivWIDTH ) 78 if( divType == DivWIDTH )
77 { 79 {
78 fnDiv = CalculateNDiv( 2*mbox->GetXHalfLen 80 fnDiv = CalculateNDiv( 2*mbox->GetXHalfLength(), width, offset );
79 } 81 }
80 else if( divType == DivNDIV ) 82 else if( divType == DivNDIV )
81 { 83 {
82 fwidth = CalculateWidth( 2*mbox->GetXHalfL 84 fwidth = CalculateWidth( 2*mbox->GetXHalfLength(), nDiv, offset );
83 } 85 }
84 #ifdef G4DIVDEBUG 86 #ifdef G4DIVDEBUG
85 if( verbose >= 1 ) 87 if( verbose >= 1 )
86 { 88 {
87 G4cout << " G4ParameterisationBoxX - no di 89 G4cout << " G4ParameterisationBoxX - no divisions "
88 << fnDiv << " = " << nDiv << G4endl 90 << fnDiv << " = " << nDiv << G4endl
89 << " Offset " << foffset << " = " < 91 << " Offset " << foffset << " = " << offset << G4endl
90 << " Width " << fwidth << " = " << 92 << " Width " << fwidth << " = " << width << G4endl;
91 } 93 }
92 #endif 94 #endif
93 } 95 }
94 96
95 //-------------------------------------------- 97 //------------------------------------------------------------------------
96 G4ParameterisationBoxX::~G4ParameterisationBox << 98 G4ParameterisationBoxX::~G4ParameterisationBoxX()
>> 99 {
>> 100 }
97 101
98 //-------------------------------------------- 102 //------------------------------------------------------------------------
99 G4double G4ParameterisationBoxX::GetMaxParamet 103 G4double G4ParameterisationBoxX::GetMaxParameter() const
100 { 104 {
101 auto msol = (G4Box*)(fmotherSolid); << 105 G4Box* msol = (G4Box*)(fmotherSolid);
102 return 2*msol->GetXHalfLength(); 106 return 2*msol->GetXHalfLength();
103 } 107 }
104 108
105 //-------------------------------------------- 109 //------------------------------------------------------------------------
106 void 110 void
107 G4ParameterisationBoxX:: 111 G4ParameterisationBoxX::
108 ComputeTransformation( const G4int copyNo, G4V 112 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
109 { 113 {
110 auto msol = (G4Box*)(fmotherSolid ); << 114 G4Box* msol = (G4Box*)(fmotherSolid );
111 G4double mdx = msol->GetXHalfLength( ); 115 G4double mdx = msol->GetXHalfLength( );
112 116
113 //----- translation 117 //----- translation
114 G4ThreeVector origin(0.,0.,0.); 118 G4ThreeVector origin(0.,0.,0.);
115 G4double posi = -mdx + foffset+(copyNo+0.5)* 119 G4double posi = -mdx + foffset+(copyNo+0.5)*fwidth;
116 120
117 if( faxis == kXAxis ) 121 if( faxis == kXAxis )
118 { 122 {
119 origin.setX( posi ); 123 origin.setX( posi );
120 } 124 }
121 else 125 else
122 { << 126 {
123 std::ostringstream message; << 127 G4cerr << "ERROR - G4ParameterisationBoxX::ComputeTransformation()"
124 message << "Only axes along X are allowed << 128 << G4endl
>> 129 << " Axis is along " << faxis << " !" << G4endl;
125 G4Exception("G4ParameterisationBoxX::Compu 130 G4Exception("G4ParameterisationBoxX::ComputeTransformation()",
126 "GeomDiv0002", FatalException, << 131 "IllegalConstruct", FatalException,
>> 132 "Only axes along X are allowed !");
127 } 133 }
128 #ifdef G4DIVDEBUG 134 #ifdef G4DIVDEBUG
129 if( verbose >= 2 ) 135 if( verbose >= 2 )
130 { 136 {
131 G4cout << std::setprecision(8) << " G4Para 137 G4cout << std::setprecision(8) << " G4ParameterisationBoxX: "
132 << copyNo << G4endl 138 << copyNo << G4endl
133 << " Position " << origin << " Axis 139 << " Position " << origin << " Axis " << faxis << G4endl;
134 } 140 }
135 #endif 141 #endif
136 //----- set translation 142 //----- set translation
137 physVol->SetTranslation( origin ); 143 physVol->SetTranslation( origin );
138 } 144 }
139 145
140 //-------------------------------------------- 146 //------------------------------------------------------------------------
141 void 147 void
142 G4ParameterisationBoxX:: 148 G4ParameterisationBoxX::
143 ComputeDimensions( G4Box& box, const G4int, 149 ComputeDimensions( G4Box& box, const G4int,
144 const G4VPhysicalVolume* ) 150 const G4VPhysicalVolume* ) const
145 { 151 {
146 auto msol = (G4Box*)(fmotherSolid); << 152 G4Box* msol = (G4Box*)(fmotherSolid);
147 153
148 G4double pDx = fwidth/2. - fhgap; << 154 G4double pDx = fwidth/2.;
149 G4double pDy = msol->GetYHalfLength(); 155 G4double pDy = msol->GetYHalfLength();
150 G4double pDz = msol->GetZHalfLength(); 156 G4double pDz = msol->GetZHalfLength();
151 157
152 box.SetXHalfLength( pDx ); 158 box.SetXHalfLength( pDx );
153 box.SetYHalfLength( pDy ); 159 box.SetYHalfLength( pDy );
154 box.SetZHalfLength( pDz ); 160 box.SetZHalfLength( pDz );
155 161
156 #ifdef G4DIVDEBUG 162 #ifdef G4DIVDEBUG
157 if( verbose >= 2 ) 163 if( verbose >= 2 )
158 { 164 {
159 G4cout << " G4ParameterisationBoxX::Comput 165 G4cout << " G4ParameterisationBoxX::ComputeDimensions()" << G4endl
160 << " pDx: " << pDz << G4endl; 166 << " pDx: " << pDz << G4endl;
161 box.DumpInfo(); 167 box.DumpInfo();
162 } 168 }
163 #endif 169 #endif
164 } 170 }
165 171
166 //-------------------------------------------- 172 //------------------------------------------------------------------------
167 G4ParameterisationBoxY:: 173 G4ParameterisationBoxY::
168 G4ParameterisationBoxY( EAxis axis, G4int nDiv 174 G4ParameterisationBoxY( EAxis axis, G4int nDiv, G4double width,
169 G4double offset, G4VSo 175 G4double offset, G4VSolid* msolid,
170 DivisionType divType) 176 DivisionType divType)
171 : G4VParameterisationBox( axis, nDiv, width 177 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
172 { 178 {
173 CheckParametersValidity(); 179 CheckParametersValidity();
174 SetType( "DivisionBoxY" ); 180 SetType( "DivisionBoxY" );
175 181
176 auto mbox = (G4Box*)(fmotherSolid); << 182 G4Box* mbox = (G4Box*)(fmotherSolid);
177 if( divType == DivWIDTH ) 183 if( divType == DivWIDTH )
178 { 184 {
179 fnDiv = CalculateNDiv( 2*mbox->GetYHalfLen 185 fnDiv = CalculateNDiv( 2*mbox->GetYHalfLength(), width, offset );
180 } 186 }
181 else if( divType == DivNDIV ) 187 else if( divType == DivNDIV )
182 { 188 {
183 fwidth = CalculateWidth( 2*mbox->GetYHalfL 189 fwidth = CalculateWidth( 2*mbox->GetYHalfLength(), nDiv, offset );
184 } 190 }
185 191
186 #ifdef G4DIVDEBUG 192 #ifdef G4DIVDEBUG
187 if( verbose >= 1 ) 193 if( verbose >= 1 )
188 { 194 {
189 G4cout << " G4ParameterisationBoxY - no di 195 G4cout << " G4ParameterisationBoxY - no divisions " << fnDiv << " = "
190 << nDiv << ". Offset " << foffset < 196 << nDiv << ". Offset " << foffset << " = " << offset
191 << ". Width " << fwidth << " = " << 197 << ". Width " << fwidth << " = " << width << G4endl;
192 } 198 }
193 #endif 199 #endif
194 } 200 }
195 201
196 //-------------------------------------------- 202 //------------------------------------------------------------------------
197 G4ParameterisationBoxY::~G4ParameterisationBox << 203 G4ParameterisationBoxY::~G4ParameterisationBoxY()
>> 204 {
>> 205 }
198 206
199 //-------------------------------------------- 207 //------------------------------------------------------------------------
200 G4double G4ParameterisationBoxY::GetMaxParamet 208 G4double G4ParameterisationBoxY::GetMaxParameter() const
201 { 209 {
202 auto msol = (G4Box*)(fmotherSolid); << 210 G4Box* msol = (G4Box*)(fmotherSolid);
203 return 2*msol->GetYHalfLength(); 211 return 2*msol->GetYHalfLength();
204 } 212 }
205 213
206 //-------------------------------------------- 214 //------------------------------------------------------------------------
207 void 215 void
208 G4ParameterisationBoxY:: 216 G4ParameterisationBoxY::
209 ComputeTransformation( const G4int copyNo, G4V 217 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
210 { 218 {
211 auto msol = (G4Box*)(fmotherSolid); << 219 G4Box* msol = (G4Box*)(fmotherSolid);
212 G4double mdy = msol->GetYHalfLength(); 220 G4double mdy = msol->GetYHalfLength();
213 221
214 //----- translation 222 //----- translation
215 G4ThreeVector origin(0.,0.,0.); 223 G4ThreeVector origin(0.,0.,0.);
216 G4double posi = -mdy + foffset + (copyNo+0.5 224 G4double posi = -mdy + foffset + (copyNo+0.5)*fwidth;
217 if( faxis == kYAxis ) 225 if( faxis == kYAxis )
218 { 226 {
219 origin.setY( posi ); 227 origin.setY( posi );
220 } 228 }
221 else 229 else
222 { 230 {
223 std::ostringstream message; << 231 G4cerr << "ERROR - G4ParameterisationBoxY::ComputeTransformation()"
224 message << "Only axes along Y are allowed << 232 << G4endl
>> 233 << " Axis is along " << faxis << " !" << G4endl;
225 G4Exception("G4ParameterisationBoxY::Compu 234 G4Exception("G4ParameterisationBoxY::ComputeTransformation()",
226 "GeomDiv0002", FatalException, << 235 "IllegalConstruct", FatalException,
>> 236 "Only axes along Y are allowed !");
227 } 237 }
228 #ifdef G4DIVDEBUG 238 #ifdef G4DIVDEBUG
229 if( verbose >= 2 ) 239 if( verbose >= 2 )
230 { 240 {
231 G4cout << std::setprecision(8) << " G4Para 241 G4cout << std::setprecision(8) << " G4ParameterisationBoxY: "
232 << copyNo << G4endl 242 << copyNo << G4endl
233 << " Position " << origin << " Axis 243 << " Position " << origin << " Axis " << faxis << G4endl;
234 } 244 }
235 #endif 245 #endif
236 //----- set translation 246 //----- set translation
237 physVol->SetTranslation( origin ); 247 physVol->SetTranslation( origin );
238 } 248 }
239 249
240 //-------------------------------------------- 250 //------------------------------------------------------------------------
241 void 251 void
242 G4ParameterisationBoxY:: 252 G4ParameterisationBoxY::
243 ComputeDimensions( G4Box& box, const G4int, 253 ComputeDimensions( G4Box& box, const G4int,
244 const G4VPhysicalVolume* ) 254 const G4VPhysicalVolume* ) const
245 { 255 {
246 auto msol = (G4Box*)(fmotherSolid); << 256 G4Box* msol = (G4Box*)(fmotherSolid);
247 257
248 G4double pDx = msol->GetXHalfLength(); 258 G4double pDx = msol->GetXHalfLength();
249 G4double pDy = fwidth/2. - fhgap; << 259 G4double pDy = fwidth/2.;
250 G4double pDz = msol->GetZHalfLength(); 260 G4double pDz = msol->GetZHalfLength();
251 261
252 box.SetXHalfLength( pDx ); 262 box.SetXHalfLength( pDx );
253 box.SetYHalfLength( pDy ); 263 box.SetYHalfLength( pDy );
254 box.SetZHalfLength( pDz ); 264 box.SetZHalfLength( pDz );
255 265
256 #ifdef G4DIVDEBUG 266 #ifdef G4DIVDEBUG
257 if( verbose >= 2 ) 267 if( verbose >= 2 )
258 { 268 {
259 G4cout << " G4ParameterisationBoxY::Comput 269 G4cout << " G4ParameterisationBoxY::ComputeDimensions()" << G4endl
260 << " pDx: " << pDz << G4endl; 270 << " pDx: " << pDz << G4endl;
261 box.DumpInfo(); 271 box.DumpInfo();
262 } 272 }
263 #endif 273 #endif
264 } 274 }
265 275
266 //-------------------------------------------- 276 //------------------------------------------------------------------------
267 G4ParameterisationBoxZ:: 277 G4ParameterisationBoxZ::
268 G4ParameterisationBoxZ( EAxis axis, G4int nDiv 278 G4ParameterisationBoxZ( EAxis axis, G4int nDiv, G4double width,
269 G4double offset, G4VSo 279 G4double offset, G4VSolid* msolid,
270 DivisionType divType ) 280 DivisionType divType )
271 : G4VParameterisationBox( axis, nDiv, width 281 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
272 { 282 {
273 CheckParametersValidity(); 283 CheckParametersValidity();
274 SetType( "DivisionBoxZ" ); 284 SetType( "DivisionBoxZ" );
275 285
276 auto mbox = (G4Box*)(fmotherSolid); << 286 G4Box* mbox = (G4Box*)(fmotherSolid);
277 if( divType == DivWIDTH ) 287 if( divType == DivWIDTH )
278 { 288 {
279 fnDiv = CalculateNDiv( 2*mbox->GetZHalfLen 289 fnDiv = CalculateNDiv( 2*mbox->GetZHalfLength(), width, offset );
280 } 290 }
281 else if ( divType == DivNDIV ) 291 else if ( divType == DivNDIV )
282 { 292 {
283 fwidth = CalculateWidth( 2*mbox->GetZHalfL 293 fwidth = CalculateWidth( 2*mbox->GetZHalfLength(), nDiv, offset );
284 } 294 }
285 #ifdef G4DIVDEBUG 295 #ifdef G4DIVDEBUG
286 if( verbose >= 1 ) 296 if( verbose >= 1 )
287 { 297 {
288 G4cout << " G4ParameterisationBoxZ - no di 298 G4cout << " G4ParameterisationBoxZ - no divisions " << fnDiv << " = "
289 << nDiv << ". Offset " << foffset < 299 << nDiv << ". Offset " << foffset << " = " << offset
290 << ". Width " << fwidth << " = " << 300 << ". Width " << fwidth << " = " << width << G4endl;
291 } 301 }
292 #endif 302 #endif
293 } 303 }
294 304
295 //-------------------------------------------- 305 //------------------------------------------------------------------------
296 G4ParameterisationBoxZ::~G4ParameterisationBox << 306 G4ParameterisationBoxZ::~G4ParameterisationBoxZ()
>> 307 {
>> 308 }
297 309
298 //-------------------------------------------- 310 //------------------------------------------------------------------------
299 G4double G4ParameterisationBoxZ::GetMaxParamet 311 G4double G4ParameterisationBoxZ::GetMaxParameter() const
300 { 312 {
301 auto msol = (G4Box*)(fmotherSolid); << 313 G4Box* msol = (G4Box*)(fmotherSolid);
302 return 2*msol->GetZHalfLength(); 314 return 2*msol->GetZHalfLength();
303 } 315 }
304 316
305 //-------------------------------------------- 317 //------------------------------------------------------------------------
306 void 318 void
307 G4ParameterisationBoxZ:: 319 G4ParameterisationBoxZ::
308 ComputeTransformation( const G4int copyNo, G4V 320 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
309 { 321 {
310 auto msol = (G4Box*)(fmotherSolid ); << 322 G4Box* msol = (G4Box*)(fmotherSolid );
311 G4double mdz = msol->GetZHalfLength(); 323 G4double mdz = msol->GetZHalfLength();
312 324
313 //----- translation 325 //----- translation
314 G4ThreeVector origin(0.,0.,0.); 326 G4ThreeVector origin(0.,0.,0.);
315 G4double posi = -mdz + OffsetZ() + (copyNo+0 327 G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
316 328
317 if( faxis == kZAxis ) 329 if( faxis == kZAxis )
318 { 330 {
319 origin.setZ( posi ); 331 origin.setZ( posi );
320 } 332 }
321 else 333 else
322 { 334 {
323 std::ostringstream message; << 335 G4cerr << "ERROR - G4ParameterisationBoxZ::ComputeTransformation()"
324 message << "Only axes along Z are allowed << 336 << G4endl;
325 G4Exception("G4ParameterisationBoxZ::Compu 337 G4Exception("G4ParameterisationBoxZ::ComputeTransformation()",
326 "GeomDiv0002", FatalException, << 338 "IllegalConstruct", FatalException,
>> 339 "Only axes along Z are allowed !");
327 } 340 }
328 #ifdef G4DIVDEBUG 341 #ifdef G4DIVDEBUG
329 if( verbose >= 2 ) 342 if( verbose >= 2 )
330 { 343 {
331 G4cout << std::setprecision(8) << " G4Para 344 G4cout << std::setprecision(8) << " G4ParameterisationBoxZ: "
332 << copyNo << G4endl 345 << copyNo << G4endl
333 << " Position " << origin << " Axis 346 << " Position " << origin << " Axis " << faxis << G4endl;
334 } 347 }
335 #endif 348 #endif
336 //----- set translation 349 //----- set translation
337 physVol->SetTranslation( origin ); 350 physVol->SetTranslation( origin );
338 } 351 }
339 352
340 //-------------------------------------------- 353 //------------------------------------------------------------------------
341 void 354 void
342 G4ParameterisationBoxZ:: 355 G4ParameterisationBoxZ::
343 ComputeDimensions( G4Box& box, const G4int, 356 ComputeDimensions( G4Box& box, const G4int,
344 const G4VPhysicalVolume* ) 357 const G4VPhysicalVolume* ) const
345 { 358 {
346 auto msol = (G4Box*)(fmotherSolid); << 359 G4Box* msol = (G4Box*)(fmotherSolid);
347 360
348 G4double pDx = msol->GetXHalfLength(); 361 G4double pDx = msol->GetXHalfLength();
349 G4double pDy = msol->GetYHalfLength(); 362 G4double pDy = msol->GetYHalfLength();
350 G4double pDz = fwidth/2. - fhgap; << 363 G4double pDz = fwidth/2.;
351 364
352 box.SetXHalfLength( pDx ); 365 box.SetXHalfLength( pDx );
353 box.SetYHalfLength( pDy ); 366 box.SetYHalfLength( pDy );
354 box.SetZHalfLength( pDz ); 367 box.SetZHalfLength( pDz );
355 368
356 #ifdef G4DIVDEBUG 369 #ifdef G4DIVDEBUG
357 if( verbose >= 2 ) 370 if( verbose >= 2 )
358 { 371 {
359 G4cout << " G4ParameterisationBoxZ::Comput 372 G4cout << " G4ParameterisationBoxZ::ComputeDimensions()" << G4endl
360 << " pDx: " << pDz << G4endl; 373 << " pDx: " << pDz << G4endl;
361 box.DumpInfo(); 374 box.DumpInfo();
362 } 375 }
363 #endif 376 #endif
364 } 377 }
>> 378
365 379