| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 //
29 // John Allison 5th April 2001
30 // A scene handler to dump geometry hierarchy.
31 // Based on a provisional G4ASCIITreeGraphicsS
32
33 #include "G4ASCIITreeSceneHandler.hh"
34
35 #include "G4ASCIITree.hh"
36 #include "G4ASCIITreeMessenger.hh"
37 #include "G4VSolid.hh"
38 #include "G4PhysicalVolumeModel.hh"
39 #include "G4VPhysicalVolume.hh"
40 #include "G4LogicalVolume.hh"
41 #include "G4VPVParameterisation.hh"
42 #include "G4Polyhedron.hh"
43 #include "G4UnitsTable.hh"
44 #include "G4Material.hh"
45 #include "G4Scene.hh"
46 #include "G4ModelingParameters.hh"
47 #include "G4PhysicalVolumeMassScene.hh"
48 #include "G4VSensitiveDetector.hh"
49 #include "G4VReadOutGeometry.hh"
50 #include "G4TransportationManager.hh"
51 #include "G4AttCheck.hh"
52 #include "G4AttValue.hh"
53
54 G4ASCIITreeSceneHandler::G4ASCIITreeSceneHandl
55 (G4VGraphicsSystem& system,
56 const G4String& name):
57 G4VTreeSceneHandler(system, name),
58 fpOutFile(0),
59 fpLastPV(0),
60 fLastCopyNo(-99),
61 fLastNonSequentialCopyNo(-99)
62 {}
63
64 G4ASCIITreeSceneHandler::~G4ASCIITreeSceneHand
65
66 void G4ASCIITreeSceneHandler::BeginModeling ()
67
68 G4VTreeSceneHandler::BeginModeling (); // T
69
70 const G4ASCIITree* pSystem = (G4ASCIITree*)G
71 const G4String& outFileName = pSystem -> Get
72 if (outFileName == "G4cout") {
73 fpOutFile = &G4cout;
74 } else {
75 fOutFile.open (outFileName);
76 fpOutFile = &fOutFile;
77 }
78
79 static G4bool firstTime = true;
80 if (firstTime) {
81 firstTime = false;
82 G4cout << "G4ASCIITreeSceneHandler::BeginM
83 if (outFileName == "G4cout") {
84 G4cout << "G4 standard output (G4cout)";
85 } else {
86 G4cout << "file \"" << outFileName << "\
87 }
88 G4cout << G4endl;
89
90 WriteHeader (G4cout); G4cout << G4endl;
91 }
92
93 if (outFileName != "G4cout") {
94 WriteHeader (fOutFile); fOutFile << std::e
95 }
96 }
97
98 void G4ASCIITreeSceneHandler::WriteHeader (std
99 {
100 const G4ASCIITree* pSystem = (G4ASCIITree*)G
101 const G4int verbosity = pSystem->GetVerbosit
102 const G4int detail = verbosity % 10;
103 os << "# Set verbosity with \"/vis/ASCIITre
104 for (size_t i = 0;
105 i < G4ASCIITreeMessenger::fVerbosityGui
106 os << "\n# " << G4ASCIITreeMessenger::fVe
107 }
108 os << "\n# Now printing with verbosity " <<
109 os << "\n# Format is: PV:n";
110 if (detail >= 1) os << " / LV (SD,RO)";
111 if (detail >= 2) os << " / Solid(type)";
112 if (detail >= 3) os << ", volume, density";
113 if (detail >= 5) os << ", daughter-subtracte
114 if (detail >= 6) os << ", physical volume du
115 if (detail >= 7) os << ", polyhedron dump";
116 os <<
117 "\n# Abbreviations: PV = Physical Volume,
118 "\n# SD = Sensitive Detect
119 }
120
121 void G4ASCIITreeSceneHandler::EndModeling () {
122 const G4ASCIITree* pSystem = (G4ASCIITree*)
123 const G4int verbosity = pSystem->GetVerbosit
124 const G4int detail = verbosity % 10;
125 const G4String& outFileName = pSystem -> Get
126
127 // Output left over copy number, if any...
128 if (fLastCopyNo != fLastNonSequentialCopyNo)
129 if (fLastCopyNo == fLastNonSequentialCopyN
130 else *fpOutFile << '-';
131 *fpOutFile << fLastCopyNo;
132 }
133 // Output outstanding rest of line, if any..
134 if (!fRestOfLine.str().empty()) *fpOutFile <
135 fRestOfLine.str("");
136 fpLastPV = 0;
137 fLastPVName.clear();
138 fLastCopyNo = -99;
139 fLastNonSequentialCopyNo = -99;
140
141 // This detail to G4cout regardless of outFi
142 if (detail >= 4) {
143 G4cout << "Calculating mass(es)..." << G4e
144 const std::vector<G4Scene::Model>& models
145 std::vector<G4Scene::Model>::const_iterato
146 for (i = models.begin(); i != models.end()
147 G4PhysicalVolumeModel* pvModel =
148 dynamic_cast<G4PhysicalVolumeModel*>(i->fpMo
149 if (pvModel) {
150 const G4ModelingParameters* tempMP =
151 pvModel->GetModelingParameters();
152 G4ModelingParameters mp; // Default -
153 pvModel->SetModelingParameters (&mp);
154 G4PhysicalVolumeMassScene massScene(pv
155 pvModel->DescribeYourselfTo (massScene
156 G4double volume = massScene.GetVolume(
157 G4double mass = massScene.GetMass();
158
159 G4cout << "Overall volume of \""
160 << pvModel->GetTopPhysicalVolume()->Ge
161 << "\":"
162 << pvModel->GetTopPhysicalVolume()->Ge
163 << ", is "
164 << G4BestUnit (volume, "Volume")
165 << " and the daughter-included mass";
166 G4int requestedDepth = pvModel->GetReq
167 if (requestedDepth == G4PhysicalVolume
168 G4cout << " to unlimited depth";
169 } else {
170 G4cout << ", ignoring daughters at d
171 << requestedDepth
172 << " and below,";
173 }
174 G4cout << " is " << G4BestUnit (mass,
175 << G4endl;
176
177 pvModel->SetModelingParameters (tempMP
178 }
179 }
180 }
181
182 if (outFileName != "G4cout") {
183 fOutFile.close();
184 G4cout << "Output file \"" << outFileName
185 }
186 fLVSet.clear();
187 fReplicaSet.clear();
188 G4cout << "G4ASCIITreeSceneHandler::EndModel
189 G4VTreeSceneHandler::EndModeling (); // To
190 }
191
192 void G4ASCIITreeSceneHandler::RequestPrimitive
193
194 G4PhysicalVolumeModel* pPVModel =
195 dynamic_cast<G4PhysicalVolumeModel*>(fpMod
196 if (!pPVModel) return; // Not from a G4Phys
197
198 // This call comes from a G4PhysicalVolumeMo
199 // the path of the current drawn (non-culled
200 // drawn (non-culled) ancestors. Each node
201 // PVNodeID object, which is a physical volu
202 // is a vector of PVNodeIDs corresponding to
203 // actually selected, i.e., not culled.
204 // The following typedef's already set in he
205 //typedef G4PhysicalVolumeModel::G4PhysicalV
206 //typedef std::vector<PVNodeID> PVPath;
207 const PVPath& drawnPVPath = pPVModel->GetDra
208 //G4int currentDepth = pPVModel->GetCurrentD
209 G4VPhysicalVolume* pCurrentPV = pPVModel->Ge
210 const G4String& currentPVName = pCurrentPV->
211 const G4int currentCopyNo = pCurrentPV->GetC
212 G4LogicalVolume* pCurrentLV = pPVModel->GetC
213 G4Material* pCurrentMaterial = pPVModel->Get
214
215 G4ASCIITree* pSystem = (G4ASCIITree*)GetGrap
216 G4int verbosity = pSystem->GetVerbosity();
217 G4int detail = verbosity % 10;
218
219 // If verbosity < 10 suppress unnecessary re
220 // Repeated simple replicas can always be su
221 // Paramaterisations can only be suppressed
222 // size, density, etc., are in principle dif
223 const G4bool isParameterised = pCurrentPV->G
224 const G4bool isSimpleReplica = pCurrentPV->I
225 const G4bool isAmenableToSupression =
226 (verbosity < 10 && isSimpleReplica) || (verb
227 if (isAmenableToSupression) {
228 // See if this has been found before with
229 PVPath::const_reverse_iterator thisID = dr
230 PVPath::const_reverse_iterator motherID =
231 G4bool ignore = false;
232 for (ReplicaSetIterator i = fReplicaSet.be
233 ++i) {
234 if (i->back().GetPhysicalVolume()->GetLo
235 thisID->GetPhysicalVolume()->GetLogi
236 // For each one previously found (if m
237 // have different mothers)...
238 // To avoid compilation errors on VC++
239 // Previously:
240 // PVNodeID previousMotherID = ++(i-
241 // (Should that have been: PVNodeID::c
242 // Replace
243 // previousMotherID == i->rend()
244 // by
245 // i->size() <= 1
246 // Replace
247 // previousMotherID != i->rend()
248 // by
249 // i->size() > 1
250 // Replace
251 // previousMotherID->
252 // by
253 // (*i)[i->size() - 2].
254 if (motherID == drawnPVPath.rend() &&
255 i->size() <= 1)
256 ignore = true; // Both have no moth
257 if (motherID != drawnPVPath.rend() &&
258 i->size() > 1 &&
259 motherID->GetPhysicalVolume()->Get
260 (*i)[i->size() - 2].GetPhysicalVol
261 ignore = true; // Same mother LV...
262 }
263 }
264 if (ignore) {
265 pPVModel->CurtailDescent();
266 return;
267 }
268 }
269
270 // Now suppress printing for volumes with th
271 // copy number - but not if they are paramet
272 // taken out above (those that are "amenable
273 // taken out).
274 if (verbosity < 10 && !isParameterised &&
275 currentPVName == fLastPVName &&
276 currentCopyNo != fLastCopyNo) {
277 // Check...
278 if (isAmenableToSupression) {
279 G4Exception("G4ASCIITreeSceneHandler::Re
280 "vistree0001",
281 JustWarning,
282 "Volume amenable to suppressed printing
283 }
284 // Check mothers are identical...
285 else if (pCurrentLV == (fpLastPV? fpLastPV
286 if (currentCopyNo != fLastCopyNo + 1) {
287 // Non-sequential copy number...
288 *fpOutFile << ',' << currentCopyNo;
289 fLastNonSequentialCopyNo = currentCopyNo;
290 }
291 fLastCopyNo = currentCopyNo;
292 pPVModel->CurtailDescent();
293 return;
294 }
295 }
296 fpLastPV = pCurrentPV;
297
298 // High verbosity or a new or otherwise non-
299 // Output copy number, if any, from previous
300 if (fLastCopyNo != fLastNonSequentialCopyNo)
301 if (fLastCopyNo == fLastNonSequentialCopyN
302 else *fpOutFile << '-';
303 *fpOutFile << fLastCopyNo;
304 }
305 // Output rest of line, if any, from previou
306 if (!fRestOfLine.str().empty()) *fpOutFile <
307 fRestOfLine.str("");
308 fLastPVName = currentPVName;
309 fLastCopyNo = currentCopyNo;
310 fLastNonSequentialCopyNo = currentCopyNo;
311 // Start next line...
312 // Indent according to drawn path depth...
313 for (size_t i = 0; i < drawnPVPath.size(); i
314 *fpOutFile << "\"" << currentPVName
315 << "\":" << currentCopyNo;
316
317 if (pCurrentPV->IsReplicated()) {
318 if (verbosity < 10) {
319 // Add printing for replicas (when repli
320 EAxis axis;
321 G4int nReplicas;
322 G4double width;
323 G4double offset;
324 G4bool consuming;
325 pCurrentPV->GetReplicationData(axis,nRep
326 G4VPVParameterisation* pP = pCurrentPV->
327 if (pP) {
328 if (detail < 3) {
329 fReplicaSet.insert(drawnPVPath);
330 if (nReplicas > 2) fRestOfLine << '-';
331 else fRestOfLine << ',';
332 fRestOfLine << nReplicas - 1
333 << " (" << nReplicas << " parametris
334 }
335 }
336 else {
337 fReplicaSet.insert(drawnPVPath);
338 if (nReplicas > 2) fRestOfLine << '-';
339 else fRestOfLine << ',';
340 fRestOfLine << nReplicas - 1
341 << " (" << nReplicas << " replicas)";
342 }
343 }
344 } else {
345 if (fLVSet.find(pCurrentLV) != fLVSet.end(
346 if (verbosity < 10) {
347 // Add printing for repeated LV (if it has d
348 if (pCurrentLV->GetNoDaughters()) fRestOfLin
349 // ...and curtail descent.
350 pPVModel->CurtailDescent();
351 }
352 }
353 }
354
355 if (detail >= 1) {
356 fRestOfLine << " / \""
357 << pCurrentLV->GetName() << "\"";
358 G4VSensitiveDetector* sd = pCurrentLV->Get
359 if (sd) {
360 fRestOfLine << " (SD=\"" << sd->GetName(
361 G4VReadOutGeometry* roGeom = sd->GetROge
362 if (roGeom) {
363 fRestOfLine << ",RO=\"" << roGeom->GetName()
364 }
365 fRestOfLine << ")";
366 }
367 }
368
369 if (detail >= 2) {
370 fRestOfLine << " / \""
371 << solid.GetName()
372 << "\"("
373 << solid.GetEntityType() << ")";
374 }
375
376 if (detail >= 3) {
377 fRestOfLine << ", "
378 << G4BestUnit(((G4VSolid&)solid).GetCubicV
379 << ", ";
380 if (pCurrentMaterial) {
381 fRestOfLine
382 << G4BestUnit(pCurrentMaterial->GetDensity()
383 << " (" << pCurrentMaterial->GetName() << ")
384 } else {
385 fRestOfLine << "(No material)";
386 }
387 }
388
389 if (detail >= 5) {
390 if (pCurrentMaterial) {
391 G4Material* pMaterial = const_cast<G4Mat
392 // ...and find daughter-subtracted mass.
393 G4double daughter_subtracted_mass = pCur
394 (pCurrentPV->IsParameterised(), // Force if
395 false, // Do not propagate - calculate for
396 // volume of daughters.
397 pMaterial);
398 G4double daughter_subtracted_volume =
399 daughter_subtracted_mass / pCurrentMaterial-
400 fRestOfLine << ", "
401 << G4BestUnit(daughter_subtracted_volume
402 << ", "
403 << G4BestUnit(daughter_subtracted_mass,"
404 }
405 }
406
407 if (detail >= 6) {
408 std::vector<G4AttValue>* attValues = pPVMo
409 const std::map<G4String,G4AttDef>* attDefs
410 fRestOfLine << '\n' << G4AttCheck(attValue
411 delete attValues;
412 }
413
414 if (detail >= 7) {
415 G4Polyhedron* polyhedron = solid.GetPolyhe
416 fRestOfLine << "\nLocal polyhedron coordin
417 const G4Transform3D& transform = pPVModel-
418 polyhedron->Transform(transform);
419 fRestOfLine << "\nGlobal polyhedron coordi
420 }
421
422 if (fLVSet.find(pCurrentLV) == fLVSet.end())
423 fLVSet.insert(pCurrentLV); // Record new
424 }
425
426 fRestOfLine << std::endl;
427
428 return;
429 }
430