LXeSteppingAction Class Reference

#include <Doxymodules_optical.h>

Inheritance diagram for LXeSteppingAction:

Public Member Functions
	LXeSteppingAction (LXeEventAction *)
	~LXeSteppingAction () override
void	UserSteppingAction (const G4Step *) override
void	SetOneStepPrimaries (G4bool b)
G4bool	GetOneStepPrimaries ()

Private Attributes
G4bool	fOneStepPrimaries = false
LXeSteppingMessenger *	fSteppingMessenger = nullptr
LXeEventAction *	fEventAction = nullptr
G4OpBoundaryProcess *	fBoundary = nullptr
G4OpBoundaryProcessStatus	fExpectedNextStatus = Undefined

Detailed Description

Definition at line 65 of file Doxymodules_optical.h.

Constructor & Destructor Documentation

LXeSteppingAction()

LXeSteppingAction::LXeSteppingAction

(

LXeEventAction *

ea

)

Definition at line 51 of file LXeSteppingAction.cc.

  : fEventAction(ea)
{
  fSteppingMessenger = new LXeSteppingMessenger(this);
}

~LXeSteppingAction()

LXeSteppingAction::~LXeSteppingAction ( )

override

Definition at line 59 of file LXeSteppingAction.cc.

{ delete fSteppingMessenger; }

Member Function Documentation

UserSteppingAction()

void LXeSteppingAction::UserSteppingAction ( const G4Step *  theStep )

override

Definition at line 63 of file LXeSteppingAction.cc.

{
  G4Track* theTrack = theStep->GetTrack();
  const G4ParticleDefinition* part = theTrack->GetDefinition();
  G4int pdg = part->GetPDGEncoding();
 
  if(theTrack->GetCurrentStepNumber() == 1)
    fExpectedNextStatus = Undefined;
 
  auto trackInformation =
    static_cast<LXeUserTrackInformation*>(theTrack->GetUserInformation());
 
  G4StepPoint* thePrePoint    = theStep->GetPreStepPoint();
  G4VPhysicalVolume* thePrePV = thePrePoint->GetPhysicalVolume();
 
  G4StepPoint* thePostPoint    = theStep->GetPostStepPoint();
  G4VPhysicalVolume* thePostPV = thePostPoint->GetPhysicalVolume();
 
  G4OpBoundaryProcessStatus boundaryStatus = Undefined;
 
  // find the boundary process only once
  if(nullptr == fBoundary && pdg == -22)
  {
    G4ProcessManager* pm = part->GetProcessManager();
    G4int nprocesses = pm->GetProcessListLength();
    G4ProcessVector* pv = pm->GetProcessList();
    for(G4int i = 0; i < nprocesses; ++i)
    {
      if(nullptr != (*pv)[i] && (*pv)[i]->GetProcessName() == "OpBoundary")
      {
        fBoundary = dynamic_cast<G4OpBoundaryProcess*>((*pv)[i]);
        break;
      }
    }
  }
 
  if(theTrack->GetParentID() == 0)
  {
    // This is a primary track
    auto secondaries = theStep->GetSecondaryInCurrentStep();
    // If we haven't already found the conversion position and there were
    // secondaries generated, then search for it
    // since this is happening before the secondary is being tracked,
    // the vertex position has not been set yet (set in initial step)
    if(nullptr != secondaries && !fEventAction->IsConvPosSet())
    {
      if(!secondaries->empty()) 
      {
        for(auto & tr : *secondaries)
        {
          const G4VProcess* creator = tr->GetCreatorProcess();
          if(nullptr != creator)
          {
            G4int type = creator->GetProcessSubType();
            // 12 - photoeffect
            // 13 - Compton scattering
            // 14 - gamma conversion
            if(type >= 12 && type <= 14)
            {
              fEventAction->SetConvPos(tr->GetPosition());
            }
          }
        }
      }
    }
    if(fOneStepPrimaries && thePrePV->GetName() == "scintillator")
      theTrack->SetTrackStatus(fStopAndKill);
  }
 
  if(nullptr == thePostPV)
  {  // out of world
    fExpectedNextStatus = Undefined;
    return;
  }
 
  // Optical photon only
  if(pdg == -22)
  {
    if(thePrePV->GetName() == "Slab")
      // force drawing of photons in WLS slab
      trackInformation->SetForceDrawTrajectory(true);
    else if(thePostPV->GetName() == "expHall")
      // Kill photons entering expHall from something other than Slab
      theTrack->SetTrackStatus(fStopAndKill);
 
    // Was the photon absorbed by the absorption process
    auto proc = thePostPoint->GetProcessDefinedStep(); 
    if(nullptr != proc && proc->GetProcessName() == "OpAbsorption")
    {
      fEventAction->IncAbsorption();
      trackInformation->AddTrackStatusFlag(absorbed);
    }
    if(nullptr != fBoundary)
      boundaryStatus = fBoundary->GetStatus();
 
    if(thePostPoint->GetStepStatus() == fGeomBoundary)
    {
      // Check to see if the particle was actually at a boundary
      // Otherwise the boundary status may not be valid
      if(fExpectedNextStatus == StepTooSmall)
      {
        if(boundaryStatus != StepTooSmall)
        {
          G4cout << "LXeSteppingAction::UserSteppingAction(): "
                 << "trackID=" << theTrack->GetTrackID()
                 << " parentID=" << theTrack->GetParentID()
                 << " " << part->GetParticleName()
                 << " E(MeV)=" << theTrack->GetKineticEnergy()
                 << "n/ at " << theTrack->GetPosition()
                 << " prePV: " << thePrePV->GetName()
                 << " postPV: " << thePostPV->GetName()
                 << G4endl;
          G4ExceptionDescription ed;
          ed << "LXeSteppingAction: "
             << "No reallocation step after reflection!"
             << "Something is wrong with the surface normal or geometry";
          G4Exception("LXeSteppingAction:", "LXeExpl01", JustWarning, ed, "");
          return;
        }
      }
      fExpectedNextStatus = Undefined;
      switch(boundaryStatus)
      {
        case Absorption:
          trackInformation->AddTrackStatusFlag(boundaryAbsorbed);
          fEventAction->IncBoundaryAbsorption();
          break;
        case Detection:  // Note, this assumes that the volume causing detection
                         // is the photocathode because it is the only one with
                         // non-zero efficiency
        {
          // Trigger sensitive detector manually since photon is
          // absorbed but status was Detection
          G4SDManager* SDman = G4SDManager::GetSDMpointer();
          G4String sdName    = "/LXeDet/pmtSD";
          LXePMTSD* pmtSD    = (LXePMTSD*) SDman->FindSensitiveDetector(sdName);
          if(pmtSD)
            pmtSD->ProcessHits_boundary(theStep, nullptr);
          trackInformation->AddTrackStatusFlag(hitPMT);
          break;
        }
        case FresnelReflection:
        case TotalInternalReflection:
        case LambertianReflection:
        case LobeReflection:
        case SpikeReflection:
        case BackScattering:
          trackInformation->IncReflections();
          fExpectedNextStatus = StepTooSmall;
          break;
        default:
          break;
      }
      if(thePostPV->GetName() == "sphere")
        trackInformation->AddTrackStatusFlag(hitSphere);
    }
  }
}

SetOneStepPrimaries()

void LXeSteppingAction::SetOneStepPrimaries ( G4bool  b )

inline

Definition at line 49 of file LXeSteppingAction.hh.

{ fOneStepPrimaries = b; }

GetOneStepPrimaries()

G4bool LXeSteppingAction::GetOneStepPrimaries ( )

inline

Definition at line 50 of file LXeSteppingAction.hh.

{ return fOneStepPrimaries; }

Member Data Documentation

fOneStepPrimaries

G4bool LXeSteppingAction::fOneStepPrimaries = false

private

Definition at line 53 of file LXeSteppingAction.hh.

fSteppingMessenger

LXeSteppingMessenger* LXeSteppingAction::fSteppingMessenger = nullptr

private

Definition at line 54 of file LXeSteppingAction.hh.

fEventAction

LXeEventAction* LXeSteppingAction::fEventAction = nullptr

private

Definition at line 55 of file LXeSteppingAction.hh.

fBoundary

G4OpBoundaryProcess* LXeSteppingAction::fBoundary = nullptr

private

Definition at line 56 of file LXeSteppingAction.hh.

fExpectedNextStatus

G4OpBoundaryProcessStatus LXeSteppingAction::fExpectedNextStatus = Undefined

private

Definition at line 58 of file LXeSteppingAction.hh.

---

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

• .doxygen/Doxymodules_optical.h
• extended/optical/LXe/include/LXeSteppingAction.hh
• extended/optical/LXe/src/LXeSteppingAction.cc