source: trunk/source/geometry/divisions/src/G4ReplicatedSlice.cc

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

update to last version 4.9.4
File size: 19.0 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: G4ReplicatedSlice.cc,v 1.2 2010/11/10 09:16:18 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-04-ref-00 $
29//
30// --------------------------------------------------------------------
31
32#include "G4ReplicatedSlice.hh"
33#include "G4LogicalVolume.hh"
34#include "G4VSolid.hh"
35#include "G4ReflectedSolid.hh"
36#include "G4ParameterisationBox.hh"
37#include "G4ParameterisationTubs.hh"
38#include "G4ParameterisationCons.hh"
39#include "G4ParameterisationTrd.hh"
40#include "G4ParameterisationPara.hh"
41#include "G4ParameterisationPolycone.hh"
42#include "G4ParameterisationPolyhedra.hh"
43
44//--------------------------------------------------------------------------
45G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
46 G4LogicalVolume* pLogical,
47 G4LogicalVolume* pMotherLogical,
48 const EAxis pAxis,
49 const G4int nDivs,
50 const G4double width,
51 const G4double half_gap,
52 const G4double offset )
53 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
54{
55 CheckAndSetParameters(pAxis, nDivs, width, half_gap, offset,
56 DivNDIVandWIDTH, pMotherLogical, pLogical);
57}
58
59//--------------------------------------------------------------------------
60G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
61 G4LogicalVolume* pLogical,
62 G4LogicalVolume* pMotherLogical,
63 const EAxis pAxis,
64 const G4int nDivs,
65 const G4double half_gap,
66 const G4double offset )
67 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
68{
69 CheckAndSetParameters(pAxis, nDivs, 0., half_gap, offset,
70 DivNDIV, pMotherLogical, pLogical);
71}
72
73//--------------------------------------------------------------------------
74G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
75 G4LogicalVolume* pLogical,
76 G4LogicalVolume* pMotherLogical,
77 const EAxis pAxis,
78 const G4double width,
79 const G4double half_gap,
80 const G4double offset )
81 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
82{
83 CheckAndSetParameters(pAxis, 0, width, half_gap, offset,
84 DivWIDTH, pMotherLogical, pLogical);
85}
86
87//--------------------------------------------------------------------------
88G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
89 G4LogicalVolume* pLogical,
90 G4VPhysicalVolume* pMotherPhysical,
91 const EAxis pAxis,
92 const G4int nDivs,
93 const G4double width,
94 const G4double half_gap,
95 const G4double offset )
96 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
97{
98 CheckAndSetParameters(pAxis, nDivs, width, half_gap, offset,
99 DivNDIVandWIDTH, pMotherPhysical->GetLogicalVolume(), pLogical);
100}
101
102//--------------------------------------------------------------------------
103G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
104 G4LogicalVolume* pLogical,
105 G4VPhysicalVolume* pMotherPhysical,
106 const EAxis pAxis,
107 const G4int nDivs,
108 const G4double half_gap,
109 const G4double offset )
110 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
111{
112 CheckAndSetParameters(pAxis, nDivs, 0., half_gap, offset,
113 DivNDIV, pMotherPhysical->GetLogicalVolume(), pLogical);
114}
115
116//--------------------------------------------------------------------------
117G4ReplicatedSlice::G4ReplicatedSlice(const G4String& pName,
118 G4LogicalVolume* pLogical,
119 G4VPhysicalVolume* pMotherPhysical,
120 const EAxis pAxis,
121 const G4double width,
122 const G4double half_gap,
123 const G4double offset )
124 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0), fcopyNo(-1)
125{
126 CheckAndSetParameters(pAxis, 0, width, half_gap, offset,
127 DivWIDTH, pMotherPhysical->GetLogicalVolume(), pLogical);
128}
129
130//--------------------------------------------------------------------------
131void
132G4ReplicatedSlice::CheckAndSetParameters( const EAxis pAxis,
133 const G4int nDivs,
134 const G4double width,
135 const G4double half_gap,
136 const G4double offset,
137 DivisionType divType,
138 G4LogicalVolume* pMotherLogical,
139 const G4LogicalVolume* pLogical )
140{
141 if(!pMotherLogical)
142 {
143 G4String message_1 = "NULL pointer specified as mother! Volume: "
144 + GetName();
145 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "InvalidSetup",
146 FatalException, message_1);
147 }
148 if(pLogical == pMotherLogical)
149 {
150 G4String message_2 = "Cannot place a volume inside itself! Volume: "
151 + GetName();
152 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "InvalidSetup",
153 FatalException, message_2);
154 }
155
156 //----- Check that mother solid is of the same type as
157 // daughter solid (otherwise, the corresponding
158 // Parameterisation::ComputeDimension() will not be called)
159 //
160 G4String msolType = pMotherLogical->GetSolid()->GetEntityType();
161 G4String dsolType = pLogical->GetSolid()->GetEntityType();
162 if( msolType != dsolType && ( msolType != "G4Trd" || dsolType != "G4Trap" ) )
163 {
164 G4String message = "Incorrect solid type for division of volume "
165 + GetName() + " It is: " + msolType
166 + ", while it should be: " + dsolType;
167 G4Exception("G4ReplicatedSlice::CheckAndSetParameters()",
168 "IllegalConstruct", FatalException, message );
169 }
170
171 pMotherLogical->AddDaughter(this);
172 SetMotherLogical(pMotherLogical);
173 SetParameterisation(pMotherLogical, pAxis, nDivs,
174 width, half_gap, offset, divType);
175
176 if( divType == DivWIDTH )
177 {
178 fnReplicas = fparam->GetNoDiv();
179 }
180 else
181 {
182 fnReplicas = nDivs;
183 }
184 if (fnReplicas < 1 )
185 {
186 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "IllegalConstruct",
187 FatalException, "Illegal number of replicas!");
188 }
189 if( divType != DivNDIV)
190 {
191 fwidth = fparam->GetWidth();
192 }
193 else
194 {
195 fwidth = width;
196 }
197 if( fwidth < 0 )
198 {
199 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "IllegalConstruct",
200 FatalException, "Width must be positive!");
201 }
202 if( fwidth < 2.*half_gap )
203 {
204 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "IllegalConstruct",
205 FatalException, "Half_gap is too large!");
206 }
207
208 foffset = offset;
209 fdivAxis = pAxis;
210
211 //!!!!! axis has to be x/y/z in G4VoxelLimits::GetMinExtent
212 //
213 if( pAxis == kRho || pAxis == kRadial3D || pAxis == kPhi )
214 {
215 faxis = kZAxis;
216 }
217 else
218 {
219 faxis = pAxis;
220 }
221
222 switch (faxis)
223 {
224 case kPhi:
225 case kRho:
226 case kXAxis:
227 case kYAxis:
228 case kZAxis:
229 break;
230 default:
231 G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "IllegalConstruct",
232 FatalException, "Unknown axis of replication.");
233 break;
234 }
235
236 // Create rotation matrix: for phi axis it will be changed
237 // in G4VPVParameterisation::ComputeTransformation, for others
238 // it will stay the unity
239 //
240 G4RotationMatrix *pRMat = new G4RotationMatrix();
241 SetRotation(pRMat);
242}
243
244//--------------------------------------------------------------------------
245G4ReplicatedSlice::~G4ReplicatedSlice()
246{
247 delete GetRotation();
248}
249
250//--------------------------------------------------------------------------
251EAxis G4ReplicatedSlice::GetDivisionAxis() const
252{
253 return fdivAxis;
254}
255
256//--------------------------------------------------------------------------
257G4bool G4ReplicatedSlice::IsParameterised() const
258{
259 return true;
260}
261
262//--------------------------------------------------------------------------
263G4bool G4ReplicatedSlice::IsMany() const
264{
265 return false;
266}
267
268//--------------------------------------------------------------------------
269G4int G4ReplicatedSlice::GetCopyNo() const
270{
271 return fcopyNo;
272}
273
274//--------------------------------------------------------------------------
275void G4ReplicatedSlice::SetCopyNo(G4int newCopyNo)
276{
277 fcopyNo= newCopyNo;
278}
279
280//--------------------------------------------------------------------------
281G4bool G4ReplicatedSlice::IsReplicated() const
282{
283 return true;
284}
285
286//--------------------------------------------------------------------------
287G4VPVParameterisation* G4ReplicatedSlice::GetParameterisation() const
288{
289 return fparam;
290}
291
292//--------------------------------------------------------------------------
293void G4ReplicatedSlice::GetReplicationData(EAxis& axis,
294 G4int& nDivs,
295 G4double& width,
296 G4double& offset,
297 G4bool& consuming ) const
298{
299 axis=faxis;
300 nDivs=fnReplicas;
301 width=fwidth;
302 offset=foffset;
303 consuming=false;
304}
305
306
307//--------------------------------------------------------------------------
308void G4ReplicatedSlice::SetParameterisation( G4LogicalVolume* motherLogical,
309 const EAxis axis,
310 const G4int nDivs,
311 const G4double width,
312 const G4double half_gap,
313 const G4double offset,
314 DivisionType divType )
315{
316 G4VSolid* mSolid = motherLogical->GetSolid();
317 G4String mSolidType = mSolid->GetEntityType();
318
319 // If the solid is a reflected one, update type to its
320 // real constituent solid.
321 //
322 if (mSolidType == "G4ReflectedSolid")
323 {
324 mSolidType = ((G4ReflectedSolid*)mSolid)->GetConstituentMovedSolid()
325 ->GetEntityType();
326 }
327
328 // Parameterisation type depend of mother solid type and axis of division
329 //
330 if( mSolidType == "G4Box" )
331 {
332 switch( axis )
333 {
334 case kXAxis:
335 fparam = new G4ParameterisationBoxX( axis, nDivs, width,
336 offset, mSolid, divType );
337 break;
338 case kYAxis:
339 fparam = new G4ParameterisationBoxY( axis, nDivs, width,
340 offset, mSolid, divType );
341 break;
342 case kZAxis:
343 fparam = new G4ParameterisationBoxZ( axis, nDivs, width,
344 offset, mSolid, divType );
345 break;
346 default:
347 ErrorInAxis( axis, mSolid );
348 break;
349 }
350 }
351 else if( mSolidType == "G4Tubs" )
352 {
353 switch( axis )
354 {
355 case kRho:
356 fparam = new G4ParameterisationTubsRho( axis, nDivs, width,
357 offset, mSolid, divType );
358 break;
359 case kPhi:
360 fparam = new G4ParameterisationTubsPhi( axis, nDivs, width,
361 offset, mSolid, divType );
362 break;
363 case kZAxis:
364 fparam = new G4ParameterisationTubsZ( axis, nDivs, width,
365 offset, mSolid, divType );
366 break;
367 default:
368 ErrorInAxis( axis, mSolid );
369 break;
370 }
371 }
372 else if( mSolidType == "G4Cons" )
373 {
374 switch( axis )
375 {
376 case kRho:
377 fparam = new G4ParameterisationConsRho( axis, nDivs, width,
378 offset, mSolid, divType );
379 break;
380 case kPhi:
381 fparam = new G4ParameterisationConsPhi( axis, nDivs, width,
382 offset, mSolid, divType );
383 break;
384 case kZAxis:
385 fparam = new G4ParameterisationConsZ( axis, nDivs, width,
386 offset, mSolid, divType );
387 break;
388 default:
389 ErrorInAxis( axis, mSolid );
390 break;
391 }
392 }
393 else if( mSolidType == "G4Trd" )
394 {
395 switch( axis )
396 {
397 case kXAxis:
398 fparam = new G4ParameterisationTrdX( axis, nDivs, width,
399 offset, mSolid, divType );
400 break;
401 case kYAxis:
402 fparam = new G4ParameterisationTrdY( axis, nDivs, width,
403 offset, mSolid, divType );
404 break;
405 case kZAxis:
406 fparam = new G4ParameterisationTrdZ( axis, nDivs, width,
407 offset, mSolid, divType );
408 break;
409 default:
410 ErrorInAxis( axis, mSolid );
411 break;
412 }
413 }
414 else if( mSolidType == "G4Para" )
415 {
416 switch( axis )
417 {
418 case kXAxis:
419 fparam = new G4ParameterisationParaX( axis, nDivs, width,
420 offset, mSolid, divType );
421 break;
422 case kYAxis:
423 fparam = new G4ParameterisationParaY( axis, nDivs, width,
424 offset, mSolid, divType );
425 break;
426 case kZAxis:
427 fparam = new G4ParameterisationParaZ( axis, nDivs, width,
428 offset, mSolid, divType );
429 break;
430 default:
431 ErrorInAxis( axis, mSolid );
432 break;
433 }
434 }
435// else if( mSolidType == "G4Trap" )
436// {
437// }
438// else if( mSolidType == "G4Polycone" )
439// {
440// switch( axis )
441// {
442// case kRho:
443// fparam = new G4ParameterisationPolyconeRho( axis, nDivs, width,
444// offset, mSolid, divType );
445// break;
446// case kPhi:
447// fparam = new G4ParameterisationPolyconePhi( axis, nDivs, width,
448// offset, mSolid, divType );
449// break;
450// case kZAxis:
451// fparam = new G4ParameterisationPolyconeZ( axis, nDivs, width,
452// offset, mSolid, divType );
453// break;
454// default:
455// ErrorInAxis( axis, mSolid );
456// break;
457// }
458// }
459// else if( mSolidType == "G4Polyhedra" )
460// {
461// switch( axis )
462// {
463// case kRho:
464// fparam = new G4ParameterisationPolyhedraRho( axis, nDivs, width,
465// offset, mSolid, divType );
466// break;
467// case kPhi:
468// fparam = new G4ParameterisationPolyhedraPhi( axis, nDivs, width,
469// offset, mSolid, divType );
470// break;
471// case kZAxis:
472// fparam = new G4ParameterisationPolyhedraZ( axis, nDivs, width,
473// offset, mSolid, divType );
474// break;
475// default:
476// ErrorInAxis( axis, mSolid );
477// break;
478// }
479// }
480 else
481 {
482 G4cerr << "ERROR - G4ReplicatedSlice::SetParameterisation()" << G4endl
483 << " Divisions for " << mSolidType
484 << " not implemented." << G4endl;
485 G4String message = "Solid type not supported: " + mSolidType;
486 G4Exception("G4ReplicatedSlice::SetParameterisation()", "IllegalConstruct",
487 FatalException, message);
488 }
489
490 fparam->SetHalfGap(half_gap);
491}
492
493//--------------------------------------------------------------------------
494void G4ReplicatedSlice::ErrorInAxis( EAxis axis, G4VSolid* solid )
495{
496 G4String error = "Trying to divide solid " + solid->GetName()
497 + " of type " + solid->GetEntityType() + " along axis ";
498 switch( axis )
499 {
500 case kXAxis:
501 error += "X.";
502 break;
503 case kYAxis:
504 error += "Y.";
505 break;
506 case kZAxis:
507 error += "Z.";
508 break;
509 case kRho:
510 error += "Rho.";
511 break;
512 case kRadial3D:
513 error += "Radial3D.";
514 break;
515 case kPhi:
516 error += "Phi.";
517 break;
518 default:
519 break;
520 }
521 G4Exception("G4ReplicatedSlice::ErrorInAxis()", "IllegalConstruct",
522 FatalException, error);
523}
524
525// The next methods are for specialised repeated volumes
526// (replicas, parameterised vol.) which are completely regular.
527// Currently this is not applicable to divisions ( J.A. Nov 2005 )
528// ----------------------------------------------------------------------
529// IsRegularRepeatedStructure()
530//
531G4bool G4ReplicatedSlice::IsRegularStructure() const
532{
533 return false;
534}
535
536// ----------------------------------------------------------------------
537// IsRegularRepeatedStructure()
538//
539G4int G4ReplicatedSlice::GetRegularStructureId() const
540{
541 return 0;
542}
Note: See TracBrowser for help on using the repository browser.