| Geant4 Cross Reference |
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
28 // /vis/set - John Allison 21st March 2012
29 // Set quantities for use in appropriate future commands.
30
31 #include "G4VisCommandsSet.hh"
32
33 #include "G4UIcommand.hh"
34 #include "G4UIcmdWithAnInteger.hh"
35 #include "G4UIcmdWithADouble.hh"
36 #include "G4UIcmdWithAString.hh"
37 #include "G4UIcmdWithABool.hh"
38 #include "G4TouchablePropertiesScene.hh"
39 #include "G4TransportationManager.hh"
40 #include "G4BoundingExtentScene.hh"
41
42 #include <sstream>
43 #include <utility>
44
45 #define G4warn G4cout
46
47 ////////////// /vis/set/arrow3DLineSegmentsPerCircle ////////////////////////////////////
48
49 G4VisCommandSetArrow3DLineSegmentsPerCircle::G4VisCommandSetArrow3DLineSegmentsPerCircle ()
50 {
51 G4bool omitable;
52 fpCommand = new G4UIcmdWithAnInteger("/vis/set/arrow3DLineSegmentsPerCircle", this);
53 fpCommand->SetGuidance
54 ("Defines number of line segments per circle for drawing 3D arrows"
55 " for future \"/vis/scene/add/\" commands.");
56 fpCommand->SetParameterName ("number", omitable = true);
57 fpCommand->SetDefaultValue (6);
58 fpCommand->SetRange("number >= 3");
59 }
60
61 G4VisCommandSetArrow3DLineSegmentsPerCircle::~G4VisCommandSetArrow3DLineSegmentsPerCircle ()
62 {
63 delete fpCommand;
64 }
65
66 G4String G4VisCommandSetArrow3DLineSegmentsPerCircle::GetCurrentValue (G4UIcommand*)
67 {
68 return G4String();
69 }
70
71 void G4VisCommandSetArrow3DLineSegmentsPerCircle::SetNewValue (G4UIcommand*, G4String newValue)
72 {
73 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
74
75 fCurrentArrow3DLineSegmentsPerCircle = fpCommand->GetNewIntValue(newValue);
76
77 if (verbosity >= G4VisManager::confirmations) {
78 G4cout <<
79 "Number of line segments per circle for drawing 3D arrows for future"
80 "\n \"/vis/scene/add/\" commands has been set to "
81 << fCurrentArrow3DLineSegmentsPerCircle
82 << G4endl;
83 }
84 }
85
86 ////////////// /vis/set/colour ////////////////////////////////////
87
88 G4VisCommandSetColour::G4VisCommandSetColour ()
89 {
90 G4bool omitable;
91 fpCommand = new G4UIcommand("/vis/set/colour", this);
92 fpCommand->SetGuidance
93 ("Defines colour and opacity for future \"/vis/scene/add/\" commands.");
94 fpCommand->SetGuidance
95 ("(Except \"/vis/scene/add/text\" commands - see \"/vis/set/textColour\".)");
96 fpCommand->SetGuidance(ConvertToColourGuidance());
97 fpCommand->SetGuidance("Default: white and opaque.");
98 G4UIparameter* parameter;
99 parameter = new G4UIparameter ("red", 's', omitable = true);
100 parameter->SetGuidance
101 ("Red component or a string, e.g., \"cyan\" (green and blue parameters are ignored).");
102 parameter->SetDefaultValue ("1.");
103 fpCommand->SetParameter (parameter);
104 parameter = new G4UIparameter ("green", 'd', omitable = true);
105 parameter->SetDefaultValue (1.);
106 fpCommand->SetParameter (parameter);
107 parameter = new G4UIparameter ("blue", 'd', omitable = true);
108 parameter->SetDefaultValue (1.);
109 fpCommand->SetParameter (parameter);
110 parameter = new G4UIparameter ("alpha", 'd', omitable = true);
111 parameter->SetDefaultValue (1.);
112 parameter->SetGuidance ("Opacity");
113 fpCommand->SetParameter (parameter);
114 }
115
116 G4VisCommandSetColour::~G4VisCommandSetColour ()
117 {
118 delete fpCommand;
119 }
120
121 G4String G4VisCommandSetColour::GetCurrentValue (G4UIcommand*)
122 {
123 return G4String();
124 }
125
126 void G4VisCommandSetColour::SetNewValue (G4UIcommand*, G4String newValue)
127 {
128 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
129
130 G4String redOrString;
131 G4double green, blue, opacity;
132 std::istringstream iss(newValue);
133 iss >> redOrString >> green >> blue >> opacity;
134
135 ConvertToColour(fCurrentColour, redOrString, green, blue, opacity);
136
137 if (verbosity >= G4VisManager::confirmations) {
138 G4cout <<
139 "Colour for future \"/vis/scene/add/\" commands has been set to "
140 << fCurrentColour <<
141 ".\n(Except \"/vis/scene/add/text\" commands - use \"/vis/set/textColour\".)"
142 << G4endl;
143 }
144 }
145
146 ////////////// /vis/set/extentForField ////////////////////////////////////
147
148 G4VisCommandSetExtentForField::G4VisCommandSetExtentForField ()
149 {
150 G4bool omitable;
151 fpCommand = new G4UIcommand("/vis/set/extentForField", this);
152 fpCommand->SetGuidance
153 ("Sets an extent for future \"/vis/scene/add/*Field\" commands.");
154 fpCommand->SetGuidance
155 ("The default is a null extent, which is interpreted by the commands as the"
156 "\nextent of the whole scene.");
157 G4UIparameter* parameter;
158 parameter = new G4UIparameter ("xmin", 'd', omitable = false);
159 fpCommand->SetParameter (parameter);
160 parameter = new G4UIparameter ("xmax", 'd', omitable = false);
161 fpCommand->SetParameter (parameter);
162 parameter = new G4UIparameter ("ymin", 'd', omitable = false);
163 fpCommand->SetParameter (parameter);
164 parameter = new G4UIparameter ("ymax", 'd', omitable = false);
165 fpCommand->SetParameter (parameter);
166 parameter = new G4UIparameter ("zmin", 'd', omitable = false);
167 fpCommand->SetParameter (parameter);
168 parameter = new G4UIparameter ("zmax", 'd', omitable = false);
169 fpCommand->SetParameter (parameter);
170 parameter = new G4UIparameter ("unit", 's', omitable = false);
171 fpCommand->SetParameter (parameter);
172 }
173
174 G4VisCommandSetExtentForField::~G4VisCommandSetExtentForField ()
175 {
176 delete fpCommand;
177 }
178
179 G4String G4VisCommandSetExtentForField::GetCurrentValue (G4UIcommand*)
180 {
181 return G4String();
182 }
183
184 void G4VisCommandSetExtentForField::SetNewValue (G4UIcommand*, G4String newValue)
185 {
186 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
187
188 G4double xmin, xmax, ymin, ymax, zmin, zmax;
189 G4String unitString;
190 std::istringstream iss(newValue);
191 iss >> xmin >> xmax >> ymin >> ymax >> zmin >> zmax >> unitString;
192 G4double unit = G4UIcommand::ValueOf(unitString);
193 xmin *= unit; xmax *= unit;
194 ymin *= unit; ymax *= unit;
195 zmin *= unit; zmax *= unit;
196
197 fCurrentExtentForField = G4VisExtent(xmin,xmax,ymin,ymax,zmin,zmax);
198 fCurrrentPVFindingsForField.clear();
199
200 if (verbosity >= G4VisManager::confirmations) {
201 G4cout <<
202 "Extent for future \"/vis/scene/add/*Field\" commands has been set to "
203 << fCurrentExtentForField
204 << "\nVolume for field has been cleared."
205 << G4endl;
206 }
207 }
208
209 ////////////// /vis/set/lineWidth ////////////////////////////////////
210
211 G4VisCommandSetLineWidth::G4VisCommandSetLineWidth ()
212 {
213 G4bool omitable;
214 fpCommand = new G4UIcmdWithADouble("/vis/set/lineWidth", this);
215 fpCommand->SetGuidance
216 ("Defines line width for future \"/vis/scene/add/\" commands."
217 "\nSee \"/vis/viewer/set/lineWidth\" for more information.");
218 fpCommand->SetParameterName ("lineWidth", omitable = true);
219 fpCommand->SetDefaultValue (1.);
220 fpCommand->SetRange("lineWidth >= 1.");
221 }
222
223 G4VisCommandSetLineWidth::~G4VisCommandSetLineWidth ()
224 {
225 delete fpCommand;
226 }
227
228 G4String G4VisCommandSetLineWidth::GetCurrentValue (G4UIcommand*)
229 {
230 return G4String();
231 }
232
233 void G4VisCommandSetLineWidth::SetNewValue (G4UIcommand*, G4String newValue)
234 {
235 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
236
237 fCurrentLineWidth = fpCommand->GetNewDoubleValue(newValue);
238
239 if (verbosity >= G4VisManager::warnings) {
240 G4warn <<
241 "Line width for *future* \"/vis/scene/add/\" commands has been set to "
242 << fCurrentLineWidth <<
243 "\nSee \"/vis/viewer/set/lineWidth\" for more information."
244 << G4endl;
245 }
246 }
247
248 ////////////// /vis/set/textColour ////////////////////////////////////
249
250 G4VisCommandSetTextColour::G4VisCommandSetTextColour ()
251 {
252 G4bool omitable;
253 fpCommand = new G4UIcommand("/vis/set/textColour", this);
254 fpCommand->SetGuidance
255 ("Defines colour and opacity for future \"/vis/scene/add/text\" commands.");
256 fpCommand->SetGuidance(ConvertToColourGuidance());
257 fpCommand->SetGuidance("Default: blue and opaque.");
258 G4UIparameter* parameter;
259 parameter = new G4UIparameter ("red", 's', omitable = true);
260 parameter->SetGuidance
261 ("Red component or a string, e.g., \"cyan\" (green and blue parameters are ignored).");
262 parameter->SetDefaultValue ("0.");
263 fpCommand->SetParameter (parameter);
264 parameter = new G4UIparameter ("green", 'd', omitable = true);
265 parameter->SetDefaultValue (0.);
266 fpCommand->SetParameter (parameter);
267 parameter = new G4UIparameter ("blue", 'd', omitable = true);
268 parameter->SetDefaultValue (1.);
269 fpCommand->SetParameter (parameter);
270 parameter = new G4UIparameter ("alpha", 'd', omitable = true);
271 parameter->SetDefaultValue (1.);
272 parameter->SetGuidance ("Opacity");
273 fpCommand->SetParameter (parameter);
274 }
275
276 G4VisCommandSetTextColour::~G4VisCommandSetTextColour ()
277 {
278 delete fpCommand;
279 }
280
281 G4String G4VisCommandSetTextColour::GetCurrentValue (G4UIcommand*)
282 {
283 return G4String();
284 }
285
286 void G4VisCommandSetTextColour::SetNewValue (G4UIcommand*, G4String newValue)
287 {
288 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
289
290 G4String redOrString;
291 G4double green, blue, opacity;
292 std::istringstream iss(newValue);
293 iss >> redOrString >> green >> blue >> opacity;
294
295 ConvertToColour(fCurrentTextColour, redOrString, green, blue, opacity);
296
297 if (verbosity >= G4VisManager::confirmations) {
298 G4cout <<
299 "Colour for future \"/vis/scene/add/text\" commands has been set to "
300 << fCurrentTextColour << '.'
301 << G4endl;
302 }
303 }
304
305 ////////////// /vis/set/textLayout ////////////////////////////////////
306
307 G4VisCommandSetTextLayout::G4VisCommandSetTextLayout ()
308 {
309 G4bool omitable;
310 fpCommand = new G4UIcmdWithAString("/vis/set/textLayout", this);
311 fpCommand->SetGuidance
312 ("Defines layout future \"/vis/scene/add/text\" commands.");
313 fpCommand->SetGuidance
314 ("\"left\" (default) for left justification to provided coordinate.");
315 fpCommand->SetGuidance
316 ("\"centre\" or \"center\" for text centered on provided coordinate.");
317 fpCommand->SetGuidance
318 ("\"right\" for right justification to provided coordinate.");
319 fpCommand->SetGuidance("Default: left.");
320 fpCommand->SetParameterName("layout", omitable = true);
321 fpCommand->SetCandidates ("left centre center right");
322 fpCommand->SetDefaultValue ("left");
323 }
324
325 G4VisCommandSetTextLayout::~G4VisCommandSetTextLayout ()
326 {
327 delete fpCommand;
328 }
329
330 G4String G4VisCommandSetTextLayout::GetCurrentValue (G4UIcommand*)
331 {
332 return G4String();
333 }
334
335 void G4VisCommandSetTextLayout::SetNewValue (G4UIcommand*, G4String newValue)
336 {
337 G4Text::Layout layout = G4Text::left;
338 if (newValue == "left") layout = G4Text::left;
339 else if (newValue == "centre" || newValue == "center")
340 layout = G4Text::centre;
341 else if (newValue == "right") layout = G4Text::right;
342
343 fCurrentTextLayout = layout;
344
345 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
346 if (verbosity >= G4VisManager::confirmations) {
347 G4cout << "Text layout (for future \"text\" commands) has been set to \""
348 << fCurrentTextLayout << "\"."
349 << G4endl;
350 }
351 }
352
353 ////////////// /vis/set/textSize ////////////////////////////////////
354
355 G4VisCommandSetTextSize::G4VisCommandSetTextSize ()
356 {
357 G4bool omitable;
358 fpCommand = new G4UIcmdWithADouble("/vis/set/textSize", this);
359 fpCommand->SetGuidance
360 ("Defines text size (pixels) for future \"/vis/scene/add/\" commands.");
361 fpCommand->SetParameterName ("textSize", omitable = true);
362 fpCommand->SetDefaultValue (12.); // pixels
363 fpCommand->SetRange("textSize >= 8.");
364 }
365
366 G4VisCommandSetTextSize::~G4VisCommandSetTextSize ()
367 {
368 delete fpCommand;
369 }
370
371 G4String G4VisCommandSetTextSize::GetCurrentValue (G4UIcommand*)
372 {
373 return G4String();
374 }
375
376 void G4VisCommandSetTextSize::SetNewValue (G4UIcommand*, G4String newValue)
377 {
378 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
379
380 fCurrentTextSize = fpCommand->GetNewDoubleValue(newValue);
381
382 if (verbosity >= G4VisManager::confirmations) {
383 G4cout <<
384 "Text size for future \"/vis/scene/add/\" commands has been set to "
385 << fCurrentTextSize
386 << G4endl;
387 }
388 }
389
390 ////////////// /vis/set/touchable ////////////////////////////////////
391
392 G4VisCommandSetTouchable::G4VisCommandSetTouchable ()
393 {
394 G4bool omitable;
395 G4UIparameter* parameter;
396 fpCommand = new G4UIcommand("/vis/set/touchable", this);
397 fpCommand->SetGuidance
398 ("Defines touchable for future \"/vis/touchable/set/\" commands.");
399 fpCommand->SetGuidance
400 ("Please provide a list of space-separated physical volume names and"
401 "\ncopy number pairs starting at the world volume, e.g:"
402 "\n /vis/set/touchable World 0 Envelope 0 Shape1 0"
403 "\n(To get list of touchables, use \"/vis/drawTree\")"
404 "\n(To save, use \"/vis/viewer/save\")");
405 parameter = new G4UIparameter ("list", 's', omitable = true);
406 parameter->SetGuidance
407 ("List of physical volume names and copy number pairs");
408 fpCommand->SetParameter (parameter);
409 }
410
411 G4VisCommandSetTouchable::~G4VisCommandSetTouchable ()
412 {
413 delete fpCommand;
414 }
415
416 G4String G4VisCommandSetTouchable::GetCurrentValue (G4UIcommand*)
417 {
418 return G4String();
419 }
420
421 void G4VisCommandSetTouchable::SetNewValue (G4UIcommand*, G4String newValue)
422 {
423 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
424
425 if (newValue.empty()) {
426 fCurrentTouchableProperties = G4PhysicalVolumeModel::TouchableProperties();
427 if (verbosity >= G4VisManager::confirmations) {
428 G4cout <<
429 "Current touchable reset to: " << fCurrentTouchableProperties.fTouchablePath
430 << G4endl;
431 }
432 return;
433 }
434
435 G4ModelingParameters::PVNameCopyNoPath currentTouchablePath;
436
437 // Algorithm from Josuttis p.476.
438 G4String::size_type iBegin, iEnd;
439 iBegin = newValue.find_first_not_of(' ');
440 while (iBegin != G4String::npos) {
441 iEnd = newValue.find_first_of(' ',iBegin);
442 if (iEnd == G4String::npos) {
443 iEnd = newValue.length();
444 }
445 const G4String& name(newValue.substr(iBegin,iEnd-iBegin));
446 iBegin = newValue.find_first_not_of(' ',iEnd);
447 if (iBegin == G4String::npos) {
448 if (verbosity >= G4VisManager::warnings) {
449 G4warn <<
450 "WARNING: G4VisCommandSetTouchable::SetNewValue"
451 "\n A pair not found. (There should be an even number of parameters.)"
452 "\n Command ignored."
453 << G4endl;
454 return;
455 }
456 }
457 iEnd = newValue.find_first_of(' ',iBegin);
458 if (iEnd == G4String::npos) {
459 iEnd = newValue.length();
460 }
461 G4int copyNo;
462 std::istringstream iss(newValue.substr(iBegin,iEnd-iBegin));
463 if (!(iss >> copyNo)) {
464 if (verbosity >= G4VisManager::warnings) {
465 G4warn <<
466 "WARNING: G4VisCommandSetTouchable::SetNewValue"
467 "\n Error reading copy number - it was not numeric?"
468 "\n Command ignored."
469 << G4endl;
470 return;
471 }
472 }
473 currentTouchablePath.push_back
474 (G4ModelingParameters::PVNameCopyNo(name,copyNo));
475 iBegin = newValue.find_first_not_of(' ',iEnd);
476 }
477
478 // Check validity
479 G4bool successful = false;
480 G4TransportationManager* transportationManager =
481 G4TransportationManager::GetTransportationManager ();
482 size_t nWorlds = transportationManager->GetNoWorlds();
483 std::vector<G4VPhysicalVolume*>::iterator iterWorld =
484 transportationManager->GetWorldsIterator();
485 for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
486 G4PhysicalVolumeModel pvModel (*iterWorld); // Unlimited depth.
487 G4ModelingParameters mp; // Default - no culling.
488 pvModel.SetModelingParameters (&mp);
489 G4TouchablePropertiesScene scene (&pvModel,currentTouchablePath);
490 pvModel.DescribeYourselfTo (scene); // Initiate geometry tree traversal.
491 if (scene.GetFoundTouchableProperties().fpTouchablePV) {
492 successful = true;
493 fCurrentTouchableProperties = scene.GetFoundTouchableProperties();
494 break; // Found, so no need to scan more worlds.
495 }
496 }
497
498 if (successful) {
499 if (verbosity >= G4VisManager::confirmations) {
500 G4cout <<
501 "Current touchable: " << fCurrentTouchableProperties.fTouchablePath
502 << G4endl;
503 return;
504 }
505 } else {
506 if (verbosity >= G4VisManager::warnings) {
507 G4warn <<
508 "WARNING: G4VisCommandSetTouchable::SetNewValue"
509 "\n Touchable not found."
510 << G4endl;
511 return;
512 }
513 }
514 }
515
516 ////////////// /vis/set/volumeForField ////////////////////////////////////
517
518 G4VisCommandSetVolumeForField::G4VisCommandSetVolumeForField ()
519 {
520 G4bool omitable;
521 G4UIparameter* parameter;
522 fpCommand = new G4UIcommand("/vis/set/volumeForField", this);
523 fpCommand->SetGuidance
524 ("Sets a volume for \"/vis/scene/add/*Field\" commands.");
525 fpCommand->SetGuidance
526 ("Takes a volume name or a /regular expression/ -- see guidance for"
527 "\n\"/vis/drawVolume\"");
528 parameter = new G4UIparameter ("physical-volume-name", 's', omitable = false);
529 fpCommand -> SetParameter (parameter);
530 parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
531 parameter -> SetGuidance ("If negative, matches any copy no.");
532 parameter -> SetDefaultValue (-1);
533 fpCommand -> SetParameter (parameter);
534 parameter = new G4UIparameter ("draw", 'b', omitable = true);
535 parameter -> SetGuidance ("If true, draw extent of found volumes.");
536 parameter -> SetDefaultValue (false);
537 fpCommand -> SetParameter (parameter);
538 }
539
540 G4VisCommandSetVolumeForField::~G4VisCommandSetVolumeForField ()
541 {
542 delete fpCommand;
543 }
544
545 G4String G4VisCommandSetVolumeForField::GetCurrentValue (G4UIcommand*)
546 {
547 return G4String();
548 }
549
550 void G4VisCommandSetVolumeForField::SetNewValue (G4UIcommand*, G4String newValue)
551 {
552 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
553
554 G4String name, drawString;
555 G4int copyNo;
556 std::istringstream is (newValue);
557 is >> name >> copyNo >> drawString;
558 G4bool draw = G4UIcmdWithABool::ConvertToBool(drawString);
559
560 G4TransportationManager* transportationManager =
561 G4TransportationManager::GetTransportationManager ();
562 size_t nWorlds = transportationManager->GetNoWorlds();
563 std::vector<G4VPhysicalVolume*>::iterator iterWorld =
564 transportationManager->GetWorldsIterator();
565 fCurrrentPVFindingsForField.clear();
566 G4BoundingExtentScene extentScene;
567 for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
568 G4PhysicalVolumeModel searchModel (*iterWorld); // Unlimited depth.
569 G4ModelingParameters mp; // Default - no culling.
570 searchModel.SetModelingParameters (&mp);
571 // Find all instances at any position in the tree
572 G4PhysicalVolumesSearchScene searchScene (&searchModel, name, copyNo);
573 searchModel.DescribeYourselfTo (searchScene); // Initiate search.
574 for (const auto& findings: searchScene.GetFindings()) {
575 fCurrrentPVFindingsForField.push_back(findings);
576 G4VisExtent extent = findings.fpFoundPV->GetLogicalVolume()->GetSolid()->GetExtent();
577 extent.Transform(findings.fFoundObjectTransformation);
578 extentScene.AccrueBoundingExtent(extent);
579 }
580 }
581
582 if (fCurrrentPVFindingsForField.empty()) {
583 if (verbosity >= G4VisManager::errors) {
584 G4warn << "ERROR: Volume \"" << name << "\"";
585 if (copyNo >= 0) {
586 G4warn << ", copy no. " << copyNo << ",";
587 }
588 G4warn << " not found." << G4endl;
589 }
590 return;
591 }
592
593 fCurrentExtentForField = extentScene.GetExtent();
594
595 if (draw) DrawExtent(fCurrentExtentForField);
596
597 if (verbosity >= G4VisManager::confirmations) {
598 for (const auto& findings: fCurrrentPVFindingsForField) {
599 G4cout
600 << "\"" << findings.fpFoundPV->GetName()
601 << "\", copy no. " << findings.fFoundPVCopyNo
602 << ", found\nin searched volume \""
603 << findings.fpSearchPV->GetName()
604 << "\" at depth " << findings.fFoundDepth
605 << ",\nbase path: \"" << findings.fFoundBasePVPath
606 << "\",\nand has been set as volume for field."
607 << G4endl;
608 }
609 }
610 }
611