pymodG4processes.cc File Reference

#include <boost/python.hpp>

Go to the source code of this file.

Functions
void	export_G4ProcessManager ()
void	export_G4ProcessTable ()
void	export_G4VProcess ()
void	export_G4ProcVector ()
void	export_G4ProcessType ()
void	export_G4EmCalculator ()
void	export_G4LossTableManager ()
void	export_G4ProductionCutsTable ()
void	export_G4VCrossSectionHandler ()
void	export_G4CrossSectionHandler ()
	BOOST_PYTHON_MODULE (G4processes)

Function Documentation

BOOST_PYTHON_MODULE

(

G4processes

)

Definition at line 50 of file pymodG4processes.cc.

References export_G4CrossSectionHandler(), export_G4EmCalculator(), export_G4LossTableManager(), export_G4ProcessManager(), export_G4ProcessTable(), export_G4ProcessType(), export_G4ProcVector(), export_G4ProductionCutsTable(), export_G4VCrossSectionHandler(), and export_G4VProcess().

{
  export_G4ProcessManager();
  export_G4ProcessTable();
  export_G4VProcess();
  export_G4ProcVector();
  export_G4ProcessType();
  export_G4EmCalculator();
  export_G4LossTableManager();
  export_G4ProductionCutsTable();
  export_G4VCrossSectionHandler();
  export_G4CrossSectionHandler();
}

void export_G4CrossSectionHandler

(

)

Definition at line 40 of file pyG4CrossSectionHandler.cc.

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4CrossSectionHandler, bases<G4VCrossSectionHandler>,
    boost::noncopyable>
    ("G4CrossSectionHandler", "cross section handler")
    .def(init<>())
    ;
}

void export_G4EmCalculator

(

)

Definition at line 214 of file pyG4EmCalculator.cc.

References pyG4EmCalculator::f1_ComputeElectronicDEDX, pyG4EmCalculator::f1_ComputeEnergyCutFromRangeCut, pyG4EmCalculator::f1_ComputeMeanFreePath, pyG4EmCalculator::f1_ComputeNuclearDEDX, pyG4EmCalculator::f1_GetCrossSectionPerVolume, pyG4EmCalculator::f1_GetDEDX, pyG4EmCalculator::f1_GetKinEnergy, pyG4EmCalculator::f1_GetRange, pyG4EmCalculator::f2_ComputeCrossSectionPerAtom, pyG4EmCalculator::f2_ComputeCrossSectionPerVolume, pyG4EmCalculator::f2_ComputeDEDX, pyG4EmCalculator::f2_ComputeElectronicDEDX, pyG4EmCalculator::f2_ComputeEnergyCutFromRangeCut, pyG4EmCalculator::f2_ComputeMeanFreePath, pyG4EmCalculator::f2_ComputeNuclearDEDX, pyG4EmCalculator::f2_ComputeTotalDEDX, pyG4EmCalculator::f2_GetCrossSectionPerVolume, pyG4EmCalculator::f2_GetDEDX, pyG4EmCalculator::f2_GetKinEnergy, pyG4EmCalculator::f2_GetMeanFreePath, G4EmCalculator::FindCouple(), G4EmCalculator::FindMaterial(), G4EmCalculator::FindParticle(), G4EmCalculator::FindRegion(), G4EmCalculator::PrintDEDXTable(), G4EmCalculator::PrintInverseRangeTable(), G4EmCalculator::PrintRangeTable(), and G4EmCalculator::SetVerbose().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4EmCalculator, boost::noncopyable>
    ("G4EmCalculator", "Provide access to dE/dx and cross section")
    // ---
    .def("GetDEDX",       f1_GetDEDX,       f_GetDEDX())
    .def("GetDEDX",       f2_GetDEDX,       f_GetDEDX())
    .def("GetRange",      f1_GetRange,      f_GetRange())
    .def("GetRange",      f2_GetDEDX,       f_GetRange())
    .def("GetKinEnergy",  f1_GetKinEnergy,  f_GetKinEnergy())
    .def("GetKinEnergy",  f2_GetKinEnergy,  f_GetKinEnergy())
    .def("GetCrossSectionPerVolume",
     f1_GetCrossSectionPerVolume, f_GetCrossSectionPerVolume())
    .def("GetCrossSectionPerVolume",
     f2_GetCrossSectionPerVolume, f_GetCrossSectionPerVolume())
    .def("GetMeanFreePath",  f1_GetMeanFreePath,  f_GetMeanFreePath())
    .def("GetMeanFreePath",  f2_GetMeanFreePath,  f_GetMeanFreePath())
    // ---
    .def("PrintDEDXTable",         &G4EmCalculator::PrintDEDXTable)
    .def("PrintRangeTable",        &G4EmCalculator::PrintRangeTable)
    .def("PrintInverseRangeTable", &G4EmCalculator::PrintInverseRangeTable)
    // ---
    .def("ComputeDEDX",            f1_ComputeDEDX,  f_ComputeDEDX())
    .def("ComputeDEDX",            f2_ComputeDEDX,  f_ComputeDEDX())
    .def("ComputeNuclearDEDX",     f1_ComputeNuclearDEDX)
    .def("ComputeNuclearDEDX",     f2_ComputeNuclearDEDX)
    .def("ComputeElectronicDEDX",  f1_ComputeElectronicDEDX,
         f_ComputeElectronicDEDX())
    .def("ComputeDEDX",            f2_ComputeElectronicDEDX,
         f_ComputeElectronicDEDX())
    .def("ComputeTotalDEDX",       f1_ComputeTotalDEDX,  f_ComputeTotalDEDX())
    .def("ComputeTotalDEDX",       f2_ComputeTotalDEDX,  f_ComputeTotalDEDX())
    // ---
    .def("ComputeCrossSectionPerVolume",
     f1_ComputeCrossSectionPerVolume, f_ComputeCrossSectionPerVolume())
    .def("ComputeCrossSectionPerVolume",
     f2_ComputeCrossSectionPerVolume, f_ComputeCrossSectionPerVolume())
    .def("ComputeCrossSectionPerAtom",
         f1_ComputeCrossSectionPerAtom, f_ComputeCrossSectionPerAtom())
    .def("ComputeCrossSectionPerAtom",
         f2_ComputeCrossSectionPerAtom, g_ComputeCrossSectionPerAtom())
    .def("ComputeEnergyCutFromRangeCut", f1_ComputeEnergyCutFromRangeCut)
    .def("ComputeEnergyCutFromRangeCut", f2_ComputeEnergyCutFromRangeCut)
    // ---
    .def("ComputeMeanFreePath",
     f1_ComputeMeanFreePath, f_ComputeMeanFreePath())
    .def("ComputeMeanFreePath",
     f2_ComputeMeanFreePath, f_ComputeMeanFreePath())
    // ---
    .def("FindParticle",  &G4EmCalculator::FindParticle,
         return_value_policy<reference_existing_object>())
    .def("FindMaterial",  &G4EmCalculator::FindMaterial,
         return_value_policy<reference_existing_object>())
    .def("FindRegion",    &G4EmCalculator::FindRegion,
         return_value_policy<reference_existing_object>())
    .def("FindCouple",    &G4EmCalculator::FindCouple,
     f_FindCouple()[return_value_policy<reference_existing_object>()])
    // ---
    .def("SetVerbose",    &G4EmCalculator::SetVerbose)
    ;
}

void export_G4LossTableManager

(

)

Definition at line 41 of file pyG4LossTableManager.cc.

References G4LossTableManager::BremsstrahlungTh(), G4LossTableManager::BuildCSDARange(), G4LossTableManager::Instance(), G4LossTableManager::LPMFlag(), G4LossTableManager::SetBremsstrahlungTh(), G4LossTableManager::SetBuildCSDARange(), G4LossTableManager::SetIntegral(), G4LossTableManager::SetLinearLossLimit(), G4LossTableManager::SetLossFluctuations(), G4LossTableManager::SetLPMFlag(), G4LossTableManager::SetMaxEnergy(), G4LossTableManager::SetMaxEnergyForCSDARange(), G4LossTableManager::SetMaxEnergyForMuons(), G4LossTableManager::SetMinEnergy(), G4LossTableManager::SetMinSubRange(), G4LossTableManager::SetRandomStep(), G4LossTableManager::SetStepFunction(), G4LossTableManager::SetSubCutoff(), and G4LossTableManager::SetVerbose().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4LossTableManager, boost::noncopyable>
    ("G4LossTableManager", "energy loss table manager", no_init)
    .def("Instance",    &G4LossTableManager::Instance,
         return_value_policy<reference_existing_object>())
    .staticmethod("Instance")

    // internally used methods are limmitted to be exposed...

    // ----
    .def("SetLossFluctuations",  &G4LossTableManager::SetLossFluctuations)
    .def("SetSubCutoff",         &G4LossTableManager::SetSubCutoff)
    .def("SetIntegral",          &G4LossTableManager::SetIntegral)
    .def("SetRandomStep",        &G4LossTableManager::SetRandomStep)
    .def("SetMinSubRange",       &G4LossTableManager::SetMinSubRange)
    .def("SetMinEnergy",         &G4LossTableManager::SetMinEnergy)
    .def("SetMaxEnergy",         &G4LossTableManager::SetMaxEnergy)

#if G4VERSION_NUMBER >= 810
    .def("SetMaxEnergyForCSDARange", 
         &G4LossTableManager::SetMaxEnergyForCSDARange)
#else
    .def("SetMaxEnergyForPreciseRange", 
         &G4LossTableManager::SetMaxEnergyForPreciseRange)
#endif

    .def("SetMaxEnergyForMuons", &G4LossTableManager::SetMaxEnergyForMuons)

#if G4VERSION_NUMBER >= 810
    .def("SetStepFunction",      &G4LossTableManager::SetStepFunction)
    .def("SetBuildCSDARange",    &G4LossTableManager::SetBuildCSDARange)
    .def("SetLPMFlag",           &G4LossTableManager::SetLPMFlag)
    .def("SetBremsstrahlungTh",  &G4LossTableManager::SetBremsstrahlungTh)
#else
    .def("SetStepLimits",        &G4LossTableManager::SetStepLimits)
    .def("SetBuildPreciseRange", &G4LossTableManager::SetBuildPreciseRange)
#endif
    .def("SetVerbose",           &G4LossTableManager::SetVerbose)

    // ---
#if G4VERSION_NUMBER >= 810
    .def("BuildCSDARange",       &G4LossTableManager::BuildCSDARange)
    .def("LPMFlag",              &G4LossTableManager::LPMFlag)
    .def("BremsstrahlungTh",     &G4LossTableManager::BremsstrahlungTh)

#if G4VERSION_NUMBER <= 830
    .def("SetMscStepLimitation", &G4LossTableManager::SetMscStepLimitation)
    .def("MscFlag",              &G4LossTableManager::MscFlag)
    .def("FacRange",             &G4LossTableManager::FacRange)
#endif

#else
    .def("BuildPreciseRange",    &G4LossTableManager::BuildPreciseRange)
#endif

    // ---
#if G4VERSION_NUMBER == 830
    .def("SetMscLateralDisplacement", 
         &G4LossTableManager::SetMscLateralDisplacement)
    .def("SetSkin",              &G4LossTableManager::SetSkin)
#endif

#if G4VERSION_NUMBER >= 830
    .def("SetLinearLossLimit",   &G4LossTableManager::SetLinearLossLimit)
#endif

    ;

}

void export_G4ProcessManager

(

)

Definition at line 171 of file pyG4ProcessManager.cc.

References G4ProcessManager::AddContinuousProcess(), G4ProcessManager::AddDiscreteProcess(), G4ProcessManager::AddProcess(), G4ProcessManager::AddRestProcess(), G4ProcessManager::DumpInfo(), pyG4ProcessManager::f1_GetProcessActivation, pyG4ProcessManager::f1_SetProcessActivation, pyG4ProcessManager::f2_GetProcessActivation, pyG4ProcessManager::f2_RemoveProcess, pyG4ProcessManager::f2_SetProcessActivation, pyG4ProcessManager::f_GetProcessList(), pyG4ProcessManager::f_GetProcessVector(), G4ProcessManager::GetAlongStepIndex(), G4ProcessManager::GetAtRestIndex(), G4ProcessManager::GetParticleType(), G4ProcessManager::GetPostStepIndex(), G4ProcessManager::GetProcessIndex(), G4ProcessManager::GetProcessListLength(), G4ProcessManager::GetProcessOrdering(), G4ProcessManager::GetProcessVectorIndex(), G4ProcessManager::GetVerboseLevel(), idxAll, idxAlongStep, idxAtRest, idxPostStep, ordDefault, ordInActive, ordLast, G4ProcessManager::SetParticleType(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetVerboseLevel(), and typeDoIt.

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4ProcessManager, G4ProcessManager*, boost::noncopyable>
    ("G4ProcessManager", "process manager class", no_init)
    // ---
    .def("GetProcessList",            f_GetProcessList)
    .def("GetProcessListLength",      &G4ProcessManager::GetProcessListLength)
    .def("GetProcessIndex",           &G4ProcessManager::GetProcessIndex)
    .def("GetProcessVector",          f_GetProcessVector,
                                  g_GetProcessVector())
    .def("GetAtRestProcessVector",    f_GetAtRestProcessVector,
                                  g_GetAtRestProcessVector())
    .def("GetAlongStepProcessVector", f_GetAlongStepProcessVector,
                                  g_GetAlongStepProcessVector())
    .def("GetPostStepProcessVector",  f_GetPostStepProcessVector,
                                  g_GetPostStepProcessVector())
    .def("GetProcessVectorIndex",
     &G4ProcessManager::GetProcessVectorIndex,
     f_GetProcessVectorIndex())
    .def("GetAtRestIndex",            &G4ProcessManager::GetAtRestIndex,
                                  f_GetAtRestIndex())
    .def("GetAlongStepIndex",         &G4ProcessManager::GetAlongStepIndex,
                                  f_GetAlongStepIndex())
    .def("GetPostStepIndex",          &G4ProcessManager::GetPostStepIndex,
                                  f_GetPostStepIndex())
    // ----
    .def("AddProcess",            &G4ProcessManager::AddProcess,
                              f_AddProcess())
    .def("AddRestProcess",        &G4ProcessManager::AddRestProcess,
                              f_AddRestProcess())
    .def("AddDiscreteProcess",    &G4ProcessManager::AddDiscreteProcess,
                              f_AddDiscreteProcess())
    .def("AddContinuousProcess",  &G4ProcessManager::AddContinuousProcess,
                              f_AddContinuousProcess())
    // ---
    .def("GetProcessOrdering",    &G4ProcessManager::GetProcessOrdering)
    .def("SetProcessOrdering",    &G4ProcessManager::SetProcessOrdering,
                                  f_SetProcessOrdering())
    .def("SetProcessOrderingToFirst",
     &G4ProcessManager::SetProcessOrderingToFirst)
    .def("SetProcessOrderingToLast",
     &G4ProcessManager::SetProcessOrderingToLast)
    // ---
    .def("RemoveProcess",         f1_RemoveProcess,
         return_value_policy<reference_existing_object>())
    .def("RemoveProcess",         f2_RemoveProcess,
         return_value_policy<reference_existing_object>())
    // ---
    .def("SetProcessActivation",  f1_SetProcessActivation,
     return_value_policy<reference_existing_object>())
    .def("SetProcessActivation",  f2_SetProcessActivation,
     return_value_policy<reference_existing_object>())
    .def("GetProcessActivation",  f1_GetProcessActivation)
    .def("GetProcessActivation",  f2_GetProcessActivation)
    // ---
    .def("GetParticleType",       &G4ProcessManager::GetParticleType,
         return_internal_reference<>())
    .def("SetParticleType",       &G4ProcessManager::SetParticleType)
    .def("DumpInfo",              &G4ProcessManager::DumpInfo)
    .def("SetVerboseLevel",       &G4ProcessManager::SetVerboseLevel)
    .def("GetVerboseLevel",       &G4ProcessManager::GetVerboseLevel)
    ;

  // enums...
  enum_<G4ProcessVectorTypeIndex>("G4ProcessVectorTypeIndex")
    .value("typeGPIL", typeGPIL)
    .value("typeGPIL", typeDoIt)
    ;

  enum_<G4ProcessVectorDoItIndex>("G4ProcessVectorDoItIndex")
    .value("idxAll",       idxAll)
    .value("idxAtRest",    idxAtRest)
    .value("idxAlongStep", idxAlongStep)
    .value("idxPostStep",  idxPostStep)
    ;

  enum_<G4ProcessVectorOrdering>("G4ProcessVectorOrdering")
    .value("ordInActive", ordInActive)
    .value("ordDefault",  ordDefault)
    .value("ordLast",     ordLast)
    ;
}

void export_G4ProcessTable

(

)

Definition at line 144 of file pyG4ProcessTable.cc.

References G4ProcessTable::DumpInfo(), pyG4ProcessTable::f1_FindProcess, pyG4ProcessTable::f1_FindProcesses(), pyG4ProcessTable::f1_SetProcessActivation, pyG4ProcessTable::f2_FindProcess, pyG4ProcessTable::f2_FindProcesses(), pyG4ProcessTable::f2_SetProcessActivation, pyG4ProcessTable::f3_FindProcess, pyG4ProcessTable::f3_FindProcesses(), pyG4ProcessTable::f3_SetProcessActivation, pyG4ProcessTable::f4_FindProcesses(), pyG4ProcessTable::f4_SetProcessActivation, pyG4ProcessTable::f5_SetProcessActivation, pyG4ProcessTable::f6_SetProcessActivation, pyG4ProcessTable::f7_SetProcessActivation, pyG4ProcessTable::f8_SetProcessActivation, G4ProcessTable::GetNameList(), G4ProcessTable::GetProcessTable(), G4ProcessTable::GetVerboseLevel(), G4ProcessTable::Length(), and G4ProcessTable::SetVerboseLevel().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4ProcessTable, G4ProcessTable*, boost::noncopyable>
    ("G4ProcessTable", "process table")
    // ---
    .def("GetProcessTable",  &G4ProcessTable::GetProcessTable,
         return_value_policy<reference_existing_object>())
    .staticmethod("GetProcessTable")
    .def("Length",               &G4ProcessTable::Length)
    //.def("Insert",             &G4ProcessTable::Insert)  // protected
    //.def("Remove",             &G4ProcessTable::Remove)  // protected
    // ---
    .def("FindProcess",          f1_FindProcess,
         return_value_policy<reference_existing_object>())
    .def("FindProcess",          f2_FindProcess,
         return_value_policy<reference_existing_object>())
    .def("FindProcess",          f3_FindProcess,
         return_value_policy<reference_existing_object>())
    .def("FindProcess",          f3_FindProcess,
         return_value_policy<reference_existing_object>())
    // ---
    .def("FindProcesses",        f1_FindProcesses)
    .def("FindProcesses",        f2_FindProcesses)
    .def("FindProcesses",        f3_FindProcesses)
    .def("FindProcesses",        f4_FindProcesses)
    // ---
    .def("SetProcessActivation", f1_SetProcessActivation)
    .def("SetProcessActivation", f2_SetProcessActivation)
    .def("SetProcessActivation", f3_SetProcessActivation)
    .def("SetProcessActivation", f4_SetProcessActivation)
    .def("SetProcessActivation", f5_SetProcessActivation)
    .def("SetProcessActivation", f6_SetProcessActivation)
    .def("SetProcessActivation", f7_SetProcessActivation)
    .def("SetProcessActivation", f8_SetProcessActivation)
    // ---
    .def("GetNameList",          &G4ProcessTable::GetNameList,
         return_internal_reference<>())
    .def("DumpInfo",             &G4ProcessTable::DumpInfo, f_DumpInfo())
    .def("SetVerboseLevel",      &G4ProcessTable::SetVerboseLevel)
    .def("GetVerboseLevel",      &G4ProcessTable::GetVerboseLevel)
    ;
}

void export_G4ProcessType

(

)

Definition at line 40 of file pyG4ProcessType.cc.

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhotolepton_hadron, fTransportation, and fUserDefined.

Referenced by BOOST_PYTHON_MODULE().

{
 enum_<G4ProcessType>("G4ProcessType")
   .value("fNotDefined",         fNotDefined)
   .value("fTransportation",     fTransportation)
   .value("fElectromagnetic",    fElectromagnetic)
   .value("fOptical",            fOptical)
   .value("fHadronic",           fHadronic)
   .value("fPhotolepton_hadron", fPhotolepton_hadron)
   .value("fDecay",              fDecay)
   .value("fGeneral",            fGeneral)
   .value("fParameterisation",   fParameterisation)
   .value("fUserDefined",        fUserDefined)
   ;
}

void export_G4ProcVector

(

)

Definition at line 49 of file pyG4ProcVector.cc.

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4ProcVector> ("G4ProcVector", "process vector")
    .def(vector_indexing_suite<G4ProcVector>())
    ;
}

void export_G4ProductionCutsTable

(

)

Definition at line 42 of file pyG4ProductionCutsTable.cc.

References G4ProductionCutsTable::ConvertRangeToEnergy(), G4ProductionCutsTable::DumpCouples(), G4ProductionCutsTable::GetHighEdgeEnergy(), G4ProductionCutsTable::GetLowEdgeEnergy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetVerboseLevel(), G4ProductionCutsTable::IsModified(), G4ProductionCutsTable::SetEnergyRange(), and G4ProductionCutsTable::SetVerboseLevel().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4ProductionCutsTable, boost::noncopyable>
    ("G4ProductionCutsTable", "production cuts table", no_init)    
    .def("GetProductionCutsTable", 
         &G4ProductionCutsTable::GetProductionCutsTable,
         return_value_policy<reference_existing_object>())
    .staticmethod("GetProductionCutsTable")

    // internally used methods are limmitted to be exposed...

    // ---
    .def("GetLowEdgeEnergy",   &G4ProductionCutsTable::GetLowEdgeEnergy)
    .def("GetHighEdgeEnergy",  &G4ProductionCutsTable::GetHighEdgeEnergy)
    .def("SetEnergyRange",     &G4ProductionCutsTable::SetEnergyRange)
    .def("DumpCouples",        &G4ProductionCutsTable::DumpCouples)
    .def("IsModified",         &G4ProductionCutsTable::IsModified)
    // ---
#if G4VERSION_NUMBER >= 830
    .def("ConvertRangeToEnergy", &G4ProductionCutsTable::ConvertRangeToEnergy)
#endif
    // ---
    .def("SetVerboseLevel",    &G4ProductionCutsTable::SetVerboseLevel)
    .def("GetVerboseLevel",    &G4ProductionCutsTable::GetVerboseLevel)
    ;
}

void export_G4VCrossSectionHandler

(

)

Definition at line 61 of file pyG4VCrossSectionHandler.cc.

References G4VCrossSectionHandler::Clear(), pyG4VCrossSectionHandler::f1_FindValue, pyG4VCrossSectionHandler::f2_FindValue, G4VCrossSectionHandler::Initialise(), G4VCrossSectionHandler::LoadData(), G4VCrossSectionHandler::LoadShellData(), G4VCrossSectionHandler::PrintData(), G4VCrossSectionHandler::SelectRandomElement(), G4VCrossSectionHandler::SelectRandomShell(), and G4VCrossSectionHandler::ValueForMaterial().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4VCrossSectionHandler, boost::noncopyable>
    ("G4VCrossSectionHandler", "cross section handler", no_init)
    // ---
    .def("Initialise",           &G4VCrossSectionHandler::Initialise,
         f_Initialise())
    .def("SelectRandomElement",  &G4VCrossSectionHandler::SelectRandomElement,
         return_value_policy<reference_existing_object>())
    .def("SelectRandomShell",    &G4VCrossSectionHandler::SelectRandomShell)
    .def("FindValue",            f1_FindValue)
    .def("FindValue",            f2_FindValue)
    .def("ValueForMaterial",     &G4VCrossSectionHandler::ValueForMaterial)
    .def("LoadData",             &G4VCrossSectionHandler::LoadData)
    .def("LoadShellData",        &G4VCrossSectionHandler::LoadShellData)
    .def("PrintData",            &G4VCrossSectionHandler::PrintData)
    .def("Clear",                &G4VCrossSectionHandler::Clear)
    ;
}

void export_G4VProcess

(

)

Definition at line 51 of file pyG4VProcess.cc.

References G4VProcess::BuildPhysicsTable(), G4VProcess::DumpInfo(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetPILfactor(), G4VProcess::GetProcessName(), G4VProcess::GetProcessType(), G4VProcess::GetVerboseLevel(), G4VProcess::IsApplicable(), G4VProcess::PreparePhysicsTable(), G4VProcess::RetrievePhysicsTable(), G4VProcess::SetPILfactor(), G4VProcess::SetVerboseLevel(), and G4VProcess::StorePhysicsTable().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<G4VProcess, G4VProcess*, boost::noncopyable>
    ("G4VProcess", "base class for process", no_init)
    // ---
    // Note that only limited methods are exposed.
    .def("SetPILfactor",         &G4VProcess::SetPILfactor)
    .def("GetPILfactor",         &G4VProcess::GetPILfactor)
    .def("IsApplicable",         &G4VProcess::IsApplicable)
    .def("BuildPhysicsTable",    &G4VProcess::BuildPhysicsTable)
    .def("PreparePhysicsTable",  &G4VProcess::PreparePhysicsTable)
    .def("StorePhysicsTable",    &G4VProcess::StorePhysicsTable)
    .def("RetrievePhysicsTable", &G4VProcess::RetrievePhysicsTable)
    .def("GetPhysicsTableFileName", &G4VProcess::GetPhysicsTableFileName,
         f_GetPhysicsTableFileName()
         [return_value_policy<return_by_value>()])
    .def("GetProcessName",       &G4VProcess::GetProcessName,
         return_value_policy<return_by_value>())
    .def("GetProcessType",       &G4VProcess::GetProcessType)
    .def("DumpInfo",             &G4VProcess::DumpInfo)
    .def("SetVerboseLevel",      &G4VProcess::SetVerboseLevel)
    .def("GetVerboseLevel",      &G4VProcess::GetVerboseLevel)
    ;
}