biasing::TargetBremFilter Class Reference

User action that allows a user to filter out events that don't result in a brem within the target. More...

#include <TargetBremFilter.h>

Public Member Functions
	TargetBremFilter (const std::string &name, framework::config::Parameters &parameters)
	Constructor.
	~TargetBremFilter ()
	Destructor.
void	stepping (const G4Step *step) override
	Implement the stepping action which performs the target volume biasing.
void	EndOfEventAction (const G4Event *) override
	Method called at the end of every event.
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
double	recoil_max_p_threshold_ {1500}
	Recoil electron threshold.
double	brem_energy_threshold_ {2500}
	Brem gamma energy treshold.
bool	kill_recoil_ {false}
	Flag indicating if the recoil electron track should be killed.

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

User action that allows a user to filter out events that don't result in a brem within the target.

Definition at line 26 of file TargetBremFilter.h.

Constructor & Destructor Documentation

TargetBremFilter()

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

Constructor.

Definition at line 22 of file TargetBremFilter.cxx.

    : simcore::UserAction(name, parameters) {
  recoil_max_p_threshold_ = parameters.get<double>("recoil_max_p_threshold");
  brem_energy_threshold_ = parameters.get<double>("brem_min_energy_threshold");
  kill_recoil_ = parameters.get<bool>("kill_recoil_track");
}

References brem_energy_threshold_, framework::config::Parameters::get(), kill_recoil_, and recoil_max_p_threshold_.

~TargetBremFilter()

biasing::TargetBremFilter::~TargetBremFilter

(

)

Destructor.

Definition at line 30 of file TargetBremFilter.cxx.

{}

Member Function Documentation

ClassifyNewTrack()

G4ClassificationOfNewTrack biasing::TargetBremFilter::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 32 of file TargetBremFilter.cxx.

                                                                               {
  // get the PDGID of the track.
  G4int pdg_id = track->GetParticleDefinition()->GetPDGEncoding();
 
  // Get the particle type.
  G4String particle_name = track->GetParticleDefinition()->GetParticleName();
 
  // Use current classification by default so values from other plugins are not
  // overridden.
  G4ClassificationOfNewTrack classification = currentTrackClass;
 
  if (track->GetTrackID() == 1 && pdg_id == 11) {
    return fWaiting;
  }
 
  return classification;
}

EndOfEventAction()

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

overridevirtual

Method called at the end of every event.

Parameters

event

Geant4 event object.

Reimplemented from simcore::UserAction.

Definition at line 166 of file TargetBremFilter.cxx.

{}

getTypes()

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

inlineoverridevirtual

Retrieve the type of actions this class defines.

Implements simcore::UserAction.

Definition at line 59 of file TargetBremFilter.h.

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

stepping()

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

overridevirtual

Implement the 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 if the next volume is World_PV because in some geometries (e.g. v14), there is a air-gap between the target region and the recoil.

Reimplemented from simcore::UserAction.

Definition at line 51 of file TargetBremFilter.cxx.

                                                  {
  // Get the track associated with this step.
  auto track{step->GetTrack()};
 
  // Only process the primary electron track
  if (track->GetParentID() != 0) return;
 
  // Get the PDG ID of the track and make sure it's an electron. If
  // another particle type is found, thrown an exception.
  if (auto pdg_id{track->GetParticleDefinition()->GetPDGEncoding()};
      pdg_id != 11)
    return;
 
  // 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 track_region{log_vol ? log_vol->GetRegion() : nullptr};
  if (track_region != target_region) return;
 
  /*
  std::cout << "[TargetBremFilter] : Stepping primary electron in 'target'
  region into "
    << track->GetNextVolume()->GetName()
    << std::endl;
   */
 
  auto recoil_physical_volume =
      simcore::g4user::ptrretrieval::getPhysicalVolume("recoil_PV");
  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 track_volume = track->GetNextVolume();
  if (track_volume == recoil_physical_volume or
      track_volume == world_physical_volume) {
    // If the recoil electron
    if (track->GetMomentum().mag() >= recoil_max_p_threshold_) {
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    }
 
    // Get the electron secondries
    bool has_brem_candidate = false;
    if (auto secondaries = step->GetSecondary(); secondaries->size() == 0) {
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    } else {
      for (auto& secondary_track : *secondaries) {
        auto electron = G4Electron::Definition();
        auto ebrem_process =
            simcore::g4user::ptrretrieval::getProcess(electron, "eBrem");
        if (!ebrem_process) {
          ldmx_log(warn) << "Process 'eBrem' not found in Geant4 process store";
        }
 
        if (ebrem_process &&
            secondary_track->GetKineticEnergy() > brem_energy_threshold_) {
          auto track_info{simcore::UserTrackInformation::get(secondary_track)};
          track_info->tagBremCandidate();
 
          getEventInfo()->incBremCandidateCount();
 
          has_brem_candidate = true;
        }
      }
    }
 
    if (!has_brem_candidate) {
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    }
 
    /*
    std::cout << "[TargetBremFilter] : Found brem candidate" << std::endl;
     */
 
    // Check if the recoil electron should be killed.  If not, postpone
    // its processing until the brem gamma has been processed.
    if (kill_recoil_)
      track->SetTrackStatus(fStopAndKill);
    else
      track->SetTrackStatus(fSuspend);
 
  } else if (step->GetPostStepPoint()->GetKineticEnergy() == 0) {
    track->SetTrackStatus(fKillTrackAndSecondaries);
    G4RunManager::GetRunManager()->AbortEvent();
    return;
  }
}

References brem_energy_threshold_, simcore::UserTrackInformation::get(), simcore::UserAction::getEventInfo(), simcore::UserEventInformation::incBremCandidateCount(), kill_recoil_, and recoil_max_p_threshold_.

Member Data Documentation

brem_energy_threshold_

double biasing::TargetBremFilter::brem_energy_threshold_ {2500}

private

Brem gamma energy treshold.

Definition at line 69 of file TargetBremFilter.h.

{2500};

Referenced by stepping(), and TargetBremFilter().

kill_recoil_

bool biasing::TargetBremFilter::kill_recoil_ {false}

private

Flag indicating if the recoil electron track should be killed.

Definition at line 72 of file TargetBremFilter.h.

{false};

Referenced by stepping(), and TargetBremFilter().

recoil_max_p_threshold_

double biasing::TargetBremFilter::recoil_max_p_threshold_ {1500}

private

Recoil electron threshold.

Definition at line 66 of file TargetBremFilter.h.

{1500};  // MeV

Referenced by stepping(), and TargetBremFilter().

---

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

• Biasing/include/Biasing/TargetBremFilter.h
• Biasing/src/Biasing/TargetBremFilter.cxx