Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ParameterisedNavigation Class Reference

#include <G4ParameterisedNavigation.hh>

Inheritance diagram for G4ParameterisedNavigation:
Collaboration diagram for G4ParameterisedNavigation:

Public Member Functions

 G4ParameterisedNavigation ()
 
 ~G4ParameterisedNavigation ()
 
G4SmartVoxelNodeParamVoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
 
G4bool LevelLocate (G4NavigationHistory &history, const G4VPhysicalVolume *blockedVol, const G4int blockedNum, const G4ThreeVector &globalPoint, const G4ThreeVector *globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector &localPoint)
 
G4double ComputeStep (const G4ThreeVector &globalPoint, const G4ThreeVector &globalDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume *(*pBlockedPhysical), G4int &blockedReplicaNo)
 
G4double ComputeSafety (const G4ThreeVector &localPoint, const G4NavigationHistory &history, const G4double pProposedMaxLength=DBL_MAX)
 
- Public Member Functions inherited from G4VoxelNavigation
 G4VoxelNavigation ()
 
virtual ~G4VoxelNavigation ()
 
G4SmartVoxelNodeVoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
 
G4int GetVerboseLevel () const
 
void SetVerboseLevel (G4int level)
 
void CheckMode (G4bool mode)
 
void EnableBestSafety (G4bool flag=false)
 

Additional Inherited Members

- Protected Member Functions inherited from G4VoxelNavigation
G4double ComputeVoxelSafety (const G4ThreeVector &localPoint) const
 
G4bool LocateNextVoxel (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentStep)
 
G4SmartVoxelNodeVoxelLocateLight (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint) const
 
- Protected Attributes inherited from G4VoxelNavigation
G4BlockingList fBList
 
G4int fVoxelDepth
 
std::vector< EAxisfVoxelAxisStack
 
std::vector< G4intfVoxelNoSlicesStack
 
std::vector< G4doublefVoxelSliceWidthStack
 
std::vector< G4intfVoxelNodeNoStack
 
std::vector< G4SmartVoxelHeader * > fVoxelHeaderStack
 
G4SmartVoxelNodefVoxelNode
 
G4VoxelSafetyfpVoxelSafety
 
G4double fHalfTolerance
 
G4bool fCheck
 
G4bool fBestSafety
 
G4NavigationLoggerfLogger
 

Detailed Description

Definition at line 58 of file G4ParameterisedNavigation.hh.

Constructor & Destructor Documentation

G4ParameterisedNavigation::G4ParameterisedNavigation ( )

Definition at line 60 of file G4ParameterisedNavigation.cc.

61  : fVoxelAxis(kUndefined), fVoxelNoSlices(0), fVoxelSliceWidth(0.),
62  fVoxelNodeNo(0), fVoxelHeader(0)
63 {
64 }
G4ParameterisedNavigation::~G4ParameterisedNavigation ( )

Definition at line 70 of file G4ParameterisedNavigation.cc.

71 {
72 }

Member Function Documentation

G4double G4ParameterisedNavigation::ComputeSafety ( const G4ThreeVector localPoint,
const G4NavigationHistory history,
const G4double  pProposedMaxLength = DBL_MAX 
)
virtual

Reimplemented from G4VoxelNavigation.

Definition at line 399 of file G4ParameterisedNavigation.cc.

402 {
403  G4VPhysicalVolume *motherPhysical, *samplePhysical;
404  G4VPVParameterisation *sampleParam;
405  G4LogicalVolume *motherLogical;
406  G4VSolid *motherSolid, *sampleSolid;
407  G4double motherSafety, ourSafety;
408  G4int sampleNo, curVoxelNodeNo;
409 
410  G4SmartVoxelNode *curVoxelNode;
411  G4int curNoVolumes, contentNo;
412  G4double voxelSafety;
413 
414  // Replication data
415  //
416  EAxis axis;
417  G4int nReplicas;
418  G4double width, offset;
419  G4bool consuming;
420 
421  motherPhysical = history.GetTopVolume();
422  motherLogical = motherPhysical->GetLogicalVolume();
423  motherSolid = motherLogical->GetSolid();
424 
425  //
426  // Compute mother safety
427  //
428 
429  motherSafety = motherSolid->DistanceToOut(localPoint);
430  ourSafety = motherSafety; // Working isotropic safety
431 
432  //
433  // Compute daughter safeties
434  //
435 
436  // By definition, parameterised volumes exist as first
437  // daughter of the mother volume
438  //
439  samplePhysical = motherLogical->GetDaughter(0);
440  samplePhysical->GetReplicationData(axis, nReplicas,
441  width, offset, consuming);
442  sampleParam = samplePhysical->GetParameterisation();
443 
444  // Look inside the current Voxel only at the current point
445  //
446  if ( axis==kUndefined ) // 3D case: current voxel node is retrieved
447  { // from G4VoxelNavigation.
448  curVoxelNode = fVoxelNode;
449  }
450  else // 1D case: current voxel node is computed here.
451  {
452  curVoxelNodeNo = G4int((localPoint(fVoxelAxis)
453  -fVoxelHeader->GetMinExtent()) / fVoxelSliceWidth );
454  curVoxelNode = fVoxelHeader->GetSlice(curVoxelNodeNo)->GetNode();
455  fVoxelNodeNo = curVoxelNodeNo;
456  fVoxelNode = curVoxelNode;
457  }
458  curNoVolumes = curVoxelNode->GetNoContained();
459 
460  for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
461  {
462  sampleNo = curVoxelNode->GetVolume(contentNo);
463 
464  // Call virtual methods, and copy information if needed
465  //
466  sampleSolid= IdentifyAndPlaceSolid( sampleNo,samplePhysical,sampleParam );
467 
468  G4AffineTransform sampleTf(samplePhysical->GetRotation(),
469  samplePhysical->GetTranslation());
470  sampleTf.Invert();
471  const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
472  G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
473  if ( sampleSafety<ourSafety )
474  {
475  ourSafety = sampleSafety;
476  }
477  }
478 
479  voxelSafety = ComputeVoxelSafety(localPoint,axis);
480  if ( voxelSafety<ourSafety )
481  {
482  ourSafety=voxelSafety;
483  }
484 
485  return ourSafety;
486 }
G4VPhysicalVolume * GetTopVolume() const
G4int GetVolume(G4int pVolumeNo) const
G4VSolid * GetSolid() const
G4VPhysicalVolume * GetDaughter(const G4int i) const
#define width
const G4RotationMatrix * GetRotation() const
int G4int
Definition: G4Types.hh:78
G4int GetNoContained() const
G4AffineTransform & Invert()
G4double GetMinExtent() const
bool G4bool
Definition: G4Types.hh:79
virtual G4VPVParameterisation * GetParameterisation() const =0
virtual G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const =0
const G4ThreeVector & GetTranslation() const
G4LogicalVolume * GetLogicalVolume() const
G4SmartVoxelNode * GetNode() const
EAxis
Definition: geomdefs.hh:54
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
G4SmartVoxelNode * fVoxelNode
G4SmartVoxelProxy * GetSlice(G4int n) const
double G4double
Definition: G4Types.hh:76
virtual G4double DistanceToOut(const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const =0

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4ParameterisedNavigation::ComputeStep ( const G4ThreeVector globalPoint,
const G4ThreeVector globalDirection,
const G4double  currentProposedStepLength,
G4double newSafety,
G4NavigationHistory history,
G4bool validExitNormal,
G4ThreeVector exitNormal,
G4bool exiting,
G4bool entering,
G4VPhysicalVolume **  pBlockedPhysical,
G4int blockedReplicaNo 
)
virtual

Reimplemented from G4VoxelNavigation.

Definition at line 79 of file G4ParameterisedNavigation.cc.

90 {
91  G4VPhysicalVolume *motherPhysical, *samplePhysical;
92  G4VPVParameterisation *sampleParam;
93  G4LogicalVolume *motherLogical;
94  G4VSolid *motherSolid, *sampleSolid;
95  G4ThreeVector sampleDirection;
96  G4double ourStep=currentProposedStepLength, ourSafety;
97  G4double motherSafety, motherStep=DBL_MAX;
98  G4bool motherValidExitNormal=false;
99  G4ThreeVector motherExitNormal;
100 
101  G4int sampleNo;
102 
103  G4bool initialNode, noStep;
104  G4SmartVoxelNode *curVoxelNode;
105  G4int curNoVolumes, contentNo;
106  G4double voxelSafety;
107 
108  // Replication data
109  //
110  EAxis axis;
111  G4int nReplicas;
112  G4double width, offset;
113  G4bool consuming;
114 
115  motherPhysical = history.GetTopVolume();
116  motherLogical = motherPhysical->GetLogicalVolume();
117  motherSolid = motherLogical->GetSolid();
118 
119  //
120  // Compute mother safety
121  //
122 
123  motherSafety = motherSolid->DistanceToOut(localPoint);
124  ourSafety = motherSafety; // Working isotropic safety
125 
126 #ifdef G4VERBOSE
127  if ( fCheck )
128  {
129  if( motherSafety < 0.0 )
130  {
131  motherSolid->DumpInfo();
132  std::ostringstream message;
133  message << "Negative Safety In Voxel Navigation !" << G4endl
134  << " Current solid " << motherSolid->GetName()
135  << " gave negative safety: " << motherSafety << G4endl
136  << " for the current (local) point " << localPoint;
137  G4Exception("G4ParameterisedNavigation::ComputeStep()",
138  "GeomNav0003", FatalException, message);
139  }
140  if( motherSolid->Inside(localPoint)==kOutside )
141  {
142  std::ostringstream message;
143  message << "Point is outside Current Volume !" << G4endl
144  << " Point " << localPoint
145  << " is outside current volume " << motherPhysical->GetName()
146  << G4endl;
147  G4double estDistToSolid= motherSolid->DistanceToIn(localPoint);
148  G4cout << " Estimated isotropic distance to solid (distToIn)= "
149  << estDistToSolid;
150  if( estDistToSolid > 100.0 * motherSolid->GetTolerance() )
151  {
152  motherSolid->DumpInfo();
153  G4Exception("G4ParameterisedNavigation::ComputeStep()",
154  "GeomNav0003", FatalException, message,
155  "Point is far outside Current Volume !");
156  }
157  else
158  G4Exception("G4ParameterisedNavigation::ComputeStep()",
159  "GeomNav1002", JustWarning, message,
160  "Point is a little outside Current Volume.");
161  }
162 
163  // Compute early:
164  // a) to check whether point is (wrongly) outside
165  // (signaled if step < 0 or step == kInfinity )
166  // b) to check value against answer of daughters!
167  //
168  motherStep = motherSolid->DistanceToOut(localPoint,
169  localDirection,
170  true,
171  &motherValidExitNormal,
172  &motherExitNormal);
173 
174  if( (motherStep >= kInfinity) || (motherStep < 0.0) )
175  {
176  // Error - indication of being outside solid !!
177  //
178  fLogger->ReportOutsideMother(localPoint, localDirection, motherPhysical);
179 
180  ourStep = motherStep = 0.0;
181  exiting = true;
182  entering = false;
183 
184  // If we are outside the solid does the normal make sense?
185  validExitNormal = motherValidExitNormal;
186  exitNormal = motherExitNormal;
187 
188  *pBlockedPhysical= 0; // or motherPhysical ?
189  blockedReplicaNo= 0; // or motherReplicaNumber ?
190 
191  newSafety= 0.0;
192  return ourStep;
193  }
194  }
195 #endif
196 
197  initialNode = true;
198  noStep = true;
199 
200  // By definition, the parameterised volume is the first
201  // (and only) daughter of the mother volume
202  //
203  samplePhysical = motherLogical->GetDaughter(0);
204  samplePhysical->GetReplicationData(axis,nReplicas,width,offset,consuming);
205  fBList.Enlarge(nReplicas);
206  fBList.Reset();
207 
208  // Exiting normal optimisation
209  //
210  if (exiting && (*pBlockedPhysical==samplePhysical) && validExitNormal)
211  {
212  if (localDirection.dot(exitNormal)>=kMinExitingNormalCosine)
213  {
214  // Block exited daughter replica; Must be on boundary => zero safety
215  //
216  fBList.BlockVolume(blockedReplicaNo);
217  ourSafety = 0;
218  }
219  }
220  exiting = false;
221  entering = false;
222 
223  sampleParam = samplePhysical->GetParameterisation();
224 
225  // Loop over voxels & compute daughter safeties & intersections
226 
227  do
228  {
229  curVoxelNode = fVoxelNode;
230  curNoVolumes = curVoxelNode->GetNoContained();
231 
232  for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
233  {
234  sampleNo = curVoxelNode->GetVolume(contentNo);
235  if ( !fBList.IsBlocked(sampleNo) )
236  {
237  fBList.BlockVolume(sampleNo);
238 
239  // Call virtual methods, and copy information if needed
240  //
241  sampleSolid = IdentifyAndPlaceSolid( sampleNo, samplePhysical,
242  sampleParam );
243 
244  G4AffineTransform sampleTf(samplePhysical->GetRotation(),
245  samplePhysical->GetTranslation());
246  sampleTf.Invert();
247  const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
248  const G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
249  if ( sampleSafety<ourSafety )
250  {
251  ourSafety = sampleSafety;
252  }
253  if ( sampleSafety<=ourStep )
254  {
255  sampleDirection = sampleTf.TransformAxis(localDirection);
256  G4double sampleStep =
257  sampleSolid->DistanceToIn(samplePoint, sampleDirection);
258  if ( sampleStep<=ourStep )
259  {
260  ourStep = sampleStep;
261  entering = true;
262  exiting = false;
263  *pBlockedPhysical = samplePhysical;
264  blockedReplicaNo = sampleNo;
265 #ifdef G4VERBOSE
266  // Check to see that the resulting point is indeed in/on volume.
267  // This check could eventually be made only for successful
268  // candidate.
269 
270  if ( ( fCheck ) && ( sampleStep < kInfinity ) )
271  {
272  G4ThreeVector intersectionPoint;
273  intersectionPoint= samplePoint + sampleStep * sampleDirection;
274  EInside insideIntPt= sampleSolid->Inside(intersectionPoint);
275  if( insideIntPt != kSurface )
276  {
277  G4int oldcoutPrec = G4cout.precision(16);
278  std::ostringstream message;
279  message << "Navigator gets conflicting response from Solid."
280  << G4endl
281  << " Inaccurate solid DistanceToIn"
282  << " for solid " << sampleSolid->GetName() << G4endl
283  << " Solid gave DistanceToIn = "
284  << sampleStep << " yet returns " ;
285  if( insideIntPt == kInside )
286  message << "-kInside-";
287  else if( insideIntPt == kOutside )
288  message << "-kOutside-";
289  else
290  message << "-kSurface-";
291  message << " for this point !" << G4endl
292  << " Point = " << intersectionPoint
293  << G4endl;
294  if ( insideIntPt != kInside )
295  message << " DistanceToIn(p) = "
296  << sampleSolid->DistanceToIn(intersectionPoint);
297  if ( insideIntPt != kOutside )
298  message << " DistanceToOut(p) = "
299  << sampleSolid->DistanceToOut(intersectionPoint);
300  G4Exception("G4ParameterisedNavigation::ComputeStep()",
301  "GeomNav1002", JustWarning, message);
302  G4cout.precision(oldcoutPrec);
303  }
304  }
305 #endif
306  }
307  }
308  }
309  }
310 
311  if ( initialNode )
312  {
313  initialNode = false;
314  voxelSafety = ComputeVoxelSafety(localPoint,axis);
315  if ( voxelSafety<ourSafety )
316  {
317  ourSafety = voxelSafety;
318  }
319  if ( currentProposedStepLength<ourSafety )
320  {
321  // Guaranteed physics limited
322  //
323  noStep = false;
324  entering = false;
325  exiting = false;
326  *pBlockedPhysical = 0;
327  ourStep = kInfinity;
328  }
329  else
330  {
331  // Consider intersection with mother solid
332  //
333  if ( motherSafety<=ourStep )
334  {
335  if ( !fCheck )
336  {
337  motherStep = motherSolid->DistanceToOut(localPoint,
338  localDirection,
339  true,
340  &motherValidExitNormal,
341  &motherExitNormal);
342  }
343 
344  if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
345  {
346 #ifdef G4VERBOSE
347  fLogger->ReportOutsideMother(localPoint, localDirection, motherPhysical);
348 #endif
349  ourStep = motherStep = 0.0;
350  // Rely on the code below to set the remaining state, i.e.
351  // exiting, entering, exitNormal & validExitNormal,
352  // pBlockedPhysical etc.
353  }
354 #ifdef G4VERBOSE
355  if( motherValidExitNormal && ( fCheck || (motherStep<=ourStep)) )
356  {
357  fLogger->CheckAndReportBadNormal(motherExitNormal,
358  localPoint, localDirection,
359  motherStep, motherSolid,
360  "From motherSolid::DistanceToOut");
361  }
362 #endif
363  if ( motherStep<=ourStep )
364  {
365  ourStep = motherStep;
366  exiting = true;
367  entering = false;
368  if ( validExitNormal )
369  {
370  const G4RotationMatrix *rot = motherPhysical->GetRotation();
371  if (rot)
372  {
373  exitNormal *= rot->inverse();
374  }
375  }
376  }
377  else
378  {
379  validExitNormal = false;
380  }
381  }
382  }
383  newSafety=ourSafety;
384  }
385  if (noStep)
386  {
387  noStep = LocateNextVoxel(localPoint, localDirection, ourStep, axis);
388  }
389  } while (noStep);
390 
391  return ourStep;
392 }
G4String GetName() const
G4VPhysicalVolume * GetTopVolume() const
static const G4double kInfinity
Definition: geomdefs.hh:42
G4int GetVolume(G4int pVolumeNo) const
G4VSolid * GetSolid() const
G4VPhysicalVolume * GetDaughter(const G4int i) const
#define width
G4double GetTolerance() const
const G4RotationMatrix * GetRotation() const
int G4int
Definition: G4Types.hh:78
G4int GetNoContained() const
HepRotation inverse() const
void DumpInfo() const
void ReportOutsideMother(const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4VPhysicalVolume *motherPV, G4double tDist=30.0 *CLHEP::cm) const
G4AffineTransform & Invert()
G4BlockingList fBList
G4GLOB_DLL std::ostream G4cout
const G4String & GetName() const
virtual EInside Inside(const G4ThreeVector &p) const =0
bool G4bool
Definition: G4Types.hh:79
void BlockVolume(const G4int v)
virtual G4VPVParameterisation * GetParameterisation() const =0
G4bool IsBlocked(const G4int v) const
G4bool CheckAndReportBadNormal(const G4ThreeVector &unitNormal, const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, G4double step, const G4VSolid *solid, const char *msg) const
virtual G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const =0
static const double kMinExitingNormalCosine
Definition: geomdefs.hh:46
G4NavigationLogger * fLogger
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4ThreeVector & GetTranslation() const
G4LogicalVolume * GetLogicalVolume() const
EInside
Definition: geomdefs.hh:58
EAxis
Definition: geomdefs.hh:54
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
G4SmartVoxelNode * fVoxelNode
#define G4endl
Definition: G4ios.hh:61
double G4double
Definition: G4Types.hh:76
virtual G4double DistanceToOut(const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const =0
#define DBL_MAX
Definition: templates.hh:83
void Enlarge(const G4int nv)

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ParameterisedNavigation::LevelLocate ( G4NavigationHistory history,
const G4VPhysicalVolume blockedVol,
const G4int  blockedNum,
const G4ThreeVector globalPoint,
const G4ThreeVector globalDirection,
const G4bool  pLocatedOnEdge,
G4ThreeVector localPoint 
)
virtual

Reimplemented from G4VoxelNavigation.

Definition at line 605 of file G4ParameterisedNavigation.cc.

612 {
613  G4SmartVoxelHeader *motherVoxelHeader;
614  G4SmartVoxelNode *motherVoxelNode;
615  G4VPhysicalVolume *motherPhysical, *pPhysical;
616  G4VPVParameterisation *pParam;
617  G4LogicalVolume *motherLogical;
618  G4VSolid *pSolid;
619  G4ThreeVector samplePoint;
620  G4int voxelNoDaughters, replicaNo;
621 
622  motherPhysical = history.GetTopVolume();
623  motherLogical = motherPhysical->GetLogicalVolume();
624  motherVoxelHeader = motherLogical->GetVoxelHeader();
625 
626  // Find the voxel containing the point
627  //
628  motherVoxelNode = ParamVoxelLocate(motherVoxelHeader,localPoint);
629 
630  voxelNoDaughters = motherVoxelNode->GetNoContained();
631  if ( voxelNoDaughters==0 ) { return false; }
632 
633  pPhysical = motherLogical->GetDaughter(0);
634  pParam = pPhysical->GetParameterisation();
635 
636  // Save parent history in touchable history
637  // ... for use as parent t-h in ComputeMaterial method of param
638  //
639  G4TouchableHistory parentTouchable( history );
640 
641  // Search replicated daughter volume
642  //
643  for ( G4int sampleNo=voxelNoDaughters-1; sampleNo>=0; sampleNo-- )
644  {
645  replicaNo = motherVoxelNode->GetVolume(sampleNo);
646  if ( (replicaNo!=blockedNum) || (pPhysical!=blockedVol) )
647  {
648  // Obtain solid (as it can vary) and obtain its parameters
649  //
650  pSolid = IdentifyAndPlaceSolid( replicaNo, pPhysical, pParam );
651 
652  // Setup history
653  //
654  history.NewLevel(pPhysical, kParameterised, replicaNo);
655  samplePoint = history.GetTopTransform().TransformPoint(globalPoint);
656  if ( !G4AuxiliaryNavServices::CheckPointOnSurface( pSolid, samplePoint,
657  globalDirection, history.GetTopTransform(), pLocatedOnEdge) )
658  {
659  history.BackLevel();
660  }
661  else
662  {
663  // Enter this daughter
664  //
665  localPoint = samplePoint;
666 
667  // Set the correct copy number in physical
668  //
669  pPhysical->SetCopyNo(replicaNo);
670 
671  // Set the correct solid and material in Logical Volume
672  //
673  G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
674  pLogical->SetSolid(pSolid);
675  pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
676  pPhysical, &parentTouchable) );
677  return true;
678  }
679  }
680  }
681  return false;
682 }
G4SmartVoxelHeader * GetVoxelHeader() const
G4VPhysicalVolume * GetTopVolume() const
virtual G4Material * ComputeMaterial(const G4int repNo, G4VPhysicalVolume *currentVol, const G4VTouchable *parentTouch=0)
static G4bool CheckPointOnSurface(const G4VSolid *sampleSolid, const G4ThreeVector &localPoint, const G4ThreeVector *globalDirection, const G4AffineTransform &sampleTransform, const G4bool locatedOnEdge)
void UpdateMaterial(G4Material *pMaterial)
G4int GetVolume(G4int pVolumeNo) const
G4VPhysicalVolume * GetDaughter(const G4int i) const
void SetSolid(G4VSolid *pSolid)
G4SmartVoxelNode * ParamVoxelLocate(G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
int G4int
Definition: G4Types.hh:78
G4int GetNoContained() const
virtual G4VPVParameterisation * GetParameterisation() const =0
virtual void SetCopyNo(G4int CopyNo)=0
void NewLevel(G4VPhysicalVolume *pNewMother, EVolume vType=kNormal, G4int nReplica=-1)
G4ThreeVector TransformPoint(const G4ThreeVector &vec) const
G4LogicalVolume * GetLogicalVolume() const
const G4AffineTransform & GetTopTransform() const

Here is the call graph for this function:

Here is the caller graph for this function:

G4SmartVoxelNode* G4ParameterisedNavigation::ParamVoxelLocate ( G4SmartVoxelHeader pHead,
const G4ThreeVector localPoint 
)
inline

Here is the caller graph for this function:


The documentation for this class was generated from the following files: