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