| 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 //
>> 26 //
>> 27 // $Id: G4MultiNavigator.cc,v 1.4 2006/11/14 15:41:56 japost Exp $
>> 28 // GEANT4 tag $ Name: $
25 // 29 //
26 // class G4MultiNavigator Implementation << 30 // class G4PathFinder Implementation
27 // 31 //
28 // Author: John Apostolakis, November 2006 32 // Author: John Apostolakis, November 2006
29 // ------------------------------------------- 33 // --------------------------------------------------------------------
30 34
31 #include <iomanip> <<
32 <<
33 #include "G4MultiNavigator.hh" 35 #include "G4MultiNavigator.hh"
34 36
35 class G4FieldManager; 37 class G4FieldManager;
36 38
37 #include "G4SystemOfUnits.hh" <<
38 #include "G4Navigator.hh" 39 #include "G4Navigator.hh"
39 #include "G4PropagatorInField.hh" 40 #include "G4PropagatorInField.hh"
40 #include "G4TransportationManager.hh" 41 #include "G4TransportationManager.hh"
41 42
42 // ------------------------------------------- << 43 #include <iomanip>
43 44
44 G4MultiNavigator::G4MultiNavigator() << 45 // ********************************************************************
45 { << 46 // Constructor
46 G4ThreeVector Big3Vector( kInfinity, kInfini << 47 // ********************************************************************
47 fLastLocatedPosition = Big3Vector; << 48 //
48 fSafetyLocation = Big3Vector; << 49 G4MultiNavigator::G4MultiNavigator()
49 fPreStepLocation = Big3Vector; << 50 // : fpActiveNavigators()
50 << 51 : G4Navigator(),
51 for(auto num=0; num< fMaxNav; ++num ) << 52 fVerboseLevel(1)
52 { << 53 {
53 fpNavigator[num] = nullptr; << 54 fNoActiveNavigators= 0;
54 fLimitTruth[num] = false; << 55 G4ThreeVector Big3Vector( DBL_MAX, DBL_MAX, DBL_MAX );
55 fLimitedStep[num] = kUndefLimited; << 56 fLastLocatedPosition= Big3Vector;
56 fCurrentStepSize[num] = fNewSafety[num] = << 57 fSafetyLocation= Big3Vector;
57 fLocatedVolume[num] = nullptr; << 58 fPreStepLocation= Big3Vector;
58 } << 59
59 << 60 fMinSafety_PreStepPt= -1.0;
60 pTransportManager= G4TransportationManager:: << 61 fMinSafety_atSafLocation= -1.0;
61 << 62 fMinSafety= -DBL_MAX;
62 G4Navigator* massNav= pTransportManager->Get << 63 fMinStep= -DBL_MAX;
63 if( massNav != nullptr ) << 64 // fNewTrack= false;
64 { << 65
65 G4VPhysicalVolume* pWorld= massNav->GetWor << 66 G4int num;
66 if( pWorld != nullptr ) << 67 for( num=0; num<= fMaxNav; ++num ) {
67 { << 68 fpNavigator[num] = 0;
68 SetWorldVolume( pWorld ); << 69 fLimitTruth[num] = false;
69 fLastMassWorld = pWorld; << 70 fLimitedStep[num] = kUndefLimited;
70 } << 71 fCurrentStepSize[num] = -1.0;
71 } << 72 fLocatedVolume[num] = 0;
72 } << 73 }
>> 74 // fpNavigator= new[MaxNav] (G4Navigator*);
73 75
74 // ------------------------------------------- << 76 pTransportManager= G4TransportationManager::GetTransportationManager();
>> 77
>> 78 // EndState = G4FieldTrack( G4ThreeVector(), G4ThreeVector(), 0., 0., 0., 0., 0.) );
>> 79 // fRelocatedPoint(
>> 80 // fLastStepNo= -1;
>> 81
>> 82 G4Navigator* massNav= pTransportManager->GetNavigatorForTracking();
>> 83 if( massNav ) {
>> 84 G4VPhysicalVolume* pWorld= massNav->GetWorldVolume();
>> 85 if( pWorld ) {
>> 86 this->SetWorldVolume( pWorld );
>> 87 fLastMassWorld= pWorld;
>> 88 }
>> 89 }
>> 90 }
75 91
76 G4MultiNavigator::~G4MultiNavigator() = defaul << 92 G4MultiNavigator::~G4MultiNavigator()
>> 93 {
>> 94 // delete[] fpNavigator;
>> 95 }
77 96
78 // ------------------------------------------- << 97 // static G4int lastStepNo= -1;
>> 98 // To find the field do not forget to call
>> 99 // G4FieldManager* FindAndSetFieldManager(G4VPhysicalVolume* pCurrentPhysVol);
>> 100 // which sets and returns the correct field manager (global or local), if any.
>> 101 // Need to call it before PropagatorInField::ComputeStep is called.
79 102
80 G4double G4MultiNavigator::ComputeStep(const G << 103 G4double G4MultiNavigator::ComputeStep(const G4ThreeVector &pGlobalPoint,
81 const G << 104 const G4ThreeVector &pDirection,
82 const G << 105 const G4double proposedStepLength,
83 G << 106 G4double &pNewSafety)
84 { 107 {
85 G4double safety= 0.0, step=0.0; 108 G4double safety= 0.0, step=0.0;
86 G4double minSafety= kInfinity, minStep= kInf << 109 G4double minSafety= DBL_MAX, minStep= DBL_MAX;
87 110
88 fNoLimitingStep= -1; << 111 if( fVerboseLevel > 2 ){
89 fIdNavLimiting= -1; // Reset for new ste <<
90 <<
91 #ifdef G4DEBUG_NAVIGATION <<
92 if( fVerbose > 2 ) <<
93 { <<
94 G4cout << " G4MultiNavigator::ComputeStep 112 G4cout << " G4MultiNavigator::ComputeStep : entered " << G4endl;
95 G4cout << " Input position= " << pGlobal 113 G4cout << " Input position= " << pGlobalPoint
96 << " direction= " << pDirect 114 << " direction= " << pDirection << G4endl;
97 G4cout << " Requested step= " << propose 115 G4cout << " Requested step= " << proposedStepLength << G4endl;
98 } 116 }
99 #endif <<
100 117
101 std::vector<G4Navigator*>::iterator pNavigat 118 std::vector<G4Navigator*>::iterator pNavigatorIter;
102 119
103 pNavigatorIter= pTransportManager-> GetActiv 120 pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
104 121
105 G4ThreeVector initialPosition = pGlobalPoint << 122 G4ThreeVector initialPosition= pGlobalPoint;
106 G4ThreeVector initialDirection= pDirection; 123 G4ThreeVector initialDirection= pDirection;
107 124
108 for( auto num=0; num< fNoActiveNavigators; + << 125 G4int num=0;
109 { << 126 for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num ) {
110 safety= kInfinity; << 127 safety= DBL_MAX;
111 128
112 step= (*pNavigatorIter)->ComputeStep( ini 129 step= (*pNavigatorIter)->ComputeStep( initialPosition,
113 ini 130 initialDirection,
114 pro 131 proposedStepLength,
115 saf 132 safety );
116 if( safety < minSafety ){ minSafety = saf 133 if( safety < minSafety ){ minSafety = safety; }
117 if( step < minStep ) { minStep= step; 134 if( step < minStep ) { minStep= step; }
118 << 135 // Later could reduce the proposed step to the latest minStep value ?
>> 136 // if( step == kInfinity ) { step = proposedStepLength; }
119 fCurrentStepSize[num] = step; 137 fCurrentStepSize[num] = step;
120 fNewSafety[num]= safety; 138 fNewSafety[num]= safety;
121 // This is currently the safety from the 139 // This is currently the safety from the last sub-step
122 140
123 #ifdef G4DEBUG_NAVIGATION << 141 if( fVerboseLevel > 2 ){
124 if( fVerbose > 2 ) << 142 G4cout << "G4MultiNavigator::ComputeStep : Navigator [" << num << "] -- step size " << step << " safety= " << safety << G4endl;
125 { <<
126 G4cout << "G4MultiNavigator::ComputeSte <<
127 << num << "] -- step size " << s <<
128 << " safety= " << safety << G4en <<
129 } 143 }
130 #endif <<
131 } 144 }
132 145
>> 146 // fWasLimitedByGeometry= false; // <----- Could reset(?), but navigator leaves it as is
>> 147 // Whether any geometry limited the step
>> 148 // G4bool StepLimited = ( minStep <= proposedStepLength);
>> 149 // G4cout << "G4MultiNavigator::ComputeStep - StepLimited is " << StepLimited
>> 150 // << " given minStep= " << minStep << " and proposed Step= " << proposedStepLength << G4endl;
>> 151
133 // Save safety value, related position 152 // Save safety value, related position
134 // << 153 fPreStepLocation= initialPosition;
135 fPreStepLocation = initialPosition; << 154 fMinSafety_PreStepPt= minSafety;
136 fMinSafety_PreStepPt = minSafety; << 155
137 fMinStep = minStep; << 156 fMinStep= minStep;
138 << 157
139 if( fMinStep == kInfinity ) << 158 G4double trueMinStep= minStep;
140 { << 159 if( fMinStep == kInfinity ){
141 fTrueMinStep = proposedStepLength; // << 160 trueMinStep = proposedStepLength; // Use this below for endpoint !!
142 } << 161 }
143 else << 162 fTrueMinStep = trueMinStep;
144 { <<
145 fTrueMinStep = minStep; <<
146 } <<
147 <<
148 #ifdef G4DEBUG_NAVIGATION <<
149 if( fVerbose > 1 ) <<
150 { <<
151 G4ThreeVector endPosition = initialPositio <<
152 163
153 G4int oldPrec = G4cout.precision(8); << 164 if( fVerboseLevel > 1 ){
>> 165 G4ThreeVector endPosition;
>> 166 endPosition= initialPosition + trueMinStep * initialDirection ;
>> 167
>> 168 int oldPrec= G4cout.precision(8);
154 G4cout << "G4MultiNavigator::ComputeStep : 169 G4cout << "G4MultiNavigator::ComputeStep : "
155 << " initialPosition = " << initial 170 << " initialPosition = " << initialPosition
156 << " and endPosition = " << endPosi << 171 << " and endPosition = " << endPosition<< G4endl;
157 G4cout.precision( oldPrec ); 172 G4cout.precision( oldPrec );
158 } 173 }
159 #endif <<
160 174
161 pNewSafety = minSafety; << 175 pNewSafety= minSafety;
>> 176 // Set the EndState
>> 177 // fEndState= initialState;
>> 178 // fEndState.SetPosition( endPosition );
>> 179 // fEndState.SetProperTimeOfFlight( -1.000 ); // Not defined YET
>> 180 // fEndState.SetMomentum( initialState.GetMomentum );
162 181
163 this->WhichLimited(); 182 this->WhichLimited();
164 183
165 #ifdef G4DEBUG_NAVIGATION << 184 if( fVerboseLevel > 2 ){
166 if( fVerbose > 2 ) << 185 G4cout << " G4MultiNavigator::ComputeStep : exits returning " << minStep << G4endl;
167 { <<
168 G4cout << " G4MultiNavigator::ComputeStep <<
169 << minStep << G4endl; <<
170 } 186 }
171 #endif <<
172 187
173 return minStep; // must return kInfinity if 188 return minStep; // must return kInfinity if do not limit step
174 } 189 }
175 190
176 // ------------------------------------------- <<
177 <<
178 G4double 191 G4double
179 G4MultiNavigator::ObtainFinalStep( G4int n << 192 G4MultiNavigator::ObtainFinalStep( G4int navigatorId,
180 G4double& p << 193 G4double &pNewSafety, // for this geom
181 G4double& m << 194 G4double &minStep,
182 ELimited& l << 195 ELimited &limitedStep)
183 { << 196 {
184 if( navigatorId > fNoActiveNavigators ) << 197 G4int navigatorNo=-1;
185 { << 198
186 std::ostringstream message; << 199 if( navigatorId <= fNoActiveNavigators ){
187 message << "Bad Navigator Id!" << G4endl << 200 navigatorNo= navigatorId;
188 << " Navigator Id = " << n << 201 } else {
189 << " No Active = " << fNoA << 202 G4cerr << " Navigator Id = " << navigatorId
190 G4Exception("G4MultiNavigator::ObtainFina << 203 << " No Active = " << fNoActiveNavigators << " . " << G4endl;
191 FatalException, message); << 204 G4Exception( "G4MultiNavigator::ObtainFinalStep : Bad Navigator Id" );
192 } 205 }
>> 206 // if( ! ){ G4Exception( "G4MultiNavigator::ObtainFinalStep Called without call to ComputeStep"); }
193 207
194 // Prepare the information to return 208 // Prepare the information to return
195 // << 209 pNewSafety = fNewSafety[ navigatorNo ];
196 pNewSafety = fNewSafety[ navigatorId ]; << 210 limitedStep = fLimitedStep[ navigatorNo ];
197 limitedStep = fLimitedStep[ navigatorId ]; <<
198 minStep= fMinStep; 211 minStep= fMinStep;
199 212
200 #ifdef G4DEBUG_NAVIGATION << 213 // if( (minStep==kInfinity) || (fVerboseLevel > 1) ){
201 if( fVerbose > 1 ) << 214 if( fVerboseLevel > 1 ){
202 { << 215 G4cout << " G4MultiNavigator::ComputeStep returns " << fCurrentStepSize[ navigatorNo ]
203 G4cout << " G4MultiNavigator::ComputeStep << 216 << " for Navigator " << navigatorNo << " Limited step = " << limitedStep
204 << fCurrentStepSize[ navigatorId ] <<
205 << " for Navigator " << navigatorI <<
206 << " Limited step = " << limitedSt <<
207 << " Safety(mm) = " << pNewSafety 217 << " Safety(mm) = " << pNewSafety / mm << G4endl;
208 } 218 }
209 #endif <<
210 219
211 return fCurrentStepSize[ navigatorId ]; << 220 return fCurrentStepSize[ navigatorNo ];
212 } 221 }
213 222
214 // ------------------------------------------- 223 // ----------------------------------------------------------------------
215 224
216 void G4MultiNavigator::PrepareNewTrack( const << 225 void
217 const << 226 G4MultiNavigator::PrepareNewTrack( const G4ThreeVector position,
>> 227 const G4ThreeVector direction )
218 { 228 {
219 #ifdef G4DEBUG_NAVIGATION << 229 if( fVerboseLevel > 1 )
220 if( fVerbose > 1 ) <<
221 { <<
222 G4cout << " Entered G4MultiNavigator::Prep 230 G4cout << " Entered G4MultiNavigator::PrepareNewTrack() " << G4endl;
223 } <<
224 #endif <<
225 231
226 G4MultiNavigator::PrepareNavigators(); 232 G4MultiNavigator::PrepareNavigators();
>> 233 //***********************************
227 234
228 LocateGlobalPointAndSetup( position, &direct << 235 if( fVerboseLevel > 1 ) {
229 // << 236 G4cout << " Calling MultiNavigator::Locate() from G4MultiNavigator::PrepareNewTrack() "
>> 237 << G4endl;
>> 238 }
>> 239
>> 240 this->LocateGlobalPointAndSetup( position, &direction, false, false );
>> 241 // =========================
230 // The first location for each Navigator mus 242 // The first location for each Navigator must be non-relative
231 // or else call ResetStackAndState() for eac << 243 // or else call ResetStackAndState() for each Navigator
232 // Use direction to get correct side of boun 244 // Use direction to get correct side of boundary (ignore dir= false)
233 } <<
234 245
235 // ------------------------------------------- << 246 // fRelocatedPoint= false;
>> 247
>> 248 if( fVerboseLevel > 0 ) {
>> 249 G4cout << " G4MultiNavigator::PrepareNewTrack : exiting. " << G4endl;
>> 250 }
236 251
237 void G4MultiNavigator::PrepareNavigators() << 252 }
>> 253
>> 254 void
>> 255 G4MultiNavigator::PrepareNavigators()
238 { 256 {
239 // Key purposes: 257 // Key purposes:
240 // - Check and cache set of active navigat 258 // - Check and cache set of active navigators
241 // - Reset state for new track 259 // - Reset state for new track
>> 260 G4int num=0;
242 261
243 #ifdef G4DEBUG_NAVIGATION << 262 if( fVerboseLevel > 1 )
244 if( fVerbose > 1 ) << 263 G4cout << " G4MultiNavigator::PrepareNavigators - entered " << G4endl;
245 { << 264 // static G4TransportationManager* pTransportManager=
246 G4cout << " Entered G4MultiNavigator::Prep << 265 // G4TransportationManager::GetTransportationManager();
>> 266
>> 267 // fNavigators= true;
>> 268 // this->MovePoint(); // Signal further that the last status is wiped
>> 269
>> 270 // Message the G4NavigatorPanel / Dispatcher to find active navigators
>> 271 std::vector<G4Navigator*>::iterator pNavigatorIter;
>> 272
>> 273 fNoActiveNavigators= pTransportManager-> GetNoActiveNavigators();
>> 274 if( fNoActiveNavigators > fMaxNav ){
>> 275 G4cerr << "Too many active Navigators (worlds). G4MultiNavigator fails."
>> 276 << G4endl;
>> 277 G4cout << " Fatal error: Transportation Manager reports " << fNoActiveNavigators
>> 278 << " which is more than the number allowed = " << fMaxNav << G4endl;
>> 279 G4Exception("G4MultiNavigator::PrepareNavigators()", "TooManyNavigators",
>> 280 FatalException, "Too many active Navigators / worlds");
247 } 281 }
248 #endif <<
249 282
250 // Message the transportation-manager to fin << 283 pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
251 << 284 for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num ) {
252 std::vector<G4Navigator*>::const_iterator pN << 285
253 fNoActiveNavigators = (G4int)pTransportManag << 286 // Keep information in carray ... for returning information stored
254 << 287 fpNavigator[num] = *pNavigatorIter;
255 if( fNoActiveNavigators > fMaxNav ) <<
256 { <<
257 std::ostringstream message; <<
258 message << "Too many active Navigators / w <<
259 << " Active Navigators (wor <<
260 << fNoActiveNavigators << G4endl <<
261 << " which is more than the <<
262 << fMaxNav << " !"; <<
263 G4Exception("G4MultiNavigator::PrepareNavi <<
264 FatalException, message); <<
265 } <<
266 <<
267 pNavigatorIter= pTransportManager->GetActive <<
268 for( auto num=0; num< fNoActiveNavigators; + <<
269 { <<
270 fpNavigator[num] = *pNavigatorIter; <<
271 fLimitTruth[num] = false; 288 fLimitTruth[num] = false;
272 fLimitedStep[num] = kDoNot; 289 fLimitedStep[num] = kDoNot;
273 fCurrentStepSize[num] = 0.0; 290 fCurrentStepSize[num] = 0.0;
274 fLocatedVolume[num] = nullptr; << 291 fLocatedVolume[num] = 0;
275 } 292 }
276 fWasLimitedByGeometry = false; << 293 fWasLimitedByGeometry= false;
277 294
278 // Check the world volume of the mass naviga << 295 // Check the world volume of the mass navigator (in case a SetWorldVolume changed it)
279 // in case a call to SetWorldVolume() change << 296 G4VPhysicalVolume* massWorld = this-> GetWorldVolume();
280 << 297 // fpNavigator[0] -> GetWorldVolume();
281 G4VPhysicalVolume* massWorld = GetWorldVolum << 298 if( (massWorld != fLastMassWorld) && (massWorld!=0) ) {
282 <<
283 if( (massWorld != fLastMassWorld) && (massWo <<
284 { <<
285 // Pass along change to Mass Navigator 299 // Pass along change to Mass Navigator
286 fpNavigator[0] -> SetWorldVolume( massWor << 300 fpNavigator[0] -> SetWorldVolume( massWorld );
287 << 301 if( fVerboseLevel > 0 ) {
288 #ifdef G4DEBUG_NAVIGATION << 302 G4cout << "G4MultiNavigator::PrepareNavigators changed world volume "
289 if( fVerbose > 0 ) <<
290 { <<
291 G4cout << " G4MultiNavigator::PrepareNa <<
292 << " for mass geometry to " << m 303 << " for mass geometry to " << massWorld->GetName() << G4endl;
293 } 304 }
294 #endif << 305 fLastMassWorld= massWorld;
>> 306 }else{
>> 307 if( fVerboseLevel > 2 ) {
>> 308 G4cout << "G4MultiNavigator::PrepareNavigators retained world volume "
>> 309 << " Pointer= " << massWorld << G4endl;
>> 310 if( massWorld )
>> 311 G4cout << " Name= " << massWorld->GetName() << G4endl;
>> 312 }
>> 313 }
295 314
296 fLastMassWorld = massWorld; << 315 if( fVerboseLevel > 2 ) {
>> 316 G4cout << " G4MultiNavigator::PrepareNavigators : exiting. " << G4endl;
297 } 317 }
298 } 318 }
299 319
300 // ------------------------------------------- <<
301 320
302 G4VPhysicalVolume* 321 G4VPhysicalVolume*
303 G4MultiNavigator::LocateGlobalPointAndSetup(co 322 G4MultiNavigator::LocateGlobalPointAndSetup(const G4ThreeVector& position,
304 co 323 const G4ThreeVector* pDirection,
305 co 324 const G4bool pRelativeSearch,
306 co 325 const G4bool ignoreDirection )
307 { 326 {
308 // Locate the point in each geometry 327 // Locate the point in each geometry
309 328
310 G4ThreeVector direction(0.0, 0.0, 0.0); 329 G4ThreeVector direction(0.0, 0.0, 0.0);
311 G4bool relative = pRelativeSearch; << 330 G4bool relative= pRelativeSearch;
312 auto pNavIter = pTransportManager->GetActive << 331 std::vector<G4Navigator*>::iterator pNavIter= pTransportManager->GetActiveNavigatorsIterator();
313 << 332 G4int num=0;
314 if( pDirection != nullptr ) { direction = *p << 333
>> 334 if( pDirection ) direction = *pDirection;
>> 335
>> 336 #if 0
>> 337 G4ThreeVector lastEndPosition= fEndState.GetPosition();
>> 338 G4ThreeVector moveVec = (position - lastEndPosition );
>> 339 G4double moveLenSq= moveVec.mag2();
>> 340 if( (!fNewTrack) && (!fRelocatedPoint) && ( moveLenSq> 0.0) ){
>> 341 ReportMove( position, lastEndPosition, "Position" );
>> 342 G4Exception( "G4MultiNavigator::LocateGlobalPointAndSetup",
>> 343 "211-LocateUnexpectedPoint",
>> 344 JustWarning,
>> 345 // FatalException,
>> 346 "Location is not where last ComputeStep ended.");
>> 347 }
>> 348 fLastLocatedPosition= position;
>> 349 #endif
>> 350
>> 351 if( fVerboseLevel > 2 ){
>> 352 G4cout << " G4MultiNavigator::LocateGlobalPointAndSetup : entered " << " ---------------" << G4endl;
>> 353 G4cout << " Locating at position " << position << " with direction " << direction
>> 354 << " relative= " << relative << " ignore direction= " << ignoreDirection<< G4endl;
>> 355 G4cout << " Number of active navigators= " << fNoActiveNavigators << G4endl;
>> 356 }
>> 357
>> 358 for ( num=0; num< fNoActiveNavigators ; ++pNavIter,++num ) {
>> 359 // ... who limited the step ....
>> 360
>> 361 // G4cout << " -- Navigator id= " << num << " NavigatorPtr " << *pNavIter << G4endl;
>> 362 // G4VPhysicalVolume* world= (*pNavIter)->GetWorldVolume();
>> 363 // if( world ) { G4cout << " Navigator world= " << world->GetName() << G4endl; }
>> 364 // else{ G4cout << " No world set in Navigator. " << G4endl; }
315 365
316 #ifdef G4DEBUG_NAVIGATION << 366 if( fWasLimitedByGeometry && fLimitTruth[num] ) {
317 if( fVerbose > 2 ) <<
318 { <<
319 G4cout << " Entered G4MultiNavigator::Loca <<
320 << G4endl; <<
321 G4cout << " Locating at position: " << p <<
322 << ", with direction: " << directio <<
323 << " Relative: " << relative <<
324 << ", ignore direction: " << ignore <<
325 G4cout << " Number of active navigators: <<
326 << G4endl; <<
327 } <<
328 #endif <<
329 <<
330 for ( auto num=0; num< fNoActiveNavigators ; <<
331 { <<
332 if( fWasLimitedByGeometry && fLimitTruth[ <<
333 { <<
334 (*pNavIter)->SetGeometricallyLimitedSt 367 (*pNavIter)->SetGeometricallyLimitedStep();
335 } 368 }
336 369
337 G4VPhysicalVolume *pLocated << 370 G4VPhysicalVolume *pLocated=
338 = (*pNavIter)->LocateGlobalPointAndSetu << 371 (*pNavIter)->LocateGlobalPointAndSetup( position, &direction,
339 << 372 //*************************************//
>> 373 relative,
>> 374 ignoreDirection);
340 // Set the state related to the location 375 // Set the state related to the location
341 // <<
342 fLocatedVolume[num] = pLocated; 376 fLocatedVolume[num] = pLocated;
343 377
344 // Clear state related to the step 378 // Clear state related to the step
345 // <<
346 fLimitedStep[num] = kDoNot; 379 fLimitedStep[num] = kDoNot;
347 fCurrentStepSize[num] = 0.0; 380 fCurrentStepSize[num] = 0.0;
348 fLimitTruth[ num ] = false; // Always c 381 fLimitTruth[ num ] = false; // Always clear on locating (see Navigator)
349 382
350 #ifdef G4DEBUG_NAVIGATION << 383 if( fVerboseLevel > 2 ){
351 if( fVerbose > 2 ) << 384 G4cout << " Located in world " << num << " at " << position
352 { << 385 << " used geomLimStp " << fLimitTruth[num]
353 G4cout << " Located in world: " << num << 386 << " - found in volume " << pLocated ;
354 << " Used geomLimStp: " << fLimi << 387 G4cout << " name = '" ;
355 << ", found in volume: " << pLoc << 388 if( pLocated ){
356 G4cout << " Name = '" ; <<
357 if( pLocated ) <<
358 { <<
359 G4cout << pLocated->GetName() << "'"; 389 G4cout << pLocated->GetName() << "'";
360 G4cout << " - CopyNo= " << pLocated-> 390 G4cout << " - CopyNo= " << pLocated->GetCopyNo();
361 } << 391 } else {
362 else <<
363 { <<
364 G4cout << "Null' Id: Not-Set "; 392 G4cout << "Null' Id: Not-Set ";
365 } 393 }
366 G4cout << G4endl; << 394 G4cout << G4endl;
367 } 395 }
368 #endif << 396 } // ending for (num= ....
369 } << 397 fWasLimitedByGeometry= false; // Clear on locating
370 398
371 fWasLimitedByGeometry = false; // Clear on << 399 if( fVerboseLevel > 2 ){
372 G4VPhysicalVolume* volMassLocated = fLocated << 400 G4cout << " G4MultiNavigator::Locate : exiting. " << G4endl << G4endl;
>> 401 }
>> 402 // fRelocatedPoint= false;
373 403
>> 404 G4VPhysicalVolume* volMassLocated= fLocatedVolume[0];
374 return volMassLocated; 405 return volMassLocated;
375 } 406 }
376 407
377 // ------------------------------------------- <<
378 <<
379 void 408 void
380 G4MultiNavigator::LocateGlobalPointWithinVolum 409 G4MultiNavigator::LocateGlobalPointWithinVolume(const G4ThreeVector& position)
381 { 410 {
382 // Relocate the point in each geometry 411 // Relocate the point in each geometry
383 << 412 std::vector<G4Navigator*>::iterator pNavIter= pTransportManager->GetActiveNavigatorsIterator();
384 auto pNavIter = pTransportManager->GetActive << 413 // const G4double cErrorTolerance=1e-12;
385 << 414 // Maximum relative error from roundoff of arithmetic
386 #ifdef G4DEBUG_NAVIGATION << 415 G4int num=0;
387 if( fVerbose > 2 ) << 416
388 { << 417 if( fVerboseLevel > 2 ){
389 G4cout << " Entered G4MultiNavigator::ReLo << 418 G4cout << G4endl;
390 << " Re-locating at position: " << << 419 G4cout << " G4MultiNavigator::ReLocate : entered " << G4endl;
>> 420 G4cout << " ---------------------- -------" << G4endl;
>> 421 G4cout << " *Re*Locating at position " << position << G4endl;
391 } 422 }
392 #endif <<
393 423
394 for ( auto num=0; num< fNoActiveNavigators ; << 424 for ( num=0; num< fNoActiveNavigators ; ++pNavIter,++num ) {
395 { <<
396 // ... none limited the step 425 // ... none limited the step
397 426
>> 427 // G4VPhysicalVolume physVolume=
398 (*pNavIter)->LocateGlobalPointWithinVolum 428 (*pNavIter)->LocateGlobalPointWithinVolume( position );
>> 429 //*************************************//
399 430
400 // Clear state related to the step 431 // Clear state related to the step
401 // << 432 fLimitedStep[num] = kDoNot;
402 fLimitedStep[num] = kDoNot; <<
403 fCurrentStepSize[num] = 0.0; 433 fCurrentStepSize[num] = 0.0;
404 434
405 fLimitTruth[ num ] = false; // Always c 435 fLimitTruth[ num ] = false; // Always clear on locating (see Navigator)
>> 436 // fLocatedVolume[num]= physVolume;
>> 437
>> 438 // G4cout << " ReLocated in world " << num << " at " << position << G4endl;
406 } 439 }
407 fWasLimitedByGeometry = false; // Clear on << 440 fWasLimitedByGeometry= false; // Clear on locating
408 fLastLocatedPosition = position; << 441
>> 442 fLastLocatedPosition= position;
>> 443 // fRelocatedPoint= false;
>> 444
>> 445 if( fVerboseLevel > 2 ){
>> 446 G4cout << " G4MultiNavigator::LocateGlobalPointWithinVolume : exiting "
>> 447 << " at position " << position << G4endl;
>> 448 G4cout << G4endl;
>> 449 }
>> 450
409 } 451 }
410 452
411 // ------------------------------------------- << 453 // -----------------------------------------------------------------------------
412 454
413 G4double G4MultiNavigator::ComputeSafety( cons << 455 G4double G4MultiNavigator::ComputeSafety( const G4ThreeVector& position,
414 cons << 456 G4double maxDistance)
415 cons << 457 // Recompute safety for the relevant point
416 { 458 {
417 // Recompute safety for the relevant point << 459 G4double minSafety= DBL_MAX;
418 << 460 // G4cout << " G4MultiNavigator::ComputeSafety - called at " << position << G4endl;
419 G4double minSafety = kInfinity, safety = k <<
420 461
421 std::vector<G4Navigator*>::iterator pNavig 462 std::vector<G4Navigator*>::iterator pNavigatorIter;
422 pNavigatorIter= pTransportManager-> GetAct 463 pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
423 464
424 for( auto num=0; num< fNoActiveNavigators; << 465 G4int num=0;
425 { << 466 for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num ) {
426 safety = (*pNavigatorIter)->ComputeSafe << 467
427 if( safety < minSafety ) { minSafety = << 468 G4double safety;
>> 469 safety= (*pNavigatorIter)->ComputeSafety( position, maxDistance );
>> 470
>> 471 if( safety < minSafety ){ minSafety = safety; }
>> 472 // fNewSafety[num]= safety;
428 } 473 }
429 474
430 fSafetyLocation = position; << 475 fSafetyLocation= position;
431 fMinSafety_atSafLocation = minSafety; 476 fMinSafety_atSafLocation = minSafety;
432 477
433 #ifdef G4DEBUG_NAVIGATION << 478 if( fVerboseLevel > 1 ) {
434 if( fVerbose > 1 ) << 479 G4cout << " G4MultiNavigator::ComputeSafety - returns "
435 { << 480 << minSafety << " at location " << position
436 G4cout << " G4MultiNavigator::ComputeSaf << 481 << G4endl;
437 << minSafety << ", at location: " <<
438 } 482 }
439 #endif <<
440 return minSafety; 483 return minSafety;
441 } 484 }
442 485
443 // ------------------------------------------- <<
444 486
445 G4TouchableHandle G4MultiNavigator::CreateTouc << 487 // -----------------------------------------------------------------------------
>> 488
>> 489 G4TouchableHistoryHandle
>> 490 G4MultiNavigator::CreateTouchableHistoryHandle() const
446 { 491 {
447 G4Exception( "G4MultiNavigator::CreateToucha << 492 G4Exception( "G4MultiNavigator::CreateTouchableHistoryHandle",
448 "GeomNav0001", FatalException, << 493 "215-TouchableFromWrongNavigator",
>> 494 FatalException,
449 "Getting a touchable from G4Mul 495 "Getting a touchable from G4MultiNavigator is not defined.");
450 496
>> 497 if( fVerboseLevel > 2 ){
>> 498 G4cout << "G4MultiNavigator::CreateTouchableHandle : navId = " << 0 ;
>> 499 // << " -- " << GetNavigator(navId) << G4endl;
>> 500 }
>> 501
451 G4TouchableHistory* touchHist; 502 G4TouchableHistory* touchHist;
452 touchHist= fpNavigator[0] -> CreateTouchable 503 touchHist= fpNavigator[0] -> CreateTouchableHistory();
453 504
>> 505 // G4TouchableHistory* touchHist= new G4TouchableHistory();
>> 506
454 G4VPhysicalVolume* locatedVolume= fLocatedVo 507 G4VPhysicalVolume* locatedVolume= fLocatedVolume[0];
455 if( locatedVolume == nullptr ) << 508 if( locatedVolume == 0 )
456 { << 509 {
457 // Workaround to ensure that the touchable << 510 // Workaround to ensure that the touchable is fixed !! // TODO: fix
458 // << 511 touchHist->UpdateYourself( locatedVolume,
459 touchHist->UpdateYourself( locatedVolume, << 512 touchHist->GetHistory() );
460 } << 513 }
461 514
462 return {touchHist}; << 515 return G4TouchableHistoryHandle(touchHist);
463 } 516 }
464 517
465 // ------------------------------------------- << 518 void
466 << 519 G4MultiNavigator::WhichLimited() // Flag which processes limited the step
467 void G4MultiNavigator::WhichLimited() <<
468 { 520 {
469 // Flag which processes limited the step << 521 G4int num=-1, last=-1;
470 << 522 const G4int IdTransport= 0; // Id of Mass Navigator !!
471 G4int last=-1; <<
472 const G4int IdTransport= 0; // Id of Mass N <<
473 G4int noLimited=0; 523 G4int noLimited=0;
474 ELimited shared= kSharedOther; 524 ELimited shared= kSharedOther;
475 525
476 #ifdef G4DEBUG_NAVIGATION << 526 if( fVerboseLevel > 2 )
477 if( fVerbose > 2 ) << 527 G4cout << " G4MultiNavigator::WhichLimited - entered " << G4endl;
478 { <<
479 G4cout << " Entered G4MultiNavigator::Whic <<
480 } <<
481 #endif <<
482 528
483 // Assume that [IdTransport] is Mass / Trans 529 // Assume that [IdTransport] is Mass / Transport
484 // << 530 // G4bool transportLimited = (fCurrentStepSize[IdTransport] == fMinStep);
485 G4bool transportLimited = (fCurrentStepSize[ 531 G4bool transportLimited = (fCurrentStepSize[IdTransport] == fMinStep)
486 && ( fMinStep!= kInfi << 532 && ( fMinStep!= kInfinity) ;
487 if( transportLimited ) << 533 if( transportLimited ){
488 { << 534 shared= kSharedTransport;
489 shared = kSharedTransport; <<
490 } 535 }
491 536
492 for ( auto num = 0; num < fNoActiveNavigator << 537 for ( num= 0; num < fNoActiveNavigators; num++ ) {
493 { <<
494 G4bool limitedStep; 538 G4bool limitedStep;
495 539
496 G4double step = fCurrentStepSize[num]; << 540 G4double step= fCurrentStepSize[num];
497 541
498 limitedStep = ( step == fMinStep ) && ( st 542 limitedStep = ( step == fMinStep ) && ( step != kInfinity);
>> 543 // if( step == kInfinity ) { fCurrentStepSize[num] = proposedStepLength; }
499 544
500 fLimitTruth[ num ] = limitedStep; 545 fLimitTruth[ num ] = limitedStep;
501 if( limitedStep ) << 546 if( limitedStep ) {
502 { << 547 noLimited++;
503 ++noLimited; <<
504 fLimitedStep[num] = shared; 548 fLimitedStep[num] = shared;
505 last= num; 549 last= num;
506 } << 550 }else{
507 else <<
508 { <<
509 fLimitedStep[num] = kDoNot; 551 fLimitedStep[num] = kDoNot;
510 } 552 }
511 } 553 }
512 if( (last > -1) && (noLimited == 1 ) ) << 554 if( (last > -1) && (noLimited == 1 ) ){
513 { << 555 fLimitedStep[ last ] = kUnique;
514 fLimitedStep[ last ] = kUnique; <<
515 fIdNavLimiting = last; <<
516 } 556 }
517 557
518 fNoLimitingStep = noLimited; << 558 #ifndef G4NO_VERBOSE
>> 559 if( fVerboseLevel > 1 ){
>> 560 this->PrintLimited(); // --> for tracing
>> 561 G4cout << " G4MultiNavigator::WhichLimited - exiting. " << G4endl;
>> 562 }
>> 563 #endif
519 564
520 return; <<
521 } 565 }
522 566
523 // ------------------------------------------- <<
524 <<
525 void 567 void
526 G4MultiNavigator::PrintLimited() 568 G4MultiNavigator::PrintLimited()
527 { 569 {
>> 570 static G4String StrDoNot("DoNot"), StrUnique("Unique"), StrUndefined("Undefined"),
>> 571 StrSharedTransport("SharedTransport"), StrSharedOther("SharedOther");
528 // Report results -- for checking 572 // Report results -- for checking
529 << 573 G4cout << "G4MultiNavigator::PrintLimited reports: " ;
530 static const G4String StrDoNot("DoNot"), Str << 574 G4cout << " Minimum step (true)= " << fTrueMinStep
531 StrUndefined("Undefined"), << 575 << " reported min = " << fMinStep
532 StrSharedTransport("SharedTr << 576 << G4endl;
533 StrSharedOther("SharedOther" << 577 if( // (fCurrentStepNo <= 2) ||
534 G4cout << "### G4MultiNavigator::PrintLimite << 578 (fVerboseLevel>=2) ) {
535 G4cout << " Minimum step (true): " << fTr << 579 G4cout // << std::setw(5) << " Step#" << " "
536 << ", reported min: " << fMinStep << << 580 << std::setw(5) << " NavId" << " "
537 << 581 << std::setw(12) << " step-size " << " "
538 #ifdef G4DEBUG_NAVIGATION << 582 << std::setw(12) << " raw-size " << " "
539 if(fVerbose>=2) << 583 << std::setw(12) << " pre-safety " << " "
540 { << 584 << std::setw(15) << " Limited / flag" << " "
541 G4cout << std::setw(5) << " NavId" << " " << 585 << std::setw(15) << " World " << " "
542 << std::setw(12) << " step-size " < << 586 << G4endl;
543 << std::setw(12) << " raw-size " < <<
544 << std::setw(12) << " pre-safety " <<
545 << std::setw(15) << " Limited / fla <<
546 << std::setw(15) << " World " << <<
547 << G4endl; <<
548 } 587 }
549 #endif << 588 int num;
550 << 589 for ( num= 0; num < fNoActiveNavigators; num++ ) {
551 for ( auto num = 0; num < fNoActiveNavigator <<
552 { <<
553 G4double rawStep = fCurrentStepSize[num]; 590 G4double rawStep = fCurrentStepSize[num];
554 G4double stepLen = fCurrentStepSize[num]; 591 G4double stepLen = fCurrentStepSize[num];
555 if( stepLen > fTrueMinStep ) << 592 if( stepLen > fTrueMinStep ) {
556 { <<
557 stepLen = fTrueMinStep; // did not l 593 stepLen = fTrueMinStep; // did not limit (went as far as asked)
558 } 594 }
559 G4long oldPrec = G4cout.precision(9); << 595 G4int oldPrec= G4cout.precision(9);
560 << 596 // const char *BooleanValue[2] = { " NO", "YES" } ;
561 G4cout << std::setw(5) << num << " " << 597 G4cout // << std::setw(5) << fCurrentStepNo << " "
>> 598 << std::setw(5) << num << " "
562 << std::setw(12) << stepLen << " " 599 << std::setw(12) << stepLen << " "
563 << std::setw(12) << rawStep << " " 600 << std::setw(12) << rawStep << " "
564 << std::setw(12) << fNewSafety[num] 601 << std::setw(12) << fNewSafety[num] << " "
565 << std::setw(5) << (fLimitTruth[num 602 << std::setw(5) << (fLimitTruth[num] ? "YES" : " NO") << " ";
566 G4String limitedStr; 603 G4String limitedStr;
567 switch ( fLimitedStep[num] ) << 604 switch ( fLimitedStep[num] ) {
568 { << 605 case kDoNot: limitedStr= StrDoNot; break;
569 case kDoNot : limitedStr = StrD << 606 case kUnique: limitedStr = StrUnique; break;
570 case kUnique : limitedStr = StrU << 607 case kSharedTransport: limitedStr= StrSharedTransport; break;
571 case kSharedTransport: limitedStr = StrS << 608 case kSharedOther: limitedStr = StrSharedOther; break;
572 case kSharedOther : limitedStr = StrS << 609 default: limitedStr = StrUndefined; break;
573 default : limitedStr = StrU <<
574 } 610 }
575 G4cout << " " << std::setw(15) << limitedS 611 G4cout << " " << std::setw(15) << limitedStr << " ";
576 G4cout.precision(oldPrec); 612 G4cout.precision(oldPrec);
577 613
578 G4Navigator *pNav = fpNavigator[ num ]; << 614 G4Navigator *pNav= fpNavigator[ num ];
579 G4String WorldName( "Not-Set" ); 615 G4String WorldName( "Not-Set" );
580 if (pNav != nullptr) << 616 if (pNav) {
581 { << 617 G4VPhysicalVolume *pWorld= pNav->GetWorldVolume();
582 G4VPhysicalVolume *pWorld = pNav->GetWo << 618 if( pWorld ) {
583 if( pWorld != nullptr ) <<
584 { <<
585 WorldName = pWorld->GetName(); 619 WorldName = pWorld->GetName();
586 } 620 }
587 } 621 }
588 G4cout << " " << WorldName ; 622 G4cout << " " << WorldName ;
589 G4cout << G4endl; 623 G4cout << G4endl;
590 } 624 }
>> 625
>> 626 if( fVerboseLevel > 2 )
>> 627 G4cout << " G4MultiNavigator::PrintLimited - exiting. " << G4endl;
591 } 628 }
592 629
593 630
594 // ------------------------------------------- << 631 void
595 << 632 G4MultiNavigator::ResetState()
596 void G4MultiNavigator::ResetState() <<
597 { 633 {
598 fWasLimitedByGeometry = false; << 634 G4int num;
>> 635 fWasLimitedByGeometry= false;
599 636
600 G4Exception("G4MultiNavigator::ResetState() << 637 G4Exception( "G4MultiNavigator::ResetState",
>> 638 "217-CannotImplement",
601 FatalException, 639 FatalException,
602 "Cannot reset state for navigat << 640 "Cannot call ResetState for active navigators of G4MultiNavigator.");
603 /* <<
604 std::vector<G4Navigator*>::iterator pNaviga 641 std::vector<G4Navigator*>::iterator pNavigatorIter;
605 pNavigatorIter = pTransportManager->GetActi << 642 pNavigatorIter= pTransportManager-> GetActiveNavigatorsIterator();
606 for( auto num = 0; num< fNoActiveNavigators << 643 for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num ) {
607 { <<
608 // (*pNavigatorIter)->ResetState(); / 644 // (*pNavigatorIter)->ResetState(); // KEEP THIS comment !!!
609 } << 645 }
610 */ <<
611 } 646 }
612 647
613 // ------------------------------------------- << 648 void
614 << 649 G4MultiNavigator::SetupHierarchy()
615 void G4MultiNavigator::SetupHierarchy() <<
616 { 650 {
617 G4Exception( "G4MultiNavigator::SetupHierarc << 651 // G4Navigator::SetupHierarchy();
618 "GeomNav0001", FatalException, << 652 G4Exception( "G4MultiNavigator::SetupHierarchy",
619 "Cannot setup hierarchy for nav << 653 "217-CannotImplement",
>> 654 FatalException,
>> 655 "Cannot call SetupHierarchy for active navigators of G4MultiNavigator.");
620 } 656 }
621 657
622 // ------------------------------------------- << 658 void
623 << 659 G4MultiNavigator::CheckMassWorld()
624 void G4MultiNavigator::CheckMassWorld() <<
625 { 660 {
626 G4VPhysicalVolume* navTrackWorld = << 661 //
627 pTransportManager->GetNavigatorForTrackin << 662 G4VPhysicalVolume* navTrackWorld= pTransportManager->GetNavigatorForTracking()
628 << 663 ->GetWorldVolume();
629 if( navTrackWorld != fLastMassWorld ) << 664 if( navTrackWorld != fLastMassWorld ) {
630 { << 665 G4Exception( "G4MultiNavigator::CheckMassWorld", "MultiNav-220", FatalException,
631 G4Exception( "G4MultiNavigator::CheckMas <<
632 "GeomNav0003", FatalExcepti <<
633 "Mass world pointer has bee 666 "Mass world pointer has been changed." );
634 } << 667 }
635 } 668 }
636 669
637 // ------------------------------------------- << 670 G4VPhysicalVolume* G4MultiNavigator::ResetHierarchyAndLocate(const G4ThreeVector &point,
638 << 671 const G4ThreeVector &direction,
639 G4VPhysicalVolume* << 672 const G4TouchableHistory &MassHistory)
640 G4MultiNavigator::ResetHierarchyAndLocate(cons <<
641 cons <<
642 cons <<
643 { <<
644 // Reset geometry for all -- and use the to 673 // Reset geometry for all -- and use the touchable for the mass history
645 << 674 {
646 G4VPhysicalVolume* massVolume = nullptr; << 675 G4VPhysicalVolume* massVolume=0;
647 G4Navigator* pMassNavigator = fpNavigator[0 << 676 G4int num;
648 << 677 G4Navigator* pMassNavigator= fpNavigator[0];
649 if( pMassNavigator != nullptr ) << 678
650 { << 679 if( pMassNavigator ){
651 massVolume= pMassNavigator->ResetHierarc << 680 massVolume= pMassNavigator->ResetHierarchyAndLocate( point, direction, MassHistory);
652 << 681 }else{
653 } << 682 G4Exception("G4MultiNavigator::ResetHierarchyAndLocate",
654 else << 683 "218-TooEarlyToReset",
655 { << 684 FatalException,
656 G4Exception("G4MultiNavigator::ResetHier << 685 "Cannot reset hierarchy before object is initialised with valid navigators, including a mass Navigator" );
657 "GeomNav0002", FatalExceptio <<
658 "Cannot reset hierarchy befo <<
659 } 686 }
660 687
661 auto pNavIter= pTransportManager->GetActive << 688 std::vector<G4Navigator*>::iterator pNavIter=
>> 689 pTransportManager->GetActiveNavigatorsIterator();
662 690
663 for ( auto num = 0; num < fNoActiveNavigato << 691 for ( num=0; num< fNoActiveNavigators ; ++pNavIter,++num ) {
664 { <<
665 G4bool relativeSearch, ignoreDirection; 692 G4bool relativeSearch, ignoreDirection;
666 693
667 (*pNavIter)-> LocateGlobalPointAndSetup( 694 (*pNavIter)-> LocateGlobalPointAndSetup( point,
668 695 &direction,
669 696 relativeSearch=false,
670 697 ignoreDirection=false);
671 } 698 }
672 return massVolume; 699 return massVolume;
673 } <<
674 <<
675 // ------------------------------------------- <<
676 <<
677 G4ThreeVector <<
678 G4MultiNavigator::GetGlobalExitNormal(const G4 <<
679 G4bool* <<
680 { <<
681 G4ThreeVector normalGlobalCrd(0.0, 0.0, 0.0) <<
682 G4bool isObtained = false; <<
683 // These default values will be used if fNoL <<
684 G4int firstNavigatorId = -1; <<
685 G4bool oneObtained = false; <<
686 <<
687 if( fNoLimitingStep == 1 ) <<
688 { <<
689 // Only message the Navigator which limite <<
690 normalGlobalCrd = fpNavigator[ fIdNavLimit <<
691 ->GetGlobalExitNormal( arg <<
692 *argpObtained = isObtained; <<
693 } <<
694 else <<
695 { <<
696 if( fNoLimitingStep > 1 ) <<
697 { <<
698 auto pNavIter= pTransportManager->GetAct <<
699 <<
700 for ( auto num = 0; num < fNoActiveNavig <<
701 { <<
702 G4ThreeVector oneNormal; <<
703 if( fLimitTruth[ num ] ) // Did this <<
704 { <<
705 G4ThreeVector newNormal = <<
706 (*pNavIter)->GetGlobalExitNormal( <<
707 if( oneObtained ) <<
708 { <<
709 // Keep first one - only if it is <<
710 if( !isObtained && (newNormal.mag2 <<
711 { <<
712 normalGlobalCrd = newNormal; <<
713 isObtained = oneObtained; <<
714 firstNavigatorId = num; <<
715 } <<
716 else <<
717 { <<
718 // Check for clash <<
719 G4double dotNewPrevious = newNor <<
720 G4double productMagSq = normalGl <<
721 if( productMagSq > 0.0 ) <<
722 { <<
723 G4double productMag = std::sqr <<
724 dotNewPrevious /= productMag; <<
725 if( dotNewPrevious < (1 - perT <<
726 { <<
727 *argpObtained = false; <<
728 <<
729 if( fVerbose > 2 ) // dotN <<
730 { <<
731 std::ostringstream message <<
732 message << "Clash of Norma <<
733 << G4endl <<
734 << " Previo <<
735 << firstNavigatorI <<
736 << " Curren <<
737 << num << G4endl; <<
738 message << " Dot product <<
739 << dotNewPrevious <<
740 message << " Normal <<
741 << normalGlobalCrd <<
742 message << " Normal <<
743 G4Exception("G4MultiNaviga <<
744 "GeomNav0002", <<
745 } <<
746 } <<
747 else <<
748 { <<
749 // Close agreement - Do not <<
750 } <<
751 } <<
752 } <<
753 } <<
754 } <<
755 } // end for over the Navigators <<
756 <<
757 // Report if no Normal was obtained <<
758 if( !oneObtained ) <<
759 { <<
760 std::ostringstream message; <<
761 message << "No Normal obtained despite <<
762 << " candidate Navigators limi <<
763 G4Exception("G4MultiNavigator::GetGlob <<
764 JustWarning, message); <<
765 } <<
766 <<
767 } // end if ( fNoLimiting > 1 ) <<
768 } // end else <<
769 <<
770 *argpObtained = isObtained; <<
771 return normalGlobalCrd; <<
772 } <<
773 <<
774 // ------------------------------------------- <<
775 <<
776 G4ThreeVector <<
777 G4MultiNavigator::GetLocalExitNormal(G4bool* a <<
778 { <<
779 // If it is the mass navigator, then expect <<
780 G4ThreeVector normalGlobalCrd(0.0, 0.0, 0.0) <<
781 G4bool isObtained = false; <<
782 // These default values will be used if fNoL <<
783 <<
784 if( fNoLimitingStep == 1 ) <<
785 { <<
786 // Only message the Navigator which limite <<
787 normalGlobalCrd = fpNavigator[ fIdNavLimit <<
788 ->GetLocalExitNormal( &isO <<
789 *argpObtained = isObtained; <<
790 <<
791 static G4ThreadLocal G4int numberWarnings <<
792 G4int noWarningsStart = 10, noModuloWarnin <<
793 ++numberWarnings; <<
794 if( (numberWarnings < noWarningsStart ) <<
795 || (numberWarnings%noModuloWarnings == 0) <<
796 { <<
797 std::ostringstream message; <<
798 message << "Cannot obtain normal in loca <<
799 << "coordinate systems." << G4en <<
800 G4Exception("G4MultiNavigator::GetGlobal <<
801 JustWarning, message); <<
802 } <<
803 } <<
804 else <<
805 { <<
806 if( fNoLimitingStep > 1 ) <<
807 { <<
808 std::ostringstream message; <<
809 message << "Cannot obtain normal in loca <<
810 << "coordinate systems." << G4en <<
811 G4Exception("G4MultiNavigator::GetGlobal <<
812 FatalException, message); <<
813 } <<
814 } <<
815 <<
816 *argpObtained = isObtained; <<
817 return normalGlobalCrd; <<
818 } <<
819 <<
820 // ------------------------------------------- <<
821 <<
822 G4ThreeVector <<
823 G4MultiNavigator::GetLocalExitNormalAndCheck(c <<
824 <<
825 { <<
826 return G4MultiNavigator::GetLocalExitNormal( <<
827 } 700 }
828 701