Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/include/G4FastSimulationManagerProcess.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/parameterisation/include/G4FastSimulationManagerProcess.hh (Version 11.3.0) and /processes/parameterisation/include/G4FastSimulationManagerProcess.hh (Version 1.1)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  5 // * The  Geant4 software  is  copyright of th << 
  6 // * the Geant4 Collaboration.  It is provided << 
  7 // * conditions of the Geant4 Software License << 
  8 // * LICENSE and available at  http://cern.ch/ << 
  9 // * include a list of copyright holders.      << 
 10 // *                                           << 
 11 // * Neither the authors of this software syst << 
 12 // * institutes,nor the agencies providing fin << 
 13 // * work  make  any representation or  warran << 
 14 // * regarding  this  software system or assum << 
 15 // * use.  Please see the license in the file  << 
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                           << 
 18 // * This  code  implementation is the result  << 
 19 // * technical work of the GEANT4 collaboratio << 
 20 // * By using,  copying,  modifying or  distri << 
 21 // * any work based  on the software)  you  ag << 
 22 // * use  in  resulting  scientific  publicati << 
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // ******************************************* << 
 25 //                                             << 
 26 //                                             << 
 27 //                                                  7 //
                                                   >>   8 // $Id: G4FastSimulationManagerProcess.hh,v 1.4.2.1.2.1 1999/12/07 20:52:52 gunter Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-01-01 $
 28 //                                                 10 //
                                                   >>  11 // 
 29 //--------------------------------------------     12 //---------------------------------------------------------------
 30 //                                                 13 //
 31 //  G4FastSimulationManagerProcess.hh              14 //  G4FastSimulationManagerProcess.hh
 32 //                                                 15 //
 33 //  Description:                                   16 //  Description:
 34 //    The process that triggers parameterised  <<  17 //    The process that triggers parameterised simulations
                                                   >>  18 //    if any.
 35 //                                                 19 //
 36 //  History:                                       20 //  History:
 37 //  Feb 98: Parallel geometry sensitivity. Mor     21 //  Feb 98: Parallel geometry sensitivity. MoraDeFreitas.
 38 //  Oct 97: "Fast" replaces "Parameterisation" <<  22 //  Oct 97: "Fast" replaces "Parameterisation" in class/method names. 
 39 //          (release B.00 for parameterisation     23 //          (release B.00 for parameterisation). MoraDeFreitas.
 40 //  Aug 97: First implementation. Verderi && M     24 //  Aug 97: First implementation. Verderi && MoraDeFreitas.
 41 //  Apr 98: modified for new particle change.      25 //  Apr 98: modified for new particle change.  H.Kurashige
 42 //  Oct 06: Move to parallel geometry scheme.  << 
 43 //  Nov 06: name xxx81 is given for this relea << 
 44 //          removed @ next maj. rel. so that t << 
 45 //          the standard one.                  << 
 46 //  May 07: remove "81" tags, to migrate to 9. << 
 47 //                                                 26 //
 48 //--------------------------------------------     27 //---------------------------------------------------------------
 49                                                    28 
 50 #ifndef G4FastSimulationManagerProcess_hh      << 
 51 #define G4FastSimulationManagerProcess_hh      << 
 52                                                    29 
                                                   >>  30 #ifndef G4FastSimulationManagerProcess_h
                                                   >>  31 #define G4FastSimulationManagerProcess_h 1
                                                   >>  32 
                                                   >>  33 #include "g4rw/tpordvec.h"
                                                   >>  34 
                                                   >>  35 #include "globals.hh"
                                                   >>  36 #include "G4VProcess.hh"
 53 #include "G4FastSimulationManager.hh"              37 #include "G4FastSimulationManager.hh"
 54 #include "G4FastSimulationProcessType.hh"      << 
 55 #include "G4FieldTrack.hh"                     << 
 56 #include "G4Navigator.hh"                      << 
 57 #include "G4Step.hh"                               38 #include "G4Step.hh"
 58 #include "G4VParticleChange.hh"                <<  39 #include "G4Navigator.hh"
                                                   >>  40 #include "G4PropagatorInField.hh"
                                                   >>  41 #include "G4VTouchable.hh"
                                                   >>  42 #include "G4TouchableHistory.hh"
 59 #include "G4VPhysicalVolume.hh"                    43 #include "G4VPhysicalVolume.hh"
 60 #include "G4VProcess.hh"                       <<  44 #include "G4VParticleChange.hh"
 61 #include "globals.hh"                          << 
 62 class G4PathFinder;                            << 
 63 class G4TransportationManager;                 << 
 64                                                    45 
 65 // ------------------------------------------- <<  46 //------------------------------------------
 66 //                                                 47 //
 67 //        G4FastSimulationManagerProcess class     48 //        G4FastSimulationManagerProcess class
 68 //                                                 49 //
 69 // ------------------------------------------- <<  50 //------------------------------------------
                                                   >>  51 
 70                                                    52 
 71 // Class Description:                              53 // Class Description:
 72 // -- G4VProcess providing the interface betwe <<  54 // This is a G4VProcess. It provides the interface between the tracking and the parameterisation.
                                                   >>  55 // It has to be set in the process list of the particles you want to parameterise. 
 73 //                                                 56 //
 74                                                    57 
 75 class G4FastSimulationManagerProcess : public      58 class G4FastSimulationManagerProcess : public G4VProcess
 76 {                                                  59 {
 77   public:                                      <<  60 public:
 78     // Constructor for parameterisation in mas <<  61 
 79     G4FastSimulationManagerProcess(const G4Str <<  62   //------------------------
 80                                    G4ProcessTy <<  63   // Constructor/Destructor
 81                                                <<  64   //------------------------
 82     // -- Contructors for parameterisation att <<  65   
 83     // -- Can also be used for the mass geomet <<  66   G4FastSimulationManagerProcess(const G4String& 
 84     // -- World volume specified by name or po <<  67          processName = 
 85     G4FastSimulationManagerProcess(const G4Str <<  68          "G4FastSimulationManagerProcess",
 86                                    G4ProcessTy <<  69          G4ProcessType
 87     G4FastSimulationManagerProcess(const G4Str <<  70          theType = fParameterisation);
 88                                    G4ProcessTy <<  71   virtual ~G4FastSimulationManagerProcess();
 89                                                <<  72   
 90     ~G4FastSimulationManagerProcess() override <<  73   //--------------------------------------------------------------
 91                                                <<  74   //     Process interface
 92     // -----------------------                 <<  75   //--------------------------------------------------------------
 93     //   User access methods:                  <<  76 
 94     // -----------------------                 <<  77   void StartTracking();
 95     G4VPhysicalVolume* GetWorldVolume() const  <<  78   
 96                                                <<  79   //---------------------------------------------------
 97     // -- Set new world volume to the process  <<  80   // GetPhysicalInteractionLength() and DoIt() methods:
 98     void SetWorldVolume(G4String);             <<  81   //---------------------------------------------------
 99     void SetWorldVolume(G4VPhysicalVolume*);   <<  82   
100                                                <<  83   G4double PostStepGetPhysicalInteractionLength(const G4Track& track,
101     // --------------------------------------- <<  84             G4double   previousStepSize,
102     //                      Process interface  <<  85             G4ForceCondition* condition);
103     // --------------------------------------- <<  86   
104                                                <<  87   G4VParticleChange* PostStepDoIt(const G4Track& ,const G4Step& );
105     // -- Start/End tracking:                  <<  88 
106     void StartTracking(G4Track*) override;     <<  89   //------------------------------------------------------------------------
107     void EndTracking() override;               <<  90   // GetPhysicalInteractionLength() and DoIt() methods for AtRest particles:
108                                                <<  91   //------------------------------------------------------------------------
109     // -- PostStep methods:                    <<  92   
110     G4double PostStepGetPhysicalInteractionLen <<  93   G4double AtRestGetPhysicalInteractionLength(
111                                                <<  94                 const G4Track& ,
112                                                <<  95                 G4ForceCondition* 
113     G4VParticleChange* PostStepDoIt(const G4Tr <<  96                 );
114                                                <<  97 
115     // -- Responsible for limiting the step on <<  98   G4VParticleChange* AtRestDoIt(
116     G4double AlongStepGetPhysicalInteractionLe <<  99              const G4Track& ,
117                                                << 100              const G4Step&
118                                                << 101              );
119                                                << 102 
120     G4VParticleChange* AlongStepDoIt(const G4T << 103 
121                                                << 104   // -- no operation in AlongStepDoIt --
122     // -- AtRest methods (still there after ma << 105   G4double AlongStepGetPhysicalInteractionLength(
123     G4double AtRestGetPhysicalInteractionLengt << 106              const G4Track&,
124                                                << 107              G4double  ,
125     G4VParticleChange* AtRestDoIt(const G4Trac << 108              G4double  ,
126                                                << 109              G4double&,
127     // -- debug:                               << 110              G4GPILSelection*
128     [[deprecated("obsolete: will be remove in  << 111              );
129                                                << 112   G4VParticleChange* AlongStepDoIt(
130   private:                                     << 113           const G4Track& ,
131     //-- would be better to my taste to have " << 114           const G4Step& 
132     // at compilation                          << 115           );
133     G4VPhysicalVolume* fWorldVolume;           << 116 
134                                                << 117 
135     G4bool fIsTrackingTime;                    << 118 private:
136     G4bool fIsFirstStep;                       << 119   // When trigged, the *fFastSimulationManager holds
137     G4Navigator* fGhostNavigator;              << 120   // the pointer used to call the DoIt() method.
138     G4int fGhostNavigatorIndex;                << 121   G4FastSimulationManager* fFastSimulationManager;
139     G4bool fIsGhostGeometry;                   << 122   G4bool                   fFastSimulationTrigger;
140     G4double fGhostSafety;                     << 123   // this G4VParticleChange is used only when the safety limites the Step.
141     G4FieldTrack fFieldTrack;                  << 124   G4VParticleChange aDummyParticleChange;
142                                                << 125   G4ParticleChange xParticleChange;
143     G4FastSimulationManager* fFastSimulationMa << 126 
144     G4bool fFastSimulationTrigger;             << 127   // Flags that the track is starting
145     G4VParticleChange fDummyParticleChange;    << 128   G4bool fStartTracking;
146     G4PathFinder* fPathFinder;                 << 129 
147     G4TransportationManager* fTransportationMa << 130   // -------------------------------
                                                   >> 131   // Navigation in the Ghost World:
                                                   >> 132   // -------------------------------
                                                   >> 133   // Current parallel "ghost" world, related Navigator
                                                   >> 134   // and touchable history:
                                                   >> 135   G4VPhysicalVolume*   fGhostWorld;
                                                   >> 136   G4Navigator          fGhostNavigator;
                                                   >> 137   G4TouchableHistory*  fGhostTouchable;
                                                   >> 138   G4bool               fUpdateGhostTouchable;
                                                   >> 139   G4bool               fOutOfGhostWorld;
                                                   >> 140   // Isotropic safety value to the next ghost volume
                                                   >> 141   // and allowed Step length:
                                                   >> 142   G4double             fGhostSafety,
                                                   >> 143                        fGhostStepLength;
                                                   >> 144   // Navigation with field:
                                                   >> 145   G4PropagatorInField* fGhostFieldPropagator;
                                                   >> 146   G4double             fParticleCharge;
                                                   >> 147   G4bool               fFieldExertsForce;
                                                   >> 148 
                                                   >> 149   // Tracking Navigation used in PostStep, in case of mag-field:
                                                   >> 150   G4Navigator          fTrackingNavigator;
                                                   >> 151   G4TouchableHistory   fTrackingHistory;
                                                   >> 152 
                                                   >> 153   // ******************************************************
                                                   >> 154   // ******************************************************
                                                   >> 155   //
                                                   >> 156   //  For TESTS:
                                                   >> 157   //
                                                   >> 158   // ******************************************************
                                                   >> 159   // ******************************************************
                                                   >> 160 public:
                                                   >> 161   G4double GetPreSafety() {return fPreSafety;}
                                                   >> 162   G4double GetPreLinearSafety() {return fPreLinearSafety;}
                                                   >> 163   G4double GetSafety() {return fGhostSafety;}
                                                   >> 164   G4double GetLinearSafety() {return fGhostStepLength;}
                                                   >> 165   void Verbose() const;
                                                   >> 166 private:
                                                   >> 167   G4double fPreSafety, fPreLinearSafety;
148 };                                                168 };
149                                                   169 
150 #endif                                            170 #endif
151                                                   171