Geant4  9.6.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ParameterisationBox.cc
Go to the documentation of this file.
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 69784 2013-05-15 09:16:06Z gcosmo $
28 //
29 // class G4ParameterisationBox Implementation file
30 //
31 // 26.05.03 - P.Arce, Initial version
32 // 08.04.04 - I.Hrivnacova, Implemented reflection
33 // 21.04.10 - M.Asai, Added gaps
34 // --------------------------------------------------------------------
35 
36 #include "G4ParameterisationBox.hh"
37 
38 #include <iomanip>
39 #include "G4ThreeVector.hh"
40 #include "G4Transform3D.hh"
41 #include "G4RotationMatrix.hh"
42 #include "G4VPhysicalVolume.hh"
43 #include "G4ReflectedSolid.hh"
44 #include "G4Box.hh"
45 
46 //--------------------------------------------------------------------------
47 G4VParameterisationBox::
48 G4VParameterisationBox( EAxis axis, G4int nDiv, G4double width,
49  G4double offset, G4VSolid* msolid,
50  DivisionType divType )
51  : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
52 {
53  G4Box* msol = (G4Box*)(msolid);
54  if (msolid->GetEntityType() == "G4ReflectedSolid")
55  {
56  // Get constituent solid
57  G4VSolid* mConstituentSolid
58  = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
59  msol = (G4Box*)(mConstituentSolid);
60  fmotherSolid = msol;
61  fReflectedSolid = true;
62  }
63 }
64 
65 //--------------------------------------------------------------------------
66 G4VParameterisationBox::~G4VParameterisationBox()
67 {
68 }
69 
70 //--------------------------------------------------------------------------
71 G4ParameterisationBoxX::
72 G4ParameterisationBoxX( EAxis axis, G4int nDiv, G4double width,
73  G4double offset, G4VSolid* msolid,
74  DivisionType divType )
75  : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
76 {
77  CheckParametersValidity();
78  SetType( "DivisionBoxX" );
79 
80  G4Box* mbox = (G4Box*)(fmotherSolid);
81  if( divType == DivWIDTH )
82  {
83  fnDiv = CalculateNDiv( 2*mbox->GetXHalfLength(), width, offset );
84  }
85  else if( divType == DivNDIV )
86  {
87  fwidth = CalculateWidth( 2*mbox->GetXHalfLength(), nDiv, offset );
88  }
89 #ifdef G4DIVDEBUG
90  if( verbose >= 1 )
91  {
92  G4cout << " G4ParameterisationBoxX - no divisions "
93  << fnDiv << " = " << nDiv << G4endl
94  << " Offset " << foffset << " = " << offset << G4endl
95  << " Width " << fwidth << " = " << width << G4endl;
96  }
97 #endif
98 }
99 
100 //------------------------------------------------------------------------
101 G4ParameterisationBoxX::~G4ParameterisationBoxX()
102 {
103 }
104 
105 //------------------------------------------------------------------------
106 G4double G4ParameterisationBoxX::GetMaxParameter() const
107 {
108  G4Box* msol = (G4Box*)(fmotherSolid);
109  return 2*msol->GetXHalfLength();
110 }
111 
112 //------------------------------------------------------------------------
113 void
114 G4ParameterisationBoxX::
115 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
116 {
117  G4Box* msol = (G4Box*)(fmotherSolid );
118  G4double mdx = msol->GetXHalfLength( );
119 
120  //----- translation
121  G4ThreeVector origin(0.,0.,0.);
122  G4double posi = -mdx + foffset+(copyNo+0.5)*fwidth;
123 
124  if( faxis == kXAxis )
125  {
126  origin.setX( posi );
127  }
128  else
129  {
130  std::ostringstream message;
131  message << "Only axes along X are allowed ! Axis: " << faxis;
132  G4Exception("G4ParameterisationBoxX::ComputeTransformation()",
133  "GeomDiv0002", FatalException, message);
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 //------------------------------------------------------------------------
148 void
149 G4ParameterisationBoxX::
150 ComputeDimensions( 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 //------------------------------------------------------------------------
174 G4ParameterisationBoxY::
175 G4ParameterisationBoxY( 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 //------------------------------------------------------------------------
204 G4ParameterisationBoxY::~G4ParameterisationBoxY()
205 {
206 }
207 
208 //------------------------------------------------------------------------
209 G4double G4ParameterisationBoxY::GetMaxParameter() const
210 {
211  G4Box* msol = (G4Box*)(fmotherSolid);
212  return 2*msol->GetYHalfLength();
213 }
214 
215 //------------------------------------------------------------------------
216 void
217 G4ParameterisationBoxY::
218 ComputeTransformation( 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  std::ostringstream message;
233  message << "Only axes along Y are allowed ! Axis: " << faxis;
234  G4Exception("G4ParameterisationBoxY::ComputeTransformation()",
235  "GeomDiv0002", FatalException, message);
236  }
237 #ifdef G4DIVDEBUG
238  if( verbose >= 2 )
239  {
240  G4cout << std::setprecision(8) << " G4ParameterisationBoxY: "
241  << copyNo << G4endl
242  << " Position " << origin << " Axis " << faxis << G4endl;
243  }
244 #endif
245  //----- set translation
246  physVol->SetTranslation( origin );
247 }
248 
249 //------------------------------------------------------------------------
250 void
251 G4ParameterisationBoxY::
252 ComputeDimensions( G4Box& box, const G4int,
253  const G4VPhysicalVolume* ) const
254 {
255  G4Box* msol = (G4Box*)(fmotherSolid);
256 
257  G4double pDx = msol->GetXHalfLength();
258  G4double pDy = fwidth/2. - fhgap;
259  G4double pDz = msol->GetZHalfLength();
260 
261  box.SetXHalfLength( pDx );
262  box.SetYHalfLength( pDy );
263  box.SetZHalfLength( pDz );
264 
265 #ifdef G4DIVDEBUG
266  if( verbose >= 2 )
267  {
268  G4cout << " G4ParameterisationBoxY::ComputeDimensions()" << G4endl
269  << " pDx: " << pDz << G4endl;
270  box.DumpInfo();
271  }
272 #endif
273 }
274 
275 //------------------------------------------------------------------------
276 G4ParameterisationBoxZ::
277 G4ParameterisationBoxZ( EAxis axis, G4int nDiv, G4double width,
278  G4double offset, G4VSolid* msolid,
279  DivisionType divType )
280  : G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
281 {
282  CheckParametersValidity();
283  SetType( "DivisionBoxZ" );
284 
285  G4Box* mbox = (G4Box*)(fmotherSolid);
286  if( divType == DivWIDTH )
287  {
288  fnDiv = CalculateNDiv( 2*mbox->GetZHalfLength(), width, offset );
289  }
290  else if ( divType == DivNDIV )
291  {
292  fwidth = CalculateWidth( 2*mbox->GetZHalfLength(), nDiv, offset );
293  }
294 #ifdef G4DIVDEBUG
295  if( verbose >= 1 )
296  {
297  G4cout << " G4ParameterisationBoxZ - no divisions " << fnDiv << " = "
298  << nDiv << ". Offset " << foffset << " = " << offset
299  << ". Width " << fwidth << " = " << width << G4endl;
300  }
301 #endif
302 }
303 
304 //------------------------------------------------------------------------
305 G4ParameterisationBoxZ::~G4ParameterisationBoxZ()
306 {
307 }
308 
309 //------------------------------------------------------------------------
310 G4double G4ParameterisationBoxZ::GetMaxParameter() const
311 {
312  G4Box* msol = (G4Box*)(fmotherSolid);
313  return 2*msol->GetZHalfLength();
314 }
315 
316 //------------------------------------------------------------------------
317 void
318 G4ParameterisationBoxZ::
319 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
320 {
321  G4Box* msol = (G4Box*)(fmotherSolid );
322  G4double mdz = msol->GetZHalfLength();
323 
324  //----- translation
325  G4ThreeVector origin(0.,0.,0.);
326  G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
327 
328  if( faxis == kZAxis )
329  {
330  origin.setZ( posi );
331  }
332  else
333  {
334  std::ostringstream message;
335  message << "Only axes along Z are allowed ! Axis: " << faxis;
336  G4Exception("G4ParameterisationBoxZ::ComputeTransformation()",
337  "GeomDiv0002", FatalException, message);
338  }
339 #ifdef G4DIVDEBUG
340  if( verbose >= 2 )
341  {
342  G4cout << std::setprecision(8) << " G4ParameterisationBoxZ: "
343  << copyNo << G4endl
344  << " Position " << origin << " Axis " << faxis << G4endl;
345  }
346 #endif
347  //----- set translation
348  physVol->SetTranslation( origin );
349 }
350 
351 //------------------------------------------------------------------------
352 void
353 G4ParameterisationBoxZ::
354 ComputeDimensions( G4Box& box, const G4int,
355  const G4VPhysicalVolume* ) const
356 {
357  G4Box* msol = (G4Box*)(fmotherSolid);
358 
359  G4double pDx = msol->GetXHalfLength();
360  G4double pDy = msol->GetYHalfLength();
361  G4double pDz = fwidth/2. - fhgap;
362 
363  box.SetXHalfLength( pDx );
364  box.SetYHalfLength( pDy );
365  box.SetZHalfLength( pDz );
366 
367 #ifdef G4DIVDEBUG
368  if( verbose >= 2 )
369  {
370  G4cout << " G4ParameterisationBoxZ::ComputeDimensions()" << G4endl
371  << " pDx: " << pDz << G4endl;
372  box.DumpInfo();
373  }
374 #endif
375 }
376 
Generated on Sat May 25 2013 14:33:09 for Geant4 by   doxygen 1.8.4