Biases Geant4 to only process events where PN reaction occurred in the target. More...

#include <TargetProcessFilter.h>

Public Member Functions
	TargetProcessFilter (const std::string &name, framework::config::Parameters &parameters)
	Class constructor.

virtual	~TargetProcessFilter ()=default
	Destructor.

void	stepping (const G4Step *step) override
	Implementmthe stepping action which performs the target volume biasing.

void	EndOfEventAction (const G4Event *) override
	End of event action.

G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *aTrack, const G4ClassificationOfNewTrack &currentTrackClass) override
	Classify a new track which postpones track processing.

std::vector< simcore::TYPE >	getTypes () override
	Retrieve the type of actions this class defines.

Public Member Functions inherited from simcore::UserAction
	UserAction (const std::string &name, framework::config::Parameters &parameters)
	Constructor.

virtual	~UserAction ()=default
	Destructor.

virtual void	BeginOfEventAction (const G4Event *)
	Method called at the beginning of every event.

virtual void	BeginOfRunAction (const G4Run *)
	Method called at the beginning of a run.

virtual void	EndOfRunAction (const G4Run *)
	Method called at the end of a run.

virtual void	PreUserTrackingAction (const G4Track *)
	Method called before the UserTrackingAction.

virtual void	PostUserTrackingAction (const G4Track *)
	Method called after the UserTrackingAction.

virtual void	NewStage ()
	Method called at the beginning of a new stage.

virtual void	PrepareNewEvent ()
	Method called at the beginning of a new event.

Private Attributes
G4Track *	currentTrack_ {nullptr}
	Pointer to the current track being processed.

std::string	process_ {""}
	The process to bias.

Additional Inherited Members
Public Types inherited from simcore::UserAction
using	Factory = ::simcore::Factory< UserAction, std::shared_ptr< UserAction >, const std::string &, framework::config::Parameters & >
	factory for user actions

Protected Member Functions inherited from simcore::UserAction
UserEventInformation *	getEventInfo () const
	Get a handle to the event information.

const std::map< int, ldmx::SimParticle > &	getCurrentParticleMap () const
	Get the current particle map.

Protected Attributes inherited from simcore::UserAction
std::string	name_ {""}
	Name of the UserAction.

framework::config::Parameters	parameters_
	The set of parameters used to configure this class.

Detailed Description

Biases Geant4 to only process events where PN reaction occurred in the target.

Definition at line 26 of file TargetProcessFilter.h.

Constructor & Destructor Documentation

◆ TargetProcessFilter()

biasing::TargetProcessFilter::TargetProcessFilter	(	const std::string &	name,
		framework::config::Parameters &	parameters
	)

Class constructor.

Definition at line 25 of file TargetProcessFilter.cxx.

    : simcore::UserAction(name, parameters) {
  process_ = parameters.getParameter<std::string>("process");
}

References framework::config::Parameters::getParameter(), and process_.

Member Function Documentation

◆ ClassifyNewTrack()

G4ClassificationOfNewTrack biasing::TargetProcessFilter::ClassifyNewTrack	(	const G4Track *	aTrack,
		const G4ClassificationOfNewTrack &	currentTrackClass
	)

overridevirtual

Classify a new track which postpones track processing.

Track processing resumes normally if a target PN interaction occurred.

Parameters

aTrack	The Geant4 track.
currentTrackClass	The current track classification.

Reimplemented from simcore::UserAction.

Definition at line 31 of file TargetProcessFilter.cxx.

                                                                               {
  if (track == currentTrack_) {
    currentTrack_ = nullptr;
    // std::cout << "[ TargetBremFilter ]: Pushing track to waiting stack." <<
    // std::endl;
    return fWaiting;
  }
 
  // Use current classification by default so values from other plugins are not
  // overridden.
  G4ClassificationOfNewTrack classification = currentTrackClass;
 
  return classification;
}

References currentTrack_.

◆ EndOfEventAction()

void biasing::TargetProcessFilter::EndOfEventAction ( const G4Event * )

overridevirtual

End of event action.

Reimplemented from simcore::UserAction.

Definition at line 151 of file TargetProcessFilter.cxx.

151{}

◆ getTypes()

std::vector< simcore::TYPE > biasing::TargetProcessFilter::getTypes ( )

inlineoverridevirtual

Retrieve the type of actions this class defines.

Implements simcore::UserAction.

Definition at line 59 of file TargetProcessFilter.h.

                                             {
    return {simcore::TYPE::EVENT, simcore::TYPE::STACKING,
            simcore::TYPE::STEPPING};
  }

◆ stepping()

void biasing::TargetProcessFilter::stepping ( const G4Step * step )

overridevirtual

Implementmthe stepping action which performs the target volume biasing.

Parameters

step	The Geant4 step.

Check if the electron will be exiting the target

The 'recoil_PV' volume name is automatically constructed by Geant4's GDML parser and was found by inspecting the geometry using a visualization. This Physical Volume (PV) is associated with the recoil parent volume and so it will break if the recoil parent volume changes its name.

We also check for 'World_PV' because in later geometries, there is an air gap between the target region and the recoil tracker.

Reimplemented from simcore::UserAction.

Definition at line 47 of file TargetProcessFilter.cxx.

                                                     {
  // Get the track associated with this step.
  auto track{step->GetTrack()};
 
  if (G4EventManager::GetEventManager()->GetConstCurrentEvent()->IsAborted())
    return;
 
  // Get the track info and check if this track is a brem candidate
  auto trackInfo{simcore::UserTrackInformation::get(track)};
  if ((trackInfo != nullptr) && !trackInfo->isBremCandidate()) return;
 
  // Get the particles daughters.
  auto secondaries{step->GetSecondary()};
 
  // Get the region the particle is currently in. Continue processing
  // the particle only if it's in the target region.
  if (auto region{
          track->GetVolume()->GetLogicalVolume()->GetRegion()->GetName()};
      region.compareTo("target") != 0) {
    // If secondaries were produced outside of the volume of interest,
    // and there aren't additional brems to process, abort the event.
    // Otherwise, suspend the track and move on to the next brem.
    if (secondaries->size() != 0) {
      if (getEventInfo()->bremCandidateCount() == 1) {
        track->SetTrackStatus(fKillTrackAndSecondaries);
        G4RunManager::GetRunManager()->AbortEvent();
        currentTrack_ = nullptr;
      } else {
        currentTrack_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        trackInfo->tagBremCandidate(false);
      }
    }
    return;
  }
 
  // If the brem photon doesn't undergo any reaction in the target, stop
  // processing the rest of the event if the particle is exiting the
  // target region.
  if (secondaries->size() == 0) {
    if (auto volume{track->GetNextVolume()->GetName()};
        volume.compareTo("recoil_PV") == 0 or
        volume.compareTo("World_PV") == 0) {
      if (getEventInfo()->bremCandidateCount() == 1) {
        track->SetTrackStatus(fKillTrackAndSecondaries);
        G4RunManager::GetRunManager()->AbortEvent();
        currentTrack_ = nullptr;
      } else {
        currentTrack_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        trackInfo->tagBremCandidate(false);
      }
    }
    return;
  } else {
    // If the brem gamma interacts and produced secondaries, get the
    // process used to create them.
    G4String processName =
        secondaries->at(0)->GetCreatorProcess()->GetProcessName();
 
    // Only record the process that is being biased
    if (!processName.contains(process_)) {
      if (getEventInfo()->bremCandidateCount() == 1) {
        track->SetTrackStatus(fKillTrackAndSecondaries);
        G4RunManager::GetRunManager()->AbortEvent();
        currentTrack_ = nullptr;
      } else {
        currentTrack_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        trackInfo->tagBremCandidate(false);
      }
      return;
    }
 
    if (G4RunManager::GetRunManager()->GetVerboseLevel() > 1) {
      std::cout << "[ TargetProcessFilter ]: "
                << G4EventManager::GetEventManager()
                       ->GetConstCurrentEvent()
                       ->GetEventID()
                << " Brem photon produced " << secondaries->size()
                << " particle via " << processName << " process." << std::endl;
    }
    trackInfo->tagBremCandidate(false);
    trackInfo->setSaveFlag(true);
    trackInfo->tagPNGamma();
    getEventInfo()->decBremCandidateCount();
  }
}

References currentTrack_, simcore::UserEventInformation::decBremCandidateCount(), simcore::UserTrackInformation::get(), simcore::UserAction::getEventInfo(), and process_.

Member Data Documentation

◆ currentTrack_

G4Track* biasing::TargetProcessFilter::currentTrack_ {nullptr}

private

Pointer to the current track being processed.

Definition at line 66 of file TargetProcessFilter.h.

66{nullptr};

Referenced by ClassifyNewTrack(), and stepping().

◆ process_

std::string biasing::TargetProcessFilter::process_ {""}

private

The process to bias.

Definition at line 69 of file TargetProcessFilter.h.

69{""};

Referenced by stepping(), and TargetProcessFilter().

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

Biasing/include/Biasing/TargetProcessFilter.h
Biasing/src/Biasing/TargetProcessFilter.cxx

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TargetProcessFilter()

Member Function Documentation

◆ ClassifyNewTrack()

◆ EndOfEventAction()

◆ getTypes()

◆ stepping()

Member Data Documentation

◆ currentTrack_

◆ process_