source: trunk/source/geometry/divisions/src/G4ParameterisationTrd.cc@ 833

Last change on this file since 833 was 831, checked in by garnier, 17 years ago

import all except CVS
File size: 14.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: G4ParameterisationTrd.cc,v 1.14 2006/06/29 18:18:48 gunter Exp $
28// GEANT4 tag $Name: $
29//
30// class G4ParameterisationTrd Implementation file
31//
32// 26.05.03 - P.Arce, Initial version
33// 08.04.04 - I.Hrivnacova, Implemented reflection
34// --------------------------------------------------------------------
35
36#include "G4ParameterisationTrd.hh"
37
38#include <iomanip>
39#include "G4ThreeVector.hh"
40#include "G4RotationMatrix.hh"
41#include "G4VPhysicalVolume.hh"
42#include "G4LogicalVolume.hh"
43#include "G4ReflectedSolid.hh"
44#include "G4Trd.hh"
45#include "G4Trap.hh"
46
47//--------------------------------------------------------------------------
48G4VParameterisationTrd::
49G4VParameterisationTrd( EAxis axis, G4int nDiv, G4double width,
50 G4double offset, G4VSolid* msolid,
51 DivisionType divType )
52 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
53{
54 G4Trd* msol = (G4Trd*)(msolid);
55 if (msolid->GetEntityType() == "G4ReflectedSolid")
56 {
57 // Get constituent solid
58 G4VSolid* mConstituentSolid
59 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
60 msol = (G4Trd*)(mConstituentSolid);
61
62 // Create a new solid with inversed parameters
63 G4Trd* newSolid
64 = new G4Trd(msol->GetName(),
65 msol->GetXHalfLength2(), msol->GetXHalfLength1(),
66 msol->GetYHalfLength2(), msol->GetYHalfLength1(),
67 msol->GetZHalfLength());
68 msol = newSolid;
69 fmotherSolid = newSolid;
70 fReflectedSolid = true;
71 fDeleteSolid = true;
72 }
73}
74
75//------------------------------------------------------------------------
76G4VParameterisationTrd::~G4VParameterisationTrd()
77{
78}
79
80//------------------------------------------------------------------------
81G4ParameterisationTrdX::
82G4ParameterisationTrdX( EAxis axis, G4int nDiv,
83 G4double width, G4double offset,
84 G4VSolid* msolid, DivisionType divType )
85 : G4VParameterisationTrd( axis, nDiv, width, offset, msolid, divType )
86{
87 CheckParametersValidity();
88 SetType( "DivisionTrdX" );
89
90 G4Trd* msol = (G4Trd*)(fmotherSolid);
91 if( divType == DivWIDTH )
92 {
93 fnDiv = CalculateNDiv( 2*msol->GetXHalfLength1(),
94 width, offset );
95 }
96 else if( divType == DivNDIV )
97 {
98 fwidth = CalculateWidth( 2*msol->GetXHalfLength1(), nDiv, offset );
99 }
100
101#ifdef G4DIVDEBUG
102 if( verbose >= -1 )
103 {
104 G4cout << " G4ParameterisationTrdX - ## divisions " << fnDiv << " = "
105 << nDiv << G4endl
106 << " Offset " << foffset << " = " << offset << G4endl
107 << " Width " << fwidth << " = " << width << G4endl;
108 }
109#endif
110}
111
112//------------------------------------------------------------------------
113G4ParameterisationTrdX::~G4ParameterisationTrdX()
114{
115}
116
117//------------------------------------------------------------------------
118G4double G4ParameterisationTrdX::GetMaxParameter() const
119{
120 G4Trd* msol = (G4Trd*)(fmotherSolid);
121 return 2*msol->GetXHalfLength1();
122}
123
124//------------------------------------------------------------------------
125void
126G4ParameterisationTrdX::
127ComputeTransformation( const G4int copyNo,
128 G4VPhysicalVolume *physVol ) const
129{
130 G4Trd* msol = (G4Trd*)(fmotherSolid );
131 G4double mdx = msol->GetXHalfLength1();
132
133 //----- translation
134 G4ThreeVector origin(0.,0.,0.);
135 G4double posi = -mdx + foffset + (copyNo+0.5)*fwidth;
136 if( faxis == kXAxis )
137 {
138 origin.setX( posi );
139 }
140 else
141 {
142 G4Exception("G4ParameterisationTrdX::ComputeTransformation()",
143 "IllegalConstruct", FatalException,
144 "Only axes along X are allowed, and axis is: "+faxis);
145 }
146
147#ifdef G4DIVDEBUG
148 if( verbose >= -2 )
149 {
150 G4cout << std::setprecision(8) << " G4ParameterisationTrdX: "
151 << copyNo << G4endl
152 << " Position: " << origin << " - Axis: " << faxis << G4endl;
153 }
154#endif
155
156 //----- set translation
157 physVol->SetTranslation( origin );
158}
159
160//--------------------------------------------------------------------------
161void
162G4ParameterisationTrdX::
163ComputeDimensions( G4Trd& trd, const G4int, const G4VPhysicalVolume* ) const
164{
165 G4Trd* msol = (G4Trd*)(fmotherSolid);
166
167 G4double pDy1 = msol->GetYHalfLength1();
168 G4double pDy2 = msol->GetYHalfLength2();
169 G4double pDz = msol->GetZHalfLength();
170 G4double pDx = fwidth/2.;
171
172 trd.SetAllParameters ( pDx, pDx, pDy1, pDy2, pDz );
173
174#ifdef G4DIVDEBUG
175 if( verbose >= -2 )
176 {
177 G4cout << " G4ParameterisationTrdX::ComputeDimensions():" << G4endl;
178 trd.DumpInfo();
179 }
180#endif
181}
182
183//--------------------------------------------------------------------------
184void G4ParameterisationTrdX::CheckParametersValidity()
185{
186 G4VDivisionParameterisation::CheckParametersValidity();
187
188 G4Trd* msol = (G4Trd*)(fmotherSolid);
189
190 G4double mpDx1 = msol->GetXHalfLength1();
191 G4double mpDx2 = msol->GetXHalfLength2();
192
193 if( std::fabs(mpDx1 - mpDx2) > kCarTolerance )
194 {
195 G4cerr << "ERROR - G4ParameterisationTrdX::CheckParametersValidity()"
196 << G4endl
197 << " Making a division of a TRD along axis X," << G4endl
198 << " while the X half lengths are not equal," << G4endl
199 << " is not (yet) supported. It will result" << G4endl
200 << " in non-equal division solids." << G4endl;
201 G4Exception("G4ParameterisationTrdX::CheckParametersValidity()",
202 "IllegalConstruct", FatalException,
203 "Invalid solid specification. NOT supported.");
204 }
205}
206
207//--------------------------------------------------------------------------
208G4ParameterisationTrdY::
209G4ParameterisationTrdY( EAxis axis, G4int nDiv,
210 G4double width, G4double offset,
211 G4VSolid* msolid, DivisionType divType)
212 : G4VParameterisationTrd( axis, nDiv, width, offset, msolid, divType )
213{
214 CheckParametersValidity();
215 SetType( "DivisionTrdY" );
216
217 G4Trd* msol = (G4Trd*)(fmotherSolid);
218 if( divType == DivWIDTH )
219 {
220 fnDiv = CalculateNDiv( 2*msol->GetYHalfLength1(),
221 width, offset );
222 }
223 else if( divType == DivNDIV )
224 {
225 fwidth = CalculateWidth( 2*msol->GetYHalfLength1(),
226 nDiv, offset );
227 }
228
229#ifdef G4DIVDEBUG
230 if( verbose >= 1 )
231 {
232 G4cout << " G4ParameterisationTrdY no divisions " << fnDiv
233 << " = " << nDiv << G4endl
234 << " Offset " << foffset << " = " << offset << G4endl
235 << " width " << fwidth << " = " << width << G4endl;
236 }
237#endif
238}
239
240//------------------------------------------------------------------------
241G4ParameterisationTrdY::~G4ParameterisationTrdY()
242{
243}
244
245//------------------------------------------------------------------------
246G4double G4ParameterisationTrdY::GetMaxParameter() const
247{
248 G4Trd* msol = (G4Trd*)(fmotherSolid);
249 return 2*msol->GetYHalfLength1();
250}
251
252//--------------------------------------------------------------------------
253void
254G4ParameterisationTrdY::
255ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
256{
257 G4Trd* msol = (G4Trd*)(fmotherSolid );
258 G4double mdy = msol->GetYHalfLength1();
259
260 //----- translation
261 G4ThreeVector origin(0.,0.,0.);
262 G4double posi = -mdy + foffset + (copyNo+0.5)*fwidth;
263 if( faxis == kYAxis )
264 {
265 origin.setY( posi );
266 }
267 else
268 {
269 G4Exception("G4ParameterisationTrdY::ComputeTransformation()",
270 "IllegalConstruct", FatalException,
271 "Only axes along Y are allowed !");
272 }
273
274#ifdef G4DIVDEBUG
275 if( verbose >= 2 )
276 {
277 G4cout << std::setprecision(8) << " G4ParameterisationTrdY " << copyNo
278 << " pos " << origin << " rot mat " << " axis " << faxis << G4endl;
279 }
280#endif
281
282 //----- set translation
283 physVol->SetTranslation( origin );
284}
285
286//--------------------------------------------------------------------------
287void
288G4ParameterisationTrdY::
289ComputeDimensions(G4Trd& trd, const G4int, const G4VPhysicalVolume*) const
290{
291 //---- The division along Y of a Trd will result a Trd, only
292 //--- if Y at -Z and +Z are equal, else use the G4Trap version
293 G4Trd* msol = (G4Trd*)(fmotherSolid);
294
295 G4double pDx1 = msol->GetXHalfLength1();
296 G4double pDx2 = msol->GetXHalfLength2();
297 G4double pDz = msol->GetZHalfLength();
298 G4double pDy = fwidth/2.;
299
300 trd.SetAllParameters ( pDx1, pDx2, pDy, pDy, pDz );
301
302#ifdef G4DIVDEBUG
303 if( verbose >= 2 )
304 {
305 G4cout << " G4ParameterisationTrdY::ComputeDimensions():" << G4endl;
306 trd.DumpInfo();
307 }
308#endif
309}
310
311//--------------------------------------------------------------------------
312void G4ParameterisationTrdY::CheckParametersValidity()
313{
314 G4VDivisionParameterisation::CheckParametersValidity();
315
316 G4Trd* msol = (G4Trd*)(fmotherSolid);
317
318 G4double mpDy1 = msol->GetYHalfLength1();
319 G4double mpDy2 = msol->GetYHalfLength2();
320
321 if( std::fabs(mpDy1 - mpDy2) > kCarTolerance )
322 {
323 G4cerr << "ERROR - G4ParameterisationTrdY::CheckParametersValidity()"
324 << G4endl
325 << " Making a division of a TRD along axis Y while" << G4endl
326 << " the Y half lengths are not equal is not (yet)" << G4endl
327 << " supported. It will result in non-equal" << G4endl
328 << " division solids." << G4endl;
329 G4Exception("G4ParameterisationTrdY::CheckParametersValidity()",
330 "IllegalConstruct", FatalException,
331 "Invalid solid specification. NOT supported.");
332 }
333}
334
335//--------------------------------------------------------------------------
336G4ParameterisationTrdZ::
337G4ParameterisationTrdZ( EAxis axis, G4int nDiv,
338 G4double width, G4double offset,
339 G4VSolid* msolid, DivisionType divType )
340 : G4VParameterisationTrd( axis, nDiv, width, offset, msolid, divType )
341{
342 CheckParametersValidity();
343 SetType( "DivTrdZ" );
344
345 G4Trd* msol = (G4Trd*)(fmotherSolid);
346 if( divType == DivWIDTH )
347 {
348 fnDiv = CalculateNDiv( 2*msol->GetZHalfLength(),
349 width, offset );
350 }
351 else if( divType == DivNDIV )
352 {
353 fwidth = CalculateWidth( 2*msol->GetZHalfLength(),
354 nDiv, offset );
355 }
356
357#ifdef G4DIVDEBUG
358 if( verbose >= 1 )
359 {
360 G4cout << " G4ParameterisationTrdZ no divisions " << fnDiv
361 << " = " << nDiv << G4endl
362 << " Offset " << foffset << " = " << offset << G4endl
363 << " Width " << fwidth << " = " << width << G4endl;
364 }
365#endif
366}
367
368//------------------------------------------------------------------------
369G4ParameterisationTrdZ::~G4ParameterisationTrdZ()
370{
371}
372
373//------------------------------------------------------------------------
374G4double G4ParameterisationTrdZ::GetMaxParameter() const
375{
376 G4Trd* msol = (G4Trd*)(fmotherSolid);
377 return 2*msol->GetZHalfLength();
378}
379
380//--------------------------------------------------------------------------
381void
382G4ParameterisationTrdZ::
383ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
384{
385 G4Trd* msol = (G4Trd*)(fmotherSolid );
386 G4double mdz = msol->GetZHalfLength();
387
388 //----- translation
389 G4ThreeVector origin(0.,0.,0.);
390 G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
391 if( faxis == kZAxis )
392 {
393 origin.setZ( posi );
394 }
395 else
396 {
397 G4Exception("G4ParameterisationTrdZ::ComputeTransformation()",
398 "IllegalConstruct", FatalException,
399 "Only axes along Z are allowed !");
400 }
401
402#ifdef G4DIVDEBUG
403 if( verbose >= 1 )
404 {
405 G4cout << std::setprecision(8) << " G4ParameterisationTrdZ: "
406 << copyNo << G4endl
407 << " Position: " << origin << " - Offset: " << foffset
408 << " - Width: " << fwidth << " Axis " << faxis << G4endl;
409 }
410#endif
411
412 //----- set translation
413 physVol->SetTranslation( origin );
414}
415
416//--------------------------------------------------------------------------
417void
418G4ParameterisationTrdZ::
419ComputeDimensions(G4Trd& trd, const G4int copyNo,
420 const G4VPhysicalVolume*) const
421{
422 //---- The division along Z of a Trd will result a Trd
423 G4Trd* msol = (G4Trd*)(fmotherSolid);
424
425 G4double pDx1 = msol->GetXHalfLength1();
426 G4double DDx = (msol->GetXHalfLength2() - msol->GetXHalfLength1() );
427 G4double pDy1 = msol->GetYHalfLength1();
428 G4double DDy = (msol->GetYHalfLength2() - msol->GetYHalfLength1() );
429 G4double pDz = fwidth/2.;
430 G4double zLength = 2*msol->GetZHalfLength();
431
432 trd.SetAllParameters( pDx1+DDx*(OffsetZ()+copyNo*fwidth)/zLength,
433 pDx1+DDx*(OffsetZ()+(copyNo+1)*fwidth)/zLength,
434 pDy1+DDy*(OffsetZ()+copyNo*fwidth)/zLength,
435 pDy1+DDy*(OffsetZ()+(copyNo+1)*fwidth)/zLength, pDz );
436
437#ifdef G4DIVDEBUG
438 if( verbose >= 1 )
439 {
440 G4cout << " G4ParameterisationTrdZ::ComputeDimensions()"
441 << " - Mother TRD " << G4endl;
442 msol->DumpInfo();
443 G4cout << " - Parameterised TRD: "
444 << copyNo << G4endl;
445 trd.DumpInfo();
446 }
447#endif
448}
Note: See TracBrowser for help on using the repository browser.