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