| 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 // 27 //
28 //-------------------------------------------- 28 //---------------------------------------------------------------
29 // 29 //
30 // G4FastTrack.hh 30 // G4FastTrack.hh
31 // 31 //
32 // Description: 32 // Description:
33 // Keeps the current track information and 33 // Keeps the current track information and special features
34 // for Parameterised Simulation Models. 34 // for Parameterised Simulation Models.
35 // 35 //
36 // History: 36 // History:
37 // Oct 97: Verderi && MoraDeFreitas - First 37 // Oct 97: Verderi && MoraDeFreitas - First Implementation.
38 // 38 //
39 //-------------------------------------------- 39 //---------------------------------------------------------------
40 40
41 #ifndef G4FastTrack_h 41 #ifndef G4FastTrack_h
42 #define G4FastTrack_h 42 #define G4FastTrack_h
43 43
44 #include "G4AffineTransform.hh" 44 #include "G4AffineTransform.hh"
45 #include "G4LogicalVolume.hh" 45 #include "G4LogicalVolume.hh"
46 #include "G4Navigator.hh" 46 #include "G4Navigator.hh"
47 #include "G4Region.hh" 47 #include "G4Region.hh"
48 #include "G4Track.hh" 48 #include "G4Track.hh"
49 #include "G4VSolid.hh" 49 #include "G4VSolid.hh"
50 50
51 //--------------------------- 51 //---------------------------
52 // For possible future needs: 52 // For possible future needs:
53 //--------------------------- 53 //---------------------------
54 using G4Envelope = G4Region; 54 using G4Envelope = G4Region;
55 55
56 //------------------------------------------- 56 //-------------------------------------------
57 // 57 //
58 // G4FastTrack class 58 // G4FastTrack class
59 // 59 //
60 //------------------------------------------- 60 //-------------------------------------------
61 61
62 // Class Description: 62 // Class Description:
63 // The G4FastTrack provides you access to the 63 // The G4FastTrack provides you access to the current G4Track,
64 // gives simple access to envelope related fea 64 // gives simple access to envelope related features (G4Region,
65 // G4LogicalVolume, G4VSolid, G4AffineTransfor 65 // G4LogicalVolume, G4VSolid, G4AffineTransform references between
66 // the global and the envelope local coordinat 66 // the global and the envelope local coordinates systems) and
67 // simple access to the position, momentum exp 67 // simple access to the position, momentum expressed in the
68 // envelope coordinate system. Using those qua 68 // envelope coordinate system. Using those quantities and the
69 // G4VSolid methods, you can for example easil 69 // G4VSolid methods, you can for example easily check how far you
70 // are from the envelope boundary. 70 // are from the envelope boundary.
71 // 71 //
72 72
73 class G4FastTrack 73 class G4FastTrack
74 { 74 {
75 public: // without description 75 public: // without description
76 //------------------------ 76 //------------------------
77 // Constructor/Destructor 77 // Constructor/Destructor
78 //------------------------ 78 //------------------------
79 // Only one Constructor. By default the en 79 // Only one Constructor. By default the envelope can
80 // be placed n-Times. If the user is sure 80 // be placed n-Times. If the user is sure that it'll be
81 // placed just one time, the IsUnique flag 81 // placed just one time, the IsUnique flag should be set
82 // TRUE to avoid the G4AffineTransform re- 82 // TRUE to avoid the G4AffineTransform re-calculations each
83 // time we reach the envelope. 83 // time we reach the envelope.
84 G4FastTrack(G4Envelope* anEnvelope, G4bool 84 G4FastTrack(G4Envelope* anEnvelope, G4bool IsUnique);
85 ~G4FastTrack() = default; 85 ~G4FastTrack() = default;
86 86
87 //---------------------------------------- 87 //------------------------------------------------------------
88 // The fast simulation manager uses the Se 88 // The fast simulation manager uses the SetCurrentTrack
89 // method to setup the current G4FastTrack 89 // method to setup the current G4FastTrack object
90 //---------------------------------------- 90 //------------------------------------------------------------
91 void SetCurrentTrack(const G4Track&, const 91 void SetCurrentTrack(const G4Track&, const G4Navigator* a = nullptr);
92 92
93 //---------------------------------------- 93 //------------------------------------------------------------
94 // The fast simulation manager uses the On 94 // The fast simulation manager uses the OnTheBoundaryButExiting
95 // method to test if the particle is leavi 95 // method to test if the particle is leaving the envelope.
96 //---------------------------------------- 96 //------------------------------------------------------------
97 G4bool OnTheBoundaryButExiting() const; 97 G4bool OnTheBoundaryButExiting() const;
98 98
99 //---------------------------------- 99 //----------------------------------
100 // Informations useful to the user : 100 // Informations useful to the user :
101 // General public get functions. 101 // General public get functions.
102 //---------------------------------- 102 //----------------------------------
103 103
104 // Returns the current G4Track. 104 // Returns the current G4Track.
105 const G4Track* GetPrimaryTrack() const; 105 const G4Track* GetPrimaryTrack() const;
106 106
107 // Returns the Envelope G4Region pointer. 107 // Returns the Envelope G4Region pointer.
108 G4Envelope* GetEnvelope() const; 108 G4Envelope* GetEnvelope() const;
109 109
110 // Returns the Envelope G4LogicalVolume po 110 // Returns the Envelope G4LogicalVolume pointer.
111 G4LogicalVolume* GetEnvelopeLogicalVolume( 111 G4LogicalVolume* GetEnvelopeLogicalVolume() const;
112 112
113 // Returns the Envelope G4VPhysicalVolume 113 // Returns the Envelope G4VPhysicalVolume pointer.
114 G4VPhysicalVolume* GetEnvelopePhysicalVolu 114 G4VPhysicalVolume* GetEnvelopePhysicalVolume() const;
115 115
116 // Returns the Envelope G4VSolid pointer. 116 // Returns the Envelope G4VSolid pointer.
117 G4VSolid* GetEnvelopeSolid() const; 117 G4VSolid* GetEnvelopeSolid() const;
118 118
119 //----------------------------------- 119 //-----------------------------------
120 // Primary track informations in the 120 // Primary track informations in the
121 // Envelope coordinate system. 121 // Envelope coordinate system.
122 //----------------------------------- 122 //-----------------------------------
123 123
124 // Returns the particle position in envelo 124 // Returns the particle position in envelope coordinates.
125 G4ThreeVector GetPrimaryTrackLocalPosition 125 G4ThreeVector GetPrimaryTrackLocalPosition() const;
126 126
127 // Returns the particle momentum in envelo 127 // Returns the particle momentum in envelope coordinates.
128 G4ThreeVector GetPrimaryTrackLocalMomentum 128 G4ThreeVector GetPrimaryTrackLocalMomentum() const;
129 129
130 // Returns the particle direction in envel 130 // Returns the particle direction in envelope coordinates.
131 G4ThreeVector GetPrimaryTrackLocalDirectio 131 G4ThreeVector GetPrimaryTrackLocalDirection() const;
132 132
133 // Returns the particle polarization in en 133 // Returns the particle polarization in envelope coordinates.
134 G4ThreeVector GetPrimaryTrackLocalPolariza 134 G4ThreeVector GetPrimaryTrackLocalPolarization() const;
135 135
136 //------------------------------------ 136 //------------------------------------
137 // 3D transformation of the envelope: 137 // 3D transformation of the envelope:
138 //------------------------------------ 138 //------------------------------------
139 139
140 // Returns the envelope Global -> Local G4 140 // Returns the envelope Global -> Local G4AffineTransform
141 const G4AffineTransform* GetAffineTransfor 141 const G4AffineTransform* GetAffineTransformation() const;
142 142
143 // Returns the envelope Local -> Global G4 143 // Returns the envelope Local -> Global G4AffineTransform
144 const G4AffineTransform* GetInverseAffineT 144 const G4AffineTransform* GetInverseAffineTransformation() const;
145 145
146 private: 146 private:
147 //----------------- 147 //-----------------
148 // Private members 148 // Private members
149 //----------------- 149 //-----------------
150 // Current G4Track pointer 150 // Current G4Track pointer
151 const G4Track* fTrack{nullptr}; 151 const G4Track* fTrack{nullptr};
152 152
153 //---------------------------------------- 153 //------------------------------------------------
154 // Records the Affine/InverseAffine transf 154 // Records the Affine/InverseAffine transformation
155 // of the envelope. 155 // of the envelope.
156 //---------------------------------------- 156 //------------------------------------------------
157 void FRecordsAffineTransformation(const G4 157 void FRecordsAffineTransformation(const G4Navigator*);
158 G4bool fAffineTransformationDefined{false} 158 G4bool fAffineTransformationDefined{false};
159 G4Envelope* fEnvelope; 159 G4Envelope* fEnvelope;
160 G4bool fIsUnique; 160 G4bool fIsUnique;
161 G4LogicalVolume* fEnvelopeLogicalVolume{nu 161 G4LogicalVolume* fEnvelopeLogicalVolume{nullptr};
162 G4VPhysicalVolume* fEnvelopePhysicalVolume 162 G4VPhysicalVolume* fEnvelopePhysicalVolume{nullptr};
163 G4VSolid* fEnvelopeSolid{nullptr}; 163 G4VSolid* fEnvelopeSolid{nullptr};
164 G4ThreeVector fLocalTrackPosition, fLocalT 164 G4ThreeVector fLocalTrackPosition, fLocalTrackMomentum, fLocalTrackDirection,
165 fLocalTrackPolarization; 165 fLocalTrackPolarization;
166 G4AffineTransform fAffineTransformation, f 166 G4AffineTransform fAffineTransformation, fInverseAffineTransformation;
167 }; 167 };
168 168
169 // ----------------- 169 // -----------------
170 // -- Inline methods 170 // -- Inline methods
171 // ----------------- 171 // -----------------
172 172
173 inline G4Envelope* G4FastTrack::GetEnvelope() 173 inline G4Envelope* G4FastTrack::GetEnvelope() const
174 { 174 {
175 return fEnvelope; 175 return fEnvelope;
176 } 176 }
177 177
178 inline G4LogicalVolume* G4FastTrack::GetEnvelo 178 inline G4LogicalVolume* G4FastTrack::GetEnvelopeLogicalVolume() const
179 { 179 {
180 return fEnvelopeLogicalVolume; 180 return fEnvelopeLogicalVolume;
181 } 181 }
182 182
183 inline G4VPhysicalVolume* G4FastTrack::GetEnve 183 inline G4VPhysicalVolume* G4FastTrack::GetEnvelopePhysicalVolume() const
184 { 184 {
185 return fEnvelopePhysicalVolume; 185 return fEnvelopePhysicalVolume;
186 } 186 }
187 187
188 inline G4VSolid* G4FastTrack::GetEnvelopeSolid 188 inline G4VSolid* G4FastTrack::GetEnvelopeSolid() const
189 { 189 {
190 return fEnvelopeSolid; 190 return fEnvelopeSolid;
191 } 191 }
192 192
193 inline const G4Track* G4FastTrack::GetPrimaryT 193 inline const G4Track* G4FastTrack::GetPrimaryTrack() const
194 { 194 {
195 return fTrack; 195 return fTrack;
196 } 196 }
197 197
198 inline G4ThreeVector G4FastTrack::GetPrimaryTr 198 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalPosition() const
199 { 199 {
200 return fLocalTrackPosition; 200 return fLocalTrackPosition;
201 } 201 }
202 202
203 inline G4ThreeVector G4FastTrack::GetPrimaryTr 203 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalMomentum() const
204 { 204 {
205 return fLocalTrackMomentum; 205 return fLocalTrackMomentum;
206 } 206 }
207 207
208 inline G4ThreeVector G4FastTrack::GetPrimaryTr 208 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalDirection() const
209 { 209 {
210 return fLocalTrackDirection; 210 return fLocalTrackDirection;
211 } 211 }
212 212
213 inline G4ThreeVector G4FastTrack::GetPrimaryTr 213 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalPolarization() const
214 { 214 {
215 return fLocalTrackPolarization; 215 return fLocalTrackPolarization;
216 } 216 }
217 217
218 inline const G4AffineTransform* G4FastTrack::G 218 inline const G4AffineTransform* G4FastTrack::GetAffineTransformation() const
219 { 219 {
220 return &fAffineTransformation; 220 return &fAffineTransformation;
221 } 221 }
222 222
223 inline const G4AffineTransform* G4FastTrack::G 223 inline const G4AffineTransform* G4FastTrack::GetInverseAffineTransformation() const
224 { 224 {
225 return &fInverseAffineTransformation; 225 return &fInverseAffineTransformation;
226 } 226 }
227 227
228 inline G4bool G4FastTrack::OnTheBoundaryButExi 228 inline G4bool G4FastTrack::OnTheBoundaryButExiting() const
229 { 229 {
230 // tests if particle are on the boundary and 230 // tests if particle are on the boundary and leaving.
231 return GetEnvelopeSolid()->DistanceToOut(Get 231 return GetEnvelopeSolid()->DistanceToOut(GetPrimaryTrackLocalPosition(),
232 Get 232 GetPrimaryTrackLocalDirection())
233 == 0.; 233 == 0.;
234 } 234 }
235 235
236 #endif 236 #endif
237 237