WLSSteppingAction Class Reference

#include <WLSSteppingAction.hh>

Inheritance diagram for WLSSteppingAction:

Public Member Functions
	WLSSteppingAction (WLSDetectorConstruction *)
virtual	~WLSSteppingAction ()
virtual void	UserSteppingAction (const G4Step *)
void	SetBounceLimit (G4int)
G4int	GetNumberOfBounces ()
G4int	GetNumberOfClad1Bounces ()
G4int	GetNumberOfClad2Bounces ()
G4int	GetNumberOfWLSBounces ()
G4int	ResetSuccessCounter ()
Public Member Functions inherited from G4UserSteppingAction
	G4UserSteppingAction ()
virtual	~G4UserSteppingAction ()
void	SetSteppingManagerPointer (G4SteppingManager *pValue)

Additional Inherited Members
Protected Attributes inherited from G4UserSteppingAction
G4SteppingManager *	fpSteppingManager

Detailed Description

Definition at line 48 of file WLSSteppingAction.hh.

Constructor & Destructor Documentation

WLSSteppingAction::WLSSteppingAction

(

WLSDetectorConstruction *

detector

)

Definition at line 69 of file WLSSteppingAction.cc.

  : fDetector(detector)
{
  fSteppingMessenger = new WLSSteppingActionMessenger(this);

  fCounterEnd = 0;
  fCounterMid = 0;
  fBounceLimit = 100000;

  fOpProcess = NULL;
 
  ResetCounters();
}

WLSSteppingAction::~WLSSteppingAction ( )

virtual

Definition at line 85 of file WLSSteppingAction.cc.

{
  delete fSteppingMessenger;
}

Member Function Documentation

G4int WLSSteppingAction::GetNumberOfBounces

(

)

Definition at line 96 of file WLSSteppingAction.cc.

{return fCounterBounce;}

G4int WLSSteppingAction::GetNumberOfClad1Bounces

(

)

Definition at line 100 of file WLSSteppingAction.cc.

{return fCounterClad1Bounce;}

G4int WLSSteppingAction::GetNumberOfClad2Bounces

(

)

Definition at line 104 of file WLSSteppingAction.cc.

{return fCounterClad2Bounce;}

G4int WLSSteppingAction::GetNumberOfWLSBounces

(

)

Definition at line 108 of file WLSSteppingAction.cc.

{return fCounterWLSBounce;}

G4int WLSSteppingAction::ResetSuccessCounter

(

)

Definition at line 112 of file WLSSteppingAction.cc.

                                                 {
      G4int temp = fCounterEnd; fCounterEnd = 0; return temp;
}

void WLSSteppingAction::SetBounceLimit

(

G4int

i

)

Definition at line 92 of file WLSSteppingAction.cc.

{fBounceLimit = i;}

void WLSSteppingAction::UserSteppingAction ( const G4Step *  theStep )

virtual

Reimplemented from G4UserSteppingAction.

Definition at line 146 of file WLSSteppingAction.cc.

References WLSUserTrackInformation::AddStatusFlag(), python.hepunit::deg, Detection, G4ProcessVector::entries(), EscapedFromReadOut, EscapedFromSide, fAlive, G4SDManager::FindSensitiveDetector(), FresnelReflection, FresnelRefraction, fStopAndKill, G4cout, G4endl, G4Track::GetCurrentStepNumber(), G4VPhysicalVolume::GetName(), G4Track::GetParentID(), G4StepPoint::GetPhysicalVolume(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4ProcessManager::GetPostStepProcessVector(), G4Step::GetPreStepPoint(), G4ParticleDefinition::GetProcessManager(), G4SDManager::GetSDMpointer(), G4OpBoundaryProcess::GetStatus(), G4Step::GetTrack(), G4Track::GetTrackStatus(), G4Track::GetUserInformation(), G4Track::GetVertexMomentumDirection(), WLSDetectorConstruction::GetWLSFiberEnd(), InsideOfFiber, WLSDetectorConstruction::IsPerfectFiber(), WLSUserTrackInformation::isStatus(), LambertianReflection, LobeReflection, murderee, G4OpticalPhoton::OpticalPhoton(), OutsideOfFiber, WLSPhotonDetSD::ProcessHits_constStep(), python.hepunit::rad, ReflectedAtMirror, ReflectedAtReadOut, SameMaterial, WLSUserTrackInformation::SetExitPosition(), G4Track::SetTrackStatus(), SpikeReflection, TotalInternalReflection, typeDoIt, Undefined, test::x, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

{
  G4Track* theTrack = theStep->GetTrack();
  WLSUserTrackInformation* trackInformation
      = (WLSUserTrackInformation*)theTrack->GetUserInformation();

  G4StepPoint* thePrePoint  = theStep->GetPreStepPoint();
  G4StepPoint* thePostPoint = theStep->GetPostStepPoint();

  G4VPhysicalVolume* thePrePV  = thePrePoint->GetPhysicalVolume();
  G4VPhysicalVolume* thePostPV = thePostPoint->GetPhysicalVolume();

  G4String thePrePVname  = " ";
  G4String thePostPVname = " ";

  if (thePostPV) {
     thePrePVname  = thePrePV->GetName();
     thePostPVname = thePostPV->GetName();
  }

  //Recording data for start
  if (theTrack->GetParentID()==0) {
     //This is a primary track
     if ( theTrack->GetCurrentStepNumber() == 1 ) {
//        G4double x  = theTrack->GetVertexPosition().x();
//        G4double y  = theTrack->GetVertexPosition().y();
//        G4double z  = theTrack->GetVertexPosition().z();
//        G4double pz = theTrack->GetVertexMomentumDirection().z();
//        G4double fInitTheta = 
//                         theTrack->GetVertexMomentumDirection().angle(ZHat);
     }
  }

  // Retrieve the status of the photon
  G4OpBoundaryProcessStatus theStatus = Undefined;

  G4ProcessManager* OpManager =
                      G4OpticalPhoton::OpticalPhoton()->GetProcessManager();

  if (OpManager) {
     G4int MAXofPostStepLoops =
              OpManager->GetPostStepProcessVector()->entries();
     G4ProcessVector* fPostStepDoItVector =
              OpManager->GetPostStepProcessVector(typeDoIt);

     for ( G4int i=0; i<MAXofPostStepLoops; i++) {
         G4VProcess* fCurrentProcess = (*fPostStepDoItVector)[i];
         fOpProcess = dynamic_cast<G4OpBoundaryProcess*>(fCurrentProcess);
         if (fOpProcess) { theStatus = fOpProcess->GetStatus(); break;}
     }
  }

  // Find the skewness of the ray at first change of boundary
  if ( fInitGamma == -1 &&
       (theStatus == TotalInternalReflection
        || theStatus == FresnelReflection
        || theStatus == FresnelRefraction)
        && trackInformation->isStatus(InsideOfFiber) ) {

        G4double px = theTrack->GetVertexMomentumDirection().x();
        G4double py = theTrack->GetVertexMomentumDirection().y();
        G4double x  = theTrack->GetPosition().x();
        G4double y  = theTrack->GetPosition().y();

        fInitGamma = x * px + y * py;

        fInitGamma = 
                 fInitGamma / std::sqrt(px*px + py*py) / std::sqrt(x*x + y*y);

        fInitGamma = std::acos(fInitGamma*rad);

        if ( fInitGamma / deg > 90.0)  { fInitGamma = 180 * deg - fInitGamma;}
  }
  // Record Photons that missed the photon detector but escaped from readout
  if ( !thePostPV && trackInformation->isStatus(EscapedFromReadOut) ) {
//     UpdateHistogramSuccess(thePostPoint,theTrack);
     ResetCounters();
 
     return;
  }

  // Assumed photons are originated at the fiber OR
  // the fiber is the first material the photon hits
  switch (theStatus) {
 
     // Exiting the fiber
     case FresnelRefraction:
     case SameMaterial:

       G4bool isFiber;
       isFiber = thePostPVname == "WLSFiber"
                     || thePostPVname == "Clad1"
                     || thePostPVname == "Clad2";
 
       if ( isFiber ) {

           if (trackInformation->isStatus(OutsideOfFiber))
                               trackInformation->AddStatusFlag(InsideOfFiber);

       // Set the Exit flag when the photon refracted out of the fiber
       } else if (trackInformation->isStatus(InsideOfFiber)) {

           // EscapedFromReadOut if the z position is the same as fiber's end
           if (theTrack->GetPosition().z() == fDetector->GetWLSFiberEnd())
           {
              trackInformation->AddStatusFlag(EscapedFromReadOut);
              fCounterEnd++;
           }
           else // Escaped from side
           {
              trackInformation->AddStatusFlag(EscapedFromSide);
              trackInformation->SetExitPosition(theTrack->GetPosition());

//              UpdateHistogramEscape(thePostPoint,theTrack);

              fCounterMid++;
              ResetCounters();
           }

           trackInformation->AddStatusFlag(OutsideOfFiber);
           trackInformation->SetExitPosition(theTrack->GetPosition());

       }

       return;
 
     // Internal Reflections
     case TotalInternalReflection:
 
       // Kill the track if it's number of bounces exceeded the limit
       if (fBounceLimit > 0 && fCounterBounce >= fBounceLimit)
       {
          theTrack->SetTrackStatus(fStopAndKill);
          trackInformation->AddStatusFlag(murderee);
          ResetCounters();
          G4cout << "\n Bounce Limit Exceeded" << G4endl;
          return;
       }
 
     case FresnelReflection:

       fCounterBounce++;
 
       if ( thePrePVname == "WLSFiber") fCounterWLSBounce++;

       else if ( thePrePVname == "Clad1") fCounterClad1Bounce++;

       else if ( thePrePVname == "Clad2") fCounterClad2Bounce++;
 
       // Determine if the photon has reflected off the read-out end
       if (theTrack->GetPosition().z() == fDetector->GetWLSFiberEnd())
       {
          if (!trackInformation->isStatus(ReflectedAtReadOut) &&
              trackInformation->isStatus(InsideOfFiber))
          {
             trackInformation->AddStatusFlag(ReflectedAtReadOut);

             if (fDetector->IsPerfectFiber() &&
                 theStatus == TotalInternalReflection)
             {
                theTrack->SetTrackStatus(fStopAndKill);
                trackInformation->AddStatusFlag(murderee);
//                UpdateHistogramReflect(thePostPoint,theTrack);
                     ResetCounters();
                return;
             }
          }
       }
       return;

     // Reflection of the mirror
     case LambertianReflection:
     case LobeReflection:
     case SpikeReflection:

       // Check if it hits the mirror
       if ( thePostPVname == "Mirror" )
          trackInformation->AddStatusFlag(ReflectedAtMirror);
 
       return;

     // Detected by a detector
     case Detection:

       // Check if the photon hits the detector and process the hit if it does
       if ( thePostPVname == "PhotonDet" ) {

          G4SDManager* SDman = G4SDManager::GetSDMpointer();
          G4String SDname="WLS/PhotonDet";
          WLSPhotonDetSD* mppcSD =
                        (WLSPhotonDetSD*)SDman->FindSensitiveDetector(SDname);

          if (mppcSD) mppcSD->ProcessHits_constStep(theStep,NULL);

          // Record Photons that escaped at the end
//          if (trackInformation->isStatus(EscapedFromReadOut))
//                              UpdateHistogramSuccess(thePostPoint,theTrack);

          // Stop Tracking when it hits the detector's surface
          ResetCounters();
          theTrack->SetTrackStatus(fStopAndKill);

          return;
       }

       break;

     default: break;

  }
 
  // Check for absorbed photons
  if (theTrack->GetTrackStatus() != fAlive  &&
      trackInformation->isStatus(InsideOfFiber))
  {
//     UpdateHistogramAbsorb(thePostPoint,theTrack);
     ResetCounters();
     return;
  }
 
}

---

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

• WLSSteppingAction.hh
• WLSSteppingAction.cc