void RegisterBridge_PCL(Registry& reg, string parentGroup)
{
string grp(parentGroup);
grp.append("/pcl");
reg.add_function("PclDebugBarrierEnabled", &PclDebugBarrierEnabled, grp,
"Enabled", "", "Returns the whether debug barriers are enabled.");
reg.add_function("PclDebugBarrierAll", &PclDebugBarrierAll, grp,
"", "", "Synchronizes all parallel processes if the executable"
"has been compiled with PCL_DEBUG_BARRIER=ON");
reg.add_function("NumProcs", &pcl::NumProcs, grp,
"NumProcs", "", "Returns the number of active processes.");
reg.add_function("ProcRank", &pcl::ProcRank, grp,
"ProcRank", "", "Returns the rank of the current process.");
reg.add_function("SynchronizeProcesses", &pcl::SynchronizeProcesses, grp,
"", "", "Waits until all active processes reached this point.");
reg.add_function("AllProcsTrue", &PclAllProcsTrue, grp,
"boolean", "boolean", "Returns true if all processes call the method with true.");
reg.add_function("ParallelMin", &ParallelMin<double>, grp, "tmax", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelMax", &ParallelMax<double>, grp, "tmin", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelSum", &ParallelSum<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelVecMin", &ParallelVecMin<double>, grp, "tmax", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelVecMax", &ParallelVecMax<double>, grp, "tmin", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelVecSum", &ParallelVecSum<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");
}
static void Domain(Registry& reg, string grp)
{
string suffix = GetDomainSuffix<TDomain>();
string tag = GetDomainTag<TDomain>();
#ifdef UG_PARALLEL
{
typedef DomainBalanceWeights<TDomain, AnisotropicBalanceWeights<TDomain::dim> > T;
string name = string("AnisotropicBalanceWeights").append(suffix);
reg.add_class_<T, IBalanceWeights>(name, grp)
.template add_constructor<void (*)(TDomain&)>()
.add_method("set_weight_factor", &T::set_weight_factor)
.add_method("weight_factor", &T::weight_factor)
.set_construct_as_smart_pointer(true);
reg.add_class_to_group(name, "AnisotropicBalanceWeights", tag);
}
{
typedef BalanceWeightsLuaCallback<TDomain> T;
string name = string("BalanceWeightsLuaCallback").append(suffix);
reg.add_class_<T, IBalanceWeights>(name, grp)
.template add_constructor<void (*)(SmartPtr<TDomain> spDom,
const char* luaCallbackName)>()
.add_method("set_time", &T::set_time)
.add_method("time", &T::time)
.set_construct_as_smart_pointer(true);
reg.add_class_to_group(name, "BalanceWeightsLuaCallback", tag);
}
{
string name = string("DomainLoadBalancer").append(suffix);
typedef DomainLoadBalancer<TDomain> T;
typedef LoadBalancer TBase;
reg.add_class_<T, TBase>(name, grp)
.template add_constructor<void (*)(SmartPtr<TDomain>)>("Domain")
.set_construct_as_smart_pointer(true);
reg.add_class_to_group(name, "DomainLoadBalancer", tag);
}
reg.add_function("CreateProcessHierarchy",
static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
size_t, size_t, int,
int)>
(&CreateProcessHierarchy<TDomain>),
grp, "ProcessHierarchy", "Domain, minNumElemsPerProcPerLvl, "
"maxNumRedistProcs, maxNumProcs, minDistLvl, "
"maxLvlsWithoutRedist");
reg.add_function("CreateProcessHierarchy",
static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
size_t, size_t, int,
int, IRefiner*)>
(&CreateProcessHierarchy<TDomain>),
grp, "ProcessHierarchy", "Domain, minNumElemsPerProcPerLvl, "
"maxNumRedistProcs, maxNumProcs, minDistLvl, "
"maxLvlsWithoutRedist, refiner");
#endif
}
void RegisterBridge_PCL(Registry& reg, string parentGroup)
{
string grp(parentGroup);
grp.append("/PCL");
reg.add_function("DisableMPIInit", &DisableMPIInitDUMMY, grp, "", "",
"Tells PCL to not call MPI_Init and MPI_Finalize.");
reg.add_function("PclDebugBarrierEnabled", &PclDebugBarrierEnabledDUMMY, grp,
"Enabled", "", "Returns the whether debug barriers are enabled.");
reg.add_function("PclDebugBarrierAll", &PclDebugBarrierAllDUMMY, grp,
"", "", "Synchronizes all parallel processes if the executable"
"has been compiled with PCL_DEBUG_BARRIER=ON");
reg.add_function("NumProcs", &NumProcsDUMMY, grp,
"NumProcs", "", "Returns the number of active processes.");
reg.add_function("ProcRank", &ProcRankDUMMY, grp,
"ProcRank", "", "Returns the rank of the current process.");
reg.add_function("SynchronizeProcesses", &SynchronizeProcessesDUMMY, grp,
"", "", "Waits until all active processes reached this point.");
reg.add_function("AllProcsTrue", &AllProcsTrueDUMMY, grp,
"boolean", "boolean", "Returns true if all processes call the method with true.");
reg.add_function("ParallelMin", &ParallelMinDUMMY<double>, grp, "tmax", "t", "returns the maximum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelMax", &ParallelMaxDUMMY<double>, grp, "tmin", "t", "returns the minimum of t over all processes. note: you have to assure that all processes call this function.");
reg.add_function("ParallelSum", &ParallelSumDUMMY<double>, grp, "tsum", "t", "returns the sum of t over all processes. note: you have to assure that all processes call this function.");
}
bool RegisterSerializationCommands(Registry ®, const char* parentGroup)
{
stringstream grpSS; grpSS << parentGroup << "/Serialization";
std::string grp = grpSS.str();
try
{
// reg.add_function("LuaList_writeObjects", &LuaList_writeObjects, grp.c_str());
reg.add_function("LuaWrite", &LuaWrite, grp.c_str());
reg.add_function("LuaWriteCout", &LuaWriteCout, grp.c_str());
}
UG_REGISTRY_CATCH_THROW(grp);
return true;
}
void RegisterGridBridge_FileIO(Registry& reg, string parentGroup)
{
string grp = parentGroup;
// UGXFileInfo
reg.add_class_<UGXFileInfo>("UGXFileInfo", grp)
.add_constructor()
.add_method("parse_file", &UGXFileInfo::parse_file, "", "filename")
.add_method("num_grids", &UGXFileInfo::num_grids)
.add_method("num_subset_handlers", &UGXFileInfo::num_subset_handlers)
.add_method("num_subsets", &UGXFileInfo::num_subsets)
.add_method("grid_name", &UGXFileInfo::grid_name, "grid name", "gridInd")
.add_method("subset_handler_name", &UGXFileInfo::subset_handler_name, "", "gridInd#shInd")
.add_method("subset_name", &UGXFileInfo::subset_name, "", "gridInd#shInd#subsetInd")
.add_method("grid_has_volumes", &UGXFileInfo::grid_has_volumes, "", "gridInd")
.add_method("grid_has_faces", &UGXFileInfo::grid_has_faces, "", "gridInd")
.add_method("grid_has_edges", &UGXFileInfo::grid_has_edges, "", "gridInd")
.add_method("grid_has_vertices", &UGXFileInfo::grid_has_vertices, "", "gridInd")
.add_method("physical_grid_dimension", &UGXFileInfo::physical_grid_dimension, "", "gridInd")
.add_method("topological_grid_dimension", &UGXFileInfo::topological_grid_dimension, "", "gridInd")
.add_method("grid_world_dimension", &UGXFileInfo::grid_world_dimension, "", "gridInd")
.set_construct_as_smart_pointer(true);
// GridObject functions
reg.add_function("LoadGrid", static_cast<bool (*)(Grid&, ISubsetHandler&, const char*)>(&LoadGrid), grp,
"", "grid#sh#filename")
.add_function("LoadGrid", static_cast<bool (*)(Grid&, const char*)>(&LoadGrid), grp,
"", "grid#filename")
.add_function("SaveGrid", static_cast<bool (*)(Grid&, const ISubsetHandler&, const char*)>(&SaveGrid), grp,
"", "grid#sh#filename")
.add_function("SaveGrid", static_cast<bool (*)(Grid&, ISubsetHandler&, const char*)>(&SaveGrid), grp,
"", "grid#sh#filename")
.add_function("SaveGrid", static_cast<bool (*)(Grid&, const char*)>(&SaveGrid), grp,
"", "grid#filename")
// .add_function("LoadGridObject", &LoadGridObject, grp,
// "", "go#filename")
// .add_function("SaveGridObject", &SaveGridObject, grp,
// "", "go#filename")
.add_function("SaveGridHierarchy", &SaveGridHierarchy, grp,
"", "mg#filename")
.add_function("SaveGridHierarchyTransformed",
static_cast<bool (*)(MultiGrid&, ISubsetHandler&, const char*, number)>(
&SaveGridHierarchyTransformed),
grp, "", "mg#sh#filename#offset")
.add_function("SaveGridHierarchyTransformed",
static_cast<bool (*)(MultiGrid&, const char*, number)>(
&SaveGridHierarchyTransformed),
grp, "", "mg#filename#offset")
.add_function("SaveParallelGridLayout", &SaveParallelGridLayout,
grp, "", "mg#filename#offset")
.add_function("SaveSurfaceViewTransformed", &SaveSurfaceViewTransformed);
}
void RegisterStandardBridges(Registry& reg, string parentGroup)
{
try
{
// uncomment this to register test-methods
//RegisterBridge_Test(reg, parentGroup);
RegisterBridge_VecMath(reg, parentGroup);
RegisterBridge_Util(reg, parentGroup);
RegisterBridge_PCL(reg, parentGroup);
RegisterBridge_Profiler(reg, parentGroup);
RegisterBridge_Misc(reg, parentGroup);
RegisterBridge_Raster(reg, parentGroup);
RegisterBridge_OrthoPoly(reg, parentGroup);
#ifdef UG_GRID
RegisterBridge_Grid(reg, parentGroup);
#endif
#ifdef UG_ALGEBRA
RegisterBridge_Selection(reg, parentGroup);
RegisterBridge_Domain(reg, parentGroup);
RegisterBridge_PeriodicBoundary(reg, parentGroup);
RegisterBridge_Refinement(reg, parentGroup);
RegisterBridge_DomainRayTracing(reg, parentGroup);
RegisterBridge_Transform(reg, parentGroup);
RegisterBridge_LoadBalancing(reg, parentGroup);
// depends on lib_disc
RegisterBridge_DiscCommon(reg, parentGroup);
RegisterBridge_ElemDiscs(reg, parentGroup);
// depends on lib_algebra
RegisterBridge_AlgebraCommon(reg, parentGroup);
RegisterBridge_Preconditioner(reg, parentGroup);
RegisterBridge_Schur(reg, parentGroup);
RegisterBridge_Obstacle(reg, parentGroup);
RegisterBridge_PILUT(reg, parentGroup);
RegisterBridge_Solver(reg, parentGroup);
RegisterBridge_Eigensolver(reg, parentGroup);
RegisterBridge_DomainDependentPreconditioner(reg, parentGroup);
//RegisterBridge_ConstrainedLinearIterator(reg, parentGroup);
RegisterBridge_Restart(reg, parentGroup);
// depends on lib_disc
RegisterBridge_DiscAlgebra(reg, parentGroup);
RegisterBridge_DomainDisc(reg, parentGroup);
RegisterBridge_GridFunction(reg, parentGroup);
RegisterBridge_Interpolate(reg, parentGroup);
RegisterBridge_Evaluate(reg, parentGroup);
RegisterBridge_MaxError(reg, parentGroup);
RegisterBridge_Ordering(reg, parentGroup);
RegisterBridge_UserData(reg, parentGroup);
RegisterBridge_Constraints(reg, parentGroup);
RegisterBridge_MultiGrid(reg, parentGroup);
RegisterBridge_Output(reg, parentGroup);
RegisterBridge_AdaptiveTools(reg, parentGroup);
RegisterBridge_FiniteVolume(reg, parentGroup);
RegisterBridge_Integrate(reg, parentGroup);
RegisterBridge_ManifoldUtil(reg, parentGroup);
RegisterBridge_ReferenceMappingTest(reg, parentGroup);
#endif
// build a string with all compiled dimensions
stringstream availDims; bool first = true;
#ifdef UG_DIM_1
if(!first) {availDims << ",";}; availDims << "1";
first = false;
#endif
#ifdef UG_DIM_2
if(!first) {availDims << ",";}; availDims << "2";
first = false;
#endif
#ifdef UG_DIM_3
if(!first) {availDims << ",";}; availDims << "3";
first = false;
#endif
#ifdef UG_ALGEBRA
reg.add_function("InitUG", static_cast<void (*)(int, const AlgebraType&, bool)>(&InitUG), "/ug4/Init",
"", string("Dimension|selection|value=[").append(availDims.str()).
append("]#AlgebraType#verbose"));
reg.add_function("InitUG", static_cast<void (*)(int, const AlgebraType&)>(&InitUG), "/ug4/Init",
"", string("Dimension|selection|value=[").append(availDims.str()).
append("]#AlgebraType"));
reg.add_function("GetUGDim", &GetUGDim, "/ug4", "dimension", "", "Returns the dimension to which UG was initialized.");
// AlgebraType Interface
reg.add_class_<AlgebraType>("AlgebraType", "/ug4/Init")
.add_constructor<void (*)(const char*, int)>("Type|selection|value=[\"CPU\"]#Blocksize|selection|value=[1,2,3,4]")
.add_constructor<void (*)(const char*)>("Type|selection|value=[\"CPU\"]", "Variable Blocksize")
.set_construct_as_smart_pointer(true);
#endif
}
UG_REGISTRY_CATCH_THROW("RegisterStandardInterfaces")
UG_CATCH_THROW("RegisterStandardInterfaces failed.")
reg.registry_changed();
}
void RegisterGridBridge_Grid(Registry& reg, string parentGroup)
{
string grp = parentGroup;
// Geometric Objects
reg.add_class_<GridObject>("GridObject", grp);
reg.add_class_<Vertex, GridObject>("Vertex", grp);
reg.add_class_<Edge, GridObject>("Edge", grp)
.add_method("num_vertices", &Edge::num_vertices, grp)
.add_method("vertex", &Edge::vertex, grp);
reg.add_class_<Face, GridObject>("Face", grp)
.add_method("num_vertices", &Face::num_vertices, grp)
.add_method("vertex", &Face::vertex, grp);
reg.add_class_<Volume, GridObject>("Volume", grp)
.add_method("num_vertices", &Volume::num_vertices, grp)
.add_method("vertex", &Volume::vertex, grp);
reg.add_function("IsValid", &IsValidPtr<Vertex>, grp);
reg.add_function("IsValid", &IsValidPtr<Edge>, grp);
reg.add_function("IsValid", &IsValidPtr<Face>, grp);
reg.add_function("IsValid", &IsValidPtr<Volume>, grp);
// Grid
reg.add_class_<Grid>("Grid", grp)
.add_constructor()
.add_method("clear", static_cast<void (Grid::*)()>(&Grid::clear))
.add_method("clear_geometry", &Grid::clear_geometry)
.add_method("num_vertices", &Grid::num_vertices)
.add_method("num_edges", &Grid::num_edges)
.add_method("num_faces", &Grid::num_faces)
.add_method("num_triangles", &Grid::num<Triangle>)
.add_method("num_quadrilaterals", &Grid::num<Quadrilateral>)
.add_method("num_volumes", &Grid::num_volumes)
.add_method("num_tetrahedrons", &Grid::num<Tetrahedron>)
.add_method("num_pyramids", &Grid::num<Pyramid>)
.add_method("num_prisms", &Grid::num<Prism>)
.add_method("num_hexahedrons", &Grid::num<Hexahedron>)
.add_method("reserve_vertices", &Grid::reserve<Vertex>, "", "num")
.add_method("reserve_edges", &Grid::reserve<Edge>, "", "num")
.add_method("reserve_faces", &Grid::reserve<Face>, "", "num")
.add_method("reserve_volumes", &Grid::reserve<Volume>, "", "num")
.set_construct_as_smart_pointer(true);
// MultiGrid
reg.add_class_<MultiGrid, Grid>("MultiGrid", grp)
.add_constructor()
.add_method("num_levels", &MultiGrid::num_levels)
.add_method("num_vertices", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Vertex>)
.add_method("num_edges", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Edge>)
.add_method("num_faces", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Face>)
.add_method("num_triangles", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Triangle>)
.add_method("num_quadrilaterals", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Quadrilateral>)
.add_method("num_volumes", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Volume>)
.add_method("num_tetrahedrons", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Tetrahedron>)
.add_method("num_pyramids", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Pyramid>)
.add_method("num_prisms", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Prism>)
.add_method("num_hexahedrons", (size_t (MultiGrid::*)(int) const) &MultiGrid::num<Hexahedron>)
.set_construct_as_smart_pointer(true);
// standard attachments
reg.add_class_<AInt>("AInt");
reg.add_class_<ANumber>("ANumber");
reg.add_class_<APosition1>("APosition1");
reg.add_class_<APosition2>("APosition2");
reg.add_class_<APosition3>("APosition3");
// geometry
RegisterGeometry<1>(reg, grp);
RegisterGeometry<2>(reg, grp);
RegisterGeometry<3>(reg, grp);
}
void RegisterGridBridge_Refinement(Registry& reg, string parentGroup)
{
string grp = parentGroup;
reg.add_class_<IRefinementCallback>("IRefinementCallback", grp);
// IRefiner
reg.add_class_<IRefiner>("IRefiner", grp)
.add_method("refine", &IRefiner::refine)
.add_method("coarsen", &IRefiner::coarsen)
.add_method("save_marks_to_file", &IRefiner::save_marks_to_file, "", "filename")
.add_method("set_adjusted_marks_debug_filename", &IRefiner::set_adjusted_marks_debug_filename, "", "filename")
.add_method("mark_neighborhood",
static_cast<void (IRefiner::*)(size_t)>(&IRefiner::mark_neighborhood),
"", "numIterations")
.add_method("clear_marks", &IRefiner::clear_marks)
.add_method("set_refinement_callback", &IRefiner::set_refinement_callback)
.add_method("enable_debugging", &IRefiner::enable_debugging)
.add_method("num_marked_edges", static_cast<size_t (IRefiner::*)()>(&IRefiner::num_marked_edges))
.add_method("num_marked_faces", static_cast<size_t (IRefiner::*)()>(&IRefiner::num_marked_faces))
.add_method("num_marked_volumes", static_cast<size_t (IRefiner::*)()>(&IRefiner::num_marked_volumes))
.add_method("num_marked_elements", static_cast<size_t (IRefiner::*)()>(&IRefiner::num_marked_elements));
// HangingNodeRefiner
reg.add_class_<HangingNodeRefiner_Grid, IRefiner>("HangingNodeRefiner_Grid", grp)
.add_constructor()
.add_method("assign_grid", &HangingNodeRefiner_Grid::assign_grid, "", "g")
.set_construct_as_smart_pointer(true);
reg.add_class_<HangingNodeRefiner_MultiGrid, IRefiner>("HangingNodeRefiner_MultiGrid", grp)
.add_constructor()
.add_method("assign_grid", &HangingNodeRefiner_MultiGrid::assign_grid, "", "mg")
.set_construct_as_smart_pointer(true);
// AdaptiveRegularMGRefiner
reg.add_class_<AdaptiveRegularRefiner_MultiGrid, HangingNodeRefiner_MultiGrid>("AdaptiveRegularRefiner_MultiGrid", grp)
.add_constructor()
.add_method("assign_grid", &AdaptiveRegularRefiner_MultiGrid::assign_grid, "", "mg")
.set_construct_as_smart_pointer(true);
// GlobalMultiGridRefiner
reg.add_class_<GlobalMultiGridRefiner, IRefiner>("GlobalMultiGridRefiner", grp)
.add_constructor()
.add_method("assign_grid", static_cast<void (GlobalMultiGridRefiner::*)(MultiGrid&)>(&GlobalMultiGridRefiner::assign_grid),
"", "mg")
.set_construct_as_smart_pointer(true);
// FracturedMediaRefiner
/*typedef FracturedMediaRefiner<typename TDomain::grid_type,
typename TDomain::position_attachment_type> FracDomRef;
reg.add_class_<FracDomRef, IRefiner>("FracturedMediumRefiner", grp)
.add_constructor()
.add_method("set_aspect_ratio_threshold", &FracDomRef::set_aspect_ratio_threshold);*/
// GlobalFracturedDomainRefiner
{
typedef GlobalFracturedMediaRefiner cls;
reg.add_class_<cls, IRefiner>("GlobalFracturedMediumRefiner", grp)
.add_constructor()
.add_method("assign_grid", static_cast<void (cls::*)(MultiGrid*)>(&cls::assign_grid), "", "g")
.add_method("set_subset_handler", static_cast<void (cls::*)(ISubsetHandler*)>(&cls::set_subset_handler),
"", "sh")
.add_method("mark_as_fracture", &cls::mark_as_fracture, "", "subInd#bIsFracture")
.add_method("is_fracture", &cls::is_fracture, "", "subInd")
.set_construct_as_smart_pointer(true);
}
// parallel refinement
#ifdef UG_PARALLEL
reg.add_class_<ParallelHangingNodeRefiner_MultiGrid, HangingNodeRefiner_MultiGrid>
("ParallelHangingNodeRefiner_MultiGrid", grp)
.add_constructor()
.set_construct_as_smart_pointer(true);
/*Currently not directly usable. For domains, you may use the factory method
* GlobalFracturedDomainRefiner, which automatically creates a
* ParallelGlobalFracturedMediaRefiner, if required.
reg.add_class_<ParallelGlobalFracturedMediaRefiner, GlobalFracturedMediaRefiner>
("ParallelGlobalFracturedMediaRefiner", grp)
.add_constructor()
.set_construct_as_smart_pointer(true);
*/
#endif
// refinement
reg.add_function("TestSubdivision", &TestSubdivision, grp)
.add_function("CreateHierarchy", &CreateHierarchy, grp)
.add_function("CreateSmoothHierarchy", &CreateSmoothHierarchy, grp)
.add_function("CreateSmoothVolumeHierarchy", &CreateSmoothVolumeHierarchy, grp)
.add_function("CreateSemiSmoothHierarchy", &CreateSemiSmoothHierarchy, grp);
// smooth volume subdivision
reg.add_function("ApplySmoothSubdivisionToTopLevel", &ApplySmoothSubdivisionToTopLevel, grp);
reg.add_function("ProjectHierarchyToLimitSubdivisionVolume", &ProjectHierarchyToLimitSubdivisionVolume, grp);
reg.add_function("OctReferenceMappingTest", &OctReferenceMappingTest, grp);
reg.add_function("TetReferenceMappingTest", &TetReferenceMappingTest, grp);
reg.add_function("EdgeReferenceMappingTest", &EdgeReferenceMappingTest, grp);
// register boundary refinement rule switch function for Subdivision Volumes smoothing
reg.add_function("SetBoundaryRefinementRule", &SetBoundaryRefinementRule, grp, "", "bndRefRule",
"Sets the boundary refinement rule used during Subdivision Volumes smoothing. Possible parameters: 'linear', 'subdiv_loop");
}
void RegisterUserDataType(Registry& reg, string grp)
{
string dimSuffix = GetDimensionSuffix<dim>();
string dimTag = GetDimensionTag<dim>();
string type = user_data_traits<TData>::name();
// User"Type"
// NOTE: For better readability this class is named User"Type"
// in vrl and lua. E.g. UserNumber, UserVector, ...
{
typedef UserData<TData, dim> T;
typedef UserDataInfo TBase1;
string name = string("User").append(type).append(dimSuffix);
reg.add_class_<T,TBase1>(name, grp)
.add_method("get_dim", &T::get_dim)
.add_method("type", &T::type);
reg.add_class_to_group(name, string("User").append(type), dimTag);
reg.add_function("PrintUserDataValue", &PrintUserDataValue<TData, dim>,
grp, "", "userData#position#time#subsetIndex",
"Prints the value of the given user data at the given global position at the given time on the given subset.");
}
// CondUser"Type"
// NOTE: For better readability this class is named CondUser"Type"
// in vrl and lua. E.g. CondUserNumber, CondUserVector, ...
{
typedef UserData<TData, dim, bool> T;
typedef UserDataInfo TBase1;
string name = string("CondUser").append(type).append(dimSuffix);
reg.add_class_<T,TBase1>(name, grp);
reg.add_class_to_group(name, string("CondUser").append(type), dimTag);
reg.add_function("PrintUserDataValue", &PrintCondUserDataValue<TData, dim>,
grp, "", "userData#position#time#subsetIndex",
"Prints the value of the given user data at the given global position at the given time on the given subset.");
}
// CplUser"Type"
{
typedef CplUserData<TData, dim> T;
typedef UserData<TData,dim> TBase1;
string name = string("CplUser").append(type).append(dimSuffix);
reg.add_class_<T,TBase1>(name, grp)
.add_method("get_dim", &T::get_dim)
.add_method("type", &T::type);
reg.add_class_to_group(name, string("CplUser").append(type), dimTag);
}
// CondCplUser"Type"
{
typedef CplUserData<TData, dim, bool> T;
typedef UserData<TData,dim,bool> TBase1;
string name = string("CondCplUser").append(type).append(dimSuffix);
reg.add_class_<T,TBase1>(name, grp);
reg.add_class_to_group(name, string("CondCplUser").append(type), dimTag);
}
// DependentUserData"Type"
{
typedef DependentUserData<TData, dim> T;
typedef CplUserData<TData, dim> TBase;
string name = string("DependentUserData").append(type).append(dimSuffix);
reg.add_class_<T, TBase >(name, grp);
reg.add_class_to_group(name, string("DependentUserData").append(type), dimTag);
}
// ScaleAddLinker"Type"
{
typedef ScaleAddLinker<TData, dim, number> T;
typedef DependentUserData<TData, dim> TBase;
string name = string("ScaleAddLinker").append(type).append(dimSuffix);
reg.add_class_<T, TBase>(name, grp)
.add_method("add", static_cast<void (T::*)(SmartPtr<CplUserData<number,dim> > , SmartPtr<CplUserData<TData,dim> >)>(&T::add))
.add_method("add", static_cast<void (T::*)(number , SmartPtr<CplUserData<TData,dim> >)>(&T::add))
.add_method("add", static_cast<void (T::*)(SmartPtr<CplUserData<number,dim> > , number)>(&T::add))
.add_method("add", static_cast<void (T::*)(number,number)>(&T::add))
.add_constructor()
.template add_constructor<void (*)(const ScaleAddLinker<TData, dim, number>&)>()
.set_construct_as_smart_pointer(true);
reg.add_class_to_group(name, string("ScaleAddLinker").append(type), dimTag);
}
}
