Dependency cycles:  ok. No dependency cycle.
Undefined types
---------------

The definition of the following types where not found. Use the extra_headers configuration parameters to specify the header files that defines.

The auto_veto parameter is set to true, generation of the wrappers that would have needed theses types were skipped.

G4Allocator<G4Event>
G4Allocator<G4HCofThisEvent>
G4Allocator<G4PrimaryParticle>
G4Allocator<G4PrimaryVertex>
G4Allocator<G4TrajectoryContainer>
G4ChordFinder
G4DCtable
G4DecayTable
G4GeomSplitter<G4LVData>
G4GeomSplitter<G4PVData>
G4GeomSplitter<G4ReplicaData>
G4MTcoutDestination
G4PropagatorInField
G4UIbridge
G4UIcommandTree
G4UIsession
G4UserPhysicsListMessenger
G4UserWorkerThreadInitialization
G4VAuxiliaryTrackInformation
G4VGraphicsScene
G4VScoreColorMap
G4VTrackingManager
G4VUPLSplitter<G4VMPLData>
G4VUPLSplitter<G4VUPLData>
G4VUserParallelWorld
G4VUserPrimaryParticleInformation
G4VUserPrimaryVertexInformation
G4VisExtent
G4VoxelLimits
G4WorkerThread
__void__
_opaque_pthread_t
std::__thread_id
std::__wrap_iter<G4Navigator **>
std::__wrap_iter<G4VPhysicalVolume **>
std::basic_istream
std::basic_istringstream
std::basic_ostream
std::map<G4LogicalVolume *,std::vector<G4GDMLAuxStructType,std::allocator<G4GDMLAuxStructType>>,std::less<G4LogicalVolume *>,std::allocator<std::pair<G4LogicalVolume *const,std::vector<G4GDMLAuxStructType,std::allocator<G4GDMLAuxStructType>>>>>
std::map<G4Material *,double,std::less<G4Material *>,std::allocator<std::pair<G4Material *const,double>>>
std::map<G4String,G4AttDef,std::less<G4String>,std::allocator<std::pair<const G4String,G4AttDef>>>
std::map<G4String,G4Colour,std::less<G4String>,std::allocator<std::pair<const G4String,G4Colour>>>
std::map<G4String,std::vector<G4LogicalVolume *,std::allocator<G4LogicalVolume *>>,std::less<G4String>,std::allocator<std::pair<const G4String,std::vector<G4LogicalVolume *,std::allocator<G4LogicalVolume *>>>>>
std::map<const G4LogicalVolume *,G4LogicalSkinSurface *,std::less<const G4LogicalVolume *>,std::allocator<std::pair<const G4LogicalVolume *const,G4LogicalSkinSurface *>>>
std::map<int,G4VAuxiliaryTrackInformation *,std::less<int>,std::allocator<std::pair<const int,G4VAuxiliaryTrackInformation *>>>
std::map<int,G4VPhysicalVolume *,std::less<int>,std::allocator<std::pair<const int,G4VPhysicalVolume *>>>
std::map<std::pair<const G4VPhysicalVolume *,const G4VPhysicalVolume *>,G4LogicalBorderSurface *,std::less<std::pair<const G4VPhysicalVolume *,const G4VPhysicalVolume *>>,std::allocator<std::pair<const std::pair<const G4VPhysicalVolume *,const G4VPhysicalVolume *>,G4LogicalBorderSurface *>>>
std::queue<long,std::deque<long,std::allocator<long>>>

Auto-vetoed functions
---------------------
void G4LogicalVolume::G4LogicalVolume(__void__ &)
const G4LVManager & G4LogicalVolume::GetSubInstanceManager()
G4Pid_t G4Threading::G4GetPidId()
G4bool G4Threading::G4SetPinAffinity(G4int, G4NativeThread &)
void G4ParticleDefinition::G4ParticleDefinition(const G4String &, G4double, G4double, G4double, G4int, G4int, G4int, G4int, G4int, G4int, const G4String &, G4int, G4int, G4int, G4bool, G4double, G4DecayTable *, G4bool, const G4String &, G4int, G4double)
G4DecayTable * G4ParticleDefinition::GetDecayTable()
void G4ParticleDefinition::SetDecayTable(G4DecayTable *)
G4VTrackingManager * G4ParticleDefinition::GetTrackingManager()
void G4ParticleDefinition::SetTrackingManager(G4VTrackingManager *)
void G4FieldManager::G4FieldManager(G4Field *, G4ChordFinder *, G4bool)
void G4FieldManager::SetChordFinder(G4ChordFinder *)
G4ChordFinder * G4FieldManager::GetChordFinder()
const G4ChordFinder * G4FieldManager::GetChordFinder()
G4Allocator<G4HCofThisEvent> *& anHCoTHAllocator_G4MT_TLS_()
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::Hep3Vector &)
std::istream & CLHEP::operator>>(std::istream &, CLHEP::Hep3Vector &)
std::ostream & operator<<(std::ostream &, const G4AffineTransform &)
const std::map<G4Material *,G4double> & G4Material::GetMatComponents()
void G4Track::SetAuxiliaryTrackInformation(G4int, G4VAuxiliaryTrackInformation *)
G4VAuxiliaryTrackInformation * G4Track::GetAuxiliaryTrackInformation(G4int)
std::map<G4int,G4VAuxiliaryTrackInformation *> * G4Track::GetAuxiliaryTrackInformationMap()
void G4VUserDetectorConstruction::RegisterParallelWorld(G4VUserParallelWorld *)
G4VUserParallelWorld * G4VUserDetectorConstruction::GetParallelWorld(G4int)
G4VUserPrimaryParticleInformation * G4PrimaryParticle::GetUserInformation()
void G4PrimaryParticle::SetUserInformation(G4VUserPrimaryParticleInformation *)
G4Allocator<G4PrimaryParticle> *& aPrimaryParticleAllocator()
void G4PrimaryParticle::SetUserInformation(G4VUserPrimaryParticleInformation *)
G4VUserPrimaryParticleInformation * G4PrimaryParticle::GetUserInformation()
void G4PrimaryVertex::SetUserInformation(G4VUserPrimaryVertexInformation *)
G4VUserPrimaryVertexInformation * G4PrimaryVertex::GetUserInformation()
G4Allocator<G4PrimaryVertex> *& aPrimaryVertexAllocator()
void G4PrimaryVertex::SetUserInformation(G4VUserPrimaryVertexInformation *)
G4VUserPrimaryVertexInformation * G4PrimaryVertex::GetUserInformation()
const std::map<G4String,std::vector<G4LogicalVolume *>> & G4LogicalVolumeStore::GetMap()
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::Hep2Vector &)
std::istream & CLHEP::operator>>(std::istream &, CLHEP::Hep2Vector &)
void G4VTrajectory::ShowTrajectory(std::ostream &)
const std::map<G4String,G4AttDef> * G4VTrajectory::GetAttDefs()
G4Allocator<G4TrajectoryContainer> *& aTrajectoryContainerAllocator()
G4Allocator<G4Event> *& anEventAllocator()
std::ostream & CLHEP::HepRandomEngine::put(std::ostream &)
std::istream & CLHEP::HepRandomEngine::get(std::istream &)
std::istream & CLHEP::HepRandomEngine::getState(std::istream &)
CLHEP::HepRandomEngine * CLHEP::HepRandomEngine::newEngine(std::istream &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepRandomEngine &)
std::istream & CLHEP::operator>>(std::istream &, CLHEP::HepRandomEngine &)
std::ostream & CLHEP::HepRandom::put(std::ostream &)
std::istream & CLHEP::HepRandom::get(std::istream &)
std::ostream & CLHEP::HepRandom::saveFullState(std::ostream &)
std::istream & CLHEP::HepRandom::restoreFullState(std::istream &)
std::ostream & CLHEP::HepRandom::saveDistState(std::ostream &)
std::istream & CLHEP::HepRandom::restoreDistState(std::istream &)
std::ostream & CLHEP::HepRandom::saveStaticRandomStates(std::ostream &)
std::istream & CLHEP::HepRandom::restoreStaticRandomStates(std::istream &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepRandom &)
std::istream & CLHEP::operator>>(std::istream &, CLHEP::HepRandom &)
std::ostream & CLHEP::RandFlat::put(std::ostream &)
std::istream & CLHEP::RandFlat::get(std::istream &)
std::ostream & CLHEP::RandFlat::saveFullState(std::ostream &)
std::istream & CLHEP::RandFlat::restoreFullState(std::istream &)
std::ostream & CLHEP::RandFlat::saveDistState(std::ostream &)
std::istream & CLHEP::RandFlat::restoreDistState(std::istream &)
std::ostream & CLHEP::RandExponential::put(std::ostream &)
std::istream & CLHEP::RandExponential::get(std::istream &)
std::ostream & CLHEP::RandBit::put(std::ostream &)
std::istream & CLHEP::RandBit::get(std::istream &)
std::ostream & CLHEP::RandBit::saveFullState(std::ostream &)
std::istream & CLHEP::RandBit::restoreFullState(std::istream &)
std::ostream & CLHEP::RandBit::saveDistState(std::ostream &)
std::istream & CLHEP::RandBit::restoreDistState(std::istream &)
std::ostream & CLHEP::RandGamma::put(std::ostream &)
std::istream & CLHEP::RandGamma::get(std::istream &)
std::ostream & CLHEP::RandGaussQ::put(std::ostream &)
std::istream & CLHEP::RandGaussQ::get(std::istream &)
std::ostream & CLHEP::RandGeneral::put(std::ostream &)
std::istream & CLHEP::RandGeneral::get(std::istream &)
std::ostream & CLHEP::RandPoissonQ::put(std::ostream &)
std::istream & CLHEP::RandPoissonQ::get(std::istream &)
void G4VProcess::ProcessDescription(std::ostream &)
void G4MTRunManagerKernel::StartThread(G4WorkerThread *)
G4WorkerThread * G4MTRunManagerKernel::GetWorkerThread()
G4UIcommandTree * G4UImanager::GetTree()
G4UIsession * G4UImanager::GetSession()
G4UIsession * G4UImanager::GetG4UIWindow()
G4UIsession * G4UImanager::GetBaseSession()
void G4UImanager::SetSession(G4UIsession *const)
void G4UImanager::SetG4UIWindow(G4UIsession *const)
void G4UImanager::SetCoutDestination(G4UIsession *const)
void G4UImanager::RegisterBridge(G4UIbridge *)
G4MTcoutDestination * G4UImanager::GetThreadCout()
std::ostream & G4CSGSolid::StreamInfo(std::ostream &)
void G4CSGSolid::G4CSGSolid(__void__ &)
void G4PVPlacement::G4PVPlacement(__void__ &)
void G4PVReplica::G4PVReplica(__void__ &)
const G4PVRManager & G4PVReplica::GetSubInstanceManager()
G4PropagatorInField * G4TransportationManager::GetPropagatorInField()
void G4TransportationManager::SetPropagatorInField(G4PropagatorInField *)
std::vector<G4Navigator *>::iterator G4TransportationManager::GetActiveNavigatorsIterator()
std::vector<G4VPhysicalVolume *>::iterator G4TransportationManager::GetWorldsIterator()
G4bool G4Box::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Box::StreamInfo(std::ostream &)
void G4Box::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4Box::GetExtent()
void G4Box::G4Box(__void__ &)
G4bool G4ExtrudedSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4ExtrudedSolid::StreamInfo(std::ostream &)
void G4ExtrudedSolid::G4ExtrudedSolid(__void__ &)
G4bool G4MultiUnion::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4MultiUnion::StreamInfo(std::ostream &)
void G4MultiUnion::DescribeYourselfTo(G4VGraphicsScene &)
void G4MultiUnion::G4MultiUnion(__void__ &)
G4bool G4Trd::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Trd::StreamInfo(std::ostream &)
void G4Trd::DescribeYourselfTo(G4VGraphicsScene &)
void G4Trd::G4Trd(__void__ &)
G4bool G4Trap::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Trap::StreamInfo(std::ostream &)
void G4Trap::DescribeYourselfTo(G4VGraphicsScene &)
void G4Trap::G4Trap(__void__ &)
G4bool G4Cons::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Cons::StreamInfo(std::ostream &)
void G4Cons::DescribeYourselfTo(G4VGraphicsScene &)
void G4Cons::G4Cons(__void__ &)
G4bool G4Sphere::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Sphere::StreamInfo(std::ostream &)
G4VisExtent G4Sphere::GetExtent()
void G4Sphere::DescribeYourselfTo(G4VGraphicsScene &)
void G4Sphere::G4Sphere(__void__ &)
G4bool G4Orb::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Orb::StreamInfo(std::ostream &)
void G4Orb::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4Orb::GetExtent()
void G4Orb::G4Orb(__void__ &)
const G4VUPLManager & G4VUserPhysicsList::GetSubInstanceManager()
const G4VUPLManager & G4VUserPhysicsList::GetSubInstanceManager()
const G4VMPLManager & G4VModularPhysicsList::GetSubInstanceManager()
const G4VMPLManager & G4VModularPhysicsList::GetSubInstanceManager()
const G4DCtable * G4Run::GetDCtable()
void G4Run::SetDCtable(G4DCtable *)
G4bool G4CutTubs::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4CutTubs::StreamInfo(std::ostream &)
void G4CutTubs::DescribeYourselfTo(G4VGraphicsScene &)
void G4CutTubs::G4CutTubs(__void__ &)
G4bool G4GenericPolycone::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4GenericPolycone::StreamInfo(std::ostream &)
void G4GenericPolycone::G4GenericPolycone(__void__ &)
G4bool G4EllipticalTube::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4EllipticalTube::StreamInfo(std::ostream &)
void G4EllipticalTube::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4EllipticalTube::GetExtent()
void G4EllipticalTube::G4EllipticalTube(__void__ &)
G4bool G4EllipticalCone::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4EllipticalCone::StreamInfo(std::ostream &)
void G4EllipticalCone::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4EllipticalCone::GetExtent()
void G4EllipticalCone::G4EllipticalCone(__void__ &)
G4bool G4Paraboloid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Paraboloid::StreamInfo(std::ostream &)
void G4Paraboloid::DescribeYourselfTo(G4VGraphicsScene &)
void G4Paraboloid::G4Paraboloid(__void__ &)
G4bool G4Tet::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Tet::StreamInfo(std::ostream &)
void G4Tet::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4Tet::GetExtent()
void G4Tet::G4Tet(__void__ &)
std::ostream & G4TwistedBox::StreamInfo(std::ostream &)
void G4TwistedBox::G4TwistedBox(__void__ &)
std::ostream & G4TwistedTrap::StreamInfo(std::ostream &)
void G4TwistedTrap::G4TwistedTrap(__void__ &)
std::ostream & G4TwistedTrd::StreamInfo(std::ostream &)
void G4TwistedTrd::G4TwistedTrd(__void__ &)
void G4GenericTrap::G4GenericTrap(__void__ &)
G4bool G4GenericTrap::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4GenericTrap::StreamInfo(std::ostream &)
void G4GenericTrap::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4GenericTrap::GetExtent()
G4bool G4TwistedTubs::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
void G4TwistedTubs::DescribeYourselfTo(G4VGraphicsScene &)
std::ostream & G4TwistedTubs::StreamInfo(std::ostream &)
G4VisExtent G4TwistedTubs::GetExtent()
void G4TwistedTubs::G4TwistedTubs(__void__ &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepEulerAngles &)
std::istream & CLHEP::operator>>(std::istream &, CLHEP::HepEulerAngles &)
std::ostream & CLHEP::HepBoost::print(std::ostream &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepBoost &)
std::ostream & CLHEP::HepLorentzRotation::print(std::ostream &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepLorentzRotation &)
G4bool G4DisplacedSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4DisplacedSolid::StreamInfo(std::ostream &)
void G4DisplacedSolid::G4DisplacedSolid(__void__ &)
void G4DisplacedSolid::DescribeYourselfTo(G4VGraphicsScene &)
std::ostream & G4BooleanSolid::StreamInfo(std::ostream &)
void G4BooleanSolid::G4BooleanSolid(__void__ &)
void G4UnionSolid::G4UnionSolid(__void__ &)
G4bool G4UnionSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
void G4UnionSolid::DescribeYourselfTo(G4VGraphicsScene &)
void G4SubtractionSolid::G4SubtractionSolid(__void__ &)
G4bool G4SubtractionSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
void G4SubtractionSolid::DescribeYourselfTo(G4VGraphicsScene &)
void G4IntersectionSolid::G4IntersectionSolid(__void__ &)
G4bool G4IntersectionSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
void G4IntersectionSolid::DescribeYourselfTo(G4VGraphicsScene &)
const std::map<G4String,G4Colour> & G4Colour::GetMap()
void G4VisAttributes::SetAttDefs(const std::map<G4String,G4AttDef> *)
const std::map<G4String,G4AttDef> * G4VisAttributes::GetAttDefs()
const G4GDMLAuxMapType * G4GDMLParser::GetAuxMap()
void G4OpticalParameters::StreamInfo(std::ostream &)
void G4OpticalSurface::ReadCompressedFile(const G4String &, std::istringstream &)
const G4LogicalBorderSurfaceTable * G4LogicalBorderSurface::GetSurfaceTable()
const G4LogicalSkinSurfaceTable * G4LogicalSkinSurface::GetSurfaceTable()
void G4ScoringManager::RegisterScoreColorMap(G4VScoreColorMap *)
G4VScoreColorMap * G4ScoringManager::GetScoreColorMap(const G4String &)
const std::map<G4String,G4AttDef> * G4VTrajectoryPoint::GetAttDefs()
std::ostream & CLHEP::HepRotation::print(std::ostream &)
std::ostream & CLHEP::operator<<(std::ostream &, const CLHEP::HepRotation &)
void G4VPhysicalVolume::G4VPhysicalVolume(__void__ &)
const G4PVManager & G4VPhysicalVolume::GetSubInstanceManager()
G4bool G4VSolid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4VSolid::StreamInfo(std::ostream &)
void G4VSolid::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4VSolid::GetExtent()
void G4VSolid::G4VSolid(__void__ &)
std::ostream & operator<<(std::ostream &, const G4VSolid &)
void G4RunManager::SetUserInitialization(G4UserWorkerThreadInitialization *)
const G4UserWorkerThreadInitialization * G4RunManager::GetUserWorkerThreadInitialization()
void G4RunManager::SetDCtable(G4DCtable *)
G4int G4MTRunManager::SetUpNEvents(G4Event *, G4SeedsQueue *, G4bool)
G4MTRunManager::masterWorlds_t & G4MTRunManager::GetMasterWorlds()
void G4MTRunManager::SetUserInitialization(G4UserWorkerThreadInitialization *)
G4bool G4Ellipsoid::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Ellipsoid::StreamInfo(std::ostream &)
void G4Ellipsoid::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4Ellipsoid::GetExtent()
void G4Ellipsoid::G4Ellipsoid(__void__ &)
G4bool G4VCSGfaceted::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4VCSGfaceted::StreamInfo(std::ostream &)
void G4VCSGfaceted::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4VCSGfaceted::GetExtent()
void G4VCSGfaceted::G4VCSGfaceted(__void__ &)
G4bool G4Polycone::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Polycone::StreamInfo(std::ostream &)
void G4Polycone::G4Polycone(__void__ &)
G4bool G4Polyhedra::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Polyhedra::StreamInfo(std::ostream &)
void G4Polyhedra::G4Polyhedra(__void__ &)
G4bool G4Torus::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Torus::StreamInfo(std::ostream &)
void G4Torus::DescribeYourselfTo(G4VGraphicsScene &)
void G4Torus::G4Torus(__void__ &)
G4bool G4Para::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Para::StreamInfo(std::ostream &)
void G4Para::DescribeYourselfTo(G4VGraphicsScene &)
void G4Para::G4Para(__void__ &)
G4bool G4Hype::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Hype::StreamInfo(std::ostream &)
void G4Hype::DescribeYourselfTo(G4VGraphicsScene &)
G4VisExtent G4Hype::GetExtent()
void G4Hype::G4Hype(__void__ &)
G4bool G4Tubs::CalculateExtent(const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &)
std::ostream & G4Tubs::StreamInfo(std::ostream &)
void G4Tubs::DescribeYourselfTo(G4VGraphicsScene &)
void G4Tubs::G4Tubs(__void__ &)

Class(es) from vetoed_finalizer_classes configuration parameter that were not found:
-------------------------------------------------------------------------------------

None

List of wrapped classed:

G4ParticleDefinition
G4String
G4ProcessManager
G4ParticleTable
G4PDefManager
G4FieldManager
G4Field
G4MagneticField
G4Track
G4HCofThisEvent
G4VHitsCollection
CLHEP::Hep3Vector
CLHEP::HepRotation
CLHEP::HepAxisAngle
CLHEP::HepEulerAngles
CLHEP::HepRotationX
CLHEP::HepRotationY
CLHEP::HepRotationZ
CLHEP::HepRep3x3
CLHEP::HepRotation::HepRotation_row
CLHEP::HepLorentzVector
CLHEP::HepRep4x4
CLHEP::HepBoost
CLHEP::HepLorentzRotation
G4PVData
G4VPhysicalVolume
G4LogicalVolume
G4VPVParameterisation
HepGeom::Point3D
HepGeom::Vector3D
HepGeom::Normal3D
HepGeom::Transform3D
HepGeom::Transform3D::Transform3D_row
HepGeom::Point3D
HepGeom::Scale3D
HepGeom::Rotate3D
HepGeom::Translate3D
HepGeom::Vector3D
HepGeom::RotateX3D
HepGeom::RotateY3D
HepGeom::RotateZ3D
HepGeom::TranslateX3D
HepGeom::TranslateY3D
HepGeom::TranslateZ3D
HepGeom::Reflect3D
HepGeom::Normal3D
HepGeom::ReflectX3D
HepGeom::ReflectY3D
HepGeom::ReflectZ3D
HepGeom::ScaleX3D
HepGeom::ScaleY3D
HepGeom::ScaleZ3D
G4AffineTransform
G4NavigationHistory
G4LVData
G4VSolid
G4VSensitiveDetector
G4Material
G4MaterialCutsCouple
G4UserLimits
G4SmartVoxelHeader
G4Region
G4VisAttributes
G4FastSimulationManager
G4TouchableHistory
G4Isotope
G4Element
G4IonisParamElm
G4MaterialPropertiesTable
G4PhysicsFreeVector
G4IonisParamMat
G4SandiaTable
G4StepPoint
G4ReferenceCountedHandle
G4VProcess
G4Step
G4DynamicParticle
G4VUserTrackInformation
G4VReadOutGeometry
G4VSDFilter
G4VUserDetectorConstruction
G4VUserActionInitialization
G4VSteppingVerbose
G4VUserPrimaryGeneratorAction
G4Event
G4UserSteppingAction
G4SteppingManager
G4VPrimaryGenerator
G4PrimaryParticle
G4PrimaryVertex
G4ParticleGun
G4UserWorkerInitialization
G4LogicalVolumeStore
G4VNotifier
G4VStateDependent
G4Run
CLHEP::Hep2Vector
G4JLExceptionHandler
G4JLSensDet
G4JLDetectorConstruction
G4JLActionInitialization
G4UserRunAction
G4UserEventAction
G4UserStackingAction
G4UserTrackingAction
G4JLParticleGun
G4JLWorkerInitialization
G4JLGeneratorAction
G4JLMagField
G4JLSteppingAction
G4JLTrackingAction
G4JLRunAction
G4JLEventAction
G4JLStackingAction
G4JLStateDependent
G4PolyconeSideRZ
G4Polycone
G4GenericPolycone
G4PolyhedraSideRZ
G4Polyhedra
std::pair
std::vector
G4VTrajectory
G4VTrajectoryPoint
G4AttValue
G4TrajectoryContainer
G4DCofThisEvent
G4VUserEventInformation
G4SubEvent
G4Polyhedron
G4DisplacedSolid
G4Navigator
G4VExternalNavigation
G4VoxelNavigation
CLHEP::HepRandomEngine
std::basic_string
CLHEP::HepRandom
CLHEP::RandFlat
CLHEP::RandExponential
CLHEP::RandBit
CLHEP::RandGamma
CLHEP::RandGaussQ
CLHEP::RandGeneral
CLHEP::RandPoissonQ
G4VParticleChange
G4ProcessVector
G4EventManager
G4StackManager
G4TrackingManager
G4PrimaryTransformer
G4RunManager
G4VUserPhysicsList
G4MTRunManager
G4ScoringManager
G4RunManagerKernel
G4MTRunManagerKernel
G4UImanager
G4UIcommand
G4SPSPosDistribution
G4SPSRandomGenerator
G4SPSAngDistribution
G4SPSEneDistribution
G4SingleParticleSource
G4GeneralParticleSource
G4VFastSimulationModel
G4NistManager
G4ICRU90StoppingData
G4CSGSolid
G4SteppingVerbose
G4PVPlacement
G4ReplicaData
G4PVReplica
G4TransportationManager
G4SafetyHelper
G4GDMLAuxStructType
G4Box
G4ExtrudedSolid
G4ExtrudedSolid::ZSection
G4MultiUnion
G4Voxelizer
G4Trd
TrapSidePlane
G4Trap
G4Cons
G4Sphere
G4Orb
G4Ellipsoid
G4VCSGfaceted
G4PolyconeHistorical
G4PolyhedraHistorical
G4Torus
G4Para
G4Hype
G4Tubs
G4GDMLParser
G4GDMLReadStructure
G4GDMLWriteStructure
G4GDMLMatrix
G4OpticalParameters
G4OpticalSurface
G4Physics2DVector
G4LogicalBorderSurface
G4SurfaceProperty
G4LogicalSkinSurface
G4ParticleTableIterator
G4PhysicsListHelper
G4VMPLData
G4VPhysicsConstructor
G4VModularPhysicsList
QGS_BIC
QBBC
FTFP_BERT
LBE
G4EmStandardPhysics_option4
G4OpticalPhysics
G4DecayPhysics
G4EmStandardPhysics
G4RadioactiveDecayPhysics
G4OpBoundaryProcess
G4StepLimiterPhysics
G4HCtable
G4CutTubs
G4EllipticalTube
G4EllipticalCone
G4Paraboloid
G4Tet
G4TwistedBox
G4TwistedTrap
G4TwistedTrd
G4GenericTrap
G4TwistedTubs
CLHEP::HepRep4x4Symmetric
CLHEP::HepBoostX
CLHEP::HepBoostY
CLHEP::HepBoostZ
CLHEP::HepLorentzRotation::HepLorentzRotation_row
G4BooleanSolid
G4VBooleanProcessor
G4UnionSolid
G4SubtractionSolid
G4IntersectionSolid
G4UniformMagField
G4Colour
G4VScoringMesh
G4VScoreWriter
G4StateManager
G4VExceptionHandler



List of wrapped methods:

:G4bool G4ParticleDefinition::operator==(const G4ParticleDefinition &)
G4bool G4ParticleDefinition::operator!=(const G4ParticleDefinition &)
const G4String & G4ParticleDefinition::GetParticleName()
G4double G4ParticleDefinition::GetPDGMass()
G4double G4ParticleDefinition::GetPDGWidth()
G4double G4ParticleDefinition::GetPDGCharge()
G4double G4ParticleDefinition::GetPDGSpin()
G4int G4ParticleDefinition::GetPDGiSpin()
G4int G4ParticleDefinition::GetPDGiParity()
G4int G4ParticleDefinition::GetPDGiConjugation()
G4double G4ParticleDefinition::GetPDGIsospin()
G4double G4ParticleDefinition::GetPDGIsospin3()
G4int G4ParticleDefinition::GetPDGiIsospin()
G4int G4ParticleDefinition::GetPDGiIsospin3()
G4int G4ParticleDefinition::GetPDGiGParity()
G4double G4ParticleDefinition::GetPDGMagneticMoment()
void G4ParticleDefinition::SetPDGMagneticMoment(G4double)
G4double G4ParticleDefinition::CalculateAnomaly()
const G4String & G4ParticleDefinition::GetParticleType()
const G4String & G4ParticleDefinition::GetParticleSubType()
G4int G4ParticleDefinition::GetLeptonNumber()
G4int G4ParticleDefinition::GetBaryonNumber()
G4int G4ParticleDefinition::GetPDGEncoding()
G4int G4ParticleDefinition::GetAntiPDGEncoding()
void G4ParticleDefinition::SetAntiPDGEncoding(G4int)
G4int G4ParticleDefinition::GetQuarkContent(G4int)
G4int G4ParticleDefinition::GetAntiQuarkContent(G4int)
G4bool G4ParticleDefinition::IsShortLived()
G4bool G4ParticleDefinition::GetPDGStable()
void G4ParticleDefinition::SetPDGStable(const G4bool)
G4double G4ParticleDefinition::GetPDGLifeTime()
void G4ParticleDefinition::SetPDGLifeTime(G4double)
G4double G4ParticleDefinition::GetIonLifeTime()
G4ProcessManager * G4ParticleDefinition::GetProcessManager()
void G4ParticleDefinition::SetProcessManager(G4ProcessManager *)
G4ParticleTable * G4ParticleDefinition::GetParticleTable()
G4int G4ParticleDefinition::GetAtomicNumber()
G4int G4ParticleDefinition::GetAtomicMass()
void G4ParticleDefinition::DumpTable()
void G4ParticleDefinition::SetVerboseLevel(G4int)
G4int G4ParticleDefinition::GetVerboseLevel()
void G4ParticleDefinition::SetApplyCutsFlag(G4bool)
G4bool G4ParticleDefinition::GetApplyCutsFlag()
G4bool G4ParticleDefinition::IsGeneralIon()
G4bool G4ParticleDefinition::IsMuonicAtom()
G4ProcessManager * G4ParticleDefinition::GetMasterProcessManager()
void G4ParticleDefinition::SetMasterProcessManager(G4ProcessManager *)
G4int G4ParticleDefinition::GetInstanceID()
const G4PDefManager & G4ParticleDefinition::GetSubInstanceManager()
void G4ParticleDefinition::Clean()
void G4ParticleDefinition::SetParticleDefinitionID(G4int)
G4int G4ParticleDefinition::GetParticleDefinitionID()
G4bool G4ParticleDefinition::IsHypernucleus()
G4int G4ParticleDefinition::GetNumberOfLambdasInHypernucleus()
G4bool G4ParticleDefinition::IsAntiHypernucleus()
G4int G4ParticleDefinition::GetNumberOfAntiLambdasInAntiHypernucleus()
void G4ProcessManager::G4ProcessManager(const G4ParticleDefinition *)
void G4ProcessManager::G4ProcessManager(G4ProcessManager &)
G4bool G4ProcessManager::operator==(const G4ProcessManager &)
G4bool G4ProcessManager::operator!=(const G4ProcessManager &)
G4ProcessVector * G4ProcessManager::GetProcessList()
G4int G4ProcessManager::GetProcessListLength()
G4int G4ProcessManager::GetProcessIndex(G4VProcess *)
G4ProcessVector * G4ProcessManager::GetProcessVector(G4ProcessVectorDoItIndex, G4ProcessVectorTypeIndex)
G4ProcessVector * G4ProcessManager::GetAtRestProcessVector(G4ProcessVectorTypeIndex)
G4ProcessVector * G4ProcessManager::GetAlongStepProcessVector(G4ProcessVectorTypeIndex)
G4ProcessVector * G4ProcessManager::GetPostStepProcessVector(G4ProcessVectorTypeIndex)
G4int G4ProcessManager::GetProcessVectorIndex(G4VProcess *, G4ProcessVectorDoItIndex, G4ProcessVectorTypeIndex)
G4int G4ProcessManager::GetAtRestIndex(G4VProcess *, G4ProcessVectorTypeIndex)
G4int G4ProcessManager::GetAlongStepIndex(G4VProcess *, G4ProcessVectorTypeIndex)
G4int G4ProcessManager::GetPostStepIndex(G4VProcess *, G4ProcessVectorTypeIndex)
G4int G4ProcessManager::AddProcess(G4VProcess *, G4int, G4int, G4int)
G4int G4ProcessManager::AddRestProcess(G4VProcess *, G4int)
G4int G4ProcessManager::AddDiscreteProcess(G4VProcess *, G4int)
G4int G4ProcessManager::AddContinuousProcess(G4VProcess *, G4int)
G4int G4ProcessManager::GetProcessOrdering(G4VProcess *, G4ProcessVectorDoItIndex)
void G4ProcessManager::SetProcessOrdering(G4VProcess *, G4ProcessVectorDoItIndex, G4int)
void G4ProcessManager::SetProcessOrderingToFirst(G4VProcess *, G4ProcessVectorDoItIndex)
void G4ProcessManager::SetProcessOrderingToSecond(G4VProcess *, G4ProcessVectorDoItIndex)
void G4ProcessManager::SetProcessOrderingToLast(G4VProcess *, G4ProcessVectorDoItIndex)
G4VProcess * G4ProcessManager::RemoveProcess(G4VProcess *)
G4VProcess * G4ProcessManager::RemoveProcess(G4int)
G4VProcess * G4ProcessManager::SetProcessActivation(G4VProcess *, G4bool)
G4VProcess * G4ProcessManager::SetProcessActivation(G4int, G4bool)
G4bool G4ProcessManager::GetProcessActivation(G4VProcess *)
G4bool G4ProcessManager::GetProcessActivation(G4int)
G4ParticleDefinition * G4ProcessManager::GetParticleType()
void G4ProcessManager::SetParticleType(const G4ParticleDefinition *)
G4VProcess * G4ProcessManager::GetProcess(const G4String &)
void G4ProcessManager::StartTracking(G4Track *)
void G4ProcessManager::EndTracking()
void G4ProcessManager::DumpInfo()
void G4ProcessManager::SetVerboseLevel(G4int)
G4int G4ProcessManager::GetVerboseLevel()
void G4FieldManager::G4FieldManager(G4MagneticField *)
G4bool G4FieldManager::SetDetectorField(G4Field *, G4int)
void G4FieldManager::ProposeDetectorField(G4Field *)
void G4FieldManager::ChangeDetectorField(G4Field *)
const G4Field * G4FieldManager::GetDetectorField()
G4bool G4FieldManager::DoesFieldExist()
void G4FieldManager::CreateChordFinder(G4MagneticField *)
void G4FieldManager::ConfigureForTrack(const G4Track *)
void G4FieldManager::SetGlobalFieldManager(G4FieldManager *)
G4FieldManager * G4FieldManager::GetGlobalFieldManager()
G4double G4FieldManager::GetDeltaIntersection()
G4double G4FieldManager::GetDeltaOneStep()
void G4FieldManager::SetAccuraciesWithDeltaOneStep(G4double)
void G4FieldManager::SetDeltaOneStep(G4double)
void G4FieldManager::SetDeltaIntersection(G4double)
G4double G4FieldManager::GetMinimumEpsilonStep()
G4bool G4FieldManager::SetMinimumEpsilonStep(G4double)
G4double G4FieldManager::GetMaximumEpsilonStep()
G4bool G4FieldManager::SetMaximumEpsilonStep(G4double)
G4bool G4FieldManager::DoesFieldChangeEnergy()
void G4FieldManager::SetFieldChangesEnergy(G4bool)
G4FieldManager * G4FieldManager::Clone()
G4double G4FieldManager::GetMaxAcceptedEpsilon()
G4bool G4FieldManager::SetMaxAcceptedEpsilon(G4double, G4bool)
void G4MagneticField::G4MagneticField(const G4MagneticField &)
G4MagneticField & G4MagneticField::operator=(const G4MagneticField &)
G4bool G4MagneticField::DoesFieldChangeEnergy()
void G4MagneticField::GetFieldValue(const G4double[4], G4double *)
void G4Track::G4Track(G4DynamicParticle *, G4double, const G4ThreeVector &)
void G4Track::G4Track(const G4Track &, G4bool)
G4Track & G4Track::operator=(const G4Track &)
G4bool G4Track::operator==(const G4Track &)
G4bool G4Track::operator!=(const G4Track &)
void G4Track::CopyTrackInfo(const G4Track &, G4bool)
G4int G4Track::GetTrackID()
void G4Track::SetTrackID(const G4int)
G4int G4Track::GetParentID()
void G4Track::SetParentID(const G4int)
const G4DynamicParticle * G4Track::GetDynamicParticle()
const G4ParticleDefinition * G4Track::GetParticleDefinition()
G4ParticleDefinition * G4Track::GetDefinition()
const G4ThreeVector & G4Track::GetPosition()
void G4Track::SetPosition(const G4ThreeVector &)
G4double G4Track::GetGlobalTime()
void G4Track::SetGlobalTime(const G4double)
G4double G4Track::GetLocalTime()
void G4Track::SetLocalTime(const G4double)
G4double G4Track::GetProperTime()
void G4Track::SetProperTime(const G4double)
G4VPhysicalVolume * G4Track::GetVolume()
G4VPhysicalVolume * G4Track::GetNextVolume()
G4Material * G4Track::GetMaterial()
G4Material * G4Track::GetNextMaterial()
const G4MaterialCutsCouple * G4Track::GetMaterialCutsCouple()
const G4MaterialCutsCouple * G4Track::GetNextMaterialCutsCouple()
const G4VTouchable * G4Track::GetTouchable()
const G4TouchableHandle & G4Track::GetTouchableHandle()
void G4Track::SetTouchableHandle(const G4TouchableHandle &)
const G4VTouchable * G4Track::GetNextTouchable()
const G4TouchableHandle & G4Track::GetNextTouchableHandle()
void G4Track::SetNextTouchableHandle(const G4TouchableHandle &)
const G4VTouchable * G4Track::GetOriginTouchable()
const G4TouchableHandle & G4Track::GetOriginTouchableHandle()
void G4Track::SetOriginTouchableHandle(const G4TouchableHandle &)
G4double G4Track::GetKineticEnergy()
G4double G4Track::GetTotalEnergy()
void G4Track::SetKineticEnergy(const G4double)
G4ThreeVector G4Track::GetMomentum()
const G4ThreeVector & G4Track::GetMomentumDirection()
void G4Track::SetMomentumDirection(const G4ThreeVector &)
G4double G4Track::GetVelocity()
void G4Track::SetVelocity(G4double)
G4double G4Track::CalculateVelocity()
G4double G4Track::CalculateVelocityForOpticalPhoton()
G4bool G4Track::UseGivenVelocity()
void G4Track::UseGivenVelocity(G4bool)
const G4ThreeVector & G4Track::GetPolarization()
void G4Track::SetPolarization(const G4ThreeVector &)
G4TrackStatus G4Track::GetTrackStatus()
void G4Track::SetTrackStatus(const G4TrackStatus)
G4bool G4Track::IsBelowThreshold()
void G4Track::SetBelowThresholdFlag(G4bool)
G4bool G4Track::IsGoodForTracking()
void G4Track::SetGoodForTrackingFlag(G4bool)
G4double G4Track::GetTrackLength()
void G4Track::AddTrackLength(const G4double)
const G4Step * G4Track::GetStep()
void G4Track::SetStep(const G4Step *)
G4int G4Track::GetCurrentStepNumber()
void G4Track::IncrementCurrentStepNumber()
G4double G4Track::GetStepLength()
void G4Track::SetStepLength(G4double)
const G4ThreeVector & G4Track::GetVertexPosition()
void G4Track::SetVertexPosition(const G4ThreeVector &)
const G4ThreeVector & G4Track::GetVertexMomentumDirection()
void G4Track::SetVertexMomentumDirection(const G4ThreeVector &)
G4double G4Track::GetVertexKineticEnergy()
void G4Track::SetVertexKineticEnergy(const G4double)
const G4LogicalVolume * G4Track::GetLogicalVolumeAtVertex()
void G4Track::SetLogicalVolumeAtVertex(const G4LogicalVolume *)
const G4VProcess * G4Track::GetCreatorProcess()
void G4Track::SetCreatorProcess(const G4VProcess *)
void G4Track::SetCreatorModelID(const G4int)
G4int G4Track::GetCreatorModelID()
G4int G4Track::GetCreatorModelIndex()
const G4String G4Track::GetCreatorModelName()
const G4ParticleDefinition * G4Track::GetParentResonanceDef()
void G4Track::SetParentResonanceDef(const G4ParticleDefinition *)
G4int G4Track::GetParentResonanceID()
void G4Track::SetParentResonanceID(const G4int)
G4bool G4Track::HasParentResonance()
G4int G4Track::GetParentResonancePDGEncoding()
G4String G4Track::GetParentResonanceName()
G4double G4Track::GetParentResonanceMass()
G4double G4Track::GetWeight()
void G4Track::SetWeight(G4double)
G4VUserTrackInformation * G4Track::GetUserInformation()
void G4Track::SetUserInformation(G4VUserTrackInformation *)
void G4Track::RemoveAuxiliaryTrackInformation(G4int)
void G4Track::RemoveAuxiliaryTrackInformation(G4String &)
void G4HCofThisEvent::G4HCofThisEvent(G4int)
void G4HCofThisEvent::G4HCofThisEvent(const G4HCofThisEvent &)
G4HCofThisEvent & G4HCofThisEvent::operator=(const G4HCofThisEvent &)
void G4HCofThisEvent::AddHitsCollection(G4int, G4VHitsCollection *)
G4VHitsCollection * G4HCofThisEvent::GetHC(G4int)
G4int G4HCofThisEvent::GetNumberOfCollections()
std::size_t G4HCofThisEvent::GetCapacity()
void CLHEP::Hep3Vector::Hep3Vector(double)
void CLHEP::Hep3Vector::Hep3Vector(double, double)
void CLHEP::Hep3Vector::Hep3Vector(double, double, double)
void CLHEP::Hep3Vector::Hep3Vector(const CLHEP::Hep3Vector &)
void CLHEP::Hep3Vector::Hep3Vector(CLHEP::Hep3Vector &&)
double CLHEP::Hep3Vector::operator()(int)
double CLHEP::Hep3Vector::operator[](int)
double & CLHEP::Hep3Vector::operator()(int)
double & CLHEP::Hep3Vector::operator[](int)
double CLHEP::Hep3Vector::x()
double CLHEP::Hep3Vector::y()
double CLHEP::Hep3Vector::z()
void CLHEP::Hep3Vector::setX(double)
void CLHEP::Hep3Vector::setY(double)
void CLHEP::Hep3Vector::setZ(double)
void CLHEP::Hep3Vector::set(double, double, double)
double CLHEP::Hep3Vector::phi()
double CLHEP::Hep3Vector::theta()
double CLHEP::Hep3Vector::cosTheta()
double CLHEP::Hep3Vector::cos2Theta()
double CLHEP::Hep3Vector::mag2()
double CLHEP::Hep3Vector::mag()
void CLHEP::Hep3Vector::setPhi(double)
void CLHEP::Hep3Vector::setTheta(double)
void CLHEP::Hep3Vector::setMag(double)
double CLHEP::Hep3Vector::perp2()
double CLHEP::Hep3Vector::perp()
void CLHEP::Hep3Vector::setPerp(double)
void CLHEP::Hep3Vector::setCylTheta(double)
double CLHEP::Hep3Vector::perp2(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::perp(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator=(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator=(CLHEP::Hep3Vector &&)
bool CLHEP::Hep3Vector::operator==(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::operator!=(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::isNear(const CLHEP::Hep3Vector &, double)
double CLHEP::Hep3Vector::howNear(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::deltaR(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator+=(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator-=(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::Hep3Vector::operator-()
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator*=(double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator/=(double)
CLHEP::Hep3Vector CLHEP::Hep3Vector::unit()
CLHEP::Hep3Vector CLHEP::Hep3Vector::orthogonal()
double CLHEP::Hep3Vector::dot(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::Hep3Vector::cross(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::angle(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::pseudoRapidity()
void CLHEP::Hep3Vector::setEta(double)
void CLHEP::Hep3Vector::setCylEta(double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotateX(double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotateY(double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotateZ(double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotateUz(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotate(double, const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::operator*=(const CLHEP::HepRotation &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::transform(const CLHEP::HepRotation &)
void CLHEP::Hep3Vector::setRThetaPhi(double, double, double)
void CLHEP::Hep3Vector::setREtaPhi(double, double, double)
void CLHEP::Hep3Vector::setRhoPhiZ(double, double, double)
void CLHEP::Hep3Vector::setRhoPhiTheta(double, double, double)
void CLHEP::Hep3Vector::setRhoPhiEta(double, double, double)
double CLHEP::Hep3Vector::getX()
double CLHEP::Hep3Vector::getY()
double CLHEP::Hep3Vector::getZ()
double CLHEP::Hep3Vector::getR()
double CLHEP::Hep3Vector::getTheta()
double CLHEP::Hep3Vector::getPhi()
double CLHEP::Hep3Vector::r()
double CLHEP::Hep3Vector::rho()
double CLHEP::Hep3Vector::getRho()
double CLHEP::Hep3Vector::eta()
double CLHEP::Hep3Vector::getEta()
void CLHEP::Hep3Vector::setR(double)
void CLHEP::Hep3Vector::setRho(double)
int CLHEP::Hep3Vector::compare(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::operator>(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::operator<(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::operator>=(const CLHEP::Hep3Vector &)
bool CLHEP::Hep3Vector::operator<=(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::diff2(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::setTolerance(double)
double CLHEP::Hep3Vector::getTolerance()
bool CLHEP::Hep3Vector::isParallel(const CLHEP::Hep3Vector &, double)
bool CLHEP::Hep3Vector::isOrthogonal(const CLHEP::Hep3Vector &, double)
double CLHEP::Hep3Vector::howParallel(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::howOrthogonal(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::beta()
double CLHEP::Hep3Vector::gamma()
double CLHEP::Hep3Vector::coLinearRapidity()
double CLHEP::Hep3Vector::angle()
double CLHEP::Hep3Vector::theta(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::cosTheta(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::cos2Theta(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::Hep3Vector::project()
CLHEP::Hep3Vector CLHEP::Hep3Vector::project(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::Hep3Vector::perpPart()
CLHEP::Hep3Vector CLHEP::Hep3Vector::perpPart(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::rapidity()
double CLHEP::Hep3Vector::rapidity(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::eta(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::polarAngle(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::deltaPhi(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::azimAngle(const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::polarAngle(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
double CLHEP::Hep3Vector::azimAngle(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotate(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotate(const CLHEP::HepAxisAngle &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotate(const CLHEP::HepEulerAngles &)
CLHEP::Hep3Vector & CLHEP::Hep3Vector::rotate(double, double, double)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepRotation &)
void CLHEP::HepRotation::HepRotation(CLHEP::HepRotation &&)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepRotationX &)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepRotationY &)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::Hep3Vector &, double)
void CLHEP::HepRotation::HepRotation(const CLHEP::Hep3Vector &, double)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepAxisAngle &)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepAxisAngle &)
CLHEP::HepRotation & CLHEP::HepRotation::set(double, double, double)
void CLHEP::HepRotation::HepRotation(double, double, double)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepEulerAngles &)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepEulerAngles &)
void CLHEP::HepRotation::HepRotation(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::HepRotation & CLHEP::HepRotation::setRows(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepRotationX &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepRotationY &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::operator=(const CLHEP::HepRotation &)
CLHEP::HepRotation & CLHEP::HepRotation::operator=(CLHEP::HepRotation &&)
CLHEP::HepRotation & CLHEP::HepRotation::operator=(const CLHEP::HepRotationX &)
CLHEP::HepRotation & CLHEP::HepRotation::operator=(const CLHEP::HepRotationY &)
CLHEP::HepRotation & CLHEP::HepRotation::operator=(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::set(const CLHEP::HepRep3x3 &)
void CLHEP::HepRotation::HepRotation(const CLHEP::HepRep3x3 &)
CLHEP::Hep3Vector CLHEP::HepRotation::colX()
CLHEP::Hep3Vector CLHEP::HepRotation::colY()
CLHEP::Hep3Vector CLHEP::HepRotation::colZ()
CLHEP::Hep3Vector CLHEP::HepRotation::rowX()
CLHEP::Hep3Vector CLHEP::HepRotation::rowY()
CLHEP::Hep3Vector CLHEP::HepRotation::rowZ()
double CLHEP::HepRotation::xx()
double CLHEP::HepRotation::xy()
double CLHEP::HepRotation::xz()
double CLHEP::HepRotation::yx()
double CLHEP::HepRotation::yy()
double CLHEP::HepRotation::yz()
double CLHEP::HepRotation::zx()
double CLHEP::HepRotation::zy()
double CLHEP::HepRotation::zz()
CLHEP::HepRep3x3 CLHEP::HepRotation::rep3x3()
const CLHEP::HepRotation::HepRotation_row CLHEP::HepRotation::operator[](int)
double CLHEP::HepRotation::operator()(int, int)
double CLHEP::HepRotation::getPhi()
double CLHEP::HepRotation::getTheta()
double CLHEP::HepRotation::getPsi()
double CLHEP::HepRotation::phi()
double CLHEP::HepRotation::theta()
double CLHEP::HepRotation::psi()
CLHEP::HepEulerAngles CLHEP::HepRotation::eulerAngles()
double CLHEP::HepRotation::getDelta()
CLHEP::Hep3Vector CLHEP::HepRotation::getAxis()
double CLHEP::HepRotation::delta()
CLHEP::Hep3Vector CLHEP::HepRotation::axis()
CLHEP::HepAxisAngle CLHEP::HepRotation::axisAngle()
void CLHEP::HepRotation::getAngleAxis(double &, CLHEP::Hep3Vector &)
double CLHEP::HepRotation::phiX()
double CLHEP::HepRotation::phiY()
double CLHEP::HepRotation::phiZ()
double CLHEP::HepRotation::thetaX()
double CLHEP::HepRotation::thetaY()
double CLHEP::HepRotation::thetaZ()
CLHEP::HepLorentzVector CLHEP::HepRotation::col1()
CLHEP::HepLorentzVector CLHEP::HepRotation::col2()
CLHEP::HepLorentzVector CLHEP::HepRotation::col3()
CLHEP::HepLorentzVector CLHEP::HepRotation::col4()
CLHEP::HepLorentzVector CLHEP::HepRotation::row1()
CLHEP::HepLorentzVector CLHEP::HepRotation::row2()
CLHEP::HepLorentzVector CLHEP::HepRotation::row3()
CLHEP::HepLorentzVector CLHEP::HepRotation::row4()
double CLHEP::HepRotation::xt()
double CLHEP::HepRotation::yt()
double CLHEP::HepRotation::zt()
double CLHEP::HepRotation::tx()
double CLHEP::HepRotation::ty()
double CLHEP::HepRotation::tz()
double CLHEP::HepRotation::tt()
CLHEP::HepRep4x4 CLHEP::HepRotation::rep4x4()
void CLHEP::HepRotation::setPhi(double)
void CLHEP::HepRotation::setTheta(double)
void CLHEP::HepRotation::setPsi(double)
void CLHEP::HepRotation::setAxis(const CLHEP::Hep3Vector &)
void CLHEP::HepRotation::setDelta(double)
void CLHEP::HepRotation::decompose(CLHEP::HepAxisAngle &, CLHEP::Hep3Vector &)
void CLHEP::HepRotation::decompose(CLHEP::Hep3Vector &, CLHEP::HepAxisAngle &)
bool CLHEP::HepRotation::isIdentity()
int CLHEP::HepRotation::compare(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator==(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator!=(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator<(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator>(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator<=(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::operator>=(const CLHEP::HepRotation &)
double CLHEP::HepRotation::distance2(const CLHEP::HepRotation &)
double CLHEP::HepRotation::howNear(const CLHEP::HepRotation &)
bool CLHEP::HepRotation::isNear(const CLHEP::HepRotation &, double)
double CLHEP::HepRotation::distance2(const CLHEP::HepBoost &)
double CLHEP::HepRotation::distance2(const CLHEP::HepLorentzRotation &)
double CLHEP::HepRotation::howNear(const CLHEP::HepBoost &)
double CLHEP::HepRotation::howNear(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepRotation::isNear(const CLHEP::HepBoost &, double)
bool CLHEP::HepRotation::isNear(const CLHEP::HepLorentzRotation &, double)
double CLHEP::HepRotation::norm2()
void CLHEP::HepRotation::rectify()
CLHEP::Hep3Vector CLHEP::HepRotation::operator()(const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::HepRotation::operator*(const CLHEP::Hep3Vector &)
CLHEP::HepLorentzVector CLHEP::HepRotation::operator()(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzVector CLHEP::HepRotation::operator*(const CLHEP::HepLorentzVector &)
CLHEP::HepRotation CLHEP::HepRotation::operator*(const CLHEP::HepRotation &)
CLHEP::HepRotation CLHEP::HepRotation::operator*(const CLHEP::HepRotationX &)
CLHEP::HepRotation CLHEP::HepRotation::operator*(const CLHEP::HepRotationY &)
CLHEP::HepRotation CLHEP::HepRotation::operator*(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::operator*=(const CLHEP::HepRotation &)
CLHEP::HepRotation & CLHEP::HepRotation::transform(const CLHEP::HepRotation &)
CLHEP::HepRotation & CLHEP::HepRotation::operator*=(const CLHEP::HepRotationX &)
CLHEP::HepRotation & CLHEP::HepRotation::operator*=(const CLHEP::HepRotationY &)
CLHEP::HepRotation & CLHEP::HepRotation::operator*=(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::transform(const CLHEP::HepRotationX &)
CLHEP::HepRotation & CLHEP::HepRotation::transform(const CLHEP::HepRotationY &)
CLHEP::HepRotation & CLHEP::HepRotation::transform(const CLHEP::HepRotationZ &)
CLHEP::HepRotation & CLHEP::HepRotation::rotateX(double)
CLHEP::HepRotation & CLHEP::HepRotation::rotateY(double)
CLHEP::HepRotation & CLHEP::HepRotation::rotateZ(double)
CLHEP::HepRotation & CLHEP::HepRotation::rotate(double, const CLHEP::Hep3Vector &)
CLHEP::HepRotation & CLHEP::HepRotation::rotate(double, const CLHEP::Hep3Vector *)
CLHEP::HepRotation & CLHEP::HepRotation::rotateAxes(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::HepRotation CLHEP::HepRotation::inverse()
CLHEP::HepRotation & CLHEP::HepRotation::invert()
double CLHEP::HepRotation::getTolerance()
double CLHEP::HepRotation::setTolerance(double)
void CLHEP::HepEulerAngles::HepEulerAngles(double, double, double)
double CLHEP::HepEulerAngles::getPhi()
double CLHEP::HepEulerAngles::phi()
CLHEP::HepEulerAngles::EA & CLHEP::HepEulerAngles::setPhi(double)
double CLHEP::HepEulerAngles::getTheta()
double CLHEP::HepEulerAngles::theta()
CLHEP::HepEulerAngles::EA & CLHEP::HepEulerAngles::setTheta(double)
double CLHEP::HepEulerAngles::getPsi()
double CLHEP::HepEulerAngles::psi()
CLHEP::HepEulerAngles::EA & CLHEP::HepEulerAngles::setPsi(double)
CLHEP::HepEulerAngles::EA & CLHEP::HepEulerAngles::set(double, double, double)
int CLHEP::HepEulerAngles::compare(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator==(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator!=(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator<(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator<=(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator>(const CLHEP::HepEulerAngles::EA &)
bool CLHEP::HepEulerAngles::operator>=(const CLHEP::HepEulerAngles::EA &)
double CLHEP::HepEulerAngles::getTolerance()
double CLHEP::HepEulerAngles::setTolerance(double)
bool CLHEP::HepEulerAngles::isNear(const CLHEP::HepEulerAngles::EA &, double)
double CLHEP::HepEulerAngles::howNear(const CLHEP::HepEulerAngles::EA &)
void CLHEP::HepRotation::HepRotation_row::HepRotation_row(const CLHEP::HepRotation &, int)
double CLHEP::HepRotation::HepRotation_row::operator[](int)
void CLHEP::HepBoost::HepBoost(const CLHEP::HepBoost &)
void CLHEP::HepBoost::HepBoost(CLHEP::HepBoost &&)
CLHEP::HepBoost & CLHEP::HepBoost::operator=(const CLHEP::HepBoost &)
CLHEP::HepBoost & CLHEP::HepBoost::operator=(CLHEP::HepBoost &&)
CLHEP::HepBoost & CLHEP::HepBoost::set(double, double, double)
void CLHEP::HepBoost::HepBoost(double, double, double)
CLHEP::HepBoost & CLHEP::HepBoost::set(const CLHEP::HepRep4x4Symmetric &)
void CLHEP::HepBoost::HepBoost(const CLHEP::HepRep4x4Symmetric &)
CLHEP::HepBoost & CLHEP::HepBoost::set(CLHEP::Hep3Vector, double)
void CLHEP::HepBoost::HepBoost(CLHEP::Hep3Vector, double)
CLHEP::HepBoost & CLHEP::HepBoost::set(const CLHEP::Hep3Vector &)
void CLHEP::HepBoost::HepBoost(const CLHEP::Hep3Vector &)
CLHEP::HepBoost & CLHEP::HepBoost::set(const CLHEP::HepBoostX &)
CLHEP::HepBoost & CLHEP::HepBoost::set(const CLHEP::HepBoostY &)
CLHEP::HepBoost & CLHEP::HepBoost::set(const CLHEP::HepBoostZ &)
void CLHEP::HepBoost::HepBoost(const CLHEP::HepBoostX &)
void CLHEP::HepBoost::HepBoost(const CLHEP::HepBoostY &)
void CLHEP::HepBoost::HepBoost(const CLHEP::HepBoostZ &)
double CLHEP::HepBoost::beta()
double CLHEP::HepBoost::gamma()
CLHEP::Hep3Vector CLHEP::HepBoost::boostVector()
CLHEP::Hep3Vector CLHEP::HepBoost::getDirection()
CLHEP::Hep3Vector CLHEP::HepBoost::direction()
double CLHEP::HepBoost::xx()
double CLHEP::HepBoost::xy()
double CLHEP::HepBoost::xz()
double CLHEP::HepBoost::xt()
double CLHEP::HepBoost::yx()
double CLHEP::HepBoost::yy()
double CLHEP::HepBoost::yz()
double CLHEP::HepBoost::yt()
double CLHEP::HepBoost::zx()
double CLHEP::HepBoost::zy()
double CLHEP::HepBoost::zz()
double CLHEP::HepBoost::zt()
double CLHEP::HepBoost::tx()
double CLHEP::HepBoost::ty()
double CLHEP::HepBoost::tz()
double CLHEP::HepBoost::tt()
CLHEP::HepLorentzVector CLHEP::HepBoost::col1()
CLHEP::HepLorentzVector CLHEP::HepBoost::col2()
CLHEP::HepLorentzVector CLHEP::HepBoost::col3()
CLHEP::HepLorentzVector CLHEP::HepBoost::col4()
CLHEP::HepLorentzVector CLHEP::HepBoost::row1()
CLHEP::HepLorentzVector CLHEP::HepBoost::row2()
CLHEP::HepLorentzVector CLHEP::HepBoost::row3()
CLHEP::HepLorentzVector CLHEP::HepBoost::row4()
CLHEP::HepRep4x4 CLHEP::HepBoost::rep4x4()
CLHEP::HepRep4x4Symmetric CLHEP::HepBoost::rep4x4Symmetric()
void CLHEP::HepBoost::decompose(CLHEP::HepRotation &, CLHEP::HepBoost &)
void CLHEP::HepBoost::decompose(CLHEP::HepAxisAngle &, CLHEP::Hep3Vector &)
void CLHEP::HepBoost::decompose(CLHEP::HepBoost &, CLHEP::HepRotation &)
void CLHEP::HepBoost::decompose(CLHEP::Hep3Vector &, CLHEP::HepAxisAngle &)
int CLHEP::HepBoost::compare(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator==(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator!=(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator<=(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator>=(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator<(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::operator>(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::isIdentity()
double CLHEP::HepBoost::distance2(const CLHEP::HepBoost &)
double CLHEP::HepBoost::distance2(const CLHEP::HepBoostX &)
double CLHEP::HepBoost::distance2(const CLHEP::HepBoostY &)
double CLHEP::HepBoost::distance2(const CLHEP::HepBoostZ &)
double CLHEP::HepBoost::distance2(const CLHEP::HepRotation &)
double CLHEP::HepBoost::distance2(const CLHEP::HepLorentzRotation &)
double CLHEP::HepBoost::howNear(const CLHEP::HepBoost &)
bool CLHEP::HepBoost::isNear(const CLHEP::HepBoost &, double)
double CLHEP::HepBoost::howNear(const CLHEP::HepRotation &)
double CLHEP::HepBoost::howNear(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepBoost::isNear(const CLHEP::HepRotation &, double)
bool CLHEP::HepBoost::isNear(const CLHEP::HepLorentzRotation &, double)
double CLHEP::HepBoost::norm2()
void CLHEP::HepBoost::rectify()
CLHEP::HepLorentzVector CLHEP::HepBoost::operator()(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzVector CLHEP::HepBoost::operator*(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzRotation CLHEP::HepBoost::operator*(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation CLHEP::HepBoost::operator*(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation CLHEP::HepBoost::operator*(const CLHEP::HepLorentzRotation &)
CLHEP::HepBoost CLHEP::HepBoost::inverse()
CLHEP::HepBoost & CLHEP::HepBoost::invert()
double CLHEP::HepBoost::getTolerance()
double CLHEP::HepBoost::setTolerance(double)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepLorentzRotation &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(CLHEP::HepLorentzRotation &&)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRotation &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRotationX &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRotationY &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRotationZ &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepBoost &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepBoostX &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepBoostY &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepBoostZ &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator=(CLHEP::HepLorentzRotation &&)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator=(const CLHEP::HepLorentzRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator=(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator=(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(double, double, double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::Hep3Vector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRotationX &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRotationY &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRotationZ &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepBoostX &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepBoostY &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepBoostZ &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(double, double, double)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::Hep3Vector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepBoost &, const CLHEP::HepRotation &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepBoost &, const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRotation &, const CLHEP::HepBoost &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRotation &, const CLHEP::HepBoost &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::setRows(const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &, const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::set(const CLHEP::HepRep4x4 &)
void CLHEP::HepLorentzRotation::HepLorentzRotation(const CLHEP::HepRep4x4 &)
double CLHEP::HepLorentzRotation::xx()
double CLHEP::HepLorentzRotation::xy()
double CLHEP::HepLorentzRotation::xz()
double CLHEP::HepLorentzRotation::xt()
double CLHEP::HepLorentzRotation::yx()
double CLHEP::HepLorentzRotation::yy()
double CLHEP::HepLorentzRotation::yz()
double CLHEP::HepLorentzRotation::yt()
double CLHEP::HepLorentzRotation::zx()
double CLHEP::HepLorentzRotation::zy()
double CLHEP::HepLorentzRotation::zz()
double CLHEP::HepLorentzRotation::zt()
double CLHEP::HepLorentzRotation::tx()
double CLHEP::HepLorentzRotation::ty()
double CLHEP::HepLorentzRotation::tz()
double CLHEP::HepLorentzRotation::tt()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::col1()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::col2()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::col3()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::col4()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::row1()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::row2()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::row3()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::row4()
CLHEP::HepRep4x4 CLHEP::HepLorentzRotation::rep4x4()
const CLHEP::HepLorentzRotation::HepLorentzRotation_row CLHEP::HepLorentzRotation::operator[](int)
double CLHEP::HepLorentzRotation::operator()(int, int)
void CLHEP::HepLorentzRotation::decompose(CLHEP::Hep3Vector &, CLHEP::HepAxisAngle &)
void CLHEP::HepLorentzRotation::decompose(CLHEP::HepBoost &, CLHEP::HepRotation &)
void CLHEP::HepLorentzRotation::decompose(CLHEP::HepAxisAngle &, CLHEP::Hep3Vector &)
void CLHEP::HepLorentzRotation::decompose(CLHEP::HepRotation &, CLHEP::HepBoost &)
int CLHEP::HepLorentzRotation::compare(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator==(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator!=(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator<=(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator>=(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator<(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::operator>(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::isIdentity()
double CLHEP::HepLorentzRotation::distance2(const CLHEP::HepBoost &)
double CLHEP::HepLorentzRotation::distance2(const CLHEP::HepRotation &)
double CLHEP::HepLorentzRotation::distance2(const CLHEP::HepLorentzRotation &)
double CLHEP::HepLorentzRotation::howNear(const CLHEP::HepBoost &)
double CLHEP::HepLorentzRotation::howNear(const CLHEP::HepRotation &)
double CLHEP::HepLorentzRotation::howNear(const CLHEP::HepLorentzRotation &)
bool CLHEP::HepLorentzRotation::isNear(const CLHEP::HepBoost &, double)
bool CLHEP::HepLorentzRotation::isNear(const CLHEP::HepRotation &, double)
bool CLHEP::HepLorentzRotation::isNear(const CLHEP::HepLorentzRotation &, double)
double CLHEP::HepLorentzRotation::norm2()
void CLHEP::HepLorentzRotation::rectify()
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::vectorMultiplication(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::operator()(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzVector CLHEP::HepLorentzRotation::operator*(const CLHEP::HepLorentzVector &)
CLHEP::HepLorentzRotation CLHEP::HepLorentzRotation::matrixMultiplication(const CLHEP::HepRep4x4 &)
CLHEP::HepLorentzRotation CLHEP::HepLorentzRotation::operator*(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation CLHEP::HepLorentzRotation::operator*(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation CLHEP::HepLorentzRotation::operator*(const CLHEP::HepLorentzRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator*=(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator*=(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::operator*=(const CLHEP::HepLorentzRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::transform(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::transform(const CLHEP::HepRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::transform(const CLHEP::HepLorentzRotation &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::rotateX(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::rotateY(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::rotateZ(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::rotate(double, const CLHEP::Hep3Vector &)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::rotate(double, const CLHEP::Hep3Vector *)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::boostX(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::boostY(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::boostZ(double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::boost(double, double, double)
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::boost(const CLHEP::Hep3Vector &)
CLHEP::HepLorentzRotation CLHEP::HepLorentzRotation::inverse()
CLHEP::HepLorentzRotation & CLHEP::HepLorentzRotation::invert()
double CLHEP::HepLorentzRotation::getTolerance()
double CLHEP::HepLorentzRotation::setTolerance(double)
void G4PVData::initialize()
void G4VPhysicalVolume::G4VPhysicalVolume(G4RotationMatrix *, const G4ThreeVector &, const G4String &, G4LogicalVolume *, G4VPhysicalVolume *)
G4bool G4VPhysicalVolume::operator==(const G4VPhysicalVolume &)
G4RotationMatrix * G4VPhysicalVolume::GetObjectRotation()
G4RotationMatrix G4VPhysicalVolume::GetObjectRotationValue()
G4ThreeVector G4VPhysicalVolume::GetObjectTranslation()
const G4RotationMatrix * G4VPhysicalVolume::GetFrameRotation()
G4ThreeVector G4VPhysicalVolume::GetFrameTranslation()
const G4ThreeVector G4VPhysicalVolume::GetTranslation()
const G4RotationMatrix * G4VPhysicalVolume::GetRotation()
void G4VPhysicalVolume::SetTranslation(const G4ThreeVector &)
G4RotationMatrix * G4VPhysicalVolume::GetRotation()
void G4VPhysicalVolume::SetRotation(G4RotationMatrix *)
G4LogicalVolume * G4VPhysicalVolume::GetLogicalVolume()
void G4VPhysicalVolume::SetLogicalVolume(G4LogicalVolume *)
G4LogicalVolume * G4VPhysicalVolume::GetMotherLogical()
void G4VPhysicalVolume::SetMotherLogical(G4LogicalVolume *)
const G4String & G4VPhysicalVolume::GetName()
void G4VPhysicalVolume::SetName(const G4String &)
G4int G4VPhysicalVolume::GetMultiplicity()
EVolume G4VPhysicalVolume::VolumeType()
G4bool G4VPhysicalVolume::IsMany()
G4int G4VPhysicalVolume::GetCopyNo()
void G4VPhysicalVolume::SetCopyNo(G4int)
G4bool G4VPhysicalVolume::IsReplicated()
G4bool G4VPhysicalVolume::IsParameterised()
G4VPVParameterisation * G4VPhysicalVolume::GetParameterisation()
void G4VPhysicalVolume::GetReplicationData(EAxis &, G4int &, G4double &, G4double &, G4bool &)
G4bool G4VPhysicalVolume::IsRegularStructure()
G4int G4VPhysicalVolume::GetRegularStructureId()
G4bool G4VPhysicalVolume::CheckOverlaps(G4int, G4double, G4bool, G4int)
G4int G4VPhysicalVolume::GetInstanceID()
void G4VPhysicalVolume::Clean()
EVolume G4VPhysicalVolume::DeduceVolumeType()
void G4LogicalVolume::G4LogicalVolume(G4VSolid *, G4Material *, const G4String &, G4FieldManager *, G4VSensitiveDetector *, G4UserLimits *, G4bool)
const G4String & G4LogicalVolume::GetName()
void G4LogicalVolume::SetName(const G4String &)
std::size_t G4LogicalVolume::GetNoDaughters()
G4VPhysicalVolume * G4LogicalVolume::GetDaughter(const std::size_t)
void G4LogicalVolume::AddDaughter(G4VPhysicalVolume *)
G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume *)
G4bool G4LogicalVolume::IsAncestor(const G4VPhysicalVolume *)
void G4LogicalVolume::RemoveDaughter(const G4VPhysicalVolume *)
void G4LogicalVolume::ClearDaughters()
G4int G4LogicalVolume::TotalVolumeEntities()
EVolume G4LogicalVolume::CharacteriseDaughters()
EVolume G4LogicalVolume::DeduceDaughtersType()
G4VSolid * G4LogicalVolume::GetSolid()
void G4LogicalVolume::SetSolid(G4VSolid *)
G4Material * G4LogicalVolume::GetMaterial()
void G4LogicalVolume::SetMaterial(G4Material *)
void G4LogicalVolume::UpdateMaterial(G4Material *)
G4double G4LogicalVolume::GetMass(G4bool, G4bool, G4Material *)
void G4LogicalVolume::ResetMass()
G4FieldManager * G4LogicalVolume::GetFieldManager()
void G4LogicalVolume::SetFieldManager(G4FieldManager *, G4bool)
G4VSensitiveDetector * G4LogicalVolume::GetSensitiveDetector()
void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector *)
G4UserLimits * G4LogicalVolume::GetUserLimits()
void G4LogicalVolume::SetUserLimits(G4UserLimits *)
G4SmartVoxelHeader * G4LogicalVolume::GetVoxelHeader()
void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader *)
G4double G4LogicalVolume::GetSmartless()
void G4LogicalVolume::SetSmartless(G4double)
G4bool G4LogicalVolume::IsToOptimise()
void G4LogicalVolume::SetOptimisation(G4bool)
G4bool G4LogicalVolume::IsRootRegion()
void G4LogicalVolume::SetRegionRootFlag(G4bool)
G4bool G4LogicalVolume::IsRegion()
void G4LogicalVolume::SetRegion(G4Region *)
G4Region * G4LogicalVolume::GetRegion()
void G4LogicalVolume::PropagateRegion()
const G4MaterialCutsCouple * G4LogicalVolume::GetMaterialCutsCouple()
void G4LogicalVolume::SetMaterialCutsCouple(G4MaterialCutsCouple *)
G4bool G4LogicalVolume::operator==(const G4LogicalVolume &)
const G4VisAttributes * G4LogicalVolume::GetVisAttributes()
void G4LogicalVolume::SetVisAttributes(const G4VisAttributes *)
void G4LogicalVolume::SetVisAttributes(const G4VisAttributes &)
G4FastSimulationManager * G4LogicalVolume::GetFastSimulationManager()
void G4LogicalVolume::SetBiasWeight(G4double)
G4double G4LogicalVolume::GetBiasWeight()
G4bool G4LogicalVolume::IsExtended()
G4FieldManager * G4LogicalVolume::GetMasterFieldManager()
G4VSensitiveDetector * G4LogicalVolume::GetMasterSensitiveDetector()
G4VSolid * G4LogicalVolume::GetMasterSolid()
G4int G4LogicalVolume::GetInstanceID()
void G4LogicalVolume::Clean()
void G4LogicalVolume::Lock()
void G4LogicalVolume::InitialiseWorker(G4LogicalVolume *, G4VSolid *, G4VSensitiveDetector *)
void G4LogicalVolume::TerminateWorker(G4LogicalVolume *)
void G4LogicalVolume::AssignFieldManager(G4FieldManager *)
G4VSolid * G4LogicalVolume::GetSolid(G4LVData &)
void G4LogicalVolume::SetSolid(G4LVData &, G4VSolid *)
G4bool G4LogicalVolume::ChangeDaughtersType(EVolume)
void HepGeom::Transform3D::Transform3D(const CLHEP::HepRotation &, const CLHEP::Hep3Vector &)
void HepGeom::Transform3D::Transform3D(const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &)
void HepGeom::Transform3D::Transform3D(const HepGeom::Transform3D &)
void HepGeom::Transform3D::Transform3D(HepGeom::Transform3D &&)
HepGeom::Transform3D & HepGeom::Transform3D::operator=(const HepGeom::Transform3D &)
HepGeom::Transform3D & HepGeom::Transform3D::operator=(HepGeom::Transform3D &&)
const HepGeom::Transform3D::Transform3D_row HepGeom::Transform3D::operator[](int)
double HepGeom::Transform3D::operator()(int, int)
double HepGeom::Transform3D::xx()
double HepGeom::Transform3D::xy()
double HepGeom::Transform3D::xz()
double HepGeom::Transform3D::yx()
double HepGeom::Transform3D::yy()
double HepGeom::Transform3D::yz()
double HepGeom::Transform3D::zx()
double HepGeom::Transform3D::zy()
double HepGeom::Transform3D::zz()
double HepGeom::Transform3D::dx()
double HepGeom::Transform3D::dy()
double HepGeom::Transform3D::dz()
void HepGeom::Transform3D::setIdentity()
HepGeom::Transform3D HepGeom::Transform3D::inverse()
HepGeom::Transform3D HepGeom::Transform3D::operator*(const HepGeom::Transform3D &)
void HepGeom::Transform3D::getDecomposition(HepGeom::Scale3D &, HepGeom::Rotate3D &, HepGeom::Translate3D &)
bool HepGeom::Transform3D::isNear(const HepGeom::Transform3D &, double)
CLHEP::HepRotation HepGeom::Transform3D::getRotation()
CLHEP::Hep3Vector HepGeom::Transform3D::getTranslation()
bool HepGeom::Transform3D::operator==(const HepGeom::Transform3D &)
bool HepGeom::Transform3D::operator!=(const HepGeom::Transform3D &)
void HepGeom::Transform3D::Transform3D_row::Transform3D_row(const HepGeom::Transform3D &, int)
double HepGeom::Transform3D::Transform3D_row::operator[](int)
void HepGeom::Scale3D::Scale3D(double, double, double)
void HepGeom::Scale3D::Scale3D(double)
void HepGeom::Rotate3D::Rotate3D(const CLHEP::HepRotation &)
void HepGeom::Rotate3D::Rotate3D(double, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &)
void HepGeom::Rotate3D::Rotate3D(double, const HepGeom::Vector3D<double> &)
void HepGeom::Rotate3D::Rotate3D(const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &, const HepGeom::Point3D<double> &)
void HepGeom::Translate3D::Translate3D(const CLHEP::Hep3Vector &)
void HepGeom::Translate3D::Translate3D(double, double, double)
void HepGeom::RotateX3D::RotateX3D(double)
void HepGeom::RotateY3D::RotateY3D(double)
void HepGeom::RotateZ3D::RotateZ3D(double)
void HepGeom::TranslateX3D::TranslateX3D(double)
void HepGeom::TranslateY3D::TranslateY3D(double)
void HepGeom::TranslateZ3D::TranslateZ3D(double)
void HepGeom::Reflect3D::Reflect3D(double, double, double, double)
void HepGeom::Reflect3D::Reflect3D(const HepGeom::Normal3D<double> &, const HepGeom::Point3D<double> &)
void HepGeom::ReflectX3D::ReflectX3D(double)
void HepGeom::ReflectY3D::ReflectY3D(double)
void HepGeom::ReflectZ3D::ReflectZ3D(double)
void HepGeom::ScaleX3D::ScaleX3D(double)
void HepGeom::ScaleY3D::ScaleY3D(double)
void HepGeom::ScaleZ3D::ScaleZ3D(double)
void G4AffineTransform::G4AffineTransform(const G4ThreeVector &)
void G4AffineTransform::G4AffineTransform(const G4RotationMatrix &)
void G4AffineTransform::G4AffineTransform(const G4RotationMatrix &, const G4ThreeVector &)
void G4AffineTransform::G4AffineTransform(const G4RotationMatrix *, const G4ThreeVector &)
void G4AffineTransform::G4AffineTransform(const G4AffineTransform &)
void G4AffineTransform::G4AffineTransform(G4AffineTransform &&)
G4AffineTransform & G4AffineTransform::operator=(const G4AffineTransform &)
G4AffineTransform & G4AffineTransform::operator=(G4AffineTransform &&)
G4AffineTransform G4AffineTransform::operator*(const G4AffineTransform &)
G4AffineTransform & G4AffineTransform::operator*=(const G4AffineTransform &)
G4AffineTransform & G4AffineTransform::Product(const G4AffineTransform &, const G4AffineTransform &)
G4AffineTransform & G4AffineTransform::InverseProduct(const G4AffineTransform &, const G4AffineTransform &)
G4ThreeVector G4AffineTransform::TransformPoint(const G4ThreeVector &)
G4ThreeVector G4AffineTransform::InverseTransformPoint(const G4ThreeVector &)
G4ThreeVector G4AffineTransform::TransformAxis(const G4ThreeVector &)
G4ThreeVector G4AffineTransform::InverseTransformAxis(const G4ThreeVector &)
void G4AffineTransform::ApplyPointTransform(G4ThreeVector &)
void G4AffineTransform::ApplyAxisTransform(G4ThreeVector &)
G4AffineTransform G4AffineTransform::Inverse()
G4AffineTransform & G4AffineTransform::Invert()
G4AffineTransform & G4AffineTransform::operator+=(const G4ThreeVector &)
G4AffineTransform & G4AffineTransform::operator-=(const G4ThreeVector &)
G4bool G4AffineTransform::operator==(const G4AffineTransform &)
G4bool G4AffineTransform::operator!=(const G4AffineTransform &)
G4double G4AffineTransform::operator[](const G4int)
G4bool G4AffineTransform::IsRotated()
G4bool G4AffineTransform::IsTranslated()
G4RotationMatrix G4AffineTransform::NetRotation()
G4RotationMatrix G4AffineTransform::InverseNetRotation()
G4ThreeVector G4AffineTransform::NetTranslation()
G4ThreeVector G4AffineTransform::InverseNetTranslation()
void G4AffineTransform::SetNetRotation(const G4RotationMatrix &)
void G4AffineTransform::SetNetTranslation(const G4ThreeVector &)
void G4NavigationHistory::G4NavigationHistory(const G4NavigationHistory &)
G4NavigationHistory & G4NavigationHistory::operator=(const G4NavigationHistory &)
void G4NavigationHistory::Reset()
void G4NavigationHistory::Clear()
void G4NavigationHistory::SetFirstEntry(G4VPhysicalVolume *)
const G4AffineTransform & G4NavigationHistory::GetTopTransform()
const G4AffineTransform * G4NavigationHistory::GetPtrTopTransform()
G4int G4NavigationHistory::GetTopReplicaNo()
EVolume G4NavigationHistory::GetTopVolumeType()
G4VPhysicalVolume * G4NavigationHistory::GetTopVolume()
std::size_t G4NavigationHistory::GetDepth()
std::size_t G4NavigationHistory::GetMaxDepth()
const G4AffineTransform & G4NavigationHistory::GetTransform(G4int)
G4int G4NavigationHistory::GetReplicaNo(G4int)
EVolume G4NavigationHistory::GetVolumeType(G4int)
G4VPhysicalVolume * G4NavigationHistory::GetVolume(G4int)
void G4NavigationHistory::NewLevel(G4VPhysicalVolume *, EVolume, G4int)
void G4NavigationHistory::BackLevel()
void G4NavigationHistory::BackLevel(G4int)
void G4LVData::initialize()
void G4VSolid::G4VSolid(const G4String &)
G4bool G4VSolid::operator==(const G4VSolid &)
G4String G4VSolid::GetName()
void G4VSolid::SetName(const G4String &)
G4double G4VSolid::GetTolerance()
void G4VSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4VSolid::Inside(const G4ThreeVector &)
G4ThreeVector G4VSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4VSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4VSolid::DistanceToIn(const G4ThreeVector &)
G4double G4VSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4VSolid::DistanceToOut(const G4ThreeVector &)
void G4VSolid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4double G4VSolid::GetCubicVolume()
G4double G4VSolid::GetSurfaceArea()
G4GeometryType G4VSolid::GetEntityType()
G4ThreeVector G4VSolid::GetPointOnSurface()
G4int G4VSolid::GetNumOfConstituents()
G4bool G4VSolid::IsFaceted()
G4VSolid * G4VSolid::Clone()
void G4VSolid::DumpInfo()
G4Polyhedron * G4VSolid::CreatePolyhedron()
G4Polyhedron * G4VSolid::GetPolyhedron()
const G4VSolid * G4VSolid::GetConstituentSolid(G4int)
G4VSolid * G4VSolid::GetConstituentSolid(G4int)
const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr()
G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr()
void G4VSolid::G4VSolid(const G4VSolid &)
G4VSolid & G4VSolid::operator=(const G4VSolid &)
G4double G4VSolid::EstimateCubicVolume(G4int, G4double)
G4double G4VSolid::EstimateSurfaceArea(G4int, G4double)
void G4VSensitiveDetector::G4VSensitiveDetector(const G4String &)
void G4VSensitiveDetector::G4VSensitiveDetector(const G4VSensitiveDetector &)
G4VSensitiveDetector & G4VSensitiveDetector::operator=(const G4VSensitiveDetector &)
G4bool G4VSensitiveDetector::operator==(const G4VSensitiveDetector &)
G4bool G4VSensitiveDetector::operator!=(const G4VSensitiveDetector &)
void G4VSensitiveDetector::Initialize(G4HCofThisEvent *)
void G4VSensitiveDetector::EndOfEvent(G4HCofThisEvent *)
void G4VSensitiveDetector::clear()
void G4VSensitiveDetector::DrawAll()
void G4VSensitiveDetector::PrintAll()
G4bool G4VSensitiveDetector::Hit(G4Step *)
void G4VSensitiveDetector::SetROgeometry(G4VReadOutGeometry *)
void G4VSensitiveDetector::SetFilter(G4VSDFilter *)
G4int G4VSensitiveDetector::GetNumberOfCollections()
const G4String & G4VSensitiveDetector::GetCollectionName(G4int)
void G4VSensitiveDetector::SetVerboseLevel(G4int)
void G4VSensitiveDetector::Activate(G4bool)
G4bool G4VSensitiveDetector::isActive()
const G4String & G4VSensitiveDetector::GetName()
const G4String & G4VSensitiveDetector::GetPathName()
const G4String & G4VSensitiveDetector::GetFullPathName()
G4VReadOutGeometry * G4VSensitiveDetector::GetROgeometry()
G4VSDFilter * G4VSensitiveDetector::GetFilter()
G4VSensitiveDetector * G4VSensitiveDetector::Clone()
void G4Material::G4Material(const G4String &, G4double, G4double, G4double, G4State, G4double, G4double)
void G4Material::G4Material(const G4String &, G4double, G4int, G4State, G4double, G4double)
void G4Material::G4Material(const G4String &, G4double, const G4Material *, G4State, G4double, G4double)
void G4Material::SetChemicalFormula(const G4String &)
void G4Material::SetFreeElectronDensity(G4double)
void G4Material::ComputeDensityEffectOnFly(G4bool)
void G4Material::AddElementByNumberOfAtoms(const G4Element *, G4int)
void G4Material::AddElement(G4Element *, G4int)
void G4Material::AddElementByMassFraction(const G4Element *, G4double)
void G4Material::AddElement(G4Element *, G4double)
void G4Material::AddMaterial(G4Material *, G4double)
const G4String & G4Material::GetName()
const G4String & G4Material::GetChemicalFormula()
G4double G4Material::GetFreeElectronDensity()
G4double G4Material::GetDensity()
G4State G4Material::GetState()
G4double G4Material::GetTemperature()
G4double G4Material::GetPressure()
std::size_t G4Material::GetNumberOfElements()
const G4ElementVector * G4Material::GetElementVector()
const G4double * G4Material::GetFractionVector()
const G4int * G4Material::GetAtomsVector()
const G4Element * G4Material::GetElement(G4int)
const G4double * G4Material::GetVecNbOfAtomsPerVolume()
G4double G4Material::GetTotNbOfAtomsPerVolume()
G4double G4Material::GetTotNbOfElectPerVolume()
const G4double * G4Material::GetAtomicNumDensityVector()
G4double G4Material::GetElectronDensity()
G4double G4Material::GetRadlen()
G4double G4Material::GetNuclearInterLength()
G4IonisParamMat * G4Material::GetIonisation()
G4SandiaTable * G4Material::GetSandiaTable()
const G4Material * G4Material::GetBaseMaterial()
G4double G4Material::GetMassOfMolecule()
G4double G4Material::GetZ()
G4double G4Material::GetA()
void G4Material::SetMaterialPropertiesTable(G4MaterialPropertiesTable *)
G4MaterialPropertiesTable * G4Material::GetMaterialPropertiesTable()
std::size_t G4Material::GetIndex()
G4MaterialTable * G4Material::GetMaterialTable()
std::size_t G4Material::GetNumberOfMaterials()
G4Material * G4Material::GetMaterial(const G4String &, G4bool)
G4Material * G4Material::GetMaterial(G4double, G4double, G4double)
G4Material * G4Material::GetMaterial(std::size_t, G4double)
void G4Material::SetName(const G4String &)
G4bool G4Material::IsExtended()
void G4UserLimits::G4UserLimits(G4double, G4double, G4double, G4double, G4double)
void G4UserLimits::G4UserLimits(const G4String &, G4double, G4double, G4double, G4double, G4double)
G4double G4UserLimits::GetMaxAllowedStep(const G4Track &)
G4double G4UserLimits::GetUserMaxTrackLength(const G4Track &)
G4double G4UserLimits::GetUserMaxTime(const G4Track &)
G4double G4UserLimits::GetUserMinEkine(const G4Track &)
G4double G4UserLimits::GetUserMinRange(const G4Track &)
void G4UserLimits::SetMaxAllowedStep(G4double)
void G4UserLimits::SetUserMaxTrackLength(G4double)
void G4UserLimits::SetUserMaxTime(G4double)
void G4UserLimits::SetUserMinEkine(G4double)
void G4UserLimits::SetUserMinRange(G4double)
const G4String & G4UserLimits::GetType()
void G4UserLimits::SetType(const G4String &)
void G4VisAttributes::G4VisAttributes(G4bool)
void G4VisAttributes::G4VisAttributes(const G4Colour &)
void G4VisAttributes::G4VisAttributes(G4bool, const G4Colour &)
void G4VisAttributes::G4VisAttributes(const G4VisAttributes &)
G4VisAttributes & G4VisAttributes::operator=(const G4VisAttributes &)
const G4VisAttributes & G4VisAttributes::GetInvisible()
G4bool G4VisAttributes::operator!=(const G4VisAttributes &)
G4bool G4VisAttributes::operator==(const G4VisAttributes &)
void G4VisAttributes::SetVisibility(G4bool)
void G4VisAttributes::SetDaughtersInvisible(G4bool)
void G4VisAttributes::SetColour(const G4Colour &)
void G4VisAttributes::SetColor(const G4Color &)
void G4VisAttributes::SetColour(G4double, G4double, G4double, G4double)
void G4VisAttributes::SetColor(G4double, G4double, G4double, G4double)
void G4VisAttributes::SetLineStyle(G4VisAttributes::LineStyle)
void G4VisAttributes::SetLineWidth(G4double)
void G4VisAttributes::SetForceWireframe(G4bool)
void G4VisAttributes::SetForceSolid(G4bool)
void G4VisAttributes::SetForceCloud(G4bool)
void G4VisAttributes::SetForceNumberOfCloudPoints(G4int)
void G4VisAttributes::SetForceAuxEdgeVisible(G4bool)
void G4VisAttributes::SetForceLineSegmentsPerCircle(G4int)
void G4VisAttributes::SetStartTime(G4double)
void G4VisAttributes::SetEndTime(G4double)
void G4VisAttributes::SetAttValues(const std::vector<G4AttValue> *)
G4bool G4VisAttributes::IsVisible()
G4bool G4VisAttributes::IsDaughtersInvisible()
const G4Colour & G4VisAttributes::GetColour()
const G4Color & G4VisAttributes::GetColor()
G4VisAttributes::LineStyle G4VisAttributes::GetLineStyle()
G4double G4VisAttributes::GetLineWidth()
G4bool G4VisAttributes::IsForceDrawingStyle()
G4VisAttributes::ForcedDrawingStyle G4VisAttributes::GetForcedDrawingStyle()
G4int G4VisAttributes::GetForcedNumberOfCloudPoints()
G4bool G4VisAttributes::IsForceAuxEdgeVisible()
G4bool G4VisAttributes::IsForcedAuxEdgeVisible()
G4bool G4VisAttributes::IsForceLineSegmentsPerCircle()
G4int G4VisAttributes::GetForcedLineSegmentsPerCircle()
G4double G4VisAttributes::GetStartTime()
G4double G4VisAttributes::GetEndTime()
G4int G4VisAttributes::GetMinLineSegmentsPerCircle()
const std::vector<G4AttValue> * G4VisAttributes::CreateAttValues()
void G4FastSimulationManager::G4FastSimulationManager(G4Envelope *, G4bool)
void G4FastSimulationManager::AddFastSimulationModel(G4VFastSimulationModel *)
void G4FastSimulationManager::RemoveFastSimulationModel(G4VFastSimulationModel *)
G4bool G4FastSimulationManager::ActivateFastSimulationModel(const G4String &)
G4bool G4FastSimulationManager::InActivateFastSimulationModel(const G4String &)
void G4FastSimulationManager::ListTitle()
void G4FastSimulationManager::ListModels()
void G4FastSimulationManager::ListModels(const G4ParticleDefinition *)
void G4FastSimulationManager::ListModels(const G4String &)
const G4Envelope * G4FastSimulationManager::GetEnvelope()
G4VFastSimulationModel * G4FastSimulationManager::GetFastSimulationModel(const G4String &, const G4VFastSimulationModel *, G4bool &)
const std::vector<G4VFastSimulationModel *> & G4FastSimulationManager::GetFastSimulationModelList()
void G4FastSimulationManager::FlushModels()
G4bool G4FastSimulationManager::PostStepGetFastSimulationManagerTrigger(const G4Track &, const G4Navigator *)
G4VParticleChange * G4FastSimulationManager::InvokePostStepDoIt()
G4bool G4FastSimulationManager::AtRestGetFastSimulationManagerTrigger(const G4Track &, const G4Navigator *)
G4VParticleChange * G4FastSimulationManager::InvokeAtRestDoIt()
G4bool G4FastSimulationManager::operator==(const G4FastSimulationManager &)
void G4TouchableHistory::G4TouchableHistory(const G4NavigationHistory &)
G4VPhysicalVolume * G4TouchableHistory::GetVolume(G4int)
G4VSolid * G4TouchableHistory::GetSolid(G4int)
const G4ThreeVector & G4TouchableHistory::GetTranslation(G4int)
const G4RotationMatrix * G4TouchableHistory::GetRotation(G4int)
G4int G4TouchableHistory::GetReplicaNumber(G4int)
G4int G4TouchableHistory::GetCopyNumber(G4int)
G4int G4TouchableHistory::GetHistoryDepth()
G4int G4TouchableHistory::MoveUpHistory(G4int)
void G4TouchableHistory::UpdateYourself(G4VPhysicalVolume *, const G4NavigationHistory *)
const G4NavigationHistory * G4TouchableHistory::GetHistory()
void G4Isotope::G4Isotope(const G4String &, G4int, G4int, G4double, G4int)
const G4String & G4Isotope::GetName()
G4int G4Isotope::GetZ()
G4int G4Isotope::GetN()
G4double G4Isotope::GetA()
G4int G4Isotope::Getm()
G4Isotope * G4Isotope::GetIsotope(const G4String &, G4bool)
const G4IsotopeTable * G4Isotope::GetIsotopeTable()
std::size_t G4Isotope::GetNumberOfIsotopes()
std::size_t G4Isotope::GetIndex()
G4bool G4Isotope::operator==(const G4Isotope &)
G4bool G4Isotope::operator!=(const G4Isotope &)
void G4Isotope::SetName(const G4String &)
void G4Element::G4Element(const G4String &, const G4String &, G4double, G4double)
void G4Element::G4Element(const G4String &, const G4String &, G4int)
void G4Element::AddIsotope(G4Isotope *, G4double)
const G4String & G4Element::GetName()
const G4String & G4Element::GetSymbol()
G4double G4Element::GetZ()
G4int G4Element::GetZasInt()
G4double G4Element::GetN()
G4double G4Element::GetAtomicMassAmu()
G4double G4Element::GetA()
G4bool G4Element::GetNaturalAbundanceFlag()
void G4Element::SetNaturalAbundanceFlag(G4bool)
G4int G4Element::GetNbOfAtomicShells()
G4double G4Element::GetAtomicShell(G4int)
G4int G4Element::GetNbOfShellElectrons(G4int)
std::size_t G4Element::GetNumberOfIsotopes()
G4IsotopeVector * G4Element::GetIsotopeVector()
G4double * G4Element::GetRelativeAbundanceVector()
const G4Isotope * G4Element::GetIsotope(G4int)
const G4ElementTable * G4Element::GetElementTable()
std::size_t G4Element::GetNumberOfElements()
std::size_t G4Element::GetIndex()
G4Element * G4Element::GetElement(const G4String &, G4bool)
G4double G4Element::GetfCoulomb()
G4double G4Element::GetfRadTsai()
G4IonisParamElm * G4Element::GetIonisation()
void G4Element::SetName(const G4String &)
void G4MaterialPropertiesTable::AddConstProperty(const G4String &, G4double, G4bool)
G4MaterialPropertyVector * G4MaterialPropertiesTable::AddProperty(const G4String &, const std::vector<G4double> &, const std::vector<G4double> &, G4bool, G4bool)
void G4MaterialPropertiesTable::AddProperty(const G4String &, G4MaterialPropertyVector *, G4bool)
void G4MaterialPropertiesTable::AddProperty(const char *, G4MaterialPropertyVector *, G4bool)
void G4MaterialPropertiesTable::AddProperty(const G4String &, const G4String &)
void G4MaterialPropertiesTable::RemoveConstProperty(const G4String &)
void G4MaterialPropertiesTable::RemoveConstProperty(const char *)
void G4MaterialPropertiesTable::RemoveProperty(const G4String &)
void G4MaterialPropertiesTable::RemoveProperty(const char *)
G4double G4MaterialPropertiesTable::GetConstProperty(const G4String &)
G4double G4MaterialPropertiesTable::GetConstProperty(const char *)
G4double G4MaterialPropertiesTable::GetConstProperty(const G4int)
G4bool G4MaterialPropertiesTable::ConstPropertyExists(const G4String &)
G4bool G4MaterialPropertiesTable::ConstPropertyExists(const char *)
G4bool G4MaterialPropertiesTable::ConstPropertyExists(const G4int)
G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty(const G4String &)
G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty(const G4int)
void G4MaterialPropertiesTable::AddEntry(const G4String &, G4double, G4double)
void G4MaterialPropertiesTable::AddEntry(const char *, G4double, G4double)
G4int G4MaterialPropertiesTable::GetConstPropertyIndex(const G4String &)
G4int G4MaterialPropertiesTable::GetPropertyIndex(const G4String &)
void G4MaterialPropertiesTable::DumpTable()
const std::vector<G4String> & G4MaterialPropertiesTable::GetMaterialPropertyNames()
const std::vector<G4String> & G4MaterialPropertiesTable::GetMaterialConstPropertyNames()
const std::vector<G4MaterialPropertyVector *> & G4MaterialPropertiesTable::GetProperties()
const std::vector<std::pair<G4double,G4bool>> & G4MaterialPropertiesTable::GetConstProperties()
void G4StepPoint::G4StepPoint(const G4StepPoint &)
G4StepPoint & G4StepPoint::operator=(const G4StepPoint &)
const G4ThreeVector & G4StepPoint::GetPosition()
void G4StepPoint::SetPosition(const G4ThreeVector &)
void G4StepPoint::AddPosition(const G4ThreeVector &)
G4double G4StepPoint::GetLocalTime()
void G4StepPoint::SetLocalTime(const G4double)
void G4StepPoint::AddLocalTime(const G4double)
G4double G4StepPoint::GetGlobalTime()
void G4StepPoint::SetGlobalTime(const G4double)
void G4StepPoint::AddGlobalTime(const G4double)
G4double G4StepPoint::GetProperTime()
void G4StepPoint::SetProperTime(const G4double)
void G4StepPoint::AddProperTime(const G4double)
const G4ThreeVector & G4StepPoint::GetMomentumDirection()
void G4StepPoint::SetMomentumDirection(const G4ThreeVector &)
void G4StepPoint::AddMomentumDirection(const G4ThreeVector &)
G4ThreeVector G4StepPoint::GetMomentum()
G4double G4StepPoint::GetTotalEnergy()
G4double G4StepPoint::GetKineticEnergy()
void G4StepPoint::SetKineticEnergy(const G4double)
void G4StepPoint::AddKineticEnergy(const G4double)
G4double G4StepPoint::GetVelocity()
void G4StepPoint::SetVelocity(G4double)
G4double G4StepPoint::GetBeta()
G4double G4StepPoint::GetGamma()
G4VPhysicalVolume * G4StepPoint::GetPhysicalVolume()
const G4VTouchable * G4StepPoint::GetTouchable()
const G4TouchableHandle & G4StepPoint::GetTouchableHandle()
void G4StepPoint::SetTouchableHandle(const G4TouchableHandle &)
G4Material * G4StepPoint::GetMaterial()
void G4StepPoint::SetMaterial(G4Material *)
const G4MaterialCutsCouple * G4StepPoint::GetMaterialCutsCouple()
void G4StepPoint::SetMaterialCutsCouple(const G4MaterialCutsCouple *)
G4VSensitiveDetector * G4StepPoint::GetSensitiveDetector()
void G4StepPoint::SetSensitiveDetector(G4VSensitiveDetector *)
G4double G4StepPoint::GetSafety()
void G4StepPoint::SetSafety(const G4double)
const G4ThreeVector & G4StepPoint::GetPolarization()
void G4StepPoint::SetPolarization(const G4ThreeVector &)
void G4StepPoint::AddPolarization(const G4ThreeVector &)
G4StepStatus G4StepPoint::GetStepStatus()
void G4StepPoint::SetStepStatus(const G4StepStatus)
const G4VProcess * G4StepPoint::GetProcessDefinedStep()
void G4StepPoint::SetProcessDefinedStep(const G4VProcess *)
G4double G4StepPoint::GetMass()
void G4StepPoint::SetMass(G4double)
G4double G4StepPoint::GetCharge()
void G4StepPoint::SetCharge(G4double)
G4double G4StepPoint::GetMagneticMoment()
void G4StepPoint::SetMagneticMoment(G4double)
void G4StepPoint::SetWeight(G4double)
G4double G4StepPoint::GetWeight()
void G4VProcess::G4VProcess(const G4String &, G4ProcessType)
void G4VProcess::G4VProcess(const G4VProcess &)
G4bool G4VProcess::operator==(const G4VProcess &)
G4bool G4VProcess::operator!=(const G4VProcess &)
G4VParticleChange * G4VProcess::PostStepDoIt(const G4Track &, const G4Step &)
G4VParticleChange * G4VProcess::AlongStepDoIt(const G4Track &, const G4Step &)
G4VParticleChange * G4VProcess::AtRestDoIt(const G4Track &, const G4Step &)
G4double G4VProcess::AlongStepGetPhysicalInteractionLength(const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
G4double G4VProcess::AtRestGetPhysicalInteractionLength(const G4Track &, G4ForceCondition *)
G4double G4VProcess::PostStepGetPhysicalInteractionLength(const G4Track &, G4double, G4ForceCondition *)
G4double G4VProcess::GetCurrentInteractionLength()
void G4VProcess::SetPILfactor(G4double)
G4double G4VProcess::GetPILfactor()
G4double G4VProcess::AlongStepGPIL(const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
G4double G4VProcess::AtRestGPIL(const G4Track &, G4ForceCondition *)
G4double G4VProcess::PostStepGPIL(const G4Track &, G4double, G4ForceCondition *)
G4bool G4VProcess::IsApplicable(const G4ParticleDefinition &)
void G4VProcess::BuildPhysicsTable(const G4ParticleDefinition &)
void G4VProcess::PreparePhysicsTable(const G4ParticleDefinition &)
G4bool G4VProcess::StorePhysicsTable(const G4ParticleDefinition *, const G4String &, G4bool)
G4bool G4VProcess::RetrievePhysicsTable(const G4ParticleDefinition *, const G4String &, G4bool)
const G4String & G4VProcess::GetPhysicsTableFileName(const G4ParticleDefinition *, const G4String &, const G4String &, G4bool)
const G4String & G4VProcess::GetProcessName()
G4ProcessType G4VProcess::GetProcessType()
void G4VProcess::SetProcessType(G4ProcessType)
G4int G4VProcess::GetProcessSubType()
void G4VProcess::SetProcessSubType(G4int)
const G4String & G4VProcess::GetProcessTypeName(G4ProcessType)
const G4VProcess * G4VProcess::GetCreatorProcess()
void G4VProcess::StartTracking(G4Track *)
void G4VProcess::EndTracking()
void G4VProcess::SetProcessManager(const G4ProcessManager *)
const G4ProcessManager * G4VProcess::GetProcessManager()
void G4VProcess::ResetNumberOfInteractionLengthLeft()
G4double G4VProcess::GetNumberOfInteractionLengthLeft()
G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed()
G4bool G4VProcess::isAtRestDoItIsEnabled()
G4bool G4VProcess::isAlongStepDoItIsEnabled()
G4bool G4VProcess::isPostStepDoItIsEnabled()
void G4VProcess::DumpInfo()
void G4VProcess::SetVerboseLevel(G4int)
G4int G4VProcess::GetVerboseLevel()
void G4VProcess::SetMasterProcess(G4VProcess *)
const G4VProcess * G4VProcess::GetMasterProcess()
void G4VProcess::BuildWorkerPhysicsTable(const G4ParticleDefinition &)
void G4VProcess::PrepareWorkerPhysicsTable(const G4ParticleDefinition &)
void G4Step::G4Step(const G4Step &)
G4Step & G4Step::operator=(const G4Step &)
G4Track * G4Step::GetTrack()
void G4Step::SetTrack(G4Track *)
G4StepPoint * G4Step::GetPreStepPoint()
void G4Step::SetPreStepPoint(G4StepPoint *)
G4StepPoint * G4Step::ResetPreStepPoint(G4StepPoint *)
G4StepPoint * G4Step::GetPostStepPoint()
void G4Step::SetPostStepPoint(G4StepPoint *)
G4StepPoint * G4Step::ResetPostStepPoint(G4StepPoint *)
G4double G4Step::GetStepLength()
void G4Step::SetStepLength(G4double)
G4double G4Step::GetTotalEnergyDeposit()
void G4Step::SetTotalEnergyDeposit(G4double)
G4double G4Step::GetNonIonizingEnergyDeposit()
void G4Step::SetNonIonizingEnergyDeposit(G4double)
G4SteppingControl G4Step::GetControlFlag()
void G4Step::SetControlFlag(G4SteppingControl)
void G4Step::AddTotalEnergyDeposit(G4double)
void G4Step::ResetTotalEnergyDeposit()
void G4Step::AddNonIonizingEnergyDeposit(G4double)
void G4Step::ResetNonIonizingEnergyDeposit()
G4bool G4Step::IsFirstStepInVolume()
G4bool G4Step::IsLastStepInVolume()
void G4Step::SetFirstStepFlag()
void G4Step::ClearFirstStepFlag()
void G4Step::SetLastStepFlag()
void G4Step::ClearLastStepFlag()
G4ThreeVector G4Step::GetDeltaPosition()
G4double G4Step::GetDeltaTime()
G4ThreeVector G4Step::GetDeltaMomentum()
G4double G4Step::GetDeltaEnergy()
void G4Step::InitializeStep(G4Track *)
void G4Step::UpdateTrack()
void G4Step::CopyPostToPreStepPoint()
void G4Step::SetPointerToVectorOfAuxiliaryPoints(std::vector<G4ThreeVector> *)
std::vector<G4ThreeVector> * G4Step::GetPointerToVectorOfAuxiliaryPoints()
std::size_t G4Step::GetNumberOfSecondariesInCurrentStep()
const std::vector<const G4Track *> * G4Step::GetSecondaryInCurrentStep()
const G4TrackVector * G4Step::GetSecondary()
G4TrackVector * G4Step::GetfSecondary()
G4TrackVector * G4Step::NewSecondaryVector()
void G4Step::DeleteSecondaryVector()
void G4Step::SetSecondary(G4TrackVector *)
G4VPhysicalVolume * G4VUserDetectorConstruction::Construct()
void G4VUserDetectorConstruction::ConstructSDandField()
void G4VUserDetectorConstruction::CloneSD()
void G4VUserDetectorConstruction::CloneF()
G4int G4VUserDetectorConstruction::ConstructParallelGeometries()
void G4VUserDetectorConstruction::ConstructParallelSD()
G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld()
void G4VUserActionInitialization::Build()
void G4VUserActionInitialization::BuildForMaster()
G4VSteppingVerbose * G4VUserActionInitialization::InitializeSteppingVerbose()
void G4VUserPrimaryGeneratorAction::GeneratePrimaries(G4Event *)
void G4Event::G4Event(G4int)
G4bool G4Event::operator==(const G4Event &)
G4bool G4Event::operator!=(const G4Event &)
void G4Event::Print()
void G4Event::Draw()
void G4Event::SetEventID(G4int)
void G4Event::SetHCofThisEvent(G4HCofThisEvent *)
void G4Event::SetDCofThisEvent(G4DCofThisEvent *)
void G4Event::SetTrajectoryContainer(G4TrajectoryContainer *)
void G4Event::SetEventAborted()
void G4Event::SetRandomNumberStatus(G4String &)
void G4Event::SetRandomNumberStatusForProcessing(G4String &)
void G4Event::KeepTheEvent(G4bool)
G4bool G4Event::KeepTheEventFlag()
G4bool G4Event::ToBeKept()
void G4Event::KeepForPostProcessing()
void G4Event::PostProcessingFinished()
G4int G4Event::GetNumberOfGrips()
G4int G4Event::GetEventID()
void G4Event::AddPrimaryVertex(G4PrimaryVertex *)
G4int G4Event::GetNumberOfPrimaryVertex()
G4PrimaryVertex * G4Event::GetPrimaryVertex(G4int)
G4HCofThisEvent * G4Event::GetHCofThisEvent()
G4DCofThisEvent * G4Event::GetDCofThisEvent()
G4TrajectoryContainer * G4Event::GetTrajectoryContainer()
G4bool G4Event::IsAborted()
void G4Event::SetUserInformation(G4VUserEventInformation *)
G4VUserEventInformation * G4Event::GetUserInformation()
const G4String & G4Event::GetRandomNumberStatus()
const G4String & G4Event::GetRandomNumberStatusForProcessing()
G4SubEvent * G4Event::PopSubEvent(G4int)
G4int G4Event::TerminateSubEvent(G4SubEvent *)
G4int G4Event::StoreSubEvent(G4int, G4SubEvent *)
G4int G4Event::SpawnSubEvent(G4SubEvent *)
G4int G4Event::GetNumberOfRemainingSubEvents()
G4int G4Event::GetNumberOfCompletedSubEvent()
void G4Event::MergeSubEventResults(const G4Event *)
void G4Event::FlagAsSubEvent(G4Event *, G4int)
G4Event * G4Event::GetMotherEvent()
G4int G4Event::GetSubEventType()
void G4Event::ScoresRecorded()
G4bool G4Event::ScoresAlreadyRecorded()
void G4Event::EventCompleted()
G4bool G4Event::IsEventCompleted()
void G4UserSteppingAction::SetSteppingManagerPointer(G4SteppingManager *)
void G4UserSteppingAction::UserSteppingAction(const G4Step *)
G4bool G4VPrimaryGenerator::CheckVertexInsideWorld(const G4ThreeVector &)
void G4VPrimaryGenerator::GeneratePrimaryVertex(G4Event *)
G4ThreeVector G4VPrimaryGenerator::GetParticlePosition()
G4double G4VPrimaryGenerator::GetParticleTime()
void G4VPrimaryGenerator::SetParticlePosition(G4ThreeVector)
void G4VPrimaryGenerator::SetParticleTime(G4double)
void G4VPrimaryGenerator::CheckInside(G4bool)
G4bool G4VPrimaryGenerator::IfCheckInside()
void G4PrimaryParticle::G4PrimaryParticle(G4int)
void G4PrimaryParticle::G4PrimaryParticle(G4int, G4double, G4double, G4double)
void G4PrimaryParticle::G4PrimaryParticle(G4int, G4double, G4double, G4double, G4double)
void G4PrimaryParticle::G4PrimaryParticle(const G4ParticleDefinition *)
void G4PrimaryParticle::G4PrimaryParticle(const G4ParticleDefinition *, G4double, G4double, G4double)
void G4PrimaryParticle::G4PrimaryParticle(const G4ParticleDefinition *, G4double, G4double, G4double, G4double)
void G4PrimaryParticle::G4PrimaryParticle(const G4PrimaryParticle &)
G4PrimaryParticle & G4PrimaryParticle::operator=(const G4PrimaryParticle &)
G4bool G4PrimaryParticle::operator==(const G4PrimaryParticle &)
G4bool G4PrimaryParticle::operator!=(const G4PrimaryParticle &)
void G4PrimaryParticle::Print()
G4int G4PrimaryParticle::GetPDGcode()
void G4PrimaryParticle::SetPDGcode(G4int)
G4ParticleDefinition * G4PrimaryParticle::GetG4code()
void G4PrimaryParticle::SetG4code(const G4ParticleDefinition *)
const G4ParticleDefinition * G4PrimaryParticle::GetParticleDefinition()
void G4PrimaryParticle::SetParticleDefinition(const G4ParticleDefinition *)
G4double G4PrimaryParticle::GetMass()
void G4PrimaryParticle::SetMass(G4double)
G4double G4PrimaryParticle::GetCharge()
void G4PrimaryParticle::SetCharge(G4double)
G4double G4PrimaryParticle::GetKineticEnergy()
void G4PrimaryParticle::SetKineticEnergy(G4double)
const G4ThreeVector & G4PrimaryParticle::GetMomentumDirection()
void G4PrimaryParticle::SetMomentumDirection(const G4ThreeVector &)
G4double G4PrimaryParticle::GetTotalMomentum()
void G4PrimaryParticle::Set4Momentum(G4double, G4double, G4double, G4double)
G4double G4PrimaryParticle::GetTotalEnergy()
void G4PrimaryParticle::SetTotalEnergy(G4double)
G4ThreeVector G4PrimaryParticle::GetMomentum()
void G4PrimaryParticle::SetMomentum(G4double, G4double, G4double)
G4double G4PrimaryParticle::GetPx()
G4double G4PrimaryParticle::GetPy()
G4double G4PrimaryParticle::GetPz()
G4PrimaryParticle * G4PrimaryParticle::GetNext()
void G4PrimaryParticle::SetNext(G4PrimaryParticle *)
void G4PrimaryParticle::ClearNext()
G4PrimaryParticle * G4PrimaryParticle::GetDaughter()
void G4PrimaryParticle::SetDaughter(G4PrimaryParticle *)
G4int G4PrimaryParticle::GetTrackID()
void G4PrimaryParticle::SetTrackID(G4int)
G4ThreeVector G4PrimaryParticle::GetPolarization()
void G4PrimaryParticle::SetPolarization(const G4ThreeVector &)
void G4PrimaryParticle::SetPolarization(G4double, G4double, G4double)
G4double G4PrimaryParticle::GetPolX()
G4double G4PrimaryParticle::GetPolY()
G4double G4PrimaryParticle::GetPolZ()
G4double G4PrimaryParticle::GetWeight()
void G4PrimaryParticle::SetWeight(G4double)
G4double G4PrimaryParticle::GetProperTime()
void G4PrimaryParticle::SetProperTime(G4double)
void G4PrimaryVertex::G4PrimaryVertex(G4double, G4double, G4double, G4double)
void G4PrimaryVertex::G4PrimaryVertex(G4ThreeVector, G4double)
void G4PrimaryVertex::G4PrimaryVertex(const G4PrimaryVertex &)
G4PrimaryVertex & G4PrimaryVertex::operator=(const G4PrimaryVertex &)
G4bool G4PrimaryVertex::operator==(const G4PrimaryVertex &)
G4bool G4PrimaryVertex::operator!=(const G4PrimaryVertex &)
G4ThreeVector G4PrimaryVertex::GetPosition()
void G4PrimaryVertex::SetPosition(G4double, G4double, G4double)
G4double G4PrimaryVertex::GetX0()
G4double G4PrimaryVertex::GetY0()
G4double G4PrimaryVertex::GetZ0()
G4double G4PrimaryVertex::GetT0()
void G4PrimaryVertex::SetT0(G4double)
G4int G4PrimaryVertex::GetNumberOfParticle()
void G4PrimaryVertex::SetPrimary(G4PrimaryParticle *)
G4PrimaryParticle * G4PrimaryVertex::GetPrimary(G4int)
void G4PrimaryVertex::SetNext(G4PrimaryVertex *)
void G4PrimaryVertex::ClearNext()
G4PrimaryVertex * G4PrimaryVertex::GetNext()
G4double G4PrimaryVertex::GetWeight()
void G4PrimaryVertex::SetWeight(G4double)
void G4PrimaryVertex::Print()
void G4ParticleGun::G4ParticleGun(G4int)
void G4ParticleGun::G4ParticleGun(G4ParticleDefinition *, G4int)
void G4ParticleGun::GeneratePrimaryVertex(G4Event *)
void G4ParticleGun::SetParticleDefinition(G4ParticleDefinition *)
void G4ParticleGun::SetParticleEnergy(G4double)
void G4ParticleGun::SetParticleMomentum(G4double)
void G4ParticleGun::SetParticleMomentum(G4ParticleMomentum)
void G4ParticleGun::SetParticleMomentumDirection(G4ParticleMomentum)
void G4ParticleGun::SetParticleCharge(G4double)
void G4ParticleGun::SetParticlePolarization(G4ThreeVector)
void G4ParticleGun::SetNumberOfParticles(G4int)
void G4ParticleGun::SetParticleWeight(G4double)
G4ParticleDefinition * G4ParticleGun::GetParticleDefinition()
G4ParticleMomentum G4ParticleGun::GetParticleMomentumDirection()
G4double G4ParticleGun::GetParticleEnergy()
G4double G4ParticleGun::GetParticleMomentum()
G4double G4ParticleGun::GetParticleCharge()
G4ThreeVector G4ParticleGun::GetParticlePolarization()
G4int G4ParticleGun::GetNumberOfParticles()
G4double G4ParticleGun::GetParticleWeight()
void G4UserWorkerInitialization::WorkerInitialize()
void G4UserWorkerInitialization::WorkerStart()
void G4UserWorkerInitialization::WorkerRunStart()
void G4UserWorkerInitialization::WorkerRunEnd()
void G4UserWorkerInitialization::WorkerStop()
void G4LogicalVolumeStore::Register(G4LogicalVolume *)
void G4LogicalVolumeStore::DeRegister(G4LogicalVolume *)
G4LogicalVolumeStore * G4LogicalVolumeStore::GetInstance()
void G4LogicalVolumeStore::SetNotifier(G4VStoreNotifier *)
void G4LogicalVolumeStore::Clean()
G4LogicalVolume * G4LogicalVolumeStore::GetVolume(const G4String &, G4bool, G4bool)
G4bool G4LogicalVolumeStore::IsMapValid()
void G4LogicalVolumeStore::SetMapValid(G4bool)
void G4LogicalVolumeStore::UpdateMap()
void G4VStateDependent::G4VStateDependent(G4bool)
G4bool G4VStateDependent::operator==(const G4VStateDependent &)
G4bool G4VStateDependent::operator!=(const G4VStateDependent &)
G4bool G4VStateDependent::Notify(G4ApplicationState)
void G4VStateDependent::NotifyDeletion(const G4Event *)
void G4VStateDependent::NotifyDeletion(const G4Run *)
void G4Run::RecordEvent(const G4Event *)
void G4Run::Merge(const G4Run *)
void G4Run::MergeSubEvent(G4Event *, const G4Event *)
void G4Run::StoreEvent(G4Event *)
G4int G4Run::GetRunID()
G4int G4Run::GetNumberOfEvent()
G4int G4Run::GetNumberOfEventToBeProcessed()
const G4HCtable * G4Run::GetHCtable()
const G4String & G4Run::GetRandomNumberStatus()
std::vector<const G4Event *> * G4Run::GetEventVector()
G4int G4Run::GetEventVectorSize()
G4int G4Run::GetNumberOfKeptEvents()
void G4Run::SetRunID(G4int)
void G4Run::SetNumberOfEventToBeProcessed(G4int)
void G4Run::SetHCtable(G4HCtable *)
void G4Run::SetRandomNumberStatus(G4String &)
void CLHEP::Hep2Vector::Hep2Vector(double, double)
void CLHEP::Hep2Vector::Hep2Vector(const CLHEP::Hep2Vector &)
void CLHEP::Hep2Vector::Hep2Vector(CLHEP::Hep2Vector &&)
void CLHEP::Hep2Vector::Hep2Vector(const CLHEP::Hep3Vector &)
double CLHEP::Hep2Vector::x()
double CLHEP::Hep2Vector::y()
double CLHEP::Hep2Vector::operator()(int)
double CLHEP::Hep2Vector::operator[](int)
double & CLHEP::Hep2Vector::operator()(int)
double & CLHEP::Hep2Vector::operator[](int)
void CLHEP::Hep2Vector::setX(double)
void CLHEP::Hep2Vector::setY(double)
void CLHEP::Hep2Vector::set(double, double)
double CLHEP::Hep2Vector::phi()
double CLHEP::Hep2Vector::mag2()
double CLHEP::Hep2Vector::mag()
double CLHEP::Hep2Vector::r()
void CLHEP::Hep2Vector::setPhi(double)
void CLHEP::Hep2Vector::setMag(double)
void CLHEP::Hep2Vector::setR(double)
void CLHEP::Hep2Vector::setPolar(double, double)
CLHEP::Hep2Vector & CLHEP::Hep2Vector::operator=(const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector & CLHEP::Hep2Vector::operator=(CLHEP::Hep2Vector &&)
bool CLHEP::Hep2Vector::operator==(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::operator!=(const CLHEP::Hep2Vector &)
int CLHEP::Hep2Vector::compare(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::operator>(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::operator<(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::operator>=(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::operator<=(const CLHEP::Hep2Vector &)
double CLHEP::Hep2Vector::getTolerance()
double CLHEP::Hep2Vector::setTolerance(double)
double CLHEP::Hep2Vector::howNear(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::isNear(const CLHEP::Hep2Vector &, double)
double CLHEP::Hep2Vector::howParallel(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::isParallel(const CLHEP::Hep2Vector &, double)
double CLHEP::Hep2Vector::howOrthogonal(const CLHEP::Hep2Vector &)
bool CLHEP::Hep2Vector::isOrthogonal(const CLHEP::Hep2Vector &, double)
CLHEP::Hep2Vector & CLHEP::Hep2Vector::operator+=(const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector & CLHEP::Hep2Vector::operator-=(const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector CLHEP::Hep2Vector::operator-()
CLHEP::Hep2Vector & CLHEP::Hep2Vector::operator*=(double)
CLHEP::Hep2Vector CLHEP::Hep2Vector::unit()
CLHEP::Hep2Vector CLHEP::Hep2Vector::orthogonal()
double CLHEP::Hep2Vector::dot(const CLHEP::Hep2Vector &)
double CLHEP::Hep2Vector::angle(const CLHEP::Hep2Vector &)
void CLHEP::Hep2Vector::rotate(double)
G4bool G4JLExceptionHandler::Notify(const char *, const char *, G4ExceptionSeverity, const char *)
void G4JLSensDet::G4JLSensDet(const G4String &, processhits_f, void *)
void G4JLSensDet::Initialize(G4HCofThisEvent *)
void G4JLSensDet::EndOfEvent(G4HCofThisEvent *)
G4bool G4JLSensDet::ProcessHits(G4Step *, G4TouchableHistory *)
void G4JLSensDet::SetInitialize(initend_f, void *)
void G4JLSensDet::SetEndOfEvent(initend_f, void *)
void G4JLDetectorConstruction::G4JLDetectorConstruction(construct_f, void *, sdandf_f, void *)
G4VPhysicalVolume * G4JLDetectorConstruction::Construct()
void G4JLDetectorConstruction::ConstructSDandField()
void G4JLDetectorConstruction::SetSensitiveDetector(const G4String &, G4JLSensDet *, G4bool)
void G4JLActionInitialization::G4JLActionInitialization(build_f, void *, build_f, void *)
void G4JLActionInitialization::BuildForMaster()
void G4JLActionInitialization::Build()
void G4JLActionInitialization::SetUserAction(G4VUserPrimaryGeneratorAction *)
void G4JLActionInitialization::SetUserAction(G4UserRunAction *)
void G4JLActionInitialization::SetUserAction(G4UserEventAction *)
void G4JLActionInitialization::SetUserAction(G4UserStackingAction *)
void G4JLActionInitialization::SetUserAction(G4UserTrackingAction *)
void G4JLActionInitialization::SetUserAction(G4UserSteppingAction *)
G4ParticleGun * G4JLParticleGun::GetGun()
void G4JLParticleGun::GeneratePrimaries(G4Event *)
void G4JLWorkerInitialization::WorkerInitialize()
void G4JLWorkerInitialization::WorkerStart()
void G4JLWorkerInitialization::WorkerRunStart()
void G4JLWorkerInitialization::WorkerRunEnd()
void G4JLWorkerInitialization::WorkerStop()
void G4JLGeneratorAction::G4JLGeneratorAction(generate_f, void *)
void G4JLGeneratorAction::GeneratePrimaries(G4Event *)
void G4JLMagField::G4JLMagField(getfield_f, void *)
void G4JLMagField::GetFieldValue(const G4double[3], G4double *)
void G4JLSteppingAction::G4JLSteppingAction(stepaction_f, void *)
void G4JLSteppingAction::UserSteppingAction(const G4Step *)
void G4JLTrackingAction::G4JLTrackingAction(trackaction_f, void *, trackaction_f, void *)
void G4JLTrackingAction::PreUserTrackingAction(const G4Track *)
void G4JLTrackingAction::PostUserTrackingAction(const G4Track *)
void G4JLRunAction::G4JLRunAction(runaction_f, void *, runaction_f, void *)
void G4JLRunAction::BeginOfRunAction(const G4Run *)
void G4JLRunAction::EndOfRunAction(const G4Run *)
void G4JLEventAction::G4JLEventAction(eventaction_f, void *, eventaction_f, void *)
void G4JLEventAction::BeginOfEventAction(const G4Event *)
void G4JLEventAction::EndOfEventAction(const G4Event *)
void G4JLStackingAction::G4JLStackingAction(classify_f, void *, stackaction_f, void *, stackaction_f, void *)
G4ClassificationOfNewTrack G4JLStackingAction::ClassifyNewTrack(const G4Track *)
void G4JLStackingAction::NewStage()
void G4JLStackingAction::PrepareNewEvent()
void G4JLStateDependent::G4JLStateDependent(notify_f, void *)
G4bool G4JLStateDependent::Notify(G4ApplicationState)
void G4VCSGfaceted::G4VCSGfaceted(const G4String &)
void G4VCSGfaceted::G4VCSGfaceted(const G4VCSGfaceted &)
G4VCSGfaceted & G4VCSGfaceted::operator=(const G4VCSGfaceted &)
EInside G4VCSGfaceted::Inside(const G4ThreeVector &)
G4ThreeVector G4VCSGfaceted::SurfaceNormal(const G4ThreeVector &)
G4double G4VCSGfaceted::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4VCSGfaceted::DistanceToIn(const G4ThreeVector &)
G4double G4VCSGfaceted::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4VCSGfaceted::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4VCSGfaceted::GetEntityType()
G4Polyhedron * G4VCSGfaceted::CreatePolyhedron()
G4Polyhedron * G4VCSGfaceted::GetPolyhedron()
G4int G4VCSGfaceted::GetCubVolStatistics()
G4double G4VCSGfaceted::GetCubVolEpsilon()
void G4VCSGfaceted::SetCubVolStatistics(G4int)
void G4VCSGfaceted::SetCubVolEpsilon(G4double)
G4int G4VCSGfaceted::GetAreaStatistics()
G4double G4VCSGfaceted::GetAreaAccuracy()
void G4VCSGfaceted::SetAreaStatistics(G4int)
void G4VCSGfaceted::SetAreaAccuracy(G4double)
G4double G4VCSGfaceted::GetCubicVolume()
G4double G4VCSGfaceted::GetSurfaceArea()
void G4Polycone::G4Polycone(const G4String &, G4double, G4double, G4int, const G4double[], const G4double[], const G4double[])
void G4Polycone::G4Polycone(const G4String &, G4double, G4double, G4int, const G4double[], const G4double[])
EInside G4Polycone::Inside(const G4ThreeVector &)
G4double G4Polycone::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Polycone::DistanceToIn(const G4ThreeVector &)
void G4Polycone::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4Polycone::GetCubicVolume()
G4double G4Polycone::GetSurfaceArea()
G4ThreeVector G4Polycone::GetPointOnSurface()
void G4Polycone::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4GeometryType G4Polycone::GetEntityType()
G4VSolid * G4Polycone::Clone()
G4Polyhedron * G4Polycone::CreatePolyhedron()
G4bool G4Polycone::Reset()
G4double G4Polycone::GetStartPhi()
G4double G4Polycone::GetEndPhi()
G4double G4Polycone::GetSinStartPhi()
G4double G4Polycone::GetCosStartPhi()
G4double G4Polycone::GetSinEndPhi()
G4double G4Polycone::GetCosEndPhi()
G4bool G4Polycone::IsOpen()
G4int G4Polycone::GetNumRZCorner()
G4PolyconeSideRZ G4Polycone::GetCorner(G4int)
G4PolyconeHistorical * G4Polycone::GetOriginalParameters()
void G4Polycone::SetOriginalParameters(G4PolyconeHistorical *)
void G4Polycone::G4Polycone(const G4Polycone &)
G4Polycone & G4Polycone::operator=(const G4Polycone &)
void G4GenericPolycone::G4GenericPolycone(const G4String &, G4double, G4double, G4int, const G4double[], const G4double[])
EInside G4GenericPolycone::Inside(const G4ThreeVector &)
G4double G4GenericPolycone::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4GenericPolycone::DistanceToIn(const G4ThreeVector &)
void G4GenericPolycone::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4GenericPolycone::GetCubicVolume()
G4double G4GenericPolycone::GetSurfaceArea()
G4ThreeVector G4GenericPolycone::GetPointOnSurface()
G4GeometryType G4GenericPolycone::GetEntityType()
G4VSolid * G4GenericPolycone::Clone()
G4Polyhedron * G4GenericPolycone::CreatePolyhedron()
G4bool G4GenericPolycone::Reset()
G4double G4GenericPolycone::GetStartPhi()
G4double G4GenericPolycone::GetEndPhi()
G4double G4GenericPolycone::GetSinStartPhi()
G4double G4GenericPolycone::GetCosStartPhi()
G4double G4GenericPolycone::GetSinEndPhi()
G4double G4GenericPolycone::GetCosEndPhi()
G4bool G4GenericPolycone::IsOpen()
G4int G4GenericPolycone::GetNumRZCorner()
G4PolyconeSideRZ G4GenericPolycone::GetCorner(G4int)
void G4GenericPolycone::G4GenericPolycone(const G4GenericPolycone &)
G4GenericPolycone & G4GenericPolycone::operator=(const G4GenericPolycone &)
void G4Polyhedra::G4Polyhedra(const G4String &, G4double, G4double, G4int, G4int, const G4double[], const G4double[], const G4double[])
void G4Polyhedra::G4Polyhedra(const G4String &, G4double, G4double, G4int, G4int, const G4double[], const G4double[])
EInside G4Polyhedra::Inside(const G4ThreeVector &)
G4double G4Polyhedra::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Polyhedra::DistanceToIn(const G4ThreeVector &)
void G4Polyhedra::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
void G4Polyhedra::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4GeometryType G4Polyhedra::GetEntityType()
G4bool G4Polyhedra::IsFaceted()
G4VSolid * G4Polyhedra::Clone()
G4double G4Polyhedra::GetCubicVolume()
G4double G4Polyhedra::GetSurfaceArea()
G4ThreeVector G4Polyhedra::GetPointOnSurface()
G4Polyhedron * G4Polyhedra::CreatePolyhedron()
G4bool G4Polyhedra::Reset()
G4int G4Polyhedra::GetNumSide()
G4double G4Polyhedra::GetStartPhi()
G4double G4Polyhedra::GetEndPhi()
G4double G4Polyhedra::GetSinStartPhi()
G4double G4Polyhedra::GetCosStartPhi()
G4double G4Polyhedra::GetSinEndPhi()
G4double G4Polyhedra::GetCosEndPhi()
G4bool G4Polyhedra::IsOpen()
G4bool G4Polyhedra::IsGeneric()
G4int G4Polyhedra::GetNumRZCorner()
G4PolyhedraSideRZ G4Polyhedra::GetCorner(const G4int)
G4PolyhedraHistorical * G4Polyhedra::GetOriginalParameters()
void G4Polyhedra::SetOriginalParameters(G4PolyhedraHistorical *)
void G4Polyhedra::G4Polyhedra(const G4Polyhedra &)
G4Polyhedra & G4Polyhedra::operator=(const G4Polyhedra &)
G4bool G4VTrajectory::operator==(const G4VTrajectory &)
G4VTrajectory * G4VTrajectory::CloneForMaster()
G4int G4VTrajectory::GetTrackID()
G4int G4VTrajectory::GetParentID()
G4String G4VTrajectory::GetParticleName()
G4double G4VTrajectory::GetCharge()
G4int G4VTrajectory::GetPDGEncoding()
G4ThreeVector G4VTrajectory::GetInitialMomentum()
G4int G4VTrajectory::GetPointEntries()
G4VTrajectoryPoint * G4VTrajectory::GetPoint(G4int)
void G4VTrajectory::DrawTrajectory()
std::vector<G4AttValue> * G4VTrajectory::CreateAttValues()
void G4VTrajectory::AppendStep(const G4Step *)
void G4VTrajectory::MergeTrajectory(G4VTrajectory *)
G4bool G4VTrajectoryPoint::operator==(const G4VTrajectoryPoint &)
const G4ThreeVector G4VTrajectoryPoint::GetPosition()
const std::vector<G4ThreeVector> * G4VTrajectoryPoint::GetAuxiliaryPoints()
std::vector<G4AttValue> * G4VTrajectoryPoint::CreateAttValues()
G4bool G4TrajectoryContainer::operator==(const G4TrajectoryContainer &)
G4bool G4TrajectoryContainer::operator!=(const G4TrajectoryContainer &)
std::size_t G4TrajectoryContainer::size()
void G4TrajectoryContainer::push_back(G4VTrajectory *)
std::size_t G4TrajectoryContainer::entries()
G4bool G4TrajectoryContainer::insert(G4VTrajectory *)
void G4TrajectoryContainer::clearAndDestroy()
G4VTrajectory * G4TrajectoryContainer::operator[](std::size_t)
TrajectoryVector * G4TrajectoryContainer::GetVector()
void G4DisplacedSolid::G4DisplacedSolid(const G4String &, G4VSolid *, G4RotationMatrix *, const G4ThreeVector &)
void G4DisplacedSolid::G4DisplacedSolid(const G4String &, G4VSolid *, const G4Transform3D &)
void G4DisplacedSolid::G4DisplacedSolid(const G4String &, G4VSolid *, const G4AffineTransform)
EInside G4DisplacedSolid::Inside(const G4ThreeVector &)
void G4DisplacedSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4ThreeVector G4DisplacedSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4DisplacedSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4DisplacedSolid::DistanceToIn(const G4ThreeVector &)
G4double G4DisplacedSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4DisplacedSolid::DistanceToOut(const G4ThreeVector &)
void G4DisplacedSolid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4DisplacedSolid::CleanTransformations()
G4double G4DisplacedSolid::GetCubicVolume()
G4double G4DisplacedSolid::GetSurfaceArea()
G4ThreeVector G4DisplacedSolid::GetPointOnSurface()
G4int G4DisplacedSolid::GetNumOfConstituents()
G4bool G4DisplacedSolid::IsFaceted()
G4GeometryType G4DisplacedSolid::GetEntityType()
G4VSolid * G4DisplacedSolid::Clone()
const G4DisplacedSolid * G4DisplacedSolid::GetDisplacedSolidPtr()
G4DisplacedSolid * G4DisplacedSolid::GetDisplacedSolidPtr()
G4VSolid * G4DisplacedSolid::GetConstituentMovedSolid()
G4AffineTransform G4DisplacedSolid::GetTransform()
void G4DisplacedSolid::SetTransform(G4AffineTransform &)
G4AffineTransform G4DisplacedSolid::GetDirectTransform()
void G4DisplacedSolid::SetDirectTransform(G4AffineTransform &)
G4RotationMatrix G4DisplacedSolid::GetFrameRotation()
void G4DisplacedSolid::SetFrameRotation(const G4RotationMatrix &)
G4ThreeVector G4DisplacedSolid::GetFrameTranslation()
void G4DisplacedSolid::SetFrameTranslation(const G4ThreeVector &)
G4RotationMatrix G4DisplacedSolid::GetObjectRotation()
void G4DisplacedSolid::SetObjectRotation(const G4RotationMatrix &)
G4ThreeVector G4DisplacedSolid::GetObjectTranslation()
void G4DisplacedSolid::SetObjectTranslation(const G4ThreeVector &)
void G4DisplacedSolid::G4DisplacedSolid(const G4DisplacedSolid &)
G4DisplacedSolid & G4DisplacedSolid::operator=(const G4DisplacedSolid &)
G4Polyhedron * G4DisplacedSolid::CreatePolyhedron()
G4Polyhedron * G4DisplacedSolid::GetPolyhedron()
G4double G4Navigator::ComputeStep(const G4ThreeVector &, const G4ThreeVector &, const G4double, G4double &)
G4double G4Navigator::CheckNextStep(const G4ThreeVector &, const G4ThreeVector &, const G4double, G4double &)
G4VPhysicalVolume * G4Navigator::ResetHierarchyAndLocate(const G4ThreeVector &, const G4ThreeVector &, const G4TouchableHistory &)
G4VPhysicalVolume * G4Navigator::LocateGlobalPointAndSetup(const G4ThreeVector &, const G4ThreeVector *, const G4bool, const G4bool)
void G4Navigator::LocateGlobalPointWithinVolume(const G4ThreeVector &)
void G4Navigator::LocateGlobalPointAndUpdateTouchableHandle(const G4ThreeVector &, const G4ThreeVector &, G4TouchableHandle &, const G4bool)
void G4Navigator::LocateGlobalPointAndUpdateTouchable(const G4ThreeVector &, const G4ThreeVector &, G4VTouchable *, const G4bool)
void G4Navigator::LocateGlobalPointAndUpdateTouchable(const G4ThreeVector &, G4VTouchable *, const G4bool)
void G4Navigator::SetGeometricallyLimitedStep()
G4double G4Navigator::ComputeSafety(const G4ThreeVector &, const G4double, const G4bool)
G4VPhysicalVolume * G4Navigator::GetWorldVolume()
void G4Navigator::SetWorldVolume(G4VPhysicalVolume *)
G4TouchableHistory * G4Navigator::CreateTouchableHistory()
G4TouchableHistory * G4Navigator::CreateTouchableHistory(const G4NavigationHistory *)
G4TouchableHandle G4Navigator::CreateTouchableHistoryHandle()
G4ThreeVector G4Navigator::GetLocalExitNormal(G4bool *)
G4ThreeVector G4Navigator::GetLocalExitNormalAndCheck(const G4ThreeVector &, G4bool *)
G4ThreeVector G4Navigator::GetGlobalExitNormal(const G4ThreeVector &, G4bool *)
G4int G4Navigator::GetVerboseLevel()
void G4Navigator::SetVerboseLevel(G4int)
G4bool G4Navigator::IsActive()
void G4Navigator::Activate(G4bool)
G4bool G4Navigator::EnteredDaughterVolume()
G4bool G4Navigator::ExitedMotherVolume()
void G4Navigator::CheckMode(G4bool)
G4bool G4Navigator::IsCheckModeActive()
void G4Navigator::SetPushVerbosity(G4bool)
void G4Navigator::PrintState()
const G4AffineTransform & G4Navigator::GetGlobalToLocalTransform()
const G4AffineTransform G4Navigator::GetLocalToGlobalTransform()
G4AffineTransform G4Navigator::GetMotherToDaughterTransform(G4VPhysicalVolume *, G4int, EVolume)
void G4Navigator::ResetStackAndState()
G4int G4Navigator::SeverityOfZeroStepping(G4int *)
G4ThreeVector G4Navigator::GetCurrentLocalCoordinate()
G4ThreeVector G4Navigator::NetTranslation()
G4RotationMatrix G4Navigator::NetRotation()
void G4Navigator::EnableBestSafety(G4bool)
G4VExternalNavigation * G4Navigator::GetExternalNavigation()
void G4Navigator::SetExternalNavigation(G4VExternalNavigation *)
G4VoxelNavigation & G4Navigator::GetVoxelNavigator()
void G4Navigator::SetVoxelNavigation(G4VoxelNavigation *)
G4Navigator * G4Navigator::Clone()
G4ThreeVector G4Navigator::GetLastStepEndPoint()
void G4Navigator::InformLastStep(G4double, G4bool, G4bool)
bool CLHEP::HepRandomEngine::operator==(const CLHEP::HepRandomEngine &)
bool CLHEP::HepRandomEngine::operator!=(const CLHEP::HepRandomEngine &)
double CLHEP::HepRandomEngine::flat()
void CLHEP::HepRandomEngine::flatArray(const int, double *)
void CLHEP::HepRandomEngine::setSeed(long, int)
void CLHEP::HepRandomEngine::setSeeds(const long *, int)
void CLHEP::HepRandomEngine::saveStatus(const char[])
void CLHEP::HepRandomEngine::restoreStatus(const char[])
void CLHEP::HepRandomEngine::showStatus()
std::string CLHEP::HepRandomEngine::name()
std::string CLHEP::HepRandomEngine::beginTag()
CLHEP::HepRandomEngine * CLHEP::HepRandomEngine::newEngine(const std::vector<unsigned long> &)
std::vector<unsigned long> CLHEP::HepRandomEngine::put()
bool CLHEP::HepRandomEngine::getState(const std::vector<unsigned long> &)
long CLHEP::HepRandomEngine::getSeed()
const long * CLHEP::HepRandomEngine::getSeeds()
void CLHEP::HepRandom::HepRandom(long)
void CLHEP::HepRandom::HepRandom(CLHEP::HepRandomEngine &)
void CLHEP::HepRandom::HepRandom(CLHEP::HepRandomEngine *)
double CLHEP::HepRandom::flat()
void CLHEP::HepRandom::flatArray(const int, double *)
double CLHEP::HepRandom::flat(CLHEP::HepRandomEngine *)
void CLHEP::HepRandom::flatArray(CLHEP::HepRandomEngine *, const int, double *)
double CLHEP::HepRandom::operator()()
std::string CLHEP::HepRandom::name()
CLHEP::HepRandomEngine & CLHEP::HepRandom::engine()
void CLHEP::HepRandom::setTheSeed(long, int)
long CLHEP::HepRandom::getTheSeed()
void CLHEP::HepRandom::setTheSeeds(const long *, int)
const long * CLHEP::HepRandom::getTheSeeds()
void CLHEP::HepRandom::getTheTableSeeds(long *, int)
CLHEP::HepRandom * CLHEP::HepRandom::getTheGenerator()
void CLHEP::HepRandom::setTheEngine(CLHEP::HepRandomEngine *)
CLHEP::HepRandomEngine * CLHEP::HepRandom::getTheEngine()
void CLHEP::HepRandom::saveEngineStatus(const char[])
void CLHEP::HepRandom::restoreEngineStatus(const char[])
void CLHEP::HepRandom::showEngineStatus()
int CLHEP::HepRandom::createInstance()
std::string CLHEP::HepRandom::distributionName()
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine &)
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine &, double)
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine &, double, double)
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine *)
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine *, double)
void CLHEP::RandFlat::RandFlat(CLHEP::HepRandomEngine *, double, double)
double CLHEP::RandFlat::shoot()
double CLHEP::RandFlat::shoot(double)
double CLHEP::RandFlat::shoot(double, double)
long CLHEP::RandFlat::shootInt(long)
long CLHEP::RandFlat::shootInt(long, long)
int CLHEP::RandFlat::shootBit()
void CLHEP::RandFlat::shootArray(const int, double *)
void CLHEP::RandFlat::shootArray(const int, double *, double, double)
double CLHEP::RandFlat::shoot(CLHEP::HepRandomEngine *)
double CLHEP::RandFlat::shoot(CLHEP::HepRandomEngine *, double)
double CLHEP::RandFlat::shoot(CLHEP::HepRandomEngine *, double, double)
long CLHEP::RandFlat::shootInt(CLHEP::HepRandomEngine *, long)
long CLHEP::RandFlat::shootInt(CLHEP::HepRandomEngine *, long, long)
int CLHEP::RandFlat::shootBit(CLHEP::HepRandomEngine *)
void CLHEP::RandFlat::shootArray(CLHEP::HepRandomEngine *, const int, double *)
void CLHEP::RandFlat::shootArray(CLHEP::HepRandomEngine *, const int, double *, double, double)
double CLHEP::RandFlat::fire()
double CLHEP::RandFlat::fire(double)
double CLHEP::RandFlat::fire(double, double)
long CLHEP::RandFlat::fireInt(long)
long CLHEP::RandFlat::fireInt(long, long)
int CLHEP::RandFlat::fireBit()
void CLHEP::RandFlat::fireArray(const int, double *)
void CLHEP::RandFlat::fireArray(const int, double *, double, double)
double CLHEP::RandFlat::operator()()
double CLHEP::RandFlat::operator()(double)
double CLHEP::RandFlat::operator()(double, double)
std::string CLHEP::RandFlat::name()
CLHEP::HepRandomEngine & CLHEP::RandFlat::engine()
std::string CLHEP::RandFlat::distributionName()
void CLHEP::RandFlat::saveEngineStatus(const char[])
void CLHEP::RandFlat::restoreEngineStatus(const char[])
void CLHEP::RandExponential::RandExponential(CLHEP::HepRandomEngine &, double)
void CLHEP::RandExponential::RandExponential(CLHEP::HepRandomEngine *, double)
double CLHEP::RandExponential::shoot()
double CLHEP::RandExponential::shoot(double)
void CLHEP::RandExponential::shootArray(const int, double *, double)
double CLHEP::RandExponential::shoot(CLHEP::HepRandomEngine *)
double CLHEP::RandExponential::shoot(CLHEP::HepRandomEngine *, double)
void CLHEP::RandExponential::shootArray(CLHEP::HepRandomEngine *, const int, double *, double)
double CLHEP::RandExponential::fire()
double CLHEP::RandExponential::fire(double)
void CLHEP::RandExponential::fireArray(const int, double *)
void CLHEP::RandExponential::fireArray(const int, double *, double)
double CLHEP::RandExponential::operator()()
double CLHEP::RandExponential::operator()(double)
std::string CLHEP::RandExponential::name()
CLHEP::HepRandomEngine & CLHEP::RandExponential::engine()
std::string CLHEP::RandExponential::distributionName()
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine &)
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine &, double)
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine &, double, double)
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine *)
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine *, double)
void CLHEP::RandBit::RandBit(CLHEP::HepRandomEngine *, double, double)
int CLHEP::RandBit::shootBit()
int CLHEP::RandBit::shootBit(CLHEP::HepRandomEngine *)
int CLHEP::RandBit::fireBit()
std::string CLHEP::RandBit::name()
std::string CLHEP::RandBit::distributionName()
void CLHEP::RandGamma::RandGamma(CLHEP::HepRandomEngine &, double, double)
void CLHEP::RandGamma::RandGamma(CLHEP::HepRandomEngine *, double, double)
double CLHEP::RandGamma::shoot()
double CLHEP::RandGamma::shoot(double, double)
void CLHEP::RandGamma::shootArray(const int, double *, double, double)
double CLHEP::RandGamma::shoot(CLHEP::HepRandomEngine *)
double CLHEP::RandGamma::shoot(CLHEP::HepRandomEngine *, double, double)
void CLHEP::RandGamma::shootArray(CLHEP::HepRandomEngine *, const int, double *, double, double)
double CLHEP::RandGamma::fire()
double CLHEP::RandGamma::fire(double, double)
void CLHEP::RandGamma::fireArray(const int, double *)
void CLHEP::RandGamma::fireArray(const int, double *, double, double)
double CLHEP::RandGamma::operator()()
double CLHEP::RandGamma::operator()(double, double)
std::string CLHEP::RandGamma::name()
CLHEP::HepRandomEngine & CLHEP::RandGamma::engine()
std::string CLHEP::RandGamma::distributionName()
void CLHEP::RandGaussQ::RandGaussQ(CLHEP::HepRandomEngine &, double, double)
void CLHEP::RandGaussQ::RandGaussQ(CLHEP::HepRandomEngine *, double, double)
double CLHEP::RandGaussQ::shoot()
double CLHEP::RandGaussQ::shoot(double, double)
void CLHEP::RandGaussQ::shootArray(const int, double *, double, double)
double CLHEP::RandGaussQ::shoot(CLHEP::HepRandomEngine *)
double CLHEP::RandGaussQ::shoot(CLHEP::HepRandomEngine *, double, double)
void CLHEP::RandGaussQ::shootArray(CLHEP::HepRandomEngine *, const int, double *, double, double)
double CLHEP::RandGaussQ::fire()
double CLHEP::RandGaussQ::fire(double, double)
void CLHEP::RandGaussQ::fireArray(const int, double *)
void CLHEP::RandGaussQ::fireArray(const int, double *, double, double)
double CLHEP::RandGaussQ::operator()()
double CLHEP::RandGaussQ::operator()(double, double)
std::string CLHEP::RandGaussQ::name()
CLHEP::HepRandomEngine & CLHEP::RandGaussQ::engine()
std::string CLHEP::RandGaussQ::distributionName()
void CLHEP::RandGeneral::RandGeneral(const double *, int, int)
void CLHEP::RandGeneral::RandGeneral(CLHEP::HepRandomEngine &, const double *, int, int)
void CLHEP::RandGeneral::RandGeneral(CLHEP::HepRandomEngine *, const double *, int, int)
double CLHEP::RandGeneral::shoot()
void CLHEP::RandGeneral::shootArray(const int, double *)
double CLHEP::RandGeneral::shoot(CLHEP::HepRandomEngine *)
void CLHEP::RandGeneral::shootArray(CLHEP::HepRandomEngine *, const int, double *)
double CLHEP::RandGeneral::fire()
void CLHEP::RandGeneral::fireArray(const int, double *)
double CLHEP::RandGeneral::operator()()
std::string CLHEP::RandGeneral::name()
CLHEP::HepRandomEngine & CLHEP::RandGeneral::engine()
std::string CLHEP::RandGeneral::distributionName()
void CLHEP::RandPoissonQ::RandPoissonQ(CLHEP::HepRandomEngine &, double)
void CLHEP::RandPoissonQ::RandPoissonQ(CLHEP::HepRandomEngine *, double)
long CLHEP::RandPoissonQ::shoot(double)
void CLHEP::RandPoissonQ::shootArray(const int, long *, double)
long CLHEP::RandPoissonQ::shoot(CLHEP::HepRandomEngine *, double)
long CLHEP::RandPoissonQ::fire()
long CLHEP::RandPoissonQ::fire(double)
void CLHEP::RandPoissonQ::fireArray(const int, long *)
void CLHEP::RandPoissonQ::fireArray(const int, long *, double)
double CLHEP::RandPoissonQ::operator()()
double CLHEP::RandPoissonQ::operator()(double)
std::string CLHEP::RandPoissonQ::name()
CLHEP::HepRandomEngine & CLHEP::RandPoissonQ::engine()
std::string CLHEP::RandPoissonQ::distributionName()
int CLHEP::RandPoissonQ::tableBoundary()
void G4ProcessVector::G4ProcessVector(std::size_t)
void G4ProcessVector::G4ProcessVector(const G4ProcessVector &)
G4ProcessVector & G4ProcessVector::operator=(const G4ProcessVector &)
G4bool G4ProcessVector::operator==(const G4ProcessVector &)
std::size_t G4ProcessVector::entries()
std::size_t G4ProcessVector::length()
std::size_t G4ProcessVector::size()
std::size_t G4ProcessVector::index(G4VProcess *)
G4bool G4ProcessVector::contains(G4VProcess *)
G4bool G4ProcessVector::insert(G4VProcess *)
G4bool G4ProcessVector::insertAt(G4int, G4VProcess *)
G4VProcess * G4ProcessVector::removeAt(G4int)
G4VProcess * G4ProcessVector::removeLast()
void G4ProcessVector::clear()
G4VProcess *const & G4ProcessVector::operator[](G4int)
G4VProcess *const & G4ProcessVector::operator()(G4int)
G4VProcess *& G4ProcessVector::operator[](G4int)
G4VProcess *& G4ProcessVector::operator()(G4int)
G4EventManager * G4EventManager::GetEventManager()
void G4EventManager::ProcessOneEvent(G4Event *)
void G4EventManager::ProcessOneEvent(G4TrackVector *, G4Event *)
void G4EventManager::StackTracks(G4TrackVector *, G4bool)
const G4Event * G4EventManager::GetConstCurrentEvent()
G4Event * G4EventManager::GetNonconstCurrentEvent()
void G4EventManager::AbortCurrentEvent()
void G4EventManager::SetUserAction(G4UserEventAction *)
void G4EventManager::SetUserAction(G4UserStackingAction *)
void G4EventManager::SetUserAction(G4UserTrackingAction *)
void G4EventManager::SetUserAction(G4UserSteppingAction *)
G4UserEventAction * G4EventManager::GetUserEventAction()
G4UserStackingAction * G4EventManager::GetUserStackingAction()
G4UserTrackingAction * G4EventManager::GetUserTrackingAction()
G4UserSteppingAction * G4EventManager::GetUserSteppingAction()
void G4EventManager::KeepTheCurrentEvent()
G4StackManager * G4EventManager::GetStackManager()
G4TrackingManager * G4EventManager::GetTrackingManager()
G4int G4EventManager::GetVerboseLevel()
void G4EventManager::SetVerboseLevel(G4int)
void G4EventManager::SetUserInformation(G4VUserEventInformation *)
G4VUserEventInformation * G4EventManager::GetUserInformation()
G4PrimaryTransformer * G4EventManager::GetPrimaryTransformer()
void G4EventManager::SetPrimaryTransformer(G4PrimaryTransformer *)
void G4EventManager::StoreRandomNumberStatusToG4Event(G4int)
void G4EventManager::UseSubEventParallelism(G4bool)
G4SubEvent * G4EventManager::PopSubEvent(G4int)
void G4EventManager::TerminateSubEvent(const G4SubEvent *, const G4Event *)
G4int G4EventManager::StoreSubEvent(G4Event *, G4int &, G4SubEvent *)
G4RunManager * G4RunManager::GetRunManager()
void G4RunManager::BeamOn(G4int, const char *, G4int)
void G4RunManager::Initialize()
void G4RunManager::DefineWorldVolume(G4VPhysicalVolume *, G4bool)
void G4RunManager::AbortRun(G4bool)
void G4RunManager::AbortEvent()
void G4RunManager::InitializeGeometry()
void G4RunManager::InitializePhysics()
G4bool G4RunManager::ConfirmBeamOnCondition()
void G4RunManager::RunInitialization()
void G4RunManager::DoEventLoop(G4int, const char *, G4int)
void G4RunManager::RunTermination()
void G4RunManager::InitializeEventLoop(G4int, const char *, G4int)
void G4RunManager::ProcessOneEvent(G4int)
void G4RunManager::TerminateOneEvent()
void G4RunManager::TerminateEventLoop()
G4Event * G4RunManager::GenerateEvent(G4int)
void G4RunManager::AnalyzeEvent(G4Event *)
void G4RunManager::SetNumberOfThreads(G4int)
G4int G4RunManager::GetNumberOfThreads()
void G4RunManager::DumpRegion(const G4String &)
void G4RunManager::DumpRegion(G4Region *)
void G4RunManager::GeometryHasBeenModified(G4bool)
void G4RunManager::ReinitializeGeometry(G4bool, G4bool)
void G4RunManager::PhysicsHasBeenModified()
void G4RunManager::CutOffHasBeenModified()
void G4RunManager::ReOptimizeMotherOf(G4VPhysicalVolume *)
void G4RunManager::ReOptimize(G4LogicalVolume *)
void G4RunManager::SetGeometryToBeOptimized(G4bool)
G4bool G4RunManager::GetGeometryToBeOptimized()
void G4RunManager::GeometryDirectlyUpdated(G4bool)
G4bool G4RunManager::IfGeometryHasBeenDestroyed()
void G4RunManager::ConstructScoringWorlds()
void G4RunManager::rndmSaveThisRun()
void G4RunManager::rndmSaveThisEvent()
void G4RunManager::RestoreRandomNumberStatus(const G4String &)
void G4RunManager::RestoreRndmEachEvent(G4bool)
void G4RunManager::SetUserInitialization(G4VUserDetectorConstruction *)
void G4RunManager::SetUserInitialization(G4VUserPhysicsList *)
void G4RunManager::SetUserInitialization(G4VUserActionInitialization *)
void G4RunManager::SetUserInitialization(G4UserWorkerInitialization *)
void G4RunManager::SetUserAction(G4UserRunAction *)
void G4RunManager::SetUserAction(G4VUserPrimaryGeneratorAction *)
void G4RunManager::SetUserAction(G4UserEventAction *)
void G4RunManager::SetUserAction(G4UserStackingAction *)
void G4RunManager::SetUserAction(G4UserTrackingAction *)
void G4RunManager::SetUserAction(G4UserSteppingAction *)
const G4VUserDetectorConstruction * G4RunManager::GetUserDetectorConstruction()
const G4VUserPhysicsList * G4RunManager::GetUserPhysicsList()
const G4VUserActionInitialization * G4RunManager::GetUserActionInitialization()
G4VUserActionInitialization * G4RunManager::GetNonConstUserActionInitialization()
const G4UserWorkerInitialization * G4RunManager::GetUserWorkerInitialization()
const G4UserRunAction * G4RunManager::GetUserRunAction()
const G4VUserPrimaryGeneratorAction * G4RunManager::GetUserPrimaryGeneratorAction()
const G4UserEventAction * G4RunManager::GetUserEventAction()
const G4UserStackingAction * G4RunManager::GetUserStackingAction()
const G4UserTrackingAction * G4RunManager::GetUserTrackingAction()
const G4UserSteppingAction * G4RunManager::GetUserSteppingAction()
void G4RunManager::SetNumberOfAdditionalWaitingStacks(G4int)
void G4RunManager::SetDefaultClassification(G4TrackStatus, G4ClassificationOfNewTrack, G4ExceptionSeverity)
void G4RunManager::SetDefaultClassification(const G4ParticleDefinition *, G4ClassificationOfNewTrack, G4ExceptionSeverity)
const G4String & G4RunManager::GetVersionString()
void G4RunManager::SetPrimaryTransformer(G4PrimaryTransformer *)
void G4RunManager::StoreRandomNumberStatusToG4Event(G4int)
G4int G4RunManager::GetFlagRandomNumberStatusToG4Event()
void G4RunManager::SetRandomNumberStore(G4bool)
G4bool G4RunManager::GetRandomNumberStore()
void G4RunManager::SetRandomNumberStoreDir(const G4String &)
const G4String & G4RunManager::GetRandomNumberStoreDir()
const G4String & G4RunManager::GetRandomNumberStatusForThisRun()
const G4String & G4RunManager::GetRandomNumberStatusForThisEvent()
void G4RunManager::SetRandomNumberStorePerEvent(G4bool)
G4bool G4RunManager::GetRandomNumberStorePerEvent()
void G4RunManager::SetVerboseLevel(G4int)
G4int G4RunManager::GetVerboseLevel()
G4int G4RunManager::GetPrintProgress()
void G4RunManager::SetPrintProgress(G4int)
void G4RunManager::SetNumberOfEventsToBeStored(G4int)
const G4Run * G4RunManager::GetCurrentRun()
G4Run * G4RunManager::GetNonConstCurrentRun()
const G4Event * G4RunManager::GetCurrentEvent()
const G4Event * G4RunManager::GetPreviousEvent(G4int)
void G4RunManager::SetRunIDCounter(G4int)
G4int G4RunManager::GetNumberOfParallelWorld()
void G4RunManager::SetNumberOfEventsToBeProcessed(G4int)
G4int G4RunManager::GetNumberOfEventsToBeProcessed()
G4int G4RunManager::GetNumberOfSelectEvents()
const G4String & G4RunManager::GetSelectMacro()
G4RunManager::RMType G4RunManager::GetRunManagerType()
void G4RunManager::RegisterSubEventType(G4int, G4int)
void G4RunManager::MergeTrajectories(const G4SubEvent *, const G4Event *)
void G4RunManager::UpdateScoringForSubEvent(const G4SubEvent *, const G4Event *)
const G4SubEvent * G4RunManager::GetSubEvent(G4int, G4bool &, G4long &, G4long &, G4long &, G4bool)
void G4RunManager::SubEventFinished(const G4SubEvent *, const G4Event *)
G4int G4RunManager::GetSubEventType()
void G4RunManager::SetSubEventType(G4int)
std::size_t G4RunManager::GetMaxNTrack()
void G4RunManager::TrajectoriesToBeMerged(G4bool)
void G4RunManager::ReportEventDeletion(const G4Event *)
void G4RunManager::ResetNavigatorAtInitialization(G4bool)
void G4VUserPhysicsList::G4VUserPhysicsList(const G4VUserPhysicsList &)
G4VUserPhysicsList & G4VUserPhysicsList::operator=(const G4VUserPhysicsList &)
void G4VUserPhysicsList::ConstructParticle()
void G4VUserPhysicsList::Construct()
void G4VUserPhysicsList::ConstructProcess()
void G4VUserPhysicsList::SetCuts()
void G4VUserPhysicsList::SetDefaultCutValue(G4double)
G4double G4VUserPhysicsList::GetDefaultCutValue()
void G4VUserPhysicsList::BuildPhysicsTable()
void G4VUserPhysicsList::PreparePhysicsTable(G4ParticleDefinition *)
void G4VUserPhysicsList::BuildPhysicsTable(G4ParticleDefinition *)
G4bool G4VUserPhysicsList::StorePhysicsTable(const G4String &)
G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved()
G4bool G4VUserPhysicsList::IsStoredInAscii()
const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory()
void G4VUserPhysicsList::SetPhysicsTableRetrieved(const G4String &)
void G4VUserPhysicsList::SetStoredInAscii()
void G4VUserPhysicsList::ResetPhysicsTableRetrieved()
void G4VUserPhysicsList::ResetStoredInAscii()
void G4VUserPhysicsList::DumpList()
void G4VUserPhysicsList::DumpCutValuesTable(G4int)
void G4VUserPhysicsList::DumpCutValuesTableIfRequested()
void G4VUserPhysicsList::SetVerboseLevel(G4int)
G4int G4VUserPhysicsList::GetVerboseLevel()
void G4VUserPhysicsList::UseCoupledTransportation(G4bool)
void G4VUserPhysicsList::SetCutsWithDefault()
void G4VUserPhysicsList::SetCutValue(G4double, const G4String &)
G4double G4VUserPhysicsList::GetCutValue(const G4String &)
void G4VUserPhysicsList::SetCutValue(G4double, const G4String &, const G4String &)
void G4VUserPhysicsList::SetParticleCuts(G4double, G4ParticleDefinition *, G4Region *)
void G4VUserPhysicsList::SetParticleCuts(G4double, const G4String &, G4Region *)
void G4VUserPhysicsList::SetCutsForRegion(G4double, const G4String &)
void G4VUserPhysicsList::SetApplyCuts(G4bool, const G4String &)
G4bool G4VUserPhysicsList::GetApplyCuts(const G4String &)
void G4VUserPhysicsList::RemoveProcessManager()
void G4VUserPhysicsList::RemoveTrackingManager()
void G4VUserPhysicsList::AddProcessManager(G4ParticleDefinition *, G4ProcessManager *)
void G4VUserPhysicsList::CheckParticleList()
void G4VUserPhysicsList::DisableCheckParticleList()
G4int G4VUserPhysicsList::GetInstanceID()
void G4VUserPhysicsList::InitializeWorker()
void G4VUserPhysicsList::TerminateWorker()
void G4MTRunManager::SetNumberOfThreads(G4int)
G4int G4MTRunManager::GetNumberOfThreads()
void G4MTRunManager::SetPinAffinity(G4int)
G4int G4MTRunManager::GetPinAffinity()
void G4MTRunManager::Initialize()
void G4MTRunManager::InitializeEventLoop(G4int, const char *, G4int)
void G4MTRunManager::InitializeThreadPool()
void G4MTRunManager::TerminateOneEvent()
void G4MTRunManager::ProcessOneEvent(G4int)
void G4MTRunManager::ConstructScoringWorlds()
void G4MTRunManager::RunTermination()
G4bool G4MTRunManager::SetUpAnEvent(G4Event *, G4long &, G4long &, G4long &, G4bool)
std::vector<G4String> G4MTRunManager::GetCommandStack()
size_t G4MTRunManager::GetNumberActiveThreads()
void G4MTRunManager::ThisWorkerReady()
void G4MTRunManager::ThisWorkerEndEventLoop()
G4ScoringManager * G4MTRunManager::GetMasterScoringManager()
void G4MTRunManager::addWorld(G4int, G4VPhysicalVolume *)
const CLHEP::HepRandomEngine * G4MTRunManager::getMasterRandomEngine()
G4MTRunManager * G4MTRunManager::GetMasterRunManager()
G4RunManagerKernel * G4MTRunManager::GetMasterRunManagerKernel()
G4MTRunManagerKernel * G4MTRunManager::GetMTMasterRunManagerKernel()
void G4MTRunManager::SetUserInitialization(G4VUserPhysicsList *)
void G4MTRunManager::SetUserInitialization(G4VUserDetectorConstruction *)
void G4MTRunManager::SetUserInitialization(G4UserWorkerInitialization *)
void G4MTRunManager::SetUserInitialization(G4VUserActionInitialization *)
void G4MTRunManager::SetUserAction(G4UserRunAction *)
void G4MTRunManager::SetUserAction(G4VUserPrimaryGeneratorAction *)
void G4MTRunManager::SetUserAction(G4UserEventAction *)
void G4MTRunManager::SetUserAction(G4UserStackingAction *)
void G4MTRunManager::SetUserAction(G4UserTrackingAction *)
void G4MTRunManager::SetUserAction(G4UserSteppingAction *)
void G4MTRunManager::MergeScores(const G4ScoringManager *)
void G4MTRunManager::MergeRun(const G4Run *)
void G4MTRunManager::RequestWorkersProcessCommandsStack()
void G4MTRunManager::ThisWorkerProcessCommandsStackDone()
G4MTRunManager::WorkerActionRequest G4MTRunManager::ThisWorkerWaitForNextAction()
void G4MTRunManager::SetEventModulo(G4int)
G4int G4MTRunManager::GetEventModulo()
void G4MTRunManager::AbortRun(G4bool)
void G4MTRunManager::AbortEvent()
G4int G4MTRunManager::SeedOncePerCommunication()
void G4MTRunManager::SetSeedOncePerCommunication(G4int)
G4ScoringManager * G4ScoringManager::GetScoringManager()
G4ScoringManager * G4ScoringManager::GetScoringManagerIfExist()
void G4ScoringManager::SetReplicaLevel(G4int)
G4int G4ScoringManager::GetReplicaLevel()
void G4ScoringManager::Accumulate(G4VHitsCollection *)
void G4ScoringManager::Merge(const G4ScoringManager *)
G4VScoringMesh * G4ScoringManager::FindMesh(G4VHitsCollection *)
G4VScoringMesh * G4ScoringManager::FindMesh(const G4String &)
void G4ScoringManager::List()
void G4ScoringManager::Dump()
void G4ScoringManager::DrawMesh(const G4String &, const G4String &, const G4String &, G4int)
void G4ScoringManager::DrawMesh(const G4String &, const G4String &, G4int, G4int, const G4String &)
void G4ScoringManager::DumpQuantityToFile(const G4String &, const G4String &, const G4String &, const G4String &)
void G4ScoringManager::DumpAllQuantitiesToFile(const G4String &, const G4String &, const G4String &)
void G4ScoringManager::ListScoreColorMaps()
void G4ScoringManager::SetCurrentMesh(G4VScoringMesh *)
G4VScoringMesh * G4ScoringManager::GetCurrentMesh()
void G4ScoringManager::CloseCurrentMesh()
void G4ScoringManager::SetVerboseLevel(G4int)
G4int G4ScoringManager::GetVerboseLevel()
std::size_t G4ScoringManager::GetNumberOfMesh()
void G4ScoringManager::RegisterScoringMesh(G4VScoringMesh *)
G4VScoringMesh * G4ScoringManager::GetMesh(G4int)
const G4String & G4ScoringManager::GetWorldName(G4int)
void G4ScoringManager::SetScoreWriter(G4VScoreWriter *)
void G4ScoringManager::SetFactor(G4double)
G4double G4ScoringManager::GetFactor()
void G4MTRunManagerKernel::SetUpDecayChannels()
void G4MTRunManagerKernel::BroadcastAbortRun(G4bool)
G4UImanager * G4UImanager::GetUIpointer()
G4UImanager * G4UImanager::GetMasterUIpointer()
G4String G4UImanager::GetCurrentValues(const char *)
void G4UImanager::AddNewCommand(G4UIcommand *)
void G4UImanager::RemoveCommand(G4UIcommand *)
void G4UImanager::ExecuteMacroFile(const char *)
void G4UImanager::Loop(const char *, const char *, G4double, G4double, G4double)
void G4UImanager::Foreach(const char *, const char *, const char *)
G4int G4UImanager::ApplyCommand(const char *)
G4UIcommand * G4UImanager::FindCommand(const char *)
G4UIcommand * G4UImanager::FindCommand(const G4String &)
void G4UImanager::StoreHistory(const char *)
void G4UImanager::StoreHistory(G4bool, const char *)
void G4UImanager::ListCommands(const char *)
void G4UImanager::SetAlias(const char *)
void G4UImanager::RemoveAlias(const char *)
void G4UImanager::ListAlias()
G4String G4UImanager::SolveAlias(const char *)
void G4UImanager::CreateHTML(const char *)
void G4UImanager::LoopS(const char *)
void G4UImanager::ForeachS(const char *)
G4bool G4UImanager::Notify(G4ApplicationState)
G4String G4UImanager::GetCurrentStringValue(const char *, G4int, G4bool)
G4int G4UImanager::GetCurrentIntValue(const char *, G4int, G4bool)
G4double G4UImanager::GetCurrentDoubleValue(const char *, G4int, G4bool)
G4String G4UImanager::GetCurrentStringValue(const char *, const char *, G4bool)
G4int G4UImanager::GetCurrentIntValue(const char *, const char *, G4bool)
G4double G4UImanager::GetCurrentDoubleValue(const char *, const char *, G4bool)
void G4UImanager::SetPauseAtBeginOfEvent(G4bool)
G4bool G4UImanager::GetPauseAtBeginOfEvent()
void G4UImanager::SetPauseAtEndOfEvent(G4bool)
G4bool G4UImanager::GetPauseAtEndOfEvent()
void G4UImanager::SetVerboseLevel(G4int)
G4int G4UImanager::GetVerboseLevel()
G4int G4UImanager::GetNumberOfHistory()
G4String G4UImanager::GetPreviousCommand(G4int)
void G4UImanager::SetMaxHistSize(G4int)
G4int G4UImanager::GetMaxHistSize()
void G4UImanager::SetMacroSearchPath(const G4String &)
const G4String & G4UImanager::GetMacroSearchPath()
void G4UImanager::ParseMacroSearchPath()
G4String G4UImanager::FindMacroPath(const G4String &)
void G4UImanager::SetMasterUIManager(G4bool)
void G4UImanager::SetIgnoreCmdNotFound(G4bool)
std::vector<G4String> * G4UImanager::GetCommandStack()
void G4UImanager::SetUpForAThread(G4int)
void G4UImanager::SetUpForSpecialThread(const G4String &)
G4int G4UImanager::GetThreadID()
void G4UImanager::SetCoutFileName(const G4String &, G4bool)
void G4UImanager::SetCerrFileName(const G4String &, G4bool)
void G4UImanager::SetThreadPrefixString(const G4String &)
void G4UImanager::SetThreadUseBuffer(G4bool)
void G4UImanager::SetThreadIgnore(G4int)
void G4UImanager::SetThreadIgnoreInit(G4bool)
void G4UImanager::UseDoublePrecisionStr(G4bool)
G4bool G4UImanager::DoublePrecisionStr()
G4int G4UImanager::GetLastReturnCode()
bool G4UImanager::IsLastCommandOutputTreated()
void G4UImanager::SetLastCommandOutputTreated()
void G4SPSPosDistribution::SetPosDisType(const G4String &)
void G4SPSPosDistribution::SetPosDisShape(const G4String &)
void G4SPSPosDistribution::SetCentreCoords(const G4ThreeVector &)
void G4SPSPosDistribution::SetPosRot1(const G4ThreeVector &)
void G4SPSPosDistribution::SetPosRot2(const G4ThreeVector &)
void G4SPSPosDistribution::SetHalfX(G4double)
void G4SPSPosDistribution::SetHalfY(G4double)
void G4SPSPosDistribution::SetHalfZ(G4double)
void G4SPSPosDistribution::SetRadius(G4double)
void G4SPSPosDistribution::SetRadius0(G4double)
void G4SPSPosDistribution::SetBeamSigmaInR(G4double)
void G4SPSPosDistribution::SetBeamSigmaInX(G4double)
void G4SPSPosDistribution::SetBeamSigmaInY(G4double)
void G4SPSPosDistribution::SetParAlpha(G4double)
void G4SPSPosDistribution::SetParTheta(G4double)
void G4SPSPosDistribution::SetParPhi(G4double)
void G4SPSPosDistribution::ConfineSourceToVolume(const G4String &)
void G4SPSPosDistribution::SetBiasRndm(G4SPSRandomGenerator *)
void G4SPSPosDistribution::SetVerbosity(G4int)
G4ThreeVector G4SPSPosDistribution::GenerateOne()
const G4String & G4SPSPosDistribution::GetPosDisType()
const G4String & G4SPSPosDistribution::GetPosDisShape()
const G4ThreeVector & G4SPSPosDistribution::GetCentreCoords()
G4double G4SPSPosDistribution::GetHalfX()
G4double G4SPSPosDistribution::GetHalfY()
G4double G4SPSPosDistribution::GetHalfZ()
G4double G4SPSPosDistribution::GetRadius()
G4double G4SPSPosDistribution::GetRadius0()
G4double G4SPSPosDistribution::GetParAlpha()
G4double G4SPSPosDistribution::GetParTheta()
G4double G4SPSPosDistribution::GetParPhi()
const G4ThreeVector & G4SPSPosDistribution::GetRotx()
const G4ThreeVector & G4SPSPosDistribution::GetRoty()
const G4ThreeVector & G4SPSPosDistribution::GetRotz()
G4bool G4SPSPosDistribution::GetConfined()
const G4String & G4SPSPosDistribution::GetConfineVolume()
const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec1()
const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec2()
const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec3()
const G4String & G4SPSPosDistribution::GetSourcePosType()
const G4ThreeVector & G4SPSPosDistribution::GetParticlePos()
void G4SPSAngDistribution::SetAngDistType(const G4String &)
void G4SPSAngDistribution::DefineAngRefAxes(const G4String &, const G4ThreeVector &)
void G4SPSAngDistribution::SetMinTheta(G4double)
void G4SPSAngDistribution::SetMinPhi(G4double)
void G4SPSAngDistribution::SetMaxTheta(G4double)
void G4SPSAngDistribution::SetMaxPhi(G4double)
void G4SPSAngDistribution::SetBeamSigmaInAngR(G4double)
void G4SPSAngDistribution::SetBeamSigmaInAngX(G4double)
void G4SPSAngDistribution::SetBeamSigmaInAngY(G4double)
void G4SPSAngDistribution::UserDefAngTheta(const G4ThreeVector &)
void G4SPSAngDistribution::UserDefAngPhi(const G4ThreeVector &)
void G4SPSAngDistribution::SetFocusPoint(const G4ThreeVector &)
void G4SPSAngDistribution::SetParticleMomentumDirection(const G4ParticleMomentum &)
void G4SPSAngDistribution::SetUseUserAngAxis(G4bool)
void G4SPSAngDistribution::SetUserWRTSurface(G4bool)
void G4SPSAngDistribution::SetPosDistribution(G4SPSPosDistribution *)
void G4SPSAngDistribution::SetBiasRndm(G4SPSRandomGenerator *)
G4ParticleMomentum G4SPSAngDistribution::GenerateOne()
void G4SPSAngDistribution::ReSetHist(const G4String &)
void G4SPSAngDistribution::SetVerbosity(G4int)
G4String G4SPSAngDistribution::GetDistType()
G4double G4SPSAngDistribution::GetMinTheta()
G4double G4SPSAngDistribution::GetMaxTheta()
G4double G4SPSAngDistribution::GetMinPhi()
G4double G4SPSAngDistribution::GetMaxPhi()
G4ThreeVector G4SPSAngDistribution::GetDirection()
void G4SPSEneDistribution::SetEnergyDisType(const G4String &)
const G4String & G4SPSEneDistribution::GetEnergyDisType()
void G4SPSEneDistribution::SetEmin(G4double)
G4double G4SPSEneDistribution::GetEmin()
G4double G4SPSEneDistribution::GetArbEmin()
void G4SPSEneDistribution::SetEmax(G4double)
G4double G4SPSEneDistribution::GetEmax()
G4double G4SPSEneDistribution::GetArbEmax()
void G4SPSEneDistribution::SetMonoEnergy(G4double)
void G4SPSEneDistribution::SetAlpha(G4double)
void G4SPSEneDistribution::SetBiasAlpha(G4double)
void G4SPSEneDistribution::SetTemp(G4double)
void G4SPSEneDistribution::SetBeamSigmaInE(G4double)
void G4SPSEneDistribution::SetEzero(G4double)
void G4SPSEneDistribution::SetGradient(G4double)
void G4SPSEneDistribution::SetInterCept(G4double)
void G4SPSEneDistribution::UserEnergyHisto(const G4ThreeVector &)
void G4SPSEneDistribution::ArbEnergyHisto(const G4ThreeVector &)
void G4SPSEneDistribution::ArbEnergyHistoFile(const G4String &)
void G4SPSEneDistribution::EpnEnergyHisto(const G4ThreeVector &)
void G4SPSEneDistribution::InputEnergySpectra(G4bool)
void G4SPSEneDistribution::InputDifferentialSpectra(G4bool)
void G4SPSEneDistribution::ArbInterpolate(const G4String &)
const G4String & G4SPSEneDistribution::GetIntType()
void G4SPSEneDistribution::Calculate()
void G4SPSEneDistribution::SetBiasRndm(G4SPSRandomGenerator *)
void G4SPSEneDistribution::ReSetHist(const G4String &)
void G4SPSEneDistribution::SetVerbosity(G4int)
G4double G4SPSEneDistribution::GetWeight()
G4double G4SPSEneDistribution::GetMonoEnergy()
G4double G4SPSEneDistribution::GetSE()
G4double G4SPSEneDistribution::Getalpha()
G4double G4SPSEneDistribution::GetEzero()
G4double G4SPSEneDistribution::GetTemp()
G4double G4SPSEneDistribution::Getgrad()
G4double G4SPSEneDistribution::Getcept()
G4PhysicsFreeVector G4SPSEneDistribution::GetUserDefinedEnergyHisto()
G4PhysicsFreeVector G4SPSEneDistribution::GetArbEnergyHisto()
G4double G4SPSEneDistribution::GenerateOne(G4ParticleDefinition *)
G4double G4SPSEneDistribution::GetProbability(G4double)
G4double G4SPSEneDistribution::GetArbEneWeight(G4double)
void G4SPSEneDistribution::ApplyEnergyWeight(G4bool)
G4bool G4SPSEneDistribution::IfApplyEnergyWeight()
void G4SingleParticleSource::GeneratePrimaryVertex(G4Event *)
G4SPSPosDistribution * G4SingleParticleSource::GetPosDist()
G4SPSAngDistribution * G4SingleParticleSource::GetAngDist()
G4SPSEneDistribution * G4SingleParticleSource::GetEneDist()
G4SPSRandomGenerator * G4SingleParticleSource::GetBiasRndm()
void G4SingleParticleSource::SetVerbosity(G4int)
void G4SingleParticleSource::SetParticleDefinition(G4ParticleDefinition *)
G4ParticleDefinition * G4SingleParticleSource::GetParticleDefinition()
void G4SingleParticleSource::SetParticleCharge(G4double)
void G4SingleParticleSource::SetParticlePolarization(const G4ThreeVector &)
const G4ThreeVector & G4SingleParticleSource::GetParticlePolarization()
void G4SingleParticleSource::SetParticleTime(G4double)
G4double G4SingleParticleSource::GetParticleTime()
void G4SingleParticleSource::SetNumberOfParticles(G4int)
G4int G4SingleParticleSource::GetNumberOfParticles()
G4ThreeVector G4SingleParticleSource::GetParticlePosition()
G4ThreeVector G4SingleParticleSource::GetParticleMomentumDirection()
G4double G4SingleParticleSource::GetParticleEnergy()
void G4GeneralParticleSource::GeneratePrimaryVertex(G4Event *)
G4int G4GeneralParticleSource::GetNumberofSource()
void G4GeneralParticleSource::ListSource()
void G4GeneralParticleSource::SetCurrentSourceto(G4int)
void G4GeneralParticleSource::SetCurrentSourceIntensity(G4double)
G4SingleParticleSource * G4GeneralParticleSource::GetCurrentSource()
G4int G4GeneralParticleSource::GetCurrentSourceIndex()
G4double G4GeneralParticleSource::GetCurrentSourceIntensity()
void G4GeneralParticleSource::ClearAll()
void G4GeneralParticleSource::AddaSource(G4double)
void G4GeneralParticleSource::DeleteaSource(G4int)
void G4GeneralParticleSource::SetVerbosity(G4int)
void G4GeneralParticleSource::SetMultipleVertex(G4bool)
void G4GeneralParticleSource::SetFlatSampling(G4bool)
void G4GeneralParticleSource::SetParticleDefinition(G4ParticleDefinition *)
G4ParticleDefinition * G4GeneralParticleSource::GetParticleDefinition()
void G4GeneralParticleSource::SetParticleCharge(G4double)
void G4GeneralParticleSource::SetParticlePolarization(G4ThreeVector)
G4ThreeVector G4GeneralParticleSource::GetParticlePolarization()
void G4GeneralParticleSource::SetParticleTime(G4double)
G4double G4GeneralParticleSource::GetParticleTime()
void G4GeneralParticleSource::SetNumberOfParticles(G4int)
G4int G4GeneralParticleSource::GetNumberOfParticles()
G4ThreeVector G4GeneralParticleSource::GetParticlePosition()
G4ThreeVector G4GeneralParticleSource::GetParticleMomentumDirection()
G4double G4GeneralParticleSource::GetParticleEnergy()
G4NistManager * G4NistManager::Instance()
G4Element * G4NistManager::GetElement(std::size_t)
G4Element * G4NistManager::FindElement(G4int)
G4Element * G4NistManager::FindOrBuildElement(G4int, G4bool)
G4Element * G4NistManager::FindOrBuildElement(const G4String &, G4bool)
std::size_t G4NistManager::GetNumberOfElements()
G4int G4NistManager::GetZ(const G4String &)
G4double G4NistManager::GetAtomicMassAmu(const G4String &)
G4double G4NistManager::GetAtomicMassAmu(G4int)
G4double G4NistManager::GetIsotopeMass(G4int, G4int)
G4double G4NistManager::GetAtomicMass(G4int, G4int)
G4double G4NistManager::GetTotalElectronBindingEnergy(G4int)
G4int G4NistManager::GetNistFirstIsotopeN(G4int)
G4int G4NistManager::GetNumberOfNistIsotopes(G4int)
G4double G4NistManager::GetIsotopeAbundance(G4int, G4int)
void G4NistManager::PrintElement(G4int)
void G4NistManager::PrintElement(const G4String &)
void G4NistManager::PrintG4Element(const G4String &)
const std::vector<G4String> & G4NistManager::GetNistElementNames()
G4double G4NistManager::GetMeanIonisationEnergy(G4int)
G4double G4NistManager::GetNominalDensity(G4int)
G4Material * G4NistManager::GetMaterial(std::size_t)
G4Material * G4NistManager::FindMaterial(const G4String &)
G4Material * G4NistManager::FindOrBuildMaterial(const G4String &, G4bool, G4bool)
G4Material * G4NistManager::FindSimpleMaterial(G4int)
G4Material * G4NistManager::FindOrBuildSimpleMaterial(G4int, G4bool)
G4Material * G4NistManager::BuildMaterialWithNewDensity(const G4String &, const G4String &, G4double, G4double, G4double)
G4Material * G4NistManager::ConstructNewMaterial(const G4String &, const std::vector<G4String> &, const std::vector<G4int> &, G4double, G4bool, G4State, G4double, G4double)
G4Material * G4NistManager::ConstructNewMaterial(const G4String &, const std::vector<G4String> &, const std::vector<G4double> &, G4double, G4bool, G4State, G4double, G4double)
G4Material * G4NistManager::ConstructNewGasMaterial(const G4String &, const G4String &, G4double, G4double, G4bool)
G4Material * G4NistManager::ConstructNewIdealGasMaterial(const G4String &, const std::vector<G4String> &, const std::vector<G4int> &, G4bool, G4double, G4double)
void G4NistManager::SetDensityEffectCalculatorFlag(const G4String &, G4bool)
void G4NistManager::SetDensityEffectCalculatorFlag(G4Material *, G4bool)
std::size_t G4NistManager::GetNumberOfMaterials()
G4int G4NistManager::GetVerbose()
void G4NistManager::SetVerbose(G4int)
void G4NistManager::PrintG4Material(const G4String &)
void G4NistManager::ListMaterials(const G4String &)
const std::vector<G4String> & G4NistManager::GetNistMaterialNames()
G4double G4NistManager::GetZ13(G4double)
G4double G4NistManager::GetZ13(G4int)
G4double G4NistManager::GetA27(G4int)
G4double G4NistManager::GetLOGZ(G4int)
G4double G4NistManager::GetLOGAMU(G4int)
G4ICRU90StoppingData * G4NistManager::GetICRU90StoppingData()
void G4CSGSolid::G4CSGSolid(const G4String &)
G4Polyhedron * G4CSGSolid::GetPolyhedron()
void G4CSGSolid::G4CSGSolid(const G4CSGSolid &)
G4CSGSolid & G4CSGSolid::operator=(const G4CSGSolid &)
G4VSteppingVerbose * G4SteppingVerbose::Clone()
void G4SteppingVerbose::NewStep()
void G4SteppingVerbose::AtRestDoItInvoked()
void G4SteppingVerbose::AlongStepDoItAllDone()
void G4SteppingVerbose::PostStepDoItAllDone()
void G4SteppingVerbose::AlongStepDoItOneByOne()
void G4SteppingVerbose::PostStepDoItOneByOne()
void G4SteppingVerbose::StepInfo()
void G4SteppingVerbose::TrackingStarted()
void G4SteppingVerbose::DPSLStarted()
void G4SteppingVerbose::DPSLUserLimit()
void G4SteppingVerbose::DPSLPostStep()
void G4SteppingVerbose::DPSLAlongStep()
void G4SteppingVerbose::VerboseTrack()
void G4SteppingVerbose::VerboseParticleChange()
void G4SteppingVerbose::ShowStep()
void G4SteppingVerbose::UseBestUnit(G4int)
G4int G4SteppingVerbose::BestUnitPrecision()
void G4PVPlacement::G4PVPlacement(G4RotationMatrix *, const G4ThreeVector &, G4LogicalVolume *, const G4String &, G4LogicalVolume *, G4bool, G4int, G4bool)
void G4PVPlacement::G4PVPlacement(const G4Transform3D &, G4LogicalVolume *, const G4String &, G4LogicalVolume *, G4bool, G4int, G4bool)
void G4PVPlacement::G4PVPlacement(G4RotationMatrix *, const G4ThreeVector &, const G4String &, G4LogicalVolume *, G4VPhysicalVolume *, G4bool, G4int, G4bool)
void G4PVPlacement::G4PVPlacement(const G4Transform3D &, const G4String &, G4LogicalVolume *, G4VPhysicalVolume *, G4bool, G4int, G4bool)
G4int G4PVPlacement::GetCopyNo()
void G4PVPlacement::SetCopyNo(G4int)
G4bool G4PVPlacement::CheckOverlaps(G4int, G4double, G4bool, G4int)
G4bool G4PVPlacement::IsMany()
G4bool G4PVPlacement::IsReplicated()
G4bool G4PVPlacement::IsParameterised()
G4VPVParameterisation * G4PVPlacement::GetParameterisation()
void G4PVPlacement::GetReplicationData(EAxis &, G4int &, G4double &, G4double &, G4bool &)
G4bool G4PVPlacement::IsRegularStructure()
G4int G4PVPlacement::GetRegularStructureId()
EVolume G4PVPlacement::VolumeType()
void G4ReplicaData::initialize()
void G4PVReplica::G4PVReplica(const G4String &, G4LogicalVolume *, G4LogicalVolume *, const EAxis, const G4int, const G4double, const G4double)
void G4PVReplica::G4PVReplica(const G4String &, G4LogicalVolume *, G4VPhysicalVolume *, const EAxis, const G4int, const G4double, const G4double)
EVolume G4PVReplica::VolumeType()
G4bool G4PVReplica::IsMany()
G4bool G4PVReplica::IsReplicated()
G4int G4PVReplica::GetCopyNo()
void G4PVReplica::SetCopyNo(G4int)
G4bool G4PVReplica::IsParameterised()
G4VPVParameterisation * G4PVReplica::GetParameterisation()
G4int G4PVReplica::GetMultiplicity()
void G4PVReplica::GetReplicationData(EAxis &, G4int &, G4double &, G4double &, G4bool &)
void G4PVReplica::SetRegularStructureId(G4int)
G4bool G4PVReplica::IsRegularStructure()
G4int G4PVReplica::GetRegularStructureId()
G4int G4PVReplica::GetInstanceID()
void G4PVReplica::InitialiseWorker(G4PVReplica *)
void G4PVReplica::TerminateWorker(G4PVReplica *)
G4TransportationManager * G4TransportationManager::GetTransportationManager()
G4TransportationManager * G4TransportationManager::GetInstanceIfExist()
G4FieldManager * G4TransportationManager::GetFieldManager()
void G4TransportationManager::SetFieldManager(G4FieldManager *)
G4Navigator * G4TransportationManager::GetNavigatorForTracking()
void G4TransportationManager::SetNavigatorForTracking(G4Navigator *)
void G4TransportationManager::SetWorldForTracking(G4VPhysicalVolume *)
std::size_t G4TransportationManager::GetNoActiveNavigators()
std::size_t G4TransportationManager::GetNoWorlds()
G4SafetyHelper * G4TransportationManager::GetSafetyHelper()
G4VPhysicalVolume * G4TransportationManager::GetParallelWorld(const G4String &)
G4VPhysicalVolume * G4TransportationManager::IsWorldExisting(const G4String &)
G4Navigator * G4TransportationManager::GetNavigator(const G4String &)
G4Navigator * G4TransportationManager::GetNavigator(G4VPhysicalVolume *)
G4bool G4TransportationManager::RegisterWorld(G4VPhysicalVolume *)
void G4TransportationManager::DeRegisterNavigator(G4Navigator *)
G4int G4TransportationManager::ActivateNavigator(G4Navigator *)
void G4TransportationManager::DeActivateNavigator(G4Navigator *)
void G4TransportationManager::InactivateAll()
G4Navigator * G4TransportationManager::GetFirstTrackingNavigator()
void G4TransportationManager::SetFirstTrackingNavigator(G4Navigator *)
void G4TransportationManager::ClearParallelWorlds()
void G4Box::G4Box(const G4String &, G4double, G4double, G4double)
void G4Box::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Box::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4Box::GetXHalfLength()
G4double G4Box::GetYHalfLength()
G4double G4Box::GetZHalfLength()
void G4Box::SetXHalfLength(G4double)
void G4Box::SetYHalfLength(G4double)
void G4Box::SetZHalfLength(G4double)
G4double G4Box::GetCubicVolume()
G4double G4Box::GetSurfaceArea()
EInside G4Box::Inside(const G4ThreeVector &)
G4ThreeVector G4Box::SurfaceNormal(const G4ThreeVector &)
G4double G4Box::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Box::DistanceToIn(const G4ThreeVector &)
G4double G4Box::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Box::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Box::GetEntityType()
G4ThreeVector G4Box::GetPointOnSurface()
G4bool G4Box::IsFaceted()
G4VSolid * G4Box::Clone()
G4Polyhedron * G4Box::CreatePolyhedron()
void G4Box::G4Box(const G4Box &)
G4Box & G4Box::operator=(const G4Box &)
void G4ExtrudedSolid::G4ExtrudedSolid(const G4String &, const std::vector<G4TwoVector> &, const std::vector<G4ExtrudedSolid::ZSection> &)
void G4ExtrudedSolid::G4ExtrudedSolid(const G4String &, const std::vector<G4TwoVector> &, G4double, const G4TwoVector &, G4double, const G4TwoVector &, G4double)
G4int G4ExtrudedSolid::GetNofVertices()
G4TwoVector G4ExtrudedSolid::GetVertex(G4int)
std::vector<G4TwoVector> G4ExtrudedSolid::GetPolygon()
G4int G4ExtrudedSolid::GetNofZSections()
G4ExtrudedSolid::ZSection G4ExtrudedSolid::GetZSection(G4int)
std::vector<G4ExtrudedSolid::ZSection> G4ExtrudedSolid::GetZSections()
EInside G4ExtrudedSolid::Inside(const G4ThreeVector &)
G4ThreeVector G4ExtrudedSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4ExtrudedSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4ExtrudedSolid::DistanceToIn(const G4ThreeVector &)
G4double G4ExtrudedSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4ExtrudedSolid::DistanceToOut(const G4ThreeVector &)
void G4ExtrudedSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4GeometryType G4ExtrudedSolid::GetEntityType()
G4bool G4ExtrudedSolid::IsFaceted()
G4VSolid * G4ExtrudedSolid::Clone()
void G4ExtrudedSolid::G4ExtrudedSolid(const G4ExtrudedSolid &)
G4ExtrudedSolid & G4ExtrudedSolid::operator=(const G4ExtrudedSolid &)
void G4ExtrudedSolid::ZSection::ZSection(G4double, const G4TwoVector &, G4double)
void G4MultiUnion::G4MultiUnion(const G4String &)
void G4MultiUnion::AddNode(G4VSolid &, const G4Transform3D &)
void G4MultiUnion::AddNode(G4VSolid *, const G4Transform3D &)
void G4MultiUnion::G4MultiUnion(const G4MultiUnion &)
G4MultiUnion & G4MultiUnion::operator=(const G4MultiUnion &)
const G4Transform3D & G4MultiUnion::GetTransformation(G4int)
G4VSolid * G4MultiUnion::GetSolid(G4int)
G4int G4MultiUnion::GetNumberOfSolids()
EInside G4MultiUnion::Inside(const G4ThreeVector &)
G4double G4MultiUnion::DistanceToIn(const G4ThreeVector &)
G4double G4MultiUnion::DistanceToOut(const G4ThreeVector &)
void G4MultiUnion::SetAccurateSafety(G4bool)
G4double G4MultiUnion::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4MultiUnion::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4MultiUnion::DistanceToInNoVoxels(const G4ThreeVector &, const G4ThreeVector &)
G4double G4MultiUnion::DistanceToOutVoxels(const G4ThreeVector &, const G4ThreeVector &, G4ThreeVector *)
G4double G4MultiUnion::DistanceToOutNoVoxels(const G4ThreeVector &, const G4ThreeVector &, G4ThreeVector *)
G4ThreeVector G4MultiUnion::SurfaceNormal(const G4ThreeVector &)
void G4MultiUnion::Extent(EAxis, G4double &, G4double &)
void G4MultiUnion::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4MultiUnion::GetCubicVolume()
G4double G4MultiUnion::GetSurfaceArea()
G4int G4MultiUnion::GetNumOfConstituents()
G4bool G4MultiUnion::IsFaceted()
G4VSolid * G4MultiUnion::Clone()
G4GeometryType G4MultiUnion::GetEntityType()
void G4MultiUnion::Voxelize()
EInside G4MultiUnion::InsideNoVoxels(const G4ThreeVector &)
G4Voxelizer & G4MultiUnion::GetVoxels()
G4ThreeVector G4MultiUnion::GetPointOnSurface()
G4Polyhedron * G4MultiUnion::CreatePolyhedron()
G4Polyhedron * G4MultiUnion::GetPolyhedron()
void G4Trd::G4Trd(const G4String &, G4double, G4double, G4double, G4double, G4double)
G4double G4Trd::GetXHalfLength1()
G4double G4Trd::GetXHalfLength2()
G4double G4Trd::GetYHalfLength1()
G4double G4Trd::GetYHalfLength2()
G4double G4Trd::GetZHalfLength()
void G4Trd::SetXHalfLength1(G4double)
void G4Trd::SetXHalfLength2(G4double)
void G4Trd::SetYHalfLength1(G4double)
void G4Trd::SetYHalfLength2(G4double)
void G4Trd::SetZHalfLength(G4double)
void G4Trd::SetAllParameters(G4double, G4double, G4double, G4double, G4double)
G4double G4Trd::GetCubicVolume()
G4double G4Trd::GetSurfaceArea()
void G4Trd::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Trd::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Trd::Inside(const G4ThreeVector &)
G4ThreeVector G4Trd::SurfaceNormal(const G4ThreeVector &)
G4double G4Trd::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Trd::DistanceToIn(const G4ThreeVector &)
G4double G4Trd::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Trd::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Trd::GetEntityType()
G4ThreeVector G4Trd::GetPointOnSurface()
G4bool G4Trd::IsFaceted()
G4VSolid * G4Trd::Clone()
G4Polyhedron * G4Trd::CreatePolyhedron()
void G4Trd::G4Trd(const G4Trd &)
G4Trd & G4Trd::operator=(const G4Trd &)
void G4Trap::G4Trap(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double)
void G4Trap::G4Trap(const G4String &, const G4ThreeVector[8])
void G4Trap::G4Trap(const G4String &, G4double, G4double, G4double, G4double)
void G4Trap::G4Trap(const G4String &, G4double, G4double, G4double, G4double, G4double)
void G4Trap::G4Trap(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double)
void G4Trap::G4Trap(const G4String &)
G4double G4Trap::GetZHalfLength()
G4double G4Trap::GetYHalfLength1()
G4double G4Trap::GetXHalfLength1()
G4double G4Trap::GetXHalfLength2()
G4double G4Trap::GetTanAlpha1()
G4double G4Trap::GetYHalfLength2()
G4double G4Trap::GetXHalfLength3()
G4double G4Trap::GetXHalfLength4()
G4double G4Trap::GetTanAlpha2()
TrapSidePlane G4Trap::GetSidePlane(G4int)
G4ThreeVector G4Trap::GetSymAxis()
G4double G4Trap::GetPhi()
G4double G4Trap::GetTheta()
G4double G4Trap::GetAlpha1()
G4double G4Trap::GetAlpha2()
void G4Trap::SetAllParameters(G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4Trap::GetCubicVolume()
G4double G4Trap::GetSurfaceArea()
void G4Trap::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Trap::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Trap::Inside(const G4ThreeVector &)
G4ThreeVector G4Trap::SurfaceNormal(const G4ThreeVector &)
G4double G4Trap::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Trap::DistanceToIn(const G4ThreeVector &)
G4double G4Trap::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Trap::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Trap::GetEntityType()
G4ThreeVector G4Trap::GetPointOnSurface()
G4bool G4Trap::IsFaceted()
G4VSolid * G4Trap::Clone()
G4Polyhedron * G4Trap::CreatePolyhedron()
void G4Trap::G4Trap(const G4Trap &)
G4Trap & G4Trap::operator=(const G4Trap &)
void G4Cons::G4Cons(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4Cons::GetInnerRadiusMinusZ()
G4double G4Cons::GetOuterRadiusMinusZ()
G4double G4Cons::GetInnerRadiusPlusZ()
G4double G4Cons::GetOuterRadiusPlusZ()
G4double G4Cons::GetZHalfLength()
G4double G4Cons::GetStartPhiAngle()
G4double G4Cons::GetDeltaPhiAngle()
G4double G4Cons::GetSinStartPhi()
G4double G4Cons::GetCosStartPhi()
G4double G4Cons::GetSinEndPhi()
G4double G4Cons::GetCosEndPhi()
void G4Cons::SetInnerRadiusMinusZ(G4double)
void G4Cons::SetOuterRadiusMinusZ(G4double)
void G4Cons::SetInnerRadiusPlusZ(G4double)
void G4Cons::SetOuterRadiusPlusZ(G4double)
void G4Cons::SetZHalfLength(G4double)
void G4Cons::SetStartPhiAngle(G4double, G4bool)
void G4Cons::SetDeltaPhiAngle(G4double)
G4double G4Cons::GetCubicVolume()
G4double G4Cons::GetSurfaceArea()
void G4Cons::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Cons::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Cons::Inside(const G4ThreeVector &)
G4ThreeVector G4Cons::SurfaceNormal(const G4ThreeVector &)
G4double G4Cons::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Cons::DistanceToIn(const G4ThreeVector &)
G4double G4Cons::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Cons::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Cons::GetEntityType()
G4ThreeVector G4Cons::GetPointOnSurface()
G4VSolid * G4Cons::Clone()
G4Polyhedron * G4Cons::CreatePolyhedron()
void G4Cons::G4Cons(const G4Cons &)
G4Cons & G4Cons::operator=(const G4Cons &)
void G4Sphere::G4Sphere(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4Sphere::GetInnerRadius()
G4double G4Sphere::GetOuterRadius()
G4double G4Sphere::GetStartPhiAngle()
G4double G4Sphere::GetDeltaPhiAngle()
G4double G4Sphere::GetStartThetaAngle()
G4double G4Sphere::GetDeltaThetaAngle()
G4double G4Sphere::GetSinStartPhi()
G4double G4Sphere::GetCosStartPhi()
G4double G4Sphere::GetSinEndPhi()
G4double G4Sphere::GetCosEndPhi()
G4double G4Sphere::GetSinStartTheta()
G4double G4Sphere::GetCosStartTheta()
G4double G4Sphere::GetSinEndTheta()
G4double G4Sphere::GetCosEndTheta()
void G4Sphere::SetInnerRadius(G4double)
void G4Sphere::SetOuterRadius(G4double)
void G4Sphere::SetStartPhiAngle(G4double, G4bool)
void G4Sphere::SetDeltaPhiAngle(G4double)
void G4Sphere::SetStartThetaAngle(G4double)
void G4Sphere::SetDeltaThetaAngle(G4double)
G4double G4Sphere::GetCubicVolume()
G4double G4Sphere::GetSurfaceArea()
void G4Sphere::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Sphere::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Sphere::Inside(const G4ThreeVector &)
G4ThreeVector G4Sphere::SurfaceNormal(const G4ThreeVector &)
G4double G4Sphere::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Sphere::DistanceToIn(const G4ThreeVector &)
G4double G4Sphere::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Sphere::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Sphere::GetEntityType()
G4ThreeVector G4Sphere::GetPointOnSurface()
G4VSolid * G4Sphere::Clone()
G4Polyhedron * G4Sphere::CreatePolyhedron()
void G4Sphere::G4Sphere(const G4Sphere &)
G4Sphere & G4Sphere::operator=(const G4Sphere &)
void G4Orb::G4Orb(const G4String &, G4double)
G4double G4Orb::GetRadius()
G4double G4Orb::GetRadialTolerance()
void G4Orb::SetRadius(G4double)
G4double G4Orb::GetCubicVolume()
G4double G4Orb::GetSurfaceArea()
void G4Orb::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Orb::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Orb::Inside(const G4ThreeVector &)
G4ThreeVector G4Orb::SurfaceNormal(const G4ThreeVector &)
G4double G4Orb::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Orb::DistanceToIn(const G4ThreeVector &)
G4double G4Orb::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Orb::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Orb::GetEntityType()
G4ThreeVector G4Orb::GetPointOnSurface()
G4VSolid * G4Orb::Clone()
G4Polyhedron * G4Orb::CreatePolyhedron()
void G4Orb::G4Orb(const G4Orb &)
G4Orb & G4Orb::operator=(const G4Orb &)
void G4Ellipsoid::G4Ellipsoid(const G4String &, G4double, G4double, G4double, G4double, G4double)
G4double G4Ellipsoid::GetDx()
G4double G4Ellipsoid::GetDy()
G4double G4Ellipsoid::GetDz()
G4double G4Ellipsoid::GetSemiAxisMax(G4int)
G4double G4Ellipsoid::GetZBottomCut()
G4double G4Ellipsoid::GetZTopCut()
void G4Ellipsoid::SetSemiAxis(G4double, G4double, G4double)
void G4Ellipsoid::SetZCuts(G4double, G4double)
void G4Ellipsoid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Ellipsoid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Ellipsoid::Inside(const G4ThreeVector &)
G4ThreeVector G4Ellipsoid::SurfaceNormal(const G4ThreeVector &)
G4double G4Ellipsoid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Ellipsoid::DistanceToIn(const G4ThreeVector &)
G4double G4Ellipsoid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Ellipsoid::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Ellipsoid::GetEntityType()
G4VSolid * G4Ellipsoid::Clone()
G4double G4Ellipsoid::GetCubicVolume()
G4double G4Ellipsoid::GetSurfaceArea()
G4ThreeVector G4Ellipsoid::GetPointOnSurface()
G4Polyhedron * G4Ellipsoid::CreatePolyhedron()
G4Polyhedron * G4Ellipsoid::GetPolyhedron()
void G4Ellipsoid::G4Ellipsoid(const G4Ellipsoid &)
G4Ellipsoid & G4Ellipsoid::operator=(const G4Ellipsoid &)
void G4Torus::G4Torus(const G4String &, G4double, G4double, G4double, G4double, G4double)
G4double G4Torus::GetRmin()
G4double G4Torus::GetRmax()
G4double G4Torus::GetRtor()
G4double G4Torus::GetSPhi()
G4double G4Torus::GetDPhi()
G4double G4Torus::GetSinStartPhi()
G4double G4Torus::GetCosStartPhi()
G4double G4Torus::GetSinEndPhi()
G4double G4Torus::GetCosEndPhi()
G4double G4Torus::GetCubicVolume()
G4double G4Torus::GetSurfaceArea()
EInside G4Torus::Inside(const G4ThreeVector &)
void G4Torus::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
void G4Torus::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4ThreeVector G4Torus::SurfaceNormal(const G4ThreeVector &)
G4double G4Torus::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Torus::DistanceToIn(const G4ThreeVector &)
G4double G4Torus::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Torus::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Torus::GetEntityType()
G4ThreeVector G4Torus::GetPointOnSurface()
G4VSolid * G4Torus::Clone()
G4Polyhedron * G4Torus::CreatePolyhedron()
void G4Torus::SetAllParameters(G4double, G4double, G4double, G4double, G4double)
void G4Torus::G4Torus(const G4Torus &)
G4Torus & G4Torus::operator=(const G4Torus &)
void G4Para::G4Para(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double)
void G4Para::G4Para(const G4String &, const G4ThreeVector[8])
G4double G4Para::GetZHalfLength()
G4ThreeVector G4Para::GetSymAxis()
G4double G4Para::GetYHalfLength()
G4double G4Para::GetXHalfLength()
G4double G4Para::GetTanAlpha()
G4double G4Para::GetAlpha()
G4double G4Para::GetTheta()
G4double G4Para::GetPhi()
void G4Para::SetXHalfLength(G4double)
void G4Para::SetYHalfLength(G4double)
void G4Para::SetZHalfLength(G4double)
void G4Para::SetAlpha(G4double)
void G4Para::SetTanAlpha(G4double)
void G4Para::SetThetaAndPhi(G4double, G4double)
void G4Para::SetAllParameters(G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4Para::GetCubicVolume()
G4double G4Para::GetSurfaceArea()
void G4Para::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Para::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Para::Inside(const G4ThreeVector &)
G4ThreeVector G4Para::SurfaceNormal(const G4ThreeVector &)
G4double G4Para::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Para::DistanceToIn(const G4ThreeVector &)
G4double G4Para::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Para::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Para::GetEntityType()
G4ThreeVector G4Para::GetPointOnSurface()
G4bool G4Para::IsFaceted()
G4VSolid * G4Para::Clone()
G4Polyhedron * G4Para::CreatePolyhedron()
void G4Para::G4Para(const G4Para &)
G4Para & G4Para::operator=(const G4Para &)
void G4Hype::G4Hype(const G4String &, G4double, G4double, G4double, G4double, G4double)
void G4Hype::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Hype::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4Hype::GetInnerRadius()
G4double G4Hype::GetOuterRadius()
G4double G4Hype::GetZHalfLength()
G4double G4Hype::GetInnerStereo()
G4double G4Hype::GetOuterStereo()
void G4Hype::SetInnerRadius(G4double)
void G4Hype::SetOuterRadius(G4double)
void G4Hype::SetZHalfLength(G4double)
void G4Hype::SetInnerStereo(G4double)
void G4Hype::SetOuterStereo(G4double)
EInside G4Hype::Inside(const G4ThreeVector &)
G4ThreeVector G4Hype::SurfaceNormal(const G4ThreeVector &)
G4double G4Hype::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Hype::DistanceToIn(const G4ThreeVector &)
G4double G4Hype::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Hype::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Hype::GetEntityType()
G4VSolid * G4Hype::Clone()
G4double G4Hype::GetCubicVolume()
G4double G4Hype::GetSurfaceArea()
G4ThreeVector G4Hype::GetPointOnSurface()
G4Polyhedron * G4Hype::CreatePolyhedron()
G4Polyhedron * G4Hype::GetPolyhedron()
void G4Hype::G4Hype(const G4Hype &)
G4Hype & G4Hype::operator=(const G4Hype &)
void G4Tubs::G4Tubs(const G4String &, G4double, G4double, G4double, G4double, G4double)
G4double G4Tubs::GetInnerRadius()
G4double G4Tubs::GetOuterRadius()
G4double G4Tubs::GetZHalfLength()
G4double G4Tubs::GetStartPhiAngle()
G4double G4Tubs::GetDeltaPhiAngle()
G4double G4Tubs::GetSinStartPhi()
G4double G4Tubs::GetCosStartPhi()
G4double G4Tubs::GetSinEndPhi()
G4double G4Tubs::GetCosEndPhi()
void G4Tubs::SetInnerRadius(G4double)
void G4Tubs::SetOuterRadius(G4double)
void G4Tubs::SetZHalfLength(G4double)
void G4Tubs::SetStartPhiAngle(G4double, G4bool)
void G4Tubs::SetDeltaPhiAngle(G4double)
G4double G4Tubs::GetCubicVolume()
G4double G4Tubs::GetSurfaceArea()
void G4Tubs::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Tubs::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Tubs::Inside(const G4ThreeVector &)
G4ThreeVector G4Tubs::SurfaceNormal(const G4ThreeVector &)
G4double G4Tubs::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Tubs::DistanceToIn(const G4ThreeVector &)
G4double G4Tubs::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Tubs::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Tubs::GetEntityType()
G4ThreeVector G4Tubs::GetPointOnSurface()
G4VSolid * G4Tubs::Clone()
G4Polyhedron * G4Tubs::CreatePolyhedron()
void G4Tubs::G4Tubs(const G4Tubs &)
G4Tubs & G4Tubs::operator=(const G4Tubs &)
void G4GDMLParser::G4GDMLParser(G4GDMLReadStructure *)
void G4GDMLParser::G4GDMLParser(G4GDMLReadStructure *, G4GDMLWriteStructure *)
void G4GDMLParser::Read(const G4String &, G4bool)
void G4GDMLParser::ReadModule(const G4String &, G4bool)
void G4GDMLParser::Write(const G4String &, const G4VPhysicalVolume *, G4bool, const G4String &)
void G4GDMLParser::Write(const G4String &, const G4LogicalVolume *, G4bool, const G4String &)
G4LogicalVolume * G4GDMLParser::ParseST(const G4String &, G4Material *, G4Material *)
G4bool G4GDMLParser::IsValid(const G4String &)
G4double G4GDMLParser::GetConstant(const G4String &)
G4double G4GDMLParser::GetVariable(const G4String &)
G4double G4GDMLParser::GetQuantity(const G4String &)
G4ThreeVector G4GDMLParser::GetPosition(const G4String &)
G4ThreeVector G4GDMLParser::GetRotation(const G4String &)
G4ThreeVector G4GDMLParser::GetScale(const G4String &)
G4GDMLMatrix G4GDMLParser::GetMatrix(const G4String &)
G4LogicalVolume * G4GDMLParser::GetVolume(const G4String &)
G4VPhysicalVolume * G4GDMLParser::GetPhysVolume(const G4String &)
G4VPhysicalVolume * G4GDMLParser::GetWorldVolume(const G4String &)
G4GDMLAuxListType G4GDMLParser::GetVolumeAuxiliaryInformation(G4LogicalVolume *)
const G4GDMLAuxListType * G4GDMLParser::GetAuxList()
void G4GDMLParser::AddAuxiliary(G4GDMLAuxStructType)
void G4GDMLParser::StripNamePointers()
void G4GDMLParser::SetStripFlag(G4bool)
void G4GDMLParser::SetOverlapCheck(G4bool)
void G4GDMLParser::SetRegionExport(G4bool)
void G4GDMLParser::SetEnergyCutsExport(G4bool)
void G4GDMLParser::SetSDExport(G4bool)
void G4GDMLParser::SetReverseSearch(G4bool)
void G4GDMLParser::SetImportSchema(const G4String &)
G4int G4GDMLParser::GetMaxExportLevel()
void G4GDMLParser::SetMaxExportLevel(G4int)
void G4GDMLParser::Clear()
void G4GDMLParser::AddModule(const G4VPhysicalVolume *const)
void G4GDMLParser::AddModule(const G4int)
void G4GDMLParser::SetAddPointerToName(G4bool)
void G4GDMLParser::AddVolumeAuxiliary(G4GDMLAuxStructType, const G4LogicalVolume *const)
void G4GDMLParser::SetOutputFileOverwrite(G4bool)
G4OpticalParameters * G4OpticalParameters::Instance()
void G4OpticalParameters::SetDefaults()
void G4OpticalParameters::Dump()
void G4OpticalParameters::SetVerboseLevel(G4int)
G4int G4OpticalParameters::GetVerboseLevel()
void G4OpticalParameters::SetProcessActivation(const G4String &, G4bool)
G4bool G4OpticalParameters::GetProcessActivation(const G4String &)
void G4OpticalParameters::SetCerenkovMaxPhotonsPerStep(G4int)
G4int G4OpticalParameters::GetCerenkovMaxPhotonsPerStep()
void G4OpticalParameters::SetCerenkovVerboseLevel(G4int)
G4int G4OpticalParameters::GetCerenkovVerboseLevel()
void G4OpticalParameters::SetCerenkovMaxBetaChange(G4double)
G4double G4OpticalParameters::GetCerenkovMaxBetaChange()
void G4OpticalParameters::SetCerenkovTrackSecondariesFirst(G4bool)
G4bool G4OpticalParameters::GetCerenkovTrackSecondariesFirst()
void G4OpticalParameters::SetCerenkovStackPhotons(G4bool)
G4bool G4OpticalParameters::GetCerenkovStackPhotons()
void G4OpticalParameters::SetScintByParticleType(G4bool)
G4bool G4OpticalParameters::GetScintByParticleType()
void G4OpticalParameters::SetScintTrackInfo(G4bool)
G4bool G4OpticalParameters::GetScintTrackInfo()
void G4OpticalParameters::SetScintTrackSecondariesFirst(G4bool)
G4bool G4OpticalParameters::GetScintTrackSecondariesFirst()
void G4OpticalParameters::SetScintFiniteRiseTime(G4bool)
G4bool G4OpticalParameters::GetScintFiniteRiseTime()
void G4OpticalParameters::SetScintStackPhotons(G4bool)
G4bool G4OpticalParameters::GetScintStackPhotons()
void G4OpticalParameters::SetScintVerboseLevel(G4int)
G4int G4OpticalParameters::GetScintVerboseLevel()
void G4OpticalParameters::SetWLSTimeProfile(const G4String &)
G4String G4OpticalParameters::GetWLSTimeProfile()
void G4OpticalParameters::SetWLSVerboseLevel(G4int)
G4int G4OpticalParameters::GetWLSVerboseLevel()
void G4OpticalParameters::SetWLS2TimeProfile(const G4String &)
G4String G4OpticalParameters::GetWLS2TimeProfile()
void G4OpticalParameters::SetWLS2VerboseLevel(G4int)
G4int G4OpticalParameters::GetWLS2VerboseLevel()
void G4OpticalParameters::SetBoundaryVerboseLevel(G4int)
G4int G4OpticalParameters::GetBoundaryVerboseLevel()
void G4OpticalParameters::SetBoundaryInvokeSD(G4bool)
G4bool G4OpticalParameters::GetBoundaryInvokeSD()
void G4OpticalParameters::SetAbsorptionVerboseLevel(G4int)
G4int G4OpticalParameters::GetAbsorptionVerboseLevel()
void G4OpticalParameters::SetRayleighVerboseLevel(G4int)
G4int G4OpticalParameters::GetRayleighVerboseLevel()
void G4OpticalParameters::SetMieVerboseLevel(G4int)
G4int G4OpticalParameters::GetMieVerboseLevel()
void G4OpticalSurface::G4OpticalSurface(const G4String &, G4OpticalSurfaceModel, G4OpticalSurfaceFinish, G4SurfaceType, G4double)
void G4OpticalSurface::G4OpticalSurface(const G4OpticalSurface &)
G4OpticalSurface & G4OpticalSurface::operator=(const G4OpticalSurface &)
G4bool G4OpticalSurface::operator==(const G4OpticalSurface &)
G4bool G4OpticalSurface::operator!=(const G4OpticalSurface &)
void G4OpticalSurface::SetType(const G4SurfaceType &)
G4OpticalSurfaceFinish G4OpticalSurface::GetFinish()
void G4OpticalSurface::SetFinish(const G4OpticalSurfaceFinish)
G4OpticalSurfaceModel G4OpticalSurface::GetModel()
void G4OpticalSurface::SetModel(const G4OpticalSurfaceModel)
G4double G4OpticalSurface::GetSigmaAlpha()
void G4OpticalSurface::SetSigmaAlpha(const G4double)
G4double G4OpticalSurface::GetPolish()
void G4OpticalSurface::SetPolish(const G4double)
G4MaterialPropertiesTable * G4OpticalSurface::GetMaterialPropertiesTable()
void G4OpticalSurface::SetMaterialPropertiesTable(G4MaterialPropertiesTable *)
void G4OpticalSurface::DumpInfo()
void G4OpticalSurface::ReadDataFile()
void G4OpticalSurface::ReadLUTFile()
G4double G4OpticalSurface::GetAngularDistributionValue(G4int, G4int, G4int)
G4double G4OpticalSurface::GetAngularDistributionValueLUT(G4int)
void G4OpticalSurface::ReadLUTDAVISFile()
void G4OpticalSurface::ReadReflectivityLUTFile()
G4double G4OpticalSurface::GetReflectivityLUTValue(G4int)
G4int G4OpticalSurface::GetInmax()
G4int G4OpticalSurface::GetLUTbins()
G4int G4OpticalSurface::GetRefMax()
G4int G4OpticalSurface::GetThetaIndexMax()
G4int G4OpticalSurface::GetPhiIndexMax()
void G4OpticalSurface::ReadDichroicFile()
G4Physics2DVector * G4OpticalSurface::GetDichroicVector()
void G4LogicalBorderSurface::G4LogicalBorderSurface(const G4String &, G4VPhysicalVolume *, G4VPhysicalVolume *, G4SurfaceProperty *)
G4bool G4LogicalBorderSurface::operator==(const G4LogicalBorderSurface &)
G4bool G4LogicalBorderSurface::operator!=(const G4LogicalBorderSurface &)
G4LogicalBorderSurface * G4LogicalBorderSurface::GetSurface(const G4VPhysicalVolume *, const G4VPhysicalVolume *)
void G4LogicalBorderSurface::SetPhysicalVolumes(G4VPhysicalVolume *, G4VPhysicalVolume *)
const G4VPhysicalVolume * G4LogicalBorderSurface::GetVolume1()
const G4VPhysicalVolume * G4LogicalBorderSurface::GetVolume2()
std::size_t G4LogicalBorderSurface::GetIndex()
void G4LogicalBorderSurface::SetVolume1(G4VPhysicalVolume *)
void G4LogicalBorderSurface::SetVolume2(G4VPhysicalVolume *)
void G4LogicalBorderSurface::CleanSurfaceTable()
std::size_t G4LogicalBorderSurface::GetNumberOfBorderSurfaces()
void G4LogicalBorderSurface::DumpInfo()
void G4LogicalSkinSurface::G4LogicalSkinSurface(const G4String &, G4LogicalVolume *, G4SurfaceProperty *)
G4bool G4LogicalSkinSurface::operator==(const G4LogicalSkinSurface &)
G4bool G4LogicalSkinSurface::operator!=(const G4LogicalSkinSurface &)
G4LogicalSkinSurface * G4LogicalSkinSurface::GetSurface(const G4LogicalVolume *)
const G4LogicalVolume * G4LogicalSkinSurface::GetLogicalVolume()
void G4LogicalSkinSurface::SetLogicalVolume(G4LogicalVolume *)
void G4LogicalSkinSurface::CleanSurfaceTable()
std::size_t G4LogicalSkinSurface::GetNumberOfSkinSurfaces()
void G4LogicalSkinSurface::DumpInfo()
void G4VMPLData::initialize()
void G4VModularPhysicsList::ConstructParticle()
void G4VModularPhysicsList::ConstructProcess()
void G4VModularPhysicsList::RegisterPhysics(G4VPhysicsConstructor *)
const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics(G4int)
const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics(const G4String &)
const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysicsWithType(G4int)
void G4VModularPhysicsList::ReplacePhysics(G4VPhysicsConstructor *)
void G4VModularPhysicsList::RemovePhysics(G4VPhysicsConstructor *)
void G4VModularPhysicsList::RemovePhysics(G4int)
void G4VModularPhysicsList::RemovePhysics(const G4String &)
G4int G4VModularPhysicsList::GetInstanceID()
void G4VModularPhysicsList::TerminateWorker()
void G4VModularPhysicsList::SetVerboseLevel(G4int)
G4int G4VModularPhysicsList::GetVerboseLevel()
void QGS_BIC::QGS_BIC(G4int)
void QBBC::QBBC(G4int, const G4String &)
void FTFP_BERT::FTFP_BERT(G4int)
void LBE::LBE(G4int)
void LBE::SetCuts()
void G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int, const G4String &)
void G4EmStandardPhysics_option4::ConstructParticle()
void G4EmStandardPhysics_option4::ConstructProcess()
void G4OpticalPhysics::G4OpticalPhysics(G4int, const G4String &)
void G4OpticalPhysics::PrintStatistics()
void G4DecayPhysics::G4DecayPhysics(G4int)
void G4DecayPhysics::G4DecayPhysics(const G4String &, G4int)
void G4DecayPhysics::ConstructParticle()
void G4DecayPhysics::ConstructProcess()
void G4EmStandardPhysics::G4EmStandardPhysics(G4int, const G4String &)
void G4EmStandardPhysics::ConstructParticle()
void G4EmStandardPhysics::ConstructProcess()
void G4RadioactiveDecayPhysics::G4RadioactiveDecayPhysics(G4int)
void G4RadioactiveDecayPhysics::G4RadioactiveDecayPhysics(const G4String &, G4int)
void G4RadioactiveDecayPhysics::ConstructParticle()
void G4RadioactiveDecayPhysics::ConstructProcess()
void G4OpBoundaryProcess::G4OpBoundaryProcess(const G4String &, G4ProcessType)
G4bool G4OpBoundaryProcess::IsApplicable(const G4ParticleDefinition &)
G4double G4OpBoundaryProcess::GetMeanFreePath(const G4Track &, G4double, G4ForceCondition *)
G4VParticleChange * G4OpBoundaryProcess::PostStepDoIt(const G4Track &, const G4Step &)
G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus()
void G4OpBoundaryProcess::SetInvokeSD(G4bool)
void G4OpBoundaryProcess::PreparePhysicsTable(const G4ParticleDefinition &)
void G4OpBoundaryProcess::Initialise()
void G4OpBoundaryProcess::SetVerboseLevel(G4int)
void G4StepLimiterPhysics::G4StepLimiterPhysics(const G4String &)
void G4StepLimiterPhysics::ConstructParticle()
void G4StepLimiterPhysics::ConstructProcess()
void G4StepLimiterPhysics::SetApplyToAll(G4bool)
G4bool G4StepLimiterPhysics::GetApplyToAll()
void G4CutTubs::G4CutTubs(const G4String &, G4double, G4double, G4double, G4double, G4double, G4ThreeVector, G4ThreeVector)
G4double G4CutTubs::GetInnerRadius()
G4double G4CutTubs::GetOuterRadius()
G4double G4CutTubs::GetZHalfLength()
G4double G4CutTubs::GetStartPhiAngle()
G4double G4CutTubs::GetDeltaPhiAngle()
G4double G4CutTubs::GetSinStartPhi()
G4double G4CutTubs::GetCosStartPhi()
G4double G4CutTubs::GetSinEndPhi()
G4double G4CutTubs::GetCosEndPhi()
G4ThreeVector G4CutTubs::GetLowNorm()
G4ThreeVector G4CutTubs::GetHighNorm()
void G4CutTubs::SetInnerRadius(G4double)
void G4CutTubs::SetOuterRadius(G4double)
void G4CutTubs::SetZHalfLength(G4double)
void G4CutTubs::SetStartPhiAngle(G4double, G4bool)
void G4CutTubs::SetDeltaPhiAngle(G4double)
G4double G4CutTubs::GetCubicVolume()
G4double G4CutTubs::GetSurfaceArea()
void G4CutTubs::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4CutTubs::Inside(const G4ThreeVector &)
G4ThreeVector G4CutTubs::SurfaceNormal(const G4ThreeVector &)
G4double G4CutTubs::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4CutTubs::DistanceToIn(const G4ThreeVector &)
G4double G4CutTubs::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4CutTubs::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4CutTubs::GetEntityType()
G4ThreeVector G4CutTubs::GetPointOnSurface()
G4VSolid * G4CutTubs::Clone()
G4Polyhedron * G4CutTubs::CreatePolyhedron()
void G4CutTubs::G4CutTubs(const G4CutTubs &)
G4CutTubs & G4CutTubs::operator=(const G4CutTubs &)
void G4EllipticalTube::G4EllipticalTube(const G4String &, G4double, G4double, G4double)
void G4EllipticalTube::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4EllipticalTube::Inside(const G4ThreeVector &)
G4ThreeVector G4EllipticalTube::SurfaceNormal(const G4ThreeVector &)
G4double G4EllipticalTube::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4EllipticalTube::DistanceToIn(const G4ThreeVector &)
G4double G4EllipticalTube::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4EllipticalTube::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4EllipticalTube::GetEntityType()
G4VSolid * G4EllipticalTube::Clone()
G4double G4EllipticalTube::GetCubicVolume()
G4double G4EllipticalTube::GetSurfaceArea()
G4ThreeVector G4EllipticalTube::GetPointOnSurface()
G4Polyhedron * G4EllipticalTube::CreatePolyhedron()
G4Polyhedron * G4EllipticalTube::GetPolyhedron()
G4double G4EllipticalTube::GetDx()
G4double G4EllipticalTube::GetDy()
G4double G4EllipticalTube::GetDz()
void G4EllipticalTube::SetDx(G4double)
void G4EllipticalTube::SetDy(G4double)
void G4EllipticalTube::SetDz(G4double)
void G4EllipticalTube::G4EllipticalTube(const G4EllipticalTube &)
G4EllipticalTube & G4EllipticalTube::operator=(const G4EllipticalTube &)
void G4EllipticalCone::G4EllipticalCone(const G4String &, G4double, G4double, G4double, G4double)
G4double G4EllipticalCone::GetSemiAxisMin()
G4double G4EllipticalCone::GetSemiAxisMax()
G4double G4EllipticalCone::GetSemiAxisX()
G4double G4EllipticalCone::GetSemiAxisY()
G4double G4EllipticalCone::GetZMax()
G4double G4EllipticalCone::GetZTopCut()
void G4EllipticalCone::SetSemiAxis(G4double, G4double, G4double)
void G4EllipticalCone::SetZCut(G4double)
G4double G4EllipticalCone::GetCubicVolume()
G4double G4EllipticalCone::GetSurfaceArea()
void G4EllipticalCone::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4EllipticalCone::Inside(const G4ThreeVector &)
G4ThreeVector G4EllipticalCone::SurfaceNormal(const G4ThreeVector &)
G4double G4EllipticalCone::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4EllipticalCone::DistanceToIn(const G4ThreeVector &)
G4double G4EllipticalCone::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4EllipticalCone::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4EllipticalCone::GetEntityType()
G4VSolid * G4EllipticalCone::Clone()
G4ThreeVector G4EllipticalCone::GetPointOnSurface()
G4Polyhedron * G4EllipticalCone::GetPolyhedron()
G4Polyhedron * G4EllipticalCone::CreatePolyhedron()
void G4EllipticalCone::G4EllipticalCone(const G4EllipticalCone &)
G4EllipticalCone & G4EllipticalCone::operator=(const G4EllipticalCone &)
void G4Paraboloid::G4Paraboloid(const G4String &, G4double, G4double, G4double)
G4double G4Paraboloid::GetZHalfLength()
G4double G4Paraboloid::GetRadiusMinusZ()
G4double G4Paraboloid::GetRadiusPlusZ()
G4double G4Paraboloid::GetCubicVolume()
G4double G4Paraboloid::GetSurfaceArea()
G4double G4Paraboloid::CalculateSurfaceArea()
void G4Paraboloid::SetZHalfLength(G4double)
void G4Paraboloid::SetRadiusMinusZ(G4double)
void G4Paraboloid::SetRadiusPlusZ(G4double)
void G4Paraboloid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Paraboloid::Inside(const G4ThreeVector &)
G4ThreeVector G4Paraboloid::SurfaceNormal(const G4ThreeVector &)
G4double G4Paraboloid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Paraboloid::DistanceToIn(const G4ThreeVector &)
G4double G4Paraboloid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Paraboloid::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Paraboloid::GetEntityType()
G4VSolid * G4Paraboloid::Clone()
G4ThreeVector G4Paraboloid::GetPointOnSurface()
G4Polyhedron * G4Paraboloid::CreatePolyhedron()
G4Polyhedron * G4Paraboloid::GetPolyhedron()
void G4Paraboloid::G4Paraboloid(const G4Paraboloid &)
G4Paraboloid & G4Paraboloid::operator=(const G4Paraboloid &)
void G4Tet::G4Tet(const G4String &, const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &, G4bool *)
void G4Tet::SetVertices(const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &, G4bool *)
void G4Tet::GetVertices(G4ThreeVector &, G4ThreeVector &, G4ThreeVector &, G4ThreeVector &)
std::vector<G4ThreeVector> G4Tet::GetVertices()
void G4Tet::PrintWarnings(G4bool)
G4bool G4Tet::CheckDegeneracy(const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &, const G4ThreeVector &)
void G4Tet::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4Tet::SetBoundingLimits(const G4ThreeVector &, const G4ThreeVector &)
void G4Tet::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4Tet::Inside(const G4ThreeVector &)
G4ThreeVector G4Tet::SurfaceNormal(const G4ThreeVector &)
G4double G4Tet::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4Tet::DistanceToIn(const G4ThreeVector &)
G4double G4Tet::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4Tet::DistanceToOut(const G4ThreeVector &)
G4GeometryType G4Tet::GetEntityType()
G4bool G4Tet::IsFaceted()
G4VSolid * G4Tet::Clone()
G4double G4Tet::GetCubicVolume()
G4double G4Tet::GetSurfaceArea()
G4ThreeVector G4Tet::GetPointOnSurface()
G4Polyhedron * G4Tet::CreatePolyhedron()
G4Polyhedron * G4Tet::GetPolyhedron()
void G4Tet::G4Tet(const G4Tet &)
G4Tet & G4Tet::operator=(const G4Tet &)
void G4TwistedBox::G4TwistedBox(const G4String &, G4double, G4double, G4double, G4double)
G4double G4TwistedBox::GetXHalfLength()
G4double G4TwistedBox::GetYHalfLength()
G4double G4TwistedBox::GetZHalfLength()
G4double G4TwistedBox::GetPhiTwist()
G4GeometryType G4TwistedBox::GetEntityType()
G4double G4TwistedBox::GetCubicVolume()
G4double G4TwistedBox::GetSurfaceArea()
G4VSolid * G4TwistedBox::Clone()
void G4TwistedBox::G4TwistedBox(const G4TwistedBox &)
G4TwistedBox & G4TwistedBox::operator=(const G4TwistedBox &)
void G4TwistedTrap::G4TwistedTrap(const G4String &, G4double, G4double, G4double, G4double, G4double)
void G4TwistedTrap::G4TwistedTrap(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4TwistedTrap::GetY1HalfLength()
G4double G4TwistedTrap::GetX1HalfLength()
G4double G4TwistedTrap::GetX2HalfLength()
G4double G4TwistedTrap::GetY2HalfLength()
G4double G4TwistedTrap::GetX3HalfLength()
G4double G4TwistedTrap::GetX4HalfLength()
G4double G4TwistedTrap::GetZHalfLength()
G4double G4TwistedTrap::GetPhiTwist()
G4double G4TwistedTrap::GetTiltAngleAlpha()
G4double G4TwistedTrap::GetPolarAngleTheta()
G4double G4TwistedTrap::GetAzimuthalAnglePhi()
G4GeometryType G4TwistedTrap::GetEntityType()
G4VSolid * G4TwistedTrap::Clone()
void G4TwistedTrap::G4TwistedTrap(const G4TwistedTrap &)
G4TwistedTrap & G4TwistedTrap::operator=(const G4TwistedTrap &)
void G4TwistedTrd::G4TwistedTrd(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double)
G4double G4TwistedTrd::GetX1HalfLength()
G4double G4TwistedTrd::GetX2HalfLength()
G4double G4TwistedTrd::GetY1HalfLength()
G4double G4TwistedTrd::GetY2HalfLength()
G4double G4TwistedTrd::GetZHalfLength()
G4double G4TwistedTrd::GetPhiTwist()
G4GeometryType G4TwistedTrd::GetEntityType()
G4double G4TwistedTrd::GetCubicVolume()
G4double G4TwistedTrd::GetSurfaceArea()
G4VSolid * G4TwistedTrd::Clone()
void G4TwistedTrd::G4TwistedTrd(const G4TwistedTrd &)
G4TwistedTrd & G4TwistedTrd::operator=(const G4TwistedTrd &)
void G4GenericTrap::G4GenericTrap(const G4String &, G4double, const std::vector<G4TwoVector> &)
void G4GenericTrap::G4GenericTrap(const G4GenericTrap &)
G4GenericTrap & G4GenericTrap::operator=(const G4GenericTrap &)
G4double G4GenericTrap::GetZHalfLength()
G4int G4GenericTrap::GetNofVertices()
G4TwoVector G4GenericTrap::GetVertex(G4int)
const std::vector<G4TwoVector> & G4GenericTrap::GetVertices()
G4double G4GenericTrap::GetTwistAngle(G4int)
G4bool G4GenericTrap::IsTwisted()
G4int G4GenericTrap::GetVisSubdivisions()
void G4GenericTrap::SetVisSubdivisions(G4int)
EInside G4GenericTrap::Inside(const G4ThreeVector &)
G4ThreeVector G4GenericTrap::SurfaceNormal(const G4ThreeVector &)
G4double G4GenericTrap::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4GenericTrap::DistanceToIn(const G4ThreeVector &)
G4double G4GenericTrap::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4GenericTrap::DistanceToOut(const G4ThreeVector &)
void G4GenericTrap::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4GeometryType G4GenericTrap::GetEntityType()
G4bool G4GenericTrap::IsFaceted()
G4VSolid * G4GenericTrap::Clone()
G4ThreeVector G4GenericTrap::GetPointOnSurface()
G4double G4GenericTrap::GetCubicVolume()
G4double G4GenericTrap::GetSurfaceArea()
G4Polyhedron * G4GenericTrap::CreatePolyhedron()
G4Polyhedron * G4GenericTrap::GetPolyhedron()
void G4TwistedTubs::G4TwistedTubs(const G4String &, G4double, G4double, G4double, G4double, G4double)
void G4TwistedTubs::G4TwistedTubs(const G4String &, G4double, G4double, G4double, G4double, G4int, G4double)
void G4TwistedTubs::G4TwistedTubs(const G4String &, G4double, G4double, G4double, G4double, G4double, G4double)
void G4TwistedTubs::G4TwistedTubs(const G4String &, G4double, G4double, G4double, G4double, G4double, G4int, G4double)
void G4TwistedTubs::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
void G4TwistedTubs::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
G4double G4TwistedTubs::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4TwistedTubs::DistanceToIn(const G4ThreeVector &)
G4double G4TwistedTubs::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4TwistedTubs::DistanceToOut(const G4ThreeVector &)
EInside G4TwistedTubs::Inside(const G4ThreeVector &)
G4ThreeVector G4TwistedTubs::SurfaceNormal(const G4ThreeVector &)
G4Polyhedron * G4TwistedTubs::CreatePolyhedron()
G4Polyhedron * G4TwistedTubs::GetPolyhedron()
G4double G4TwistedTubs::GetDPhi()
G4double G4TwistedTubs::GetPhiTwist()
G4double G4TwistedTubs::GetInnerRadius()
G4double G4TwistedTubs::GetOuterRadius()
G4double G4TwistedTubs::GetInnerStereo()
G4double G4TwistedTubs::GetOuterStereo()
G4double G4TwistedTubs::GetZHalfLength()
G4double G4TwistedTubs::GetKappa()
G4double G4TwistedTubs::GetTanInnerStereo()
G4double G4TwistedTubs::GetTanInnerStereo2()
G4double G4TwistedTubs::GetTanOuterStereo()
G4double G4TwistedTubs::GetTanOuterStereo2()
G4double G4TwistedTubs::GetEndZ(G4int)
G4double G4TwistedTubs::GetEndPhi(G4int)
G4double G4TwistedTubs::GetEndInnerRadius(G4int)
G4double G4TwistedTubs::GetEndOuterRadius(G4int)
G4double G4TwistedTubs::GetEndInnerRadius()
G4double G4TwistedTubs::GetEndOuterRadius()
G4GeometryType G4TwistedTubs::GetEntityType()
G4VSolid * G4TwistedTubs::Clone()
G4double G4TwistedTubs::GetCubicVolume()
G4double G4TwistedTubs::GetSurfaceArea()
G4ThreeVector G4TwistedTubs::GetPointOnSurface()
void G4TwistedTubs::G4TwistedTubs(const G4TwistedTubs &)
G4TwistedTubs & G4TwistedTubs::operator=(const G4TwistedTubs &)
void CLHEP::HepLorentzRotation::HepLorentzRotation_row::HepLorentzRotation_row(const CLHEP::HepLorentzRotation &, int)
double CLHEP::HepLorentzRotation::HepLorentzRotation_row::operator[](int)
void G4BooleanSolid::G4BooleanSolid(const G4String &, G4VSolid *, G4VSolid *)
void G4BooleanSolid::G4BooleanSolid(const G4String &, G4VSolid *, G4VSolid *, G4RotationMatrix *, const G4ThreeVector &)
void G4BooleanSolid::G4BooleanSolid(const G4String &, G4VSolid *, G4VSolid *, const G4Transform3D &)
const G4VSolid * G4BooleanSolid::GetConstituentSolid(G4int)
G4VSolid * G4BooleanSolid::GetConstituentSolid(G4int)
G4double G4BooleanSolid::GetCubicVolume()
G4double G4BooleanSolid::GetSurfaceArea()
G4GeometryType G4BooleanSolid::GetEntityType()
G4Polyhedron * G4BooleanSolid::GetPolyhedron()
G4int G4BooleanSolid::GetCubVolStatistics()
G4double G4BooleanSolid::GetCubVolEpsilon()
void G4BooleanSolid::SetCubVolStatistics(G4int)
void G4BooleanSolid::SetCubVolEpsilon(G4double)
G4int G4BooleanSolid::GetAreaStatistics()
G4double G4BooleanSolid::GetAreaAccuracy()
void G4BooleanSolid::SetAreaStatistics(G4int)
void G4BooleanSolid::SetAreaAccuracy(G4double)
G4ThreeVector G4BooleanSolid::GetPointOnSurface()
G4int G4BooleanSolid::GetNumOfConstituents()
G4bool G4BooleanSolid::IsFaceted()
void G4BooleanSolid::G4BooleanSolid(const G4BooleanSolid &)
G4BooleanSolid & G4BooleanSolid::operator=(const G4BooleanSolid &)
void G4BooleanSolid::SetExternalBooleanProcessor(G4VBooleanProcessor *)
G4VBooleanProcessor * G4BooleanSolid::GetExternalBooleanProcessor()
void G4UnionSolid::G4UnionSolid(const G4String &, G4VSolid *, G4VSolid *)
void G4UnionSolid::G4UnionSolid(const G4String &, G4VSolid *, G4VSolid *, G4RotationMatrix *, const G4ThreeVector &)
void G4UnionSolid::G4UnionSolid(const G4String &, G4VSolid *, G4VSolid *, const G4Transform3D &)
G4GeometryType G4UnionSolid::GetEntityType()
G4VSolid * G4UnionSolid::Clone()
void G4UnionSolid::G4UnionSolid(const G4UnionSolid &)
G4UnionSolid & G4UnionSolid::operator=(const G4UnionSolid &)
void G4UnionSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4UnionSolid::Inside(const G4ThreeVector &)
G4ThreeVector G4UnionSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4UnionSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4UnionSolid::DistanceToIn(const G4ThreeVector &)
G4double G4UnionSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4UnionSolid::DistanceToOut(const G4ThreeVector &)
void G4UnionSolid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4Polyhedron * G4UnionSolid::CreatePolyhedron()
G4double G4UnionSolid::GetCubicVolume()
void G4SubtractionSolid::G4SubtractionSolid(const G4String &, G4VSolid *, G4VSolid *)
void G4SubtractionSolid::G4SubtractionSolid(const G4String &, G4VSolid *, G4VSolid *, G4RotationMatrix *, const G4ThreeVector &)
void G4SubtractionSolid::G4SubtractionSolid(const G4String &, G4VSolid *, G4VSolid *, const G4Transform3D &)
G4GeometryType G4SubtractionSolid::GetEntityType()
G4VSolid * G4SubtractionSolid::Clone()
void G4SubtractionSolid::G4SubtractionSolid(const G4SubtractionSolid &)
G4SubtractionSolid & G4SubtractionSolid::operator=(const G4SubtractionSolid &)
void G4SubtractionSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4SubtractionSolid::Inside(const G4ThreeVector &)
G4ThreeVector G4SubtractionSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4SubtractionSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4SubtractionSolid::DistanceToIn(const G4ThreeVector &)
G4double G4SubtractionSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4SubtractionSolid::DistanceToOut(const G4ThreeVector &)
void G4SubtractionSolid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4Polyhedron * G4SubtractionSolid::CreatePolyhedron()
G4double G4SubtractionSolid::GetCubicVolume()
void G4IntersectionSolid::G4IntersectionSolid(const G4String &, G4VSolid *, G4VSolid *)
void G4IntersectionSolid::G4IntersectionSolid(const G4String &, G4VSolid *, G4VSolid *, G4RotationMatrix *, const G4ThreeVector &)
void G4IntersectionSolid::G4IntersectionSolid(const G4String &, G4VSolid *, G4VSolid *, const G4Transform3D &)
G4GeometryType G4IntersectionSolid::GetEntityType()
G4VSolid * G4IntersectionSolid::Clone()
void G4IntersectionSolid::G4IntersectionSolid(const G4IntersectionSolid &)
G4IntersectionSolid & G4IntersectionSolid::operator=(const G4IntersectionSolid &)
void G4IntersectionSolid::BoundingLimits(G4ThreeVector &, G4ThreeVector &)
EInside G4IntersectionSolid::Inside(const G4ThreeVector &)
G4ThreeVector G4IntersectionSolid::SurfaceNormal(const G4ThreeVector &)
G4double G4IntersectionSolid::DistanceToIn(const G4ThreeVector &, const G4ThreeVector &)
G4double G4IntersectionSolid::DistanceToIn(const G4ThreeVector &)
G4double G4IntersectionSolid::DistanceToOut(const G4ThreeVector &, const G4ThreeVector &, const G4bool, G4bool *, G4ThreeVector *)
G4double G4IntersectionSolid::DistanceToOut(const G4ThreeVector &)
void G4IntersectionSolid::ComputeDimensions(G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *)
G4Polyhedron * G4IntersectionSolid::CreatePolyhedron()
void G4UniformMagField::G4UniformMagField(const G4ThreeVector &)
void G4UniformMagField::G4UniformMagField(G4double, G4double, G4double)
void G4UniformMagField::G4UniformMagField(const G4UniformMagField &)
G4UniformMagField & G4UniformMagField::operator=(const G4UniformMagField &)
void G4UniformMagField::GetFieldValue(const G4double[4], G4double *)
void G4UniformMagField::SetFieldValue(const G4ThreeVector &)
G4ThreeVector G4UniformMagField::GetConstantFieldValue()
G4Field * G4UniformMagField::Clone()
void G4Colour::G4Colour(G4double, G4double, G4double, G4double)
void G4Colour::G4Colour(G4ThreeVector)
G4bool G4Colour::operator!=(const G4Colour &)
G4bool G4Colour::operator==(const G4Colour &)
G4Colour & G4Colour::operator+=(const G4Colour &)
G4double G4Colour::GetRed()
G4double G4Colour::GetGreen()
G4double G4Colour::GetBlue()
G4double G4Colour::GetAlpha()
void G4Colour::SetRed(G4double)
void G4Colour::SetGreen(G4double)
void G4Colour::SetBlue(G4double)
void G4Colour::SetAlpha(G4double)
G4Colour G4Colour::White()
G4Colour G4Colour::Gray()
G4Colour G4Colour::Grey()
G4Colour G4Colour::Black()
G4Colour G4Colour::Brown()
G4Colour G4Colour::Red()
G4Colour G4Colour::Green()
G4Colour G4Colour::Blue()
G4Colour G4Colour::Cyan()
G4Colour G4Colour::Magenta()
G4Colour G4Colour::Yellow()
G4bool G4Colour::GetColour(const G4String &, G4Colour &)
G4bool G4Colour::GetColor(const G4String &, G4Colour &)
void G4Colour::AddToMap(const G4String &, const G4Colour &)
void G4Colour::InitialiseColourMap()
G4bool G4Colour::operator<(const G4Colour &)
G4StateManager * G4StateManager::GetStateManager()
const G4ApplicationState & G4StateManager::GetCurrentState()
const G4ApplicationState & G4StateManager::GetPreviousState()
G4bool G4StateManager::SetNewState(const G4ApplicationState &)
G4bool G4StateManager::SetNewState(const G4ApplicationState &, const char *)
G4bool G4StateManager::RegisterDependent(G4VStateDependent *, G4bool)
G4bool G4StateManager::DeregisterDependent(G4VStateDependent *)
G4VStateDependent * G4StateManager::RemoveDependent(const G4VStateDependent *)
G4String G4StateManager::GetStateString(const G4ApplicationState &)
void G4StateManager::NotifyDeletion(const G4Event *)
void G4StateManager::NotifyDeletion(const G4Run *)
void G4StateManager::SetSuppressAbortion(G4int)
G4int G4StateManager::GetSuppressAbortion()
const char * G4StateManager::GetMessage()
void G4StateManager::SetExceptionHandler(G4VExceptionHandler *)
G4VExceptionHandler * G4StateManager::GetExceptionHandler()
void G4StateManager::SetVerboseLevel(G4int)
G4int G4Threading::G4GetNumberOfCores()
G4int G4Threading::G4GetThreadId()
G4bool G4Threading::IsWorkerThread()
G4bool G4Threading::IsMasterThread()
void G4Threading::G4SetThreadId(G4int)
void G4Threading::SetMultithreadedApplication(G4bool)
G4bool G4Threading::IsMultithreadedApplication()
G4int G4Threading::WorkerThreadLeavesPool()
G4int G4Threading::WorkerThreadJoinsPool()
G4int G4Threading::GetNumberOfRunningWorkerThreads()
CLHEP::Hep3Vector CLHEP::rotationXOf(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::rotationYOf(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::rotationZOf(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::rotationOf(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::rotationOf(const CLHEP::Hep3Vector &, const CLHEP::HepAxisAngle &)
CLHEP::Hep3Vector CLHEP::rotationOf(const CLHEP::Hep3Vector &, double, double, double)
CLHEP::Hep3Vector CLHEP::rotationOf(const CLHEP::Hep3Vector &, const CLHEP::HepEulerAngles &)
CLHEP::Hep3Vector CLHEP::operator/(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::operator+(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::operator-(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
double CLHEP::operator*(const CLHEP::Hep3Vector &, const CLHEP::Hep3Vector &)
CLHEP::Hep3Vector CLHEP::operator*(const CLHEP::Hep3Vector &, double)
CLHEP::Hep3Vector CLHEP::operator*(double, const CLHEP::Hep3Vector &)
CLHEP::HepRotation CLHEP::inverseOf(const CLHEP::HepRotation &)
CLHEP::HepRotation CLHEP::operator*(const CLHEP::HepRotationX &, const CLHEP::HepRotation &)
CLHEP::HepRotation CLHEP::operator*(const CLHEP::HepRotationY &, const CLHEP::HepRotation &)
CLHEP::HepRotation CLHEP::operator*(const CLHEP::HepRotationZ &, const CLHEP::HepRotation &)
double CLHEP::operator*(const CLHEP::Hep2Vector &, const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector CLHEP::operator*(const CLHEP::Hep2Vector &, double)
CLHEP::Hep2Vector CLHEP::operator*(double, const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector CLHEP::operator/(const CLHEP::Hep2Vector &, double)
CLHEP::Hep2Vector CLHEP::operator+(const CLHEP::Hep2Vector &, const CLHEP::Hep2Vector &)
CLHEP::Hep2Vector CLHEP::operator-(const CLHEP::Hep2Vector &, const CLHEP::Hep2Vector &)
size_t size(const G4LogicalVolumeStore *)
G4LogicalVolume * GetVolume(const G4LogicalVolumeStore *, size_t)
G4PolyconeSideRZ & GetPolyCorner(const G4Polycone &, G4int)
G4PolyconeSideRZ & GetPolyCorner(const G4GenericPolycone &, G4int)
G4PolyhedraSideRZ & GetPolyCorner(const G4Polyhedra &, G4int)
void SetParticleByName(G4ParticleGun *, const char *)
G4ParticleDefinition * FindParticle(const char *)
G4ParticleDefinition * GetIon(G4int, G4int, G4double, G4int)
G4String make_G4String(const char *)
char * G4JL_getenv(const char *)
int G4JL_setenv(const char *, const char *)
void G4JL_init()
void G4JL_println(const char *)
void gc_safe_enter()
void gc_safe_leave()
CLHEP::HepBoost CLHEP::inverseOf(const CLHEP::HepBoost &)
CLHEP::HepLorentzRotation CLHEP::inverseOf(const CLHEP::HepLorentzRotation &)
CLHEP::HepLorentzRotation CLHEP::operator*(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator==(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator!=(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator<=(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator>=(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator<(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator>(const CLHEP::HepRotation &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator==(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator!=(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator<=(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator>=(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator<(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
bool CLHEP::operator>(const CLHEP::HepBoost &, const CLHEP::HepLorentzRotation &)
G4long G4Poisson(G4double)
