source: trunk/source/visualization/modeling/src/G4PhysicalVolumeModel.cc@ 842

Last change on this file since 842 was 834, checked in by garnier, 17 years ago

import all except CVS
File size: 27.2 KB
RevLine 
[834]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: G4PhysicalVolumeModel.cc,v 1.63 2007/11/10 14:56:36 allison Exp $
28// GEANT4 tag $Name: $
29//
30//
31// John Allison 31st December 1997.
32// Model for physical volumes.
33
34#include "G4PhysicalVolumeModel.hh"
35
36#include "G4ModelingParameters.hh"
37#include "G4VGraphicsScene.hh"
38#include "G4VPhysicalVolume.hh"
39#include "G4VPVParameterisation.hh"
40#include "G4LogicalVolume.hh"
41#include "G4VSolid.hh"
42#include "G4Material.hh"
43#include "G4VisAttributes.hh"
44#include "G4BoundingSphereScene.hh"
45#include "G4PhysicalVolumeSearchScene.hh"
46#include "G4TransportationManager.hh"
47#include "G4Polyhedron.hh"
48#include "G4AttDefStore.hh"
49#include "G4AttDef.hh"
50#include "G4AttValue.hh"
51#include "G4UnitsTable.hh"
52#include "G4Vector3D.hh"
53
54#include <sstream>
55
56G4bool G4PhysicalVolumeModel::G4PhysicalVolumeNodeID::operator<
57 (const G4PhysicalVolumeModel::G4PhysicalVolumeNodeID& right) const
58{
59 if (fpPV < right.fpPV) return true;
60 if (fpPV == right.fpPV) {
61 if (fCopyNo < right.fCopyNo) return true;
62 if (fCopyNo == right.fCopyNo)
63 return fNonCulledDepth < right.fNonCulledDepth;
64 }
65 return false;
66}
67
68std::ostream& operator<<
69 (std::ostream& os, const G4PhysicalVolumeModel::G4PhysicalVolumeNodeID node)
70{
71 G4VPhysicalVolume* pPV = node.GetPhysicalVolume();
72 if (pPV) {
73 os << pPV->GetName()
74 << ':' << node.GetCopyNo()
75 << '[' << node.GetNonCulledDepth() << ']';
76 } else {
77 os << "Null node";
78 }
79 return os;
80}
81
82G4PhysicalVolumeModel::G4PhysicalVolumeModel
83(G4VPhysicalVolume* pVPV,
84 G4int requestedDepth,
85 const G4Transform3D& modelTransformation,
86 const G4ModelingParameters* pMP,
87 G4bool useFullExtent):
88 G4VModel (modelTransformation, pMP),
89 fpTopPV (pVPV),
90 fTopPVName (pVPV -> GetName ()),
91 fTopPVCopyNo (pVPV -> GetCopyNo ()),
92 fRequestedDepth (requestedDepth),
93 fUseFullExtent (useFullExtent),
94 fCurrentDepth (0),
95 fpCurrentPV (0),
96 fpCurrentLV (0),
97 fpCurrentMaterial (0),
98 fpCurrentTransform (0),
99 fCurtailDescent (false),
100 fpClippingPolyhedron (0),
101 fClippingMode (subtraction)
102{
103 std::ostringstream o;
104 o << fpTopPV -> GetCopyNo ();
105 fGlobalTag = fpTopPV -> GetName () + "." + o.str();
106 fGlobalDescription = "G4PhysicalVolumeModel " + fGlobalTag;
107
108 CalculateExtent ();
109}
110
111G4PhysicalVolumeModel::~G4PhysicalVolumeModel ()
112{
113 delete fpClippingPolyhedron;
114}
115
116void G4PhysicalVolumeModel::CalculateExtent ()
117{
118 if (fUseFullExtent) {
119 fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent ();
120 }
121 else {
122 G4BoundingSphereScene bsScene(this);
123 const G4int tempRequestedDepth = fRequestedDepth;
124 fRequestedDepth = -1; // Always search to all depths to define extent.
125 const G4ModelingParameters* tempMP = fpMP;
126 G4ModelingParameters mParams
127 (0, // No default vis attributes needed.
128 G4ModelingParameters::wf, // wireframe (not relevant for this).
129 true, // Global culling.
130 true, // Cull invisible volumes.
131 false, // Density culling.
132 0., // Density (not relevant if density culling false).
133 true, // Cull daughters of opaque mothers.
134 24); // No of sides (not relevant for this operation).
135 fpMP = &mParams;
136 DescribeYourselfTo (bsScene);
137 G4double radius = bsScene.GetRadius();
138 if (radius < 0.) { // Nothing in the scene.
139 fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent ();
140 } else {
141 // Transform back to coordinates relative to the top
142 // transformation, which is in G4VModel::fTransform. This makes
143 // it conform to all models, which are defined by a
144 // transformation and an extent relative to that
145 // transformation...
146 G4Point3D centre = bsScene.GetCentre();
147 centre.transform(fTransform.inverse());
148 fExtent = G4VisExtent(centre, radius);
149 }
150 fpMP = tempMP;
151 fRequestedDepth = tempRequestedDepth;
152 }
153}
154
155void G4PhysicalVolumeModel::DescribeYourselfTo
156(G4VGraphicsScene& sceneHandler)
157{
158 if (!fpMP) G4Exception
159 ("G4PhysicalVolumeModel::DescribeYourselfTo: No modeling parameters.");
160
161 // For safety...
162 fCurrentDepth = 0;
163
164 G4Transform3D startingTransformation = fTransform;
165
166 VisitGeometryAndGetVisReps
167 (fpTopPV,
168 fRequestedDepth,
169 startingTransformation,
170 sceneHandler);
171
172 // Clear data...
173 fCurrentDepth = 0;
174 fpCurrentPV = 0;
175 fpCurrentLV = 0;
176 fpCurrentMaterial = 0;
177 fFullPVPath.clear();
178 fDrawnPVPath.clear();
179}
180
181G4String G4PhysicalVolumeModel::GetCurrentTag () const
182{
183 if (fpCurrentPV) {
184 std::ostringstream o;
185 o << fpCurrentPV -> GetCopyNo ();
186 return fpCurrentPV -> GetName () + "." + o.str();
187 }
188 else {
189 return "WARNING: NO CURRENT VOLUME - global tag is " + fGlobalTag;
190 }
191}
192
193G4String G4PhysicalVolumeModel::GetCurrentDescription () const
194{
195 return "G4PhysicalVolumeModel " + GetCurrentTag ();
196}
197
198void G4PhysicalVolumeModel::VisitGeometryAndGetVisReps
199(G4VPhysicalVolume* pVPV,
200 G4int requestedDepth,
201 const G4Transform3D& theAT,
202 G4VGraphicsScene& sceneHandler)
203{
204 // Visits geometry structure to a given depth (requestedDepth), starting
205 // at given physical volume with given starting transformation and
206 // describes volumes to the scene handler.
207 // requestedDepth < 0 (default) implies full visit.
208 // theAT is the Accumulated Transformation.
209
210 // Find corresponding logical volume and (later) solid, storing in
211 // local variables to preserve re-entrancy.
212 G4LogicalVolume* pLV = pVPV -> GetLogicalVolume ();
213
214 G4VSolid* pSol;
215 G4Material* pMaterial;
216
217 if (!(pVPV -> IsReplicated ())) {
218 // Non-replicated physical volume.
219 pSol = pLV -> GetSolid ();
220 pMaterial = pLV -> GetMaterial ();
221 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
222 theAT, sceneHandler);
223 }
224 else {
225 // Replicated or parametrised physical volume.
226 EAxis axis;
227 G4int nReplicas;
228 G4double width;
229 G4double offset;
230 G4bool consuming;
231 pVPV -> GetReplicationData (axis, nReplicas, width, offset, consuming);
232 G4VPVParameterisation* pP = pVPV -> GetParameterisation ();
233 if (pP) { // Parametrised volume.
234 for (int n = 0; n < nReplicas; n++) {
235 pSol = pP -> ComputeSolid (n, pVPV);
236 pMaterial = pP -> ComputeMaterial (n, pVPV);
237 pP -> ComputeTransformation (n, pVPV);
238 pSol -> ComputeDimensions (pP, n, pVPV);
239 pVPV -> SetCopyNo (n);
240 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
241 theAT, sceneHandler);
242 }
243 }
244 else { // Plain replicated volume. From geometry_guide.txt...
245 // The replica's positions are claculated by means of a linear formula.
246 // Replication may occur along:
247 //
248 // o Cartesian axes (kXAxis,kYAxis,kZAxis)
249 //
250 // The replications, of specified width have coordinates of
251 // form (-width*(nReplicas-1)*0.5+n*width,0,0) where n=0.. nReplicas-1
252 // for the case of kXAxis, and are unrotated.
253 //
254 // o Radial axis (cylindrical polar) (kRho)
255 //
256 // The replications are cons/tubs sections, centred on the origin
257 // and are unrotated.
258 // They have radii of width*n+offset to width*(n+1)+offset
259 // where n=0..nReplicas-1
260 //
261 // o Phi axis (cylindrical polar) (kPhi)
262 // The replications are `phi sections' or wedges, and of cons/tubs form
263 // They have phi of offset+n*width to offset+(n+1)*width where
264 // n=0..nReplicas-1
265 //
266 pSol = pLV -> GetSolid ();
267 pMaterial = pLV -> GetMaterial ();
268 G4ThreeVector originalTranslation = pVPV -> GetTranslation ();
269 G4RotationMatrix* pOriginalRotation = pVPV -> GetRotation ();
270 G4double originalRMin = 0., originalRMax = 0.;
271 if (axis == kRho && pSol->GetEntityType() == "G4Tubs") {
272 originalRMin = ((G4Tubs*)pSol)->GetInnerRadius();
273 originalRMax = ((G4Tubs*)pSol)->GetOuterRadius();
274 }
275 G4bool visualisable = true;
276 for (int n = 0; n < nReplicas; n++) {
277 G4ThreeVector translation; // Null.
278 G4RotationMatrix rotation; // Null - life long enough for visualizing.
279 G4RotationMatrix* pRotation = 0;
280 switch (axis) {
281 default:
282 case kXAxis:
283 translation = G4ThreeVector (-width*(nReplicas-1)*0.5+n*width,0,0);
284 break;
285 case kYAxis:
286 translation = G4ThreeVector (0,-width*(nReplicas-1)*0.5+n*width,0);
287 break;
288 case kZAxis:
289 translation = G4ThreeVector (0,0,-width*(nReplicas-1)*0.5+n*width);
290 break;
291 case kRho:
292 if (pSol->GetEntityType() == "G4Tubs") {
293 ((G4Tubs*)pSol)->SetInnerRadius(width*n+offset);
294 ((G4Tubs*)pSol)->SetOuterRadius(width*(n+1)+offset);
295 } else {
296 if (fpMP->IsWarning())
297 G4cout <<
298 "G4PhysicalVolumeModel::VisitGeometryAndGetVisReps: WARNING:"
299 "\n built-in replicated volumes replicated in radius for "
300 << pSol->GetEntityType() <<
301 "-type\n solids (your solid \""
302 << pSol->GetName() <<
303 "\") are not visualisable."
304 << G4endl;
305 visualisable = false;
306 }
307 break;
308 case kPhi:
309 rotation.rotateZ (-(offset+(n+0.5)*width));
310 // Minus Sign because for the physical volume we need the
311 // coordinate system rotation.
312 pRotation = &rotation;
313 break;
314 }
315 pVPV -> SetTranslation (translation);
316 pVPV -> SetRotation (pRotation);
317 pVPV -> SetCopyNo (n);
318 if (visualisable) {
319 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial,
320 theAT, sceneHandler);
321 }
322 }
323 // Restore originals...
324 pVPV -> SetTranslation (originalTranslation);
325 pVPV -> SetRotation (pOriginalRotation);
326 if (axis == kRho && pSol->GetEntityType() == "G4Tubs") {
327 ((G4Tubs*)pSol)->SetInnerRadius(originalRMin);
328 ((G4Tubs*)pSol)->SetOuterRadius(originalRMax);
329 }
330 }
331 }
332
333 return;
334}
335
336void G4PhysicalVolumeModel::DescribeAndDescend
337(G4VPhysicalVolume* pVPV,
338 G4int requestedDepth,
339 G4LogicalVolume* pLV,
340 G4VSolid* pSol,
341 G4Material* pMaterial,
342 const G4Transform3D& theAT,
343 G4VGraphicsScene& sceneHandler)
344{
345 // Maintain useful data members...
346 fpCurrentPV = pVPV;
347 fpCurrentLV = pLV;
348 fpCurrentMaterial = pMaterial;
349
350 const G4RotationMatrix objectRotation = pVPV -> GetObjectRotationValue ();
351 const G4ThreeVector& translation = pVPV -> GetTranslation ();
352 G4Transform3D theLT (G4Transform3D (objectRotation, translation));
353
354 // Compute the accumulated transformation...
355 // Note that top volume's transformation relative to the world
356 // coordinate system is specified in theAT == startingTransformation
357 // = fTransform (see DescribeYourselfTo), so first time through the
358 // volume's own transformation, which is only relative to its
359 // mother, i.e., not relative to the world coordinate system, should
360 // not be accumulated.
361 G4Transform3D theNewAT (theAT);
362 if (fCurrentDepth != 0) theNewAT = theAT * theLT;
363 fpCurrentTransform = &theNewAT;
364
365 /********************************************************
366 G4cout << "G4PhysicalVolumeModel::DescribeAndDescend: "
367 << pVPV -> GetName () << "." << pVPV -> GetCopyNo ();
368 G4cout << "\n theAT: ";
369 G4cout << "\n Rotation: ";
370 G4RotationMatrix rotation = theAT.getRotation ();
371 G4cout << rotation.thetaX() << ", "
372 << rotation.phiX() << ", "
373 << rotation.thetaY() << ", "
374 << rotation.phiY() << ", "
375 << rotation.thetaZ() << ", "
376 << rotation.phiZ();
377 G4cout << "\n Translation: " << theAT.getTranslation();
378 G4cout << "\n theNewAT: ";
379 G4cout << "\n Rotation: ";
380 rotation = theNewAT.getRotation ();
381 G4cout << rotation.thetaX() << ", "
382 << rotation.phiX() << ", "
383 << rotation.thetaY() << ", "
384 << rotation.phiY() << ", "
385 << rotation.thetaZ() << ", "
386 << rotation.phiZ();
387 G4cout << "\n Translation: " << theNewAT.getTranslation();
388 G4cout << G4endl;
389 **********************************************************/
390
391 // Make decision to draw...
392 const G4VisAttributes* pVisAttribs = pLV->GetVisAttributes();
393 if (!pVisAttribs) pVisAttribs = fpMP->GetDefaultVisAttributes();
394 // Beware - pVisAttribs might still be zero - create a temporary default one...
395 G4bool visAttsCreated = false;
396 if (!pVisAttribs) {
397 pVisAttribs = new G4VisAttributes;
398 visAttsCreated = true;
399 }
400
401 // From here, can assume pVisAttribs is a valid pointer.
402
403 G4bool thisToBeDrawn = true;
404
405 // There are various reasons why this volume
406 // might not be drawn...
407 G4bool culling = fpMP->IsCulling();
408 G4bool cullingInvisible = fpMP->IsCullingInvisible();
409 G4bool markedVisible = pVisAttribs->IsVisible();
410 G4bool cullingLowDensity = fpMP->IsDensityCulling();
411 G4double density = pMaterial? pMaterial->GetDensity(): 0;
412 G4double densityCut = fpMP -> GetVisibleDensity ();
413
414 // 1) Global culling is on....
415 if (culling) {
416 // 2) Culling of invisible volumes is on...
417 if (cullingInvisible) {
418 // 3) ...and the volume is marked not visible...
419 if (!markedVisible) thisToBeDrawn = false;
420 }
421 // 4) Or culling of low density volumes is on...
422 if (cullingLowDensity) {
423 // 5) ...and density is less than cut value...
424 if (density < densityCut) thisToBeDrawn = false;
425 }
426 }
427
428 // Update full path of physical volumes...
429 G4int copyNo = fpCurrentPV->GetCopyNo();
430 fFullPVPath.push_back
431 (G4PhysicalVolumeNodeID(fpCurrentPV,copyNo,fCurrentDepth));
432
433 if (thisToBeDrawn) {
434
435 // Update path of drawn physical volumes...
436 G4int copyNo = fpCurrentPV->GetCopyNo();
437 fDrawnPVPath.push_back
438 (G4PhysicalVolumeNodeID(fpCurrentPV,copyNo,fCurrentDepth));
439
440 if (fpMP->IsExplode() && fDrawnPVPath.size() == 1) {
441 // For top-level drawn volumes, explode along radius...
442 G4Transform3D centering = G4Translate3D(fpMP->GetExplodeCentre());
443 G4Transform3D centred = centering.inverse() * theNewAT;
444 G4Scale3D scale;
445 G4Rotate3D rotation;
446 G4Translate3D translation;
447 centred.getDecomposition(scale, rotation, translation);
448 G4double explodeFactor = fpMP->GetExplodeFactor();
449 G4Translate3D newTranslation =
450 G4Translate3D(explodeFactor * translation.dx(),
451 explodeFactor * translation.dy(),
452 explodeFactor * translation.dz());
453 theNewAT = centering * newTranslation * rotation * scale;
454 }
455
456 DescribeSolid (theNewAT, pSol, pVisAttribs, sceneHandler);
457
458 }
459
460 // Make decision to draw daughters, if any. There are various
461 // reasons why daughters might not be drawn...
462
463 // First, reasons that do not depend on culling policy...
464 G4int nDaughters = pLV->GetNoDaughters();
465 G4bool daughtersToBeDrawn = true;
466 // 1) There are no daughters...
467 if (!nDaughters) daughtersToBeDrawn = false;
468 // 2) We are at the limit if requested depth...
469 else if (requestedDepth == 0) daughtersToBeDrawn = false;
470 // 3) The user has asked that the descent be curtailed...
471 else if (fCurtailDescent) daughtersToBeDrawn = false;
472
473 // Now, reasons that depend on culling policy...
474 else {
475 G4bool culling = fpMP->IsCulling();
476 G4bool cullingInvisible = fpMP->IsCullingInvisible();
477 G4bool daughtersInvisible = pVisAttribs->IsDaughtersInvisible();
478 // Culling of covered daughters request. This is computed in
479 // G4VSceneHandler::CreateModelingParameters() depending on view
480 // parameters...
481 G4bool cullingCovered = fpMP->IsCullingCovered();
482 G4bool surfaceDrawing =
483 fpMP->GetDrawingStyle() == G4ModelingParameters::hsr ||
484 fpMP->GetDrawingStyle() == G4ModelingParameters::hlhsr;
485 if (pVisAttribs->IsForceDrawingStyle()) {
486 switch (pVisAttribs->GetForcedDrawingStyle()) {
487 default:
488 case G4VisAttributes::wireframe: surfaceDrawing = false; break;
489 case G4VisAttributes::solid: surfaceDrawing = true; break;
490 }
491 }
492 G4bool opaque = pVisAttribs->GetColour().GetAlpha() >= 1.;
493 // 4) Global culling is on....
494 if (culling) {
495 // 5) ..and culling of invisible volumes is on...
496 if (cullingInvisible) {
497 // 6) ...and the mother requests daughters invisible
498 if (daughtersInvisible) daughtersToBeDrawn = false;
499 }
500 // 7) Or culling of covered daughters is requested...
501 if (cullingCovered) {
502 // 8) ...and surface drawing is operating...
503 if (surfaceDrawing) {
504 // 9) ...but only if mother is visible...
505 if (thisToBeDrawn) {
506 // 10) ...and opaque...
507 if (opaque) daughtersToBeDrawn = false;
508 }
509 }
510 }
511 }
512 }
513
514 // Vis atts for this volume no longer needed if created...
515 if (visAttsCreated) delete pVisAttribs;
516
517 if (daughtersToBeDrawn) {
518 for (G4int iDaughter = 0; iDaughter < nDaughters; iDaughter++) {
519 G4VPhysicalVolume* pVPV = pLV -> GetDaughter (iDaughter);
520 // Descend the geometry structure recursively...
521 fCurrentDepth++;
522 VisitGeometryAndGetVisReps
523 (pVPV, requestedDepth - 1, theNewAT, sceneHandler);
524 fCurrentDepth--;
525 }
526 }
527
528 // Reset for normal descending of next volume at this level...
529 fCurtailDescent = false;
530
531 // Pop item from paths physical volumes...
532 fFullPVPath.pop_back();
533 if (thisToBeDrawn) {
534 fDrawnPVPath.pop_back();
535 }
536}
537
538void G4PhysicalVolumeModel::DescribeSolid
539(const G4Transform3D& theAT,
540 G4VSolid* pSol,
541 const G4VisAttributes* pVisAttribs,
542 G4VGraphicsScene& sceneHandler)
543{
544 sceneHandler.PreAddSolid (theAT, *pVisAttribs);
545
546 const G4Polyhedron* pSectionPolyhedron = fpMP->GetSectionPolyhedron();
547 const G4Polyhedron* pCutawayPolyhedron = fpMP->GetCutawayPolyhedron();
548
549 if (!fpClippingPolyhedron && !pSectionPolyhedron && !pCutawayPolyhedron) {
550
551 pSol -> DescribeYourselfTo (sceneHandler); // Standard treatment.
552
553 } else {
554
555 // Clipping, etc., performed by Boolean operations on polyhedron objects.
556
557 // First, get polyhedron for current solid...
558 if (pVisAttribs->IsForceLineSegmentsPerCircle())
559 G4Polyhedron::SetNumberOfRotationSteps
560 (pVisAttribs->GetForcedLineSegmentsPerCircle());
561 else
562 G4Polyhedron::SetNumberOfRotationSteps(fpMP->GetNoOfSides());
563 G4Polyhedron* pOriginal = pSol->GetPolyhedron();
564 G4Polyhedron::ResetNumberOfRotationSteps();
565 if (!pOriginal) {
566 if (fpMP->IsWarning())
567 G4cout <<
568 "WARNING: G4PhysicalVolumeModel::DescribeSolid: solid\n \""
569 << pSol->GetName() <<
570 "\" has no polyhedron. Cannot by clipped."
571 << G4endl;
572 pSol -> DescribeYourselfTo (sceneHandler); // Standard treatment.
573 } else {
574
575 G4Polyhedron resultant = *pOriginal;
576
577 if (fpClippingPolyhedron) {
578 G4Polyhedron clipper = *fpClippingPolyhedron; // Local copy.
579 clipper.Transform(theAT.inverse());
580 switch (fClippingMode) {
581 default:
582 case subtraction: resultant = resultant.subtract(clipper); break;
583 case intersection: resultant = resultant.intersect(clipper); break;
584 }
585 if(resultant.IsErrorBooleanProcess()) {
586 if (fpMP->IsWarning())
587 G4cout <<
588 "WARNING: G4PhysicalVolumeModel::DescribeSolid: clipped polyhedron for"
589 "\n solid \"" << pSol->GetName() <<
590 "\" not defined due to error during Boolean processing."
591 << G4endl;
592 // Nevertheless, keep resultant.
593 }
594 }
595
596 if (pSectionPolyhedron) {
597 G4Polyhedron sectioner = *pSectionPolyhedron; // Local copy.
598 sectioner.Transform(theAT.inverse());
599 resultant = resultant.intersect(sectioner);
600 if(resultant.IsErrorBooleanProcess()) {
601 if (fpMP->IsWarning())
602 G4cout <<
603 "WARNING: G4PhysicalVolumeModel::DescribeSolid: sectioned polyhedron for"
604 "\n solid \"" << pSol->GetName() <<
605 "\" not defined due to error during Boolean processing."
606 << G4endl;
607 // Nevertheless, keep resultant.
608 }
609 }
610
611 if (pCutawayPolyhedron) {
612 G4Polyhedron cutter = *pCutawayPolyhedron; // Local copy.
613 cutter.Transform(theAT.inverse());
614 resultant = resultant.subtract(cutter);
615 if(resultant.IsErrorBooleanProcess()) {
616 if (fpMP->IsWarning())
617 G4cout <<
618 "WARNING: G4PhysicalVolumeModel::DescribeSolid: cutaway polyhedron for"
619 "\n solid \"" << pSol->GetName() <<
620 "\" not defined due to error during Boolean processing."
621 << G4endl;
622 // Nevertheless, keep resultant.
623 }
624 }
625
626 // Finally, force polyhedron drawing...
627 resultant.SetVisAttributes(pVisAttribs);
628 sceneHandler.BeginPrimitives(theAT);
629 sceneHandler.AddPrimitive(resultant);
630 sceneHandler.EndPrimitives();
631 }
632 }
633 sceneHandler.PostAddSolid ();
634}
635
636G4bool G4PhysicalVolumeModel::Validate (G4bool warn)
637{
638 G4VPhysicalVolume* world =
639 G4TransportationManager::GetTransportationManager ()
640 -> GetNavigatorForTracking () -> GetWorldVolume ();
641 // The idea now is to seek a PV with the same name and copy no
642 // in the hope it's the same one!!
643 if (warn) {
644 G4cout << "G4PhysicalVolumeModel::Validate() called." << G4endl;
645 }
646 G4PhysicalVolumeModel searchModel (world);
647 G4PhysicalVolumeSearchScene searchScene
648 (&searchModel, fTopPVName, fTopPVCopyNo);
649 G4ModelingParameters mp; // Default modeling parameters for this search.
650 mp.SetDefaultVisAttributes(fpMP? fpMP->GetDefaultVisAttributes(): 0);
651 searchModel.SetModelingParameters (&mp);
652 searchModel.DescribeYourselfTo (searchScene);
653 G4VPhysicalVolume* foundVolume = searchScene.GetFoundVolume ();
654 if (foundVolume) {
655 if (warn) {
656 G4cout << " Volume of the same name and copy number (\""
657 << fTopPVName << "\", copy " << fTopPVCopyNo
658 << ") still exists and is being used."
659 "\n WARNING: This does not necessarily guarantee it's the same"
660 "\n volume you originally specified in /vis/scene/add/."
661 << G4endl;
662 }
663 fpTopPV = foundVolume;
664 CalculateExtent ();
665 return true;
666 }
667 else {
668 if (warn) {
669 G4cout << " A volume of the same name and copy number (\""
670 << fTopPVName << "\", copy " << fTopPVCopyNo
671 << ") no longer exists."
672 << G4endl;
673 }
674 return false;
675 }
676}
677
678const std::map<G4String,G4AttDef>* G4PhysicalVolumeModel::GetAttDefs() const
679{
680 G4bool isNew;
681 std::map<G4String,G4AttDef>* store
682 = G4AttDefStore::GetInstance("G4PhysicalVolumeModel", isNew);
683 if (isNew) {
684 (*store)["PVPath"] =
685 G4AttDef("PVPath","Physical Volume Path","Physics","","G4String");
686 (*store)["LVol"] =
687 G4AttDef("LVol","Logical Volume","Physics","","G4String");
688 (*store)["Solid"] =
689 G4AttDef("Solid","Solid Name","Physics","","G4String");
690 (*store)["EType"] =
691 G4AttDef("EType","Entity Type","Physics","","G4String");
692 (*store)["DmpSol"] =
693 G4AttDef("DmpSol","Dump of Solid properties","Physics","","G4String");
694 (*store)["Trans"] =
695 G4AttDef("Trans","Transformation of volume","Physics","","G4String");
696 (*store)["Material"] =
697 G4AttDef("Material","Material Name","Physics","","G4String");
698 (*store)["Density"] =
699 G4AttDef("Density","Material Density","Physics","G4BestUnit","G4double");
700 (*store)["State"] =
701 G4AttDef("State","Material State (enum undefined,solid,liquid,gas)","Physics","","G4String");
702 (*store)["Radlen"] =
703 G4AttDef("Radlen","Material Radiation Length","Physics","G4BestUnit","G4double");
704 }
705 (*store)["Region"] =
706 G4AttDef("Region","Cuts Region","Physics","","G4String");
707 (*store)["RootRegion"] =
708 G4AttDef("RootRegion","Root Region (0/1 = false/true)","Physics","","G4bool");
709 return store;
710}
711
712#include <iomanip>
713
714static std::ostream& operator<< (std::ostream& o, const G4Transform3D t)
715{
716 using namespace std;
717
718 G4Scale3D s;
719 G4Rotate3D r;
720 G4Translate3D tl;
721 t.getDecomposition(s, r, tl);
722
723 const int w = 10;
724
725 // Transformation itself
726 o << setw(w) << t.xx() << setw(w) << t.xy() << setw(w) << t.xz() << setw(w) << t.dx() << endl;
727 o << setw(w) << t.yx() << setw(w) << t.yy() << setw(w) << t.yz() << setw(w) << t.dy() << endl;
728 o << setw(w) << t.zx() << setw(w) << t.zy() << setw(w) << t.zz() << setw(w) << t.dz() << endl;
729
730 // Translation
731 o << "= translation:" << endl;
732 o << setw(w) << tl.dx() << setw(w) << tl.dy() << setw(w) << tl.dz() << endl;
733
734 // Rotation
735 o << "* rotation:" << endl;
736 o << setw(w) << r.xx() << setw(w) << r.xy() << setw(w) << r.xz() << endl;
737 o << setw(w) << r.yx() << setw(w) << r.yy() << setw(w) << r.yz() << endl;
738 o << setw(w) << r.zx() << setw(w) << r.zy() << setw(w) << r.zz() << endl;
739
740 // Scale
741 o << "* scale:" << endl;
742 o << setw(w) << s.xx() << setw(w) << s.yy() << setw(w) << s.zz() << endl;
743
744 // Transformed axes
745 o << "Transformed axes:" << endl;
746 o << "x': " << r * G4Vector3D(1., 0., 0.) << endl;
747 o << "y': " << r * G4Vector3D(0., 1., 0.) << endl;
748 o << "z': " << r * G4Vector3D(0., 0., 1.) << endl;
749
750 return o;
751}
752
753std::vector<G4AttValue>* G4PhysicalVolumeModel::CreateCurrentAttValues() const
754{
755 std::vector<G4AttValue>* values = new std::vector<G4AttValue>;
756 std::ostringstream oss;
757 for (size_t i = 0; i < fFullPVPath.size(); ++i) {
758 oss << fFullPVPath[i].GetPhysicalVolume()->GetName()
759 << ':' << fFullPVPath[i].GetCopyNo();
760 if (i != fFullPVPath.size() - 1) oss << '/';
761 }
762 values->push_back(G4AttValue("PVPath", oss.str(),""));
763 values->push_back(G4AttValue("LVol", fpCurrentLV->GetName(),""));
764 G4VSolid* pSol = fpCurrentLV->GetSolid();
765 values->push_back(G4AttValue("Solid", pSol->GetName(),""));
766 values->push_back(G4AttValue("EType", pSol->GetEntityType(),""));
767 oss.str(""); oss << '\n' << *pSol;
768 values->push_back(G4AttValue("DmpSol", oss.str(),""));
769 oss.str(""); oss << '\n' << *fpCurrentTransform;
770 values->push_back(G4AttValue("Trans", oss.str(),""));
771 G4String matName = fpCurrentMaterial? fpCurrentMaterial->GetName(): G4String("No material");
772 values->push_back(G4AttValue("Material", matName,""));
773 G4double matDensity = fpCurrentMaterial? fpCurrentMaterial->GetDensity(): 0.;
774 values->push_back(G4AttValue("Density", G4BestUnit(matDensity,"Volumic Mass"),""));
775 G4State matState = fpCurrentMaterial? fpCurrentMaterial->GetState(): kStateUndefined;
776 oss.str(""); oss << matState;
777 values->push_back(G4AttValue("State", oss.str(),""));
778 G4double matRadlen = fpCurrentMaterial? fpCurrentMaterial->GetRadlen(): 0.;
779 values->push_back(G4AttValue("Radlen", G4BestUnit(matRadlen,"Length"),""));
780 G4Region* region = fpCurrentLV->GetRegion();
781 G4String regionName = region? region->GetName(): G4String("No region");
782 values->push_back(G4AttValue("Region", regionName,""));
783 oss.str(""); oss << fpCurrentLV->IsRootRegion();
784 values->push_back(G4AttValue("RootRegion", oss.str(),""));
785 return values;
786}
Note: See TracBrowser for help on using the repository browser.