G4LongLivedNeutralTransportation.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
// modified from GEANT4 G4Transportation class
 
 
#ifndef G4LongLivedNeutralTransportation_hh
#define G4LongLivedNeutralTransportation_hh 1
 
#include "G4VProcess.hh"
#include "G4FieldManager.hh"
 
#include "G4Navigator.hh"
#include "G4TransportationManager.hh"
#include "G4PropagatorInField.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ParticleChangeForTransport.hh"
 
class G4SafetyHelper;
class G4CoupledTransportation;
namespace Belle2 {

  class G4LongLivedNeutralTransportation : public G4VProcess {
 
  public:

    G4LongLivedNeutralTransportation(G4int verbosityLevel = 1);

    ~G4LongLivedNeutralTransportation();

    G4double AlongStepGetPhysicalInteractionLength(
      const G4Track& track,
      G4double  previousStepSize,
      G4double  currentMinimumStep,
      G4double& currentSafety,
      G4GPILSelection* selection
    );

    G4VParticleChange* AlongStepDoIt(
      const G4Track& track,
      const G4Step& stepData
    );

    G4VParticleChange* PostStepDoIt(
      const G4Track& track,
      const G4Step&  stepData
    );

    G4double PostStepGetPhysicalInteractionLength(
      const G4Track& track,
      G4double   previousStepSize,
      G4ForceCondition* pForceCond
    );
 
 
 
    inline G4bool FieldExertedForce() { return fFieldExertedForce; }
 
    G4PropagatorInField* GetPropagatorInField();
    void SetPropagatorInField(G4PropagatorInField* pFieldPropagator);
 
    inline G4double GetThresholdWarningEnergy() const; 
    inline G4double GetThresholdImportantEnergy() const; 
    inline G4int GetThresholdTrials() const; 
 
 
 
    inline void SetThresholdWarningEnergy(G4double newEnWarn)
    {
      fThreshold_Warning_Energy = newEnWarn;
    } 
    inline void SetThresholdImportantEnergy(G4double newEnImp)
    {
      fThreshold_Important_Energy = newEnImp;
    } 
    inline void SetThresholdTrials(G4int newMaxTrials)
    {
      fThresholdTrials = newMaxTrials;
    }
 

 
    void SetHighLooperThresholds();
    void SetLowLooperThresholds();
    void ReportLooperThresholds();
 
    inline G4double GetMaxEnergyKilled() const;
    inline G4double GetSumEnergyKilled() const;
    inline void ResetKilledStatistics(G4int report = 1);
 
    inline void EnableShortStepOptimisation(G4bool optimise = true);
 
    static void   SetSilenceLooperWarnings(G4bool val);
    static G4bool GetSilenceLooperWarnings();
 
  public:  // without description

    G4double AtRestGetPhysicalInteractionLength(const G4Track&,
                                                G4ForceCondition*)
    { return -1.0; }

    G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&)
    { return 0; }
 
    void StartTracking(G4Track* aTrack);

    virtual void ProcessDescription(std::ostream& outStream) const;
 
    void PrintStatistics(std::ostream& outStr) const;
 
  protected:

    inline G4bool DoesGlobalFieldExist()
    {
      G4TransportationManager* transportMgr;
      transportMgr = G4TransportationManager::GetTransportationManager();
 
      // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
      // return fFieldExists;
      return transportMgr->GetFieldManager()->DoesFieldExist();
    }
 
  private:
 
    G4Navigator* fLinearNavigator; 
    G4PropagatorInField* fFieldPropagator; 
 
    G4ThreeVector fTransportEndPosition = G4ThreeVector(0.0, 0.0, 0.0); 
    G4ThreeVector fTransportEndMomentumDir = G4ThreeVector(0.0, 0.0, 0.0); 
    G4double      fTransportEndKineticEnergy = 0.0; 
    G4ThreeVector fTransportEndSpin = G4ThreeVector(0.0, 0.0, 0.0); 
    G4bool        fMomentumChanged =  true; 
    G4bool        fEndGlobalTimeComputed = false; 
    G4double      fCandidateEndGlobalTime = 0.0; 
 
    G4bool        fAnyFieldExists = false; 
 
    G4bool fNewTrack = true;          
    G4bool fFirstStepInVolume = true; 
    G4bool fLastStepInVolume = false; 
    G4bool fGeometryLimitedStep = true; 
 
    G4bool fFieldExertedForce = false; 
 
    G4TouchableHandle fCurrentTouchableHandle; 
 
    G4ThreeVector fPreviousSftOrigin; 
    G4double      fPreviousSafety; 
 
    G4ParticleChangeForTransport fParticleChange; 
 
    G4double fEndPointDistance; 
 
    // Thresholds for looping particles:
    //
    G4double fThreshold_Warning_Energy =   1.0 * CLHEP::keV;  
    G4double fThreshold_Important_Energy = 1.0 * CLHEP::MeV;  
    G4int    fThresholdTrials = 10;  
    // Above 'important' energy a 'looping' particle in field will
    // *NOT* be abandoned, except after fThresholdTrials attempts.
    G4int    fAbandonUnstableTrials = 0; 
    //   unstable loopers ( 0 = never )
    // Counter for steps in which particle reports 'looping',
    //  ( Used if it is above 'Important' Energy. )
    G4int    fNoLooperTrials = 0; 
 
    // Statistics for tracks abandoned due to looping, only used as flag, no looping neutral particles
    //
    G4double fSumEnergyKilled = 0.0;
    G4bool   fShortStepOptimisation;
 
    G4SafetyHelper* fpSafetyHelper; 
 
  private:
 
    friend class G4CoupledTransportation;
    static G4bool fUseMagneticMoment; 
    static G4bool fUseGravity; 
    static G4bool fSilenceLooperWarnings;  
 
  };
}
 
#endif