| Geant4 Cross Reference |
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 // G4ParameterisationBox[X/Y/Z] implementation << 26 //
>> 27 // $Id: G4ParameterisationBox.cc,v 1.10 2006/06/29 18:18:35 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-09-03-patch-02 $
>> 29 //
>> 30 // class G4ParameterisationBox Implementation file
27 // 31 //
28 // 26.05.03 - P.Arce, Initial version 32 // 26.05.03 - P.Arce, Initial version
29 // 08.04.04 - I.Hrivnacova, Implemented reflec 33 // 08.04.04 - I.Hrivnacova, Implemented reflection
30 // 21.04.10 - M.Asai, Added gaps <<
31 // ------------------------------------------- 34 // --------------------------------------------------------------------
32 35
33 #include "G4ParameterisationBox.hh" 36 #include "G4ParameterisationBox.hh"
34 37
35 #include <iomanip> 38 #include <iomanip>
36 #include "G4ThreeVector.hh" 39 #include "G4ThreeVector.hh"
37 #include "G4Transform3D.hh" 40 #include "G4Transform3D.hh"
38 #include "G4RotationMatrix.hh" 41 #include "G4RotationMatrix.hh"
39 #include "G4VPhysicalVolume.hh" 42 #include "G4VPhysicalVolume.hh"
40 #include "G4ReflectedSolid.hh" 43 #include "G4ReflectedSolid.hh"
41 #include "G4Box.hh" 44 #include "G4Box.hh"
42 45
43 //-------------------------------------------- 46 //--------------------------------------------------------------------------
44 G4VParameterisationBox:: 47 G4VParameterisationBox::
45 G4VParameterisationBox( EAxis axis, G4int nDiv 48 G4VParameterisationBox( EAxis axis, G4int nDiv, G4double width,
46 G4double offset, G4VSo 49 G4double offset, G4VSolid* msolid,
47 DivisionType divType ) 50 DivisionType divType )
48 : G4VDivisionParameterisation( axis, nDiv, 51 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
49 { 52 {
50 auto msol = (G4Box*)(msolid); << 53 G4Box* msol = (G4Box*)(msolid);
51 if (msolid->GetEntityType() == "G4ReflectedS 54 if (msolid->GetEntityType() == "G4ReflectedSolid")
52 { 55 {
53 // Get constituent solid 56 // Get constituent solid
54 G4VSolid* mConstituentSolid 57 G4VSolid* mConstituentSolid
55 = ((G4ReflectedSolid*)msolid)->GetConst 58 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
56 msol = (G4Box*)(mConstituentSolid); 59 msol = (G4Box*)(mConstituentSolid);
57 fmotherSolid = msol; 60 fmotherSolid = msol;
58 fReflectedSolid = true; 61 fReflectedSolid = true;
59 } 62 }
60 } 63 }
61 64
62 //-------------------------------------------- 65 //--------------------------------------------------------------------------
63 G4VParameterisationBox::~G4VParameterisationBo << 66 G4VParameterisationBox::~G4VParameterisationBox()
>> 67 {
>> 68 }
64 69
65 //-------------------------------------------- 70 //--------------------------------------------------------------------------
66 G4ParameterisationBoxX:: 71 G4ParameterisationBoxX::
67 G4ParameterisationBoxX( EAxis axis, G4int nDiv 72 G4ParameterisationBoxX( EAxis axis, G4int nDiv, G4double width,
68 G4double offset, G4VSo 73 G4double offset, G4VSolid* msolid,
69 DivisionType divType ) 74 DivisionType divType )
70 : G4VParameterisationBox( axis, nDiv, width 75 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
71 { 76 {
72 CheckParametersValidity(); 77 CheckParametersValidity();
73 SetType( "DivisionBoxX" ); 78 SetType( "DivisionBoxX" );
74 79
75 auto mbox = (G4Box*)(fmotherSolid); << 80 G4Box* mbox = (G4Box*)(fmotherSolid);
76 if( divType == DivWIDTH ) 81 if( divType == DivWIDTH )
77 { 82 {
78 fnDiv = CalculateNDiv( 2*mbox->GetXHalfLen 83 fnDiv = CalculateNDiv( 2*mbox->GetXHalfLength(), width, offset );
79 } 84 }
80 else if( divType == DivNDIV ) 85 else if( divType == DivNDIV )
81 { 86 {
82 fwidth = CalculateWidth( 2*mbox->GetXHalfL 87 fwidth = CalculateWidth( 2*mbox->GetXHalfLength(), nDiv, offset );
83 } 88 }
84 #ifdef G4DIVDEBUG 89 #ifdef G4DIVDEBUG
85 if( verbose >= 1 ) 90 if( verbose >= 1 )
86 { 91 {
87 G4cout << " G4ParameterisationBoxX - no di 92 G4cout << " G4ParameterisationBoxX - no divisions "
88 << fnDiv << " = " << nDiv << G4endl 93 << fnDiv << " = " << nDiv << G4endl
89 << " Offset " << foffset << " = " < 94 << " Offset " << foffset << " = " << offset << G4endl
90 << " Width " << fwidth << " = " << 95 << " Width " << fwidth << " = " << width << G4endl;
91 } 96 }
92 #endif 97 #endif
93 } 98 }
94 99
95 //-------------------------------------------- 100 //------------------------------------------------------------------------
96 G4ParameterisationBoxX::~G4ParameterisationBox << 101 G4ParameterisationBoxX::~G4ParameterisationBoxX()
>> 102 {
>> 103 }
97 104
98 //-------------------------------------------- 105 //------------------------------------------------------------------------
99 G4double G4ParameterisationBoxX::GetMaxParamet 106 G4double G4ParameterisationBoxX::GetMaxParameter() const
100 { 107 {
101 auto msol = (G4Box*)(fmotherSolid); << 108 G4Box* msol = (G4Box*)(fmotherSolid);
102 return 2*msol->GetXHalfLength(); 109 return 2*msol->GetXHalfLength();
103 } 110 }
104 111
105 //-------------------------------------------- 112 //------------------------------------------------------------------------
106 void 113 void
107 G4ParameterisationBoxX:: 114 G4ParameterisationBoxX::
108 ComputeTransformation( const G4int copyNo, G4V 115 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
109 { 116 {
110 auto msol = (G4Box*)(fmotherSolid ); << 117 G4Box* msol = (G4Box*)(fmotherSolid );
111 G4double mdx = msol->GetXHalfLength( ); 118 G4double mdx = msol->GetXHalfLength( );
112 119
113 //----- translation 120 //----- translation
114 G4ThreeVector origin(0.,0.,0.); 121 G4ThreeVector origin(0.,0.,0.);
115 G4double posi = -mdx + foffset+(copyNo+0.5)* 122 G4double posi = -mdx + foffset+(copyNo+0.5)*fwidth;
116 123
117 if( faxis == kXAxis ) 124 if( faxis == kXAxis )
118 { 125 {
119 origin.setX( posi ); 126 origin.setX( posi );
120 } 127 }
121 else 128 else
122 { << 129 {
123 std::ostringstream message; <<
124 message << "Only axes along X are allowed <<
125 G4Exception("G4ParameterisationBoxX::Compu 130 G4Exception("G4ParameterisationBoxX::ComputeTransformation()",
126 "GeomDiv0002", FatalException, << 131 "IllegalConstruct", FatalException,
>> 132 "Only axes along X are allowed ! Axis: "+faxis);
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; <<
224 message << "Only axes along Y are allowed <<
225 G4Exception("G4ParameterisationBoxY::Compu 231 G4Exception("G4ParameterisationBoxY::ComputeTransformation()",
226 "GeomDiv0002", FatalException, << 232 "IllegalConstruct", FatalException,
>> 233 "Only axes along Y are allowed ! Axis: "+faxis);
227 } 234 }
228 #ifdef G4DIVDEBUG 235 #ifdef G4DIVDEBUG
229 if( verbose >= 2 ) 236 if( verbose >= 2 )
230 { 237 {
231 G4cout << std::setprecision(8) << " G4Para 238 G4cout << std::setprecision(8) << " G4ParameterisationBoxY: "
232 << copyNo << G4endl 239 << copyNo << G4endl
233 << " Position " << origin << " Axis 240 << " Position " << origin << " Axis " << faxis << G4endl;
234 } 241 }
235 #endif 242 #endif
236 //----- set translation 243 //----- set translation
237 physVol->SetTranslation( origin ); 244 physVol->SetTranslation( origin );
238 } 245 }
239 246
240 //-------------------------------------------- 247 //------------------------------------------------------------------------
241 void 248 void
242 G4ParameterisationBoxY:: 249 G4ParameterisationBoxY::
243 ComputeDimensions( G4Box& box, const G4int, 250 ComputeDimensions( G4Box& box, const G4int,
244 const G4VPhysicalVolume* ) 251 const G4VPhysicalVolume* ) const
245 { 252 {
246 auto msol = (G4Box*)(fmotherSolid); << 253 G4Box* msol = (G4Box*)(fmotherSolid);
247 254
248 G4double pDx = msol->GetXHalfLength(); 255 G4double pDx = msol->GetXHalfLength();
249 G4double pDy = fwidth/2. - fhgap; << 256 G4double pDy = fwidth/2.;
250 G4double pDz = msol->GetZHalfLength(); 257 G4double pDz = msol->GetZHalfLength();
251 258
252 box.SetXHalfLength( pDx ); 259 box.SetXHalfLength( pDx );
253 box.SetYHalfLength( pDy ); 260 box.SetYHalfLength( pDy );
254 box.SetZHalfLength( pDz ); 261 box.SetZHalfLength( pDz );
255 262
256 #ifdef G4DIVDEBUG 263 #ifdef G4DIVDEBUG
257 if( verbose >= 2 ) 264 if( verbose >= 2 )
258 { 265 {
259 G4cout << " G4ParameterisationBoxY::Comput 266 G4cout << " G4ParameterisationBoxY::ComputeDimensions()" << G4endl
260 << " pDx: " << pDz << G4endl; 267 << " pDx: " << pDz << G4endl;
261 box.DumpInfo(); 268 box.DumpInfo();
262 } 269 }
263 #endif 270 #endif
264 } 271 }
265 272
266 //-------------------------------------------- 273 //------------------------------------------------------------------------
267 G4ParameterisationBoxZ:: 274 G4ParameterisationBoxZ::
268 G4ParameterisationBoxZ( EAxis axis, G4int nDiv 275 G4ParameterisationBoxZ( EAxis axis, G4int nDiv, G4double width,
269 G4double offset, G4VSo 276 G4double offset, G4VSolid* msolid,
270 DivisionType divType ) 277 DivisionType divType )
271 : G4VParameterisationBox( axis, nDiv, width 278 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
272 { 279 {
273 CheckParametersValidity(); 280 CheckParametersValidity();
274 SetType( "DivisionBoxZ" ); 281 SetType( "DivisionBoxZ" );
275 282
276 auto mbox = (G4Box*)(fmotherSolid); << 283 G4Box* mbox = (G4Box*)(fmotherSolid);
277 if( divType == DivWIDTH ) 284 if( divType == DivWIDTH )
278 { 285 {
279 fnDiv = CalculateNDiv( 2*mbox->GetZHalfLen 286 fnDiv = CalculateNDiv( 2*mbox->GetZHalfLength(), width, offset );
280 } 287 }
281 else if ( divType == DivNDIV ) 288 else if ( divType == DivNDIV )
282 { 289 {
283 fwidth = CalculateWidth( 2*mbox->GetZHalfL 290 fwidth = CalculateWidth( 2*mbox->GetZHalfLength(), nDiv, offset );
284 } 291 }
285 #ifdef G4DIVDEBUG 292 #ifdef G4DIVDEBUG
286 if( verbose >= 1 ) 293 if( verbose >= 1 )
287 { 294 {
288 G4cout << " G4ParameterisationBoxZ - no di 295 G4cout << " G4ParameterisationBoxZ - no divisions " << fnDiv << " = "
289 << nDiv << ". Offset " << foffset < 296 << nDiv << ". Offset " << foffset << " = " << offset
290 << ". Width " << fwidth << " = " << 297 << ". Width " << fwidth << " = " << width << G4endl;
291 } 298 }
292 #endif 299 #endif
293 } 300 }
294 301
295 //-------------------------------------------- 302 //------------------------------------------------------------------------
296 G4ParameterisationBoxZ::~G4ParameterisationBox << 303 G4ParameterisationBoxZ::~G4ParameterisationBoxZ()
>> 304 {
>> 305 }
297 306
298 //-------------------------------------------- 307 //------------------------------------------------------------------------
299 G4double G4ParameterisationBoxZ::GetMaxParamet 308 G4double G4ParameterisationBoxZ::GetMaxParameter() const
300 { 309 {
301 auto msol = (G4Box*)(fmotherSolid); << 310 G4Box* msol = (G4Box*)(fmotherSolid);
302 return 2*msol->GetZHalfLength(); 311 return 2*msol->GetZHalfLength();
303 } 312 }
304 313
305 //-------------------------------------------- 314 //------------------------------------------------------------------------
306 void 315 void
307 G4ParameterisationBoxZ:: 316 G4ParameterisationBoxZ::
308 ComputeTransformation( const G4int copyNo, G4V 317 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
309 { 318 {
310 auto msol = (G4Box*)(fmotherSolid ); << 319 G4Box* msol = (G4Box*)(fmotherSolid );
311 G4double mdz = msol->GetZHalfLength(); 320 G4double mdz = msol->GetZHalfLength();
312 321
313 //----- translation 322 //----- translation
314 G4ThreeVector origin(0.,0.,0.); 323 G4ThreeVector origin(0.,0.,0.);
315 G4double posi = -mdz + OffsetZ() + (copyNo+0 324 G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
316 325
317 if( faxis == kZAxis ) 326 if( faxis == kZAxis )
318 { 327 {
319 origin.setZ( posi ); 328 origin.setZ( posi );
320 } 329 }
321 else 330 else
322 { 331 {
323 std::ostringstream message; <<
324 message << "Only axes along Z are allowed <<
325 G4Exception("G4ParameterisationBoxZ::Compu 332 G4Exception("G4ParameterisationBoxZ::ComputeTransformation()",
326 "GeomDiv0002", FatalException, << 333 "IllegalConstruct", FatalException,
>> 334 "Only axes along Z are allowed ! Axis: "+faxis);
327 } 335 }
328 #ifdef G4DIVDEBUG 336 #ifdef G4DIVDEBUG
329 if( verbose >= 2 ) 337 if( verbose >= 2 )
330 { 338 {
331 G4cout << std::setprecision(8) << " G4Para 339 G4cout << std::setprecision(8) << " G4ParameterisationBoxZ: "
332 << copyNo << G4endl 340 << copyNo << G4endl
333 << " Position " << origin << " Axis 341 << " Position " << origin << " Axis " << faxis << G4endl;
334 } 342 }
335 #endif 343 #endif
336 //----- set translation 344 //----- set translation
337 physVol->SetTranslation( origin ); 345 physVol->SetTranslation( origin );
338 } 346 }
339 347
340 //-------------------------------------------- 348 //------------------------------------------------------------------------
341 void 349 void
342 G4ParameterisationBoxZ:: 350 G4ParameterisationBoxZ::
343 ComputeDimensions( G4Box& box, const G4int, 351 ComputeDimensions( G4Box& box, const G4int,
344 const G4VPhysicalVolume* ) 352 const G4VPhysicalVolume* ) const
345 { 353 {
346 auto msol = (G4Box*)(fmotherSolid); << 354 G4Box* msol = (G4Box*)(fmotherSolid);
347 355
348 G4double pDx = msol->GetXHalfLength(); 356 G4double pDx = msol->GetXHalfLength();
349 G4double pDy = msol->GetYHalfLength(); 357 G4double pDy = msol->GetYHalfLength();
350 G4double pDz = fwidth/2. - fhgap; << 358 G4double pDz = fwidth/2.;
351 359
352 box.SetXHalfLength( pDx ); 360 box.SetXHalfLength( pDx );
353 box.SetYHalfLength( pDy ); 361 box.SetYHalfLength( pDy );
354 box.SetZHalfLength( pDz ); 362 box.SetZHalfLength( pDz );
355 363
356 #ifdef G4DIVDEBUG 364 #ifdef G4DIVDEBUG
357 if( verbose >= 2 ) 365 if( verbose >= 2 )
358 { 366 {
359 G4cout << " G4ParameterisationBoxZ::Comput 367 G4cout << " G4ParameterisationBoxZ::ComputeDimensions()" << G4endl
360 << " pDx: " << pDz << G4endl; 368 << " pDx: " << pDz << G4endl;
361 box.DumpInfo(); 369 box.DumpInfo();
362 } 370 }
363 #endif 371 #endif
364 } 372 }
>> 373
365 374