| 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: G4RegularNavigation.cc 66356 2012-12-18 09:02:32Z gcosmo $
>> 28 // GEANT4 tag $ Name:$
>> 29 //
26 // class G4RegularNavigation implementation 30 // class G4RegularNavigation implementation
27 // 31 //
28 // Author: Pedro Arce, May 2007 32 // Author: Pedro Arce, May 2007
29 // 33 //
30 // ------------------------------------------- 34 // --------------------------------------------------------------------
31 35
32 #include "G4RegularNavigation.hh" 36 #include "G4RegularNavigation.hh"
33 #include "G4TouchableHistory.hh" 37 #include "G4TouchableHistory.hh"
34 #include "G4PhantomParameterisation.hh" 38 #include "G4PhantomParameterisation.hh"
35 #include "G4Material.hh" 39 #include "G4Material.hh"
36 #include "G4NormalNavigation.hh" 40 #include "G4NormalNavigation.hh"
37 #include "G4Navigator.hh" 41 #include "G4Navigator.hh"
38 #include "G4GeometryTolerance.hh" 42 #include "G4GeometryTolerance.hh"
39 #include "G4RegularNavigationHelper.hh" 43 #include "G4RegularNavigationHelper.hh"
40 44
41 //-------------------------------------------- 45 //------------------------------------------------------------------
42 G4RegularNavigation::G4RegularNavigation() 46 G4RegularNavigation::G4RegularNavigation()
>> 47 : fverbose(false), fcheck(false), fnormalNav(0)
43 { 48 {
44 kCarTolerance = G4GeometryTolerance::GetInst 49 kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
45 fMinStep = 101*kCarTolerance; <<
46 } 50 }
47 51
48 52
49 //-------------------------------------------- 53 //------------------------------------------------------------------
50 G4RegularNavigation::~G4RegularNavigation() = << 54 G4RegularNavigation::~G4RegularNavigation()
>> 55 {
>> 56 }
51 57
52 58
53 //-------------------------------------------- 59 //------------------------------------------------------------------
54 G4double G4RegularNavigation:: 60 G4double G4RegularNavigation::
55 ComputeStep(const G4ThreeV 61 ComputeStep(const G4ThreeVector& localPoint,
56 const G4ThreeV 62 const G4ThreeVector& localDirection,
57 const G4double 63 const G4double currentProposedStepLength,
58 G4double 64 G4double& newSafety,
59 G4Naviga 65 G4NavigationHistory& history,
60 G4bool& 66 G4bool& validExitNormal,
61 G4ThreeV 67 G4ThreeVector& exitNormal,
62 G4bool& 68 G4bool& exiting,
63 G4bool& 69 G4bool& entering,
64 G4VPhysi 70 G4VPhysicalVolume *(*pBlockedPhysical),
65 G4int& b 71 G4int& blockedReplicaNo)
66 { 72 {
67 // This method is never called because to be 73 // This method is never called because to be called the daughter has to be
68 // a regular structure. This would only happ 74 // a regular structure. This would only happen if the track is in the mother
69 // of voxels volume. But the voxels fill com 75 // of voxels volume. But the voxels fill completely their mother, so when a
70 // track enters the mother it automatically 76 // track enters the mother it automatically enters a voxel. Only precision
71 // problems would make this method to be cal 77 // problems would make this method to be called
72 78
73 G4ThreeVector globalPoint = 79 G4ThreeVector globalPoint =
74 history.GetTopTransform().InverseTransform << 80 history.GetTopTransform().Inverse().TransformPoint(localPoint);
75 G4ThreeVector globalDirection = 81 G4ThreeVector globalDirection =
76 history.GetTopTransform().InverseTran << 82 history.GetTopTransform().Inverse().TransformAxis(localDirection);
77 83
78 G4ThreeVector localPoint2 = localPoint; // t 84 G4ThreeVector localPoint2 = localPoint; // take away constantness
79 85
80 LevelLocate( history, *pBlockedPhysical, blo 86 LevelLocate( history, *pBlockedPhysical, blockedReplicaNo,
81 globalPoint, &globalDirection, 87 globalPoint, &globalDirection, true, localPoint2 );
82 88
83 89
84 // Get in which voxel it is 90 // Get in which voxel it is
85 // 91 //
86 G4VPhysicalVolume *motherPhysical, *daughter 92 G4VPhysicalVolume *motherPhysical, *daughterPhysical;
87 G4LogicalVolume *motherLogical; 93 G4LogicalVolume *motherLogical;
88 motherPhysical = history.GetTopVolume(); 94 motherPhysical = history.GetTopVolume();
89 motherLogical = motherPhysical->GetLogicalVo 95 motherLogical = motherPhysical->GetLogicalVolume();
90 daughterPhysical = motherLogical->GetDaughte 96 daughterPhysical = motherLogical->GetDaughter(0);
91 97
92 auto daughterParam = << 98 G4PhantomParameterisation * daughterParam =
93 (G4PhantomParameterisation*)(daughterPh << 99 (G4PhantomParameterisation*)(daughterPhysical->GetParameterisation());
94 G4int copyNo = daughterParam ->GetReplicaNo( 100 G4int copyNo = daughterParam ->GetReplicaNo(localPoint,localDirection);
95 101
96 G4ThreeVector voxelTranslation = daughterPar 102 G4ThreeVector voxelTranslation = daughterParam->GetTranslation( copyNo );
97 G4ThreeVector daughterPoint = localPoint - v 103 G4ThreeVector daughterPoint = localPoint - voxelTranslation;
98 104
99 105
100 // Compute step in voxel 106 // Compute step in voxel
101 // 107 //
102 return fnormalNav->ComputeStep(daughterPoint 108 return fnormalNav->ComputeStep(daughterPoint,
103 localDirectio 109 localDirection,
104 currentPropos 110 currentProposedStepLength,
105 newSafety, 111 newSafety,
106 history, 112 history,
107 validExitNorm 113 validExitNormal,
108 exitNormal, 114 exitNormal,
109 exiting, 115 exiting,
110 entering, 116 entering,
111 pBlockedPhysi 117 pBlockedPhysical,
112 blockedReplic 118 blockedReplicaNo);
113 } 119 }
114 120
115 121
116 //-------------------------------------------- 122 //------------------------------------------------------------------
117 G4double G4RegularNavigation::ComputeStepSkipp 123 G4double G4RegularNavigation::ComputeStepSkippingEqualMaterials(
118 G4ThreeV 124 G4ThreeVector& localPoint,
119 const G4ThreeV 125 const G4ThreeVector& localDirection,
120 const G4double 126 const G4double currentProposedStepLength,
121 G4double& newS 127 G4double& newSafety,
122 G4NavigationHi 128 G4NavigationHistory& history,
123 G4bool& validE 129 G4bool& validExitNormal,
124 G4ThreeVector& 130 G4ThreeVector& exitNormal,
125 G4bool& exitin 131 G4bool& exiting,
126 G4bool& enteri 132 G4bool& entering,
127 G4VPhysicalVol 133 G4VPhysicalVolume *(*pBlockedPhysical),
128 G4int& blocked 134 G4int& blockedReplicaNo,
129 G4VPhysicalVol 135 G4VPhysicalVolume* pCurrentPhysical)
130 { 136 {
131 G4RegularNavigationHelper::Instance()->Clear 137 G4RegularNavigationHelper::Instance()->ClearStepLengths();
132 138
133 auto param = << 139 G4PhantomParameterisation *param =
134 (G4PhantomParameterisation*)(pCurrentPhysi 140 (G4PhantomParameterisation*)(pCurrentPhysical->GetParameterisation());
135 141
136 if( !param->SkipEqualMaterials() ) 142 if( !param->SkipEqualMaterials() )
137 { 143 {
138 return fnormalNav->ComputeStep(localPoint, 144 return fnormalNav->ComputeStep(localPoint,
139 localDirect 145 localDirection,
140 currentProp 146 currentProposedStepLength,
141 newSafety, 147 newSafety,
142 history, 148 history,
143 validExitNo 149 validExitNormal,
144 exitNormal, 150 exitNormal,
145 exiting, 151 exiting,
146 entering, 152 entering,
147 pBlockedPhy 153 pBlockedPhysical,
148 blockedRepl 154 blockedReplicaNo);
149 } 155 }
150 156
151 157
152 G4double ourStep = 0.; 158 G4double ourStep = 0.;
153 159
154 // To get replica No: transform local point 160 // To get replica No: transform local point to the reference system of the
155 // param container volume 161 // param container volume
156 // 162 //
157 auto ide = (G4int)history.GetDepth(); << 163 G4int ide = history.GetDepth();
158 G4ThreeVector containerPoint = history.GetTr << 164 G4ThreeVector containerPoint = history.GetTransform(ide).Inverse().TransformPoint(localPoint);
159 .InverseTrans <<
160 165
161 // Point in global frame 166 // Point in global frame
162 // 167 //
163 containerPoint = history.GetTransform(ide).I << 168 containerPoint = history.GetTransform(ide).Inverse().TransformPoint(localPoint);
164 169
165 // Point in voxel parent volume frame 170 // Point in voxel parent volume frame
166 // 171 //
167 containerPoint = history.GetTransform(ide-1) 172 containerPoint = history.GetTransform(ide-1).TransformPoint(containerPoint);
168 173
169 // Store previous voxel translation to move 174 // Store previous voxel translation to move localPoint by the difference
170 // with the new one 175 // with the new one
171 // 176 //
172 G4ThreeVector prevVoxelTranslation = contain 177 G4ThreeVector prevVoxelTranslation = containerPoint - localPoint;
173 178
174 // Do not use the expression below: There ar 179 // Do not use the expression below: There are cases where the
175 // fLastLocatedPointLocal does not give the 180 // fLastLocatedPointLocal does not give the correct answer
176 // (particle reaching a wall and bounced bac 181 // (particle reaching a wall and bounced back, particle travelling through
177 // the wall that is deviated in an step, ... 182 // the wall that is deviated in an step, ...; these are pathological cases
178 // that give wrong answers in G4PhantomParam 183 // that give wrong answers in G4PhantomParameterisation::GetReplicaNo()
179 // 184 //
180 // G4ThreeVector prevVoxelTranslation = para 185 // G4ThreeVector prevVoxelTranslation = param->GetTranslation( copyNo );
181 186
182 G4int copyNo = param->GetReplicaNo(container 187 G4int copyNo = param->GetReplicaNo(containerPoint,localDirection);
183 188
184 G4Material* currentMate = param->ComputeMate << 189 G4Material* currentMate = param->ComputeMaterial( copyNo, 0, 0 );
185 G4VSolid* voxelBox = pCurrentPhysical->GetLo 190 G4VSolid* voxelBox = pCurrentPhysical->GetLogicalVolume()->GetSolid();
186 191
187 G4VSolid* containerSolid = param->GetContain 192 G4VSolid* containerSolid = param->GetContainerSolid();
188 G4Material* nextMate; 193 G4Material* nextMate;
189 G4bool bFirstStep = true; 194 G4bool bFirstStep = true;
190 G4double newStep; 195 G4double newStep;
191 G4double totalNewStep = 0.; 196 G4double totalNewStep = 0.;
192 197
193 // Loop while same material is found 198 // Loop while same material is found
194 // 199 //
195 // << 200 for( ;; )
196 fNumberZeroSteps = 0; <<
197 for( G4int ii = 0; ii < fNoStepsAllowed+1; + <<
198 { 201 {
199 if( ii == fNoStepsAllowed ) { <<
200 // Must kill this stuck track <<
201 // <<
202 G4ThreeVector pGlobalpoint = history.Get <<
203 .InverseTra <<
204 std::ostringstream message; <<
205 message << "G4RegularNavigation::Compute <<
206 << "Stuck Track: potential geometry or <<
207 << G4endl <<
208 << " Track stuck, moving for mo <<
209 << ii << " steps" << G4endl <<
210 << "- at point " << pGlobalpoint << G4 <<
211 << " local direction: " << loca <<
212 G4Exception("G4RegularNavigation::Comput <<
213 "GeomRegNav1001", <<
214 EventMustBeAborted, <<
215 message); <<
216 } <<
217 newStep = voxelBox->DistanceToOut( localPo 202 newStep = voxelBox->DistanceToOut( localPoint, localDirection );
218 fLastStepWasZero = (newStep<fMinStep); << 203
219 if( fLastStepWasZero ) <<
220 { <<
221 ++fNumberZeroSteps; <<
222 #ifdef G4DEBUG_NAVIGATION <<
223 if( fNumberZeroSteps > 1 ) <<
224 { <<
225 G4ThreeVector pGlobalpoint = history.G <<
226 .InverseT <<
227 std::ostringstream message; <<
228 message.precision(16); <<
229 message << "G4RegularNavigation::Compute <<
230 << fNumberZeroSteps <<
231 << ", at " << pGlobalpoint <<
232 << ", nav-comp-step calls # " << i <<
233 << ", Step= " << newStep; <<
234 G4Exception("G4RegularNavigation:: <<
235 "GeomRegNav1002", Just <<
236 "Potential overlap in <<
237 } <<
238 #endif <<
239 if( fNumberZeroSteps > fActionThreshold_ <<
240 { <<
241 // Act to recover this stuck track. Pu <<
242 // <<
243 newStep = std::min(101*kCarTolerance*s <<
244 #ifdef G4DEBUG_NAVIGATION <<
245 G4ThreeVector pGlobalpoint = history.G <<
246 .Invers <<
247 std::ostringstream message; <<
248 message.precision(16); <<
249 message << "Track stuck or not moving. <<
250 << " Track stuc <<
251 << fNumberZeroSteps << " <<
252 << "- at point " << pGlo <<
253 << " (local point " << l <<
254 << " local direct <<
255 << " Potential <<
256 << G4endl <<
257 << " Trying pus <<
258 G4Exception("G4RegularNavigation <<
259 "GeomRegNav1003", Ju <<
260 "Potential overlap i <<
261 #endif <<
262 } <<
263 if( fNumberZeroSteps > fAbandonThreshold <<
264 { <<
265 // Must kill this stuck track <<
266 // <<
267 G4ThreeVector pGlobalpoint = history.G <<
268 .Inv <<
269 std::ostringstream message; <<
270 message << "G4RegularNavigation::Compu <<
271 << "Stuck Track: potential geometry <<
272 << G4endl <<
273 << " Track stuck, not moving <<
274 << fNumberZeroSteps << " steps" << G <<
275 << "- at point " << pGlobalpoint << <<
276 << " local direction: " << lo <<
277 G4Exception("G4RegularNavigation::Comp <<
278 "GeomRegNav1004", <<
279 EventMustBeAborted, <<
280 message); <<
281 } <<
282 } <<
283 else <<
284 { <<
285 // reset the zero step counter when a no <<
286 fNumberZeroSteps = 0; <<
287 } <<
288 if( (bFirstStep) && (newStep < currentProp 204 if( (bFirstStep) && (newStep < currentProposedStepLength) )
289 { 205 {
290 exiting = true; 206 exiting = true;
291 } 207 }
292 bFirstStep = false; 208 bFirstStep = false;
293 209
294 newStep += kCarTolerance; // Avoid preci 210 newStep += kCarTolerance; // Avoid precision problems
295 ourStep += newStep; 211 ourStep += newStep;
296 totalNewStep += newStep; 212 totalNewStep += newStep;
297 213
298 // Physical process is limiting the step, 214 // Physical process is limiting the step, don't continue
299 // 215 //
300 if(std::fabs(totalNewStep-currentProposedS 216 if(std::fabs(totalNewStep-currentProposedStepLength) < kCarTolerance)
301 { 217 {
302 return currentProposedStepLength; 218 return currentProposedStepLength;
303 } 219 }
304 if(totalNewStep > currentProposedStepLengt 220 if(totalNewStep > currentProposedStepLength)
305 { 221 {
306 G4RegularNavigationHelper::Instance()-> 222 G4RegularNavigationHelper::Instance()->
307 AddStepLength(copyNo, newStep-totalNew 223 AddStepLength(copyNo, newStep-totalNewStep+currentProposedStepLength);
308 return currentProposedStepLength; 224 return currentProposedStepLength;
309 } 225 }
310 G4RegularNavigationHelper::Instance()->Add << 226 else
>> 227 {
>> 228 G4RegularNavigationHelper::Instance()->AddStepLength( copyNo, newStep );
>> 229 }
>> 230
311 231
312 // Move container point until wall of voxe 232 // Move container point until wall of voxel
313 // 233 //
314 containerPoint += newStep*localDirection; 234 containerPoint += newStep*localDirection;
315 if( containerSolid->Inside( containerPoint 235 if( containerSolid->Inside( containerPoint ) != kInside )
316 { 236 {
317 break; 237 break;
318 } 238 }
319 239
320 // Get copyNo and translation of new voxel 240 // Get copyNo and translation of new voxel
321 // 241 //
322 copyNo = param->GetReplicaNo(containerPoin << 242 copyNo = param->GetReplicaNo(containerPoint,localDirection);
323 G4ThreeVector voxelTranslation = param->Ge 243 G4ThreeVector voxelTranslation = param->GetTranslation( copyNo );
324 244
>> 245 // G4cout << " copyNo " << copyNo << " = " << pCurrentPhysical->GetCopyNo() << G4endl;
325 // Move local point until wall of voxel an 246 // Move local point until wall of voxel and then put it in the new voxel
326 // local coordinates 247 // local coordinates
327 // 248 //
328 localPoint += newStep*localDirection; 249 localPoint += newStep*localDirection;
329 localPoint += prevVoxelTranslation - voxel 250 localPoint += prevVoxelTranslation - voxelTranslation;
330 251
331 prevVoxelTranslation = voxelTranslation; 252 prevVoxelTranslation = voxelTranslation;
332 253
333 // Check if material of next voxel is the 254 // Check if material of next voxel is the same as that of the current voxel
334 nextMate = param->ComputeMaterial( copyNo, << 255 nextMate = param->ComputeMaterial( copyNo, 0, 0 );
335 256
336 if( currentMate != nextMate ) { break; } 257 if( currentMate != nextMate ) { break; }
337 } 258 }
338 259
339 return ourStep; 260 return ourStep;
340 } 261 }
341 262
342 263
343 //-------------------------------------------- 264 //------------------------------------------------------------------
344 G4double 265 G4double
345 G4RegularNavigation::ComputeSafety(const G4Thr 266 G4RegularNavigation::ComputeSafety(const G4ThreeVector& localPoint,
346 const G4Nav 267 const G4NavigationHistory& history,
347 const G4dou 268 const G4double pMaxLength)
348 { 269 {
349 // This method is never called because to be 270 // This method is never called because to be called the daughter has to be a
350 // regular structure. This would only happen 271 // regular structure. This would only happen if the track is in the mother of
351 // voxels volume. But the voxels fill comple 272 // voxels volume. But the voxels fill completely their mother, so when a
352 // track enters the mother it automatically 273 // track enters the mother it automatically enters a voxel. Only precision
353 // problems would make this method to be cal 274 // problems would make this method to be called
354 275
355 // Compute step in voxel 276 // Compute step in voxel
356 // 277 //
357 return fnormalNav->ComputeSafety(localPoint, 278 return fnormalNav->ComputeSafety(localPoint,
358 history, 279 history,
359 pMaxLength 280 pMaxLength );
360 } 281 }
361 282
362 283
363 //-------------------------------------------- 284 //------------------------------------------------------------------
364 G4bool 285 G4bool
365 G4RegularNavigation::LevelLocate( G4Navigation 286 G4RegularNavigation::LevelLocate( G4NavigationHistory& history,
366 const G4VPhy 287 const G4VPhysicalVolume* ,
367 const G4int 288 const G4int ,
368 const G4Thre 289 const G4ThreeVector& globalPoint,
369 const G4Thre 290 const G4ThreeVector* globalDirection,
370 const G4bool 291 const G4bool, // pLocatedOnEdge,
371 G4ThreeVecto 292 G4ThreeVector& localPoint )
372 { 293 {
373 G4VPhysicalVolume *motherPhysical, *pPhysica 294 G4VPhysicalVolume *motherPhysical, *pPhysical;
374 G4PhantomParameterisation *pParam; 295 G4PhantomParameterisation *pParam;
375 G4LogicalVolume *motherLogical; 296 G4LogicalVolume *motherLogical;
376 G4ThreeVector localDir; 297 G4ThreeVector localDir;
377 G4int replicaNo; 298 G4int replicaNo;
378 299
379 motherPhysical = history.GetTopVolume(); 300 motherPhysical = history.GetTopVolume();
380 motherLogical = motherPhysical->GetLogicalVo 301 motherLogical = motherPhysical->GetLogicalVolume();
381 302
382 pPhysical = motherLogical->GetDaughter(0); 303 pPhysical = motherLogical->GetDaughter(0);
383 pParam = (G4PhantomParameterisation*)(pPhysi 304 pParam = (G4PhantomParameterisation*)(pPhysical->GetParameterisation());
384 305
385 // Save parent history in touchable history 306 // Save parent history in touchable history
386 // ... for use as parent t-h in ComputeMater 307 // ... for use as parent t-h in ComputeMaterial method of param
387 // 308 //
388 G4TouchableHistory parentTouchable( history 309 G4TouchableHistory parentTouchable( history );
389 310
390 // Get local direction 311 // Get local direction
391 // 312 //
392 if( globalDirection != nullptr ) << 313 if( globalDirection )
393 { 314 {
394 localDir = history.GetTopTransform().Trans 315 localDir = history.GetTopTransform().TransformAxis(*globalDirection);
395 } 316 }
396 else 317 else
397 { 318 {
398 localDir = G4ThreeVector(0.,0.,0.); 319 localDir = G4ThreeVector(0.,0.,0.);
399 } 320 }
400 321
401 // Enter this daughter 322 // Enter this daughter
402 // 323 //
403 replicaNo = pParam->GetReplicaNo( localPoint 324 replicaNo = pParam->GetReplicaNo( localPoint, localDir );
404 325
405 if( replicaNo < 0 || replicaNo >= G4int(pPar << 326 if( replicaNo < 0 || replicaNo >= G4int(pParam->GetNoVoxel()) )
406 { 327 {
407 return false; 328 return false;
408 } 329 }
409 330
410 // Set the correct copy number in physical 331 // Set the correct copy number in physical
411 // 332 //
412 pPhysical->SetCopyNo(replicaNo); 333 pPhysical->SetCopyNo(replicaNo);
413 pParam->ComputeTransformation(replicaNo,pPhy 334 pParam->ComputeTransformation(replicaNo,pPhysical);
414 335
415 history.NewLevel(pPhysical, kParameterised, 336 history.NewLevel(pPhysical, kParameterised, replicaNo );
416 localPoint = history.GetTopTransform().Trans 337 localPoint = history.GetTopTransform().TransformPoint(globalPoint);
417 338
418 // Set the correct solid and material in Log 339 // Set the correct solid and material in Logical Volume
419 // 340 //
420 G4LogicalVolume *pLogical = pPhysical->GetLo 341 G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
421 342
422 pLogical->UpdateMaterial(pParam->ComputeMate 343 pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
423 pPhysical, &parentT 344 pPhysical, &parentTouchable) );
424 return true; 345 return true;
425 } 346 }
426 347