Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
hep.geant4.jni.G4VPhysicalVolume

Packages that use G4VPhysicalVolume
hep.geant4.jni   
 

Uses of G4VPhysicalVolume in hep.geant4.jni
 

Subclasses of G4VPhysicalVolume in hep.geant4.jni
 class G4PVDivision
           
 class G4PVParameterised
           
 class G4PVPlacement
           
 class G4PVReplica
           
 

Methods in hep.geant4.jni that return G4VPhysicalVolume
protected  G4VPhysicalVolume G4VReadOutGeometry.build()
           
 G4VPhysicalVolume G4VUserDetectorConstruction.construct()
           
 G4VPhysicalVolume G4VPVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, EAxis pAxis, double width, double offset)
           
 G4VPhysicalVolume G4PVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, EAxis pAxis, double width, double offset)
           
 G4VPhysicalVolume G4VPVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, EAxis pAxis, int nReplicas, double offset)
           
 G4VPhysicalVolume G4PVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, EAxis pAxis, int nReplicas, double offset)
           
 G4VPhysicalVolume G4VPVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMother, EAxis pAxis, int nReplicas, double width, double offset)
           
 G4VPhysicalVolume G4PVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMother, EAxis pAxis, int nReplicas, double width, double offset)
           
 G4VPhysicalVolume G4VPVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, G4VPVParameterisation param)
           
 G4VPhysicalVolume G4PVDivisionFactory.createPVDivision(String pName, G4LogicalVolume pLogical, G4LogicalVolume pMotherLogical, G4VPVParameterisation param)
           
 G4VPhysicalVolume G4PhysicalVolumeModel.getCurrentPV()
           
 G4VPhysicalVolume G4GeomTestOvershootList.getDaughter()
           
 G4VPhysicalVolume G4LogicalVolume.getDaughter(int i)
           
 G4VPhysicalVolume G4GeomTestOverlapList.getDaughter1()
           
 G4VPhysicalVolume G4GeomTestOverlapList.getDaughter2()
           
 G4VPhysicalVolume G4FastTrack.getEnvelopePhysicalVolume()
           
 G4VPhysicalVolume G4SteppingManager.getfCurrentVolume()
           
 G4VPhysicalVolume G4PhysicalVolumesPair.getFirst()
           
 G4VPhysicalVolume G4GeomTestErrorList.getMother()
           
 G4VPhysicalVolume G4Track.getNextVolume()
           
 G4VPhysicalVolume G4TransportationManager.getParallelWorld(String worldName)
           
 G4VPhysicalVolume G4StepPoint.getPhysicalVolume()
           
 G4VPhysicalVolume G4PhysicalVolumeNodeID.getPhysicalVolume()
           
 G4VPhysicalVolume G4NavigationLevelRep.getPhysicalVolume()
           
 G4VPhysicalVolume G4NavigationLevel.getPhysicalVolume()
           
 G4VPhysicalVolume G4GeometryCell.getPhysicalVolume()
           
 G4VPhysicalVolume G4VReadOutGeometry.getROWorld()
           
 G4VPhysicalVolume G4PhysicalVolumesPair.getSecond()
           
 G4VPhysicalVolume G4VFlavoredParallelWorld.getThePhysicalVolumeWorld()
           
 G4VPhysicalVolume G4PhysicalVolumeModel.getTopPhysicalVolume()
           
 G4VPhysicalVolume G4NavigationHistory.getTopVolume()
           
 G4VPhysicalVolume G4VTouchable.getVolume()
           
 G4VPhysicalVolume G4Track.getVolume()
           
 G4VPhysicalVolume G4TouchableHistoryReference.getVolume()
           
 G4VPhysicalVolume G4TouchableHistoryHandle.getVolume()
           
 G4VPhysicalVolume G4TouchableHistory.getVolume()
           
 G4VPhysicalVolume G4TouchableHandle.getVolume()
           
 G4VPhysicalVolume G4GRSVolume.getVolume()
           
 G4VPhysicalVolume G4VTouchable.getVolume(int depth)
           
 G4VPhysicalVolume G4TouchableHistoryReference.getVolume(int depth)
           
 G4VPhysicalVolume G4TouchableHistoryHandle.getVolume(int depth)
           
 G4VPhysicalVolume G4TouchableHistory.getVolume(int depth)
           
 G4VPhysicalVolume G4TouchableHandle.getVolume(int depth)
           
 G4VPhysicalVolume G4NavigationHistory.getVolume(int n)
           
 G4VPhysicalVolume G4GRSVolume.getVolume(int depth)
           
 G4VPhysicalVolume G4LogicalBorderSurface.getVolume1()
           
 G4VPhysicalVolume G4LogicalBorderSurface.getVolume2()
           
 G4VPhysicalVolume G4Region.getWorldPhysical()
           
 G4VPhysicalVolume G4WeightWindowStore.getWorldVolume()
           
 G4VPhysicalVolume G4VWeightWindowStore.getWorldVolume()
           
 G4VPhysicalVolume G4VIStore.getWorldVolume()
           
 G4VPhysicalVolume G4Navigator.getWorldVolume()
           
 G4VPhysicalVolume G4IStore.getWorldVolume()
           
 G4VPhysicalVolume G4TransportationManager.isWorldExisting(String worldName)
           
 G4VPhysicalVolume G4Navigator.locateGlobalPointAndSetup(G4ThreeVector point)
           
 G4VPhysicalVolume G4Navigator.locateGlobalPointAndSetup(G4ThreeVector point, G4ThreeVector direction)
           
 G4VPhysicalVolume G4Navigator.locateGlobalPointAndSetup(G4ThreeVector point, G4ThreeVector direction, boolean pRelativeSearch)
           
 G4VPhysicalVolume G4Navigator.locateGlobalPointAndSetup(G4ThreeVector point, G4ThreeVector direction, boolean pRelativeSearch, boolean ignoreDirection)
           
 G4VPhysicalVolume G4Navigator.resetHierarchyAndLocate(G4ThreeVector point, G4ThreeVector direction, G4TouchableHistory h)
           
 

Methods in hep.geant4.jni with parameters of type G4VPhysicalVolume
 G4CellScorer G4CellScorerStore.addCellScorer(G4VPhysicalVolume vol)
           
 G4CellScorer G4CellScorerStore.addCellScorer(G4VPhysicalVolume vol, int repnum)
           
 void G4LogicalVolume.addDaughter(G4VPhysicalVolume p)
           
 void G4IStore.addImportanceGeometryCell(double importance, G4VPhysicalVolume arg1)
           
 void G4IStore.addImportanceGeometryCell(double importance, G4VPhysicalVolume arg1, int aRepNum)
           
 boolean G4Region.belongsTo(G4VPhysicalVolume thePhys)
           
 void G4IStore.changeImportance(double importance, G4VPhysicalVolume arg1)
           
 void G4IStore.changeImportance(double importance, G4VPhysicalVolume arg1, int aRepNum)
           
 boolean G4SensitiveVolumeList.checkPV(G4VPhysicalVolume pvp)
           
 boolean G4GeometryManager.closeGeometry(boolean pOptimise, boolean verbose, G4VPhysicalVolume vol)
           
 void G4VPVParameterisation.computeDimensions(G4Box arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationBoxZ.computeDimensions(G4Box box, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationBoxY.computeDimensions(G4Box box, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationBoxX.computeDimensions(G4Box box, int copyNo, G4VPhysicalVolume physVol)
           
 void G4VPVParameterisation.computeDimensions(G4Cons arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationConsZ.computeDimensions(G4Cons tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationConsRho.computeDimensions(G4Cons tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationConsPhi.computeDimensions(G4Cons tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4VPVParameterisation.computeDimensions(G4Hype arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VPVParameterisation.computeDimensions(G4Orb arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VPVParameterisation.computeDimensions(G4Para arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationParaZ.computeDimensions(G4Para para, int copyNo, G4VPhysicalVolume pv)
           
 void G4ParameterisationParaY.computeDimensions(G4Para para, int copyNo, G4VPhysicalVolume pv)
           
 void G4ParameterisationParaX.computeDimensions(G4Para para, int copyNo, G4VPhysicalVolume pv)
           
 void G4VPVParameterisation.computeDimensions(G4Polycone arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationPolyconeZ.computeDimensions(G4Polycone pcone, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyconeRho.computeDimensions(G4Polycone pcone, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyconePhi.computeDimensions(G4Polycone pcone, int copyNo, G4VPhysicalVolume physVol)
           
 void G4VPVParameterisation.computeDimensions(G4Polyhedra arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationPolyhedraZ.computeDimensions(G4Polyhedra phedra, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyhedraRho.computeDimensions(G4Polyhedra phedra, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyhedraPhi.computeDimensions(G4Polyhedra phedra, int copyNo, G4VPhysicalVolume physVol)
           
 void G4VPVParameterisation.computeDimensions(G4Sphere arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VPVParameterisation.computeDimensions(G4Torus arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VPVParameterisation.computeDimensions(G4Trap arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VPVParameterisation.computeDimensions(G4Trd arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationTrdZ.computeDimensions(G4Trd trd, int copyNo, G4VPhysicalVolume pv)
           
 void G4ParameterisationTrdY.computeDimensions(G4Trd trd, int copyNo, G4VPhysicalVolume pv)
           
 void G4ParameterisationTrdX.computeDimensions(G4Trd trd, int copyNo, G4VPhysicalVolume pv)
           
 void G4VPVParameterisation.computeDimensions(G4Tubs arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4ParameterisationTubsZ.computeDimensions(G4Tubs tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTubsRho.computeDimensions(G4Tubs tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTubsPhi.computeDimensions(G4Tubs tubs, int copyNo, G4VPhysicalVolume physVol)
           
 void G4VTwistedFaceted.computeDimensions(G4VPVParameterisation arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4VSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4UnionSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4TwistedTubs.computeDimensions(G4VPVParameterisation arg0, int arg1, G4VPhysicalVolume arg2)
           
 void G4Tubs.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Trd.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Trap.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Torus.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Tet.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4SubtractionSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Sphere.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4ReflectedSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Polyhedra.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Polycone.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Para.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Orb.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4IntersectionSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Hype.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4DisplacedSolid.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Cons.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 void G4Box.computeDimensions(G4VPVParameterisation p, int n, G4VPhysicalVolume pRep)
           
 G4Material G4VPVParameterisation.computeMaterial(int repNo, G4VPhysicalVolume currentVol)
           
 G4Material G4VPVParameterisation.computeMaterial(int repNo, G4VPhysicalVolume currentVol, G4VTouchable parentTouch)
           
 G4VSolid G4VPVParameterisation.computeSolid(int arg0, G4VPhysicalVolume arg1)
           
 G4VSolid G4VDivisionParameterisation.computeSolid(int arg0, G4VPhysicalVolume arg1)
           
 double G4PropagatorInField.computeStep(G4FieldTrack pFieldTrack, double pCurrentProposedStepLength, SWIGTYPE_p_double pNewSafety, G4VPhysicalVolume pPhysVol)
           
 void G4VPVParameterisation.computeTransformation(int arg0, G4VPhysicalVolume arg1)
           
 void G4VDivisionParameterisation.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ReplicaNavigation.computeTransformation(int replicaNo, G4VPhysicalVolume pVol)
           
 void G4ParameterisationTubsZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTubsRho.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTubsPhi.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTrdZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTrdY.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationTrdX.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyhedraZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyhedraRho.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyhedraPhi.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyconeZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyconeRho.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationPolyconePhi.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationParaZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationParaY.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationParaX.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationConsZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationConsRho.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationConsPhi.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationBoxZ.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationBoxY.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ParameterisationBoxX.computeTransformation(int copyNo, G4VPhysicalVolume physVol)
           
 void G4ReplicaNavigation.computeTransformation(int replicaNo, G4VPhysicalVolume pVol, G4ThreeVector point)
           
 void G4RunManagerKernel.defineWorldVolume(G4VPhysicalVolume worldVol)
           
 void G4RunManager.defineWorldVolume(G4VPhysicalVolume worldVol)
           
 void G4RunManagerKernel.defineWorldVolume(G4VPhysicalVolume worldVol, boolean topologyIsChanged)
           
 void G4RunManager.defineWorldVolume(G4VPhysicalVolume worldVol, boolean topologyIsChanged)
           
 double G4ReplicaNavigation.distanceToOut(G4VPhysicalVolume pVol, int replicaNo, G4ThreeVector localPoint)
           
 double G4ReplicaNavigation.distanceToOut(G4VPhysicalVolume pVol, int replicaNo, G4ThreeVector localPoint, G4ThreeVector localDirection)
           
 void G4VVisManager.draw(G4VPhysicalVolume arg0, G4VisAttributes arg1)
           
 void G4VVisManager.draw(G4VPhysicalVolume arg0, G4VisAttributes arg1, G4Transform3D objectTransformation)
           
 G4FieldManager G4PropagatorInField.findAndSetFieldManager(G4VPhysicalVolume pCurrentPhysVol)
           
static long G4VPhysicalVolume.getCPtr(G4VPhysicalVolume obj)
           
 double G4IStore.getImportance(G4VPhysicalVolume arg0)
           
 double G4IStore.getImportance(G4VPhysicalVolume arg0, int aRepNum)
           
 G4Navigator G4TransportationManager.getNavigator(G4VPhysicalVolume aWorld)
           
 void G4GeomTestErrorList.getOneDaughtPoints(G4VPhysicalVolume daught, int i, G4ThreeVector s1, G4ThreeVector s2)
           
static G4LogicalBorderSurface G4LogicalBorderSurface.getSurface(G4VPhysicalVolume vol1, G4VPhysicalVolume vol2)
           
 boolean G4FastSimulationManager.insertGhostHereIfNecessary(G4VPhysicalVolume arg0, G4ParticleDefinition arg1)
           
 EInside G4ReplicaNavigation.inside(G4VPhysicalVolume pVol, int replicaNo, G4ThreeVector localPoint)
           
 boolean G4LogicalVolume.isAncestor(G4VPhysicalVolume p)
           
 boolean G4LogicalVolume.isDaughter(G4VPhysicalVolume p)
           
 boolean G4VPVDivisionFactory.isPVDivision(G4VPhysicalVolume pv)
           
 boolean G4PVDivisionFactory.isPVDivision(G4VPhysicalVolume pv)
           
 boolean G4VoxelNavigation.levelLocate(G4NavigationHistory history, G4VPhysicalVolume blockedVol, int blockedNum, G4ThreeVector globalPoint, G4ThreeVector globalDirection, boolean pLocatedOnEdge, G4ThreeVector localPoint)
           
 boolean G4ReplicaNavigation.levelLocate(G4NavigationHistory history, G4VPhysicalVolume blockedVol, int blockedNum, G4ThreeVector globalPoint, G4ThreeVector globalDirection, boolean pLocatedOnEdge, G4ThreeVector localPoint)
           
 boolean G4ParameterisedNavigation.levelLocate(G4NavigationHistory history, G4VPhysicalVolume blockedVol, int blockedNum, G4ThreeVector globalPoint, G4ThreeVector globalDirection, boolean pLocatedOnEdge, G4ThreeVector localPoint)
           
 boolean G4NormalNavigation.levelLocate(G4NavigationHistory history, G4VPhysicalVolume blockedVol, int blockedNum, G4ThreeVector globalPoint, G4ThreeVector globalDirection, boolean pLocatedOnEdge, G4ThreeVector localPoint)
           
 void G4NavigationHistory.newLevel(G4VPhysicalVolume pNewMother)
           
 void G4NavigationHistory.newLevel(G4VPhysicalVolume pNewMother, EVolume vType)
           
 void G4NavigationHistory.newLevel(G4VPhysicalVolume pNewMother, EVolume vType, int nReplica)
           
 void G4GeometryManager.openGeometry(G4VPhysicalVolume vol)
           
 void G4PropagatorInField.printStatus(G4FieldTrack startFT, G4FieldTrack currentFT, double requestStep, double safety, int step, G4VPhysicalVolume startVolume)
           
 void G4LogicalVolume.removeDaughter(G4VPhysicalVolume p)
           
 boolean G4VPersistencyManager.retrieve(G4VPhysicalVolume theWorld)
           
 void G4PhysicalVolumesPair.setFirst(G4VPhysicalVolume value)
           
 void G4NavigationHistory.setFirstEntry(G4VPhysicalVolume pVol)
           
 void G4LogicalBorderSurface.setPhysicalVolumes(G4VPhysicalVolume vol1, G4VPhysicalVolume vol2)
           
 void G4PhysicalVolumesPair.setSecond(G4VPhysicalVolume value)
           
 void G4LogicalBorderSurface.setVolume1(G4VPhysicalVolume vol1)
           
 void G4LogicalBorderSurface.setVolume2(G4VPhysicalVolume vol2)
           
 void G4Region.setWorld(G4VPhysicalVolume wp)
           
 void G4Navigator.setWorldVolume(G4VPhysicalVolume pWorld)
           
 boolean G4VPersistencyManager.store(G4VPhysicalVolume theWorld)
           
 void G4RegionStore.updateMaterialList(G4VPhysicalVolume currentWorld)
           
 void G4VTouchable.updateYourself(G4VPhysicalVolume pPhysVol)
           
 void G4TouchableHistoryReference.updateYourself(G4VPhysicalVolume pPhysVol)
           
 void G4TouchableHistoryHandle.updateYourself(G4VPhysicalVolume pPhysVol)
           
 void G4TouchableHistory.updateYourself(G4VPhysicalVolume pPhysVol)
           
 void G4TouchableHandle.updateYourself(G4VPhysicalVolume pPhysVol)
           
 void G4VTouchable.updateYourself(G4VPhysicalVolume pPhysVol, G4NavigationHistory history)
           
 void G4TouchableHistoryReference.updateYourself(G4VPhysicalVolume pPhysVol, G4NavigationHistory history)
           
 void G4TouchableHistoryHandle.updateYourself(G4VPhysicalVolume pPhysVol, G4NavigationHistory history)
           
 void G4TouchableHistory.updateYourself(G4VPhysicalVolume pPhysVol, G4NavigationHistory history)
           
 void G4TouchableHandle.updateYourself(G4VPhysicalVolume pPhysVol, G4NavigationHistory history)
           
 

Constructors in hep.geant4.jni with parameters of type G4VPhysicalVolume
G4GeometryCell(G4VPhysicalVolume aVolume, int RepNum)
           
G4GeomTestErrorList(G4VPhysicalVolume theMother)
           
G4GeomTestOverlapList(G4VPhysicalVolume theMother, int theDaughter1, int theDaughter2)
           
G4GeomTestOvershootList(G4VPhysicalVolume theMother, int theDaughter)
           
G4GeomTestVolume(G4VPhysicalVolume theTarget, G4GeomTestLogger theLogger)
           
G4GeomTestVolume(G4VPhysicalVolume theTarget, G4GeomTestLogger theLogger, double theTolerance)
           
G4GRSVolume(G4VPhysicalVolume pVol, G4RotationMatrix pRot, G4ThreeVector tlate)
           
G4IStore(G4VPhysicalVolume worldvolume)
           
G4LogicalBorderSurface(String name, G4VPhysicalVolume vol1, G4VPhysicalVolume vol2, G4SurfaceProperty surfaceProperty)
           
G4NavigationLevel(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform newT, EVolume newVolTp)
           
G4NavigationLevel(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform newT, EVolume newVolTp, int newRepNo)
           
G4NavigationLevel(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform levelAbove, G4AffineTransform relativeCurrent, EVolume newVolTp)
           
G4NavigationLevel(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform levelAbove, G4AffineTransform relativeCurrent, EVolume newVolTp, int newRepNo)
           
G4NavigationLevelRep(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform newT, EVolume newVolTp)
           
G4NavigationLevelRep(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform newT, EVolume newVolTp, int newRepNo)
           
G4NavigationLevelRep(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform levelAbove, G4AffineTransform relativeCurrent, EVolume newVolTp)
           
G4NavigationLevelRep(G4VPhysicalVolume newPtrPhysVol, G4AffineTransform levelAbove, G4AffineTransform relativeCurrent, EVolume newVolTp, int newRepNo)
           
G4ParallelNavigator(G4VPhysicalVolume aWorldVolume)
           
G4ParallelWorld(G4VPhysicalVolume worldvolume)
           
G4PhysicalVolumeModel(G4VPhysicalVolume arg0)
           
G4PhysicalVolumeModel(G4VPhysicalVolume arg0, int requestedDepth)
           
G4PhysicalVolumeModel(G4VPhysicalVolume arg0, int requestedDepth, G4Transform3D modelTransformation)
           
G4PhysicalVolumeModel(G4VPhysicalVolume arg0, int requestedDepth, G4Transform3D modelTransformation, G4ModelingParameters arg3)
           
G4PhysicalVolumeModel(G4VPhysicalVolume arg0, int requestedDepth, G4Transform3D modelTransformation, G4ModelingParameters arg3, boolean useFullExtent)
           
G4PhysicalVolumeNodeID(G4VPhysicalVolume pPV)
           
G4PhysicalVolumeNodeID(G4VPhysicalVolume pPV, int iCopyNo)
           
G4PhysicalVolumesPair(G4VPhysicalVolume first, G4VPhysicalVolume second)
           
G4PVParameterised(String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, EAxis pAxis, int nReplicas, G4VPVParameterisation pParam)
           
G4PVParameterised(String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, EAxis pAxis, int nReplicas, G4VPVParameterisation pParam, boolean pSurfChk)
           
G4PVPlacement(G4RotationMatrix pRot, G4ThreeVector tlate, String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, boolean pMany, int pCopyNo)
           
G4PVPlacement(G4RotationMatrix pRot, G4ThreeVector tlate, String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, boolean pMany, int pCopyNo, boolean pSurfChk)
           
G4PVPlacement(G4Transform3D Transform3D, String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, boolean pMany, int pCopyNo)
           
G4PVPlacement(G4Transform3D Transform3D, String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, boolean pMany, int pCopyNo, boolean pSurfChk)
           
G4PVReplica(String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, EAxis pAxis, int nReplicas, double width)
           
G4PVReplica(String pName, G4LogicalVolume pLogical, G4VPhysicalVolume pMother, EAxis pAxis, int nReplicas, double width, double offset)
           
G4WeightWindowStore(G4VPhysicalVolume worldvolume)
           
 

Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    
Copyright © 2000-2007 FreeHEP. All Rights Reserved.