LXeSteppingAction Class Reference

#include <LXeSteppingAction.hh>

Inheritance diagram for LXeSteppingAction:

Collaboration diagram for LXeSteppingAction:

Public Member Functions
	LXeSteppingAction (LXeRecorderBase *)
virtual	~LXeSteppingAction ()
virtual void	UserSteppingAction (const G4Step *)
void	SetOneStepPrimaries (G4bool b)
G4bool	GetOneStepPrimaries ()
Public Member Functions inherited from G4UserSteppingAction
	G4UserSteppingAction ()
virtual	~G4UserSteppingAction ()
void	SetSteppingManagerPointer (G4SteppingManager *pValue)

Private Attributes
LXeRecorderBase *	fRecorder
G4bool	fOneStepPrimaries
LXeSteppingMessenger *	fSteppingMessenger
G4OpBoundaryProcessStatus	fExpectedNextStatus

Additional Inherited Members
Protected Attributes inherited from G4UserSteppingAction
G4SteppingManager *	fpSteppingManager

Detailed Description

Definition at line 44 of file LXeSteppingAction.hh.

Constructor & Destructor Documentation

LXeSteppingAction()

LXeSteppingAction::LXeSteppingAction

(

LXeRecorderBase *

r

)

Definition at line 57 of file LXeSteppingAction.cc.

  : fRecorder(r),fOneStepPrimaries(false)
{
  fSteppingMessenger = new LXeSteppingMessenger(this);

  fExpectedNextStatus = Undefined;
}

~LXeSteppingAction()

LXeSteppingAction::~LXeSteppingAction ( )

virtual

Definition at line 67 of file LXeSteppingAction.cc.

{}

Member Function Documentation

GetOneStepPrimaries()

G4bool LXeSteppingAction::GetOneStepPrimaries ( )

inline

Definition at line 53 of file LXeSteppingAction.hh.

{return fOneStepPrimaries;}

SetOneStepPrimaries()

void LXeSteppingAction::SetOneStepPrimaries ( G4bool  b )

inline

Definition at line 52 of file LXeSteppingAction.hh.

{fOneStepPrimaries=b;}

Here is the caller graph for this function:

UserSteppingAction()

void LXeSteppingAction::UserSteppingAction ( const G4Step *  theStep )

virtual

Reimplemented from G4UserSteppingAction.

Definition at line 71 of file LXeSteppingAction.cc.

                                                                {

  G4Track* theTrack = theStep->GetTrack();

  if ( theTrack->GetCurrentStepNumber() == 1 ) fExpectedNextStatus = Undefined;
 
  LXeUserTrackInformation* trackInformation
    =(LXeUserTrackInformation*)theTrack->GetUserInformation();
  LXeUserEventInformation* eventInformation
    =(LXeUserEventInformation*)G4EventManager::GetEventManager()
    ->GetConstCurrentEvent()->GetUserInformation();

  G4StepPoint* thePrePoint = theStep->GetPreStepPoint();
  G4VPhysicalVolume* thePrePV = thePrePoint->GetPhysicalVolume();

  G4StepPoint* thePostPoint = theStep->GetPostStepPoint();
  G4VPhysicalVolume* thePostPV = thePostPoint->GetPhysicalVolume();

  G4OpBoundaryProcessStatus boundaryStatus=Undefined;
  static G4ThreadLocal G4OpBoundaryProcess* boundary=NULL;

  //find the boundary process only once
  if(!boundary){
    G4ProcessManager* pm
      = theStep->GetTrack()->GetDefinition()->GetProcessManager();
    G4int nprocesses = pm->GetProcessListLength();
    G4ProcessVector* pv = pm->GetProcessList();
    G4int i;
    for( i=0;i<nprocesses;i++){
      if((*pv)[i]->GetProcessName()=="OpBoundary"){
        boundary = (G4OpBoundaryProcess*)(*pv)[i];
        break;
      }
    }
  }

  if(theTrack->GetParentID()==0){
    //This is a primary track
 
    G4TrackVector* fSecondary=fpSteppingManager->GetfSecondary();
    G4int tN2ndariesTot = fpSteppingManager->GetfN2ndariesAtRestDoIt()
      + fpSteppingManager->GetfN2ndariesAlongStepDoIt()
      + fpSteppingManager->GetfN2ndariesPostStepDoIt();

    //If we havent already found the conversion position and there were
    //secondaries generated, then search for it
    if(!eventInformation->IsConvPosSet() && tN2ndariesTot>0 ){
      for(size_t lp1=(*fSecondary).size()-tN2ndariesTot;
          lp1<(*fSecondary).size(); lp1++){
        const G4VProcess* creator=(*fSecondary)[lp1]->GetCreatorProcess();
        if(creator){
          G4String creatorName=creator->GetProcessName();
          if(creatorName=="phot"||creatorName=="compt"||creatorName=="conv"){
            //since this is happening before the secondary is being tracked
            //the Vertex position has not been set yet(set in initial step)
            eventInformation->SetConvPos((*fSecondary)[lp1]->GetPosition());
          }
        }
      }
    }

    if(fOneStepPrimaries&&thePrePV->GetName()=="scintillator")
      theTrack->SetTrackStatus(fStopAndKill);
  }

  if(!thePostPV){//out of world
    fExpectedNextStatus=Undefined;
    return;
  }

  G4ParticleDefinition* particleType = theTrack->GetDefinition();
  if(particleType==G4OpticalPhoton::OpticalPhotonDefinition()){
    //Optical photon only

    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
    if(thePostPoint->GetProcessDefinedStep()->GetProcessName()
       =="OpAbsorption"){
      eventInformation->IncAbsorption();
      trackInformation->AddTrackStatusFlag(absorbed);
    }

    boundaryStatus=boundary->GetStatus();

    //Check to see if the partcile was actually at a boundary
    //Otherwise the boundary status may not be valid
    //Prior to Geant4.6.0-p1 this would not have been enough to check
    if(thePostPoint->GetStepStatus()==fGeomBoundary){
      if(fExpectedNextStatus==StepTooSmall){
        if(boundaryStatus!=StepTooSmall){
          G4ExceptionDescription ed;
          ed << "LXeSteppingAction::UserSteppingAction(): "
                << "No reallocation step after reflection!"
                << G4endl;
          G4Exception("LXeSteppingAction::UserSteppingAction()", "LXeExpl01",
          FatalException,ed,
          "Something is wrong with the surface normal or geometry");
        }
      }
      fExpectedNextStatus=Undefined;
      switch(boundaryStatus){
      case Absorption:
        trackInformation->AddTrackStatusFlag(boundaryAbsorbed);
        eventInformation->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
        {
        //Triger 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_constStep(theStep,NULL);
        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);
    }
  }

  if(fRecorder)fRecorder->RecordStep(theStep);
}

Here is the call graph for this function:

Member Data Documentation

fExpectedNextStatus

G4OpBoundaryProcessStatus LXeSteppingAction::fExpectedNextStatus

private

Definition at line 61 of file LXeSteppingAction.hh.

fOneStepPrimaries

G4bool LXeSteppingAction::fOneStepPrimaries

private

Definition at line 58 of file LXeSteppingAction.hh.

fRecorder

LXeRecorderBase* LXeSteppingAction::fRecorder

private

Definition at line 57 of file LXeSteppingAction.hh.

fSteppingMessenger

LXeSteppingMessenger* LXeSteppingAction::fSteppingMessenger

private

Definition at line 59 of file LXeSteppingAction.hh.

---

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

• LXeSteppingAction.hh
• LXeSteppingAction.cc