LArSoft  v07_13_02
Liquid Argon Software toolkit - http://larsoft.org/
Functions
pymodG4geometry.cc File Reference
#include <boost/python.hpp>

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.

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

81 {
82  export_G4GeometryManager();
83  export_G4VTouchable();
84  export_G4TouchableHistory();
85  export_G4VPhysicalVolume();
86  export_G4PVPlacement();
87  export_G4PVReplica();
88  export_G4LogicalVolume();
89  export_G4Region();
90  export_G4VSolid();
91  export_G4Box();
92  export_G4Cons();
93  export_G4Para();
94  export_G4Torus();
95  export_G4Trd();
96  export_G4Orb();
97  export_G4Sphere();
98  export_G4Trap();
99  export_G4Tubs();
100  export_G4Polycone();
101  export_G4Polyhedra();
102  export_G4EllipticalTube();
103  export_G4Ellipsoid();
104  export_G4EllipticalCone();
105  export_G4Hype();
106  export_G4Tet();
107  export_G4TwistedBox();
108  export_G4TwistedTrap();
109  export_G4TwistedTrd();
110  export_G4TwistedTubs();
111  export_G4BooleanSolid();
112  export_G4UnionSolid();
113  export_G4IntersectionSolid();
114  export_G4SubtractionSolid();
115  export_G4TransportationManager();
116  export_G4Navigator();
117  export_G4FieldManager();
118  export_G4Field();
119  export_G4MagneticField();
120  export_G4UniformMagField();
121  export_G4ChordFinder();
122 }
export_G4Polycone
void export_G4Polycone()
Definition: pyG4Polycone.cc:91
export_G4ChordFinder
void export_G4ChordFinder()
Definition: pyG4ChordFinder.cc:52
export_G4Navigator
void export_G4Navigator()
Definition: pyG4Navigator.cc:42
export_G4SubtractionSolid
void export_G4SubtractionSolid()
Definition: pyG4SubtractionSolid.cc:40
export_G4TouchableHistory
void export_G4TouchableHistory()
Definition: pyG4TouchableHistory.cc:40
export_G4TransportationManager
void export_G4TransportationManager()
Definition: pyG4TransportationManager.cc:42
export_G4BooleanSolid
void export_G4BooleanSolid()
Definition: pyG4BooleanSolid.cc:40
export_G4EllipticalCone
void export_G4EllipticalCone()
Definition: pyG4EllipticalCone.cc:58
export_G4Ellipsoid
void export_G4Ellipsoid()
Definition: pyG4Ellipsoid.cc:62
export_G4MagneticField
void export_G4MagneticField()
Definition: pyG4MagneticField.cc:89
export_G4Box
void export_G4Box()
Definition: pyG4Box.cc:55
export_G4Polyhedra
void export_G4Polyhedra()
Definition: pyG4Polyhedra.cc:92
export_G4FieldManager
void export_G4FieldManager()
Definition: pyG4FieldManager.cc:70
export_G4Para
void export_G4Para()
Definition: pyG4Para.cc:56
export_G4PVReplica
void export_G4PVReplica()
Definition: pyG4PVReplica.cc:41
export_G4VTouchable
void export_G4VTouchable()
Definition: pyG4VTouchable.cc:66
export_G4Region
void export_G4Region()
Definition: pyG4Region.cc:47
export_G4Trap
void export_G4Trap()
Definition: pyG4Trap.cc:102
export_G4UnionSolid
void export_G4UnionSolid()
Definition: pyG4UnionSolid.cc:40
export_G4LogicalVolume
void export_G4LogicalVolume()
Definition: pyG4LogicalVolume.cc:72
export_G4VSolid
void export_G4VSolid()
Definition: pyG4VSolid.cc:41
export_G4Orb
void export_G4Orb()
Definition: pyG4Orb.cc:54
export_G4Sphere
void export_G4Sphere()
Definition: pyG4Sphere.cc:57
export_G4TwistedTrap
void export_G4TwistedTrap()
Definition: pyG4TwistedTrap.cc:70
export_G4IntersectionSolid
void export_G4IntersectionSolid()
Definition: pyG4IntersctionSolid.cc:40
export_G4TwistedBox
void export_G4TwistedBox()
Definition: pyG4TwistedBox.cc:58
export_G4TwistedTubs
void export_G4TwistedTubs()
Definition: pyG4TwistedTubs.cc:113
export_G4Trd
void export_G4Trd()
Definition: pyG4Trd.cc:55
export_G4UniformMagField
void export_G4UniformMagField()
Definition: pyG4UniformMagField.cc:40
export_G4Tubs
void export_G4Tubs()
Definition: pyG4Tubs.cc:55
export_G4Hype
void export_G4Hype()
Definition: pyG4Hype.cc:62
export_G4EllipticalTube
void export_G4EllipticalTube()
Definition: pyG4EllipticalTube.cc:57
export_G4Tet
void export_G4Tet()
Definition: pyG4Tet.cc:55
export_G4GeometryManager
void export_G4GeometryManager()
Definition: pyG4GeometryManager.cc:53
export_G4Cons
void export_G4Cons()
Definition: pyG4Cons.cc:56
export_G4Field
void export_G4Field()
Definition: pyG4Field.cc:40
export_G4VPhysicalVolume
void export_G4VPhysicalVolume()
Definition: pyG4VPhysicalVolume.cc:58
export_G4TwistedTrd
void export_G4TwistedTrd()
Definition: pyG4TwistedTrd.cc:57
export_G4Torus
void export_G4Torus()
Definition: pyG4Torus.cc:55
export_G4PVPlacement
void export_G4PVPlacement()
Definition: pyG4PVPlacement.cc:54
void export_G4BooleanSolid ( )

Definition at line 40 of file pyG4BooleanSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4BooleanSolid, G4BooleanSolid*, bases<G4VSolid>, boost::noncopyable>
43  ("G4BooleanSolid", "boolean solid class", no_init)
44  // ---
45  .def("GetCubVolStatistics", &G4BooleanSolid::GetCubVolStatistics)
46  .def("GetCubVolEpsilon", &G4BooleanSolid::GetCubVolEpsilon)
47  .def("SetCubVolStatistics", &G4BooleanSolid::SetCubVolStatistics)
48  .def("SetCubVolEpsilon", &G4BooleanSolid::SetCubVolEpsilon)
49  .def("GetAreaStatistics", &G4BooleanSolid::GetAreaStatistics)
50  .def("GetAreaAccuracy", &G4BooleanSolid::GetAreaAccuracy)
51  .def("SetAreaStatistics", &G4BooleanSolid::SetAreaStatistics)
52  .def("SetAreaAccuracy", &G4BooleanSolid::SetAreaAccuracy)
53  .def("GetPointOnSurface", &G4BooleanSolid::GetPointOnSurface)
54  ;
55 
56 }
void export_G4Box ( )

Definition at line 55 of file pyG4Box.cc.

References pyG4Box::CreateBox().

Referenced by BOOST_PYTHON_MODULE().

56 {
57  class_<G4Box, G4Box*, bases<G4VSolid> >
58  ("G4Box", "box solid class", no_init)
59  // constructors
60  .def(init<const G4String&, G4double, G4double, G4double>())
61  // ---
62  .def("GetXHalfLength", &G4Box::GetXHalfLength)
63  .def("GetYHalfLength", &G4Box::GetYHalfLength)
64  .def("GetZHalfLength", &G4Box::GetZHalfLength)
65  .def("SetXHalfLength", &G4Box::SetXHalfLength)
66  .def("SetYHalfLength", &G4Box::SetYHalfLength)
67  .def("SetZHalfLength", &G4Box::SetZHalfLength)
68  // operators
69  .def(self_ns::str(self))
70  ;
71 
72  // Create solid
73  def("CreateBox", CreateBox, return_value_policy<manage_new_object>());
74 
75 }
pyG4Box::CreateBox
G4Box * CreateBox(const G4String &name, G4double pX, G4double pY, G4double pZ)
Definition: pyG4Box.cc:42
void export_G4ChordFinder ( )

Definition at line 52 of file pyG4ChordFinder.cc.

Referenced by BOOST_PYTHON_MODULE().

53 {
54  class_<G4ChordFinder, G4ChordFinder*, boost::noncopyable>
55  ("G4ChordFinder", "chord finder class", no_init)
56  // constructor
57  .def(init<G4MagInt_Driver*>())
58  .def(init<G4MagneticField*>())
59  .def(init<G4MagneticField*, G4double>())
60  .def(init<G4MagneticField*, G4double, G4MagIntegratorStepper*>())
61  // ---
62  .def("GetDeltaChord", &G4ChordFinder::GetDeltaChord)
63  .def("SetDeltaChord", &G4ChordFinder::SetDeltaChord)
64  // ---
65  .def("PrintStatistics", &G4ChordFinder::PrintStatistics)
66  .def("SetVerbose", &G4ChordFinder::SetVerbose, f_SetVerbose())
67  ;
68 }
void export_G4Cons ( )

Definition at line 56 of file pyG4Cons.cc.

References pyG4Cons::CreateCons().

Referenced by BOOST_PYTHON_MODULE().

57 {
58  class_<G4Cons, G4Cons*, bases<G4VSolid> >
59  ("G4Cons", "Cone solid class", no_init)
60  // constructors
61  .def(init<const G4String&, G4double, G4double, G4double,
62  G4double, G4double, G4double, G4double>())
63  // ---
64  .def("GetInnerRadiusMinusZ", &G4Cons::GetInnerRadiusMinusZ)
65  .def("GetOuterRadiusMinusZ", &G4Cons::GetOuterRadiusMinusZ)
66  .def("GetInnerRadiusPlusZ", &G4Cons::GetInnerRadiusPlusZ)
67  .def("GetOuterRadiusPlusZ", &G4Cons::GetOuterRadiusPlusZ)
68  .def("GetZHalfLength", &G4Cons::GetZHalfLength)
69  .def("GetStartPhiAngle", &G4Cons::GetStartPhiAngle)
70  .def("GetDeltaPhiAngle", &G4Cons::GetDeltaPhiAngle)
71  .def("SetInnerRadiusMinusZ", &G4Cons::SetInnerRadiusMinusZ)
72  .def("SetOuterRadiusMinusZ", &G4Cons::SetOuterRadiusMinusZ)
73  .def("SetInnerRadiusPlusZ", &G4Cons::SetInnerRadiusPlusZ)
74  .def("SetOuterRadiusPlusZ", &G4Cons::SetOuterRadiusPlusZ)
75  .def("SetZHalfLength", &G4Cons::SetZHalfLength)
76  .def("SetStartPhiAngle", &G4Cons::SetStartPhiAngle)
77  .def("SetDeltaPhiAngle", &G4Cons::SetDeltaPhiAngle)
78  // operators
79  .def(self_ns::str(self))
80  ;
81 
82  // Create solid
83  def("CreateCons", CreateCons, return_value_policy<manage_new_object>());
84 
85 }
pyG4Cons::CreateCons
G4Cons * CreateCons(const G4String &name, G4double pRmin1, G4double pRmax1, G4double pRmin2, G4double pRmax2, G4double pDz, G4double pSPhi, G4double pDPhi)
Definition: pyG4Cons.cc:42
void export_G4Ellipsoid ( )

Definition at line 62 of file pyG4Ellipsoid.cc.

References pyG4Ellipsoid::CreateEllipsoid().

Referenced by BOOST_PYTHON_MODULE().

63 {
64  class_<G4Ellipsoid, G4Ellipsoid*, bases<G4VSolid> >
65  ("G4Ellipsoid", "ellipsoid class", no_init)
66  // constructors
67  .def(init<const G4String&, G4double, G4double, G4double>())
68  .def(init<const G4String&, G4double, G4double, G4double, G4double>())
69  .def(init<const G4String&, G4double, G4double, G4double, G4double,
70  G4double>())
71  // ---
72  .def("GetSemiAxisMax", &G4Ellipsoid::GetSemiAxisMax)
73  .def("GetZBottomCut", &G4Ellipsoid::GetZBottomCut)
74  .def("GetZTopCut", &G4Ellipsoid::GetZTopCut)
75  .def("SetSemiAxis", &G4Ellipsoid::SetSemiAxis)
76  .def("SetZCuts", &G4Ellipsoid::SetZCuts)
77  // operators
78  .def(self_ns::str(self))
79  ;
80 
81  // Create solid
82  def("CreateEllipsoid", CreateEllipsoid,
83  f_CreateEllipsoid()[return_value_policy<manage_new_object>()]);
84 }
pyG4Ellipsoid::CreateEllipsoid
G4Ellipsoid * CreateEllipsoid(const G4String &name, G4double pxSemiAxis, G4double pySemiAxis, G4double pzSemiAxis, G4double pzBottomCut=0, G4double pzTopCut=0)
Definition: pyG4Ellipsoid.cc:42
void export_G4EllipticalCone ( )

Definition at line 58 of file pyG4EllipticalCone.cc.

References pyG4EllipticalCone::CreateEllipticalCone().

Referenced by BOOST_PYTHON_MODULE().

59 {
60  class_<G4EllipticalCone, G4EllipticalCone*, bases<G4VSolid> >
61  ("G4EllipticalCone", "elliptical cone solid class", no_init)
62  // constructors
63  .def(init<const G4String&, G4double, G4double, G4double, G4double>())
64  // ---
65  .def("GetSimiAxisMax", &G4EllipticalCone::GetSemiAxisMax)
66  .def("GetZTopCut", &G4EllipticalCone::GetZTopCut)
67  .def("SetSemiAxis", &G4EllipticalCone::SetSemiAxis)
68  .def("SetZCut", &G4EllipticalCone::SetZCut)
69  // operators
70  .def(self_ns::str(self))
71  ;
72 
73  // Create solid
74  def("CreateEllipticalCone", CreateEllipticalCone,
75  return_value_policy<manage_new_object>());
76 
77 }
pyG4EllipticalCone::CreateEllipticalCone
G4EllipticalCone * CreateEllipticalCone(const G4String &name, G4double pxSemiAxis, G4double pySemiAxis, G4double zMax, G4double pzTopCut)
Definition: pyG4EllipticalCone.cc:42
void export_G4EllipticalTube ( )

Definition at line 57 of file pyG4EllipticalTube.cc.

References pyG4EllipticalTube::CreateEllipticalTube().

Referenced by BOOST_PYTHON_MODULE().

58 {
59  class_<G4EllipticalTube, G4EllipticalTube*, bases<G4VSolid> >
60  ("G4EllipticalTube", "elliptical tube solid class", no_init)
61  // constructors
62  .def(init<const G4String&, G4double, G4double, G4double>())
63  // ---
64  .def("GetDx", &G4EllipticalTube::GetDx)
65  .def("GetDy", &G4EllipticalTube::GetDy)
66  .def("GetDz", &G4EllipticalTube::GetDz)
67  .def("SetDx", &G4EllipticalTube::SetDx)
68  .def("SetDy", &G4EllipticalTube::SetDy)
69  .def("SetDz", &G4EllipticalTube::SetDz)
70 
71  // operators
72  .def(self_ns::str(self))
73  ;
74 
75  // Create solid
76  def("CreateEllipticalTube", CreateEllipticalTube,
77  return_value_policy<manage_new_object>());
78 
79 }
pyG4EllipticalTube::CreateEllipticalTube
G4EllipticalTube * CreateEllipticalTube(const G4String &name, G4double theDx, G4double theDy, G4double theDz)
Definition: pyG4EllipticalTube.cc:42
void export_G4Field ( )

Definition at line 40 of file pyG4Field.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4Field, G4Field*, boost::noncopyable>
43  ("G4Field", "base class of field", no_init)
44  ;
45 }
void export_G4FieldManager ( )

Definition at line 70 of file pyG4FieldManager.cc.

References pyG4FieldManager::f1_GetChordFinder, and pyG4FieldManager::f2_GetChordFinder.

Referenced by BOOST_PYTHON_MODULE().

71 {
72  class_<G4FieldManager, G4FieldManager*, boost::noncopyable>
73  ("G4FieldManager", "field manager class")
74  // constructors
75  .def(init<>())
76  .def(init<G4Field*>())
77  .def(init<G4Field*, G4ChordFinder*>())
78  .def(init<G4Field*, G4ChordFinder*, G4bool>())
79  .def(init<G4MagneticField*>())
80  // ---
81  .def("SetDetectorField", &G4FieldManager::SetDetectorField)
82  .def("GetDetectorField", &G4FieldManager::GetDetectorField,
83  return_internal_reference<>())
84  .def("DoesFieldExist", &G4FieldManager::DoesFieldExist)
85  .def("CreateChordFinder", &G4FieldManager::CreateChordFinder)
86  .def("SetChordFinder", &G4FieldManager::SetChordFinder)
87  .def("GetChordFinder", f1_GetChordFinder,
88  return_internal_reference<>())
89  .def("GetChordFinder", f2_GetChordFinder,
90  return_internal_reference<>())
91  .def("ConfigureForTrack", &G4FieldManager::ConfigureForTrack)
92  .def("GetDeltaIntersection", &G4FieldManager::GetDeltaIntersection)
93  .def("GetDeltaOneStep", &G4FieldManager::GetDeltaOneStep)
94  .def("SetAccuraciesWithDeltaOneStep",
95  &G4FieldManager::SetAccuraciesWithDeltaOneStep)
96  .def("SetDeltaOneStep", &G4FieldManager::SetDeltaOneStep)
97  .def("SetDeltaIntersection", &G4FieldManager::SetDeltaIntersection)
98  .def("GetMinimumEpsilonStep", &G4FieldManager::GetMinimumEpsilonStep)
99  .def("SetMinimumEpsilonStep", &G4FieldManager::SetMinimumEpsilonStep)
100  .def("GetMaximumEpsilonStep", &G4FieldManager::GetMaximumEpsilonStep)
101  .def("SetMaximumEpsilonStep", &G4FieldManager::SetMaximumEpsilonStep)
102  .def("DoesFieldChangeEnergy", &G4FieldManager::DoesFieldChangeEnergy)
103  .def("SetFieldChangesEnergy", &G4FieldManager::SetFieldChangesEnergy)
104  ;
105 }
pyG4FieldManager::f2_GetChordFinder
const G4ChordFinder *(G4FieldManager::* f2_GetChordFinder)() const
Definition: pyG4FieldManager.cc:60
pyG4FieldManager::f1_GetChordFinder
G4ChordFinder *(G4FieldManager::* f1_GetChordFinder)()
Definition: pyG4FieldManager.cc:58
void export_G4GeometryManager ( )

Definition at line 53 of file pyG4GeometryManager.cc.

Referenced by BOOST_PYTHON_MODULE().

54 {
55  class_<G4GeometryManager, boost::noncopyable>
56  ("G4GeometryManager", "geometry manager", no_init)
57  .def("GetInstance", &G4GeometryManager::GetInstance,
58  return_value_policy<reference_existing_object>())
59  .staticmethod("GetInstance")
60  // ---
61  .def("CloseGeometry", &G4GeometryManager::CloseGeometry,
62  f_CloseGeometry())
63  .def("OpenGeometry", &G4GeometryManager::OpenGeometry,
64  f_OpenGeometry())
65  .def("IsGeometryClosed", &G4GeometryManager::IsGeometryClosed)
66  .def("SetWorldMaximumExtent", &G4GeometryManager::SetWorldMaximumExtent)
67  ;
68 }
void export_G4Hype ( )

Definition at line 62 of file pyG4Hype.cc.

References pyG4Hype::CreateHype().

Referenced by BOOST_PYTHON_MODULE().

63 {
64  class_<G4Hype, G4Hype*, bases<G4VSolid> >
65  ("G4Hype", "hyperbolic solid class", no_init)
66  // constructors
67  .def(init<const G4String&, G4double, G4double, G4double,
68  G4double, G4double>())
69  // ---
70  .def("GetInnerRadius", &G4Hype::GetInnerRadius)
71  .def("GetOuterRadius", &G4Hype::GetOuterRadius)
72  .def("GetZHalfLength", &G4Hype::GetZHalfLength)
73  .def("GetInnerStereo", &G4Hype::GetInnerStereo)
74  .def("GetOuterStereo", &G4Hype::GetOuterStereo)
75  .def("SetInnerRadius", &G4Hype::SetInnerRadius)
76  .def("SetOuterRadius", &G4Hype::SetOuterRadius)
77  .def("SetZHalfLength", &G4Hype::SetZHalfLength)
78  .def("SetInnerStereo", &G4Hype::SetInnerStereo)
79  .def("SetOuterStereo", &G4Hype::SetOuterStereo)
80  // operators
81  .def(self_ns::str(self))
82  ;
83 
84  // Create solid
85  def("CreateHype", CreateHype, return_value_policy<manage_new_object>());
86 
87 }
pyG4Hype::CreateHype
G4Hype * CreateHype(const G4String &name, G4double newInnerRadius, G4double newOuterRadius, G4double newInnerStereo, G4double newOuterStereo, G4double newHalfLenZ)
Definition: pyG4Hype.cc:42
void export_G4IntersectionSolid ( )

Definition at line 40 of file pyG4IntersctionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4IntersectionSolid,G4IntersectionSolid*,
43  bases<G4BooleanSolid>,boost::noncopyable>
44  ("G4IntersectionSolid", "intersection solid class", no_init)
45  // ---
46  .def(init<const G4String&, G4VSolid*, G4VSolid*>())
47  .def(init<const G4String&, G4VSolid*, G4VSolid*,
48  G4RotationMatrix*, const G4ThreeVector&>())
49  .def(init<const G4String&, G4VSolid*, G4VSolid*,
50  const G4Transform3D&>())
51  ;
52 }
void export_G4LogicalVolume ( )

Definition at line 72 of file pyG4LogicalVolume.cc.

References pyG4LogicalVolume::f1_GetSolid, pyG4LogicalVolume::f1_SetSolid, pyG4LogicalVolume::f1_SetVisAttributes, and pyG4LogicalVolume::f2_SetVisAttributes.

Referenced by BOOST_PYTHON_MODULE().

73 {
74  class_<G4LogicalVolume, G4LogicalVolume*, boost::noncopyable>
75  ("G4LogicalVolume", "logical volume class", no_init)
76  // constructors
77  .def(init<G4VSolid*, G4Material*, const G4String& >())
78  .def(init<G4VSolid*, G4Material*, const G4String&,
79  G4FieldManager* >())
80  .def(init<G4VSolid*, G4Material*, const G4String&,
81  G4FieldManager*, G4VSensitiveDetector* >())
82  .def(init<G4VSolid*, G4Material*, const G4String&,
83  G4FieldManager*, G4VSensitiveDetector*,
84  G4UserLimits* >())
85  .def(init<G4VSolid*, G4Material*, const G4String&,
86  G4FieldManager*, G4VSensitiveDetector*,
87  G4UserLimits*, G4bool >())
88  // ---
89  .def("GetName", &G4LogicalVolume::GetName,
90  return_value_policy<reference_existing_object>())
91  .def("SetName", &G4LogicalVolume::SetName)
92  // ---
93  .def("GetNoDaughters", &G4LogicalVolume::GetNoDaughters)
94  .def("GetDaughter", &G4LogicalVolume::GetDaughter,
95  return_internal_reference<>())
96  .def("AddDaughter", &G4LogicalVolume::AddDaughter)
97  .def("IsDaughter", &G4LogicalVolume::IsDaughter)
98  .def("IsAncestor", &G4LogicalVolume::IsAncestor)
99  .def("RemoveDaughter", &G4LogicalVolume::RemoveDaughter)
100  .def("ClearDaughters", &G4LogicalVolume::ClearDaughters)
101  .def("TotalVolumeEntities", &G4LogicalVolume::TotalVolumeEntities)
102  // ----
103  .def("GetSolid", f1_GetSolid,
104  return_internal_reference<>())
105  .def("SetSolid", f1_SetSolid)
106  .def("GetMaterial", &G4LogicalVolume::GetMaterial,
107  return_internal_reference<>())
108  .def("SetMaterial", &G4LogicalVolume::SetMaterial)
109  .def("UpdateMaterial", &G4LogicalVolume::UpdateMaterial)
110  // ---
111  .def("GetMass", &G4LogicalVolume::GetMass, f_GetMass())
112  .def("GetFieldManager", &G4LogicalVolume::GetFieldManager,
113  return_internal_reference<>())
114  .def("SetFieldManager", &G4LogicalVolume::SetFieldManager)
115  .def("GetSensitiveDetector", &G4LogicalVolume::GetSensitiveDetector,
116  return_internal_reference<>())
117  .def("SetSensitiveDetector", &G4LogicalVolume::SetSensitiveDetector)
118  .def("GetUserLimits", &G4LogicalVolume::GetUserLimits,
119  return_internal_reference<>())
120  .def("SetUserLimits", &G4LogicalVolume::SetUserLimits)
121  // ---
122  .def("GetVoxelHeader", &G4LogicalVolume::GetVoxelHeader,
123  return_internal_reference<>())
124  .def("SetVoxelHeader", &G4LogicalVolume::SetVoxelHeader)
125  .def("GetSmartless", &G4LogicalVolume::GetSmartless)
126  .def("SetSmartless", &G4LogicalVolume::SetSmartless)
127  .def("IsToOptimise", &G4LogicalVolume::IsToOptimise)
128  .def("SetOptimisation", &G4LogicalVolume::SetOptimisation)
129  // ---
130  .def("IsRootRegion", &G4LogicalVolume::IsRootRegion)
131  .def("SetRegionRootFlag", &G4LogicalVolume::SetRegionRootFlag)
132  .def("IsRegion", &G4LogicalVolume::IsRegion)
133  .def("SetRegion", &G4LogicalVolume::SetRegion)
134  .def("GetRegion", &G4LogicalVolume::GetRegion,
135  return_internal_reference<>())
136  .def("PropagateRegion", &G4LogicalVolume::PropagateRegion)
137  .def("GetMaterialCutsCouple", &G4LogicalVolume::GetMaterialCutsCouple,
138  return_internal_reference<>())
139  .def("SetMaterialCutsCouple", &G4LogicalVolume::SetMaterialCutsCouple)
140  // ---
141  .def("GetVisAttributes", &G4LogicalVolume::GetVisAttributes,
142  return_internal_reference<>())
143  .def("SetVisAttributes", f1_SetVisAttributes)
144  .def("SetVisAttributes", f2_SetVisAttributes)
145  // ---
146  .def("GetFastSimulationManager",
147  &G4LogicalVolume::GetFastSimulationManager,
148  return_internal_reference<>())
149  // ---
150  .def("SetBiasWeight", &G4LogicalVolume::SetBiasWeight)
151  .def("GetBiasWeight", &G4LogicalVolume::GetBiasWeight)
152  ;
153 }
pyG4LogicalVolume::f2_SetVisAttributes
void(G4LogicalVolume::* f2_SetVisAttributes)(const G4VisAttributes &)
Definition: pyG4LogicalVolume.cc:55
pyG4LogicalVolume::f1_GetSolid
G4VSolid *(G4LogicalVolume::* f1_GetSolid)() const
Definition: pyG4LogicalVolume.cc:58
pyG4LogicalVolume::f1_SetSolid
void(G4LogicalVolume::* f1_SetSolid)(G4VSolid *)
Definition: pyG4LogicalVolume.cc:60
pyG4LogicalVolume::f1_SetVisAttributes
void(G4LogicalVolume::* f1_SetVisAttributes)(const G4VisAttributes *)
Definition: pyG4LogicalVolume.cc:52
void export_G4MagneticField ( )

Definition at line 89 of file pyG4MagneticField.cc.

References pyG4MagneticField::f1_GetFieldValue.

Referenced by BOOST_PYTHON_MODULE().

90 {
91  class_<G4MagneticField, boost::noncopyable >
92  ("__G4MagneticField", "dummy class of magnetic field", no_init)
93  ;
94 
95  class_<CB_PyG4MagneticField, boost::noncopyable,
96  bases<G4Field, G4MagneticField> >
97  ("G4MagneticField", "base class of magnetic field")
98  // ---
99  .def("DoesFieldChangeEnergy", &G4MagneticField::DoesFieldChangeEnergy)
100  .def("GetFieldValue", pure_virtual(f1_GetFieldValue))
101  ;
102 }
pyG4MagneticField::CB_PyG4MagneticField
Definition: pyG4MagneticField.cc:68
pyG4MagneticField::f1_GetFieldValue
G4ThreeVector(PyG4MagneticField::* f1_GetFieldValue)(const G4ThreeVector &, const G4double) const
Definition: pyG4MagneticField.cc:79
void export_G4Navigator ( )

Definition at line 42 of file pyG4Navigator.cc.

Referenced by BOOST_PYTHON_MODULE().

43 {
44  class_<G4Navigator, G4Navigator*, boost::noncopyable>
45  ("G4Navigator", "navigator")
46  // ---
47  .def("GetWorldVolume", &G4Navigator::GetWorldVolume,
48  return_value_policy<reference_existing_object>())
49  .def("GetVerboseLevel", &G4Navigator::GetVerboseLevel)
50  .def("SetVerboseLevel", &G4Navigator::SetVerboseLevel)
51  .def("IsActive", &G4Navigator::IsActive)
52  .def("PrintState", &G4Navigator::PrintState)
53  ;
54 }
void export_G4Orb ( )

Definition at line 54 of file pyG4Orb.cc.

References pyG4Orb::CreateOrb().

Referenced by BOOST_PYTHON_MODULE().

55 {
56  class_<G4Orb, G4Orb*, bases<G4VSolid> >
57  ("G4Orb", "Orb solid class", no_init)
58  // constructors
59  .def(init<const G4String&, G4double>())
60  // ---
61  .def("GetRadius", &G4Orb::GetRadius)
62  .def("SetRadius", &G4Orb::SetRadius)
63  // operators
64  .def(self_ns::str(self))
65  ;
66 
67  // Create solid
68  def("CreateOrb", CreateOrb, return_value_policy<manage_new_object>());
69 
70 }
pyG4Orb::CreateOrb
G4Orb * CreateOrb(const G4String &name, G4double pRmax)
Definition: pyG4Orb.cc:42
void export_G4Para ( )

Definition at line 56 of file pyG4Para.cc.

References pyG4Para::CreatePara().

Referenced by BOOST_PYTHON_MODULE().

57 {
58  class_<G4Para, G4Para*, bases<G4VSolid> >
59  ("G4Para", "Skewed box sold class", no_init)
60  // constructors
61  .def(init<const G4String&, G4double, G4double, G4double,
62  G4double, G4double, G4double>())
63  // ---
64  .def("GetZHalfLength", &G4Para::GetZHalfLength)
65  .def("GetSymAxis", &G4Para::GetSymAxis)
66  .def("GetYHalfLength", &G4Para::GetYHalfLength)
67  .def("GetXHalfLength", &G4Para::GetXHalfLength)
68  .def("GetTanAlpha", &G4Para::GetTanAlpha)
69  .def("SetXHalfLength", &G4Para::SetXHalfLength)
70  .def("SetYHalfLength", &G4Para::SetYHalfLength)
71  .def("SetZHalfLength", &G4Para::SetZHalfLength)
72  .def("SetAlpha", &G4Para::SetAlpha)
73  .def("SetTanAlpha", &G4Para::SetTanAlpha)
74  .def("SetThetaAndPhi", &G4Para::SetThetaAndPhi)
75  .def("SetAllParameters", &G4Para::SetAllParameters)
76  // operators
77  .def(self_ns::str(self))
78  ;
79 
80  // Create solid
81  def("CreatePara", CreatePara, return_value_policy<manage_new_object>());
82 }
pyG4Para::CreatePara
G4Para * CreatePara(const G4String &name, G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)
Definition: pyG4Para.cc:42
void export_G4Polycone ( )

Definition at line 91 of file pyG4Polycone.cc.

References pyG4Polycone::f1_CreatePolycone(), and pyG4Polycone::f2_CreatePolycone().

Referenced by BOOST_PYTHON_MODULE().

92 {
93  class_<G4Polycone, G4Polycone*, bases<G4VSolid> >
94  ("G4Polycone", "Polycone solid class", no_init)
95  // ---
96  .def("GetStartPhi", &G4Polycone::GetStartPhi)
97  .def("GetEndPhi", &G4Polycone::GetEndPhi)
98  .def("IsOpen", &G4Polycone::IsOpen)
99  .def("GetNumRZCorner", &G4Polycone::GetNumRZCorner)
100 
101  // operators
102  .def(self_ns::str(self))
103  ;
104 
105  // Create solid
106  def("CreatePolycone", f1_CreatePolycone,
107  return_value_policy<manage_new_object>());
108  def("CreatePolycone", f2_CreatePolycone,
109  return_value_policy<manage_new_object>());
110 
111 }
pyG4Polycone::f1_CreatePolycone
G4Polycone * f1_CreatePolycone(const G4String &name, G4double phiStart, G4double phiTotal, G4int numZPlanes, const std::vector< G4double > &zPlane, const std::vector< G4double > &rInner, const std::vector< G4double > &rOuter)
Definition: pyG4Polycone.cc:44
pyG4Polycone::f2_CreatePolycone
G4Polycone * f2_CreatePolycone(const G4String &name, G4double phiStart, G4double phiTotal, G4int numRZ, const std::vector< G4double > &r, const std::vector< G4double > &z)
Definition: pyG4Polycone.cc:65
void export_G4Polyhedra ( )

Definition at line 92 of file pyG4Polyhedra.cc.

References pyG4Polyhedra::f1_CreatePolyhedra(), and pyG4Polyhedra::f2_CreatePolyhedra().

Referenced by BOOST_PYTHON_MODULE().

93 {
94  class_<G4Polyhedra, G4Polyhedra*, bases<G4VSolid> >
95  ("G4Polyhedra", "Polyhedra solid class", no_init)
96  // ---
97  .def("GetStartPhi", &G4Polyhedra::GetStartPhi)
98  .def("GetEndPhi", &G4Polyhedra::GetEndPhi)
99  .def("GetNumSide", &G4Polyhedra::GetNumSide)
100  .def("GetNumRZCorner", &G4Polyhedra::GetNumRZCorner)
101  .def("IsOpen", &G4Polyhedra::IsOpen)
102  .def("IsGeneric", &G4Polyhedra::IsGeneric)
103 
104  // operators
105  .def(self_ns::str(self))
106  ;
107 
108  // Create solid
109  def("CreatePolyhedra", f1_CreatePolyhedra,
110  return_value_policy<manage_new_object>());
111  def("CreatePolyhedra", f2_CreatePolyhedra,
112  return_value_policy<manage_new_object>());
113 }
pyG4Polyhedra::f1_CreatePolyhedra
G4Polyhedra * f1_CreatePolyhedra(const G4String &name, G4double phiStart, G4double phiTotal, G4int numSide, G4int numZPlanes, const std::vector< G4double > &zPlane, const std::vector< G4double > &rInner, const std::vector< G4double > &rOuter)
Definition: pyG4Polyhedra.cc:44
pyG4Polyhedra::f2_CreatePolyhedra
G4Polyhedra * f2_CreatePolyhedra(const G4String &name, G4double phiStart, G4double phiTotal, G4int numSide, G4int numRZ, const std::vector< G4double > &r, const std::vector< G4double > &z)
Definition: pyG4Polyhedra.cc:66
void export_G4PVPlacement ( )

Definition at line 54 of file pyG4PVPlacement.cc.

Referenced by BOOST_PYTHON_MODULE().

55 {
56  class_<G4PVPlacement, G4PVPlacement*, bases<G4VPhysicalVolume>,
57  boost::noncopyable >
58  ("G4PVPlacement", "physical volume placement", no_init)
59  // ---
60  .def(init<G4RotationMatrix*, const G4ThreeVector&,
61  G4LogicalVolume*, const G4String&,
62  G4LogicalVolume*, G4bool, G4int>())
63  .def(init<const G4Transform3D&, G4LogicalVolume*,
64  const G4String&, G4LogicalVolume*, G4bool, G4int>())
65  .def(init<G4RotationMatrix*, const G4ThreeVector&,
66  const G4String, G4LogicalVolume*,
67  G4VPhysicalVolume*, G4bool, G4int>())
68  .def(init<const G4Transform3D&, const G4String&,
69  G4LogicalVolume*, G4VPhysicalVolume*, G4bool, G4int>())
70 #if G4VERSION_NUMBER >=800
71  .def(init<G4RotationMatrix*, const G4ThreeVector&,
72  G4LogicalVolume*, const G4String&,
73  G4LogicalVolume*, G4bool, G4int, G4bool>())
74  .def(init<const G4Transform3D&, G4LogicalVolume*,
75  const G4String&, G4LogicalVolume*, G4bool, G4int, G4bool>())
76  .def(init<G4RotationMatrix*, const G4ThreeVector&,
77  const G4String, G4LogicalVolume*,
78  G4VPhysicalVolume*, G4bool, G4int, G4bool>())
79  .def(init<const G4Transform3D&, const G4String&,
80  G4LogicalVolume*, G4VPhysicalVolume*, G4bool, G4int, G4bool>())
81 #endif
82  // ---
83 #if G4VERSION_NUMBER >=800
84  .def("CheckOverlaps", &G4PVPlacement::CheckOverlaps, f_CheckOverlaps())
85 #endif
86  ;
87 }
void export_G4PVReplica ( )

Definition at line 41 of file pyG4PVReplica.cc.

Referenced by BOOST_PYTHON_MODULE().

42 {
43  class_<G4PVReplica, G4PVReplica*, bases<G4VPhysicalVolume>,
44  boost::noncopyable >
45  ("G4PVReplica", "physical volume placement with replication", no_init)
46  // constructors
47  .def(init<const G4String&, G4LogicalVolume*, G4LogicalVolume*,
48  const EAxis, const G4int, const G4double>())
49  .def(init<const G4String&, G4LogicalVolume*, G4LogicalVolume*,
50  const EAxis, const G4int, const G4double, const G4double>())
51  .def(init<const G4String&, G4LogicalVolume*, G4VPhysicalVolume*,
52  const EAxis, const G4int, const G4double>())
53  .def(init<const G4String&, G4LogicalVolume*, G4VPhysicalVolume*,
54  const EAxis, const G4int, const G4double, const G4double>())
55  // ---
56  .def("GetMultiplicity", &G4PVReplica::GetMultiplicity)
57  ;
58 }
void export_G4Region ( )

Definition at line 47 of file pyG4Region.cc.

Referenced by BOOST_PYTHON_MODULE().

48 {
49  class_<G4Region, G4Region*, boost::noncopyable>
50  ("G4Region", "region class", no_init)
51  // constructors
52  .def(init<const G4String&>())
53  // ---
54  .def("AddRootLogicalVolume", &G4Region::AddRootLogicalVolume)
55  .def("RemoveRootLogicalVolume", &G4Region::RemoveRootLogicalVolume)
56  .def("SetName", &G4Region::SetName)
57  .def("GetName", &G4Region::GetName,
58  return_value_policy<return_by_value>())
59  .def("RegionModified", &G4Region::RegionModified)
60  .def("IsModified", &G4Region::IsModified)
61  .def("SetProductionCuts", &G4Region::SetProductionCuts)
62  .def("GetProductionCuts", &G4Region::GetProductionCuts,
63  return_internal_reference<>())
64  .def("GetNumberOfMaterials", &G4Region::GetNumberOfMaterials)
65  .def("GetNumberOfRootVolumes", &G4Region::GetNumberOfRootVolumes)
66  .def("UpdateMaterialList", &G4Region::UpdateMaterialList)
67  .def("ClearMaterialList", &G4Region::ClearMaterialList)
68  .def("ScanVolumeTree", &G4Region::ScanVolumeTree)
69  .def("SetUserInformation", &G4Region::SetUserInformation)
70  .def("GetUserInformation", &G4Region::GetUserInformation,
71  return_internal_reference<>())
72 #if G4VERSION_NUMBER >= 710
73  .def("SetUserLimits", &G4Region::SetUserLimits)
74  .def("GetUserLimits", &G4Region::GetUserLimits,
75  return_internal_reference<>())
76 #endif
77  .def("ClearMap", &G4Region::ClearMap)
78  .def("RegisterMaterialCouplePair", &G4Region::RegisterMaterialCouplePair)
79  .def("FindCouple", &G4Region::FindCouple,
80  return_value_policy<reference_existing_object>())
81 #if G4VERSION_NUMBER >= 800
82  .def("SetFastSimulationManager", &G4Region::SetFastSimulationManager)
83  .def("GetFastSimulationManager", &G4Region::GetFastSimulationManager,
84  return_internal_reference<>())
85  .def("ClearFastSimulationManager", &G4Region::ClearFastSimulationManager)
86  .def("GetWorldPhysical", &G4Region::GetWorldPhysical,
87  return_internal_reference<>())
88  .def("SetWorld", &G4Region::SetWorld)
89  .def("BelongsTo", &G4Region::BelongsTo)
90  .def("GetParentRegion", &G4Region::GetParentRegion,
91  return_value_policy<reference_existing_object>())
92 #endif
93  ;
94  }
void export_G4Sphere ( )

Definition at line 57 of file pyG4Sphere.cc.

References pyG4Sphere::CreateSphere().

Referenced by BOOST_PYTHON_MODULE().

58 {
59  class_<G4Sphere, G4Sphere*, bases<G4VSolid> >
60  ("G4Sphere", "Sphere solid class", no_init)
61  // constructors
62  .def(init<const G4String&, G4double, G4double, G4double,
63  G4double, G4double, G4double>())
64  // ---
65  .def("GetInsideRadius", &G4Sphere::GetInsideRadius)
66  .def("GetOuterRadius", &G4Sphere::GetOuterRadius)
67  .def("GetStartPhiAngle", &G4Sphere::GetStartPhiAngle)
68  .def("GetDeltaPhiAngle", &G4Sphere::GetDeltaPhiAngle)
69  .def("GetStartThetaAngle", &G4Sphere::GetStartThetaAngle)
70  .def("GetDeltaThetaAngle", &G4Sphere::GetDeltaThetaAngle)
71  .def("SetInsideRadius", &G4Sphere::SetInsideRadius)
72  .def("SetOuterRadius", &G4Sphere::SetOuterRadius)
73  .def("SetStartPhiAngle", &G4Sphere::SetStartPhiAngle)
74  .def("SetDeltaPhiAngle", &G4Sphere::SetDeltaPhiAngle)
75  .def("SetStartThetaAngle", &G4Sphere::SetStartThetaAngle)
76  .def("SetDeltaThetaAngle", &G4Sphere::SetDeltaThetaAngle)
77  // operators
78  .def(self_ns::str(self))
79  ;
80 
81  // Create solid
82  def("CreateSphere", CreateSphere, return_value_policy<manage_new_object>());
83 
84 }
pyG4Sphere::CreateSphere
G4Sphere * CreateSphere(const G4String &name, G4double pRmin, G4double pRmax, G4double pSPhi, G4double pDPhi, G4double pSTheta, G4double pDTheta)
Definition: pyG4Sphere.cc:42
void export_G4SubtractionSolid ( )

Definition at line 40 of file pyG4SubtractionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4SubtractionSolid, G4SubtractionSolid*,
43  bases<G4BooleanSolid>,boost::noncopyable>
44  ("G4SubtractionSolid", "subtraction solid class", no_init)
45  // ---
46  .def(init<const G4String&, G4VSolid*, G4VSolid*>())
47  .def(init<const G4String&, G4VSolid*, G4VSolid*,
48  G4RotationMatrix*, const G4ThreeVector&>())
49  .def(init<const G4String&, G4VSolid*, G4VSolid*,
50  const G4Transform3D&>())
51  ;
52 
53 }
void export_G4Tet ( )

Definition at line 55 of file pyG4Tet.cc.

References pyG4Tet::CreateTet().

Referenced by BOOST_PYTHON_MODULE().

56 {
57  class_<G4Tet, G4Tet*, bases<G4VSolid> >
58  ("G4Tet", "tetrahedra solid class", no_init)
59  // constructors
60  .def(init<const G4String&, G4ThreeVector, G4ThreeVector, G4ThreeVector,
61  G4ThreeVector>())
62  // operators
63  .def(self_ns::str(self))
64  ;
65 
66  // Create solid
67  def("CreateTet", CreateTet, return_value_policy<manage_new_object>());
68 
69 }
pyG4Tet::CreateTet
G4Tet * CreateTet(const G4String &name, G4ThreeVector anchor, G4ThreeVector p2, G4ThreeVector p3, G4ThreeVector p4)
Definition: pyG4Tet.cc:42
void export_G4Torus ( )

Definition at line 55 of file pyG4Torus.cc.

References pyG4Torus::CreateTorus().

Referenced by BOOST_PYTHON_MODULE().

56 {
57  class_<G4Torus, G4Torus*, bases<G4VSolid> >
58  ("G4Torus", "Torus solid class", no_init)
59  // constructors
60  .def(init<const G4String&, G4double, G4double, G4double,
61  G4double, G4double>())
62  // ---
63  .def("GetRmin", &G4Torus::GetRmin)
64  .def("GetRmax", &G4Torus::GetRmax)
65  .def("GetRtor", &G4Torus::GetRtor)
66  .def("GetSPhi", &G4Torus::GetSPhi)
67  .def("GetDPhi", &G4Torus::GetDPhi)
68  // operators
69  .def(self_ns::str(self))
70  ;
71 
72  // Create solid
73  def("CreateTorus", CreateTorus, return_value_policy<manage_new_object>());
74 }
pyG4Torus::CreateTorus
G4Torus * CreateTorus(const G4String &name, G4double pRmin, G4double pRmax, G4double pRtor, G4double pSPhi, G4double pDPhi)
Definition: pyG4Torus.cc:42
void export_G4TouchableHistory ( )

Definition at line 40 of file pyG4TouchableHistory.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4TouchableHistory, G4TouchableHistory*, bases<G4VTouchable> >
43  ("G4TouchableHistory", "touchable history class")
44  ;
45 }
void export_G4TransportationManager ( )

Definition at line 42 of file pyG4TransportationManager.cc.

Referenced by BOOST_PYTHON_MODULE().

43 {
44  class_<G4TransportationManager, boost::noncopyable>
45  ("G4TransportationManager", "manager class for transportation", no_init)
46  // ---
47  .def("GetTransportationManager",
48  &G4TransportationManager::GetTransportationManager,
49  return_value_policy<reference_existing_object>())
50  .staticmethod("GetTransportationManager")
51  .def("GetNavigatorForTracking",
52  &G4TransportationManager::GetNavigatorForTracking,
53  return_internal_reference<>())
54  .def("GetPropagatorInField",
55  &G4TransportationManager::GetPropagatorInField,
56  return_internal_reference<>())
57  .def("GetFieldManager",
58  &G4TransportationManager::GetFieldManager,
59  return_internal_reference<>())
60  .def("SetNavigatorForTracking",
61  &G4TransportationManager::SetNavigatorForTracking)
62  .def("SetPropagatorInField",
63  &G4TransportationManager::SetPropagatorInField)
64  .def("SetFieldManager",
65  &G4TransportationManager::SetFieldManager)
66  ;
67 }
void export_G4Trap ( )

Definition at line 102 of file pyG4Trap.cc.

References pyG4Trap::f1_CreateTrap(), pyG4Trap::f2_CreateTrap(), pyG4Trap::f3_CreateTrap(), pyG4Trap::f4_CreateTrap(), pyG4Trap::f5_CreateTrap(), and pyG4Trap::f6_CreateTrap().

Referenced by BOOST_PYTHON_MODULE().

103 {
104  class_<G4Trap, G4Trap*, bases<G4VSolid> >
105  ("G4Trap", "Generic trapezoild soild class", no_init)
106  // constructors
107  .def(init<const G4String&>())
108  .def(init<const G4String&, G4double, G4double, G4double, G4double>())
109  .def(init<const G4String&, G4double, G4double, G4double,
110  G4double, G4double>())
111  .def(init<const G4String&, G4double, G4double, G4double,
112  G4double, G4double, G4double>())
113  .def(init<const G4String&, G4double, G4double, G4double,
114  G4double, G4double, G4double, G4double, G4double,
115  G4double, G4double, G4double>())
116  // ---
117  .def("GetZHalfLength", &G4Trap::GetZHalfLength)
118  .def("GetYHalfLength1", &G4Trap::GetYHalfLength1)
119  .def("GetXHalfLength1", &G4Trap::GetXHalfLength1)
120  .def("GetXHalfLength2", &G4Trap::GetXHalfLength2)
121  .def("GetTanAlpha1", &G4Trap::GetTanAlpha1)
122  .def("GetYHalfLength2", &G4Trap::GetYHalfLength2)
123  .def("GetXHalfLength3", &G4Trap::GetXHalfLength3)
124  .def("GetXHalfLength4", &G4Trap::GetXHalfLength4)
125  .def("GetTanAlpha2", &G4Trap::GetTanAlpha2)
126  .def("GetSidePlane", &G4Trap::GetSidePlane)
127  .def("GetSymAxis", &G4Trap::GetSymAxis)
128  .def("SetAllParameters", &G4Trap::SetAllParameters)
129  // operators
130  .def(self_ns::str(self))
131  ;
132 
133  // Create solid
134  def("CreateTrap", f1_CreateTrap, return_value_policy<manage_new_object>());
135  def("CreateTrap", f2_CreateTrap, return_value_policy<manage_new_object>());
136  def("CreateTrap", f3_CreateTrap, return_value_policy<manage_new_object>());
137  def("CreateTrap", f4_CreateTrap, return_value_policy<manage_new_object>());
138  def("CreateTrap", f5_CreateTrap, return_value_policy<manage_new_object>());
139  def("CreateTrap", f6_CreateTrap, return_value_policy<manage_new_object>());
140 
141 }
pyG4Trap::f6_CreateTrap
G4Trap * f6_CreateTrap(const G4String &name, G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)
Definition: pyG4Trap.cc:88
pyG4Trap::f1_CreateTrap
G4Trap * f1_CreateTrap(const G4String &name)
Definition: pyG4Trap.cc:42
pyG4Trap::f5_CreateTrap
G4Trap * f5_CreateTrap(const G4String &name, G4double pDx1, G4double pDx2, G4double pDy1, G4double pDy2, G4double pDz)
Definition: pyG4Trap.cc:81
pyG4Trap::f4_CreateTrap
G4Trap * f4_CreateTrap(const G4String &name, G4double pZ, G4double pY, G4double pX, G4double pLTX)
Definition: pyG4Trap.cc:74
pyG4Trap::f3_CreateTrap
G4Trap * f3_CreateTrap(const G4String &name, const std::vector< G4ThreeVector > &pt)
Definition: pyG4Trap.cc:62
pyG4Trap::f2_CreateTrap
G4Trap * f2_CreateTrap(const G4String &name, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pAlp1, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlp2)
Definition: pyG4Trap.cc:48
void export_G4Trd ( )

Definition at line 55 of file pyG4Trd.cc.

References pyG4Trd::CreateTrd().

Referenced by BOOST_PYTHON_MODULE().

56 {
57  class_<G4Trd, G4Trd*, bases<G4VSolid> >
58  ("G4Trd", "Trapezoild solid class", no_init)
59  // constructors
60  .def(init<const G4String&, G4double, G4double, G4double,
61  G4double, G4double>())
62  // ---
63  .def("GetXHalfLength1", &G4Trd::GetXHalfLength1)
64  .def("GetXHalfLength2", &G4Trd::GetXHalfLength2)
65  .def("GetYHalfLength1", &G4Trd::GetYHalfLength1)
66  .def("GetYHalfLength2", &G4Trd::GetYHalfLength2)
67  .def("GetZHalfLength", &G4Trd::GetZHalfLength)
68  .def("SetXHalfLength1", &G4Trd::SetXHalfLength1)
69  .def("SetXHalfLength2", &G4Trd::SetXHalfLength2)
70  .def("SetYHalfLength1", &G4Trd::SetYHalfLength1)
71  .def("SetYHalfLength2", &G4Trd::SetYHalfLength2)
72  .def("SetZHalfLength", &G4Trd::SetZHalfLength)
73  // operators
74  .def(self_ns::str(self))
75  ;
76 
77  // Create solid
78  def("CreateTrd", CreateTrd, return_value_policy<manage_new_object>());
79 
80 }
pyG4Trd::CreateTrd
G4Trd * CreateTrd(const G4String &name, G4double pdx1, G4double pdx2, G4double pdy1, G4double pdy2, G4double pdz)
Definition: pyG4Trd.cc:42
void export_G4Tubs ( )

Definition at line 55 of file pyG4Tubs.cc.

References pyG4Tubs::CreateTubs().

Referenced by BOOST_PYTHON_MODULE().

56 {
57  class_<G4Tubs, G4Tubs*, bases<G4VSolid> >
58  ("G4Tubs", "Tube solid class", no_init)
59  // constructors
60  .def(init<const G4String&, G4double, G4double, G4double,
61  G4double, G4double>())
62  // ---
63  .def("GetInnerRadius", &G4Tubs::GetInnerRadius)
64  .def("GetOuterRadius", &G4Tubs::GetOuterRadius)
65  .def("GetZHalfLength", &G4Tubs::GetZHalfLength)
66  .def("GetStartPhiAngle", &G4Tubs::GetStartPhiAngle)
67  .def("GetDeltaPhiAngle", &G4Tubs::GetDeltaPhiAngle)
68  .def("SetInnerRadius", &G4Tubs::SetInnerRadius)
69  .def("SetOuterRadius", &G4Tubs::SetOuterRadius)
70  .def("SetZHalfLength", &G4Tubs::SetZHalfLength)
71  .def("SetStartPhiAngle", &G4Tubs::SetStartPhiAngle)
72  .def("SetDeltaPhiAngle", &G4Tubs::SetDeltaPhiAngle)
73  .def("GetRMin", &G4Tubs::GetRMin)
74  .def("GetRMax", &G4Tubs::GetRMax)
75  .def("GetDz", &G4Tubs::GetDz)
76  .def("GetSPhi", &G4Tubs::GetSPhi)
77  .def("GetDPhi", &G4Tubs::GetDPhi)
78  // operators
79  .def(self_ns::str(self))
80  ;
81 
82  // Create solid
83  def("CreateTubs", CreateTubs, return_value_policy<manage_new_object>());
84 
85 }
pyG4Tubs::CreateTubs
G4Tubs * CreateTubs(const G4String &name, G4double pRMin, G4double pRMax, G4double pDz, G4double pSPhi, G4double pDPhi)
Definition: pyG4Tubs.cc:42
void export_G4TwistedBox ( )

Definition at line 58 of file pyG4TwistedBox.cc.

References pyG4TwistedBox::CreateTwistedBox().

Referenced by BOOST_PYTHON_MODULE().

59 {
60  class_<G4TwistedBox, G4TwistedBox*, bases<G4VSolid> >
61  ("G4TwistedBox", "twisted box solid class", no_init)
62  // constructors
63  .def(init<const G4String&, G4double, G4double, G4double, G4double>())
64  // ---
65  .def("GetXHalfLength", &G4TwistedBox::GetXHalfLength)
66  .def("GetYHalfLength", &G4TwistedBox::GetYHalfLength)
67  .def("GetZHalfLength", &G4TwistedBox::GetZHalfLength)
68  .def("GetPhiTwist", &G4TwistedBox::GetPhiTwist)
69  // operators
70  .def(self_ns::str(self))
71  ;
72 
73  // Create solid
74  def("CreateTwistedBox", CreateTwistedBox,
75  return_value_policy<manage_new_object>());
76 
77 }
pyG4TwistedBox::CreateTwistedBox
G4TwistedBox * CreateTwistedBox(const G4String &name, G4double pPhiTwist, G4double pDx, G4double pDy, G4double pDz)
Definition: pyG4TwistedBox.cc:42
void export_G4TwistedTrap ( )

Definition at line 70 of file pyG4TwistedTrap.cc.

References pyG4TwistedTrap::f1_CreateTwistedTrap(), and pyG4TwistedTrap::f2_CreateTwistedTrap().

Referenced by BOOST_PYTHON_MODULE().

71 {
72  class_<G4TwistedTrap, G4TwistedTrap*, bases<G4VSolid> >
73  ("G4TwistedTrap", "twisted trapezoid solid class", no_init)
74  // constructors
75  .def(init<const G4String&, G4double, G4double, G4double,
76  G4double, G4double>())
77  .def(init<const G4String&, G4double, G4double, G4double,
78  G4double, G4double, G4double,
79  G4double, G4double, G4double,
80  G4double, G4double>())
81  // operators
82  .def(self_ns::str(self))
83  ;
84 
85  // Create solid
86  def("CreateTwistedTap", f1_CreateTwistedTrap,
87  return_value_policy<manage_new_object>());
88  def("CreateTwistedTap", f2_CreateTwistedTrap,
89  return_value_policy<manage_new_object>());
90 
91 }
pyG4TwistedTrap::f2_CreateTwistedTrap
G4TwistedTrap * f2_CreateTwistedTrap(const G4String &name, G4double pPhiTwist, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlph)
Definition: pyG4TwistedTrap.cc:51
pyG4TwistedTrap::f1_CreateTwistedTrap
G4TwistedTrap * f1_CreateTwistedTrap(const G4String &name, G4double pPhiTwist, G4double pDx1, G4double pDx2, G4double pDy, G4double pDz)
Definition: pyG4TwistedTrap.cc:42
void export_G4TwistedTrd ( )

Definition at line 57 of file pyG4TwistedTrd.cc.

References pyG4TwistedTrd::CreateTwistedTrd().

Referenced by BOOST_PYTHON_MODULE().

58 {
59  class_<G4TwistedTrd, G4TwistedTrd*, bases<G4VSolid> >
60  ("G4TwistedTrd", "twisted trapezoid solid class", no_init)
61  // constructors
62  .def(init<const G4String&, G4double, G4double, G4double,
63  G4double, G4double, G4double>())
64  // ---
65  .def("GetX1HalfLength", &G4TwistedTrd::GetX1HalfLength)
66  .def("GetX2HalfLength", &G4TwistedTrd::GetX2HalfLength)
67  .def("GetY1HalfLength", &G4TwistedTrd::GetY1HalfLength)
68  .def("GetY2HalfLength", &G4TwistedTrd::GetY2HalfLength)
69  .def("GetZHalfLength", &G4TwistedTrd::GetZHalfLength)
70  .def("GetPhiTwist", &G4TwistedTrd::GetPhiTwist)
71  // operators
72  .def(self_ns::str(self))
73  ;
74 
75  // Create solid
76  def("CreateTwistedTrd", CreateTwistedTrd,
77  return_value_policy<manage_new_object>());
78 
79 }
pyG4TwistedTrd::CreateTwistedTrd
G4TwistedTrd * CreateTwistedTrd(const G4String &name, G4double pDx1, G4double pDx2, G4double pDy1, G4double pDy2, G4double pDz, G4double pPhiTwist)
Definition: pyG4TwistedTrd.cc:42
void export_G4TwistedTubs ( )

Definition at line 113 of file pyG4TwistedTubs.cc.

References pyG4TwistedTubs::f1_CreateTwistedTubs(), pyG4TwistedTubs::f1_GetEndInnerRadius, pyG4TwistedTubs::f1_GetEndOuterRadius, pyG4TwistedTubs::f2_CreateTwistedTubs(), pyG4TwistedTubs::f2_GetEndInnerRadius, pyG4TwistedTubs::f2_GetEndOuterRadius, pyG4TwistedTubs::f3_CreateTwistedTubs(), and pyG4TwistedTubs::f4_CreateTwistedTubs().

Referenced by BOOST_PYTHON_MODULE().

114 {
115  class_<G4TwistedTubs, G4TwistedTubs*, bases<G4VSolid> >
116  ("G4TwistedTubs", "twisted tube solid class", no_init)
117  // constructors
118  .def(init<const G4String&, G4double, G4double, G4double,
119  G4double, G4double>())
120  .def(init<const G4String&, G4double, G4double, G4double,
121  G4double, G4int, G4double>())
122  .def(init<const G4String&, G4double, G4double, G4double,
123  G4double, G4double, G4double>())
124  .def(init<const G4String&, G4double, G4double, G4double,
125  G4double, G4double, G4int, G4double>())
126  // ---
127  .def("GetDPhi", &G4TwistedTubs::GetDPhi)
128  .def("GetPhiTwist", &G4TwistedTubs::GetPhiTwist)
129  .def("GetInnerRadius", &G4TwistedTubs::GetInnerRadius)
130  .def("GetOuterRadius", &G4TwistedTubs::GetOuterRadius)
131  .def("GetInnerStereo", &G4TwistedTubs::GetInnerStereo)
132  .def("GetOuterStereo", &G4TwistedTubs::GetOuterStereo)
133  .def("GetZHalfLength", &G4TwistedTubs::GetZHalfLength)
134  .def("GetKappa", &G4TwistedTubs::GetKappa)
135  .def("GetTanInnerStereo", &G4TwistedTubs::GetTanInnerStereo)
136  .def("GetTanInnerStereo2", &G4TwistedTubs::GetTanInnerStereo2)
137  .def("GetTanOuterStereo", &G4TwistedTubs::GetTanOuterStereo)
138  .def("GetTanOuterStereo2", &G4TwistedTubs::GetTanOuterStereo2)
139  .def("GetEndZ", &G4TwistedTubs::GetEndZ)
140  .def("GetEndPhi", &G4TwistedTubs::GetEndPhi)
141  .def("GetEndInnerRadius", f1_GetEndInnerRadius)
142  .def("GetEndInnerRadius", f2_GetEndInnerRadius)
143  .def("GetEndOuterRadius", f1_GetEndOuterRadius)
144  .def("GetEndOuterRadius", f2_GetEndOuterRadius)
145  // operators
146  .def(self_ns::str(self))
147  ;
148 
149  // Create solid
150  def("CreateTwistedTubs", f1_CreateTwistedTubs,
151  return_value_policy<manage_new_object>());
152  def("CreateTwistedTubs", f2_CreateTwistedTubs,
153  return_value_policy<manage_new_object>());
154  def("CreateTwistedTubs", f3_CreateTwistedTubs,
155  return_value_policy<manage_new_object>());
156  def("CreateTwistedTubs", f4_CreateTwistedTubs,
157  return_value_policy<manage_new_object>());
158 
159 }
pyG4TwistedTubs::f1_GetEndInnerRadius
G4double(G4TwistedTubs::* f1_GetEndInnerRadius)(G4int) const
Definition: pyG4TwistedTubs.cc:44
pyG4TwistedTubs::f2_GetEndInnerRadius
G4double(G4TwistedTubs::* f2_GetEndInnerRadius)(G4int) const
Definition: pyG4TwistedTubs.cc:46
pyG4TwistedTubs::f4_CreateTwistedTubs
G4TwistedTubs * f4_CreateTwistedTubs(const G4String &name, G4double twistedangle, G4double innerrad, G4double outerrad, G4double negativeEndz, G4double positiveEndz, G4int nseg, G4double totphi)
Definition: pyG4TwistedTubs.cc:92
pyG4TwistedTubs::f2_GetEndOuterRadius
G4double(G4TwistedTubs::* f2_GetEndOuterRadius)() const
Definition: pyG4TwistedTubs.cc:52
pyG4TwistedTubs::f1_CreateTwistedTubs
G4TwistedTubs * f1_CreateTwistedTubs(const G4String &name, G4double twistedangle, G4double endinnerrad, G4double endouterrad, G4double halfzlen, G4double dphi)
Definition: pyG4TwistedTubs.cc:57
pyG4TwistedTubs::f3_CreateTwistedTubs
G4TwistedTubs * f3_CreateTwistedTubs(const G4String &name, G4double twistedangle, G4double innerrad, G4double outerrad, G4double negativeEndz, G4double positiveEndz, G4double dphi)
Definition: pyG4TwistedTubs.cc:80
pyG4TwistedTubs::f2_CreateTwistedTubs
G4TwistedTubs * f2_CreateTwistedTubs(const G4String &name, G4double twistedangle, G4double endinnerrad, G4double endouterrad, G4double halfzlen, G4int nseg, G4double totphi)
Definition: pyG4TwistedTubs.cc:68
pyG4TwistedTubs::f1_GetEndOuterRadius
G4double(G4TwistedTubs::* f1_GetEndOuterRadius)(G4int) const
Definition: pyG4TwistedTubs.cc:50
void export_G4UniformMagField ( )

Definition at line 40 of file pyG4UniformMagField.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4UniformMagField, G4UniformMagField*,
43  bases<G4Field, G4MagneticField> >
44  ("G4UniformMagField", "uniform magnetic field", no_init)
45  // constructors
46  .def(init<const G4ThreeVector&>())
47  .def(init<const G4double, G4double, G4double>())
48  // ---
49  .def("SetFieldValue", &G4UniformMagField::SetFieldValue)
50  .def("GetConstantFieldValue", &G4UniformMagField::GetConstantFieldValue)
51  ;
52 }
void export_G4UnionSolid ( )

Definition at line 40 of file pyG4UnionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

41 {
42  class_<G4UnionSolid, G4UnionSolid*,
43  bases<G4BooleanSolid>,boost::noncopyable>
44  ("G4UnionSolid", "union solid class", no_init)
45  // ---
46  .def(init<const G4String&, G4VSolid*, G4VSolid*>())
47  .def(init<const G4String&, G4VSolid*, G4VSolid*,
48  G4RotationMatrix*, const G4ThreeVector&>())
49  .def(init<const G4String&, G4VSolid*, G4VSolid*,
50  const G4Transform3D&>())
51  ;
52 
53 }
void export_G4VPhysicalVolume ( )

Definition at line 58 of file pyG4VPhysicalVolume.cc.

References pyG4VPhysicalVolume::f1_GetRotation, and pyG4VPhysicalVolume::f2_GetRotation.

Referenced by BOOST_PYTHON_MODULE().

59 {
60  class_<G4VPhysicalVolume, G4VPhysicalVolume*, boost::noncopyable>
61  ("G4VPhysicalVolume", "physical volume class", no_init)
62  // ---
63  .def("SetTranslation", &G4VPhysicalVolume::SetTranslation)
64  .def("GetTranslation", &G4VPhysicalVolume::GetTranslation,
65  return_internal_reference<>())
66  .def("GetObjectTranslation", &G4VPhysicalVolume::GetObjectTranslation)
67  .def("GetFrameTranslation", &G4VPhysicalVolume::GetObjectTranslation)
68  // ---
69  .def("SetRotation", &G4VPhysicalVolume::SetRotation)
70  .def("GetRotation", f1_GetRotation,
71  return_internal_reference<>())
72  .def("GetRotation", f2_GetRotation,
73  return_internal_reference<>())
74  .def("GetObjectRotationValue", &G4VPhysicalVolume::GetObjectRotationValue)
75  .def("GetFrameRotation", &G4VPhysicalVolume::GetFrameRotation,
76  return_internal_reference<>())
77  // ---
78  .def("SetLogicalVolume", &G4VPhysicalVolume::SetLogicalVolume)
79  .def("SetMotherLogical", &G4VPhysicalVolume::SetMotherLogical)
80  .def("GetLogicalVolume", &G4VPhysicalVolume::GetLogicalVolume,
81  return_internal_reference<>())
82  .def("GetMotherLogical", &G4VPhysicalVolume::GetMotherLogical,
83  return_internal_reference<>())
84  // ---
85  .def("SetName", &G4VPhysicalVolume::SetName)
86 #if G4VERSION_NUMBER <= 801
87  .def("GetName", &G4VPhysicalVolume::GetName)
88 #else
89  .def("GetName", &G4VPhysicalVolume::GetName,
90  return_value_policy<return_by_value>())
91 #endif
92  .def("SetCopyNo", &G4VPhysicalVolume::SetCopyNo)
93  .def("GetCopyNo", &G4VPhysicalVolume::GetCopyNo)
94  // ---
95  .def("IsMany", &G4VPhysicalVolume::IsMany)
96  .def("IsReplicated", &G4VPhysicalVolume::IsReplicated)
97  .def("IsParameterised", &G4VPhysicalVolume::IsParameterised)
98  .def("GetMultiplicity", &G4VPhysicalVolume::GetMultiplicity)
99  .def("GetParameterisation", &G4VPhysicalVolume::GetParameterisation,
100  return_value_policy<reference_existing_object>())
101  ;
102 }
pyG4VPhysicalVolume::f1_GetRotation
const G4RotationMatrix *(G4VPhysicalVolume::* f1_GetRotation)() const
Definition: pyG4VPhysicalVolume.cc:45
pyG4VPhysicalVolume::f2_GetRotation
G4RotationMatrix *(G4VPhysicalVolume::* f2_GetRotation)()
Definition: pyG4VPhysicalVolume.cc:48
void export_G4VSolid ( )

Definition at line 41 of file pyG4VSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

42 {
43  class_<G4VSolid, G4VSolid*, boost::noncopyable>
44  ("G4VSolid", "solid class", no_init)
45  // ---
46  .def("GetName", &G4VSolid::GetName)
47  .def("SetName", &G4VSolid::SetName)
48  .def("DumpInfo", &G4VSolid::DumpInfo)
49 
50  .def("GetCubicVolume", &G4VSolid::GetCubicVolume)
51 #if G4VERSION_NUMBER >=820
52  .def("GetSurfaceArea", &G4VSolid::GetSurfaceArea)
53 #endif
54 #if G4VERSION_NUMBER >=800
55  .def("GetPointOnSurface", &G4VSolid::GetPointOnSurface)
56 #endif
57  // operators
58  .def(self == self)
59  ;
60 }
void export_G4VTouchable ( )

Definition at line 66 of file pyG4VTouchable.cc.

References pyG4VTouchable::GetRotation.

Referenced by BOOST_PYTHON_MODULE().

67 {
68  class_<G4VTouchable, G4VTouchable*, boost::noncopyable>
69  ("G4VTouchable", "touchable class", no_init)
70  .def("GetTranslation", &G4VTouchable::GetTranslation,
71  f_GetTranslation()
72  [return_value_policy<return_by_value>()])
73  .def("GetRotation", &G4VTouchable::GetRotation,
74  f_GetRotation()
75  [return_value_policy<reference_existing_object>()])
76  .def("GetVolume", &G4VTouchable::GetVolume,
77  f_GetVolume()
78  [return_value_policy<reference_existing_object>()])
79  .def("GetSolid", &G4VTouchable::GetSolid,
80  f_GetSolid()
81  [return_value_policy<reference_existing_object>()])
82  .def("GetReplicaNumber", &G4VTouchable::GetReplicaNumber,
83  f_GetReplicaNumber())
84  .def("GetHistoryDepth", &G4VTouchable::GetHistoryDepth)
85  .def("MoveUpHistory", &G4VTouchable::MoveUpHistory,
86  f_MoveUpHistory())
87  ;
88 }