| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id: G4ITSafetyHelper.hh 72309 2013-07-15 15:52:17Z gcosmo $
27 // 28 //
28 // 29 //
29 // class G4ITSafetyHelper 30 // class G4ITSafetyHelper
30 // 31 //
31 // Class description: 32 // Class description:
32 // 33 //
33 // G4ITSafetyHelper is a duplicated version of 34 // G4ITSafetyHelper is a duplicated version of G4SafetyHelper
34 // This class is a helper for physics processe 35 // This class is a helper for physics processes which require
35 // knowledge of the safety, and the step size 36 // knowledge of the safety, and the step size for the 'mass' geometry
36 37
37 // First version: J. Apostolakis, July 5th, 38 // First version: J. Apostolakis, July 5th, 2006
38 // Modified: 39 // Modified:
39 // 10.04.07 V.Ivanchenko Use unique G4ITSafe 40 // 10.04.07 V.Ivanchenko Use unique G4ITSafetyHelper
40 // ------------------------------------------- 41 // --------------------------------------------------------------------
41 42
42 #ifndef G4ITSAFETYHELPER_HH 43 #ifndef G4ITSAFETYHELPER_HH
43 #define G4ITSAFETYHELPER_HH 1 44 #define G4ITSAFETYHELPER_HH 1
44 45
45 #include <vector> 46 #include <vector>
46 47
47 #include "G4Types.hh" 48 #include "G4Types.hh"
48 #include "G4ThreeVector.hh" 49 #include "G4ThreeVector.hh"
49 #include "G4ITNavigator.hh" 50 #include "G4ITNavigator.hh"
50 #include "G4TrackState.hh" 51 #include "G4TrackState.hh"
51 52
52 class G4PathFinder; 53 class G4PathFinder;
53 54
54 class G4ITSafetyHelper : public G4TrackStateDe 55 class G4ITSafetyHelper : public G4TrackStateDependent<G4ITSafetyHelper>
55 { 56 {
56 public: 57 public:
57 // with description 58 // with description
58 G4ITSafetyHelper(); 59 G4ITSafetyHelper();
59 ~G4ITSafetyHelper() override; << 60 ~G4ITSafetyHelper();
60 // 61 //
61 // Constructor and destructor 62 // Constructor and destructor
62 63
63 G4double CheckNextStep(const G4ThreeVector& 64 G4double CheckNextStep(const G4ThreeVector& position,
64 const G4ThreeVector& 65 const G4ThreeVector& direction,
65 const G4double curren 66 const G4double currentMaxStep,
66 G4double& newSafety); 67 G4double& newSafety);
67 // 68 //
68 // Return linear step for mass geometry 69 // Return linear step for mass geometry
69 70
70 G4double ComputeSafety(const G4ThreeVector& << 71 G4double ComputeSafety(const G4ThreeVector& pGlobalPoint, G4double maxRadius =
71 G4double maxRadius = << 72 DBL_MAX); // Radius of interest
72 // 73 //
73 // Return safety for all geometries. 74 // Return safety for all geometries.
74 // 75 //
75 // The 2nd argument is the radius of your i 76 // The 2nd argument is the radius of your interest (e.g. maximum displacement )
76 // Giving this you can reduce the average 77 // Giving this you can reduce the average computational cost.
77 // If the second argument is not given, thi 78 // If the second argument is not given, this is the real isotropic safety
78 79
79 void Locate(const G4ThreeVector& pGlobalPoin 80 void Locate(const G4ThreeVector& pGlobalPoint,
80 const G4ThreeVector& direction); << 81 const G4ThreeVector& direction);
81 // 82 //
82 // Locate the point for all geometries 83 // Locate the point for all geometries
83 84
84 void ReLocateWithinVolume(const G4ThreeVecto 85 void ReLocateWithinVolume(const G4ThreeVector& pGlobalPoint );
85 // 86 //
86 // Relocate the point in the volume of inter 87 // Relocate the point in the volume of interest
87 88
88 inline void EnableParallelNavigation(G4bool 89 inline void EnableParallelNavigation(G4bool parallel);
89 // 90 //
90 // To have parallel worlds considered, must 91 // To have parallel worlds considered, must be true.
91 // Alternative is to use single (mass) Navi 92 // Alternative is to use single (mass) Navigator directly
92 93
93 void InitialiseNavigator(); 94 void InitialiseNavigator();
94 // 95 //
95 // Check for new navigator for tracking, and 96 // Check for new navigator for tracking, and reinitialise pointer
96 97
97 G4int SetVerboseLevel( G4int lev ) 98 G4int SetVerboseLevel( G4int lev )
98 { G4int oldlv= fVerbose; fVerbose= lev; retu 99 { G4int oldlv= fVerbose; fVerbose= lev; return oldlv;}
99 100
100 inline G4VPhysicalVolume* GetWorldVolume(); 101 inline G4VPhysicalVolume* GetWorldVolume();
101 inline void SetCurrentSafety(G4double val, c 102 inline void SetCurrentSafety(G4double val, const G4ThreeVector& pos);
102 103
103 public: // without description 104 public: // without description
104 105
105 void InitialiseHelper(); 106 void InitialiseHelper();
106 107
107 private: 108 private:
108 109
109 G4PathFinder* fpPathFinder; 110 G4PathFinder* fpPathFinder;
110 G4ITNavigator* fpMassNavigator; 111 G4ITNavigator* fpMassNavigator;
111 G4int fMassNavigatorId; 112 G4int fMassNavigatorId;
112 113
113 G4bool fUseParallelGeometries{false}; << 114 G4bool fUseParallelGeometries;
114 // Flag whether to use PathFinder or single 115 // Flag whether to use PathFinder or single (mass) Navigator directly
115 G4bool fFirstCall{true}; << 116 G4bool fFirstCall;
116 // Flag of first call 117 // Flag of first call
117 G4int fVerbose{0}; << 118 G4int fVerbose;
118 // Whether to print warning in case of move 119 // Whether to print warning in case of move outside safety
119 120
120 public: 121 public:
121 // State used during tracking -- for optimis 122 // State used during tracking -- for optimisation
122 class State 123 class State
123 { 124 {
124 friend class G4ITSafetyHelper; 125 friend class G4ITSafetyHelper;
125 G4ThreeVector fLastSafetyPosition; 126 G4ThreeVector fLastSafetyPosition;
126 G4double fLastSafety{0.0}; << 127 G4double fLastSafety;
127 128
128 public: 129 public:
129 State() : 130 State() :
130 fLastSafetyPosition(0.0,0.0,0.0) << 131 fLastSafetyPosition(0.0,0.0,0.0),
>> 132 fLastSafety(0.0)
131 {} 133 {}
132 134
133 virtual ~State() 135 virtual ~State()
134 = default; << 136 {}
135 }; 137 };
136 138
137 // const G4double fRecomputeFactor; 139 // const G4double fRecomputeFactor;
138 // parameter for further optimisation: 140 // parameter for further optimisation:
139 // if ( move < fact*safety ) do fast recomp 141 // if ( move < fact*safety ) do fast recomputation of safety
140 // End State (tracking) 142 // End State (tracking)
141 }; 143 };
142 144
143 RegisterTrackState(G4ITSafetyHelper, State) << 145 RegisterTrackState(G4ITSafetyHelper, G4ITSafetyHelper::State)
144 146
145 // Inline definitions 147 // Inline definitions
146 148
147 inline 149 inline
148 void G4ITSafetyHelper::EnableParallelNavigatio 150 void G4ITSafetyHelper::EnableParallelNavigation(G4bool parallel)
149 { 151 {
150 fUseParallelGeometries = parallel; 152 fUseParallelGeometries = parallel;
151 } 153 }
152 154
153 inline G4VPhysicalVolume* G4ITSafetyHelper::Ge 155 inline G4VPhysicalVolume* G4ITSafetyHelper::GetWorldVolume()
154 { 156 {
155 return fpMassNavigator->GetWorldVolume(); 157 return fpMassNavigator->GetWorldVolume();
156 } 158 }
157 159
158 inline 160 inline
159 void G4ITSafetyHelper::SetCurrentSafety(G4doub 161 void G4ITSafetyHelper::SetCurrentSafety(G4double val, const G4ThreeVector& pos)
160 { 162 {
161 fpTrackState->fLastSafety = val; 163 fpTrackState->fLastSafety = val;
162 fpTrackState->fLastSafetyPosition = pos; 164 fpTrackState->fLastSafetyPosition = pos;
163 } 165 }
164 166
165 #endif 167 #endif
166 168