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.
double	brem_theta_min_
	Maximum and Minimum brem gamma angle relative to beam axis [rad].
double	brem_theta_max_
double	dral_min_
	Maximum and Minimum electron-photon separation in eta-phi space.
double	dral_max_
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.
void	abortEvent (const std::string &reason) const
	Helper to abort an event with a message.
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 27 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");
  brem_theta_min_ = parameters.get<double>("brem_theta_min");
  brem_theta_max_ = parameters.get<double>("brem_theta_max");
  dral_min_ = parameters.get<double>("dral_min");
  dral_max_ = parameters.get<double>("dral_max");
  kill_recoil_ = parameters.get<bool>("kill_recoil_track");
 
  ldmx_log(info) << "TargetBremFilter configured:"
                 << " recoil_max_p_threshold=" << recoil_max_p_threshold_
                 << " brem_min_energy_threshold=" << brem_energy_threshold_
                 << " brem_theta=[" << brem_theta_min_ << ", "
                 << brem_theta_max_ << "]"
                 << " dral=[" << dral_min_ << ", " << dral_max_ << "]";
}

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

~TargetBremFilter()

biasing::TargetBremFilter::~TargetBremFilter

(

)

Destructor.

Definition at line 46 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 48 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 232 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 67 of file TargetBremFilter.cxx.

                                                  {
  double last_dral = -1;
  double last_theta = -1;
  // 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 momentum is too high, abort
    if (track->GetMomentum().mag() >= recoil_max_p_threshold_) {
      ldmx_log(trace) << "Abort: recoil p=" << track->GetMomentum().mag()
                      << " MeV >= threshold=" << recoil_max_p_threshold_;
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    }
 
    // Get the electron secondaries
    bool has_brem_candidate = false;
    if (auto secondaries = step->GetSecondary(); secondaries->size() == 0) {
      ldmx_log(trace) << "Abort: no secondaries produced";
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    } else {
      ldmx_log(trace) << "Exiting target: recoil p ="
                      << track->GetMomentum().mag() << " MeV, "
                      << secondaries->size() << " secondaries";
 
      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_) {
          // Check if secondary is photon
          auto secondary_pdg_id =
              secondary_track->GetParticleDefinition()->GetPDGEncoding();
          if (secondary_pdg_id != 22) continue;
 
          // Brem angle
          auto momentum = secondary_track->GetMomentum();
          double theta = std::atan2(std::sqrt(momentum.x() * momentum.x() +
                                              momentum.y() * momentum.y()),
                                    momentum.z());
          bool pass_brem_theta =
              theta >= brem_theta_min_ && theta <= brem_theta_max_;
 
          // Maximum and Minimum angle between outgoing Brem photons and
          // electrons
          auto gamma_mom = secondary_track->GetMomentum();
          auto electron_mom = track->GetMomentum();
          double gamma_eta = gamma_mom.eta();
          double gamma_phi = gamma_mom.phi();
          double electron_eta = electron_mom.eta();
          double electron_phi = electron_mom.phi();
 
          double dphi = std::atan2(std::sin(electron_phi - gamma_phi),
                                   std::cos(electron_phi - gamma_phi));
          double dral = std::sqrt((electron_eta - gamma_eta) *
                                      (electron_eta - gamma_eta) +
                                  dphi * dphi);
          bool pass_dral = dral >= dral_min_ && dral <= dral_max_;
 
          last_theta = theta;
          last_dral = dral;
 
          ldmx_log(trace) << "  photon E="
                          << secondary_track->GetKineticEnergy()
                          << " MeV, theta=" << theta
                          << " (pass=" << pass_brem_theta << ")"
                          << ", dR=" << dral << " (pass=" << pass_dral << ")";
 
          if (pass_brem_theta && pass_dral) {
            auto track_info{
                simcore::UserTrackInformation::get(secondary_track)};
            track_info->tagBremCandidate();
 
            getEventInfo()->incBremCandidateCount();
 
            has_brem_candidate = true;
          }
        }
      }
    }
 
    if (!has_brem_candidate) {
      ldmx_log(trace) << "Abort: no brem candidate passed cuts";
      track->SetTrackStatus(fKillTrackAndSecondaries);
      G4RunManager::GetRunManager()->AbortEvent();
      return;
    }
 
    ldmx_log(info) << "ACCEPTED: brem candidate with theta=" << last_theta
                   << ", dR=" << last_dral;
 
    // 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_, brem_theta_min_, dral_min_, 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().

brem_theta_max_

double biasing::TargetBremFilter::brem_theta_max_

private

Definition at line 73 of file TargetBremFilter.h.

brem_theta_min_

double biasing::TargetBremFilter::brem_theta_min_

private

Maximum and Minimum brem gamma angle relative to beam axis [rad].

Definition at line 72 of file TargetBremFilter.h.

Referenced by stepping(), and TargetBremFilter().

dral_max_

double biasing::TargetBremFilter::dral_max_

private

Definition at line 77 of file TargetBremFilter.h.

dral_min_

double biasing::TargetBremFilter::dral_min_

private

Maximum and Minimum electron-photon separation in eta-phi space.

Definition at line 76 of file TargetBremFilter.h.

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 80 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