Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/include/G4FastTrack.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/G4FastTrack.hh (Version 11.3.0) and /processes/parameterisation/include/G4FastTrack.hh (Version 7.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4FastTrack.hh,v 1.5 2001/07/11 10:08:24 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-07-00-cand-01 $
 27 //                                                 26 //
                                                   >>  27 // $Id:
 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 
 41 #ifndef G4FastTrack_h                              42 #ifndef G4FastTrack_h
 42 #define G4FastTrack_h                              43 #define G4FastTrack_h
 43                                                    44 
 44 #include "G4AffineTransform.hh"                <<  45 #include "G4VSolid.hh"
 45 #include "G4LogicalVolume.hh"                      46 #include "G4LogicalVolume.hh"
 46 #include "G4Navigator.hh"                      <<  47 #include "G4AffineTransform.hh"
 47 #include "G4Region.hh"                         << 
 48 #include "G4Track.hh"                              48 #include "G4Track.hh"
 49 #include "G4VSolid.hh"                         <<  49 #include "G4Navigator.hh"
 50                                                    50 
 51 //---------------------------                      51 //---------------------------
 52 // For possible future needs:                      52 // For possible future needs:
 53 //---------------------------                      53 //---------------------------
 54 using G4Envelope = G4Region;                   <<  54 typedef G4LogicalVolume G4Envelope;
                                                   >>  55 
 55                                                    56 
 56 //-------------------------------------------      57 //-------------------------------------------
 57 //                                                 58 //
 58 //        G4FastTrack class                        59 //        G4FastTrack class
 59 //                                                 60 //
 60 //-------------------------------------------      61 //-------------------------------------------
 61                                                    62 
 62 // Class Description:                              63 // Class Description:
 63 //  The G4FastTrack provides you access to the <<  64 //  The G4FastTrack provides you access to the current G4Track, gives simple access to envelope 
 64 // gives simple access to envelope related fea <<  65 //  related features (G4LogicalVolume, G4VSolid, G4AffineTransform references between the global 
 65 // G4LogicalVolume, G4VSolid, G4AffineTransfor <<  66 //  and the envelope local coordinates systems) and simple access to the position, momentum 
 66 // the global and the envelope local coordinat <<  67 //  expressed in the envelope coordinate system. Using those quantities and the G4VSolid methods, 
 67 // simple access to the position, momentum exp <<  68 //  you can for example easily check how far you are from the envelope boundary. 
 68 // envelope coordinate system. Using those qua << 
 69 // G4VSolid methods, you can for example easil << 
 70 // are from the envelope boundary.             << 
 71 //                                                 69 //
 72                                                    70 
                                                   >>  71 
 73 class G4FastTrack                                  72 class G4FastTrack
 74 {                                                  73 {
 75   public:  // without description              <<  74 public: // without description
 76     //------------------------                 <<  75   //------------------------
 77     // Constructor/Destructor                  <<  76   // Constructor/Destructor
 78     //------------------------                 <<  77   //------------------------
 79     // Only one Constructor. By default the en <<  78   // Only one Constructor. By default the envelope can
 80     // be placed n-Times. If the user is sure  <<  79   // be placed n-Times. If the user is sure that it'll be 
 81     // placed just one time, the IsUnique flag <<  80   // placed just one time, the IsUnique flag should be set 
 82     // TRUE to avoid the G4AffineTransform re- <<  81   // TRUE to avoid the G4AffineTransform re-calculations each 
 83     // time we reach the envelope.             <<  82   // time we reach the envelope.
 84     G4FastTrack(G4Envelope* anEnvelope, G4bool <<  83   G4FastTrack(G4Envelope *anEnvelope,
 85     ~G4FastTrack() = default;                  <<  84         G4bool IsUnique);
 86                                                <<  85   ~G4FastTrack();
 87     //---------------------------------------- <<  86 
 88     // The fast simulation manager uses the Se <<  87   //------------------------------------------------------------
 89     // method to setup the current G4FastTrack <<  88   // The fast simulation manager uses the SetCurrentTrack
 90     //---------------------------------------- <<  89   // method to setup the current G4FastTrack object 
 91     void SetCurrentTrack(const G4Track&, const <<  90   //------------------------------------------------------------
 92                                                <<  91   void SetCurrentTrack(const G4Track&, const G4Navigator* a = 0);
 93     //---------------------------------------- <<  92 
 94     // The fast simulation manager uses the On <<  93   //------------------------------------------------------------
 95     // method to test if the particle is leavi <<  94   // The fast simulation manager uses the OnTheBoundaryButExiting
 96     //---------------------------------------- <<  95   // method to test if the particle is leaving the envelope.
 97     G4bool OnTheBoundaryButExiting() const;    <<  96   //------------------------------------------------------------
 98                                                <<  97   G4bool OnTheBoundaryButExiting() const;
 99     //----------------------------------       <<  98 
100     // Informations useful to the user :       <<  99   //----------------------------------
101     // General public get functions.           << 100   // Informations useful to the user :
102     //----------------------------------       << 101   // General public get functions.
103                                                << 102   //----------------------------------
104     // Returns the current G4Track.            << 103 
105     const G4Track* GetPrimaryTrack() const;    << 104 public: // with Description
106                                                << 105 
107     // Returns the Envelope G4Region pointer.  << 106   const G4Track* GetPrimaryTrack() const;
108     G4Envelope* GetEnvelope() const;           << 107   // Returns the current G4Track.
109                                                << 108 
110     // Returns the Envelope G4LogicalVolume po << 109   G4Envelope* GetEnvelope() const;
111     G4LogicalVolume* GetEnvelopeLogicalVolume( << 110   // Returns the Envelope G4LogicalVolume pointer.
112                                                << 111 
113     // Returns the Envelope G4VPhysicalVolume  << 112   G4VPhysicalVolume* GetEnvelopePhysicalVolume() const;
114     G4VPhysicalVolume* GetEnvelopePhysicalVolu << 113   // Returns the Envelope G4VPhysicalVolume pointer.
115                                                << 114 
116     // Returns the Envelope G4VSolid pointer.  << 115   G4VSolid* GetEnvelopeSolid() const;
117     G4VSolid* GetEnvelopeSolid() const;        << 116   // Returns the Envelope G4VSolid pointer.
118                                                << 117 
119     //-----------------------------------      << 118   //-----------------------------------
120     // Primary track informations in the       << 119   // Primary track informations in the
121     // Envelope coordinate system.             << 120   // Envelope coordinate system.
122     //-----------------------------------      << 121   //-----------------------------------
123                                                << 122 
124     // Returns the particle position in envelo << 123   G4ThreeVector GetPrimaryTrackLocalPosition() const;
125     G4ThreeVector GetPrimaryTrackLocalPosition << 124   // Returns the particle position in envelope coordinates.
126                                                << 125 
127     // Returns the particle momentum in envelo << 126   G4ThreeVector GetPrimaryTrackLocalMomentum() const;
128     G4ThreeVector GetPrimaryTrackLocalMomentum << 127   // Returns the particle momentum in envelope coordinates.
129                                                << 128 
130     // Returns the particle direction in envel << 129   G4ThreeVector GetPrimaryTrackLocalDirection() const;
131     G4ThreeVector GetPrimaryTrackLocalDirectio << 130   // Returns the particle direction in envelope coordinates.
132                                                << 131 
133     // Returns the particle polarization in en << 132   G4ThreeVector GetPrimaryTrackLocalPolarization() const;
134     G4ThreeVector GetPrimaryTrackLocalPolariza << 133   // Returns the particle polarization in envelope coordinates.
135                                                << 134   
136     //------------------------------------     << 135   //------------------------------------
137     // 3D transformation of the envelope:      << 136   // 3D transformation of the envelope:
138     //------------------------------------     << 137   //------------------------------------
139                                                << 138   // Global -> Local
140     // Returns the envelope Global -> Local G4 << 139 
141     const G4AffineTransform* GetAffineTransfor << 140   const G4AffineTransform* GetAffineTransformation() const;  
142                                                << 141   // Returns the envelope Global -> Local G4AffineTransform
143     // Returns the envelope Local -> Global G4 << 142 
144     const G4AffineTransform* GetInverseAffineT << 143   // Local -> Global
145                                                << 144   const G4AffineTransform* GetInverseAffineTransformation() const; 
146   private:                                     << 145   // Returns the envelope Local -> Global G4AffineTransform
147     //-----------------                        << 146 
148     // Private members                         << 147   //-----------------
149     //-----------------                        << 148   // Private members
150     // Current G4Track pointer                 << 149   //-----------------
151     const G4Track* fTrack{nullptr};            << 150 private:
152                                                << 151 
153     //---------------------------------------- << 152   // Current G4Track pointer
154     // Records the Affine/InverseAffine transf << 153   const G4Track* fTrack;
155     // of the envelope.                        << 154 
156     //---------------------------------------- << 155   //------------------------------------------------
157     void FRecordsAffineTransformation(const G4 << 156   // Records the Affine/InverseAffine transformation
158     G4bool fAffineTransformationDefined{false} << 157   // of the envelope.
159     G4Envelope* fEnvelope;                     << 158   //------------------------------------------------
160     G4bool fIsUnique;                          << 159   void FRecordsAffineTransformation(const G4Navigator*);
161     G4LogicalVolume* fEnvelopeLogicalVolume{nu << 160   G4bool fAffineTransformationDefined;
162     G4VPhysicalVolume* fEnvelopePhysicalVolume << 161   G4Envelope* fEnvelope;
163     G4VSolid* fEnvelopeSolid{nullptr};         << 162   G4bool fIsUnique;
164     G4ThreeVector fLocalTrackPosition, fLocalT << 163   G4VPhysicalVolume* fEnvelopePhysicalVolume;
165       fLocalTrackPolarization;                 << 164   G4VSolid* fEnvelopeSolid;
166     G4AffineTransform fAffineTransformation, f << 165   G4ThreeVector fLocalTrackPosition, fLocalTrackMomentum, 
                                                   >> 166     fLocalTrackDirection, fLocalTrackPolarization;
                                                   >> 167   G4AffineTransform fAffineTransformation, fInverseAffineTransformation;
167 };                                                168 };
168                                                   169 
169 // -----------------                           << 170 //*******************************************************************
170 // -- Inline methods                           << 171 //
171 // -----------------                           << 172 //  Inline functions
                                                   >> 173 //
                                                   >> 174 //*******************************************************************
172                                                   175 
173 inline G4Envelope* G4FastTrack::GetEnvelope()     176 inline G4Envelope* G4FastTrack::GetEnvelope() const
174 {                                                 177 {
175   return fEnvelope;                               178   return fEnvelope;
176 }                                                 179 }
177                                                   180 
178 inline G4LogicalVolume* G4FastTrack::GetEnvelo << 
179 {                                              << 
180   return fEnvelopeLogicalVolume;               << 
181 }                                              << 
182                                                << 
183 inline G4VPhysicalVolume* G4FastTrack::GetEnve    181 inline G4VPhysicalVolume* G4FastTrack::GetEnvelopePhysicalVolume() const
184 {                                                 182 {
185   return fEnvelopePhysicalVolume;                 183   return fEnvelopePhysicalVolume;
186 }                                                 184 }
187                                                   185 
188 inline G4VSolid* G4FastTrack::GetEnvelopeSolid    186 inline G4VSolid* G4FastTrack::GetEnvelopeSolid() const
189 {                                                 187 {
190   return fEnvelopeSolid;                          188   return fEnvelopeSolid;
191 }                                                 189 }
192                                                   190 
193 inline const G4Track* G4FastTrack::GetPrimaryT    191 inline const G4Track* G4FastTrack::GetPrimaryTrack() const
194 {                                                 192 {
195   return fTrack;                                  193   return fTrack;
196 }                                                 194 }
197                                                   195 
198 inline G4ThreeVector G4FastTrack::GetPrimaryTr    196 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalPosition() const
199 {                                                 197 {
200   return fLocalTrackPosition;                     198   return fLocalTrackPosition;
201 }                                                 199 }
202                                                   200 
203 inline G4ThreeVector G4FastTrack::GetPrimaryTr    201 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalMomentum() const
204 {                                                 202 {
205   return fLocalTrackMomentum;                     203   return fLocalTrackMomentum;
206 }                                                 204 }
207                                                   205 
208 inline G4ThreeVector G4FastTrack::GetPrimaryTr    206 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalDirection() const
209 {                                                 207 {
210   return fLocalTrackDirection;                    208   return fLocalTrackDirection;
211 }                                                 209 }
212                                                   210 
213 inline G4ThreeVector G4FastTrack::GetPrimaryTr    211 inline G4ThreeVector G4FastTrack::GetPrimaryTrackLocalPolarization() const
214 {                                                 212 {
215   return fLocalTrackPolarization;                 213   return fLocalTrackPolarization;
216 }                                                 214 }
217                                                   215 
218 inline const G4AffineTransform* G4FastTrack::G    216 inline const G4AffineTransform* G4FastTrack::GetAffineTransformation() const
219 {                                                 217 {
220   return &fAffineTransformation;                  218   return &fAffineTransformation;
221 }                                                 219 }
222                                                   220 
223 inline const G4AffineTransform* G4FastTrack::G    221 inline const G4AffineTransform* G4FastTrack::GetInverseAffineTransformation() const
224 {                                                 222 {
225   return &fInverseAffineTransformation;           223   return &fInverseAffineTransformation;
226 }                                                 224 }
227                                                   225 
228 inline G4bool G4FastTrack::OnTheBoundaryButExi << 226 inline G4bool G4FastTrack::OnTheBoundaryButExiting() const 
229 {                                                 227 {
230   // tests if particle are on the boundary and    228   // tests if particle are on the boundary and leaving.
231   return GetEnvelopeSolid()->DistanceToOut(Get << 229   return GetEnvelopeSolid()->
232                                            Get << 230     DistanceToOut(GetPrimaryTrackLocalPosition(),
233          == 0.;                                << 231       GetPrimaryTrackLocalDirection())==0.;
234 }                                                 232 }
235                                                   233 
236 #endif                                            234 #endif
237                                                   235