EIC code displayed by LXR master/​include/​Geant4/​G4ITTransportation.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:58:33

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 //
 /// \brief This class is a slightly modified version of G4Transportation
 ///        initially written by John Apostolakis and colleagues (1997)
 ///        But it should use the exact same algorithm
 //
 // Original Author : John Apostolakis
 //
 // Contact : Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
 //
 // WARNING : This class is released as a prototype.
 // It might strongly evolve or even disapear in the next releases.
 //
 // -------------------------------------------------------------------
 // Author: Mathieu Karamitros
 
 // The code is developed in the framework of the ESA AO7146
 //
 // We would be very happy hearing from you, send us your feedback! :)
 //
 // In order for Geant4-DNA to be maintained and still open-source,
 // article citations are crucial. 
 // If you use Geant4-DNA chemistry and you publish papers about your software, 
 // in addition to the general paper on Geant4-DNA:
 //
 // Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
 //
 // we would be very happy if you could please also cite the following
 // reference papers on chemistry:
 //
 // J. Comput. Phys. 274 (2014) 841-882
 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508 
 
 #ifndef G4ITTransportation_H
 #define G4ITTransportation_H
 
 #include <CLHEP/Units/SystemOfUnits.h>
 
 #include "G4VITProcess.hh"
 #include "G4Track.hh"
 #include "G4Step.hh"
 #include "G4ParticleChangeForTransport.hh"
 
 class G4ITNavigator;
 //class G4Navigator;
 class G4ITSafetyHelper;
 class G4PropagatorInField;
 
 class G4ITTransportation : public G4VITProcess
 {
   // Concrete class that does the geometrical transport
 public:
   // with description
 
   G4ITTransportation(const G4String& aName = "ITTransportation",
                      G4int verbosityLevel = 0);
   ~G4ITTransportation() override;
 
   G4ITTransportation(const G4ITTransportation&);
 
   G4IT_ADD_CLONE(G4VITProcess, G4ITTransportation)
 
   void BuildPhysicsTable(const G4ParticleDefinition&) override;
 
   virtual void ComputeStep(const G4Track&,
                            const G4Step&,
                            const double timeStep,
                            double& spaceStep);
 
   void StartTracking(G4Track* aTrack) override;
   // Give to the track a pointer to the transportation state
 
   G4bool IsStepLimitedByGeometry()
   {
     return GetState<G4ITTransportationState>()->fGeometryLimitedStep;
   }
 
   //________________________________________________________
 public:
   // without description
 
   G4double AtRestGetPhysicalInteractionLength(const G4Track&,
                                                       G4ForceCondition*) override
   {
     return -1.0;
   }
   // No operation in  AtRestDoIt.
 
   G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&) override
   {
     return nullptr;
   }
   // No operation in  AtRestDoIt.
 
   G4double AlongStepGetPhysicalInteractionLength(const G4Track& track,
                                                          G4double, //   previousStepSize
                                                          G4double currentMinimumStep,
                                                          G4double& currentSafety,
                                                          G4GPILSelection* selection) override;
 
   G4double PostStepGetPhysicalInteractionLength(const G4Track&, // track
                                                         G4double, // previousStepSize
                                                         G4ForceCondition* pForceCond) override;
 
   G4VParticleChange* AlongStepDoIt(const G4Track& track,
                                            const G4Step& stepData) override;
 
   G4VParticleChange* PostStepDoIt(const G4Track& track, const G4Step&) override;
 
   //________________________________________________________
   //    inline virtual G4double GetTransportationTime() ;
 
   G4PropagatorInField* GetPropagatorInField();
   void SetPropagatorInField(G4PropagatorInField* pFieldPropagator);
   // Access/set the assistant class that Propagate in a Field.
 
   inline void SetVerboseLevel(G4int verboseLevel);
   inline G4int GetVerboseLevel() const;
   // Level of warnings regarding eg energy conservation
   // in field integration.
 
   inline G4double GetThresholdWarningEnergy() const;
   inline G4double GetThresholdImportantEnergy() const;
   inline G4int GetThresholdTrials() const;
 
   inline void SetThresholdWarningEnergy(G4double newEnWarn);
   inline void SetThresholdImportantEnergy(G4double newEnImp);
   inline void SetThresholdTrials(G4int newMaxTrials);
 
   // Get/Set parameters for killing loopers:
   //   Above 'important' energy a 'looping' particle in field will
   //   *NOT* be abandoned, except after fThresholdTrials attempts.
   // Below Warning energy, no verbosity for looping particles is issued
 
   inline G4double GetMaxEnergyKilled() const;
   inline G4double GetSumEnergyKilled() const;
   inline void ResetKilledStatistics(G4int report = 1);
   // Statistics for tracks killed (currently due to looping in field)
 
   inline void EnableShortStepOptimisation(G4bool optimise = true);
   // Whether short steps < safety will avoid to call Navigator (if field=0)
 
 protected:
   //________________________________________________________________
   // Protected methods
   G4bool DoesGlobalFieldExist();
   // Checks whether a field exists for the "global" field manager.
 
   //________________________________________________________________
   // Process information
   struct G4ITTransportationState : public G4ProcessState
   {
   public:
     G4ITTransportationState();
     ~G4ITTransportationState() override;
     G4String GetType() override
     {
       return "G4ITTransportationState";
     }
 
     G4ThreeVector fTransportEndPosition;
     G4ThreeVector fTransportEndMomentumDir;
     G4double fTransportEndKineticEnergy;
     G4ThreeVector fTransportEndSpin;
     G4bool fMomentumChanged;
     G4bool fEnergyChanged;
     G4bool fEndGlobalTimeComputed;
     G4double fCandidateEndGlobalTime;
     G4bool fParticleIsLooping;
     // The particle's state after this Step, Store for DoIt
 
     G4TouchableHandle fCurrentTouchableHandle;
     G4bool fGeometryLimitedStep;
     // Flag to determine whether a boundary was reached.
 
     G4ThreeVector fPreviousSftOrigin;
     G4double fPreviousSafety;
     // Remember last safety origin & value.
 
     // Counter for steps in which particle reports 'looping',
     //   if it is above 'Important' Energy
     G4int fNoLooperTrials;
 
     // G4bool         fFieldExists;
     // Whether a magnetic field exists ...
     // A data member for this is problematic: it is useful only if it
     // can be initialised and updated -- and a scheme is not yet possible.
 
     G4double fEndPointDistance;
   };
 
   //________________________________________________________________
   // Informations relative to the process only (meaning no information
   // relative to the treated particle)
   G4ITNavigator* fLinearNavigator;
   G4PropagatorInField* fFieldPropagator;
   // The Propagators used to transport the particle
 
   // static const G4TouchableHandle nullTouchableHandle;
   // Points to (G4VTouchable*) 0
 
   G4ParticleChangeForTransport fParticleChange;
   // New ParticleChange
 
   // Thresholds for looping particles:
   //
   G4double fThreshold_Warning_Energy; //  Warn above this energy
   G4double fThreshold_Important_Energy; //  Hesitate above this
   G4int fThresholdTrials{10}; //    for this no of trials
   // Above 'important' energy a 'looping' particle in field will
   //   *NOT* be abandoned, except after fThresholdTrials attempts.
   G4double fUnimportant_Energy;
   //  Below this energy, no verbosity for looping particles is issued
 
   // Statistics for tracks abandoned
   G4double fSumEnergyKilled{0.0};
   G4double fMaxEnergyKilled{0.0};
 
   // Whether to avoid calling G4Navigator for short step ( < safety)
   //   If using it, the safety estimate for endpoint will likely be smaller.
   G4bool fShortStepOptimisation{false};
 
   G4ITSafetyHelper* fpSafetyHelper; // To pass it the safety value obtained
 
   // Verbosity
   G4int fVerboseLevel;
   // Verbosity level for warnings
   // eg about energy non-conservation in magnetic field.
 
   void SetInstantiateProcessState(G4bool flag)
   {
     fInstantiateProcessState = flag;
   }
 
   G4bool InstantiateProcessState()
   {
     return fInstantiateProcessState;
   }
 
 private:
   G4bool fInstantiateProcessState;
   G4ITTransportation& operator=(const G4ITTransportation&);
 };
 
 #include "G4ITTransportation.icc"
 #endif // G4ITTransportation_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team