pymodG4global.cc File Reference

#include <boost/python.hpp>

Go to the source code of this file.

Functions
	BOOST_PYTHON_MODULE (G4global)
void	export_G4ApplicationState ()
void	export_G4Exception ()
void	export_G4ExceptionHandler ()
void	export_G4ExceptionSeverity ()
void	export_G4RandomDirection ()
void	export_G4RotationMatrix ()
void	export_G4StateManager ()
void	export_G4String ()
void	export_G4ThreeVector ()
void	export_G4Timer ()
void	export_G4Transform3D ()
void	export_G4TwoVector ()
void	export_G4UnitsTable ()
void	export_G4UserLimits ()
void	export_G4Version ()
void	export_geomdefs ()
void	export_globals ()
void	export_RandomEngines ()
void	export_Randomize ()

Function Documentation

BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE

(

G4global

)

Definition at line 59 of file pymodG4global.cc.

{
  export_globals();
  export_geomdefs();
  export_G4StateManager();
  export_G4ApplicationState();
  export_G4String();
  export_G4ThreeVector();
  export_G4TwoVector();
  export_G4RotationMatrix();
  export_G4Transform3D();
  export_G4UnitsTable();
  export_Randomize();
  export_RandomEngines();
  export_G4RandomDirection();
  export_G4UserLimits();
  export_G4Timer();
  export_G4Version();
  export_G4Exception();
  export_G4ExceptionHandler();
  export_G4ExceptionSeverity();
}

References export_G4ApplicationState(), export_G4Exception(), export_G4ExceptionHandler(), export_G4ExceptionSeverity(), export_G4RandomDirection(), export_G4RotationMatrix(), export_G4StateManager(), export_G4String(), export_G4ThreeVector(), export_G4Timer(), export_G4Transform3D(), export_G4TwoVector(), export_G4UnitsTable(), export_G4UserLimits(), export_G4Version(), export_geomdefs(), export_globals(), export_RandomEngines(), and export_Randomize().

export_G4ApplicationState()

void export_G4ApplicationState

(

)

Definition at line 41 of file pyG4ApplicationState.cc.

{
  enum_<G4ApplicationState>("G4ApplicationState")
    .value("G4State_PreInit",       G4State_PreInit)
    .value("G4State_Init",          G4State_Init)
    .value("G4State_Idle",          G4State_Idle)
    .value("G4State_GeomClosed",    G4State_GeomClosed)
    .value("G4State_EventProc",     G4State_EventProc)
    .value("G4State_Quit",          G4State_Quit)
    .value("G4State_Abort",         G4State_Abort)
    ;
}

References G4State_Abort, G4State_EventProc, G4State_GeomClosed, G4State_Idle, G4State_Init, G4State_PreInit, and G4State_Quit.

Referenced by BOOST_PYTHON_MODULE().

export_G4Exception()

void export_G4Exception

(

)

Definition at line 110 of file pyG4Exception.cc.

{
  def("G4Exception",   f2_G4Exception);
}

References pyG4Exception::f2_G4Exception().

Referenced by BOOST_PYTHON_MODULE().

export_G4ExceptionHandler()

void export_G4ExceptionHandler

(

)

Definition at line 104 of file pyG4ExceptionHandler.cc.

{
  class_<PyG4ExceptionHandler, boost::noncopyable>
    ("G4ExceptionHandler", "exception handler")
    ;
}

Referenced by BOOST_PYTHON_MODULE().

export_G4ExceptionSeverity()

void export_G4ExceptionSeverity

(

)

Definition at line 41 of file pyG4ExceptionSeverity.cc.

{
  enum_<G4ExceptionSeverity>("G4ExceptionSeverity")
    .value("FatalException",       FatalException)
    .value("FatalErrorInArgument", FatalErrorInArgument)
    .value("RunMustBeAborted",     RunMustBeAborted)
    .value("EventMustBeAborted",   EventMustBeAborted)
    .value("JustWarning",          JustWarning) 
    ;
 
}

References EventMustBeAborted, FatalErrorInArgument, FatalException, JustWarning, and RunMustBeAborted.

Referenced by BOOST_PYTHON_MODULE().

export_G4RandomDirection()

void export_G4RandomDirection

(

)

Definition at line 51 of file pyG4RandomDirection.cc.

{
  def("G4RandomDirection",  G4RandomDirection_1);
  def("G4RandomDirection",  G4RandomDirection_2);
}

References pyG4RandomDirection::G4RandomDirection_1, and pyG4RandomDirection::G4RandomDirection_2.

Referenced by BOOST_PYTHON_MODULE().

export_G4RotationMatrix()

void export_G4RotationMatrix

(

)

Definition at line 53 of file pyG4RotationMatrix.cc.

{
  class_<G4RotationMatrix>("G4RotationMatrix", "rotation matrix")
    // constructors
    .def(init<const XXX&>())
 
    // property
    .add_property("xx", &XXX::xx)
    .add_property("xy", &XXX::xy)
    .add_property("xz", &XXX::xz)
    .add_property("yx", &XXX::yx)
    .add_property("yy", &XXX::yy)
    .add_property("yz", &XXX::yz)
    .add_property("zx", &XXX::zx)
    .add_property("zy", &XXX::zy)
    .add_property("zz", &XXX::zz)
    .def_readonly("IDENTITY", &XXX::IDENTITY)
 
    // methods
    .def("colX",       &XXX::colX)
    .def("colY",       &XXX::colY)
    .def("colZ",       &XXX::colZ)
    .def("rowX",       &XXX::rowX)
    .def("rowY",       &XXX::rowY)
    .def("rowZ",       &XXX::rowZ)
    .def("getPhi",     &XXX::getPhi)
    .def("getTheta",   &XXX::getTheta)
    .def("getPsi",     &XXX::getPsi)
    .def("phi",        &XXX::phi)
    .def("theta",      &XXX::theta)
    .def("psi",        &XXX::psi)
    .def("getDelta",   &XXX::getDelta)
    .def("getAxis",    &XXX::getAxis)
    .def("delta",      &XXX::axis)
    .def("axis",       &XXX::delta)
    .def("phiX",       &XXX::phiX)
    .def("phiY",       &XXX::phiY)
    .def("phiZ",       &XXX::phiZ)
    .def("thetaX",     &XXX::thetaX)
    .def("thetaY",     &XXX::thetaY)
    .def("thetaZ",     &XXX::thetaZ)
    .def("setPhi",     &XXX::setPhi)
    .def("setTheta",   &XXX::setTheta)
    .def("setPsi",     &XXX::setPsi)
    .def("setAxis",    &XXX::setAxis)
    .def("setDelta",   &XXX::setDelta)
    .def("isIdentity", &XXX::isIdentity)
    .def("rotateX",    &XXX::rotateX,
     return_value_policy<reference_existing_object>())
    .def("rotateY",    &XXX::rotateY,
     return_value_policy<reference_existing_object>())
    .def("rotateZ",    &XXX::rotateZ,
     return_value_policy<reference_existing_object>())
    .def("rotate",     f1_rotate,
     return_value_policy<reference_existing_object>())
    .def("rotate",     f2_rotate,
     return_value_policy<reference_existing_object>())
    .def("rotateAxes", &XXX::rotateAxes,
     return_value_policy<reference_existing_object>())
    .def("inverse",     &XXX::inverse)
    .def("invert",     &XXX::invert,
     return_value_policy<reference_existing_object>())
 
    // operators
    .def(self_ns::str(self))
    .def(self == self)
    .def(self != self)
    .def(self >  self)
    .def(self <  self)
    .def(self >= self)
    .def(self <= self)
    .def(self *  self)
    .def(self *  G4ThreeVector())
    .def(self *= self)
    ;
}

References CLHEP::HepRotation::axis(), CLHEP::HepRotation::colX(), CLHEP::HepRotation::colY(), CLHEP::HepRotation::colZ(), CLHEP::HepRotation::delta(), pyG4RotationMatrix::f1_rotate, pyG4RotationMatrix::f2_rotate, CLHEP::HepRotation::getAxis(), CLHEP::HepRotation::getDelta(), CLHEP::HepRotation::getPhi(), CLHEP::HepRotation::getPsi(), CLHEP::HepRotation::getTheta(), CLHEP::HepRotation::IDENTITY, CLHEP::HepRotation::inverse(), CLHEP::HepRotation::invert(), CLHEP::HepRotation::isIdentity(), CLHEP::HepRotation::phi(), CLHEP::HepRotation::phiX(), CLHEP::HepRotation::phiY(), CLHEP::HepRotation::phiZ(), CLHEP::HepRotation::psi(), CLHEP::HepRotation::rotateAxes(), CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), CLHEP::HepRotation::rowX(), CLHEP::HepRotation::rowY(), CLHEP::HepRotation::rowZ(), CLHEP::HepRotation::setAxis(), CLHEP::HepRotation::setDelta(), CLHEP::HepRotation::setPhi(), CLHEP::HepRotation::setPsi(), CLHEP::HepRotation::setTheta(), CLHEP::HepRotation::theta(), CLHEP::HepRotation::thetaX(), CLHEP::HepRotation::thetaY(), CLHEP::HepRotation::thetaZ(), CLHEP::HepRotation::xx(), CLHEP::HepRotation::xy(), CLHEP::HepRotation::xz(), CLHEP::HepRotation::yx(), CLHEP::HepRotation::yy(), CLHEP::HepRotation::yz(), CLHEP::HepRotation::zx(), CLHEP::HepRotation::zy(), and CLHEP::HepRotation::zz().

Referenced by BOOST_PYTHON_MODULE().

export_G4StateManager()

void export_G4StateManager

(

)

Definition at line 39 of file pyG4StateManager.cc.

{
  class_<G4StateManager, boost::noncopyable>
    ("G4StateManager", "state manager", no_init)
    .def("GetStateManager",    &G4StateManager::GetStateManager,
           "Get an instance of G4StateManager",
         return_value_policy<reference_existing_object>())
    .staticmethod("GetStateManager")
    // ---
    .def("GetCurrentState",    &G4StateManager::GetCurrentState,
         return_value_policy<copy_const_reference>())
    .def("GetPreviousState",   &G4StateManager::GetPreviousState,
         return_value_policy<copy_const_reference>())
    .def("GetStateString",     &G4StateManager::GetStateString)
    ;
}

References G4StateManager::GetCurrentState(), G4StateManager::GetPreviousState(), G4StateManager::GetStateManager(), and G4StateManager::GetStateString().

Referenced by BOOST_PYTHON_MODULE().

export_G4String()

void export_G4String

(

)

Definition at line 47 of file pyG4String.cc.

{
  class_<G4String>("G4String", "string class")
    .def(init<const G4String&>())
    .def(init<const char*>())
    .def(self_ns::str(self))
    .def(self + self)
    .def(self += self)
    .def(self += other<const char*>())
    .def(self == self)
    .def(self == other<const char*>())
    .def(self != self)
    .def(self != other<const char*>())
    ;
  
  implicitly_convertible<G4String, const char*>();
  implicitly_convertible<const char* ,G4String>();
 
  implicitly_convertible<G4String, std::string>();
  implicitly_convertible<std::string ,G4String>();
}

Referenced by BOOST_PYTHON_MODULE().

export_G4ThreeVector()

void export_G4ThreeVector

(

)

Definition at line 98 of file pyG4ThreeVector.cc.

{
  class_<G4ThreeVector>("G4ThreeVector", "general 3-vector")
    // constructors
    .def(init<G4double>())
    .def(init<G4double, G4double>())
    .def(init<G4double, G4double, G4double>())
    .def(init<const XXX&>())
 
    // property
    .add_property("x", &XXX::x, &XXX::setX)
    .add_property("y", &XXX::y, &XXX::setY)
    .add_property("z", &XXX::z, &XXX::setZ)
 
    // methods
    .def("set",      &XXX::set)
    .def("phi",      &XXX::phi)
    .def("mag",      &XXX::mag)
    .def("mag2",     &XXX::mag2)
    .def("setPhi",   &XXX::setPhi)
    .def("setTheta", &XXX::setTheta)
    .def("setMag",   &XXX::setMag)
    .def("setPerp",  &XXX::setPerp)
    .def("setCylTheta", &XXX::setCylTheta)
    .def("howNear",  &XXX::howNear)
    .def("deltaR",   &XXX::deltaR)
    .def("unit",     &XXX::unit)
    .def("orthogonal", &XXX::orthogonal)
    .def("dot",      &XXX::dot)
    .def("cross",    &XXX::cross)
    .def("pseudoRapidity", &XXX::pseudoRapidity)
    .def("setEta",   &XXX::setEta)
    .def("setCylEta",&XXX::setCylEta)
    .def("setRThetaPhi", &XXX::setRThetaPhi)
    .def("setREtaPhi",   &XXX::setREtaPhi)
    .def("setRhoPhiZ",   &XXX::setRhoPhiZ)
    .def("setRhoPhiEta", &XXX::setRhoPhiEta)
    .def("getX",     &XXX::getX)
    .def("getY",     &XXX::getY)
    .def("getZ",     &XXX::getZ)
    .def("getR",     &XXX::getR)
    .def("getTheta", &XXX::getTheta)
    .def("getPhi",   &XXX::getPhi)
    .def("r",        &XXX::r)
    .def("rho",      &XXX::rho)
    .def("getRho",   &XXX::getRho)
    .def("getEta",   &XXX::getEta)
    .def("setR",     &XXX::setR)
    .def("setRho",   &XXX::setRho)
    .def("compare",  &XXX::compare)
    .def("diff2",    &XXX::diff2)
    .def("setTolerance",  &XXX::setTolerance)
    .staticmethod("setTolerance")
    .def("getTolerance",  &XXX::getTolerance)
    .staticmethod("getTolerance")
    .def("isNear",       &XXX::isNear,       f_isNear())
    .def("isParallel",   &XXX::isParallel,   f_isParallel())
    .def("isOrthogonal", &XXX::isOrthogonal, f_isOrthogonal())
    .def("howParallel",   &XXX::howParallel)
    .def("howOrthogonal", &XXX::howOrthogonal)
    .def("beta",     &XXX::beta)
    .def("gamma",    &XXX::gamma)
    .def("deltaPhi", &XXX::deltaPhi)
    .def("coLinearRapidity", &XXX::coLinearRapidity)
    .def("theta",     f1_theta)
    .def("theta",     f2_theta)
    .def("cosTheta",  f1_cosTheta)
    .def("cosTheta",  f2_cosTheta)
    .def("cos2Theta", f1_cos2Theta)
    .def("cos2Theta", f2_cos2Theta)
    .def("perp2",     f1_perp2)
    .def("perp2",     f2_perp2)
    .def("angle",     f1_angle)
    .def("angle",     f2_angle)
    .def("eta",       f1_eta)
    .def("eta",       f2_eta)
    .def("project",   f1_project)
    .def("project",   f2_project)
    .def("perpPart",  f1_perpPart)
    .def("perpPart",  f2_perpPart)
    .def("rapidity",  f1_rapidity)
    .def("rapidity",  f2_rapidity)
    .def("polarAngle",f1_polarAngle)
    .def("polarAngle",f2_polarAngle)
    .def("azimAngle", f1_azimAngle)
    .def("azimAngle", f2_azimAngle)
    .def("rotateX",   &XXX::rotateX,
     return_value_policy<reference_existing_object>())
    .def("rotateY",   &XXX::rotateY,
     return_value_policy<reference_existing_object>())
    .def("rotateZ",   &XXX::rotateZ,
     return_value_policy<reference_existing_object>())
    .def("rotateUz", &XXX::rotateUz,
     return_value_policy<reference_existing_object>())
    .def("transform",&XXX::transform,
     return_value_policy<reference_existing_object>())
    .def("rotate",   f1_rotate,
     return_value_policy<reference_existing_object>())
    .def("rotate",   f2_rotate,
     return_value_policy<reference_existing_object>())
    .def("rotate",   f5_rotate,
     return_value_policy<reference_existing_object>())
 
    // operators
    .def(self_ns::str(self))
    .def(self == self)
    .def(self != self)
    .def(self += self)
    .def(self -= self)
    .def(self -  self)
    .def(self + self)
    .def(self * self)
    .def(self * G4double())
    .def(self / G4double())
    .def(G4double() * self)
    .def(self *= G4double())
    .def(self /= G4double())
    .def(self >  self)
    .def(self <  self)
    .def(self >= self)
    .def(self <= self)
    ;
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, CLHEP::HepRotation::compare(), pyG4ThreeVector::f1_angle, pyG4ThreeVector::f1_azimAngle, pyG4ThreeVector::f1_cos2Theta, pyG4ThreeVector::f1_cosTheta, pyG4ThreeVector::f1_eta, pyG4ThreeVector::f1_perp2, pyG4ThreeVector::f1_perpPart, pyG4ThreeVector::f1_polarAngle, pyG4ThreeVector::f1_project, pyG4ThreeVector::f1_rapidity, pyG4ThreeVector::f1_rotate, pyG4ThreeVector::f1_theta, pyG4ThreeVector::f2_angle, pyG4ThreeVector::f2_azimAngle, pyG4ThreeVector::f2_cos2Theta, pyG4ThreeVector::f2_cosTheta, pyG4ThreeVector::f2_eta, pyG4ThreeVector::f2_perp2, pyG4ThreeVector::f2_perpPart, pyG4ThreeVector::f2_polarAngle, pyG4ThreeVector::f2_project, pyG4ThreeVector::f2_rapidity, pyG4ThreeVector::f2_rotate, pyG4ThreeVector::f2_theta, pyG4ThreeVector::f5_rotate, CLHEP::HepRotation::getPhi(), CLHEP::HepRotation::getTheta(), CLHEP::HepRotation::getTolerance(), CLHEP::HepRotation::howNear(), CLHEP::HepRotation::isNear(), CLHEP::HepRotation::phi(), CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), CLHEP::HepRotation::set(), CLHEP::HepRotation::setPhi(), CLHEP::HepRotation::setTheta(), CLHEP::HepRotation::setTolerance(), and CLHEP::HepRotation::transform().

Referenced by BOOST_PYTHON_MODULE().

export_G4Timer()

void export_G4Timer

(

)

Definition at line 39 of file pyG4Timer.cc.

{
  class_<G4Timer>("G4Timer", "Timer")
    // ---
    .def("Start",            &G4Timer::Start)
    .def("Stop",             &G4Timer::Stop)
    .def("IsValid",          &G4Timer::IsValid)
    .def("GetRealElapsed",   &G4Timer::GetRealElapsed)
    .def("GetSystemElapsed", &G4Timer::GetSystemElapsed)
    .def("GetUserElapsed",   &G4Timer::GetUserElapsed)
    ;
}

References G4Timer::GetRealElapsed(), G4Timer::GetSystemElapsed(), G4Timer::GetUserElapsed(), G4Timer::IsValid(), G4Timer::Start(), and G4Timer::Stop().

Referenced by BOOST_PYTHON_MODULE().

export_G4Transform3D()

void export_G4Transform3D

(

)

Definition at line 43 of file pyG4Transform3D.cc.

{
  class_<G4Transform3D>("G4Transform3D", "geometrical 3D transformation")
    // constructors
    .def(init<const G4RotationMatrix&, const G4ThreeVector&>())
    .def(init<const XXX&>())
 
    // property
    .add_property("xx", &XXX::xx)
    .add_property("xy", &XXX::xy)
    .add_property("xz", &XXX::xz)
    .add_property("yx", &XXX::yx)
    .add_property("yy", &XXX::yy)
    .add_property("yz", &XXX::yz)
    .add_property("zx", &XXX::zx)
    .add_property("zy", &XXX::zy)
    .add_property("zz", &XXX::zz)
    .add_property("dx", &XXX::dx)
    .add_property("dy", &XXX::dy)
    .add_property("dz", &XXX::dz)
    .def_readonly("Identity", &XXX::Identity)
 
    // methods
    .def("inverse",        &XXX::inverse)
    .def("getRotation" ,   &XXX::getRotation)
    .def("getTranslation", &XXX::getTranslation)
 
    // operators
    .def(self == self)
    .def(self != self)
    .def(self *  self)
    ;
}

References CLHEP::HepRotation::inverse(), CLHEP::HepRotation::xx(), CLHEP::HepRotation::xy(), CLHEP::HepRotation::xz(), CLHEP::HepRotation::yx(), CLHEP::HepRotation::yy(), CLHEP::HepRotation::yz(), CLHEP::HepRotation::zx(), CLHEP::HepRotation::zy(), and CLHEP::HepRotation::zz().

Referenced by BOOST_PYTHON_MODULE().

export_G4TwoVector()

void export_G4TwoVector

(

)

Definition at line 56 of file pyG4TwoVector.cc.

{
  class_<G4TwoVector>("G4TwoVector", "general 2-vector")
    // constructors
    .def(init<G4double>())
    .def(init<G4double, G4double>())
    .def(init<const XXX&>())
 
    // property
    .add_property("x", &XXX::x, &XXX::setX)
    .add_property("y", &XXX::y, &XXX::setY)
 
    // methods
    .def("set",      &XXX::set)
    .def("phi",      &XXX::phi)
    .def("mag",      &XXX::mag)
    .def("mag2",     &XXX::mag2)
    .def("r",        &XXX::r)
    .def("setPhi",   &XXX::setPhi)
    .def("setMag",   &XXX::setMag)
    .def("setR",     &XXX::setR)
    .def("setPolar", &XXX::setPolar)
    .def("howNear",  &XXX::howNear)
    .def("isNear",   &XXX::isNear,            f_isNear())
    .def("howParallel",   &XXX::howParallel)
    .def("isParallel",    &XXX::isParallel,   f_isParallel())
    .def("howOrthogonal", &XXX::howOrthogonal)
    .def("isOrthogonal",  &XXX::isOrthogonal, f_isOrthogonal())
    .def("unit",       &XXX::unit)
    .def("orthogonal", &XXX::orthogonal)
    .def("dot",        &XXX::dot)
    .def("angle",      &XXX::angle)
    .def("rotate",     &XXX::rotate)
 
    // operators
    .def(self_ns::str(self))
    .def(self == self)
    .def(self != self)
    .def(self += self)
    .def(self -= self)
    .def(self -  self)
    .def(self + self)
    .def(self * self)
    .def(self * G4double())
    .def(self / G4double())
    .def(G4double() * self)
    .def(self *= G4double())
    .def(self >  self)
    .def(self <  self)
    .def(self >= self)
    .def(self <= self)
    ;
}

References angle, CLHEP::HepRotation::howNear(), CLHEP::HepRotation::isNear(), CLHEP::HepRotation::phi(), CLHEP::HepRotation::rotate(), CLHEP::HepRotation::set(), and CLHEP::HepRotation::setPhi().

Referenced by BOOST_PYTHON_MODULE().

export_G4UnitsTable()

void export_G4UnitsTable

(

)

Definition at line 40 of file pyG4UnitsTable.cc.

{
  class_<G4UnitsTable>("G4UnitsTable", "Units Table")
    .def(vector_indexing_suite<G4UnitsTable>())
    ;
 
  class_<G4UnitsContainer>("G4UnitsContainer", "Units Container")
    .def(vector_indexing_suite<G4UnitsContainer>())
    ;
 
  class_<G4UnitDefinition, boost::noncopyable>
    ("G4UnitDefinition", "Unit Definition", no_init)
    .def(init<const G4String&, const G4String&, const G4String&, G4double>())
    // ---
    .def("GetName",           &G4UnitDefinition::GetName,
     return_value_policy<return_by_value>())
    .def("GetSymbol",         &G4UnitDefinition::GetSymbol,
     return_value_policy<return_by_value>())
    .def("GetValue",          &G4UnitDefinition::GetValue)
    .def("PrintDefinition",   &G4UnitDefinition::PrintDefinition)
    // ---
    .def("BuildUnitsTable",   &G4UnitDefinition::BuildUnitsTable)
    .staticmethod("BuildUnitsTable")
    .def("PrintUnitsTable",   &G4UnitDefinition::PrintUnitsTable)
    .staticmethod("PrintUnitsTable")
    .def("GetUnitsTable",   &G4UnitDefinition::GetUnitsTable,
         return_value_policy<reference_existing_object>())
    .staticmethod("GetUnitsTable")
    // ---
    .def("GetValueOf",          &G4UnitDefinition::GetValueOf)
    .staticmethod("GetValueOf")
    .def("GetCategory",         &G4UnitDefinition::GetCategory)
    .staticmethod("GetCategory")    
    ;
 
  class_<G4UnitsCategory, boost::noncopyable>
    ("G4UnitsCategory", "Units Category", no_init)
     .def(init<const G4String&>())
     // ---
    .def("GetName",           &G4UnitsCategory::GetName,
     return_value_policy<return_by_value>())
    .def("GetUnitsList",      &G4UnitsCategory::GetUnitsList,
         return_value_policy<reference_existing_object>())
    .def("GetNameMxLen",      &G4UnitsCategory::GetNameMxLen)
    .def("GetSymbMxLen",      &G4UnitsCategory::GetSymbMxLen)
    .def("UpdateNameMxLen",   &G4UnitsCategory::UpdateNameMxLen)
    .def("UpdateSymbMxLen",   &G4UnitsCategory::UpdateSymbMxLen)
    .def("PrintCategory",     &G4UnitsCategory::PrintCategory)
    ;
 
  class_<G4BestUnit>("G4BestUnit", "present best unit", no_init)
    .def(init<G4double, const G4String&>())
    .def(init<const G4ThreeVector&, const G4String&>())
    // ---
    .def("GetCategory",        &G4BestUnit::GetCategory,
         return_value_policy<return_by_value>())
    .def("GetIndexOfCategory", &G4BestUnit::GetIndexOfCategory)
    .def(self_ns::str(self))
    ;
 
}

References G4UnitDefinition::BuildUnitsTable(), G4BestUnit::GetCategory(), G4UnitDefinition::GetCategory(), G4BestUnit::GetIndexOfCategory(), G4UnitDefinition::GetName(), G4UnitsCategory::GetName(), G4UnitsCategory::GetNameMxLen(), G4UnitsCategory::GetSymbMxLen(), G4UnitDefinition::GetSymbol(), G4UnitsCategory::GetUnitsList(), G4UnitDefinition::GetUnitsTable(), G4UnitDefinition::GetValue(), G4UnitDefinition::GetValueOf(), G4UnitsCategory::PrintCategory(), G4UnitDefinition::PrintDefinition(), G4UnitDefinition::PrintUnitsTable(), G4UnitsCategory::UpdateNameMxLen(), and G4UnitsCategory::UpdateSymbMxLen().

Referenced by BOOST_PYTHON_MODULE().

export_G4UserLimits()

void export_G4UserLimits

(

)

Definition at line 42 of file pyG4UserLimits.cc.

{
  class_<G4UserLimits, G4UserLimits*>
    ("G4UserLimits", "user step limitations")
    // ---
    .def(init<G4double>())
    .def(init<G4double, G4double>())
    .def(init<G4double, G4double, G4double>())
    .def(init<G4double, G4double, G4double, G4double>())
    .def(init<G4double, G4double, G4double, G4double, G4double>())
    // ---
    .def(init<const G4String&>())
    .def(init<const G4String&, G4double>())
    .def(init<const G4String&, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, G4double>())
    .def(init<const G4String&, G4double, G4double, G4double, 
     G4double, G4double>())
    // ---
    .def("GetUserMaxTrackLength", &G4UserLimits::GetUserMaxTrackLength)
    .def("GetUserMaxTime",        &G4UserLimits::GetUserMaxTime)
    .def("GetUserMinEkine",       &G4UserLimits::GetUserMinEkine)
    .def("GetUserMinRange",       &G4UserLimits::GetUserMinRange)
    // ---
    .def("SetMaxAllowedStep",     &G4UserLimits::SetMaxAllowedStep)
    .def("SetUserMaxTrackLength", &G4UserLimits::SetUserMaxTrackLength)
    .def("SetUserMaxTime",        &G4UserLimits::SetUserMaxTime)
    .def("SetUserMinEkine",       &G4UserLimits::SetUserMinEkine)
    .def("SetUserMinRange",       &G4UserLimits::SetUserMinRange)
    // ---
    .def("GetType",               &G4UserLimits::GetType,
         return_internal_reference<>())
    .def("SetType",               &G4UserLimits::SetType)
    ;
}

References G4UserLimits::GetType(), G4UserLimits::GetUserMaxTime(), G4UserLimits::GetUserMaxTrackLength(), G4UserLimits::GetUserMinEkine(), G4UserLimits::GetUserMinRange(), G4UserLimits::SetMaxAllowedStep(), G4UserLimits::SetType(), G4UserLimits::SetUserMaxTime(), G4UserLimits::SetUserMaxTrackLength(), G4UserLimits::SetUserMinEkine(), and G4UserLimits::SetUserMinRange().

Referenced by BOOST_PYTHON_MODULE().

export_G4Version()

void export_G4Version

(

)

Definition at line 39 of file pyG4Version.cc.

{
  scope current;
  current.attr("G4VERSION_NUMBER")= G4VERSION_NUMBER;
  current.attr("G4Version")= G4Version.c_str();
  current.attr("G4Date")= G4Date.c_str();
}

References G4Date, G4Version, and G4VERSION_NUMBER.

Referenced by BOOST_PYTHON_MODULE().

export_geomdefs()

void export_geomdefs

(

)

Definition at line 39 of file pygeomdefs.cc.

{
 enum_<EAxis>("EAxis")
   .value("kXAxis",     kXAxis)
   .value("kYAxis",     kYAxis)
   .value("kZAxis",     kZAxis)
   .value("kRho",       kRho)
   .value("kRadial3D",  kRadial3D)
   .value("kPhi",       kPhi)
   .value("kUndefined", kUndefined)
   ;
 
 enum_<EInside>("EInside")
   .value("kOutside",   kOutside)
   .value("kSurface",   kSurface)
   .value("kInside",    kInside)
   ;
 
 enum_<EVolume>("EVolume")
   .value("kNormal",        kNormal)
   .value("kReplica",       kReplica)
   .value("kParameterised", kParameterised)
   ;
}

References kInside, kNormal, kOutside, kParameterised, kPhi, kRadial3D, kReplica, kRho, kSurface, kUndefined, kXAxis, kYAxis, and kZAxis.

Referenced by BOOST_PYTHON_MODULE().

export_globals()

void export_globals

(

)

Definition at line 76 of file pyglobals.cc.

{
  def("SetG4PyCoutDestination",    SetG4PyCoutDestination);
  def("ResetG4PyCoutDestination",  ResetG4PyCoutDestination);
 
  class_<G4intVector> ("G4intVector", "int vector")
    .def(vector_indexing_suite<G4intVector>())
    ;
 
  class_<G4doubleVector> ("G4doubleVector", "double vector")
    .def(vector_indexing_suite<G4doubleVector>())
    ;
 
  class_<G4StringVector> ("G4StringVector", "string vector")
    .def(vector_indexing_suite<G4StringVector>())
    ;
 
  class_<G4ThreeVectorVector> ("G4ThreeVectorVector", "3-vector vector")
    .def(vector_indexing_suite<G4ThreeVectorVector>())
    ;
 
  class_<G4TwoVectorVector> ("G4StringVector", "2-vector vector")
    .def(vector_indexing_suite<G4TwoVectorVector>())
    ;
 
}

References pyglobals::ResetG4PyCoutDestination(), and pyglobals::SetG4PyCoutDestination().

Referenced by BOOST_PYTHON_MODULE().

export_RandomEngines()

void export_RandomEngines

(

)

Definition at line 44 of file pyRandomEngines.cc.

{
  class_<HepRandomEngine, boost::noncopyable>
    ("HepRandomEngine", "base class of random engine", no_init)
    ;
 
  class_<HepJamesRandom, bases<HepRandomEngine> >
    ("HepJamesRandom", "HepJames random engine")
    ;
 
  class_<RanecuEngine, bases<HepRandomEngine> >
    ("RanecuEngine", "Ranecu random engine")
    ;
 
  class_<RanluxEngine, bases<HepRandomEngine> >
    ("RanluxEngine", "Ranlux random engine")
    ;
 
  class_<Ranlux64Engine, bases<HepRandomEngine> >
    ("Ranlux64Engine", "Ranlux64 random engine")
    ;
 
}

Referenced by BOOST_PYTHON_MODULE().

export_Randomize()

void export_Randomize

(

)

Definition at line 176 of file pyRandomize.cc.

{
  class_<HepRandom>("HepRandom", "generate random number")
    // ---
    .def(init<long>())
    .def(init<HepRandomEngine&>())
    .def(init<HepRandomEngine*>())
    // ---
    .def("setTheSeed",       f1_setTheSeed)
    .def("setTheSeed",       f2_setTheSeed)
    .staticmethod("setTheSeed")
    .def("getTheSeed",           &HepRandom::getTheSeed)
    .staticmethod("getTheSeed")
    .def("setTheSeeds",      f1_setTheSeeds)
    .def("setTheSeeds",      f2_setTheSeeds)
    .staticmethod("setTheSeeds")
    .def("getTheSeeds",      f_getTheSeeds)
    .staticmethod("getTheSeeds")
    .def("getTheTableSeeds", f_getTheTableSeeds)
    .staticmethod("getTheTableSeeds")
    // ---
    .def("getTheGenerator",     &HepRandom::getTheGenerator,
         return_value_policy<reference_existing_object>())
    .staticmethod("getTheGenerator")
    .def("setTheEngine",        &HepRandom::setTheEngine)
    .staticmethod("setTheEngine")
    .def("getTheEngine",        &HepRandom::getTheEngine,
         return_value_policy<reference_existing_object>())
    .staticmethod("getTheEngine")
    .def("saveEngineStatus",    f1_saveEngineStatus)
    .def("saveEngineStatus",    f2_saveEngineStatus)
    .staticmethod("saveEngineStatus")
    .def("restoreEngineStatus", f1_restoreEngineStatus)
    .def("restoreEngineStatus", f2_restoreEngineStatus)
    .staticmethod("restoreEngineStatus")
    .def("showEngineStatus",    &HepRandom::showEngineStatus)
    .staticmethod("showEngineStatus")
    .def("createInstance",      &HepRandom::createInstance)
    .staticmethod("createInstance")
    ;
 
  // ---
  class_<RandBit, boost::noncopyable>
    ("RandBit", "generate bit random number", no_init)
    .def("shootBit", f1_RandBit_shootBit)
    .staticmethod("shootBit")
    ;
 
  // ---
  class_<G4RandGauss, boost::noncopyable>
    ("G4RandGauss", "generate gaussian random number", no_init)
    .def("shoot", f1_RandGaussQ_shoot)
    .def("shoot", f2_RandGaussQ_shoot)
    .staticmethod("shoot")
    ;
 
  // ---
  def("G4UniformRand", f_G4UniformRand);
 
}

References pyRandomize::f1_RandBit_shootBit(), pyRandomize::f1_RandGaussQ_shoot(), pyRandomize::f1_restoreEngineStatus(), pyRandomize::f1_saveEngineStatus(), pyRandomize::f1_setTheSeed(), pyRandomize::f1_setTheSeeds(), pyRandomize::f2_RandGaussQ_shoot(), pyRandomize::f2_restoreEngineStatus(), pyRandomize::f2_saveEngineStatus(), pyRandomize::f2_setTheSeed(), pyRandomize::f2_setTheSeeds(), pyRandomize::f_G4UniformRand(), pyRandomize::f_getTheSeeds(), and pyRandomize::f_getTheTableSeeds().

Referenced by BOOST_PYTHON_MODULE().