pymodG4geometry.cc File Reference

#include <boost/python.hpp>

Include dependency graph for pymodG4geometry.cc:

Go to the source code of this file.

Functions
void	export_G4GeometryManager ()
void	export_G4VTouchable ()
void	export_G4TouchableHistory ()
void	export_G4VPhysicalVolume ()
void	export_G4PVPlacement ()
void	export_G4PVReplica ()
void	export_G4LogicalVolume ()
void	export_G4Region ()
void	export_G4VSolid ()
void	export_G4Box ()
void	export_G4Cons ()
void	export_G4Para ()
void	export_G4Torus ()
void	export_G4Trd ()
void	export_G4Orb ()
void	export_G4Sphere ()
void	export_G4Trap ()
void	export_G4Tubs ()
void	export_G4Polycone ()
void	export_G4Polyhedra ()
void	export_G4EllipticalTube ()
void	export_G4Ellipsoid ()
void	export_G4EllipticalCone ()
void	export_G4Hype ()
void	export_G4Tet ()
void	export_G4TwistedBox ()
void	export_G4TwistedTrap ()
void	export_G4TwistedTrd ()
void	export_G4TwistedTubs ()
void	export_G4BooleanSolid ()
void	export_G4UnionSolid ()
void	export_G4IntersectionSolid ()
void	export_G4SubtractionSolid ()
void	export_G4TransportationManager ()
void	export_G4Navigator ()
void	export_G4FieldManager ()
void	export_G4Field ()
void	export_G4MagneticField ()
void	export_G4UniformMagField ()
void	export_G4ChordFinder ()
	BOOST_PYTHON_MODULE (G4geometry)

Function Documentation

BOOST_PYTHON_MODULE

(

G4geometry

)

Definition at line 80 of file pymodG4geometry.cc.

{
  export_G4GeometryManager();
  export_G4VTouchable();
  export_G4TouchableHistory();
  export_G4VPhysicalVolume();
  export_G4PVPlacement();
  export_G4PVReplica();
  export_G4LogicalVolume();
  export_G4Region();
  export_G4VSolid();
  export_G4Box();
  export_G4Cons();
  export_G4Para();
  export_G4Torus();
  export_G4Trd();
  export_G4Orb();
  export_G4Sphere();
  export_G4Trap();
  export_G4Tubs();
  export_G4Polycone();
  export_G4Polyhedra();
  export_G4EllipticalTube();
  export_G4Ellipsoid();
  export_G4EllipticalCone();
  export_G4Hype();
  export_G4Tet();
  export_G4TwistedBox();
  export_G4TwistedTrap();
  export_G4TwistedTrd();
  export_G4TwistedTubs();
  export_G4BooleanSolid();
  export_G4UnionSolid();
  export_G4IntersectionSolid();
  export_G4SubtractionSolid();
  export_G4TransportationManager();
  export_G4Navigator();
  export_G4FieldManager();
  export_G4Field();
  export_G4MagneticField();
  export_G4UniformMagField();
  export_G4ChordFinder();
}

Here is the call graph for this function:

void export_G4BooleanSolid

(

)

Definition at line 40 of file pyG4BooleanSolid.cc.

{
  class_<G4BooleanSolid, G4BooleanSolid*, bases<G4VSolid>, boost::noncopyable>
    ("G4BooleanSolid", "boolean solid class", no_init)
    // ---
    .def("GetCubVolStatistics",   &G4BooleanSolid::GetCubVolStatistics)
    .def("GetCubVolEpsilon",      &G4BooleanSolid::GetCubVolEpsilon)
    .def("SetCubVolStatistics",   &G4BooleanSolid::SetCubVolStatistics)
    .def("SetCubVolEpsilon",      &G4BooleanSolid::SetCubVolEpsilon)
    .def("GetAreaStatistics",     &G4BooleanSolid::GetAreaStatistics)
    .def("GetAreaAccuracy",       &G4BooleanSolid::GetAreaAccuracy)
    .def("SetAreaStatistics",     &G4BooleanSolid::SetAreaStatistics)
    .def("SetAreaAccuracy",       &G4BooleanSolid::SetAreaAccuracy)
    .def("GetPointOnSurface",     &G4BooleanSolid::GetPointOnSurface)
    ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Box

(

)

Definition at line 55 of file pyG4Box.cc.

{
  class_<G4Box, G4Box*, bases<G4VSolid> >
    ("G4Box", "box solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double>())
    // ---
    .def("GetXHalfLength",   &G4Box::GetXHalfLength)
    .def("GetYHalfLength",   &G4Box::GetYHalfLength)
    .def("GetZHalfLength",   &G4Box::GetZHalfLength)
    .def("SetXHalfLength",   &G4Box::SetXHalfLength)
    .def("SetYHalfLength",   &G4Box::SetYHalfLength)
    .def("SetZHalfLength",   &G4Box::SetZHalfLength)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateBox", CreateBox, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4ChordFinder

(

)

Definition at line 52 of file pyG4ChordFinder.cc.

{
  class_<G4ChordFinder, G4ChordFinder*, boost::noncopyable>
    ("G4ChordFinder", "chord finder class", no_init)
    // constructor
    .def(init<G4MagInt_Driver*>())
    .def(init<G4MagneticField*>())
    .def(init<G4MagneticField*, G4double>())
    .def(init<G4MagneticField*, G4double, G4MagIntegratorStepper*>())
    // ---
    .def("GetDeltaChord",   &G4ChordFinder::GetDeltaChord)
    .def("SetDeltaChord",   &G4ChordFinder::SetDeltaChord)
    // ---
    .def("PrintStatistics", &G4ChordFinder::PrintStatistics)
    .def("SetVerbose",      &G4ChordFinder::SetVerbose, f_SetVerbose())
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Cons

(

)

Definition at line 56 of file pyG4Cons.cc.

{
  class_<G4Cons, G4Cons*, bases<G4VSolid> >
    ("G4Cons", "Cone solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
     G4double, G4double, G4double, G4double>())
    // ---
    .def("GetInnerRadiusMinusZ", &G4Cons::GetInnerRadiusMinusZ)
    .def("GetOuterRadiusMinusZ", &G4Cons::GetOuterRadiusMinusZ)
    .def("GetInnerRadiusPlusZ",  &G4Cons::GetInnerRadiusPlusZ)
    .def("GetOuterRadiusPlusZ",  &G4Cons::GetOuterRadiusPlusZ)
    .def("GetZHalfLength",       &G4Cons::GetZHalfLength)
    .def("GetStartPhiAngle",     &G4Cons::GetStartPhiAngle)
    .def("GetDeltaPhiAngle",     &G4Cons::GetDeltaPhiAngle)
    .def("SetInnerRadiusMinusZ", &G4Cons::SetInnerRadiusMinusZ)
    .def("SetOuterRadiusMinusZ", &G4Cons::SetOuterRadiusMinusZ)
    .def("SetInnerRadiusPlusZ",  &G4Cons::SetInnerRadiusPlusZ)
    .def("SetOuterRadiusPlusZ",  &G4Cons::SetOuterRadiusPlusZ)
    .def("SetZHalfLength",       &G4Cons::SetZHalfLength)
    .def("SetStartPhiAngle",     &G4Cons::SetStartPhiAngle)
    .def("SetDeltaPhiAngle",     &G4Cons::SetDeltaPhiAngle)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateCons", CreateCons, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Ellipsoid

(

)

Definition at line 62 of file pyG4Ellipsoid.cc.

{
  class_<G4Ellipsoid, G4Ellipsoid*, bases<G4VSolid> >
    ("G4Ellipsoid", "ellipsoid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, G4double,
                               G4double>())
    // ---
    .def("GetSemiAxisMax", &G4Ellipsoid::GetSemiAxisMax)
    .def("GetZBottomCut",  &G4Ellipsoid::GetZBottomCut)
    .def("GetZTopCut",     &G4Ellipsoid::GetZTopCut)
    .def("SetSemiAxis",  &G4Ellipsoid::SetSemiAxis)
    .def("SetZCuts",  &G4Ellipsoid::SetZCuts)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateEllipsoid", CreateEllipsoid,
        f_CreateEllipsoid()[return_value_policy<manage_new_object>()]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4EllipticalCone

(

)

Definition at line 58 of file pyG4EllipticalCone.cc.

{
  class_<G4EllipticalCone, G4EllipticalCone*, bases<G4VSolid> >
    ("G4EllipticalCone", "elliptical cone solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double, G4double>())
    // ---
    .def("GetSimiAxisMax",  &G4EllipticalCone::GetSemiAxisMax)
    .def("GetZTopCut",      &G4EllipticalCone::GetZTopCut)
    .def("SetSemiAxis",     &G4EllipticalCone::SetSemiAxis)
    .def("SetZCut",         &G4EllipticalCone::SetZCut)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateEllipticalCone", CreateEllipticalCone,
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4EllipticalTube

(

)

Definition at line 57 of file pyG4EllipticalTube.cc.

{
  class_<G4EllipticalTube, G4EllipticalTube*, bases<G4VSolid> >
    ("G4EllipticalTube", "elliptical tube solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double>())
    // ---
    .def("GetDx",  &G4EllipticalTube::GetDx)
    .def("GetDy",  &G4EllipticalTube::GetDy)
    .def("GetDz",  &G4EllipticalTube::GetDz)
    .def("SetDx",  &G4EllipticalTube::SetDx)
    .def("SetDy",  &G4EllipticalTube::SetDy)
    .def("SetDz",  &G4EllipticalTube::SetDz)

    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateEllipticalTube", CreateEllipticalTube,
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Field

(

)

Definition at line 40 of file pyG4Field.cc.

{
  class_<G4Field, G4Field*, boost::noncopyable>
    ("G4Field", "base class of field", no_init)
    ;
}

Here is the caller graph for this function:

void export_G4FieldManager

(

)

Definition at line 70 of file pyG4FieldManager.cc.

{
  class_<G4FieldManager, G4FieldManager*, boost::noncopyable>
    ("G4FieldManager", "field manager class")
    // constructors
    .def(init<>())
    .def(init<G4Field*>())
    .def(init<G4Field*, G4ChordFinder*>())
    .def(init<G4Field*, G4ChordFinder*, G4bool>())
    .def(init<G4MagneticField*>())
    // ---
    .def("SetDetectorField",      &G4FieldManager::SetDetectorField)
    .def("GetDetectorField",      &G4FieldManager::GetDetectorField,
         return_internal_reference<>())
    .def("DoesFieldExist",        &G4FieldManager::DoesFieldExist)
    .def("CreateChordFinder",     &G4FieldManager::CreateChordFinder)
    .def("SetChordFinder",        &G4FieldManager::SetChordFinder)
    .def("GetChordFinder",        f1_GetChordFinder,
     return_internal_reference<>())
    .def("GetChordFinder",        f2_GetChordFinder,
     return_internal_reference<>())
    .def("ConfigureForTrack",     &G4FieldManager::ConfigureForTrack)
    .def("GetDeltaIntersection",  &G4FieldManager::GetDeltaIntersection)
    .def("GetDeltaOneStep",       &G4FieldManager::GetDeltaOneStep)
    .def("SetAccuraciesWithDeltaOneStep",
     &G4FieldManager::SetAccuraciesWithDeltaOneStep)
    .def("SetDeltaOneStep",       &G4FieldManager::SetDeltaOneStep)
    .def("SetDeltaIntersection",  &G4FieldManager::SetDeltaIntersection)
    .def("GetMinimumEpsilonStep", &G4FieldManager::GetMinimumEpsilonStep)
    .def("SetMinimumEpsilonStep", &G4FieldManager::SetMinimumEpsilonStep)
    .def("GetMaximumEpsilonStep", &G4FieldManager::GetMaximumEpsilonStep)
    .def("SetMaximumEpsilonStep", &G4FieldManager::SetMaximumEpsilonStep)
    .def("DoesFieldChangeEnergy", &G4FieldManager::DoesFieldChangeEnergy)
    .def("SetFieldChangesEnergy", &G4FieldManager::SetFieldChangesEnergy)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4GeometryManager

(

)

Definition at line 53 of file pyG4GeometryManager.cc.

{
  class_<G4GeometryManager, boost::noncopyable>
    ("G4GeometryManager", "geometry manager", no_init)
    .def("GetInstance",           &G4GeometryManager::GetInstance,
         return_value_policy<reference_existing_object>())
    .staticmethod("GetInstance")
    // ---
    .def("CloseGeometry",         &G4GeometryManager::CloseGeometry,
         f_CloseGeometry())
    .def("OpenGeometry",          &G4GeometryManager::OpenGeometry,
         f_OpenGeometry())
    .def("IsGeometryClosed",      &G4GeometryManager::IsGeometryClosed)
    .def("SetWorldMaximumExtent", &G4GeometryManager::SetWorldMaximumExtent)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Hype

(

)

Definition at line 62 of file pyG4Hype.cc.

{
  class_<G4Hype, G4Hype*, bases<G4VSolid> >
    ("G4Hype", "hyperbolic solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
                               G4double, G4double>())
    // ---
    .def("GetInnerRadius",   &G4Hype::GetInnerRadius)
    .def("GetOuterRadius",   &G4Hype::GetOuterRadius)
    .def("GetZHalfLength",   &G4Hype::GetZHalfLength)
    .def("GetInnerStereo",   &G4Hype::GetInnerStereo)
    .def("GetOuterStereo",   &G4Hype::GetOuterStereo)
    .def("SetInnerRadius",   &G4Hype::SetInnerRadius)
    .def("SetOuterRadius",   &G4Hype::SetOuterRadius)
    .def("SetZHalfLength",   &G4Hype::SetZHalfLength)
    .def("SetInnerStereo",   &G4Hype::SetInnerStereo)
    .def("SetOuterStereo",   &G4Hype::SetOuterStereo)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateHype", CreateHype, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4IntersectionSolid

(

)

Definition at line 40 of file pyG4IntersctionSolid.cc.

{
  class_<G4IntersectionSolid,G4IntersectionSolid*,
    bases<G4BooleanSolid>,boost::noncopyable>
    ("G4IntersectionSolid", "intersection solid class", no_init)
    // ---
    .def(init<const G4String&, G4VSolid*, G4VSolid*>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         G4RotationMatrix*, const G4ThreeVector&>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         const G4Transform3D&>())   
    ;
}

Here is the caller graph for this function:

void export_G4LogicalVolume

(

)

Definition at line 72 of file pyG4LogicalVolume.cc.

{
  class_<G4LogicalVolume, G4LogicalVolume*, boost::noncopyable>
    ("G4LogicalVolume", "logical volume class", no_init)
    // constructors
    .def(init<G4VSolid*, G4Material*, const G4String& >())
    .def(init<G4VSolid*, G4Material*, const G4String&,
         G4FieldManager* >())
    .def(init<G4VSolid*, G4Material*, const G4String&,
         G4FieldManager*, G4VSensitiveDetector* >())
    .def(init<G4VSolid*, G4Material*, const G4String&,
         G4FieldManager*, G4VSensitiveDetector*,
         G4UserLimits* >())
    .def(init<G4VSolid*, G4Material*, const G4String&,
         G4FieldManager*, G4VSensitiveDetector*,
         G4UserLimits*, G4bool >())
    // ---
    .def("GetName",         &G4LogicalVolume::GetName,
         return_value_policy<reference_existing_object>())
    .def("SetName",         &G4LogicalVolume::SetName)
    // ---
    .def("GetNoDaughters",  &G4LogicalVolume::GetNoDaughters)
    .def("GetDaughter",     &G4LogicalVolume::GetDaughter,
           return_internal_reference<>())
    .def("AddDaughter",     &G4LogicalVolume::AddDaughter)
    .def("IsDaughter",      &G4LogicalVolume::IsDaughter)
    .def("IsAncestor",      &G4LogicalVolume::IsAncestor)
    .def("RemoveDaughter",  &G4LogicalVolume::RemoveDaughter)
    .def("ClearDaughters",  &G4LogicalVolume::ClearDaughters)
    .def("TotalVolumeEntities", &G4LogicalVolume::TotalVolumeEntities)
    // ----
    .def("GetSolid",        f1_GetSolid,
         return_internal_reference<>())
    .def("SetSolid",        f1_SetSolid)
    .def("GetMaterial",     &G4LogicalVolume::GetMaterial,
           return_internal_reference<>())
    .def("SetMaterial",     &G4LogicalVolume::SetMaterial)
    .def("UpdateMaterial",  &G4LogicalVolume::UpdateMaterial)
    // ---
    .def("GetMass",         &G4LogicalVolume::GetMass, f_GetMass())
    .def("GetFieldManager", &G4LogicalVolume::GetFieldManager,
           return_internal_reference<>())
    .def("SetFieldManager", &G4LogicalVolume::SetFieldManager)
    .def("GetSensitiveDetector", &G4LogicalVolume::GetSensitiveDetector,
           return_internal_reference<>())
    .def("SetSensitiveDetector", &G4LogicalVolume::SetSensitiveDetector)
    .def("GetUserLimits",   &G4LogicalVolume::GetUserLimits,
           return_internal_reference<>())
    .def("SetUserLimits",   &G4LogicalVolume::SetUserLimits)
    // ---
    .def("GetVoxelHeader",  &G4LogicalVolume::GetVoxelHeader,
           return_internal_reference<>())
    .def("SetVoxelHeader",  &G4LogicalVolume::SetVoxelHeader)
    .def("GetSmartless",    &G4LogicalVolume::GetSmartless)
    .def("SetSmartless",    &G4LogicalVolume::SetSmartless)
    .def("IsToOptimise",    &G4LogicalVolume::IsToOptimise)
    .def("SetOptimisation", &G4LogicalVolume::SetOptimisation)
    // ---
    .def("IsRootRegion",    &G4LogicalVolume::IsRootRegion)
    .def("SetRegionRootFlag", &G4LogicalVolume::SetRegionRootFlag)
    .def("IsRegion",        &G4LogicalVolume::IsRegion)
    .def("SetRegion",       &G4LogicalVolume::SetRegion)
    .def("GetRegion",       &G4LogicalVolume::GetRegion,
           return_internal_reference<>())
    .def("PropagateRegion", &G4LogicalVolume::PropagateRegion)
    .def("GetMaterialCutsCouple", &G4LogicalVolume::GetMaterialCutsCouple,
           return_internal_reference<>())
    .def("SetMaterialCutsCouple", &G4LogicalVolume::SetMaterialCutsCouple)
    // ---
    .def("GetVisAttributes", &G4LogicalVolume::GetVisAttributes,
           return_internal_reference<>())
    .def("SetVisAttributes", f1_SetVisAttributes)
    .def("SetVisAttributes", f2_SetVisAttributes)
    // ---
    .def("GetFastSimulationManager",
          &G4LogicalVolume::GetFastSimulationManager,
          return_internal_reference<>())
    // ---
    .def("SetBiasWeight",  &G4LogicalVolume::SetBiasWeight)
    .def("GetBiasWeight",  &G4LogicalVolume::GetBiasWeight)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4MagneticField

(

)

Definition at line 89 of file pyG4MagneticField.cc.

{
  class_<G4MagneticField, boost::noncopyable >
    ("__G4MagneticField", "dummy class of magnetic field", no_init)
    ;

  class_<CB_PyG4MagneticField, boost::noncopyable,
    bases<G4Field, G4MagneticField> >
    ("G4MagneticField", "base class of magnetic field")
    // ---
    .def("DoesFieldChangeEnergy", &G4MagneticField::DoesFieldChangeEnergy)
    .def("GetFieldValue", pure_virtual(f1_GetFieldValue))
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Navigator

(

)

Definition at line 42 of file pyG4Navigator.cc.

{
  class_<G4Navigator, G4Navigator*, boost::noncopyable>
    ("G4Navigator", "navigator")
    // ---
    .def("GetWorldVolume",        &G4Navigator::GetWorldVolume,
         return_value_policy<reference_existing_object>())
    .def("GetVerboseLevel",       &G4Navigator::GetVerboseLevel)
    .def("SetVerboseLevel",       &G4Navigator::SetVerboseLevel)
    .def("IsActive",              &G4Navigator::IsActive)
    .def("PrintState",            &G4Navigator::PrintState)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Orb

(

)

Definition at line 54 of file pyG4Orb.cc.

{
  class_<G4Orb, G4Orb*, bases<G4VSolid> >
    ("G4Orb", "Orb solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double>())
    // ---
    .def("GetRadius", &G4Orb::GetRadius)
    .def("SetRadius", &G4Orb::SetRadius)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateOrb", CreateOrb, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Para

(

)

Definition at line 56 of file pyG4Para.cc.

{
  class_<G4Para, G4Para*, bases<G4VSolid> >
    ("G4Para", "Skewed box sold class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
     G4double, G4double, G4double>())
    // ---
    .def("GetZHalfLength",    &G4Para::GetZHalfLength)
    .def("GetSymAxis",        &G4Para::GetSymAxis)
    .def("GetYHalfLength",    &G4Para::GetYHalfLength)
    .def("GetXHalfLength",    &G4Para::GetXHalfLength)
    .def("GetTanAlpha",       &G4Para::GetTanAlpha)
    .def("SetXHalfLength",    &G4Para::SetXHalfLength)
    .def("SetYHalfLength",    &G4Para::SetYHalfLength)
    .def("SetZHalfLength",    &G4Para::SetZHalfLength)
    .def("SetAlpha",          &G4Para::SetAlpha)
    .def("SetTanAlpha",       &G4Para::SetTanAlpha)
    .def("SetThetaAndPhi",    &G4Para::SetThetaAndPhi)
    .def("SetAllParameters",  &G4Para::SetAllParameters)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreatePara", CreatePara, return_value_policy<manage_new_object>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Polycone

(

)

Definition at line 91 of file pyG4Polycone.cc.

{
  class_<G4Polycone, G4Polycone*, bases<G4VSolid> >
    ("G4Polycone", "Polycone solid class", no_init)
    // ---
    .def("GetStartPhi",    &G4Polycone::GetStartPhi)
    .def("GetEndPhi",      &G4Polycone::GetEndPhi)
    .def("IsOpen",         &G4Polycone::IsOpen)
    .def("GetNumRZCorner", &G4Polycone::GetNumRZCorner)

    // operators
    .def(self_ns::str(self))
    ;

  // Create solid
  def("CreatePolycone", f1_CreatePolycone,
      return_value_policy<manage_new_object>());
  def("CreatePolycone", f2_CreatePolycone,
      return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Polyhedra

(

)

Definition at line 92 of file pyG4Polyhedra.cc.

{
  class_<G4Polyhedra, G4Polyhedra*, bases<G4VSolid> >
    ("G4Polyhedra", "Polyhedra solid class", no_init)
    // ---
    .def("GetStartPhi",    &G4Polyhedra::GetStartPhi)
    .def("GetEndPhi",      &G4Polyhedra::GetEndPhi)
    .def("GetNumSide",     &G4Polyhedra::GetNumSide)
    .def("GetNumRZCorner", &G4Polyhedra::GetNumRZCorner)
    .def("IsOpen",         &G4Polyhedra::IsOpen)
    .def("IsGeneric",      &G4Polyhedra::IsGeneric)

    // operators
    .def(self_ns::str(self))
    ;

  // Create solid
  def("CreatePolyhedra", f1_CreatePolyhedra,
      return_value_policy<manage_new_object>());
  def("CreatePolyhedra", f2_CreatePolyhedra,
      return_value_policy<manage_new_object>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4PVPlacement

(

)

Definition at line 54 of file pyG4PVPlacement.cc.

{
  class_<G4PVPlacement, G4PVPlacement*, bases<G4VPhysicalVolume>,
    boost::noncopyable >
    ("G4PVPlacement", "physical volume placement", no_init)
    // ---
    .def(init<G4RotationMatrix*, const G4ThreeVector&,
     G4LogicalVolume*, const G4String&,
     G4LogicalVolume*, G4bool, G4int>())
    .def(init<const G4Transform3D&, G4LogicalVolume*,
     const G4String&, G4LogicalVolume*, G4bool, G4int>())
    .def(init<G4RotationMatrix*, const G4ThreeVector&,
     const G4String, G4LogicalVolume*,
     G4VPhysicalVolume*, G4bool, G4int>())
    .def(init<const G4Transform3D&, const G4String&,
     G4LogicalVolume*, G4VPhysicalVolume*, G4bool, G4int>())
#if G4VERSION_NUMBER >=800
    .def(init<G4RotationMatrix*, const G4ThreeVector&,
     G4LogicalVolume*, const G4String&,
     G4LogicalVolume*, G4bool, G4int, G4bool>())
    .def(init<const G4Transform3D&, G4LogicalVolume*,
     const G4String&, G4LogicalVolume*, G4bool, G4int, G4bool>())
    .def(init<G4RotationMatrix*, const G4ThreeVector&,
     const G4String, G4LogicalVolume*,
     G4VPhysicalVolume*, G4bool, G4int, G4bool>())
    .def(init<const G4Transform3D&, const G4String&,
     G4LogicalVolume*, G4VPhysicalVolume*, G4bool, G4int, G4bool>())
#endif
    // ---
#if G4VERSION_NUMBER >=800
    .def("CheckOverlaps", &G4PVPlacement::CheckOverlaps, f_CheckOverlaps())
#endif
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4PVReplica

(

)

Definition at line 41 of file pyG4PVReplica.cc.

{
  class_<G4PVReplica, G4PVReplica*, bases<G4VPhysicalVolume>,
    boost::noncopyable >
    ("G4PVReplica", "physical volume placement with replication", no_init)
    // constructors
    .def(init<const G4String&, G4LogicalVolume*, G4LogicalVolume*,   
     const EAxis, const G4int, const G4double>())
    .def(init<const G4String&, G4LogicalVolume*, G4LogicalVolume*,   
     const EAxis, const G4int, const G4double, const G4double>())
    .def(init<const G4String&, G4LogicalVolume*, G4VPhysicalVolume*,
     const EAxis, const G4int, const G4double>())
    .def(init<const G4String&, G4LogicalVolume*, G4VPhysicalVolume*,
     const EAxis, const G4int, const G4double, const G4double>())
    // ---
    .def("GetMultiplicity",  &G4PVReplica::GetMultiplicity)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Region

(

)

Definition at line 47 of file pyG4Region.cc.

{
  class_<G4Region, G4Region*, boost::noncopyable>
    ("G4Region", "region class", no_init)
    // constructors
    .def(init<const G4String&>())
    // ---
    .def("AddRootLogicalVolume",    &G4Region::AddRootLogicalVolume)
    .def("RemoveRootLogicalVolume", &G4Region::RemoveRootLogicalVolume)
    .def("SetName",                 &G4Region::SetName)
    .def("GetName",                 &G4Region::GetName,
     return_value_policy<return_by_value>())
    .def("RegionModified",          &G4Region::RegionModified)
    .def("IsModified",              &G4Region::IsModified)
    .def("SetProductionCuts",       &G4Region::SetProductionCuts)
    .def("GetProductionCuts",       &G4Region::GetProductionCuts,
         return_internal_reference<>())
    .def("GetNumberOfMaterials",    &G4Region::GetNumberOfMaterials)
    .def("GetNumberOfRootVolumes",  &G4Region::GetNumberOfRootVolumes)
    .def("UpdateMaterialList",      &G4Region::UpdateMaterialList)
    .def("ClearMaterialList",       &G4Region::ClearMaterialList)
    .def("ScanVolumeTree",          &G4Region::ScanVolumeTree)
    .def("SetUserInformation",      &G4Region::SetUserInformation)
    .def("GetUserInformation",      &G4Region::GetUserInformation,
         return_internal_reference<>())
#if G4VERSION_NUMBER >= 710
    .def("SetUserLimits",           &G4Region::SetUserLimits)
    .def("GetUserLimits",           &G4Region::GetUserLimits,
         return_internal_reference<>())
#endif
    .def("ClearMap",                &G4Region::ClearMap)
    .def("RegisterMaterialCouplePair", &G4Region::RegisterMaterialCouplePair)
    .def("FindCouple",              &G4Region::FindCouple,
         return_value_policy<reference_existing_object>())   
#if G4VERSION_NUMBER >= 800
    .def("SetFastSimulationManager", &G4Region::SetFastSimulationManager)
    .def("GetFastSimulationManager", &G4Region::GetFastSimulationManager,
         return_internal_reference<>())
    .def("ClearFastSimulationManager", &G4Region::ClearFastSimulationManager)
    .def("GetWorldPhysical",        &G4Region::GetWorldPhysical,
         return_internal_reference<>())
    .def("SetWorld",                &G4Region::SetWorld)
    .def("BelongsTo",               &G4Region::BelongsTo)
    .def("GetParentRegion",         &G4Region::GetParentRegion,
         return_value_policy<reference_existing_object>())
#endif
    ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Sphere

(

)

Definition at line 57 of file pyG4Sphere.cc.

{
  class_<G4Sphere, G4Sphere*, bases<G4VSolid> >
    ("G4Sphere", "Sphere solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
         G4double, G4double, G4double>())
    // ---
    .def("GetInsideRadius",     &G4Sphere::GetInsideRadius)
    .def("GetOuterRadius",      &G4Sphere::GetOuterRadius)
    .def("GetStartPhiAngle",    &G4Sphere::GetStartPhiAngle)
    .def("GetDeltaPhiAngle",    &G4Sphere::GetDeltaPhiAngle)
    .def("GetStartThetaAngle",  &G4Sphere::GetStartThetaAngle)
    .def("GetDeltaThetaAngle",  &G4Sphere::GetDeltaThetaAngle)
    .def("SetInsideRadius",     &G4Sphere::SetInsideRadius)
    .def("SetOuterRadius",      &G4Sphere::SetOuterRadius)
    .def("SetStartPhiAngle",    &G4Sphere::SetStartPhiAngle)
    .def("SetDeltaPhiAngle",    &G4Sphere::SetDeltaPhiAngle)
    .def("SetStartThetaAngle",  &G4Sphere::SetStartThetaAngle)
    .def("SetDeltaThetaAngle",  &G4Sphere::SetDeltaThetaAngle)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateSphere", CreateSphere, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4SubtractionSolid

(

)

Definition at line 40 of file pyG4SubtractionSolid.cc.

{
  class_<G4SubtractionSolid, G4SubtractionSolid*,
    bases<G4BooleanSolid>,boost::noncopyable>
    ("G4SubtractionSolid", "subtraction solid class", no_init)
    // ---
    .def(init<const G4String&, G4VSolid*, G4VSolid*>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         G4RotationMatrix*, const G4ThreeVector&>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         const G4Transform3D&>())   
    ;

}

Here is the caller graph for this function:

void export_G4Tet

(

)

Definition at line 55 of file pyG4Tet.cc.

{
  class_<G4Tet, G4Tet*, bases<G4VSolid> >
    ("G4Tet", "tetrahedra solid class", no_init)
    // constructors
    .def(init<const G4String&, G4ThreeVector, G4ThreeVector, G4ThreeVector,
                               G4ThreeVector>())
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTet", CreateTet, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Torus

(

)

Definition at line 55 of file pyG4Torus.cc.

{
  class_<G4Torus, G4Torus*, bases<G4VSolid> >
    ("G4Torus", "Torus solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
         G4double, G4double>())
    // ---
    .def("GetRmin", &G4Torus::GetRmin)
    .def("GetRmax", &G4Torus::GetRmax)
    .def("GetRtor", &G4Torus::GetRtor)
    .def("GetSPhi", &G4Torus::GetSPhi)
    .def("GetDPhi", &G4Torus::GetDPhi)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTorus", CreateTorus, return_value_policy<manage_new_object>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4TouchableHistory

(

)

Definition at line 40 of file pyG4TouchableHistory.cc.

{
  class_<G4TouchableHistory, G4TouchableHistory*, bases<G4VTouchable> >
    ("G4TouchableHistory", "touchable history class")
    ;
}

Here is the caller graph for this function:

void export_G4TransportationManager

(

)

Definition at line 42 of file pyG4TransportationManager.cc.

{
  class_<G4TransportationManager, boost::noncopyable>
    ("G4TransportationManager", "manager class for transportation", no_init)
    // ---
    .def("GetTransportationManager", 
     &G4TransportationManager::GetTransportationManager,
     return_value_policy<reference_existing_object>())
    .staticmethod("GetTransportationManager")
    .def("GetNavigatorForTracking", 
     &G4TransportationManager::GetNavigatorForTracking,
     return_internal_reference<>())
    .def("GetPropagatorInField", 
     &G4TransportationManager::GetPropagatorInField,
     return_internal_reference<>())
    .def("GetFieldManager", 
     &G4TransportationManager::GetFieldManager,
     return_internal_reference<>())
    .def("SetNavigatorForTracking", 
     &G4TransportationManager::SetNavigatorForTracking)
    .def("SetPropagatorInField", 
     &G4TransportationManager::SetPropagatorInField)
    .def("SetFieldManager", 
     &G4TransportationManager::SetFieldManager)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Trap

(

)

Definition at line 102 of file pyG4Trap.cc.

{
  class_<G4Trap, G4Trap*, bases<G4VSolid> >
    ("G4Trap", "Generic trapezoild soild class", no_init)
    // constructors
    .def(init<const G4String&>())
    .def(init<const G4String&, G4double, G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
     G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
     G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
     G4double, G4double, G4double, G4double, G4double,
     G4double, G4double, G4double>())
    // ---
    .def("GetZHalfLength",   &G4Trap::GetZHalfLength)
    .def("GetYHalfLength1",  &G4Trap::GetYHalfLength1)
    .def("GetXHalfLength1",  &G4Trap::GetXHalfLength1)
    .def("GetXHalfLength2",  &G4Trap::GetXHalfLength2)
    .def("GetTanAlpha1",     &G4Trap::GetTanAlpha1)
    .def("GetYHalfLength2",  &G4Trap::GetYHalfLength2)
    .def("GetXHalfLength3",  &G4Trap::GetXHalfLength3)
    .def("GetXHalfLength4",  &G4Trap::GetXHalfLength4)
    .def("GetTanAlpha2",     &G4Trap::GetTanAlpha2)
    .def("GetSidePlane",     &G4Trap::GetSidePlane)
    .def("GetSymAxis",       &G4Trap::GetSymAxis)
    .def("SetAllParameters", &G4Trap::SetAllParameters)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTrap", f1_CreateTrap, return_value_policy<manage_new_object>());
    def("CreateTrap", f2_CreateTrap, return_value_policy<manage_new_object>());
    def("CreateTrap", f3_CreateTrap, return_value_policy<manage_new_object>());
    def("CreateTrap", f4_CreateTrap, return_value_policy<manage_new_object>());
    def("CreateTrap", f5_CreateTrap, return_value_policy<manage_new_object>());
    def("CreateTrap", f6_CreateTrap, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Trd

(

)

Definition at line 55 of file pyG4Trd.cc.

{
  class_<G4Trd, G4Trd*, bases<G4VSolid> >
    ("G4Trd", "Trapezoild solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
     G4double, G4double>())
    // ---
    .def("GetXHalfLength1", &G4Trd::GetXHalfLength1)
    .def("GetXHalfLength2", &G4Trd::GetXHalfLength2)
    .def("GetYHalfLength1", &G4Trd::GetYHalfLength1)
    .def("GetYHalfLength2", &G4Trd::GetYHalfLength2)
    .def("GetZHalfLength",  &G4Trd::GetZHalfLength)
    .def("SetXHalfLength1", &G4Trd::SetXHalfLength1)
    .def("SetXHalfLength2", &G4Trd::SetXHalfLength2)
    .def("SetYHalfLength1", &G4Trd::SetYHalfLength1)
    .def("SetYHalfLength2", &G4Trd::SetYHalfLength2)
    .def("SetZHalfLength",  &G4Trd::SetZHalfLength)
    // operators
    .def(self_ns::str(self))
    ;
  
    // Create solid
    def("CreateTrd", CreateTrd, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4Tubs

(

)

Definition at line 55 of file pyG4Tubs.cc.

{
  class_<G4Tubs, G4Tubs*, bases<G4VSolid> >
    ("G4Tubs", "Tube solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
     G4double, G4double>())
    // ---
    .def("GetInnerRadius",   &G4Tubs::GetInnerRadius)
    .def("GetOuterRadius",   &G4Tubs::GetOuterRadius)
    .def("GetZHalfLength",   &G4Tubs::GetZHalfLength)
    .def("GetStartPhiAngle", &G4Tubs::GetStartPhiAngle)
    .def("GetDeltaPhiAngle", &G4Tubs::GetDeltaPhiAngle)
    .def("SetInnerRadius",   &G4Tubs::SetInnerRadius)
    .def("SetOuterRadius",   &G4Tubs::SetOuterRadius)
    .def("SetZHalfLength",   &G4Tubs::SetZHalfLength)
    .def("SetStartPhiAngle", &G4Tubs::SetStartPhiAngle)
    .def("SetDeltaPhiAngle", &G4Tubs::SetDeltaPhiAngle)
    .def("GetRMin",          &G4Tubs::GetRMin)
    .def("GetRMax",          &G4Tubs::GetRMax)
    .def("GetDz",            &G4Tubs::GetDz)
    .def("GetSPhi",          &G4Tubs::GetSPhi)
    .def("GetDPhi",          &G4Tubs::GetDPhi)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTubs", CreateTubs, return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4TwistedBox

(

)

Definition at line 58 of file pyG4TwistedBox.cc.

{
  class_<G4TwistedBox, G4TwistedBox*, bases<G4VSolid> >
    ("G4TwistedBox", "twisted box solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double, G4double>())
    // ---
    .def("GetXHalfLength",   &G4TwistedBox::GetXHalfLength)
    .def("GetYHalfLength",   &G4TwistedBox::GetYHalfLength)
    .def("GetZHalfLength",   &G4TwistedBox::GetZHalfLength)
    .def("GetPhiTwist",      &G4TwistedBox::GetPhiTwist)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTwistedBox", CreateTwistedBox, 
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4TwistedTrap

(

)

Definition at line 70 of file pyG4TwistedTrap.cc.

{
  class_<G4TwistedTrap, G4TwistedTrap*, bases<G4VSolid> >
    ("G4TwistedTrap", "twisted trapezoid solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
                               G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double,
                               G4double, G4double, G4double,
                               G4double, G4double, G4double,
                               G4double, G4double>())
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTwistedTap", f1_CreateTwistedTrap,
        return_value_policy<manage_new_object>());
    def("CreateTwistedTap", f2_CreateTwistedTrap,
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4TwistedTrd

(

)

Definition at line 57 of file pyG4TwistedTrd.cc.

{
  class_<G4TwistedTrd, G4TwistedTrd*, bases<G4VSolid> >
    ("G4TwistedTrd", "twisted trapezoid solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double,
                    G4double, G4double, G4double>())
    // ---
    .def("GetX1HalfLength",    &G4TwistedTrd::GetX1HalfLength)
    .def("GetX2HalfLength",    &G4TwistedTrd::GetX2HalfLength)
    .def("GetY1HalfLength",    &G4TwistedTrd::GetY1HalfLength)
    .def("GetY2HalfLength",    &G4TwistedTrd::GetY2HalfLength)
    .def("GetZHalfLength",     &G4TwistedTrd::GetZHalfLength)
    .def("GetPhiTwist",        &G4TwistedTrd::GetPhiTwist)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTwistedTrd", CreateTwistedTrd,
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4TwistedTubs

(

)

Definition at line 113 of file pyG4TwistedTubs.cc.

{
  class_<G4TwistedTubs, G4TwistedTubs*, bases<G4VSolid> >
    ("G4TwistedTubs", "twisted tube solid class", no_init)
    // constructors
    .def(init<const G4String&, G4double, G4double, G4double, 
                               G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
                               G4double, G4int, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
                               G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
                               G4double, G4double, G4int, G4double>())
    // ---
    .def("GetDPhi",            &G4TwistedTubs::GetDPhi)
    .def("GetPhiTwist",        &G4TwistedTubs::GetPhiTwist)
    .def("GetInnerRadius",     &G4TwistedTubs::GetInnerRadius)
    .def("GetOuterRadius",     &G4TwistedTubs::GetOuterRadius)
    .def("GetInnerStereo",     &G4TwistedTubs::GetInnerStereo)
    .def("GetOuterStereo",     &G4TwistedTubs::GetOuterStereo)
    .def("GetZHalfLength",     &G4TwistedTubs::GetZHalfLength)
    .def("GetKappa",           &G4TwistedTubs::GetKappa)
    .def("GetTanInnerStereo",  &G4TwistedTubs::GetTanInnerStereo)
    .def("GetTanInnerStereo2", &G4TwistedTubs::GetTanInnerStereo2)
    .def("GetTanOuterStereo",  &G4TwistedTubs::GetTanOuterStereo)
    .def("GetTanOuterStereo2", &G4TwistedTubs::GetTanOuterStereo2)
    .def("GetEndZ",            &G4TwistedTubs::GetEndZ)
    .def("GetEndPhi",          &G4TwistedTubs::GetEndPhi)
    .def("GetEndInnerRadius",  f1_GetEndInnerRadius)
    .def("GetEndInnerRadius",  f2_GetEndInnerRadius)
    .def("GetEndOuterRadius",  f1_GetEndOuterRadius)
    .def("GetEndOuterRadius",  f2_GetEndOuterRadius)
    // operators
    .def(self_ns::str(self))
    ;

    // Create solid
    def("CreateTwistedTubs", f1_CreateTwistedTubs,
        return_value_policy<manage_new_object>());
    def("CreateTwistedTubs", f2_CreateTwistedTubs,
        return_value_policy<manage_new_object>());
    def("CreateTwistedTubs", f3_CreateTwistedTubs,
        return_value_policy<manage_new_object>());
    def("CreateTwistedTubs", f4_CreateTwistedTubs,
        return_value_policy<manage_new_object>());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4UniformMagField

(

)

Definition at line 40 of file pyG4UniformMagField.cc.

{
  class_<G4UniformMagField, G4UniformMagField*, 
    bases<G4Field, G4MagneticField> >
    ("G4UniformMagField", "uniform magnetic field", no_init)
    // constructors
    .def(init<const G4ThreeVector&>())
    .def(init<const G4double, G4double, G4double>())
    // ---
    .def("SetFieldValue",         &G4UniformMagField::SetFieldValue)
    .def("GetConstantFieldValue", &G4UniformMagField::GetConstantFieldValue)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4UnionSolid

(

)

Definition at line 40 of file pyG4UnionSolid.cc.

{
  class_<G4UnionSolid, G4UnionSolid*,
    bases<G4BooleanSolid>,boost::noncopyable>
    ("G4UnionSolid", "union solid class", no_init)
    // ---
    .def(init<const G4String&, G4VSolid*, G4VSolid*>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         G4RotationMatrix*, const G4ThreeVector&>())
    .def(init<const G4String&, G4VSolid*, G4VSolid*,
         const G4Transform3D&>())   
    ;

}

Here is the caller graph for this function:

void export_G4VPhysicalVolume

(

)

Definition at line 58 of file pyG4VPhysicalVolume.cc.

{
  class_<G4VPhysicalVolume, G4VPhysicalVolume*, boost::noncopyable>
    ("G4VPhysicalVolume", "physical volume class", no_init)
    // ---
    .def("SetTranslation",       &G4VPhysicalVolume::SetTranslation)
    .def("GetTranslation",       &G4VPhysicalVolume::GetTranslation,
     return_internal_reference<>())
    .def("GetObjectTranslation", &G4VPhysicalVolume::GetObjectTranslation)
    .def("GetFrameTranslation",  &G4VPhysicalVolume::GetObjectTranslation)
    // ---
    .def("SetRotation",          &G4VPhysicalVolume::SetRotation)
    .def("GetRotation",          f1_GetRotation,
      return_internal_reference<>())
    .def("GetRotation",          f2_GetRotation,
      return_internal_reference<>())
    .def("GetObjectRotationValue", &G4VPhysicalVolume::GetObjectRotationValue)
    .def("GetFrameRotation",       &G4VPhysicalVolume::GetFrameRotation,
     return_internal_reference<>())
    // ---
    .def("SetLogicalVolume",     &G4VPhysicalVolume::SetLogicalVolume)
    .def("SetMotherLogical",     &G4VPhysicalVolume::SetMotherLogical)
    .def("GetLogicalVolume",     &G4VPhysicalVolume::GetLogicalVolume,
     return_internal_reference<>())
    .def("GetMotherLogical",     &G4VPhysicalVolume::GetMotherLogical,
     return_internal_reference<>())
    // ---
    .def("SetName",             &G4VPhysicalVolume::SetName)
#if G4VERSION_NUMBER <= 801
    .def("GetName",             &G4VPhysicalVolume::GetName)
#else
    .def("GetName",             &G4VPhysicalVolume::GetName,
         return_value_policy<return_by_value>())
#endif
    .def("SetCopyNo",           &G4VPhysicalVolume::SetCopyNo)
    .def("GetCopyNo",           &G4VPhysicalVolume::GetCopyNo)
    // ---
    .def("IsMany",              &G4VPhysicalVolume::IsMany)
    .def("IsReplicated",        &G4VPhysicalVolume::IsReplicated)
    .def("IsParameterised",     &G4VPhysicalVolume::IsParameterised)
    .def("GetMultiplicity",     &G4VPhysicalVolume::GetMultiplicity)
    .def("GetParameterisation", &G4VPhysicalVolume::GetParameterisation,
     return_value_policy<reference_existing_object>())
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4VSolid

(

)

Definition at line 41 of file pyG4VSolid.cc.

{
  class_<G4VSolid, G4VSolid*, boost::noncopyable> 
    ("G4VSolid", "solid class", no_init)
    // ---
    .def("GetName",        &G4VSolid::GetName)
    .def("SetName",        &G4VSolid::SetName)
    .def("DumpInfo",       &G4VSolid::DumpInfo)

    .def("GetCubicVolume",    &G4VSolid::GetCubicVolume)
#if G4VERSION_NUMBER >=820
    .def("GetSurfaceArea",    &G4VSolid::GetSurfaceArea)
#endif
#if G4VERSION_NUMBER >=800
    .def("GetPointOnSurface", &G4VSolid::GetPointOnSurface)
#endif
    // operators
    .def(self == self)
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void export_G4VTouchable

(

)

Definition at line 66 of file pyG4VTouchable.cc.

{
  class_<G4VTouchable, G4VTouchable*, boost::noncopyable>
    ("G4VTouchable", "touchable class", no_init)
    .def("GetTranslation", &G4VTouchable::GetTranslation,
     f_GetTranslation()
     [return_value_policy<return_by_value>()])
    .def("GetRotation", &G4VTouchable::GetRotation,
     f_GetRotation()
     [return_value_policy<reference_existing_object>()])
    .def("GetVolume", &G4VTouchable::GetVolume,
     f_GetVolume()
     [return_value_policy<reference_existing_object>()])
    .def("GetSolid", &G4VTouchable::GetSolid,
     f_GetSolid()
     [return_value_policy<reference_existing_object>()])
    .def("GetReplicaNumber", &G4VTouchable::GetReplicaNumber,
     f_GetReplicaNumber())
    .def("GetHistoryDepth",  &G4VTouchable::GetHistoryDepth)
    .def("MoveUpHistory", &G4VTouchable::MoveUpHistory,
     f_MoveUpHistory())
    ;
}

Here is the call graph for this function:

Here is the caller graph for this function: