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