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