G4UA::AthenaStackingAction Class Reference

Standard ATLAS stacking action functionality. More...

#include <AthenaStackingAction.h>

Inheritance diagram for G4UA::AthenaStackingAction:

Collaboration diagram for G4UA::AthenaStackingAction:

Classes
struct	Config
	Configuration option struct for AthenaStackingAction. More...

Public Member Functions
	AthenaStackingAction (const Config &config)
	Constructor with configuration.
virtual G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *track) override
	Classify a new track.

Protected Member Functions
bool	isNeutrino (const G4Track *) const
	Identify track as a neutrino.
bool	isGamma (const G4Track *) const
	Identify track as a photon.
bool	isNeutron (const G4Track *) const
	Identify track as a neutron.
PrimaryParticleInformation *	getPrimaryParticleInformation (const G4Track *track) const
	obtain the PrimaryParticleInformation from the current G4Track

Protected Attributes
Config	m_config
	Configuration options.
double	m_oneOverWeightNeutron
double	m_oneOverWeightPhoton

Detailed Description

Standard ATLAS stacking action functionality.

Mostly taken from the old AthenaStackingAction implementation, but adapted for the new user action design for multi-threading.

Author

Steve Farrell Steve.nosp@m.n.Fa.nosp@m.rrell.nosp@m.@cer.nosp@m.n.ch

Definition at line 22 of file AthenaStackingAction.h.

Constructor & Destructor Documentation

AthenaStackingAction()

G4UA::AthenaStackingAction::AthenaStackingAction

(

const Config &

config

)

Constructor with configuration.

Definition at line 41 of file AthenaStackingAction.cxx.

                                                                :
    m_config(config),
    m_oneOverWeightNeutron(0),
    m_oneOverWeightPhoton(0)
  {
    // calculate this division only once
    if (m_config.applyNRR)
      m_oneOverWeightNeutron = 1./m_config.russianRouletteNeutronWeight;
 
    // calculate this division only once
    if (m_config.applyPRR)
      m_oneOverWeightPhoton = 1./m_config.russianRoulettePhotonWeight;
  }

Member Function Documentation

ClassifyNewTrack()

G4ClassificationOfNewTrack G4UA::AthenaStackingAction::ClassifyNewTrack ( const G4Track * track )

overridevirtual

Classify a new track.

Result can be fUrgent, fWaiting, fPostpone, or fKill.

Pass ownership to track. The G4VUserTrackInformation* fpUserInformation member variable set by this method is mutable. G4Tracks are thread-local.

Pass ownership to track. The G4VUserTrackInformation* fpUserInformation member variable set by this method is mutable. G4Tracks are thread-local.

Reimplemented in G4UA::AthenaDebugStackingAction.

Definition at line 59 of file AthenaStackingAction.cxx.

  {
    // Kill neutrinos if enabled
    if(m_config.killAllNeutrinos && isNeutrino(track)) {
      return fKill;
    }
 
    // Kill super-low-E photons
    const double safeCut = 0.00005;
    double totalE = track->GetTotalEnergy();
    if(isGamma(track) && totalE < safeCut) {
      return fKill;
    }
 
    // TODO: Why is this here? Can I remove it?
    G4Event* ev = G4EventManager::GetEventManager()->GetNonconstCurrentEvent();
    AtlasG4EventUserInfo* atlasG4EvtUserInfo __attribute__ ((unused)) =
      static_cast<AtlasG4EventUserInfo*> (ev->GetUserInformation());
 
    // Neutron Russian Roulette
    if (m_config.applyNRR && isNeutron(track) &&
        track->GetWeight() < m_config.russianRouletteNeutronWeight && // do not re-Roulette particles
        track->GetKineticEnergy() < m_config.russianRouletteNeutronThreshold) {
      // shoot random number
      if ( CLHEP::RandFlat::shoot() > m_oneOverWeightNeutron ) {
        // Kill (w-1)/w neutrons
        return fKill;
      }
      // TODO There may be another way to set the weights via
      // another G4 interface avoiding the const_cast, but the
      // changes are more major and will need more careful validation.
      G4Track* mutableTrack ATLAS_THREAD_SAFE = const_cast<G4Track*> (track);
      // Weight the rest 1/w neutrons with a weight of w
      mutableTrack->SetWeight(m_config.russianRouletteNeutronWeight);
    }
 
    // Photon Russian Roulette
    if (m_config.applyPRR && isGamma(track) && track->GetOriginTouchable() &&
        track->GetOriginTouchable()->GetVolume()->GetName().substr(0, 3) == "LAr" && // only for photons created in LAr
        track->GetWeight() < m_config.russianRoulettePhotonWeight && // do not re-Roulette particles
        track->GetKineticEnergy() < m_config.russianRoulettePhotonThreshold) {
      // shoot random number
      if ( CLHEP::RandFlat::shoot() > m_oneOverWeightPhoton ) {
        // Kill (w-1)/w photons
        return fKill;
      }
      // TODO There may be another way to set the weights via
      // another G4 interface avoiding the const_cast, but the
      // changes are more major and will need more careful validation.
      G4Track* mutableTrack ATLAS_THREAD_SAFE = const_cast<G4Track*> (track);
      // Weight the rest 1/w neutrons with a weight of w
      mutableTrack->SetWeight(m_config.russianRoulettePhotonWeight);
    }
 
    // Handle primary particles
    if(track->GetParentID() == 0) { // Condition for Primaries
      // Extract the PrimaryParticleInformation
      PrimaryParticleInformation* primaryPartInfo = this->getPrimaryParticleInformation(track);
      // Fill some information for this track
      if(primaryPartInfo) {
        if (!m_config.isISFJob) {
          // don't do anything
          auto  part = primaryPartInfo->GetHepMCParticle();
          if (part) {
            // OK, we got back to HepMC
            std::unique_ptr<TrackInformation> ti = std::make_unique<TrackInformation>(part);
            ti->SetRegenerationNr(0);
            ti->SetClassification(TrackInformation::Primary);
            // regNr=0 and classify=Primary are default values anyway
            track->SetUserInformation(ti.release());
          }
          // TODO What does this condition mean?
          else if(primaryPartInfo->GetParticleUniqueID() >= 0 && primaryPartInfo->GetParticleBarcode() >= 0) {
            // PrimaryParticleInformation should at least provide a barcode
            std::unique_ptr<TrackBarcodeInfo> bi = std::make_unique<TrackBarcodeInfo>(primaryPartInfo->GetParticleUniqueID(), primaryPartInfo->GetParticleBarcode());
            track->SetUserInformation(bi.release());
          }
        } // no ISFParticle attached
      } // has PrimaryParticleInformation
    }
    // Secondary track; decide whether to save or kill
    else if( isGamma(track) &&
             m_config.photonEnergyCut > 0 &&
             totalE < m_config.photonEnergyCut )
      {
        return fKill;
      }
    return fUrgent;
  }

getPrimaryParticleInformation()

PrimaryParticleInformation * G4UA::AthenaStackingAction::getPrimaryParticleInformation ( const G4Track * track ) const

protected

obtain the PrimaryParticleInformation from the current G4Track

Definition at line 155 of file AthenaStackingAction.cxx.

  {
    const G4DynamicParticle* dp = track->GetDynamicParticle();
    if(dp) {
      const G4PrimaryParticle* pp = nullptr;
      pp = dp->GetPrimaryParticle();
      if(pp) {
        // Extract the PrimaryParticleInformation
        return dynamic_cast<PrimaryParticleInformation*>
          ( pp->GetUserInformation() );
      }
    }
    return nullptr;
  }

isGamma()

bool G4UA::AthenaStackingAction::isGamma ( const G4Track * track ) const

protected

Identify track as a photon.

Definition at line 185 of file AthenaStackingAction.cxx.

  {
    return track->GetParticleDefinition() == G4Gamma::Gamma();
  }

isNeutrino()

bool G4UA::AthenaStackingAction::isNeutrino ( const G4Track * track ) const

protected

Identify track as a neutrino.

It might be useful to move this kind of functionality into some standalong helper function(s).

Definition at line 173 of file AthenaStackingAction.cxx.

  {
    auto particleDef = track->GetParticleDefinition();
    return (particleDef == G4NeutrinoE::NeutrinoEDefinition()           ||
            particleDef == G4AntiNeutrinoE::AntiNeutrinoEDefinition()   ||
            particleDef == G4NeutrinoMu::NeutrinoMuDefinition()         ||
            particleDef == G4AntiNeutrinoMu::AntiNeutrinoMuDefinition() ||
            particleDef == G4NeutrinoTau::NeutrinoTauDefinition()       ||
            particleDef == G4AntiNeutrinoTau::AntiNeutrinoTauDefinition());
  }

isNeutron()

bool G4UA::AthenaStackingAction::isNeutron ( const G4Track * track ) const

protected

Identify track as a neutron.

Definition at line 191 of file AthenaStackingAction.cxx.

  {
    return track->GetParticleDefinition() == G4Neutron::Neutron();
  }

Member Data Documentation

m_config

Config G4UA::AthenaStackingAction::m_config

protected

Configuration options.

Definition at line 61 of file AthenaStackingAction.h.

m_oneOverWeightNeutron

double G4UA::AthenaStackingAction::m_oneOverWeightNeutron

protected

Definition at line 78 of file AthenaStackingAction.h.

m_oneOverWeightPhoton

double G4UA::AthenaStackingAction::m_oneOverWeightPhoton

protected

Definition at line 81 of file AthenaStackingAction.h.

---

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

• AthenaStackingAction.h
• AthenaStackingAction.cxx