Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/navigation/include/G4VIntersectionLocator.icc

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 /geometry/navigation/include/G4VIntersectionLocator.icc (Version 11.3.0) and /geometry/navigation/include/G4VIntersectionLocator.icc (Version 10.5)


  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 //
                                                   >>  27 //
                                                   >>  28 //
 26 // Class G4VIntersectionLocator inline methods     29 // Class G4VIntersectionLocator inline methods
 27 //                                                 30 //
 28 // 27.10.07 - John Apostolakis, Tatiana Nikiti     31 // 27.10.07 - John Apostolakis, Tatiana Nikitina
 29 // -------------------------------------------     32 // ---------------------------------------------------------------------------
 30                                                    33 
 31 inline G4double G4VIntersectionLocator::GetDel     34 inline G4double G4VIntersectionLocator::GetDeltaIntersectionFor()
 32 {                                                  35 {
 33   return fiDeltaIntersection;                      36   return fiDeltaIntersection;
 34 }                                                  37 } 
 35                                                    38 
 36 inline G4double G4VIntersectionLocator::GetEps     39 inline G4double G4VIntersectionLocator::GetEpsilonStepFor()
 37 {                                                  40 {
 38   return fiEpsilonStep;                            41   return fiEpsilonStep;
 39 }                                                  42 }
 40                                                    43 
 41 inline G4Navigator* G4VIntersectionLocator::Ge     44 inline G4Navigator* G4VIntersectionLocator::GetNavigatorFor()
 42 {                                                  45 {
 43   return fiNavigator;                              46   return fiNavigator;
 44 }                                                  47 }
 45                                                    48 
 46 inline G4ChordFinder* G4VIntersectionLocator::     49 inline G4ChordFinder* G4VIntersectionLocator::GetChordFinderFor()
 47 {                                                  50 {
 48   return fiChordFinder;                            51   return fiChordFinder;
 49 }                                                  52 }
 50                                                    53 
 51 inline G4int G4VIntersectionLocator::GetVerbos     54 inline G4int G4VIntersectionLocator::GetVerboseFor()
 52 {                                                  55 {
 53   return fVerboseLevel;                            56   return fVerboseLevel;
 54 }                                                  57 }
 55                                                    58 
 56 inline G4bool G4VIntersectionLocator::GetAdjus     59 inline G4bool G4VIntersectionLocator::GetAdjustementOfFoundIntersection()
 57 {                                                  60 {
 58   return fUseNormalCorrection;                     61   return fUseNormalCorrection;
 59 }                                                  62 }
 60                                                    63 
 61 inline void G4VIntersectionLocator::               64 inline void G4VIntersectionLocator::
 62 AddAdjustementOfFoundIntersection(G4bool UseCo     65 AddAdjustementOfFoundIntersection(G4bool UseCorrection )
 63 {                                                  66 {
 64   fUseNormalCorrection = UseCorrection;        <<  67   fUseNormalCorrection=UseCorrection;
 65 }                                                  68 }
 66                                                    69 
 67 inline void G4VIntersectionLocator::SetEpsilon     70 inline void G4VIntersectionLocator::SetEpsilonStepFor( G4double EpsilonStep )
 68 {                                                  71 {
 69   fiEpsilonStep = EpsilonStep;                 <<  72   fiEpsilonStep=EpsilonStep;
 70 }                                                  73 }
 71                                                    74 
 72 inline void G4VIntersectionLocator::               75 inline void G4VIntersectionLocator::
 73 SetDeltaIntersectionFor( G4double deltaInterse     76 SetDeltaIntersectionFor( G4double deltaIntersection )
 74 {                                                  77 {
 75   fiDeltaIntersection = deltaIntersection;     <<  78   fiDeltaIntersection=deltaIntersection;
 76 }                                                  79 }
 77                                                    80 
 78 inline void G4VIntersectionLocator::SetNavigat <<  81 inline void G4VIntersectionLocator::SetNavigatorFor( G4Navigator *fNavigator )
 79 {                                                  82 {
 80   fiNavigator = fNavigator;                    <<  83   fiNavigator=fNavigator;
 81 }                                                  84 }
 82                                                    85 
 83 inline void G4VIntersectionLocator::SetChordFi <<  86 inline void G4VIntersectionLocator::SetChordFinderFor(G4ChordFinder *fCFinder )
 84 {                                                  87 {
 85   fiChordFinder = fCFinder;                    <<  88   fiChordFinder=fCFinder;
 86 }                                                  89 }
 87                                                    90 
 88 inline void G4VIntersectionLocator::SetSafetyP     91 inline void G4VIntersectionLocator::SetSafetyParametersFor(G4bool UseSafety )
 89 {                                                  92 {
 90   fiUseSafety = UseSafety;                     <<  93   fiUseSafety=UseSafety;
 91 }                                                  94 }
 92                                                    95 
 93 inline void G4VIntersectionLocator::SetVerbose     96 inline void G4VIntersectionLocator::SetVerboseFor(G4int fVerbose)
 94 {                                                  97 {
 95   fVerboseLevel = fVerbose;                    <<  98   fVerboseLevel=fVerbose;
 96 }                                                  99 }
 97                                                   100 
 98 inline G4bool                                     101 inline G4bool
 99 G4VIntersectionLocator::IntersectChord( const     102 G4VIntersectionLocator::IntersectChord( const G4ThreeVector&  StartPointA,
100                                         const     103                                         const G4ThreeVector&  EndPointB,
101                                         G4doub << 104                                         G4double      &NewSafety,
102                                         G4doub << 105                                         G4double      &PreviousSafety,
103                                         G4Thre << 106                                         G4ThreeVector &PreviousSftOrigin,
104                                         G4doub << 107                                         G4double      &LinearStepLength,
105                                         G4Thre << 108                                         G4ThreeVector &IntersectionPoint,
106                                         G4bool << 109                                         G4bool        *ptrCalledNavigator )
107 {                                                 110 {
108   G4bool CalledNavigator = false;                 111   G4bool CalledNavigator = false; 
109                                                   112 
110   // Calculate the direction and length of the    113   // Calculate the direction and length of the chord AB
111                                                   114 
112   G4ThreeVector  ChordAB_Vector = EndPointB -     115   G4ThreeVector  ChordAB_Vector = EndPointB - StartPointA;
113   G4double       ChordAB_Length = ChordAB_Vect    116   G4double       ChordAB_Length = ChordAB_Vector.mag();  // Magnitude (norm)
114   G4ThreeVector  ChordAB_Dir = ChordAB_Vector. << 117   G4ThreeVector  ChordAB_Dir =    ChordAB_Vector.unit();
115   G4bool intersects;                              118   G4bool intersects;
116   G4ThreeVector OriginShift = StartPointA - Pr << 119   G4ThreeVector OriginShift = StartPointA -  PreviousSftOrigin ;
117   G4double MagSqShift  = OriginShift.mag2() ;  << 120   G4double      MagSqShift  = OriginShift.mag2() ;
118   G4double currentSafety;                      << 121   G4double      currentSafety;
119                                                   122 
120   if( MagSqShift >= sqr(PreviousSafety) )         123   if( MagSqShift >= sqr(PreviousSafety) )
121   {                                               124   {
122     currentSafety = 0.0 ;                         125     currentSafety = 0.0 ;
123   }                                               126   }
124   else                                            127   else
125   {                                               128   {
126     currentSafety = PreviousSafety - std::sqrt    129     currentSafety = PreviousSafety - std::sqrt(MagSqShift) ;
127   }                                               130   }
128                                                   131 
129   if( fiUseSafety && (ChordAB_Length <= curren    132   if( fiUseSafety && (ChordAB_Length <= currentSafety) )
130   {                                               133   {
131     // The Step is guaranteed to be taken         134     // The Step is guaranteed to be taken
132                                                   135 
133     LinearStepLength = ChordAB_Length;            136     LinearStepLength = ChordAB_Length;
134     intersects = false;                           137     intersects = false;
135     NewSafety = currentSafety;                 << 138     NewSafety= currentSafety;
136     CalledNavigator = false;                   << 139     CalledNavigator= false;
                                                   >> 140     // G4cout << " IntersectChord> Step 'guaranteed' taken:  safety= " << currentSafety << " chordAB-len= " << ChordAB_Length << G4endl;
137   }                                               141   }
138   else                                            142   else
139   {                                               143   {
                                                   >> 144     // G4cout << " IntersectChord> Step asking Navigator:    safety= " << currentSafety << " chordAB-len= " << ChordAB_Length << G4endl;
                                                   >> 145     
140     // Check whether any volumes are encounter    146     // Check whether any volumes are encountered by the chord AB
141                                                   147 
142     LinearStepLength = GetNavigatorFor()->Comp    148     LinearStepLength = GetNavigatorFor()->ComputeStep( StartPointA,
143                                  ChordAB_Dir,     149                                  ChordAB_Dir, ChordAB_Length, NewSafety );
144     intersects = (LinearStepLength <= ChordAB_    150     intersects = (LinearStepLength <= ChordAB_Length); 
145        // G4Navigator contracts to return k_in    151        // G4Navigator contracts to return k_infinity if len==asked
146        // and it did not find a surface bounda    152        // and it did not find a surface boundary at that length
147                                                   153     
                                                   >> 154     // G4cout << "G4VIntersectionLocator:  intersect= " << intersects
                                                   >> 155     //       << " step= " << LinearStepLength << " Chord length= " << ChordAB_Length;
                                                   >> 156 
148     LinearStepLength = std::min( LinearStepLen    157     LinearStepLength = std::min( LinearStepLength, ChordAB_Length);
149     CalledNavigator = true;                       158     CalledNavigator = true; 
150                                                   159 
151     // Save the last calculated safety!           160     // Save the last calculated safety!
152                                                   161 
153     PreviousSftOrigin = StartPointA;              162     PreviousSftOrigin = StartPointA;
154     PreviousSafety    = NewSafety;                163     PreviousSafety    = NewSafety;
155                                                   164 
156     if( intersects )                              165     if( intersects )
157     {                                             166     {
158        // Intersection Point of chord AB and e    167        // Intersection Point of chord AB and either volume A's surface 
159        //                                or a     168        //                                or a daughter volume's surface ..
160        IntersectionPoint = StartPointA + Linea    169        IntersectionPoint = StartPointA + LinearStepLength * ChordAB_Dir;
161     }                                             170     }
162   }                                               171   }
163   if( ptrCalledNavigator != nullptr )          << 172   if( ptrCalledNavigator )
164   {                                               173   { 
165     *ptrCalledNavigator = CalledNavigator;        174     *ptrCalledNavigator = CalledNavigator; 
166   }                                               175   }
167                                                   176 
168   return intersects;                              177   return intersects;
169 }                                                 178 }
170                                                   179