def build_clustergeometry(self, idx: List[List[int]],
basis: 'pbem3d.BasisFunction') \
-> 'misc.ClusterGeometry':
csubs = [pylist_to_ptr(sub, c_uint) for sub in idx]
cidx = pylist_to_ptr(csubs, c_uint)
obj = libbem3d.build_bem3d_clustergeometry(self, cidx, basis.value)
return try_wrap(obj, misc.ClusterGeometry)
def fill(self, x: VectorListType, y: VectorListType, nx: VectorListType,
ny: VectorListType, v: 'mat.AMatrix', kernel):
cx = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in x], real)
cy = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in y], real)
cnx = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in nx], real)
cny = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in ny], real)
ckernel = libbem3d.CFuncKernelFunc3d(kernel)
libbem3d.fill_bem3d(self, cx, cy, cnx, cny, v, ckernel)
def finish_gmres(addeval, matrix, b: 'vec.AVector', x: 'vec.AVector',
rhat: 'vec.AVector', q: 'vec.AVector', kk: List[int],
qr: 'mat.AMatrix', tau: 'vec.AVector'):
caddeval = libkrylov.CFuncAddevalT(addeval)
cmatrix = matrix.as_voidp()
ckk = pylist_to_ptr(kk, c_uint)
libkrylov.finish_gmres(caddeval, cmatrix, b, x, rhat, q, ckk, qr, tau)
def fill_integral(self, integral_type: 'pbem3d.IntegralType',
idx: List[int], z: VectorListType, v: 'mat.AMatrix',
kernel):
if integral_type == pbem3d.IntegralType.RowC:
func = libbem3d.fill_row_c_bem3d
elif integral_type == pbem3d.IntegralType.ColC:
func = libbem3d.fill_col_c_bem3d
elif integral_type == pbem3d.IntegralType.RowL:
func = libbem3d.fill_row_l_bem3d
elif integral_type == pbem3d.IntegralType.ColL:
func = libbem3d.fill_col_l_bem3d
cidx = pylist_to_ptr(idx, c_uint)
cz = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in z], real)
ckernel = libbem3d.CFuncKernelFunc3d(kernel)
func(cidx, cz, self, v, ckernel)
def fill_wave(self, x: VectorListType, y: VectorListType,
nx: VectorListType, ny: VectorListType, v: 'mat.AMatrix',
direc: float, kernel):
cx = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in x], real)
cy = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in y], real)
cnx = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in nx], real)
cny = pylist_to_ptr([pylist_to_ptr(list(v), real) for v in ny], real)
cdirec = get_address(direc)
ckernel = libbem3d.CFuncKernelWaveFunc3d(kernel)
libbem3d.fill_wave_bem3d(self, cx, cy, cnx, cny, v, cdirec, ckernel)
def finish_pgmres(addeval, matrix, prcd, pdata, b: 'vec.AVector',
x: 'vec.AVector', rhat: 'vec.AVector', q: 'vec.AVector',
kk: List[int], qr: 'mat.AMatrix', tau: 'vec.AVector'):
caddeval = libkrylov.CFuncAddevalT(addeval)
cmatrix = matrix.as_voidp()
cprcd = libkrylov.CFuncPrcdT(prcd)
cpdata = cast(pdata, c_void_p)
ckk = pylist_to_ptr(kk, c_uint)
libkrylov.finish_pgmres(caddeval, cmatrix, cprcd, cpdata, b, x, rhat, q,
ckk, qr, tau)
def copy(self,
target: 'AMatrix',
trans: bool = False,
*,
pivots: List[int] = None):
if pivots:
cpivots = pylist_to_ptr(pivots, c_uint)
libamatrix.copy_colpiv_amatrix(trans, self, cpivots, target)
else:
libamatrix.copy_amatrix(trans, self, target)
def assemble_lagrange(self, ltype: 'pbem3d.LagrangeType', idx: List[int],
px: 'vec.AVector', py: 'vec.AVector',
pz: 'vec.AVector', v: 'mat.AMatrix'):
if ltype == pbem3d.LagrangeType.Const:
func = libbem3d.assemble_bem3d_lagrange_c_amatrix
elif ltype == pbem3d.LagrangeType.Linear:
func = libbem3d.assemble_bem3d_lagrange_l_amatrix
elif ltype == pbem3d.LagrangeType.DnConst:
func = libbem3d.assemble_bem3d_dn_lagrange_c_amatrix
elif ltype == pbem3d.LagrangeType.DnLinear:
func = libbem3d.assemble_bem3d_dn_lagrange_l_amatrix
cidx = pylist_to_ptr(idx, c_uint)
func(cidx, px, py, pz, self, v)
def assemble_quad(self, quadtype: 'pbem3d.QuadratureType', ridx: List[int],
cidx: List[int], ntrans: bool, n: 'mat.AMatrix', kernel):
if quadtype == pbem3d.QuadratureType.CCNear:
func = libbem3d.assemble_cc_near_bem3d
elif quadtype == pbem3d.QuadratureType.CCFar:
func = libbem3d.assemble_cc_far_bem3d
elif quadtype == pbem3d.QuadratureType.CLNear:
func = libbem3d.assemble_cl_near_bem3d
elif quadtype == pbem3d.QuadratureType.CLFar:
func = libbem3d.assemble_cl_far_bem3d
elif quadtype == pbem3d.QuadratureType.LCNear:
func = libbem3d.assemble_lc_near_bem3d
elif quadtype == pbem3d.QuadratureType.LCFar:
func = libbem3d.assemble_lc_far_bem3d
elif quadtype == pbem3d.QuadratureType.LLNear:
func = libbem3d.assemble_ll_near_bem3d
elif quadtype == pbem3d.QuadratureType.LLFar:
func = libbem3d.assemble_ll_far_bem3d
cridx = pylist_to_ptr(ridx, c_uint)
ccidx = pylist_to_ptr(cidx, c_uint)
ckernel = libbem3d.CFuncKernelFunc3d(kernel)
func(cridx, ccidx, self, ntrans, n, ckernel)
def build_pca(cls, cf: 'misc.ClusterGeometry', size: int, idx: List[int],
clf: int) -> 'Cluster':
cidx = pylist_to_ptr(idx, c_uint)
return cls(libcluster.build_pca_cluster(cf, size, cidx, clf))
def build_regular(cls, cf: 'misc.ClusterGeometry', size: int,
idx: List[int], clf: int, direction: int) -> 'Cluster':
cidx = pylist_to_ptr(idx, c_uint)
obj = libcluster.build_regular_cluster(cf, size, cidx, clf, direction)
return cls(obj)
def new(cls, size: int, idx: List[int], sons: int, dim: int) -> 'Cluster':
cidx = pylist_to_ptr(idx, c_uint)
return cls(libcluster.new_cluster(size, cidx, sons, dim))
def from_list(cls, elems: List[float], rows: int, cols: int) -> 'AMatrix':
assert len(elems) == rows * cols
celems = pylist_to_ptr(elems, field)
obj = libamatrix.new_pointer_amatrix(celems, rows, cols)
return cls(obj, refs=[celems])
def eval_lagrange_wave(self, x: Tuple[float, float, float],
px: 'vec.AVector', py: 'vec.AVector',
pz: 'vec.AVector', direc: float, v: 'mat.AMatrix'):
cx = pylist_to_ptr(list(x), real)
func = libbem3d.assemble_bem3d_lagrange_wave_amatrix
func(cx, px, py, pz, direc, self, v)
def eval_lagrange(self, x: Tuple[float, float, float], px: 'vec.AVector',
py: 'vec.AVector', pz: 'vec.AVector', v: 'mat.AMatrix'):
cx = pylist_to_ptr(list(x), real)
libbem3d.assemble_bem3d_lagrange_amatrix(cx, px, py, pz, self, v)
def build(cls, cf: 'misc.ClusterGeometry', size: int, idx: List[int],
clf: int, mode: 'misc.ClusterMode') -> 'Cluster':
cidx = pylist_to_ptr(idx, c_uint)
return cls(libcluster.build_cluster(cf, size, cidx, clf, mode.value))
def find_direction(self, l: int, alpha: float, d: List[float]) -> int:
cd = pylist_to_ptr(d, real)
return libdcluster.finddirection_leveldir(self, l, alpha, cd)
def scale(self, a: List[float], b: List[float]) -> None:
ca = pylist_to_ptr(a, real)
cb = pylist_to_ptr(b, real)
libsurface3d.scale_surface3d(self, ca, cb)
def build_linear_clustergeometry(self, idx: List[List[int]]) \
-> 'misc.ClusterGeometry':
csubs = [pylist_to_ptr(sub, c_uint) for sub in idx]
cidx = pylist_to_ptr(csubs, c_uint)
obj = libbem3d.build_bem3d_linear_clustergeometry(self, cidx)
return try_wrap(obj, misc.ClusterGeometry)
def translate(self, t: List[float]) -> None:
ct = pylist_to_ptr(t, real)
libsurface3d.translate_surface3d(self, ct)
def from_list(cls, elems: List[float], *, dim: int = -1) -> 'AVector':
cdim = dim if dim != -1 else len(elems)
celems = pylist_to_ptr(elems, field)
obj = libavector.new_pointer_avector(celems, cdim)
return cls(obj, refs=[celems])
def update_point_bbox(self, size: int, idx: List[int]) -> None:
cidx = pylist_to_ptr(idx, c_uint)
libclustergeometry.update_point_bbox_clustergeometry(self, size, cidx)
