G4UA::AthenaDebugStackingAction Class Reference

Debug version of the AthenaStackingAction used for validation of Russian Roulette algorimts. It can ensure that there is no randomization in simulation caused by turning the Russian Roulette on or off. More...

#include <AthenaDebugStackingAction.h>

Inheritance diagram for G4UA::AthenaDebugStackingAction:

Collaboration diagram for G4UA::AthenaDebugStackingAction:

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

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

Protected Attributes
Config	m_config
	Configuration options. More...
double	m_oneOverWeightNeutron
double	m_oneOverWeightPhoton

Detailed Description

Debug version of the AthenaStackingAction used for validation of Russian Roulette algorimts. It can ensure that there is no randomization in simulation caused by turning the Russian Roulette on or off.

Author

Miha Muskinja Miha..nosp@m.Musk.nosp@m.inja@.nosp@m.cern.nosp@m..ch

Definition at line 24 of file AthenaDebugStackingAction.h.

Constructor & Destructor Documentation

AthenaDebugStackingAction()

G4UA::AthenaDebugStackingAction::AthenaDebugStackingAction

(

const Config &

config

)

Constructor with configuration.

Definition at line 32 of file AthenaDebugStackingAction.cxx.

                                                                          :
    AthenaStackingAction(config) {}

Member Function Documentation

ClassifyNewTrack()

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

finaloverridevirtual

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 from G4UA::AthenaStackingAction.

Definition at line 39 of file AthenaDebugStackingAction.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());
 
    // Was track subject to a RR?
    bool rouletted = false;
 
    // Neutron Russian Roulette
    if (m_config.russianRouletteNeutronThreshold > 0 && 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 ) {
        if (m_config.applyNRR) {
          // Kill (w-1)/w neutrons
          return fKill;
        } else {
          // process them at the end of the stack
          return fWaiting;
        }
      }
      rouletted = true;
      // Weight the rest 1/w neutrons with a weight of w
      if (m_config.applyNRR) {
        // 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);
        mutableTrack->SetWeight(m_config.russianRouletteNeutronWeight);
      }
    }
 
    // Photon Russian Roulette
    if (m_config.russianRoulettePhotonThreshold > 0 && 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 ) {
        if (m_config.applyPRR) {
          // Kill (w-1)/w photons
          return fKill;
        } else {
          // process them at the end of the stack
          return fWaiting;
        }
      }
      rouletted = true;
      // Weight the rest 1/w neutrons with a weight of w
      if (m_config.applyPRR) {
        // 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);
        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());
          }
          // 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;
      }
    // Put rouletted tracks at the end of the stack
    if (rouletted)
      return fWaiting;
    else
      return fUrgent;
  }

getPrimaryParticleInformation()

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

Configuration options.

Definition at line 61 of file AthenaStackingAction.h.

m_oneOverWeightNeutron

double G4UA::AthenaStackingAction::m_oneOverWeightNeutron

protectedinherited

Definition at line 78 of file AthenaStackingAction.h.

m_oneOverWeightPhoton

double G4UA::AthenaStackingAction::m_oneOverWeightPhoton

protectedinherited

Definition at line 81 of file AthenaStackingAction.h.

---

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

• AthenaDebugStackingAction.h
• AthenaDebugStackingAction.cxx