WLSSteppingAction Class Reference

#include <Doxymodules_optical.h>

Inheritance diagram for WLSSteppingAction:

Public Member Functions
	WLSSteppingAction (WLSDetectorConstruction *, WLSEventAction *)
	~WLSSteppingAction () override
void	UserSteppingAction (const G4Step *) override
void	SetBounceLimit (G4int)
G4int	GetNumberOfBounces ()
G4int	GetNumberOfClad1Bounces ()
G4int	GetNumberOfClad2Bounces ()
G4int	GetNumberOfWLSBounces ()
G4int	ResetSuccessCounter ()

Private Member Functions
void	ResetCounters ()

Private Attributes
G4int	fBounceLimit = 100000
G4int	fCounterEnd = 0
G4int	fCounterMid = 0
G4int	fCounterBounce = 0
G4int	fCounterWLSBounce = 0
G4int	fCounterClad1Bounce = 0
G4int	fCounterClad2Bounce = 0
G4double	fInitGamma = -1.
G4double	fInitTheta = -1.
G4OpBoundaryProcess *	fOpProcess = nullptr
WLSDetectorConstruction *	fDetector = nullptr
WLSSteppingActionMessenger *	fSteppingMessenger = nullptr
WLSEventAction *	fEventAction = nullptr

Detailed Description

Definition at line 102 of file Doxymodules_optical.h.

Constructor & Destructor Documentation

WLSSteppingAction()

WLSSteppingAction::WLSSteppingAction	(	WLSDetectorConstruction *	detector,
		WLSEventAction *	event
	)

Definition at line 58 of file WLSSteppingAction.cc.

  : fDetector(detector)
  , fEventAction(event)
{
  fSteppingMessenger = new WLSSteppingActionMessenger(this);
  ResetCounters();
}

~WLSSteppingAction()

WLSSteppingAction::~WLSSteppingAction ( )

override

Definition at line 69 of file WLSSteppingAction.cc.

{ delete fSteppingMessenger; }

Member Function Documentation

UserSteppingAction()

void WLSSteppingAction::UserSteppingAction ( const G4Step *  theStep )

override

Definition at line 108 of file WLSSteppingAction.cc.

{
  G4Track* theTrack = theStep->GetTrack();
  auto 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
  // static const G4ThreeVector ZHat = G4ThreeVector(0.0,0.0,1.0);
  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;
 
  static G4ThreadLocal G4ProcessManager* OpManager =
    G4OpticalPhoton::OpticalPhoton()->GetProcessManager();
 
  if(OpManager)
  {
    G4int nproc = OpManager->GetPostStepProcessVector()->entries();
    G4ProcessVector* fPostStepDoItVector =
      OpManager->GetPostStepProcessVector(typeDoIt);
 
    for(G4int i = 0; i < nproc; ++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))
  {
    //G4cout << "SteppingAction: status = EscapedFromReadOut" << G4endl;
    fEventAction->AddEscaped();
    // 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:
      fEventAction->AddExiting();
 
      if(thePostPVname == "WLSFiber" || thePostPVname == "Clad1" ||
         thePostPVname == "Clad2")
      {
        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++;
          fEventAction->AddEscapedEnd();
        }
        else  // Escaped from side
        {
          trackInformation->AddStatusFlag(EscapedFromSide);
          trackInformation->SetExitPosition(theTrack->GetPosition());
          //  UpdateHistogramEscape(thePostPoint,theTrack);
 
          fCounterMid++;
          fEventAction->AddEscapedMid();
          ResetCounters();
        }
 
        trackInformation->AddStatusFlag(OutsideOfFiber);
        trackInformation->SetExitPosition(theTrack->GetPosition());
      }
 
      return;
 
    // Internal Reflections
    case TotalInternalReflection:
 
      fEventAction->AddTIR();
 
      // 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;
      }
      break;
 
    case FresnelReflection:
 
      fCounterBounce++;
      fEventAction->AddBounce();
 
      if(thePrePVname == "WLSFiber")
      {
        fCounterWLSBounce++;
        fEventAction->AddWLSBounce();
      }
      else if(thePrePVname == "Clad1")
      {
        fCounterClad1Bounce++;
        fEventAction->AddClad1Bounce();
      }
      else if(thePrePVname == "Clad2")
      {
        fCounterClad2Bounce++;
        fEventAction->AddClad1Bounce();
      }
 
      // 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 off the mirror
    case LambertianReflection:
    case LobeReflection:
    case SpikeReflection:
 
      fEventAction->AddReflected();
      // Check if it hits the mirror
      if(thePostPVname == "Mirror")
      {
        trackInformation->AddStatusFlag(ReflectedAtMirror);
        fEventAction->AddMirror();
      }
      return;
 
    // Detected by a detector
    case Detection:
      // Detected automatically with G4OpBoundaryProcess->InvokeSD set true
 
      // Stop Tracking when it hits the detector's surface
      ResetCounters();
      theTrack->SetTrackStatus(fStopAndKill);
      return;
 
    default:
      break;
  }
 
  // Check for absorbed photons
  if(theTrack->GetTrackStatus() != fAlive &&
     trackInformation->IsStatus(InsideOfFiber))
  {
    // UpdateHistogramAbsorb(thePostPoint,theTrack);
    ResetCounters();
    return;
  }
}

SetBounceLimit()

void WLSSteppingAction::SetBounceLimit

(

G4int

i

)

Definition at line 73 of file WLSSteppingAction.cc.

{ fBounceLimit = i; }

GetNumberOfBounces()

G4int WLSSteppingAction::GetNumberOfBounces

(

)

Definition at line 77 of file WLSSteppingAction.cc.

{ return fCounterBounce; }

GetNumberOfClad1Bounces()

G4int WLSSteppingAction::GetNumberOfClad1Bounces

(

)

Definition at line 81 of file WLSSteppingAction.cc.

{
  return fCounterClad1Bounce;
}

GetNumberOfClad2Bounces()

G4int WLSSteppingAction::GetNumberOfClad2Bounces

(

)

Definition at line 88 of file WLSSteppingAction.cc.

{
  return fCounterClad2Bounce;
}

GetNumberOfWLSBounces()

G4int WLSSteppingAction::GetNumberOfWLSBounces

(

)

Definition at line 95 of file WLSSteppingAction.cc.

{ return fCounterWLSBounce; }

ResetSuccessCounter()

G4int WLSSteppingAction::ResetSuccessCounter

(

)

Definition at line 99 of file WLSSteppingAction.cc.

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

ResetCounters()

void WLSSteppingAction::ResetCounters ( )

inlineprivate

Definition at line 93 of file WLSSteppingAction.hh.

  {
    fCounterBounce      = 0;
    fCounterWLSBounce   = 0;
    fCounterClad1Bounce = 0;
    fCounterClad2Bounce = 0;
    fInitGamma          = -1;
    fInitTheta          = -1;
  }

Member Data Documentation

fBounceLimit

G4int WLSSteppingAction::fBounceLimit = 100000

private

Definition at line 68 of file WLSSteppingAction.hh.

fCounterEnd

G4int WLSSteppingAction::fCounterEnd = 0

private

Definition at line 70 of file WLSSteppingAction.hh.

fCounterMid

G4int WLSSteppingAction::fCounterMid = 0

private

Definition at line 72 of file WLSSteppingAction.hh.

fCounterBounce

G4int WLSSteppingAction::fCounterBounce = 0

private

Definition at line 74 of file WLSSteppingAction.hh.

fCounterWLSBounce

G4int WLSSteppingAction::fCounterWLSBounce = 0

private

Definition at line 76 of file WLSSteppingAction.hh.

fCounterClad1Bounce

G4int WLSSteppingAction::fCounterClad1Bounce = 0

private

Definition at line 78 of file WLSSteppingAction.hh.

fCounterClad2Bounce

G4int WLSSteppingAction::fCounterClad2Bounce = 0

private

Definition at line 80 of file WLSSteppingAction.hh.

fInitGamma

G4double WLSSteppingAction::fInitGamma = -1.

private

Definition at line 83 of file WLSSteppingAction.hh.

fInitTheta

G4double WLSSteppingAction::fInitTheta = -1.

private

Definition at line 85 of file WLSSteppingAction.hh.

fOpProcess

G4OpBoundaryProcess* WLSSteppingAction::fOpProcess = nullptr

private

Definition at line 87 of file WLSSteppingAction.hh.

fDetector

WLSDetectorConstruction* WLSSteppingAction::fDetector = nullptr

private

Definition at line 89 of file WLSSteppingAction.hh.

fSteppingMessenger

WLSSteppingActionMessenger* WLSSteppingAction::fSteppingMessenger = nullptr

private

Definition at line 90 of file WLSSteppingAction.hh.

fEventAction

WLSEventAction* WLSSteppingAction::fEventAction = nullptr

private

Definition at line 91 of file WLSSteppingAction.hh.

---

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

• .doxygen/Doxymodules_optical.h
• extended/optical/wls/include/WLSSteppingAction.hh
• extended/optical/wls/src/WLSSteppingAction.cc