Geant4  9.6.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ModelingParameters.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$
28 //
29 //
30 // John Allison 31st December 1997.
31 // Parameters associated with the modeling of GEANT4 objects.
32 
33 #include "G4ModelingParameters.hh"
34 
35 #include "G4ios.hh"
36 #include "G4VisAttributes.hh"
37 #include "G4ExceptionSeverity.hh"
38 #include "G4SystemOfUnits.hh"
39 #include "G4VSolid.hh"
40 #include "G4VPhysicalVolume.hh"
41 #include "G4PhysicalVolumeModel.hh"
42 
43 G4ModelingParameters::G4ModelingParameters ():
44  fWarning (true),
45  fpDefaultVisAttributes (0),
46  fDrawingStyle (wf),
47  fCulling (false),
48  fCullInvisible (false),
49  fDensityCulling (false),
50  fVisibleDensity (0.01 * g / cm3),
51  fCullCovered (false),
52  fExplodeFactor (1.),
53  fNoOfSides (24),
54  fpSectionSolid (0),
55  fpCutawaySolid (0),
56  fpEvent (0)
57 {}
58 
59 G4ModelingParameters::G4ModelingParameters
60 (const G4VisAttributes* pDefaultVisAttributes,
61  G4ModelingParameters::DrawingStyle drawingStyle,
62  G4bool isCulling,
63  G4bool isCullingInvisible,
64  G4bool isDensityCulling,
65  G4double visibleDensity,
66  G4bool isCullingCovered,
67  G4int noOfSides
68  ):
69  fWarning (true),
70  fpDefaultVisAttributes (pDefaultVisAttributes),
71  fDrawingStyle (drawingStyle),
72  fCulling (isCulling),
73  fCullInvisible (isCullingInvisible),
74  fDensityCulling (isDensityCulling),
75  fVisibleDensity (visibleDensity),
76  fCullCovered (isCullingCovered),
77  fExplodeFactor (1.),
78  fNoOfSides (noOfSides),
79  fpSectionSolid (0),
80  fpCutawaySolid (0),
81  fpEvent (0)
82 {}
83 
84 G4ModelingParameters::~G4ModelingParameters ()
85 {
86  delete fpSectionSolid;
87  delete fpCutawaySolid;
88 }
89 
90 G4ModelingParameters::VisAttributesModifier::VisAttributesModifier
91 (const G4VisAttributes& visAtts,
92  G4ModelingParameters::VisAttributesSignifier signifier,
93  const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& path):
94 fVisAtts(visAtts), fSignifier(signifier)
95 {
96  typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
97  typedef std::vector<PVNodeID> PVPath;
98  typedef PVPath::const_iterator PVPathConstIterator;
99  PVPathConstIterator i;
100  for (i = path.begin();
101  i != path.end();
102  ++i) {
103  fPVNameCopyNoPath.push_back
104  (PVNameCopyNo
105  (i->GetPhysicalVolume()->GetName(),
106  i->GetCopyNo()));
107  }
108 }
109 
110 void G4ModelingParameters::SetVisibleDensity (G4double visibleDensity) {
111  const G4double reasonableMaximum = 10.0 * g / cm3;
112  if (visibleDensity < 0 && fWarning) {
113  G4cout << "G4ModelingParameters::SetVisibleDensity: attempt to set negative "
114  "density - ignored." << G4endl;
115  }
116  else {
117  if (fVisibleDensity > reasonableMaximum && fWarning) {
118  G4cout << "G4ModelingParameters::SetVisibleDensity: density > "
119  << reasonableMaximum
120  << " g / cm3 - did you mean this?"
121  << G4endl;
122  }
123  fVisibleDensity = visibleDensity;
124  }
125 }
126 
127 G4int G4ModelingParameters::SetNoOfSides (G4int nSides) {
128  const G4int nSidesMin = 12;
129  if (nSides < nSidesMin) {
130  nSides = nSidesMin;
131  if (fWarning)
132  G4cout << "G4ModelingParameters::SetNoOfSides: attempt to set the"
133  "\nnumber of sides per circle < " << nSidesMin
134  << "; forced to" << nSides << G4endl;
135  }
136  fNoOfSides = nSides;
137  return fNoOfSides;
138 }
139 
140 void G4ModelingParameters::SetSectionSolid
141 (G4VSolid* pSectionSolid) {
142  delete fpSectionSolid;
143  fpSectionSolid = pSectionSolid;
144 }
145 
146 void G4ModelingParameters::SetCutawaySolid
147 (G4VSolid* pCutawaySolid) {
148  delete fpCutawaySolid;
149  fpCutawaySolid = pCutawaySolid;
150 }
151 
152 std::ostream& operator << (std::ostream& os, const G4ModelingParameters& mp)
153 {
154  os << "Modeling parameters (warning ";
155  if (mp.fWarning) os << "true";
156  else os << "false";
157  os << "):";
158 
159  const G4VisAttributes* va = mp.fpDefaultVisAttributes;
160  os << "\n Default vis. attributes: ";
161  if (va) os << *va;
162  else os << "none";
163 
164  os << "\n Current requested drawing style: ";
165  switch (mp.fDrawingStyle) {
166  case G4ModelingParameters::wf:
167  os << "wireframe"; break;
168  case G4ModelingParameters::hlr:
169  os << "hidden line removal (hlr)"; break;
170  case G4ModelingParameters::hsr:
171  os << "surface (hsr)"; break;
172  case G4ModelingParameters::hlhsr:
173  os << "surface and edges (hlhsr)"; break;
174  default: os << "unrecognised"; break;
175  }
176 
177  os << "\n Culling: ";
178  if (mp.fCulling) os << "on";
179  else os << "off";
180 
181  os << "\n Culling invisible objects: ";
182  if (mp.fCullInvisible) os << "on";
183  else os << "off";
184 
185  os << "\n Density culling: ";
186  if (mp.fDensityCulling) {
187  os << "on - invisible if density less than "
188  << mp.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
189  }
190  else os << "off";
191 
192  os << "\n Culling daughters covered by opaque mothers: ";
193  if (mp.fCullCovered) os << "on";
194  else os << "off";
195 
196  os << "\n Explode factor: " << mp.fExplodeFactor
197  << " about centre: " << mp.fExplodeCentre;
198 
199  os << "\n No. of sides used in circle polygon approximation: "
200  << mp.fNoOfSides;
201 
202  os << "\n Section (DCUT) shape (G4VSolid) pointer: ";
203  if (!mp.fpSectionSolid) os << "non-";
204  os << "null";
205 
206  os << "\n Cutaway (DCUT) shape (G4VSolid) pointer: ";
207  if (!mp.fpCutawaySolid) os << "non-";
208  os << "null";
209 
210  os << "\n Event pointer: " << mp.fpEvent;
211 
212  os << "\n Vis attributes modifiers: ";
213  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
214  mp.fVisAttributesModifiers;
215  if (vams.empty()) {
216  os << "None";
217  } else {
218  os << vams;
219  }
220 
221  return os;
222 }
223 
224 G4bool G4ModelingParameters::operator !=
225 (const G4ModelingParameters& mp) const {
226 
227  if (
228  (fWarning != mp.fWarning) ||
229  (*fpDefaultVisAttributes != *mp.fpDefaultVisAttributes) ||
230  (fCulling != mp.fCulling) ||
231  (fCullInvisible != mp.fCullInvisible) ||
232  (fDensityCulling != mp.fDensityCulling) ||
233  (fCullCovered != mp.fCullCovered) ||
234  (fExplodeFactor != mp.fExplodeFactor) ||
235  (fExplodeCentre != mp.fExplodeCentre) ||
236  (fNoOfSides != mp.fNoOfSides) ||
237  (fpSectionSolid != mp.fpSectionSolid) ||
238  (fpCutawaySolid != mp.fpCutawaySolid) ||
239  (fpEvent != mp.fpEvent)
240  )
241  return true;
242 
243  if (fDensityCulling &&
244  (fVisibleDensity != mp.fVisibleDensity)) return true;
245 
246  if (VAMSNotEqual(fVisAttributesModifiers, mp.fVisAttributesModifiers))
247  return true;
248 
249  return false;
250 }
251 
252 G4bool G4ModelingParameters::PVNameCopyNoPathNotEqual
253 (const G4ModelingParameters::PVNameCopyNoPath& path1,
254  const G4ModelingParameters::PVNameCopyNoPath& path2)
255 {
256  if (path1.size() != path2.size()) return true;
257  if (path1.empty()) return false;
258  PVNameCopyNoPathConstIterator i1, i2;
259  for (i1 = path1.begin(), i2 = path2.begin();
260  i1 != path1.end();
261  ++i1, ++i2) {
262  if (i1->GetName() != i2->GetName()) return true;
263  if (i1->GetCopyNo() != i2->GetCopyNo()) return true;
264  }
265  return false;
266 }
267 
268 G4bool G4ModelingParameters::VAMSNotEqual
269 (const std::vector<G4ModelingParameters::VisAttributesModifier>& vams1,
270  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams2)
271 {
272  if (vams1.size() != vams2.size()) return true;
273  if (vams1.empty()) return false;
274  std::vector<VisAttributesModifier>::const_iterator i1, i2;
275  for (i1 = vams1.begin(), i2 = vams2.begin();
276  i1 != vams1.end();
277  ++i1, ++i2) {
278  const PVNameCopyNoPath& vam1Path = i1->GetPVNameCopyNoPath();
279  const PVNameCopyNoPath& vam2Path = i2->GetPVNameCopyNoPath();
280  if (PVNameCopyNoPathNotEqual(vam1Path,vam2Path)) return true;
281  if (i1->GetVisAttributesSignifier() != i2->GetVisAttributesSignifier())
282  return true;
283  const G4VisAttributes& vam1VisAtts = i1->GetVisAttributes();
284  const G4VisAttributes& vam2VisAtts = i2->GetVisAttributes();
285  const G4Colour& c1 = vam1VisAtts.GetColour();
286  const G4Colour& c2 = vam2VisAtts.GetColour();
287  switch (i1->GetVisAttributesSignifier()) {
288  case G4ModelingParameters::VASVisibility:
289  if (vam1VisAtts.IsVisible() != vam2VisAtts.IsVisible())
290  return true;
291  break;
292  case G4ModelingParameters::VASDaughtersInvisible:
293  if (vam1VisAtts.IsDaughtersInvisible() !=
294  vam2VisAtts.IsDaughtersInvisible())
295  return true;
296  break;
297  case G4ModelingParameters::VASColour:
298  if (c1 != c2)
299  return true;
300  break;
301  case G4ModelingParameters::VASLineStyle:
302  if (vam1VisAtts.GetLineStyle() != vam2VisAtts.GetLineStyle())
303  return true;
304  break;
305  case G4ModelingParameters::VASLineWidth:
306  if (vam1VisAtts.GetLineWidth() != vam2VisAtts.GetLineWidth())
307  return true;
308  break;
309  case G4ModelingParameters::VASForceWireframe:
310  if (vam1VisAtts.GetForcedDrawingStyle() !=
311  vam2VisAtts.GetForcedDrawingStyle())
312  return true;
313  break;
314  case G4ModelingParameters::VASForceSolid:
315  if (vam1VisAtts.GetForcedDrawingStyle() !=
316  vam2VisAtts.GetForcedDrawingStyle())
317  return true;
318  break;
319  case G4ModelingParameters::VASForceAuxEdgeVisible:
320  if (vam1VisAtts.IsForceAuxEdgeVisible() !=
321  vam2VisAtts.IsForceAuxEdgeVisible())
322  return true;
323  break;
324  case G4ModelingParameters::VASForceLineSegmentsPerCircle:
325  if (vam1VisAtts.GetForcedLineSegmentsPerCircle() !=
326  vam2VisAtts.GetForcedLineSegmentsPerCircle())
327  return true;
328  break;
329  }
330  }
331  return false;
332 }
333 
334 std::ostream& operator <<
335 (std::ostream& os, const G4ModelingParameters::PVNameCopyNoPath& path)
336 {
337 // os << "Touchable path: physical-volume-name:copy-number pairs:\n ";
338  G4ModelingParameters::PVNameCopyNoPathConstIterator i;
339  for (i = path.begin(); i != path.end(); ++i) {
340  if (i != path.begin()) {
341  os << ", ";
342  }
343  os << i->GetName() << ':' << i->GetCopyNo();
344  }
345  return os;
346 }
347 
348 std::ostream& operator <<
349 (std::ostream& os,
350  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams)
351 {
352  std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
353  iModifier;
354  for (iModifier = vams.begin();
355  iModifier != vams.end();
356  ++iModifier) {
357  const G4ModelingParameters::PVNameCopyNoPath& vamPath =
358  iModifier->GetPVNameCopyNoPath();
359  os << '\n' << vamPath;
360  const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
361  const G4Colour& c = vamVisAtts.GetColour();
362  switch (iModifier->GetVisAttributesSignifier()) {
363  case G4ModelingParameters::VASVisibility:
364  os << " visibility ";
365  if (vamVisAtts.IsVisible()) {
366  os << "true";
367  } else {
368  os << "false";
369  }
370  break;
371  case G4ModelingParameters::VASDaughtersInvisible:
372  os << " daughtersInvisible ";
373  if (vamVisAtts.IsDaughtersInvisible()) {
374  os << "true";
375  } else {
376  os << "false";
377  }
378  break;
379  case G4ModelingParameters::VASColour:
380  os << " colour " << c;
381  break;
382  case G4ModelingParameters::VASLineStyle:
383  os << " lineStyle ";
384  switch (vamVisAtts.GetLineStyle()) {
385  case G4VisAttributes::unbroken:
386  os << "unbroken";
387  break;
388  case G4VisAttributes::dashed:
389  os << "dashed";
390  break;
391  case G4VisAttributes::dotted:
392  os << "dotted";
393  }
394  break;
395  case G4ModelingParameters::VASLineWidth:
396  os << " lineWidth "
397  << vamVisAtts.GetLineWidth();
398  break;
399  case G4ModelingParameters::VASForceWireframe:
400  if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
401  os << " forceWireframe ";
402  if (vamVisAtts.IsForceDrawingStyle()) {
403  os << "true";
404  } else {
405  os << "false";
406  }
407  }
408  break;
409  case G4ModelingParameters::VASForceSolid:
410  if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
411  os << " forceSolid ";
412  if (vamVisAtts.IsForceDrawingStyle()) {
413  os << "true";
414  } else {
415  os << "false";
416  }
417  }
418  break;
419  case G4ModelingParameters::VASForceAuxEdgeVisible:
420  os << " forceAuxEdgeVisible ";
421  if (vamVisAtts.IsForceAuxEdgeVisible()) {
422  os << "true";
423  } else {
424  os << "false";
425  }
426  break;
427  case G4ModelingParameters::VASForceLineSegmentsPerCircle:
428  os << " lineSegmentsPerCircle "
429  << vamVisAtts.GetForcedLineSegmentsPerCircle();
430  break;
431  }
432  }
433 
434  return os;
435 }
436 
Generated on Sat May 25 2013 14:34:16 for Geant4 by   doxygen 1.8.4