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