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