LArSoft  v09_90_00
Liquid Argon Software toolkit - https://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 79 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().

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

Definition at line 39 of file pyG4BooleanSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 54 of file pyG4Box.cc.

References pyG4Box::CreateBox().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 51 of file pyG4ChordFinder.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 55 of file pyG4Cons.cc.

References pyG4Cons::CreateCons().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 61 of file pyG4Ellipsoid.cc.

References pyG4Ellipsoid::CreateEllipsoid().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 57 of file pyG4EllipticalCone.cc.

References pyG4EllipticalCone::CreateEllipticalCone().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 56 of file pyG4EllipticalTube.cc.

References pyG4EllipticalTube::CreateEllipticalTube().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 39 of file pyG4Field.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 62 of file pyG4FieldManager.cc.

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

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 52 of file pyG4GeometryManager.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 61 of file pyG4Hype.cc.

References pyG4Hype::CreateHype().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 39 of file pyG4IntersctionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 71 of file pyG4LogicalVolume.cc.

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

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 88 of file pyG4MagneticField.cc.

References pyG4MagneticField::f1_GetFieldValue.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 41 of file pyG4Navigator.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 53 of file pyG4Orb.cc.

References pyG4Orb::CreateOrb().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 55 of file pyG4Para.cc.

References pyG4Para::CreatePara().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 90 of file pyG4Polycone.cc.

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

Referenced by BOOST_PYTHON_MODULE().

91 {
92  class_<G4Polycone, G4Polycone*, bases<G4VSolid> >
93  ("G4Polycone", "Polycone solid class", no_init)
94  // ---
95  .def("GetStartPhi", &G4Polycone::GetStartPhi)
96  .def("GetEndPhi", &G4Polycone::GetEndPhi)
97  .def("IsOpen", &G4Polycone::IsOpen)
98  .def("GetNumRZCorner", &G4Polycone::GetNumRZCorner)
99 
100  // operators
101  .def(self_ns::str(self))
102  ;
103 
104  // Create solid
105  def("CreatePolycone", f1_CreatePolycone,
106  return_value_policy<manage_new_object>());
107  def("CreatePolycone", f2_CreatePolycone,
108  return_value_policy<manage_new_object>());
109 
110 }
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:43
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:64
void export_G4Polyhedra ( )

Definition at line 91 of file pyG4Polyhedra.cc.

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

Referenced by BOOST_PYTHON_MODULE().

92 {
93  class_<G4Polyhedra, G4Polyhedra*, bases<G4VSolid> >
94  ("G4Polyhedra", "Polyhedra solid class", no_init)
95  // ---
96  .def("GetStartPhi", &G4Polyhedra::GetStartPhi)
97  .def("GetEndPhi", &G4Polyhedra::GetEndPhi)
98  .def("GetNumSide", &G4Polyhedra::GetNumSide)
99  .def("GetNumRZCorner", &G4Polyhedra::GetNumRZCorner)
100  .def("IsOpen", &G4Polyhedra::IsOpen)
101  .def("IsGeneric", &G4Polyhedra::IsGeneric)
102 
103  // operators
104  .def(self_ns::str(self))
105  ;
106 
107  // Create solid
108  def("CreatePolyhedra", f1_CreatePolyhedra,
109  return_value_policy<manage_new_object>());
110  def("CreatePolyhedra", f2_CreatePolyhedra,
111  return_value_policy<manage_new_object>());
112 }
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:43
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:65
void export_G4PVPlacement ( )

Definition at line 53 of file pyG4PVPlacement.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 40 of file pyG4PVReplica.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 46 of file pyG4Region.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 56 of file pyG4Sphere.cc.

References pyG4Sphere::CreateSphere().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 39 of file pyG4SubtractionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 54 of file pyG4Tet.cc.

References pyG4Tet::CreateTet().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 54 of file pyG4Torus.cc.

References pyG4Torus::CreateTorus().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 39 of file pyG4TouchableHistory.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 41 of file pyG4TransportationManager.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 101 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().

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

Definition at line 54 of file pyG4Trd.cc.

References pyG4Trd::CreateTrd().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 54 of file pyG4Tubs.cc.

References pyG4Tubs::CreateTubs().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 57 of file pyG4TwistedBox.cc.

References pyG4TwistedBox::CreateTwistedBox().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 69 of file pyG4TwistedTrap.cc.

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

Referenced by BOOST_PYTHON_MODULE().

70 {
71  class_<G4TwistedTrap, G4TwistedTrap*, bases<G4VSolid> >
72  ("G4TwistedTrap", "twisted trapezoid solid class", no_init)
73  // constructors
74  .def(init<const G4String&, G4double, G4double, G4double,
75  G4double, G4double>())
76  .def(init<const G4String&, G4double, G4double, G4double,
77  G4double, G4double, G4double,
78  G4double, G4double, G4double,
79  G4double, G4double>())
80  // operators
81  .def(self_ns::str(self))
82  ;
83 
84  // Create solid
85  def("CreateTwistedTap", f1_CreateTwistedTrap,
86  return_value_policy<manage_new_object>());
87  def("CreateTwistedTap", f2_CreateTwistedTrap,
88  return_value_policy<manage_new_object>());
89 
90 }
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:50
pyG4TwistedTrap::f1_CreateTwistedTrap
G4TwistedTrap * f1_CreateTwistedTrap(const G4String &name, G4double pPhiTwist, G4double pDx1, G4double pDx2, G4double pDy, G4double pDz)
Definition: pyG4TwistedTrap.cc:41
void export_G4TwistedTrd ( )

Definition at line 56 of file pyG4TwistedTrd.cc.

References pyG4TwistedTrd::CreateTwistedTrd().

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 112 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().

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

Definition at line 39 of file pyG4UniformMagField.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 39 of file pyG4UnionSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 57 of file pyG4VPhysicalVolume.cc.

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

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 40 of file pyG4VSolid.cc.

Referenced by BOOST_PYTHON_MODULE().

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

Definition at line 65 of file pyG4VTouchable.cc.

References pyG4VTouchable::GetRotation.

Referenced by BOOST_PYTHON_MODULE().

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