| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4ASCIITreeSceneHandler.cc,v 1.12 2003/05/30 13:01:23 johna Exp $
>> 25 // GEANT4 tag $Name: geant4-05-02 $
27 // 26 //
28 // 27 //
29 // John Allison 5th April 2001 28 // John Allison 5th April 2001
30 // A scene handler to dump geometry hierarchy. 29 // A scene handler to dump geometry hierarchy.
31 // Based on a provisional G4ASCIITreeGraphicsS 30 // Based on a provisional G4ASCIITreeGraphicsScene (was in modeling).
32 31
33 #include "G4ASCIITreeSceneHandler.hh" 32 #include "G4ASCIITreeSceneHandler.hh"
34 33
35 #include "G4ASCIITree.hh" 34 #include "G4ASCIITree.hh"
36 #include "G4ASCIITreeMessenger.hh" <<
37 #include "G4VSolid.hh" 35 #include "G4VSolid.hh"
38 #include "G4PhysicalVolumeModel.hh" 36 #include "G4PhysicalVolumeModel.hh"
39 #include "G4VPhysicalVolume.hh" 37 #include "G4VPhysicalVolume.hh"
40 #include "G4LogicalVolume.hh" 38 #include "G4LogicalVolume.hh"
41 #include "G4VPVParameterisation.hh" 39 #include "G4VPVParameterisation.hh"
42 #include "G4Polyhedron.hh" << 40
43 #include "G4UnitsTable.hh" << 41 G4ASCIITreeSceneHandler::G4ASCIITreeSceneHandler(G4VGraphicsSystem& system,
44 #include "G4Material.hh" << 42 const G4String& name):
45 #include "G4Scene.hh" << 43 G4VTreeSceneHandler(system, name) {}
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 44
64 G4ASCIITreeSceneHandler::~G4ASCIITreeSceneHand 45 G4ASCIITreeSceneHandler::~G4ASCIITreeSceneHandler () {}
65 46
66 void G4ASCIITreeSceneHandler::BeginModeling () 47 void G4ASCIITreeSceneHandler::BeginModeling () {
67 48
68 G4VTreeSceneHandler::BeginModeling (); // T 49 G4VTreeSceneHandler::BeginModeling (); // To re-use "culling off" code.
69 50
70 const G4ASCIITree* pSystem = (G4ASCIITree*)G 51 const G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
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 52 const G4int verbosity = pSystem->GetVerbosity();
102 const G4int detail = verbosity % 10; << 53 G4cout << "\nG4ASCIITreeSceneHandler::BeginModeling:"
103 os << "# Set verbosity with \"/vis/ASCIITre << 54 "\n set verbosity with \"/vis/ASCIITree/verbose <verbosity>\":"
104 for (size_t i = 0; << 55 "\n < 10: - does not print daughters of repeated logical volumes."
105 i < G4ASCIITreeMessenger::fVerbosityGui << 56 "\n - does not repeat replicas."
106 os << "\n# " << G4ASCIITreeMessenger::fVe << 57 "\n >= 10: prints all physical volumes."
107 } << 58 "\n For level of detail add:"
108 os << "\n# Now printing with verbosity " << << 59 "\n >= 0: prints physical volume name."
109 os << "\n# Format is: PV:n"; << 60 "\n >= 1: prints logical volume name."
110 if (detail >= 1) os << " / LV (SD,RO)"; << 61 "\n >= 2: prints solid name and type."
111 if (detail >= 2) os << " / Solid(type)"; << 62 "\n Note: all culling, if any, is switched off so all volumes are seen."
112 if (detail >= 3) os << ", volume, density"; << 63 "\n Now printing with verbosity " << verbosity << G4endl;
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 } 64 }
120 65
121 void G4ASCIITreeSceneHandler::EndModeling () { 66 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(); 67 fLVSet.clear();
187 fReplicaSet.clear(); 68 fReplicaSet.clear();
188 G4cout << "G4ASCIITreeSceneHandler::EndModel 69 G4cout << "G4ASCIITreeSceneHandler::EndModeling" << G4endl;
189 G4VTreeSceneHandler::EndModeling (); // To 70 G4VTreeSceneHandler::EndModeling (); // To re-use "culling off" code.
190 } 71 }
191 72
192 void G4ASCIITreeSceneHandler::RequestPrimitive << 73 void G4ASCIITreeSceneHandler::RequestPrimitives(const G4VSolid&) {
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 74
270 // Now suppress printing for volumes with th << 75 const G4ASCIITree* pSystem = (G4ASCIITree*)GetGraphicsSystem();
271 // copy number - but not if they are paramet << 76 const G4int verbosity = pSystem->GetVerbosity();
272 // taken out above (those that are "amenable << 77 const G4int detail = verbosity % 10;
273 // taken out). << 78
274 if (verbosity < 10 && !isParameterised && << 79 if (verbosity < 10 && fReplicaSet.find(fpCurrentPV) != fReplicaSet.end()) {
275 currentPVName == fLastPVName && << 80 // Ignore if an already treated replica.
276 currentCopyNo != fLastCopyNo) { << 81 G4PhysicalVolumeModel* pPVM = fpModel->GetG4PhysicalVolumeModel();
277 // Check... << 82 if (pPVM) {
278 if (isAmenableToSupression) { << 83 pPVM->CurtailDescent();
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; 84 return;
294 } 85 }
295 } 86 }
296 fpLastPV = pCurrentPV; <<
297 87
298 // High verbosity or a new or otherwise non- << 88 // Print indented text...
299 // Output copy number, if any, from previous << 89 for (G4int i = 0; i < fCurrentDepth; i++ ) G4cout << " ";
300 if (fLastCopyNo != fLastNonSequentialCopyNo) << 90 G4cout << "\"" << fpCurrentPV->GetName()
301 if (fLastCopyNo == fLastNonSequentialCopyN << 91 << "\", copy no. " << fpCurrentPV->GetCopyNo();
302 else *fpOutFile << '-'; << 92 if (detail >= 1) {
303 *fpOutFile << fLastCopyNo; << 93 G4cout << ", belongs to logical volume \""
>> 94 << fpCurrentLV->GetName() << "\"";
>> 95 }
>> 96 if (detail >= 2) {
>> 97 G4cout << " and is composed of solid \""
>> 98 << fpCurrentLV->GetSolid()->GetName()
>> 99 << "\" of type \""
>> 100 << fpCurrentLV->GetSolid()->GetEntityType() << "\"";
304 } 101 }
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 102
317 if (pCurrentPV->IsReplicated()) { << 103 if (fpCurrentPV->IsReplicated()) {
>> 104 fReplicaSet.insert(fpCurrentPV); // Record new replica volume.
318 if (verbosity < 10) { 105 if (verbosity < 10) {
319 // Add printing for replicas (when repli 106 // Add printing for replicas (when replicas are ignored)...
320 EAxis axis; 107 EAxis axis;
321 G4int nReplicas; 108 G4int nReplicas;
322 G4double width; 109 G4double width;
323 G4double offset; 110 G4double offset;
324 G4bool consuming; 111 G4bool consuming;
325 pCurrentPV->GetReplicationData(axis,nRep << 112 fpCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
326 G4VPVParameterisation* pP = pCurrentPV-> << 113 G4VPVParameterisation* pP = fpCurrentPV->GetParameterisation();
>> 114 G4cout << " (" << nReplicas;
327 if (pP) { 115 if (pP) {
328 if (detail < 3) { << 116 G4cout << " parametrised volumes)";
329 fReplicaSet.insert(drawnPVPath); <<
330 if (nReplicas > 2) fRestOfLine << '-'; <<
331 else fRestOfLine << ','; <<
332 fRestOfLine << nReplicas - 1 <<
333 << " (" << nReplicas << " parametris <<
334 } <<
335 } 117 }
336 else { 118 else {
337 fReplicaSet.insert(drawnPVPath); << 119 G4cout << " replicas)";
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 } 120 }
352 } 121 }
353 } 122 }
354 << 123 else {
355 if (detail >= 1) { << 124 if (fLVSet.find(fpCurrentLV) != fLVSet.end()) {
356 fRestOfLine << " / \"" << 125 if (verbosity < 10) {
357 << pCurrentLV->GetName() << "\""; << 126 // Add printing for repeated logical volume...
358 G4VSensitiveDetector* sd = pCurrentLV->Get << 127 G4cout << " (repeated logical volume)";
359 if (sd) { << 128 // Ignore if an already treated logical volume.
360 fRestOfLine << " (SD=\"" << sd->GetName( << 129 if (fpCurrentPV) {
361 G4VReadOutGeometry* roGeom = sd->GetROge << 130 ((G4PhysicalVolumeModel*)fpModel)->CurtailDescent();
362 if (roGeom) { << 131 G4cout << G4endl;
363 fRestOfLine << ",RO=\"" << roGeom->GetName() << 132 return;
>> 133 }
364 } 134 }
365 fRestOfLine << ")"; <<
366 } 135 }
367 } 136 }
368 137
369 if (detail >= 2) { << 138 if (fLVSet.find(fpCurrentLV) == fLVSet.end()) {
370 fRestOfLine << " / \"" << 139 fLVSet.insert(fpCurrentLV); // Record new logical volume.
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 } 140 }
406 141
407 if (detail >= 6) { << 142 G4cout << G4endl;
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; 143 return;
429 } 144 }
430 145