biasing::TargetProcessFilter Class Reference

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.
	DECLARE_FACTORY (UserAction, std::shared_ptr< UserAction >, const std::string &, framework::config::Parameters &)
	factory for user actions
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 *	current_track_ {nullptr}
	Pointer to the current track being processed.
std::string	process_ {""}
	The process to bias.

Additional Inherited Members
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.
mutable::framework::logging::logger	the_log_
	the logging channel user actions can use ldmx_log with

Detailed Description

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

Definition at line 27 of file TargetProcessFilter.h.

Constructor & Destructor Documentation

TargetProcessFilter()

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

Class constructor.

Definition at line 23 of file TargetProcessFilter.cxx.

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

References framework::config::Parameters::get(), 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 29 of file TargetProcessFilter.cxx.

                                                                               {
  if (track == current_track_) {
    current_track_ = 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 current_track_.

EndOfEventAction()

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

overridevirtual

End of event action.

Reimplemented from simcore::UserAction.

Definition at line 167 of file TargetProcessFilter.cxx.

{}

getTypes()

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

inlineoverridevirtual

Retrieve the type of actions this class defines.

Implements simcore::UserAction.

Definition at line 60 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 45 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 track_info{simcore::UserTrackInformation::get(track)};
  if ((track_info != nullptr) && !track_info->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.
  static auto target_region =
      simcore::g4user::ptrretrieval::getRegion("target");
  if (!target_region) {
    ldmx_log(warn) << "Region 'target' not found in Geant4 region store";
  }
  auto phy_vol{track->GetVolume()};
  auto log_vol{phy_vol ? phy_vol->GetLogicalVolume() : nullptr};
  auto current_region{log_vol ? log_vol->GetRegion() : nullptr};
  if (current_region != target_region) {
    // 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();
        current_track_ = nullptr;
      } else {
        current_track_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        track_info->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) {
    static auto recoil_physical_volume =
        simcore::g4user::ptrretrieval::getPhysicalVolume("recoil_PV");
    static auto world_physical_volume =
        simcore::g4user::ptrretrieval::getPhysicalVolume("World_PV");
 
    if (!recoil_physical_volume) {
      ldmx_log(warn) << "Volume 'recoil_PV' not found in Geant4 volume store";
    }
    if (!world_physical_volume) {
      ldmx_log(warn) << "Volume 'World_PV' not found in Geant4 volume store";
    }
 
    auto current_volume = track->GetNextVolume();
    if (current_volume == recoil_physical_volume or
        current_volume == world_physical_volume) {
      if (getEventInfo()->bremCandidateCount() == 1) {
        track->SetTrackStatus(fKillTrackAndSecondaries);
        G4RunManager::GetRunManager()->AbortEvent();
        current_track_ = nullptr;
      } else {
        current_track_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        track_info->tagBremCandidate(false);
      }
    }
    return;
  } else {
    // If the brem gamma interacts and produced secondaries, get the
    // process used to create them.
    G4String process_name =
        secondaries->at(0)->GetCreatorProcess()->GetProcessName();
 
    // Only record the process that is being biased
    if (!process_name.contains(process_)) {
      if (getEventInfo()->bremCandidateCount() == 1) {
        track->SetTrackStatus(fKillTrackAndSecondaries);
        G4RunManager::GetRunManager()->AbortEvent();
        current_track_ = nullptr;
      } else {
        current_track_ = track;
        track->SetTrackStatus(fSuspend);
        getEventInfo()->decBremCandidateCount();
        track_info->tagBremCandidate(false);
      }
      return;
    }
 
    if (G4RunManager::GetRunManager()->GetVerboseLevel() > 1) {
      std::cout << "[ TargetProcessFilter ]: "
                << G4EventManager::GetEventManager()
                       ->GetConstCurrentEvent()
                       ->GetEventID()
                << " Brem photon produced " << secondaries->size()
                << " particle via " << process_name << " process." << std::endl;
    }
    track_info->tagBremCandidate(false);
    track_info->setSaveFlag(true);
    track_info->tagPNGamma();
    getEventInfo()->decBremCandidateCount();
  }
}

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

Member Data Documentation

current_track_

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

private

Pointer to the current track being processed.

Definition at line 67 of file TargetProcessFilter.h.

{nullptr};

Referenced by ClassifyNewTrack(), and stepping().

process_

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

private

The process to bias.

Definition at line 70 of file TargetProcessFilter.h.

{""};

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