Import Geant4 0.0.0 source tree

2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
@@ -0,0 +1,195 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4NormalNavigation.cc,v 2.0 1998/07/02 17:06:37 gunter Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+//
+// class G4NormalNavigation Implementation
+//
+
+#include "G4NormalNavigation.hh"
+
+G4double G4NormalNavigation::ComputeStep(const G4ThreeVector &localPoint,
+			     const G4ThreeVector &localDirection,
+			     const G4double currentProposedStepLength,
+			     G4double &newSafety,
+			     G4NavigationHistory &history,
+			     G4bool &validExitNormal,
+			     G4ThreeVector &exitNormal,
+			     G4bool &exiting,
+			     G4bool &entering,
+                             G4VPhysicalVolume *(*pBlockedPhysical),
+                             G4int &blockedReplicaNo)
+{
+
+	G4VPhysicalVolume *motherPhysical,*samplePhysical,*blockedExitedVol=0;
+	G4LogicalVolume *motherLogical;
+	G4VSolid *motherSolid;
+	G4ThreeVector sampleDirection;
+	G4double ourStep=currentProposedStepLength,motherSafety,ourSafety;
+	G4int localNoDaughters,sampleNo;
+
+	motherPhysical=history.GetTopVolume();
+	motherLogical=motherPhysical->GetLogicalVolume();
+
+	motherSolid=motherLogical->GetSolid();
+
+//
+// Compute mother safety
+//
+	motherSafety=motherSolid->DistanceToOut(localPoint);
+	ourSafety=motherSafety; // Working isotropic safety
+	
+//
+// Compute daughter safeties & intersections
+//
+
+// Exiting normal optimisation
+	if (exiting&&validExitNormal)
+		{
+		if (localDirection.dot(exitNormal)>=kMinExitingNormalCosine)
+			{
+// Block exited daughter volume
+			blockedExitedVol=*pBlockedPhysical;
+			ourSafety=0;
+			}
+		}
+
+	exiting=false;
+	entering=false;
+
+	localNoDaughters=motherLogical->GetNoDaughters();
+	for (sampleNo=localNoDaughters-1;sampleNo>=0;sampleNo--)
+		{
+		samplePhysical=motherLogical->GetDaughter(sampleNo);
+		if (samplePhysical!=blockedExitedVol)
+			{
+			samplePhysical->Setup(motherPhysical);
+			G4AffineTransform sampleTf(samplePhysical->GetRotation(),
+						   samplePhysical->GetTranslation());
+			sampleTf.Invert();
+			const G4ThreeVector samplePoint=sampleTf.TransformPoint(localPoint);
+			const G4VSolid *sampleSolid=samplePhysical
+						->GetLogicalVolume()
+						->GetSolid();
+			const G4double sampleSafety=sampleSolid
+						->DistanceToIn(samplePoint);
+			if (sampleSafety<ourSafety)
+				{
+			    	ourSafety=sampleSafety;
+				}
+			if (sampleSafety<=ourStep)
+				{
+				  sampleDirection=sampleTf.TransformAxis(localDirection);
+				  const G4double sampleStep=sampleSolid
+				               	->DistanceToIn(samplePoint,
+							sampleDirection);
+			    	if (sampleStep<=ourStep)
+					{
+					ourStep=sampleStep;
+					entering=true;
+					exiting=false;
+					*pBlockedPhysical=samplePhysical;
+					blockedReplicaNo=-1;
+					}
+				}
+			}
+		}
+	if (currentProposedStepLength<ourSafety)
+		{
+//
+// Guaranteed physics limited
+//
+		entering=false;
+		exiting=false;
+		*pBlockedPhysical=0;
+		ourStep=kInfinity;
+		}
+	else
+		{
+//
+// Compute mother intersection if required
+//
+		if (motherSafety<=ourStep)
+			{
+			G4double motherStep=motherSolid
+					->DistanceToOut(localPoint,
+							localDirection,
+							true,
+							&validExitNormal,
+							&exitNormal);
+			if (motherStep<=ourStep)
+				{
+				ourStep=motherStep;
+				exiting=true;
+				entering=false;
+				if (validExitNormal)
+					{
+					const G4RotationMatrix *rot=motherPhysical->GetRotation();
+					if (rot)
+						{
+						exitNormal*=rot->inverse();
+						}
+					}
+				}
+			else
+				{
+				validExitNormal=false;
+				}
+			}
+		}
+	newSafety=ourSafety;
+	return ourStep;
+}
+
+G4double G4NormalNavigation::ComputeSafety(const G4ThreeVector &localPoint,
+			     const G4NavigationHistory &history,
+			     const G4double currentProposedStepLength)
+{
+     G4VPhysicalVolume *motherPhysical,*samplePhysical;
+     G4LogicalVolume *motherLogical;
+     G4VSolid *motherSolid;
+     G4double ourStep=currentProposedStepLength,motherSafety,ourSafety;
+     G4int localNoDaughters,sampleNo;
+
+     motherPhysical=history.GetTopVolume();
+     motherLogical=motherPhysical->GetLogicalVolume();
+     motherSolid=motherLogical->GetSolid();
+
+   //
+   // Compute mother safety
+   //
+     motherSafety=motherSolid->DistanceToOut(localPoint);
+     ourSafety=motherSafety; // Working isotropic safety
+
+   //
+   // Compute daughter safeties 
+   //
+     localNoDaughters=motherLogical->GetNoDaughters();
+     for (sampleNo=localNoDaughters-1;sampleNo>=0;sampleNo--)
+	{
+	    samplePhysical=motherLogical->GetDaughter(sampleNo);
+
+	    samplePhysical->Setup(motherPhysical);
+	    G4AffineTransform sampleTf(samplePhysical->GetRotation(),
+				       samplePhysical->GetTranslation());
+	    sampleTf.Invert();
+	    const G4ThreeVector samplePoint=sampleTf.TransformPoint(localPoint);
+	    const G4VSolid *sampleSolid=samplePhysical
+				    ->GetLogicalVolume()
+				    ->GetSolid();
+	    const G4double sampleSafety=sampleSolid
+				    ->DistanceToIn(samplePoint);
+	    if (sampleSafety<ourSafety)
+		{
+		    ourSafety=sampleSafety;
+		}
+	}
+
+     return ourSafety;
+}