WLSSteppingAction Class Reference

#include <WLSSteppingAction.hh>

Inheritance diagram for WLSSteppingAction:

Collaboration 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)

Private Member Functions
void	ResetCounters ()
void	saveRandomStatus (G4String subDir)

Private Attributes
G4int	fBounceLimit
G4int	fCounterEnd
G4int	fCounterMid
G4int	fCounterBounce
G4int	fCounterWLSBounce
G4int	fCounterClad1Bounce
G4int	fCounterClad2Bounce
G4double	fInitGamma
G4double	fInitTheta
G4OpBoundaryProcess *	fOpProcess
WLSDetectorConstruction *	fDetector
WLSSteppingActionMessenger *	fSteppingMessenger

Static Private Attributes
static G4int	fMaxRndmSave = 10000

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::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();
}

Here is the call graph for this function:

~WLSSteppingAction()

WLSSteppingAction::~WLSSteppingAction ( )

virtual

Definition at line 85 of file WLSSteppingAction.cc.

{
  delete fSteppingMessenger;
}

Member Function Documentation

GetNumberOfBounces()

G4int WLSSteppingAction::GetNumberOfBounces

(

)

Definition at line 96 of file WLSSteppingAction.cc.

{return fCounterBounce;}

GetNumberOfClad1Bounces()

G4int WLSSteppingAction::GetNumberOfClad1Bounces

(

)

Definition at line 100 of file WLSSteppingAction.cc.

{return fCounterClad1Bounce;}

GetNumberOfClad2Bounces()

G4int WLSSteppingAction::GetNumberOfClad2Bounces

(

)

Definition at line 104 of file WLSSteppingAction.cc.

{return fCounterClad2Bounce;}

GetNumberOfWLSBounces()

G4int WLSSteppingAction::GetNumberOfWLSBounces

(

)

Definition at line 108 of file WLSSteppingAction.cc.

{return fCounterWLSBounce;}

ResetCounters()

void WLSSteppingAction::ResetCounters ( )

inlineprivate

Definition at line 98 of file WLSSteppingAction.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ResetSuccessCounter()

G4int WLSSteppingAction::ResetSuccessCounter

(

)

Definition at line 112 of file WLSSteppingAction.cc.

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

saveRandomStatus()

void WLSSteppingAction::saveRandomStatus ( G4String  subDir )

inlineprivate

Definition at line 118 of file WLSSteppingAction.cc.

{
 
    // don't save if the maximum amount has been reached
    if (WLSSteppingAction::fMaxRndmSave == 0) return;

    G4RunManager* theRunManager = G4RunManager::GetRunManager();
    G4String randomNumberStatusDir = theRunManager->GetRandomNumberStoreDir();
 
    G4String fileIn  = randomNumberStatusDir + "currentEvent.rndm";

    std::ostringstream os;

    os << "run" << theRunManager->GetCurrentRun()->GetRunID() << "evt"
       << theRunManager->GetCurrentEvent()->GetEventID() << ".rndm" << '\0';

    G4String fileOut = randomNumberStatusDir + subDir + os.str();

    G4String copCmd = "/control/shell cp "+fileIn+" "+fileOut;
    G4UImanager::GetUIpointer()->ApplyCommand(copCmd);

    WLSSteppingAction::fMaxRndmSave--;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetBounceLimit()

void WLSSteppingAction::SetBounceLimit

(

G4int

i

)

Definition at line 92 of file WLSSteppingAction.cc.

{fBounceLimit = i;}

UserSteppingAction()

void WLSSteppingAction::UserSteppingAction ( const G4Step *  theStep )

virtual

Reimplemented from G4UserSteppingAction.

Definition at line 146 of file WLSSteppingAction.cc.

{
  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;
  }
 
}

Here is the call graph for this function:

Member Data Documentation

fBounceLimit

G4int WLSSteppingAction::fBounceLimit

private

Definition at line 70 of file WLSSteppingAction.hh.

fCounterBounce

G4int WLSSteppingAction::fCounterBounce

private

Definition at line 76 of file WLSSteppingAction.hh.

fCounterClad1Bounce

G4int WLSSteppingAction::fCounterClad1Bounce

private

Definition at line 80 of file WLSSteppingAction.hh.

fCounterClad2Bounce

G4int WLSSteppingAction::fCounterClad2Bounce

private

Definition at line 82 of file WLSSteppingAction.hh.

fCounterEnd

G4int WLSSteppingAction::fCounterEnd

private

Definition at line 72 of file WLSSteppingAction.hh.

fCounterMid

G4int WLSSteppingAction::fCounterMid

private

Definition at line 74 of file WLSSteppingAction.hh.

fCounterWLSBounce

G4int WLSSteppingAction::fCounterWLSBounce

private

Definition at line 78 of file WLSSteppingAction.hh.

fDetector

WLSDetectorConstruction* WLSSteppingAction::fDetector

private

Definition at line 94 of file WLSSteppingAction.hh.

fInitGamma

G4double WLSSteppingAction::fInitGamma

private

Definition at line 85 of file WLSSteppingAction.hh.

fInitTheta

G4double WLSSteppingAction::fInitTheta

private

Definition at line 87 of file WLSSteppingAction.hh.

fMaxRndmSave

G4int WLSSteppingAction::fMaxRndmSave = 10000

staticprivate

Definition at line 92 of file WLSSteppingAction.hh.

fOpProcess

G4OpBoundaryProcess* WLSSteppingAction::fOpProcess

private

Definition at line 89 of file WLSSteppingAction.hh.

fSteppingMessenger

WLSSteppingActionMessenger* WLSSteppingAction::fSteppingMessenger

private

Definition at line 96 of file WLSSteppingAction.hh.

---

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

• WLSSteppingAction.hh
• WLSSteppingAction.cc