source: trunk/source/geometry/divisions/src/G4ParameterisationBox.cc@ 1350

Last change on this file since 1350 was 1347, checked in by garnier, 15 years ago

geant4 tag 9.4
File size: 11.3 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4ParameterisationBox.cc,v 1.12 2010/11/10 09:15:56 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-04-ref-00 $
29//
30// class G4ParameterisationBox Implementation file
31//
32// 26.05.03 - P.Arce, Initial version
33// 08.04.04 - I.Hrivnacova, Implemented reflection
34// 21.04.10 - M.Asai, Added gaps
35// --------------------------------------------------------------------
36
37#include "G4ParameterisationBox.hh"
38
39#include <iomanip>
40#include "G4ThreeVector.hh"
41#include "G4Transform3D.hh"
42#include "G4RotationMatrix.hh"
43#include "G4VPhysicalVolume.hh"
44#include "G4ReflectedSolid.hh"
45#include "G4Box.hh"
46
47//--------------------------------------------------------------------------
48G4VParameterisationBox::
49G4VParameterisationBox( EAxis axis, G4int nDiv, G4double width,
50 G4double offset, G4VSolid* msolid,
51 DivisionType divType )
52 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
53{
54 G4Box* msol = (G4Box*)(msolid);
55 if (msolid->GetEntityType() == "G4ReflectedSolid")
56 {
57 // Get constituent solid
58 G4VSolid* mConstituentSolid
59 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
60 msol = (G4Box*)(mConstituentSolid);
61 fmotherSolid = msol;
62 fReflectedSolid = true;
63 }
64}
65
66//--------------------------------------------------------------------------
67G4VParameterisationBox::~G4VParameterisationBox()
68{
69}
70
71//--------------------------------------------------------------------------
72G4ParameterisationBoxX::
73G4ParameterisationBoxX( EAxis axis, G4int nDiv, G4double width,
74 G4double offset, G4VSolid* msolid,
75 DivisionType divType )
76 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
77{
78 CheckParametersValidity();
79 SetType( "DivisionBoxX" );
80
81 G4Box* mbox = (G4Box*)(fmotherSolid);
82 if( divType == DivWIDTH )
83 {
84 fnDiv = CalculateNDiv( 2*mbox->GetXHalfLength(), width, offset );
85 }
86 else if( divType == DivNDIV )
87 {
88 fwidth = CalculateWidth( 2*mbox->GetXHalfLength(), nDiv, offset );
89 }
90#ifdef G4DIVDEBUG
91 if( verbose >= 1 )
92 {
93 G4cout << " G4ParameterisationBoxX - no divisions "
94 << fnDiv << " = " << nDiv << G4endl
95 << " Offset " << foffset << " = " << offset << G4endl
96 << " Width " << fwidth << " = " << width << G4endl;
97 }
98#endif
99}
100
101//------------------------------------------------------------------------
102G4ParameterisationBoxX::~G4ParameterisationBoxX()
103{
104}
105
106//------------------------------------------------------------------------
107G4double G4ParameterisationBoxX::GetMaxParameter() const
108{
109 G4Box* msol = (G4Box*)(fmotherSolid);
110 return 2*msol->GetXHalfLength();
111}
112
113//------------------------------------------------------------------------
114void
115G4ParameterisationBoxX::
116ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
117{
118 G4Box* msol = (G4Box*)(fmotherSolid );
119 G4double mdx = msol->GetXHalfLength( );
120
121 //----- translation
122 G4ThreeVector origin(0.,0.,0.);
123 G4double posi = -mdx + foffset+(copyNo+0.5)*fwidth;
124
125 if( faxis == kXAxis )
126 {
127 origin.setX( posi );
128 }
129 else
130 {
131 G4Exception("G4ParameterisationBoxX::ComputeTransformation()",
132 "IllegalConstruct", FatalException,
133 "Only axes along X are allowed ! Axis: "+faxis);
134 }
135#ifdef G4DIVDEBUG
136 if( verbose >= 2 )
137 {
138 G4cout << std::setprecision(8) << " G4ParameterisationBoxX: "
139 << copyNo << G4endl
140 << " Position " << origin << " Axis " << faxis << G4endl;
141 }
142#endif
143 //----- set translation
144 physVol->SetTranslation( origin );
145}
146
147//------------------------------------------------------------------------
148void
149G4ParameterisationBoxX::
150ComputeDimensions( G4Box& box, const G4int,
151 const G4VPhysicalVolume* ) const
152{
153 G4Box* msol = (G4Box*)(fmotherSolid);
154
155 G4double pDx = fwidth/2. - fhgap;
156 G4double pDy = msol->GetYHalfLength();
157 G4double pDz = msol->GetZHalfLength();
158
159 box.SetXHalfLength( pDx );
160 box.SetYHalfLength( pDy );
161 box.SetZHalfLength( pDz );
162
163#ifdef G4DIVDEBUG
164 if( verbose >= 2 )
165 {
166 G4cout << " G4ParameterisationBoxX::ComputeDimensions()" << G4endl
167 << " pDx: " << pDz << G4endl;
168 box.DumpInfo();
169 }
170#endif
171}
172
173//------------------------------------------------------------------------
174G4ParameterisationBoxY::
175G4ParameterisationBoxY( EAxis axis, G4int nDiv, G4double width,
176 G4double offset, G4VSolid* msolid,
177 DivisionType divType)
178 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
179{
180 CheckParametersValidity();
181 SetType( "DivisionBoxY" );
182
183 G4Box* mbox = (G4Box*)(fmotherSolid);
184 if( divType == DivWIDTH )
185 {
186 fnDiv = CalculateNDiv( 2*mbox->GetYHalfLength(), width, offset );
187 }
188 else if( divType == DivNDIV )
189 {
190 fwidth = CalculateWidth( 2*mbox->GetYHalfLength(), nDiv, offset );
191 }
192
193#ifdef G4DIVDEBUG
194 if( verbose >= 1 )
195 {
196 G4cout << " G4ParameterisationBoxY - no divisions " << fnDiv << " = "
197 << nDiv << ". Offset " << foffset << " = " << offset
198 << ". Width " << fwidth << " = " << width << G4endl;
199 }
200#endif
201}
202
203//------------------------------------------------------------------------
204G4ParameterisationBoxY::~G4ParameterisationBoxY()
205{
206}
207
208//------------------------------------------------------------------------
209G4double G4ParameterisationBoxY::GetMaxParameter() const
210{
211 G4Box* msol = (G4Box*)(fmotherSolid);
212 return 2*msol->GetYHalfLength();
213}
214
215//------------------------------------------------------------------------
216void
217G4ParameterisationBoxY::
218ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
219{
220 G4Box* msol = (G4Box*)(fmotherSolid);
221 G4double mdy = msol->GetYHalfLength();
222
223 //----- translation
224 G4ThreeVector origin(0.,0.,0.);
225 G4double posi = -mdy + foffset + (copyNo+0.5)*fwidth;
226 if( faxis == kYAxis )
227 {
228 origin.setY( posi );
229 }
230 else
231 {
232 G4Exception("G4ParameterisationBoxY::ComputeTransformation()",
233 "IllegalConstruct", FatalException,
234 "Only axes along Y are allowed ! Axis: "+faxis);
235 }
236#ifdef G4DIVDEBUG
237 if( verbose >= 2 )
238 {
239 G4cout << std::setprecision(8) << " G4ParameterisationBoxY: "
240 << copyNo << G4endl
241 << " Position " << origin << " Axis " << faxis << G4endl;
242 }
243#endif
244 //----- set translation
245 physVol->SetTranslation( origin );
246}
247
248//------------------------------------------------------------------------
249void
250G4ParameterisationBoxY::
251ComputeDimensions( G4Box& box, const G4int,
252 const G4VPhysicalVolume* ) const
253{
254 G4Box* msol = (G4Box*)(fmotherSolid);
255
256 G4double pDx = msol->GetXHalfLength();
257 G4double pDy = fwidth/2. - fhgap;
258 G4double pDz = msol->GetZHalfLength();
259
260 box.SetXHalfLength( pDx );
261 box.SetYHalfLength( pDy );
262 box.SetZHalfLength( pDz );
263
264#ifdef G4DIVDEBUG
265 if( verbose >= 2 )
266 {
267 G4cout << " G4ParameterisationBoxY::ComputeDimensions()" << G4endl
268 << " pDx: " << pDz << G4endl;
269 box.DumpInfo();
270 }
271#endif
272}
273
274//------------------------------------------------------------------------
275G4ParameterisationBoxZ::
276G4ParameterisationBoxZ( EAxis axis, G4int nDiv, G4double width,
277 G4double offset, G4VSolid* msolid,
278 DivisionType divType )
279 : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
280{
281 CheckParametersValidity();
282 SetType( "DivisionBoxZ" );
283
284 G4Box* mbox = (G4Box*)(fmotherSolid);
285 if( divType == DivWIDTH )
286 {
287 fnDiv = CalculateNDiv( 2*mbox->GetZHalfLength(), width, offset );
288 }
289 else if ( divType == DivNDIV )
290 {
291 fwidth = CalculateWidth( 2*mbox->GetZHalfLength(), nDiv, offset );
292 }
293#ifdef G4DIVDEBUG
294 if( verbose >= 1 )
295 {
296 G4cout << " G4ParameterisationBoxZ - no divisions " << fnDiv << " = "
297 << nDiv << ". Offset " << foffset << " = " << offset
298 << ". Width " << fwidth << " = " << width << G4endl;
299 }
300#endif
301}
302
303//------------------------------------------------------------------------
304G4ParameterisationBoxZ::~G4ParameterisationBoxZ()
305{
306}
307
308//------------------------------------------------------------------------
309G4double G4ParameterisationBoxZ::GetMaxParameter() const
310{
311 G4Box* msol = (G4Box*)(fmotherSolid);
312 return 2*msol->GetZHalfLength();
313}
314
315//------------------------------------------------------------------------
316void
317G4ParameterisationBoxZ::
318ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
319{
320 G4Box* msol = (G4Box*)(fmotherSolid );
321 G4double mdz = msol->GetZHalfLength();
322
323 //----- translation
324 G4ThreeVector origin(0.,0.,0.);
325 G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
326
327 if( faxis == kZAxis )
328 {
329 origin.setZ( posi );
330 }
331 else
332 {
333 G4Exception("G4ParameterisationBoxZ::ComputeTransformation()",
334 "IllegalConstruct", FatalException,
335 "Only axes along Z are allowed ! Axis: "+faxis);
336 }
337#ifdef G4DIVDEBUG
338 if( verbose >= 2 )
339 {
340 G4cout << std::setprecision(8) << " G4ParameterisationBoxZ: "
341 << copyNo << G4endl
342 << " Position " << origin << " Axis " << faxis << G4endl;
343 }
344#endif
345 //----- set translation
346 physVol->SetTranslation( origin );
347}
348
349//------------------------------------------------------------------------
350void
351G4ParameterisationBoxZ::
352ComputeDimensions( G4Box& box, const G4int,
353 const G4VPhysicalVolume* ) const
354{
355 G4Box* msol = (G4Box*)(fmotherSolid);
356
357 G4double pDx = msol->GetXHalfLength();
358 G4double pDy = msol->GetYHalfLength();
359 G4double pDz = fwidth/2. - fhgap;
360
361 box.SetXHalfLength( pDx );
362 box.SetYHalfLength( pDy );
363 box.SetZHalfLength( pDz );
364
365#ifdef G4DIVDEBUG
366 if( verbose >= 2 )
367 {
368 G4cout << " G4ParameterisationBoxZ::ComputeDimensions()" << G4endl
369 << " pDx: " << pDz << G4endl;
370 box.DumpInfo();
371 }
372#endif
373}
374
Note: See TracBrowser for help on using the repository browser.