Context Navigation

source: trunk/source/tracking/src/G4SteppingVerbose.cc@ 1088

Last change on this file since 1088 was 1011, checked in by garnier, 17 years ago
update
File size: 34.6 KB

Line
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: G4SteppingVerbose.cc,v 1.23 2006/07/14 14:13:57 tsasaki Exp $
28	// GEANT4 tag $Name: geant4-09-02-ref-02 $
29	//
30	//---------------------------------------------------------------
31	//
32	// G4SteppingVerbose.cc
33	//
34	// Description:
35	// Implementation of the G4SteppingVerbose class
36	// Contact:
37	// Questions and comments to this code should be sent to
38	// Katsuya Amako (e-mail: Katsuya.Amako@kek.jp)
39	// Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
40	//
41	//---------------------------------------------------------------
42
43	#include "G4SteppingVerbose.hh"
44	#include "G4SteppingManager.hh"
45
46	#include "G4VSensitiveDetector.hh" // Include from 'hits/digi'
47	#include "G4StepStatus.hh" // Include from 'tracking'
48
49	///#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
50
51	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
52	#include "G4UnitsTable.hh"
53	#else
54	#define G4BestUnit(a,b) a
55	#endif
56
57	//////////////////////////////////////////////////
58	G4SteppingVerbose::G4SteppingVerbose()
59	//////////////////////////////////////////////////
60	{
61	#ifdef G4_TRACKING_DEBUG
62	G4cout << "G4SteppingVerbose has instantiated" << G4endl;
63	#endif
64	}
65
66	//////////////////////////////////////////////////
67	G4SteppingVerbose::~G4SteppingVerbose()
68	//////////////////////////////////////////////////
69	{
70	}
71
72	//////////////////////////////////////////////////
73	void G4SteppingVerbose::NewStep()
74	//////////////////////////////////////////////////
75	{
76	}
77
78	//////////////////////////////////////////////////
79	void G4SteppingVerbose::AtRestDoItInvoked()
80	//////////////////////////////////////////////////
81	{
82	if(Silent==1){ return; }
83
84	G4VProcess* ptProcManager;
85	CopyState();
86
87	if(verboseLevel >= 3 ){
88	G4int npt=0;
89	G4cout << " **List of AtRestDoIt invoked:" << G4endl;
90	for(size_t np=0; np < MAXofAtRestLoops; np++){
91	size_t npGPIL = MAXofAtRestLoops-np-1;
92	if( (*fSelectedAtRestDoItVector)[npGPIL] == 2 ){
93	npt++;
94	ptProcManager = (*fAtRestDoItVector)[np];
95	G4cout << " # " << npt << " : "
96	<< ptProcManager->GetProcessName()
97	<< " (Forced)" << G4endl;
98	} else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 ){
99	npt++;
100	ptProcManager = (*fAtRestDoItVector)[np];
101	G4cout << " # " << npt << " : " << ptProcManager->GetProcessName() << G4endl;
102	}
103	}
104
105	G4cout << " Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
106
107	if( fN2ndariesAtRestDoIt > 0 ){
108	G4cout << " -- List of secondaries generated : " << "(x,y,z,kE,t,PID) --" << G4endl;
109	for( size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
110	lp1<(*fSecondary).size(); lp1++) {
111	G4cout << " "
112	<< std::setw( 9)
113	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
114	<< std::setw( 9)
115	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
116	<< std::setw( 9)
117	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
118	<< std::setw( 9)
119	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
120	<< std::setw( 9)
121	<< G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
122	<< std::setw(18)
123	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
124	}
125	}
126	}
127
128	if( verboseLevel >= 4 ){
129	ShowStep();
130	G4cout << G4endl;
131	}
132	}
133	/////////////////////////////////////////////////////
134	void G4SteppingVerbose::AlongStepDoItAllDone()
135	/////////////////////////////////////////////////////
136	{
137	if(Silent==1){ return; }
138
139	G4VProcess* ptProcManager;
140
141	CopyState();
142
143	if(verboseLevel >= 3){
144	G4cout << G4endl;
145	G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
146	G4cout << " ++List of invoked processes " << G4endl;
147
148	for(size_t ci=0; ci<MAXofAlongStepLoops; ci++){
149	ptProcManager = (*fAlongStepDoItVector)(ci);
150	G4cout << " " << ci+1 << ") ";
151	if(ptProcManager != NULL){
152	G4cout << ptProcManager->GetProcessName() << G4endl;
153	}
154	}
155
156	ShowStep();
157	G4cout << G4endl;
158	G4cout << " ++List of secondaries generated "
159	<< "(x,y,z,kE,t,PID):"
160	<< " No. of secodaries = "
161	<< (*fSecondary).size() << G4endl;
162
163	if((*fSecondary).size()>0){
164	for(size_t lp1=0; lp1<(*fSecondary).size(); lp1++){
165	G4cout << " "
166	<< std::setw( 9)
167	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
168	<< std::setw( 9)
169	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
170	<< std::setw( 9)
171	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
172	<< std::setw( 9)
173	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
174	<< std::setw( 9)
175	<< G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
176	<< std::setw(18)
177	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
178	}
179	}
180	}
181	}
182	////////////////////////////////////////////////////
183	void G4SteppingVerbose::PostStepDoItAllDone()
184	////////////////////////////////////////////////////
185	{
186	if(Silent==1){ return; }
187
188	G4VProcess* ptProcManager;
189
190	CopyState();
191
192	if( (fStepStatus == fPostStepDoItProc) \|
193	(fCondition == Forced) \|
194	(fCondition == Conditionally) \|
195	(fCondition == ExclusivelyForced) \|
196	(fCondition == StronglyForced) ){
197
198	if(verboseLevel >= 3){
199	G4int npt=0;
200	G4cout << G4endl;
201	G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
202	G4cout << " ++List of invoked processes " << G4endl;
203
204	for(size_t np=0; np < MAXofPostStepLoops; np++){
205	size_t npGPIL = MAXofPostStepLoops-np-1;
206	if( (*fSelectedPostStepDoItVector)[npGPIL] == 2){
207	npt++;
208	ptProcManager = (*fPostStepDoItVector)[np];
209	G4cout << " " << npt << ") "
210	<< ptProcManager->GetProcessName()
211	<< " (Forced)" << G4endl;
212	} else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1){
213	npt++;
214	ptProcManager = (*fPostStepDoItVector)[np];
215	G4cout << " " << npt << ") " << ptProcManager->GetProcessName() << G4endl;
216	}
217	}
218
219	ShowStep();
220	G4cout << G4endl;
221	G4cout << " ++List of secondaries generated "
222	<< "(x,y,z,kE,t,PID):"
223	<< " No. of secodaries = "
224	<< (*fSecondary).size() << G4endl;
225	G4cout << " [Note]Secondaries from AlongStepDoIt included." << G4endl;
226
227	if((*fSecondary).size()>0){
228	for(size_t lp1=0; lp1<(*fSecondary).size(); lp1++){
229	G4cout << " "
230	<< std::setw( 9)
231	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length") << " "
232	<< std::setw( 9)
233	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length") << " "
234	<< std::setw( 9)
235	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
236	<< std::setw( 9)
237	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy") << " "
238	<< std::setw( 9)
239	<< G4BestUnit((*fSecondary)[lp1]->GetGlobalTime() , "Time") << " "
240	<< std::setw(18)
241	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
242	}
243	}
244	}
245	}
246	}
247
248	/////////////////////////////////////////
249	void G4SteppingVerbose::StepInfo()
250	/////////////////////////////////////////
251	{
252	if(Silent==1){ return; }
253	if(SilentStepInfo==1){ return; }
254
255	CopyState();
256	G4cout.precision(16);
257	G4int prec = G4cout.precision(3);
258
259	if( verboseLevel >= 1 ){
260	if( verboseLevel >= 4 ) VerboseTrack();
261	if( verboseLevel >= 3 ){
262	G4cout << G4endl;
263	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
264	G4cout << std::setw( 5) << "#Step#" << " "
265	<< std::setw( 8) << "X" << " " << std::setw( 8) << "Y" << " "
266	<< std::setw( 8) << "Z" << " "
267	<< std::setw( 9) << "KineE" << " " << std::setw( 8) << "dE" << " "
268	<< std::setw(12) << "StepLeng" << " " << std::setw(12) << "TrackLeng" << " "
269	<< std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
270	#else
271	G4cout << std::setw( 5) << "#Step#" << " "
272	<< std::setw( 8) << "X(mm)" << " " << std::setw( 8) << "Y(mm)" << " "
273	<< std::setw( 8) << "Z(mm)" << " "
274	<< std::setw( 9) << "KinE(MeV)" << " " << std::setw( 8) << "dE(MeV)" << " "
275	<< std::setw( 8) << "StepLeng" << " " << std::setw( 9) << "TrackLeng" << " "
276	<< std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName" << G4endl;
277	#endif
278	}
279	G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
280	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().x() , "Length") << " "
281	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().y() , "Length") << " "
282	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().z() , "Length") << " "
283	<< std::setw( 9) << G4BestUnit(fTrack->GetKineticEnergy() , "Energy") << " "
284	<< std::setw( 8) << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
285	<< std::setw( 8) << G4BestUnit(fStep->GetStepLength() , "Length") << " "
286	<< std::setw( 9) << G4BestUnit(fTrack->GetTrackLength() , "Length") << " ";
287
288	// Put cut comment here
289	if( fTrack->GetNextVolume() != 0 ) {
290	G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
291	} else {
292	G4cout << std::setw(11) << "OutOfWorld" << " ";
293	}
294	if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != NULL){
295	G4cout << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
296	} else {
297	G4cout << "User Limit";
298	}
299	G4cout << G4endl;
300	if( verboseLevel == 2 )
301	{
302	G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt + fN2ndariesPostStepDoIt;
303	if(tN2ndariesTot>0){
304	G4cout << " :----- List of 2ndaries - "
305	<< "#SpawnInStep=" << std::setw(3) << tN2ndariesTot
306	<< "(Rest=" << std::setw(2) << fN2ndariesAtRestDoIt
307	<< ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
308	<< ",Post=" << std::setw(2) << fN2ndariesPostStepDoIt
309	<< "), "
310	<< "#SpawnTotal=" << std::setw(3) << (*fSecondary).size()
311	<< " ---------------"
312	<< G4endl;
313
314	for(size_t lp1=(fSecondary).size()-tN2ndariesTot; lp1<(fSecondary).size(); lp1++){
315	G4cout << " : "
316	<< std::setw( 9)
317	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
318	<< std::setw( 9)
319	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
320	<< std::setw( 9)
321	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
322	<< std::setw( 9)
323	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
324	<< std::setw(18)
325	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
326	}
327	G4cout << " :-----------------------------" << "----------------------------------"
328	<< "-- EndOf2ndaries Info ---------------" << G4endl;
329	}
330	}
331	}
332	G4cout.precision(prec);
333	}
334	// Put cut comment here if( fStepStatus != fWorldBoundary){
335
336	////////////////////////////////////////////
337	void G4SteppingVerbose::DPSLStarted()
338	////////////////////////////////////////////
339	{
340	if(Silent==1){ return; }
341	CopyState();
342
343	if( verboseLevel > 5 ){
344	G4cout << G4endl << " >>DefinePhysicalStepLength (List of proposed StepLengths): " << G4endl;
345	}
346	}
347	//////////////////////////////////////////////
348	void G4SteppingVerbose::DPSLUserLimit()
349	//////////////////////////////////////////////
350	{
351	if(Silent==1){ return; }
352	CopyState();
353
354	if( verboseLevel > 5 ){
355	G4cout << G4endl << G4endl;
356	G4cout << "=== Defined Physical Step Length (DPSL)" << G4endl;
357	G4cout << " ++ProposedStep(UserLimit) = " << std::setw( 9) << physIntLength
358	<< " : ProcName = User defined maximum allowed Step" << G4endl;
359	}
360	}
361	/////////////////////////////////////////////
362	void G4SteppingVerbose::DPSLPostStep()
363	/////////////////////////////////////////////
364	{
365	if(Silent==1){ return; }
366	CopyState();
367
368	if( verboseLevel > 5 ){
369	G4cout << " ++ProposedStep(PostStep ) = " << std::setw( 9) << physIntLength
370	<< " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
371	if(fCondition==ExclusivelyForced){
372	G4cout << "ExclusivelyForced)" << G4endl;
373	}
374	else if(fCondition==StronglyForced){
375	G4cout << "StronglyForced)" << G4endl;
376	}
377	else if(fCondition==Conditionally){
378	G4cout << "Conditionally)" << G4endl;
379	}
380	else if(fCondition==Forced){
381	G4cout << "Forced)" << G4endl;
382	}
383	else{
384	G4cout << "No ForceCondition)" << G4endl;
385	}
386	}
387	}
388	/////////////////////////////////////////////
389	void G4SteppingVerbose::DPSLAlongStep()
390	/////////////////////////////////////////////
391	{
392	if(Silent==1){ return; }
393	CopyState();
394
395	if( verboseLevel > 5 ){
396	G4cout << " ++ProposedStep(AlongStep) = "
397	<< std::setw( 9) << G4BestUnit(physIntLength , "Length")
398	<< " : ProcName = "
399	<< fCurrentProcess->GetProcessName()
400	<< " (";
401	if(fGPILSelection==CandidateForSelection){
402	G4cout << "CandidateForSelection)" << G4endl;
403	}
404	else if(fGPILSelection==NotCandidateForSelection){
405	G4cout << "NotCandidateForSelection)" << G4endl;
406	}
407	else{
408	G4cout << "?!?)" << G4endl;
409	}
410	}
411	}
412
413
414	////////////////////////////////////////////////
415	void G4SteppingVerbose::TrackingStarted()
416	////////////////////////////////////////////////
417	{
418	if(Silent==1){ return; }
419
420	CopyState();
421
422	G4int prec = G4cout.precision(3);
423	if( verboseLevel > 0 ){
424
425	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
426	G4cout << std::setw( 5) << "Step#" << " "
427	<< std::setw( 8) << "X" << " "
428	<< std::setw( 8) << "Y" << " "
429	<< std::setw( 8) << "Z" << " "
430	<< std::setw( 9) << "KineE" << " "
431	<< std::setw( 8) << "dE" << " "
432	<< std::setw(12) << "StepLeng" << " "
433	<< std::setw(12) << "TrackLeng" << " "
434	<< std::setw(12) << "NextVolume" << " "
435	<< std::setw( 8) << "ProcName" << G4endl;
436	#else
437	G4cout << std::setw( 5) << "Step#" << " "
438	<< std::setw( 8) << "X(mm)" << " "
439	<< std::setw( 8) << "Y(mm)" << " "
440	<< std::setw( 8) << "Z(mm)" << " "
441	<< std::setw( 9) << "KinE(MeV)" << " "
442	<< std::setw( 8) << "dE(MeV)" << " "
443	<< std::setw( 8) << "StepLeng" << " "
444	<< std::setw( 9) << "TrackLeng" << " "
445	<< std::setw(11) << "NextVolume" << " "
446	<< std::setw( 8) << "ProcName" << G4endl;
447	#endif
448
449	G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
450	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().x(),"Length")<< " "
451	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().y(),"Length") << " "
452	<< std::setw( 8) << G4BestUnit(fTrack->GetPosition().z(),"Length")<< " "
453	<< std::setw( 9) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")<< " "
454	<< std::setw( 8) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy") << " "
455	<< std::setw( 8) << G4BestUnit(fStep->GetStepLength(),"Length")<< " "
456	<< std::setw( 9) << G4BestUnit(fTrack->GetTrackLength(),"Length") << " ";
457
458	if(fTrack->GetNextVolume()){
459	G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
460	} else {
461	G4cout << std::setw(11) << "OutOfWorld" << " ";
462	}
463	G4cout << "initStep" << G4endl;
464	}
465	G4cout.precision(prec);
466	}
467	//////////////////////////////////////////////////////
468	void G4SteppingVerbose::AlongStepDoItOneByOne()
469	//////////////////////////////////////////////////////
470	{
471	if(Silent==1){ return; }
472
473	CopyState();
474
475	if(verboseLevel >= 4){
476	G4cout << G4endl;
477	G4cout << " >>AlongStepDoIt (process by process): "
478	<< " Process Name = "
479	<< fCurrentProcess->GetProcessName() << G4endl;
480
481	ShowStep();
482	G4cout << " "
483	<< "!Note! Safety of PostStep is only valid "
484	<< "after all DoIt invocations."
485	<< G4endl;
486
487	VerboseParticleChange();
488	G4cout << G4endl;
489
490	G4cout << " ++List of secondaries generated "
491	<< "(x,y,z,kE,t,PID):"
492	<< " No. of secodaries = "
493	<< fN2ndariesAlongStepDoIt << G4endl;
494
495	if(fN2ndariesAlongStepDoIt>0){
496	for(size_t lp1=(fSecondary).size()-fN2ndariesAlongStepDoIt; lp1<(fSecondary).size(); lp1++){
497	G4cout << " "
498	<< std::setw( 9)
499	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
500	<< std::setw( 9)
501	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
502	<< std::setw( 9)
503	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length")<< " "
504	<< std::setw( 9)
505	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
506	<< std::setw( 9)
507	<< G4BestUnit((*fSecondary)[lp1]->GetGlobalTime() , "Time")<< " "
508	<< std::setw(18)
509	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
510	}
511	}
512	}
513	}
514	//////////////////////////////////////////////////////
515	void G4SteppingVerbose::PostStepDoItOneByOne()
516	//////////////////////////////////////////////////////
517	{
518	if(Silent==1){ return; }
519
520	CopyState();
521
522	if(verboseLevel >= 4){
523	G4cout << G4endl;
524	G4cout << " >>PostStepDoIt (process by process): "
525	<< " Process Name = "
526	<< fCurrentProcess->GetProcessName() << G4endl;
527
528	ShowStep();
529	G4cout << G4endl;
530	VerboseParticleChange();
531	G4cout << G4endl;
532
533	G4cout << " ++List of secondaries generated "
534	<< "(x,y,z,kE,t,PID):"
535	<< " No. of secodaries = "
536	<< fN2ndariesPostStepDoIt << G4endl;
537
538	if(fN2ndariesPostStepDoIt>0){
539	for(size_t lp1=(fSecondary).size()-fN2ndariesPostStepDoIt; lp1<(fSecondary).size(); lp1++){
540	G4cout << " "
541	<< std::setw( 9)
542	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
543	<< std::setw( 9)
544	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length") << " "
545	<< std::setw( 9)
546	<< G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " "
547	<< std::setw( 9)
548	<< G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy") << " "
549	<< std::setw( 9)
550	<< G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
551	<< std::setw(18)
552	<< (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
553	}
554	}
555	}
556	}
557
558
559	//////////////////////////////////////
560	void G4SteppingVerbose::VerboseTrack()
561	//////////////////////////////////////
562	{
563	if(Silent==1){ return; }
564
565	CopyState();
566	// Show header
567	G4cout << G4endl;
568	G4cout << " ++G4Track Information " << G4endl;
569	G4int prec = G4cout.precision(3);
570
571
572	G4cout << " -----------------------------------------------"
573	<< G4endl;
574	G4cout << " G4Track Information " << std::setw(20) << G4endl;
575	G4cout << " -----------------------------------------------"
576	<< G4endl;
577
578	G4cout << " Step number : "
579	<< std::setw(20) << fTrack->GetCurrentStepNumber()
580	<< G4endl;
581	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
582	G4cout << " Position - x : "
583	<< std::setw(20) << G4BestUnit(fTrack->GetPosition().x(), "Length")
584	<< G4endl;
585	G4cout << " Position - y : "
586	<< std::setw(20) << G4BestUnit(fTrack->GetPosition().y(), "Length")
587	<< G4endl;
588	G4cout << " Position - z : "
589	<< std::setw(20) << G4BestUnit(fTrack->GetPosition().z(), "Length")
590	<< G4endl;
591	G4cout << " Global Time : "
592	<< std::setw(20) << G4BestUnit(fTrack->GetGlobalTime(), "Time")
593	<< G4endl;
594	G4cout << " Local Time : "
595	<< std::setw(20) << G4BestUnit(fTrack->GetLocalTime(), "Time")
596	<< G4endl;
597	#else
598	G4cout << " Position - x (mm) : "
599	<< std::setw(20) << fTrack->GetPosition().x() /mm
600	<< G4endl;
601	G4cout << " Position - y (mm) : "
602	<< std::setw(20) << fTrack->GetPosition().y() /mm
603	<< G4endl;
604	G4cout << " Position - z (mm) : "
605	<< std::setw(20) << fTrack->GetPosition().z() /mm
606	<< G4endl;
607	G4cout << " Global Time (ns) : "
608	<< std::setw(20) << fTrack->GetGlobalTime() /ns
609	<< G4endl;
610	G4cout << " Local Time (ns) : "
611	<< std::setw(20) << fTrack->GetLocalTime() /ns
612	<< G4endl;
613	#endif
614	G4cout << " Momentum Direct - x : "
615	<< std::setw(20) << fTrack->GetMomentumDirection().x()
616	<< G4endl;
617	G4cout << " Momentum Direct - y : "
618	<< std::setw(20) << fTrack->GetMomentumDirection().y()
619	<< G4endl;
620	G4cout << " Momentum Direct - z : "
621	<< std::setw(20) << fTrack->GetMomentumDirection().z()
622	<< G4endl;
623	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
624	G4cout << " Kinetic Energy : "
625	#else
626	G4cout << " Kinetic Energy (MeV): "
627	#endif
628	<< std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
629	<< G4endl;
630	G4cout << " Polarization - x : "
631	<< std::setw(20) << fTrack->GetPolarization().x()
632	<< G4endl;
633	G4cout << " Polarization - y : "
634	<< std::setw(20) << fTrack->GetPolarization().y()
635	<< G4endl;
636	G4cout << " Polarization - z : "
637	<< std::setw(20) << fTrack->GetPolarization().z()
638	<< G4endl;
639	G4cout << " Track Length : "
640	<< std::setw(20) << G4BestUnit(fTrack->GetTrackLength(), "Length")
641	<< G4endl;
642	G4cout << " Track ID # : "
643	<< std::setw(20) << fTrack->GetTrackID()
644	<< G4endl;
645	G4cout << " Parent Track ID # : "
646	<< std::setw(20) << fTrack->GetParentID()
647	<< G4endl;
648	G4cout << " Next Volume : "
649	<< std::setw(20);
650	if( fTrack->GetNextVolume() != 0 ) {
651	G4cout << fTrack->GetNextVolume()->GetName() << " ";
652	} else {
653	G4cout << "OutOfWorld" << " ";
654	}
655	G4cout << G4endl;
656	G4cout << " Track Status : "
657	<< std::setw(20);
658	if( fTrack->GetTrackStatus() == fAlive ){
659	G4cout << " Alive";
660	} else if( fTrack->GetTrackStatus() == fStopButAlive ){
661	G4cout << " StopButAlive";
662	} else if( fTrack->GetTrackStatus() == fStopAndKill ){
663	G4cout << " StopAndKill";
664	} else if( fTrack->GetTrackStatus() == fKillTrackAndSecondaries ){
665	G4cout << " KillTrackAndSecondaries";
666	} else if( fTrack->GetTrackStatus() == fSuspend ){
667	G4cout << " Suspend";
668	} else if( fTrack->GetTrackStatus() == fPostponeToNextEvent ){
669	G4cout << " PostponeToNextEvent";
670	}
671	G4cout << G4endl;
672	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
673	G4cout << " Vertex - x : "
674	<< std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().x(),"Length")
675	<< G4endl;
676	G4cout << " Vertex - y : "
677	<< std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().y(),"Length")
678	<< G4endl;
679	G4cout << " Vertex - z : "
680	<< std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().z(),"Length")
681	<< G4endl;
682	#else
683	G4cout << " Vertex - x (mm) : "
684	<< std::setw(20) << fTrack->GetVertexPosition().x()/mm
685	<< G4endl;
686	G4cout << " Vertex - y (mm) : "
687	<< std::setw(20) << fTrack->GetVertexPosition().y()/mm
688	<< G4endl;
689	G4cout << " Vertex - z (mm) : "
690	<< std::setw(20) << fTrack->GetVertexPosition().z()/mm
691	<< G4endl;
692	#endif
693	G4cout << " Vertex - Px (MomDir): "
694	<< std::setw(20) << fTrack->GetVertexMomentumDirection().x()
695	<< G4endl;
696	G4cout << " Vertex - Py (MomDir): "
697	<< std::setw(20) << fTrack->GetVertexMomentumDirection().y()
698	<< G4endl;
699	G4cout << " Vertex - Pz (MomDir): "
700	<< std::setw(20) << fTrack->GetVertexMomentumDirection().z()
701	<< G4endl;
702	#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
703	G4cout << " Vertex - KineE : "
704	#else
705	G4cout << " Vertex - KineE (MeV): "
706	#endif
707	<< std::setw(20) << G4BestUnit(fTrack->GetVertexKineticEnergy(),"Energy")
708	<< G4endl;
709
710	G4cout << " Creator Process : "
711	<< std::setw(20);
712	if( fTrack->GetCreatorProcess() == NULL){
713	G4cout << " Event Generator" << G4endl;
714	} else {
715	G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
716	}
717
718	G4cout << " -----------------------------------------------"
719	<< G4endl;
720
721	G4cout.precision(prec);
722	}
723
724
725	///////////////////////////////////////////////
726	void G4SteppingVerbose::VerboseParticleChange()
727	///////////////////////////////////////////////
728	{
729	if(Silent==1){ return; }
730	// Show header
731	G4cout << G4endl;
732	G4cout << " ++G4ParticleChange Information " << G4endl;
733	fParticleChange->DumpInfo();
734	}
735	/////////////////////////////////////////
736	void G4SteppingVerbose::ShowStep() const
737	////////////////////////////////////////
738	{
739	if(Silent==1){ return; }
740	G4String volName;
741
742	// Show header
743	G4cout << G4endl;
744	G4cout << " ++G4Step Information " << G4endl;
745	G4cout.precision(16);
746
747	// Show G4Step specific information
748	G4cout << " Address of G4Track : " << fStep->GetTrack() << G4endl;
749	G4cout << " Step Length (mm) : " << fStep->GetTrack()->GetStepLength() << G4endl;
750	G4cout << " Energy Deposit (MeV) : " << fStep->GetTotalEnergyDeposit() << G4endl;
751
752	// Show G4StepPoint specific information
753	G4cout << " -------------------------------------------------------"
754	<< "----------------" << G4endl;
755	G4cout << " StepPoint Information " << std::setw(20) << "PreStep"
756	<< std::setw(20) << "PostStep" << G4endl;
757	G4cout << " -------------------------------------------------------"
758	<< "----------------" << G4endl;
759	G4cout << " Position - x (mm) : "
760	<< std::setw(20) << fStep->GetPreStepPoint()->GetPosition().x()
761	<< std::setw(20) << fStep->GetPostStepPoint()->GetPosition().x() << G4endl;
762	G4cout << " Position - y (mm) : "
763	<< std::setw(20) << fStep->GetPreStepPoint()->GetPosition().y()
764	<< std::setw(20) << fStep->GetPostStepPoint()->GetPosition().y() << G4endl;
765	G4cout << " Position - z (mm) : "
766	<< std::setw(20) << fStep->GetPreStepPoint()->GetPosition().z()
767	<< std::setw(20) << fStep->GetPostStepPoint()->GetPosition().z() << G4endl;
768	G4cout << " Global Time (ns) : "
769	<< std::setw(20) << fStep->GetPreStepPoint()->GetGlobalTime()
770	<< std::setw(20) << fStep->GetPostStepPoint()->GetGlobalTime() << G4endl;
771	G4cout << " Local Time (ns) : "
772	<< std::setw(20) << fStep->GetPreStepPoint()->GetLocalTime()
773	<< std::setw(20) << fStep->GetPostStepPoint()->GetLocalTime() << G4endl;
774	G4cout << " Proper Time (ns) : "
775	<< std::setw(20) << fStep->GetPreStepPoint()->GetProperTime()
776	<< std::setw(20) << fStep->GetPostStepPoint()->GetProperTime() << G4endl;
777	G4cout << " Momentum Direct - x : "
778	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().x()
779	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().x() << G4endl;
780	G4cout << " Momentum Direct - y : "
781	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().y()
782	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().y() << G4endl;
783	G4cout << " Momentum Direct - z : "
784	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().z()
785	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().z() << G4endl;
786	G4cout << " Momentum - x (MeV/c): "
787	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().x()
788	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().x() << G4endl;
789	G4cout << " Momentum - y (MeV/c): "
790	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().y()
791	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().y() << G4endl;
792	G4cout << " Momentum - z (MeV/c): "
793	<< std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().z()
794	<< std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().z() << G4endl;
795	G4cout << " Total Energy (MeV) : "
796	<< std::setw(20) << fStep->GetPreStepPoint()->GetTotalEnergy()
797	<< std::setw(20) << fStep->GetPostStepPoint()->GetTotalEnergy() << G4endl;
798	G4cout << " Kinetic Energy (MeV): "
799	<< std::setw(20) << fStep->GetPreStepPoint()->GetKineticEnergy()
800	<< std::setw(20) << fStep->GetPostStepPoint()->GetKineticEnergy() << G4endl;
801	G4cout << " Velocity (mm/ns) : "
802	<< std::setw(20) << fStep->GetPreStepPoint()->GetVelocity()
803	<< std::setw(20) << fStep->GetPostStepPoint()->GetVelocity() << G4endl;
804	G4cout << " Volume Name : "
805	<< std::setw(20) << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
806	if (fStep->GetPostStepPoint()->GetPhysicalVolume())
807	{
808	volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
809	}
810	else
811	{
812	volName = "OutOfWorld";
813	}
814	G4cout << std::setw(20) << volName << G4endl;
815	G4cout << " Safety (mm) : "
816	<< std::setw(20) << fStep->GetPreStepPoint()->GetSafety()
817	<< std::setw(20) << fStep->GetPostStepPoint()->GetSafety() << G4endl;
818	G4cout << " Polarization - x : "
819	<< std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().x()
820	<< std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().x() << G4endl;
821	G4cout << " Polarization - y : "
822	<< std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().y()
823	<< std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().y() << G4endl;
824	G4cout << " Polarization - Z : "
825	<< std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().z()
826	<< std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().z() << G4endl;
827	G4cout << " Weight : "
828	<< std::setw(20) << fStep->GetPreStepPoint()->GetWeight()
829	<< std::setw(20) << fStep->GetPostStepPoint()->GetWeight() << G4endl;
830	G4cout << " Step Status : " ;
831	G4StepStatus tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
832	if( tStepStatus == fGeomBoundary ){
833	G4cout << std::setw(20) << "Geom Limit";
834	} else if ( tStepStatus == fAlongStepDoItProc ){
835	G4cout << std::setw(20) << "AlongStep Proc.";
836	} else if ( tStepStatus == fPostStepDoItProc ){
837	G4cout << std::setw(20) << "PostStep Proc";
838	} else if ( tStepStatus == fAtRestDoItProc ){
839	G4cout << std::setw(20) << "AtRest Proc";
840	} else if ( tStepStatus == fUndefined ){
841	G4cout << std::setw(20) << "Undefined";
842	}
843
844	tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
845	if( tStepStatus == fGeomBoundary ){
846	G4cout << std::setw(20) << "Geom Limit";
847	} else if ( tStepStatus == fAlongStepDoItProc ){
848	G4cout << std::setw(20) << "AlongStep Proc.";
849	} else if ( tStepStatus == fPostStepDoItProc ){
850	G4cout << std::setw(20) << "PostStep Proc";
851	} else if ( tStepStatus == fAtRestDoItProc ){
852	G4cout << std::setw(20) << "AtRest Proc";
853	} else if ( tStepStatus == fUndefined ){
854	G4cout << std::setw(20) << "Undefined";
855	}
856
857	G4cout << G4endl;
858	G4cout << " Process defined Step: " ;
859	if( fStep->GetPreStepPoint()->GetProcessDefinedStep() == NULL ){
860	G4cout << std::setw(20) << "Undefined";
861	} else {
862	G4cout << std::setw(20) << fStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName();
863	}
864	if( fStep->GetPostStepPoint()->GetProcessDefinedStep() == NULL){
865	G4cout << std::setw(20) << "Undefined";
866	} else {
867	G4cout << std::setw(20) << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
868	}
869
870	G4cout << G4endl;
871	G4cout << " -------------------------------------------------------"
872	<< "----------------" << G4endl;
873	}
874
875

Note: See TracBrowser for help on using the repository browser.

Download in other formats: