G4SteppingVerbose Class Reference

#include <G4SteppingVerbose.hh>

Inheritance diagram for G4SteppingVerbose:

Public Member Functions
	G4SteppingVerbose ()
	~G4SteppingVerbose ()
void	NewStep ()
void	AtRestDoItInvoked ()
void	AlongStepDoItAllDone ()
void	PostStepDoItAllDone ()
void	AlongStepDoItOneByOne ()
void	PostStepDoItOneByOne ()
void	StepInfo ()
void	TrackingStarted ()
void	DPSLStarted ()
void	DPSLUserLimit ()
void	DPSLPostStep ()
void	DPSLAlongStep ()
void	VerboseTrack ()
void	VerboseParticleChange ()
void	ShowStep () const

---

Detailed Description

Definition at line 51 of file G4SteppingVerbose.hh.

---

Constructor & Destructor Documentation

G4SteppingVerbose::G4SteppingVerbose

(

)

Definition at line 57 of file G4SteppingVerbose.cc.

References G4cout, and G4endl.

{
#ifdef G4_TRACKING_DEBUG
   G4cout << "G4SteppingVerbose has instantiated" << G4endl;
#endif
}

G4SteppingVerbose::~G4SteppingVerbose

(

)

Definition at line 66 of file G4SteppingVerbose.cc.

{
}

---

Member Function Documentation

void G4SteppingVerbose::AlongStepDoItAllDone

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 133 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fAlongStepDoItVector, G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofAlongStepLoops, ShowStep(), G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

{
   if(Silent==1){ return; }

   G4VProcess* ptProcManager;

   CopyState();

   if(verboseLevel >= 3){ 
      G4cout << G4endl;
      G4cout << " >>AlongStepDoIt (after all invocations):" << G4endl;
      G4cout << "    ++List of invoked processes " << G4endl;

      for(size_t ci=0; ci<MAXofAlongStepLoops; ci++){
          ptProcManager = (*fAlongStepDoItVector)(ci);
          G4cout << "      " << ci+1 << ") ";
          if(ptProcManager != 0){
             G4cout << ptProcManager->GetProcessName() << G4endl;
          }
      }

      ShowStep();
      G4cout << G4endl;
      G4cout << "    ++List of secondaries generated " 
             << "(x,y,z,kE,t,PID):"
             << "  No. of secodaries = " 
             << (*fSecondary).size() << G4endl;

      if((*fSecondary).size()>0){
         for(size_t lp1=0; lp1<(*fSecondary).size(); lp1++){
           G4cout << "      "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length")  << " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length")  << " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length")  << " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time")      << " "
                  << std::setw(18)
                  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName()      << G4endl;
               }
            }
   }
}

void G4SteppingVerbose::AlongStepDoItOneByOne

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 467 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fN2ndariesAlongStepDoIt, G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), G4VSteppingVerbose::Silent, G4VSteppingVerbose::verboseLevel, and VerboseParticleChange().

{ 
  if(Silent==1){ return; }

  CopyState();

  if(verboseLevel >= 4){ 
    G4cout << G4endl;
    G4cout << " >>AlongStepDoIt (process by process): "
           << "   Process Name = " 
           << fCurrentProcess->GetProcessName() << G4endl;

    ShowStep();
    G4cout << "          "
                 << "!Note! Safety of PostStep is only valid "
                 << "after all DoIt invocations."
                 << G4endl; 

    VerboseParticleChange();    
    G4cout << G4endl;

    G4cout << "    ++List of secondaries generated " 
                 << "(x,y,z,kE,t,PID):"
                 << "  No. of secodaries = " 
                 << fN2ndariesAlongStepDoIt << G4endl;

    if(fN2ndariesAlongStepDoIt>0){
       for(size_t lp1=(*fSecondary).size()-fN2ndariesAlongStepDoIt; lp1<(*fSecondary).size(); lp1++){
          G4cout  << "      "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length")<< " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
                  << std::setw( 9)
                  << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime() , "Time")<< " "
                  << std::setw(18)
                  << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
             }
          }
  }
}

void G4SteppingVerbose::AtRestDoItInvoked

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 78 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fN2ndariesAtRestDoIt, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fSelectedAtRestDoItVector, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofAtRestLoops, ShowStep(), G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

 {
   if(Silent==1){ return; }

   G4VProcess* ptProcManager;
   CopyState();

   if(verboseLevel >= 3 ){     
     G4int npt=0;
     G4cout << " **List of AtRestDoIt invoked:" << G4endl;
     for(size_t np=0; np < MAXofAtRestLoops; np++){
       size_t npGPIL = MAXofAtRestLoops-np-1;
       if( (*fSelectedAtRestDoItVector)[npGPIL] == 2 ){
               npt++;                
               ptProcManager = (*fAtRestDoItVector)[np];
               G4cout << "   # " << npt << " : " 
                      << ptProcManager->GetProcessName() 
                      << " (Forced)" << G4endl;
       } else if ( (*fSelectedAtRestDoItVector)[npGPIL] == 1 ){
               npt++;                
               ptProcManager = (*fAtRestDoItVector)[np];
               G4cout << "   # " << npt << " : "  << ptProcManager->GetProcessName() << G4endl;
       }
     }
     
     G4cout << "   Generated secondries # : " << fN2ndariesAtRestDoIt << G4endl;
     
     if( fN2ndariesAtRestDoIt > 0 ){
       G4cout << "   -- List of secondaries generated : " << "(x,y,z,kE,t,PID) --" << G4endl; 
       for( size_t lp1=(*fSecondary).size()-fN2ndariesAtRestDoIt;
                   lp1<(*fSecondary).size(); lp1++) {
         G4cout << "      "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().x(),"Length") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(),"Length") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(),"Length") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(),"Energy") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(),"Time") << " "
                << std::setw(18)
                << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
       }
     }
   }
   
   if( verboseLevel >= 4 ){ 
     ShowStep();
     G4cout << G4endl;
   }
}

void G4SteppingVerbose::DPSLAlongStep

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 388 of file G4SteppingVerbose.cc.

References CandidateForSelection, G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fGPILSelection, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), NotCandidateForSelection, G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

{
  if(Silent==1){ return; }
  CopyState();

  if( verboseLevel > 5 ){
    G4cout << "    ++ProposedStep(AlongStep) = " 
           << std::setw( 9) << G4BestUnit(physIntLength , "Length")
           << " : ProcName = "
           << fCurrentProcess->GetProcessName() 
           << " (";
    if(fGPILSelection==CandidateForSelection){
      G4cout << "CandidateForSelection)" << G4endl;
    }
    else if(fGPILSelection==NotCandidateForSelection){
      G4cout << "NotCandidateForSelection)" << G4endl;
    }
    else{
      G4cout << "?!?)" << G4endl;
    }
  }
}

void G4SteppingVerbose::DPSLPostStep

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 361 of file G4SteppingVerbose.cc.

References Conditionally, G4VSteppingVerbose::CopyState(), ExclusivelyForced, G4VSteppingVerbose::fCondition, G4VSteppingVerbose::fCurrentProcess, Forced, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, StronglyForced, and G4VSteppingVerbose::verboseLevel.

{
  if(Silent==1){ return; }
  CopyState();

  if( verboseLevel > 5 ){
    G4cout << "    ++ProposedStep(PostStep ) = " << std::setw( 9) << physIntLength
           << " : ProcName = " << fCurrentProcess->GetProcessName() << " (";
    if(fCondition==ExclusivelyForced){
      G4cout << "ExclusivelyForced)" << G4endl;
    }
    else if(fCondition==StronglyForced){
      G4cout << "StronglyForced)" << G4endl;
    }
    else if(fCondition==Conditionally){
      G4cout << "Conditionally)" << G4endl;
    }
    else if(fCondition==Forced){
      G4cout << "Forced)" << G4endl;
    }
    else{
      G4cout << "No ForceCondition)" << G4endl;
    }
  }
}

void G4SteppingVerbose::DPSLStarted

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 336 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4cout, G4endl, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

{
   if(Silent==1){ return; }
  CopyState();

  if( verboseLevel > 5 ){
    G4cout << G4endl << " >>DefinePhysicalStepLength (List of proposed StepLengths): "  << G4endl;
  }
}

void G4SteppingVerbose::DPSLUserLimit

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 347 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4cout, G4endl, G4VSteppingVerbose::physIntLength, G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

{
   if(Silent==1){ return; }
  CopyState();

  if( verboseLevel > 5 ){
    G4cout << G4endl << G4endl;
    G4cout << "=== Defined Physical Step Length (DPSL)"             << G4endl;
    G4cout << "    ++ProposedStep(UserLimit) = " << std::setw( 9) << physIntLength
                 << " : ProcName = User defined maximum allowed Step"     << G4endl;
  }
}

void G4SteppingVerbose::NewStep

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 72 of file G4SteppingVerbose.cc.

{
}

void G4SteppingVerbose::PostStepDoItAllDone

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 182 of file G4SteppingVerbose.cc.

References Conditionally, G4VSteppingVerbose::CopyState(), ExclusivelyForced, G4VSteppingVerbose::fCondition, Forced, fPostStepDoItProc, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fSelectedPostStepDoItVector, G4VSteppingVerbose::fStepStatus, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), G4VSteppingVerbose::MAXofPostStepLoops, ShowStep(), G4VSteppingVerbose::Silent, StronglyForced, and G4VSteppingVerbose::verboseLevel.

{
   if(Silent==1){ return; }

   G4VProcess* ptProcManager;

   CopyState();

   if( (fStepStatus == fPostStepDoItProc) |
       (fCondition  == Forced)            |
       (fCondition  == Conditionally)     |
       (fCondition  == ExclusivelyForced) |
       (fCondition  == StronglyForced) ){

     if(verboseLevel >= 3){
        G4int npt=0;
        G4cout << G4endl;
        G4cout << " **PostStepDoIt (after all invocations):" << G4endl;
        G4cout << "    ++List of invoked processes " << G4endl;

        for(size_t np=0; np < MAXofPostStepLoops; np++){
           size_t npGPIL = MAXofPostStepLoops-np-1;
           if( (*fSelectedPostStepDoItVector)[npGPIL] == 2){
             npt++;
             ptProcManager = (*fPostStepDoItVector)[np];
             G4cout << "      " << npt << ") "
                    << ptProcManager->GetProcessName()
                    << " (Forced)" << G4endl;
           } else if ( (*fSelectedPostStepDoItVector)[npGPIL] == 1){
             npt++;
             ptProcManager = (*fPostStepDoItVector)[np];
             G4cout << "      " << npt << ") " << ptProcManager->GetProcessName() << G4endl;
           }
        }

        ShowStep();
        G4cout << G4endl;
        G4cout << "    ++List of secondaries generated "
               << "(x,y,z,kE,t,PID):"
               << "  No. of secodaries = "
               << (*fSecondary).size() << G4endl;
        G4cout << "      [Note]Secondaries from AlongStepDoIt included." << G4endl;

        if((*fSecondary).size()>0){
          for(size_t lp1=0; lp1<(*fSecondary).size(); lp1++){
            G4cout  << "      "
                    << std::setw( 9)
                    << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length") << " "
                    << std::setw( 9)
                    << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length") << " "
                    << std::setw( 9)
                    << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
                    << std::setw( 9)
                    << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy") << " "
                    << std::setw( 9)
                    << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime() , "Time") << " "
                    << std::setw(18)
                    << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
          }
        }
     }
   }
}

void G4SteppingVerbose::PostStepDoItOneByOne

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 514 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fCurrentProcess, G4VSteppingVerbose::fN2ndariesPostStepDoIt, G4VSteppingVerbose::fSecondary, G4BestUnit, G4cout, G4endl, G4VProcess::GetProcessName(), ShowStep(), G4VSteppingVerbose::Silent, G4VSteppingVerbose::verboseLevel, and VerboseParticleChange().

{
  if(Silent==1){ return; }

  CopyState();

  if(verboseLevel >= 4){ 
    G4cout << G4endl;
    G4cout << " >>PostStepDoIt (process by process): "
           << "   Process Name = " 
           << fCurrentProcess->GetProcessName() << G4endl;

    ShowStep();
    G4cout << G4endl;
    VerboseParticleChange();    
    G4cout << G4endl;

    G4cout << "    ++List of secondaries generated " 
           << "(x,y,z,kE,t,PID):"
           << "  No. of secodaries = " 
           << fN2ndariesPostStepDoIt << G4endl;

    if(fN2ndariesPostStepDoIt>0){
      for(size_t lp1=(*fSecondary).size()-fN2ndariesPostStepDoIt; lp1<(*fSecondary).size(); lp1++){
         G4cout << "      "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().y(), "Length") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetPosition().z(), "Length") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy(), "Energy") << " "
                << std::setw( 9)
                << G4BestUnit((*fSecondary)[lp1]->GetGlobalTime(), "Time") << " "
                << std::setw(18)
                << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
            }
    }
  }
}

void G4SteppingVerbose::ShowStep

(

)

const

Definition at line 735 of file G4SteppingVerbose.cc.

References fAlongStepDoItProc, fAtRestDoItProc, fGeomBoundary, fPostStepDoItProc, G4VSteppingVerbose::fStep, fUndefined, G4cout, G4endl, G4StepPoint::GetGlobalTime(), G4StepPoint::GetKineticEnergy(), G4StepPoint::GetLocalTime(), G4StepPoint::GetMomentum(), G4StepPoint::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4StepPoint::GetPhysicalVolume(), G4StepPoint::GetPolarization(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4StepPoint::GetProperTime(), G4StepPoint::GetSafety(), G4Track::GetStepLength(), G4StepPoint::GetStepStatus(), G4StepPoint::GetTotalEnergy(), G4Step::GetTotalEnergyDeposit(), G4Step::GetTrack(), G4StepPoint::GetVelocity(), G4StepPoint::GetWeight(), and G4VSteppingVerbose::Silent.

Referenced by AlongStepDoItAllDone(), AlongStepDoItOneByOne(), AtRestDoItInvoked(), PostStepDoItAllDone(), and PostStepDoItOneByOne().

{
  if(Silent==1){ return; }
   G4String volName;
   G4int oldprc;

// Show header
   G4cout << G4endl;
   G4cout << "    ++G4Step Information " << G4endl;
   oldprc = G4cout.precision(16);

// Show G4Step specific information
   G4cout << "      Address of G4Track    : " << fStep->GetTrack() << G4endl;
   G4cout << "      Step Length (mm)      : " << fStep->GetTrack()->GetStepLength() << G4endl;
   G4cout << "      Energy Deposit (MeV)  : " << fStep->GetTotalEnergyDeposit() << G4endl;

// Show G4StepPoint specific information
   G4cout << "      -------------------------------------------------------" 
        << "----------------" <<  G4endl;
   G4cout << "        StepPoint Information  " << std::setw(20) << "PreStep" 
                                             << std::setw(20) << "PostStep" << G4endl;
   G4cout << "      -------------------------------------------------------" 
        << "----------------" <<  G4endl;
   G4cout << "         Position - x (mm)   : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().x() 
        << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().x() << G4endl;
   G4cout << "         Position - y (mm)   : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().y() 
        << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().y() << G4endl;
   G4cout << "         Position - z (mm)   : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPosition().z() 
        << std::setw(20) << fStep->GetPostStepPoint()->GetPosition().z() << G4endl;
   G4cout << "         Global Time (ns)    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetGlobalTime()
        << std::setw(20) << fStep->GetPostStepPoint()->GetGlobalTime() << G4endl;
   G4cout << "         Local Time (ns)     : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetLocalTime() 
        << std::setw(20) << fStep->GetPostStepPoint()->GetLocalTime() << G4endl;
   G4cout << "         Proper Time (ns)    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetProperTime()
        << std::setw(20) << fStep->GetPostStepPoint()->GetProperTime() << G4endl;
   G4cout << "         Momentum Direct - x : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().x()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().x() << G4endl;
   G4cout << "         Momentum Direct - y : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().y()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().y() << G4endl;
   G4cout << "         Momentum Direct - z : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentumDirection().z()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentumDirection().z() << G4endl;
   G4cout << "         Momentum - x (MeV/c): " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().x()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().x() << G4endl;
   G4cout << "         Momentum - y (MeV/c): " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().y()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().y() << G4endl;
   G4cout << "         Momentum - z (MeV/c): " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetMomentum().z()
        << std::setw(20) << fStep->GetPostStepPoint()->GetMomentum().z() << G4endl;
   G4cout << "         Total Energy (MeV)  : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetTotalEnergy()
        << std::setw(20) << fStep->GetPostStepPoint()->GetTotalEnergy() << G4endl;
   G4cout << "         Kinetic Energy (MeV): " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetKineticEnergy()
        << std::setw(20) << fStep->GetPostStepPoint()->GetKineticEnergy() << G4endl;
   G4cout << "         Velocity (mm/ns)    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetVelocity()
        << std::setw(20) << fStep->GetPostStepPoint()->GetVelocity() << G4endl;
   G4cout << "         Volume Name         : "
        << std::setw(20) << fStep->GetPreStepPoint()->GetPhysicalVolume()->GetName();
   if (fStep->GetPostStepPoint()->GetPhysicalVolume())
   {
      volName = fStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
   }
   else
   {
      volName = "OutOfWorld";
   }
   G4cout << std::setw(20) << volName << G4endl;
   G4cout << "         Safety (mm)         : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetSafety()
        << std::setw(20) << fStep->GetPostStepPoint()->GetSafety() << G4endl;
   G4cout << "         Polarization - x    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().x()
        << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().x() << G4endl;
   G4cout << "         Polarization - y    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().y()
        << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().y() << G4endl;
   G4cout << "         Polarization - Z    : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetPolarization().z()
        << std::setw(20) << fStep->GetPostStepPoint()->GetPolarization().z() << G4endl;
   G4cout << "         Weight              : " 
        << std::setw(20) << fStep->GetPreStepPoint()->GetWeight()
        << std::setw(20) << fStep->GetPostStepPoint()->GetWeight() << G4endl;
   G4cout << "         Step Status         : " ;
        G4StepStatus  tStepStatus = fStep->GetPreStepPoint()->GetStepStatus();
        if( tStepStatus == fGeomBoundary ){
           G4cout << std::setw(20) << "Geom Limit";
        } else if ( tStepStatus == fAlongStepDoItProc ){
          G4cout << std::setw(20) << "AlongStep Proc.";
        } else if ( tStepStatus == fPostStepDoItProc ){
           G4cout << std::setw(20) << "PostStep Proc";
        } else if ( tStepStatus == fAtRestDoItProc ){
           G4cout << std::setw(20) << "AtRest Proc";
        } else if ( tStepStatus == fUndefined ){
           G4cout << std::setw(20) << "Undefined";
        }

        tStepStatus = fStep->GetPostStepPoint()->GetStepStatus();
        if( tStepStatus == fGeomBoundary ){
           G4cout << std::setw(20) << "Geom Limit";
        } else if ( tStepStatus == fAlongStepDoItProc ){
           G4cout << std::setw(20) << "AlongStep Proc.";
        } else if ( tStepStatus == fPostStepDoItProc ){
           G4cout << std::setw(20) << "PostStep Proc";
        } else if ( tStepStatus == fAtRestDoItProc ){
           G4cout << std::setw(20) << "AtRest Proc";
        } else if ( tStepStatus == fUndefined ){
           G4cout << std::setw(20) << "Undefined";
        }

        G4cout << G4endl;
        G4cout << "         Process defined Step: " ;
        if( fStep->GetPreStepPoint()->GetProcessDefinedStep() == 0 ){
           G4cout << std::setw(20) << "Undefined";
        } else {
           G4cout << std::setw(20) << fStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName();
        }
        if( fStep->GetPostStepPoint()->GetProcessDefinedStep() == 0){
           G4cout << std::setw(20) << "Undefined";
        } else {
           G4cout << std::setw(20) << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName(); 
        }
   G4cout.precision(oldprc);

   G4cout << G4endl;
   G4cout << "      -------------------------------------------------------" 
        << "----------------" << G4endl;
}

void G4SteppingVerbose::StepInfo

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 248 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fN2ndariesAlongStepDoIt, G4VSteppingVerbose::fN2ndariesAtRestDoIt, G4VSteppingVerbose::fN2ndariesPostStepDoIt, G4VSteppingVerbose::fSecondary, G4VSteppingVerbose::fStep, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackLength(), G4VSteppingVerbose::Silent, G4VSteppingVerbose::SilentStepInfo, G4VSteppingVerbose::verboseLevel, and VerboseTrack().

{
   if(Silent==1){ return; }
   if(SilentStepInfo==1){ return; }

  CopyState();
  G4cout.precision(16); 
  G4int prec = G4cout.precision(3);

  if( verboseLevel >= 1 ){
    if( verboseLevel >= 4 ) VerboseTrack();
    if( verboseLevel >= 3 ){
      G4cout << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE      
      G4cout << std::setw( 5) << "#Step#" << " "
             << std::setw( 8) << "X"      << "     " << std::setw( 8) << "Y"      << "     "  
             << std::setw( 8) << "Z"      << "     "
             << std::setw( 9) << "KineE"  << "     " << std::setw( 8) << "dE"     << "     "  
             << std::setw(12) << "StepLeng"   << " " << std::setw(12) << "TrackLeng"  << " "
             << std::setw(12) << "NextVolume" << " " << std::setw( 8) << "ProcName"   << G4endl;               
#else
      G4cout << std::setw( 5) << "#Step#"      << " "
             << std::setw( 8) << "X(mm)"      << " " << std::setw( 8) << "Y(mm)"      << " "  
             << std::setw( 8) << "Z(mm)"      << " "
             << std::setw( 9) << "KinE(MeV)"  << " " << std::setw( 8) << "dE(MeV)"    << " "  
             << std::setw( 8) << "StepLeng"   << " " << std::setw( 9) << "TrackLeng"  << " "  
             << std::setw(11) << "NextVolume" << " " << std::setw( 8) << "ProcName"   << G4endl;
#endif       
    }
    G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().x() , "Length") << " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().y() , "Length") << " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().z() , "Length") << " "
                 << std::setw( 9) << G4BestUnit(fTrack->GetKineticEnergy() , "Energy") << " "
                 << std::setw( 8) << G4BestUnit(fStep->GetTotalEnergyDeposit(), "Energy") << " "
                 << std::setw( 8) << G4BestUnit(fStep->GetStepLength() , "Length") << " "
                 << std::setw( 9) << G4BestUnit(fTrack->GetTrackLength() , "Length") << " ";

    // Put cut comment here
    if( fTrack->GetNextVolume() != 0 ) { 
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    } else {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    if(fStep->GetPostStepPoint()->GetProcessDefinedStep() != 0){
      G4cout << fStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
    } else {
      G4cout << "User Limit";
    }
    G4cout << G4endl;
    if( verboseLevel == 2 )
    {
      G4int tN2ndariesTot = fN2ndariesAtRestDoIt + fN2ndariesAlongStepDoIt + fN2ndariesPostStepDoIt;
      if(tN2ndariesTot>0){
        G4cout << "    :----- List of 2ndaries - "
                     << "#SpawnInStep=" << std::setw(3) << tN2ndariesTot 
                     << "(Rest=" << std::setw(2) << fN2ndariesAtRestDoIt
                     << ",Along=" << std::setw(2) << fN2ndariesAlongStepDoIt
                     << ",Post="  << std::setw(2) << fN2ndariesPostStepDoIt
                     << "), "
                     << "#SpawnTotal=" << std::setw(3) << (*fSecondary).size()
                     << " ---------------"
                     << G4endl;

              for(size_t lp1=(*fSecondary).size()-tN2ndariesTot; lp1<(*fSecondary).size(); lp1++){
                G4cout << "    : "
                             << std::setw( 9)
                             << G4BestUnit((*fSecondary)[lp1]->GetPosition().x() , "Length")<< " "
                             << std::setw( 9)
                             << G4BestUnit((*fSecondary)[lp1]->GetPosition().y() , "Length")<< " "
                             << std::setw( 9)
                             << G4BestUnit((*fSecondary)[lp1]->GetPosition().z() , "Length") << " "
                             << std::setw( 9)
                             << G4BestUnit((*fSecondary)[lp1]->GetKineticEnergy() , "Energy")<< " "
                             << std::setw(18)
                             << (*fSecondary)[lp1]->GetDefinition()->GetParticleName() << G4endl;
              }
              G4cout << "    :-----------------------------" << "----------------------------------"
                     << "-- EndOf2ndaries Info ---------------"  << G4endl;
      }
    }
  }
  G4cout.precision(prec);
}

void G4SteppingVerbose::TrackingStarted

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 414 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), G4VSteppingVerbose::fStep, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetPosition(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackLength(), G4VSteppingVerbose::Silent, and G4VSteppingVerbose::verboseLevel.

{
  if(Silent==1){ return; }

  CopyState();

  G4int prec = G4cout.precision(3);
  if( verboseLevel > 0 ){

#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
    G4cout << std::setw( 5) << "Step#"  << " "
           << std::setw( 8) << "X"      << "     "
                 << std::setw( 8) << "Y"      << "     "  
                 << std::setw( 8) << "Z"      << "     "
                 << std::setw( 9) << "KineE"  << "     "
                 << std::setw( 8) << "dE"     << "     "  
                 << std::setw(12) << "StepLeng"   << " "  
                 << std::setw(12) << "TrackLeng"  << " "
                 << std::setw(12) << "NextVolume" << " "
                 << std::setw( 8) << "ProcName"   << G4endl;         
#else
    G4cout << std::setw( 5) << "Step#"      << " "
                 << std::setw( 8) << "X(mm)"      << " "
                 << std::setw( 8) << "Y(mm)"      << " "  
                 << std::setw( 8) << "Z(mm)"      << " "
                 << std::setw( 9) << "KinE(MeV)"  << " "
                 << std::setw( 8) << "dE(MeV)"    << " "  
                 << std::setw( 8) << "StepLeng"   << " "  
                 << std::setw( 9) << "TrackLeng"  << " "
                 << std::setw(11) << "NextVolume" << " "
                 << std::setw( 8) << "ProcName"   << G4endl;         
#endif

    G4cout << std::setw( 5) << fTrack->GetCurrentStepNumber() << " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().x(),"Length")<< " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().y(),"Length") << " "
                 << std::setw( 8) << G4BestUnit(fTrack->GetPosition().z(),"Length")<< " "
                 << std::setw( 9) << G4BestUnit(fTrack->GetKineticEnergy(),"Energy")<< " "
                 << std::setw( 8) << G4BestUnit(fStep->GetTotalEnergyDeposit(),"Energy") << " "
                 << std::setw( 8) << G4BestUnit(fStep->GetStepLength(),"Length")<< " "
                 << std::setw( 9) << G4BestUnit(fTrack->GetTrackLength(),"Length") << " ";

    if(fTrack->GetNextVolume()){
      G4cout << std::setw(11) << fTrack->GetNextVolume()->GetName() << " ";
    } else {
      G4cout << std::setw(11) << "OutOfWorld" << " ";
    }
    G4cout << "initStep" << G4endl;
  }
  G4cout.precision(prec);
}

void G4SteppingVerbose::VerboseParticleChange

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 725 of file G4SteppingVerbose.cc.

References G4VParticleChange::DumpInfo(), G4VSteppingVerbose::fParticleChange, G4cout, G4endl, and G4VSteppingVerbose::Silent.

Referenced by AlongStepDoItOneByOne(), and PostStepDoItOneByOne().

{
  if(Silent==1){ return; }
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4ParticleChange Information " << G4endl;
  fParticleChange->DumpInfo();
}

void G4SteppingVerbose::VerboseTrack

(

)

[virtual]

Implements G4VSteppingVerbose.

Definition at line 559 of file G4SteppingVerbose.cc.

References G4VSteppingVerbose::CopyState(), fAlive, fKillTrackAndSecondaries, fPostponeToNextEvent, fStopAndKill, fStopButAlive, fSuspend, G4VSteppingVerbose::fTrack, G4BestUnit, G4cout, G4endl, G4Track::GetCreatorProcess(), G4Track::GetCurrentStepNumber(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4Track::GetLocalTime(), G4Track::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4Track::GetNextVolume(), G4Track::GetParentID(), G4Track::GetPolarization(), G4Track::GetPosition(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), G4Track::GetTrackLength(), G4Track::GetTrackStatus(), G4Track::GetVertexKineticEnergy(), G4Track::GetVertexMomentumDirection(), G4Track::GetVertexPosition(), ns, and G4VSteppingVerbose::Silent.

Referenced by StepInfo().

{
  if(Silent==1){ return; }

  CopyState();
// Show header
  G4cout << G4endl;
  G4cout << "    ++G4Track Information " << G4endl;
  G4int prec = G4cout.precision(3);


  G4cout << "      -----------------------------------------------" 
       << G4endl;
  G4cout << "        G4Track Information  " << std::setw(20) << G4endl;
  G4cout << "      -----------------------------------------------" 
       << G4endl;

  G4cout << "        Step number         : " 
       << std::setw(20) << fTrack->GetCurrentStepNumber()
       << G4endl; 
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Position - x        : " 
       << std::setw(20) << G4BestUnit(fTrack->GetPosition().x(), "Length")
       << G4endl; 
  G4cout << "        Position - y        : " 
       << std::setw(20) << G4BestUnit(fTrack->GetPosition().y(), "Length")
       << G4endl; 
  G4cout << "        Position - z        : " 
       << std::setw(20) << G4BestUnit(fTrack->GetPosition().z(), "Length")
       << G4endl;
  G4cout << "        Global Time         : " 
       << std::setw(20) << G4BestUnit(fTrack->GetGlobalTime(), "Time")
       << G4endl;
  G4cout << "        Local Time          : " 
       << std::setw(20) << G4BestUnit(fTrack->GetLocalTime(), "Time")
       << G4endl;
#else
  G4cout << "        Position - x (mm)   : " 
       << std::setw(20) << fTrack->GetPosition().x() /mm
       << G4endl; 
  G4cout << "        Position - y (mm)   : " 
       << std::setw(20) << fTrack->GetPosition().y() /mm
       << G4endl; 
  G4cout << "        Position - z (mm)   : " 
       << std::setw(20) << fTrack->GetPosition().z() /mm
       << G4endl;
  G4cout << "        Global Time (ns)    : " 
       << std::setw(20) << fTrack->GetGlobalTime() /ns
       << G4endl;
  G4cout << "        Local Time (ns)     : " 
       << std::setw(20) << fTrack->GetLocalTime() /ns
       << G4endl;
#endif
  G4cout << "        Momentum Direct - x : " 
       << std::setw(20) << fTrack->GetMomentumDirection().x()
       << G4endl;
  G4cout << "        Momentum Direct - y : " 
       << std::setw(20) << fTrack->GetMomentumDirection().y()
       << G4endl;
  G4cout << "        Momentum Direct - z : " 
       << std::setw(20) << fTrack->GetMomentumDirection().z()
       << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Kinetic Energy      : " 
#else
  G4cout << "        Kinetic Energy (MeV): " 
#endif
       << std::setw(20) << G4BestUnit(fTrack->GetKineticEnergy(), "Energy")
       << G4endl;
  G4cout << "        Polarization - x    : " 
       << std::setw(20) << fTrack->GetPolarization().x()
       << G4endl;
  G4cout << "        Polarization - y    : " 
       << std::setw(20) << fTrack->GetPolarization().y()
       << G4endl;
  G4cout << "        Polarization - z    : " 
       << std::setw(20) << fTrack->GetPolarization().z()
       << G4endl;
  G4cout << "        Track Length        : " 
       << std::setw(20) << G4BestUnit(fTrack->GetTrackLength(), "Length")
       << G4endl;
  G4cout << "        Track ID #          : " 
       << std::setw(20) << fTrack->GetTrackID()
       << G4endl;
  G4cout << "        Parent Track ID #   : " 
       << std::setw(20) << fTrack->GetParentID()
       << G4endl;
  G4cout << "        Next Volume         : " 
       << std::setw(20);
       if( fTrack->GetNextVolume() != 0 ) { 
         G4cout << fTrack->GetNextVolume()->GetName() << " ";
       } else {
         G4cout << "OutOfWorld" << " ";
       }
       G4cout << G4endl;
  G4cout << "        Track Status        : " 
       << std::setw(20);
       if( fTrack->GetTrackStatus() == fAlive ){
         G4cout << " Alive";
       } else if( fTrack->GetTrackStatus() == fStopButAlive ){
           G4cout << " StopButAlive";
       } else if( fTrack->GetTrackStatus() == fStopAndKill ){
           G4cout << " StopAndKill";
       } else if( fTrack->GetTrackStatus() == fKillTrackAndSecondaries ){
           G4cout << " KillTrackAndSecondaries";
       } else if( fTrack->GetTrackStatus() == fSuspend ){
           G4cout << " Suspend";
       } else if( fTrack->GetTrackStatus() == fPostponeToNextEvent ){
           G4cout << " PostponeToNextEvent";
       }
       G4cout << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Vertex - x          : " 
       << std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().x(),"Length")
       << G4endl; 
  G4cout << "        Vertex - y          : " 
       << std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().y(),"Length")
       << G4endl; 
  G4cout << "        Vertex - z          : " 
       << std::setw(20) << G4BestUnit(fTrack->GetVertexPosition().z(),"Length")
       << G4endl;
#else
  G4cout << "        Vertex - x (mm)     : " 
       << std::setw(20) << fTrack->GetVertexPosition().x()/mm
       << G4endl; 
  G4cout << "        Vertex - y (mm)     : " 
       << std::setw(20) << fTrack->GetVertexPosition().y()/mm
       << G4endl; 
  G4cout << "        Vertex - z (mm)     : " 
       << std::setw(20) << fTrack->GetVertexPosition().z()/mm
       << G4endl;
#endif
  G4cout << "        Vertex - Px (MomDir): " 
       << std::setw(20) << fTrack->GetVertexMomentumDirection().x()
       << G4endl;
  G4cout << "        Vertex - Py (MomDir): " 
       << std::setw(20) << fTrack->GetVertexMomentumDirection().y()
       << G4endl;
  G4cout << "        Vertex - Pz (MomDir): " 
       << std::setw(20) << fTrack->GetVertexMomentumDirection().z()
       << G4endl;
#ifdef G4_USE_G4BESTUNIT_FOR_VERBOSE
  G4cout << "        Vertex - KineE      : " 
#else
  G4cout << "        Vertex - KineE (MeV): " 
#endif
       << std::setw(20) << G4BestUnit(fTrack->GetVertexKineticEnergy(),"Energy")
       << G4endl;
  
  G4cout << "        Creator Process     : " 
       << std::setw(20);
  if( fTrack->GetCreatorProcess() == 0){
    G4cout << " Event Generator" << G4endl;
  } else {
    G4cout << fTrack->GetCreatorProcess()->GetProcessName() << G4endl;
  }

  G4cout << "      -----------------------------------------------" 
       << G4endl;
       
 G4cout.precision(prec);      
}

---

The documentation for this class was generated from the following files:

• G4SteppingVerbose.hh
• G4SteppingVerbose.cc

---