PyNucleus_nl package

Submodules

PyNucleus_nl.clusterMethodCy module

class PyNucleus_nl.clusterMethodCy.DistributedH2Matrix_globalData(LinearOperator localMat, comm)

Bases: LinearOperator

Distributed H2 matrix, operating on global vectors

__init__(*args, **kwargs)

diagonal

getMemorySize(self)

localMat: localMat: PyNucleus_base.linear_operators.LinearOperator

class PyNucleus_nl.clusterMethodCy.DistributedH2Matrix_localData(H2Matrix localMat, list Pnear, Comm comm, DoFMap dm, DoFMap local_dm, CSR_LinearOperator lclR, CSR_LinearOperator lclP)

Bases: LinearOperator

Distributed H2 matrix, operating on local vectors

Pnear: Pnear: list

__init__(*args, **kwargs)

comm: comm: mpi4py.MPI.Comm

convert(self) → tuple

diagonal

dm: dm: PyNucleus_fem.DoFMaps.DoFMap

lclP: lclP: PyNucleus_base.linear_operators.LinearOperator

lclR: lclR: PyNucleus_base.linear_operators.LinearOperator

lclRoot: lclRoot: PyNucleus_nl.clusterMethodCy.tree_node

lcl_dm: lcl_dm: PyNucleus_fem.DoFMaps.DoFMap

localMat: localMat: PyNucleus_nl.clusterMethodCy.H2Matrix

class PyNucleus_nl.clusterMethodCy.DistributedLinearOperator(CSR_LinearOperator localMat, tree_node tree, list Pnear, Comm comm, DoFMap dm, DoFMap local_dm, CSR_LinearOperator lclR, CSR_LinearOperator lclP)

Bases: LinearOperator

Distributed linear operator, operating on local vectors

Pnear: Pnear: list

__init__(*args, **kwargs)

comm: comm: mpi4py.MPI.Comm

convert(self) → tuple

diagonal

dm: dm: PyNucleus_fem.DoFMaps.DoFMap

getMemorySize(self)

lclP: lclP: PyNucleus_base.linear_operators.LinearOperator

lclR: lclR: PyNucleus_base.linear_operators.LinearOperator

lclRoot: lclRoot: PyNucleus_nl.clusterMethodCy.tree_node

lcl_dm: lcl_dm: PyNucleus_fem.DoFMaps.DoFMap

localMat: localMat: PyNucleus_base.linear_operators.CSR_LinearOperator

tree: tree: PyNucleus_nl.clusterMethodCy.tree_node

class PyNucleus_nl.clusterMethodCy.H2Matrix(tree_node tree, dict Pfar, LinearOperator Anear, FakePLogger PLogger=None)

Bases: LinearOperator

Anear: Anear: PyNucleus_base.linear_operators.LinearOperator

static HDF5read(node, returnPnear=False)

HDF5write(self, node, version=2, Pnear=None)

PLogger: PLogger: PyNucleus_base.performanceLogger.FakePLogger

Pfar: Pfar: dict

__init__(*args, **kwargs)

basis: basis: PyNucleus_base.linear_operators.LinearOperator

cluster_size

compressionRatio

constructBasis(self)

diagonal

getMemorySize(self)

isSparse(self)

leafCoefficientsUp: leafCoefficientsUp: ‘REAL_t[::1]’

nearField_size

num_far_field_cluster_pairs

plot(self, Pnear=[], fill='box', nearFieldColor='red', farFieldColor='blue', kernelApproximationColor='yellow', shiftCoefficientColor='red', rankColor=None)

skip_leaves_upward: skip_leaves_upward: ‘BOOL_t’

toarray(self)

tree: tree: PyNucleus_nl.clusterMethodCy.tree_node

tree_size

class PyNucleus_nl.clusterMethodCy.VectorH2Matrix(tree_node tree, dict Pfar, VectorLinearOperator Anear, FakePLogger PLogger=None)

Bases: VectorLinearOperator

Anear: Anear: PyNucleus_base.linear_operators.VectorLinearOperator

static HDF5read(node, returnPnear=False)

HDF5write(self, node, version=2, Pnear=None)

PLogger: PLogger: PyNucleus_base.performanceLogger.FakePLogger

Pfar: Pfar: dict

__init__(*args, **kwargs)

basis: basis: PyNucleus_base.linear_operators.LinearOperator

cluster_size

constructBasis(self)

diagonal

getMemorySize(self)

isSparse(self)

leafCoefficientsUp: leafCoefficientsUp: ‘REAL_t[::1]’

nearField_size

num_far_field_cluster_pairs

plot(self, Pnear=[], fill='box', nearFieldColor='red', farFieldColor='blue', kernelApproximationColor='yellow', shiftCoefficientColor='red', rankColor=None)

skip_leaves_upward: skip_leaves_upward: ‘BOOL_t’

toarray(self)

tree: tree: PyNucleus_nl.clusterMethodCy.tree_node

tree_size

PyNucleus_nl.clusterMethodCy.assembleFarFieldInteractions(Kernel kernel, dict Pfar, BOOL_t bemMode=False)

PyNucleus_nl.clusterMethodCy.checkNearFarFields(DoFMap dm, list Pnear, dict Pfar) → INDEX_t[:, ::1]

class PyNucleus_nl.clusterMethodCy.exactSphericalIntegral2D(REAL_t[::1] u, P1_DoFMap dm, REAL_t radius)

Bases: function

__init__(*args, **kwargs)

root: root: PyNucleus_nl.clusterMethodCy.tree_node

class PyNucleus_nl.clusterMethodCy.farFieldClusterPair(tree_node n1, tree_node n2)

Bases: object

__init__(*args, **kwargs)

apply(self, REAL_t[::1] x, REAL_t[::1] y) → void

applyTrans(self, REAL_t[::1] x, REAL_t[::1] y) → void

applyVec(self, REAL_t[::1] x, REAL_t[:, ::1] y) → void

applyVecTrans(self, REAL_t[::1] x, REAL_t[:, ::1] y) → void

kernelInterpolant: kernelInterpolant: ‘REAL_t[:, ::1]’

kernelInterpolantVec: kernelInterpolantVec: ‘REAL_t[:, :, ::1]’

n1: n1: PyNucleus_nl.clusterMethodCy.tree_node

n2: n2: PyNucleus_nl.clusterMethodCy.tree_node

plot(self, color='blue')

PyNucleus_nl.clusterMethodCy.getAdmissibleClusters(Kernel kernel, tree_node n1, tree_node n2, dict Pfar=None, list Pnear=None, INDEX_t level=0) → BOOL_t

PyNucleus_nl.clusterMethodCy.getCoveringClusters(Kernel kernel, tree_node n1, tree_node n2, refinementParams refParams, list Pnear=None, INDEX_t level=0) → BOOL_t

PyNucleus_nl.clusterMethodCy.getDoFBoxesAndCells(meshBase mesh, DoFMap dm, comm=None)

PyNucleus_nl.clusterMethodCy.getFractionalOrders(variableFractionalOrder s, meshBase mesh)

class PyNucleus_nl.clusterMethodCy.productIterator(INDEX_t m, INDEX_t dim)

Bases: object

__init__(*args, **kwargs)

PyNucleus_nl.clusterMethodCy.queryAdmissibility(Kernel kernel, tree_node n1, tree_node n2) → admissibilityType

PyNucleus_nl.clusterMethodCy.symmetrizeNearFieldClusters(list Pnear)

class PyNucleus_nl.clusterMethodCy.transferMatrixBuilder(INDEX_t dim)

Bases: object

__init__(*args, **kwargs)

class PyNucleus_nl.clusterMethodCy.tree_node(tree_node parent, indexSet dofs, REAL_t[:, :, ::1] boxes, REAL_t[:, ::1] coords, REAL_t[::1] hVector, refinementParams refParams, bool mixed_node=False, bool canBeAssembled=True, indexSet local_dofs=None)

Bases: object

static HDF5read(node)

static HDF5readNew(node)

HDF5write(self, node)

HDF5writeNew(self, node)

__init__(*args, **kwargs)

box: box: ‘REAL_t[:, ::1]’

boxes: boxes: ‘REAL_t[:, :, ::1]’

canBeAssembled: canBeAssembled: ‘BOOL_t’

cells

children: children: list

coefficientsDown: coefficientsDown: ‘REAL_t[::1]’

coefficientsDownVec: coefficientsDownVec: ‘REAL_t[:, ::1]’

coefficientsUp: coefficientsUp: ‘REAL_t[::1]’

coefficientsUpOffset: coefficientsUpOffset: ‘INDEX_t’

constructBasisMatrix(self, LinearOperator B, REAL_t[::1] coefficientsUp, INDEX_t offset=0)

coords: coords: ‘REAL_t[:, ::1]’

dim: dim: ‘INDEX_t’

distFromRoot: distFromRoot: ‘INDEX_t’

dofs

downwardPass_py(self, REAL_t[::1] y, INDEX_t componentNo=0)

enterLeafValues(self, DoFMap dm, BOOL_t local=False)

enterLeafValuesGrad(self, meshBase mesh, DoFMap dm, REAL_t[:, :, ::1] boxes, comm=None)

findCell(self, meshBase mesh, REAL_t[::1] vertex, REAL_t[:, ::1] simplex, REAL_t[::1] bary) → INDEX_t

findCells(self, meshBase mesh, REAL_t[::1] vertex, REAL_t r, REAL_t[:, ::1] simplex) → set

findNodeForDoF(self, INDEX_t dof)

getMemorySize(self)

getNumLeavesOnLevel(self, INDEX_t level)

getNumNodesOnLevel(self, INDEX_t level)

getParent(self, INDEX_t parentLevel=0)

get_irregularLevelsOffset(self)

get_is_leaf_py(self)

get_max_id(self)

get_nodes(self)

get_tree_nodes(self)

get_tree_nodes_on_level(self, INDEX_t level)

get_tree_nodes_up_to_level(self, INDEX_t level)

hVector: hVector: ‘REAL_t[::1]’

hmin: hmin: ‘REAL_t’

id: id: ‘INDEX_t’

idsAreUnique(self, bitArray used=None)

interpolation_order: interpolation_order: ‘INDEX_t’

property irregularLevelsOffset: tree_node.get_irregularLevelsOffset(self)

property isLeaf: tree_node.get_is_leaf_py(self)

leaves(self)

levelNo: levelNo: ‘INDEX_t’

local_dofs

mixed_node: mixed_node: ‘BOOL_t’

property nodes: tree_node.get_nodes(self)

property numLevels: tree_node._getLevels_py(self)

num_dofs

parent: parent: PyNucleus_nl.clusterMethodCy.tree_node

partition(self, DoFMap dm, Comm comm, BOOL_t canBeAssembled, BOOL_t mixed_node, dict params={})

plot(self, level=0, plotType='box', DoFMap dm=None, BOOL_t recurse=False, BOOL_t printClusterIds=False, BOOL_t printNumDoFs=False, transferOperatorColor='purple', coefficientsColor='red', horizontal=True, levelSkip=1, skip_angle=0.)

prepareTransferOperators_py(self, INDEX_t valueSize)

refParams: refParams: ‘refinementParams’

refine(self, BOOL_t recursive=True)

relabelDoFs(self, INDEX_t[::1] translate) → void

resetCoefficientsDown_py(self, BOOL_t vecValued=False)

resetCoefficientsUp_py(self)

secondary_dofs: secondary_dofs: PyNucleus_base.tupleDict.indexSet

set_id(self, INDEX_t maxID=0, INDEX_t distFromRoot=0)

set_irregularLevelsOffset(self, INDEX_t irregularLevelsOffset)

transferOperator: transferOperator: ‘REAL_t[:, ::1]’

upwardPass_py(self, REAL_t[::1] x, INDEX_t componentNo=0, BOOL_t skip_leaves=False)

value: value: ‘REAL_t[:, :, ::1]’

PyNucleus_nl.clusterMethodCy.trimTree(tree_node tree, list Pnear, dict Pfar, comm, keep=[])

PyNucleus_nl.config module

PyNucleus_nl.fractionalLaplacian1D module

class PyNucleus_nl.fractionalLaplacian1D.fractionalLaplacian1D(Kernel kernel, meshBase mesh, DoFMap dm, quad_order_diagonal=None, target_order=None, num_dofs=None, **kwargs)

Bases: nonlocalLaplacian1D

The local stiffness matrix

\[\int_{K_1}\int_{K_2} (u(x)-u(y)) (v(x)-v(y)) \gamma(x,y) dy dx\]

for the symmetric 1D nonlocal Laplacian.

__init__(*args, **kwargs)

qrId: qrId: PyNucleus_fem.quadrature.quadratureRule

qrVertex: qrVertex: PyNucleus_fem.quadrature.quadratureRule

setKernel(self, Kernel kernel, quad_order_diagonal=None, target_order=None) → void

class PyNucleus_nl.fractionalLaplacian1D.fractionalLaplacian1DZeroExterior(Kernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, **kwargs)

Bases: nonlocalLaplacian1D

PHI_dist: PHI_dist: ‘REAL_t[:, ::1]’

PHI_sep: PHI_sep: ‘REAL_t[:, ::1]’

PHI_vertex: PHI_vertex: ‘REAL_t[:, ::1]’

__init__(*args, **kwargs)

qrVertex: qrVertex: PyNucleus_fem.quadrature.quadratureRule

class PyNucleus_nl.fractionalLaplacian1D.fractionalLaplacian1D_boundary(Kernel kernel, meshBase mesh, DoFMap dm, quad_order_diagonal=None, target_order=None, num_dofs=None, **kwargs)

Bases: fractionalLaplacian1DZeroExterior

The local stiffness matrix

\[\int_{K}\int_{e} [ u(x) v(x) n_{y} \cdot \frac{x-y}{|x-y|} \Gamma(x,y) dy dx\]

for the 1D nonlocal Laplacian.

__init__(*args, **kwargs)

setKernel(self, Kernel kernel, quad_order_diagonal=None, target_order=None) → void

class PyNucleus_nl.fractionalLaplacian1D.fractionalLaplacian1D_nonsym(Kernel kernel, meshBase mesh, DoFMap dm, target_order=None, quad_order_diagonal=None, num_dofs=None, **kwargs)

Bases: fractionalLaplacian1D

The local stiffness matrix

\[\int_{K_1}\int_{K_2} [ u(x) \gamma(x,y) - u(y) \gamma(y,x) ] [ v(x)-v(y) ] dy dx\]

for the non-symmetric 1D nonlocal Laplacian.

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalLaplacian1D.singularityCancelationQuadRule1D(panelType panel, REAL_t singularity, INDEX_t quad_order_diagonal, INDEX_t quad_order_regular)

Bases: quadratureRule

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalLaplacian1D.singularityCancelationQuadRule1D_boundary(panelType panel, REAL_t singularity, INDEX_t quad_order_diagonal, INDEX_t quad_order_regular)

Bases: quadratureRule

__init__(*args, **kwargs)

PyNucleus_nl.fractionalLaplacian2D module

class PyNucleus_nl.fractionalLaplacian2D.fractionalLaplacian2D(Kernel kernel, meshBase mesh, DoFMap dm, target_order=None, quad_order_diagonal=None, num_dofs=None, **kwargs)

Bases: nonlocalLaplacian2D

The local stiffness matrix

\[\int_{K_1}\int_{K_2} (u(x)-u(y)) (v(x)-v(y)) \gamma(x,y) dy dx\]

for the symmetric 2D nonlocal Laplacian.

PSI_edge: PSI_edge: ‘REAL_t[:, ::1]’

PSI_id: PSI_id: ‘REAL_t[:, ::1]’

PSI_vertex: PSI_vertex: ‘REAL_t[:, ::1]’

__init__(*args, **kwargs)

qrEdge: qrEdge: PyNucleus_fem.quadrature.quadratureRule

qrId: qrId: PyNucleus_fem.quadrature.quadratureRule

qrVertex: qrVertex: PyNucleus_fem.quadrature.quadratureRule

setKernel(self, Kernel kernel, quad_order_diagonal=None, target_order=None) → void

class PyNucleus_nl.fractionalLaplacian2D.fractionalLaplacian2DZeroExterior(Kernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, **kwargs)

Bases: nonlocalLaplacian2D

PHI_edge: PHI_edge: ‘REAL_t[:, :, ::1]’

PHI_edge2: PHI_edge2: ‘REAL_t[:, ::1]’

PHI_vertex: PHI_vertex: ‘REAL_t[:, :, ::1]’

PHI_vertex2: PHI_vertex2: ‘REAL_t[:, ::1]’

PSI_edge: PSI_edge: ‘REAL_t[:, :, ::1]’

PSI_vertex: PSI_vertex: ‘REAL_t[:, :, ::1]’

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalLaplacian2D.fractionalLaplacian2D_boundary(Kernel kernel, meshBase mesh, DoFMap dm, target_order=None, quad_order_diagonal=None, num_dofs=None, **kwargs)

Bases: fractionalLaplacian2DZeroExterior

The local stiffness matrix

\[\int_{K}\int_{e} [ u(x) v(x) n_{y} \cdot \frac{x-y}{|x-y|} \Gamma(x,y) dy dx\]

for the 2D nonlocal Laplacian.

__init__(*args, **kwargs)

qrEdge: qrEdge: PyNucleus_fem.quadrature.quadratureRule

qrVertex: qrVertex: PyNucleus_fem.quadrature.quadratureRule

qrVertex0: qrVertex0: PyNucleus_fem.quadrature.quadQuadratureRule

qrVertex1: qrVertex1: PyNucleus_fem.quadrature.quadQuadratureRule

setKernel(self, Kernel kernel, quad_order_diagonal=None, target_order=None) → void

class PyNucleus_nl.fractionalLaplacian2D.fractionalLaplacian2D_nonsym(Kernel kernel, meshBase mesh, DoFMap dm, target_order=None, quad_order_diagonal=None, num_dofs=None, **kwargs)

Bases: fractionalLaplacian2D

The local stiffness matrix

\[\int_{K_1}\int_{K_2} [ u(x) \gamma(x,y) - u(y) \gamma(y,x) ] [ v(x)-v(y) ] dy dx\]

for the 2D non-symmetric nonlocal Laplacian.

PHI_edge: PHI_edge: ‘REAL_t[:, :, ::1]’

PHI_id: PHI_id: ‘REAL_t[:, :, ::1]’

PHI_vertex: PHI_vertex: ‘REAL_t[:, :, ::1]’

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalLaplacian2D.singularityCancelationQuadRule2D(panelType panel, REAL_t singularity, INDEX_t quad_order_diagonal, INDEX_t quad_order_diagonalV, INDEX_t quad_order_regular)

Bases: quadratureRule

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalLaplacian2D.singularityCancelationQuadRule2D_boundary(panelType panel, REAL_t singularity, INDEX_t quad_order_diagonal, INDEX_t quad_order_regular)

Bases: quadratureRule

__init__(*args, **kwargs)

PyNucleus_nl.twoPointFunctions module

Defines the base class for functions of two spatial variables, e.g. kernels, fractional orders and normalizations.

class PyNucleus_nl.twoPointFunctions.ComplexconstantTwoPoint(double complex value)

Bases: ComplextwoPointFunction

__init__(*args, **kwargs)

getLongDescription(self)

value: value: ‘double complex’

class PyNucleus_nl.twoPointFunctions.ComplexfixedTwoPointFunction(ComplextwoPointFunction f, REAL_t[::1] point, fixed_type fixedType)

Bases: complexFunction

__init__(*args, **kwargs)

class PyNucleus_nl.twoPointFunctions.ComplexlookupTwoPoint(DoFMap dm, double complex[:, ::1] A, BOOL_t symmetric, cellFinder2 cF=None)

Bases: ComplextwoPointFunction

__init__(*args, **kwargs)

dm: dm: PyNucleus_fem.DoFMaps.DoFMap

class PyNucleus_nl.twoPointFunctions.ComplexparametrizedTwoPointFunction(BOOL_t symmetric, INDEX_t valueSize)

Bases: ComplextwoPointFunction

__init__(*args, **kwargs)

getParamPtrAddr(self)

class PyNucleus_nl.twoPointFunctions.ComplexproductParametrizedTwoPoint(ComplextwoPointFunction f1, ComplextwoPointFunction f2)

Bases: ComplexparametrizedTwoPointFunction

__init__(*args, **kwargs)

f1: f1: PyNucleus_nl.twoPointFunctions.ComplextwoPointFunction

f2: f2: PyNucleus_nl.twoPointFunctions.ComplextwoPointFunction

class PyNucleus_nl.twoPointFunctions.ComplexproductTwoPoint(ComplextwoPointFunction f1, ComplextwoPointFunction f2)

Bases: ComplextwoPointFunction

__init__(*args, **kwargs)

f1: f1: PyNucleus_nl.twoPointFunctions.ComplextwoPointFunction

f2: f2: PyNucleus_nl.twoPointFunctions.ComplextwoPointFunction

class PyNucleus_nl.twoPointFunctions.ComplextwoPointFunction(BOOL_t symmetric, INDEX_t valueSize)

Bases: object

__call__(*args, **kwargs): Call self as a function.

__init__(*args, **kwargs)

diagonal(self)

fixedX(self, REAL_t[::1] x)

fixedY(self, REAL_t[::1] y)

getLongDescription(self)

plot(self, mesh, **kwargs)

symmetric: symmetric: ‘BOOL_t’

valueSize: valueSize: ‘INDEX_t’

class PyNucleus_nl.twoPointFunctions.constantTwoPoint(REAL_t value)

Bases: twoPointFunction

__init__(*args, **kwargs)

getLongDescription(self)

value: value: ‘REAL_t’

class PyNucleus_nl.twoPointFunctions.fixedTwoPointFunction(twoPointFunction f, REAL_t[::1] point, fixed_type fixedType)

Bases: function

__init__(*args, **kwargs)

class PyNucleus_nl.twoPointFunctions.interfaceTwoPoint(REAL_t horizon1, REAL_t horizon2, BOOL_t left, REAL_t interface=0.)

Bases: twoPointFunction

__init__(*args, **kwargs)

horizon1: horizon1: ‘REAL_t’

horizon2: horizon2: ‘REAL_t’

interface: interface: ‘REAL_t’

left: left: ‘BOOL_t’

class PyNucleus_nl.twoPointFunctions.inverseTwoPoint(twoPointFunction f)

Bases: twoPointFunction

__init__(*args, **kwargs)

class PyNucleus_nl.twoPointFunctions.lambdaTwoPoint(fun, BOOL_t symmetric)

Bases: twoPointFunction

__init__(*args, **kwargs)

class PyNucleus_nl.twoPointFunctions.leftRightTwoPoint(REAL_t ll, REAL_t rr, REAL_t lr=np.nan, REAL_t rl=np.nan, REAL_t interface=0.)

Bases: twoPointFunction

__init__(*args, **kwargs)

interface: interface: ‘REAL_t’

ll: ll: ‘REAL_t’

lr: lr: ‘REAL_t’

rl: rl: ‘REAL_t’

rr: rr: ‘REAL_t’

class PyNucleus_nl.twoPointFunctions.lookupTwoPoint(DoFMap dm, REAL_t[:, ::1] A, BOOL_t symmetric, cellFinder2 cF=None)

Bases: twoPointFunction

__init__(*args, **kwargs)

dm: dm: PyNucleus_fem.DoFMaps.DoFMap

class PyNucleus_nl.twoPointFunctions.matrixTwoPoint(REAL_t[:, ::1] mat)

Bases: twoPointFunction

__init__(*args, **kwargs)

mat: mat: ‘REAL_t[:, ::1]’

class PyNucleus_nl.twoPointFunctions.parametrizedTwoPointFunction(BOOL_t symmetric, INDEX_t valueSize)

Bases: twoPointFunction

__init__(*args, **kwargs)

getParamPtrAddr(self)

class PyNucleus_nl.twoPointFunctions.productParametrizedTwoPoint(twoPointFunction f1, twoPointFunction f2)

Bases: parametrizedTwoPointFunction

__init__(*args, **kwargs)

f1: f1: PyNucleus_nl.twoPointFunctions.twoPointFunction

f2: f2: PyNucleus_nl.twoPointFunctions.twoPointFunction

class PyNucleus_nl.twoPointFunctions.productTwoPoint(twoPointFunction f1, twoPointFunction f2)

Bases: twoPointFunction

__init__(*args, **kwargs)

f1: f1: PyNucleus_nl.twoPointFunctions.twoPointFunction

f2: f2: PyNucleus_nl.twoPointFunctions.twoPointFunction

class PyNucleus_nl.twoPointFunctions.smoothedLeftRightTwoPoint(REAL_t vl, REAL_t vr, REAL_t r=0.1, REAL_t slope=200.)

Bases: twoPointFunction

__init__(*args, **kwargs)

fac: fac: ‘REAL_t’

r: r: ‘REAL_t’

slope: slope: ‘REAL_t’

vl: vl: ‘REAL_t’

vr: vr: ‘REAL_t’

class PyNucleus_nl.twoPointFunctions.temperedTwoPoint(REAL_t lambdaCoeff, INDEX_t dim)

Bases: twoPointFunction

__init__(*args, **kwargs)

dim: dim: ‘INDEX_t’

lambdaCoeff: lambdaCoeff: ‘REAL_t’

class PyNucleus_nl.twoPointFunctions.tensorTwoPoint(INDEX_t i, INDEX_t j, INDEX_t dim)

Bases: twoPointFunction

__init__(*args, **kwargs)

class PyNucleus_nl.twoPointFunctions.twoPointFunction(BOOL_t symmetric, INDEX_t valueSize)

Bases: object

__call__(*args, **kwargs): Call self as a function.

__init__(*args, **kwargs)

diagonal(self)

fixedX(self, REAL_t[::1] x)

fixedY(self, REAL_t[::1] y)

getLongDescription(self)

plot(self, mesh, **kwargs)

symmetric: symmetric: ‘BOOL_t’

valueSize: valueSize: ‘INDEX_t’

class PyNucleus_nl.twoPointFunctions.unsymTwoPoint(REAL_t l, REAL_t r)

Bases: twoPointFunction

__init__(*args, **kwargs)

l: l: ‘REAL_t’

r: r: ‘REAL_t’

PyNucleus_nl.fractionalOrders module

Defines classes for constant and space dependent fractional orders.

class PyNucleus_nl.fractionalOrders.constFractionalOrder(REAL_t s)

Bases: fractionalOrderBase

__init__(*args, **kwargs)

value: value: ‘REAL_t’

class PyNucleus_nl.fractionalOrders.constantExtended(REAL_t value)

Bases: extendedFunction

__init__(*args, **kwargs)

value: value: ‘REAL_t’

class PyNucleus_nl.fractionalOrders.constantNonSymFractionalOrder(REAL_t s)

Bases: singleVariableUnsymmetricFractionalOrder

__init__(*args, **kwargs)

value: value: ‘REAL_t’

class PyNucleus_nl.fractionalOrders.extendedFunction: Bases: function

class PyNucleus_nl.fractionalOrders.feFractionalOrder(fe_vector vec, REAL_t smin, REAL_t smax)

Bases: singleVariableUnsymmetricFractionalOrder

__init__(*args, **kwargs)

vec: vec: PyNucleus_fem.DoFMaps.fe_vector

class PyNucleus_nl.fractionalOrders.fractionalOrderBase(REAL_t smin, REAL_t smax, BOOL_t symmetric, INDEX_t numParameters=1)

Bases: twoPointFunction

__init__(*args, **kwargs)

evalGrad_py(self, REAL_t[::1] x, REAL_t[::1] y, REAL_t[::1] grad)

max: max: ‘REAL_t’

min: min: ‘REAL_t’

numParameters: numParameters: ‘INDEX_t’

class PyNucleus_nl.fractionalOrders.innerOuterFractionalOrder(INDEX_t dim, REAL_t sii, REAL_t soo, REAL_t r, REAL_t[::1] center, REAL_t sio=np.nan, REAL_t soi=np.nan)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.islandsFractionalOrder(REAL_t sii, REAL_t soo, REAL_t r, REAL_t r2, REAL_t sio=np.nan, REAL_t soi=np.nan)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.lambdaFractionalOrder(INDEX_t dim, REAL_t smin, REAL_t smax, BOOL_t symmetric, fun)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.layersFractionalOrder(INDEX_t dim, REAL_t[::1] layerBoundaries, REAL_t[:, ::1] layerOrders)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

layerBoundaries: layerBoundaries: ‘REAL_t[::1]’

layerOrders: layerOrders: ‘REAL_t[:, ::1]’

class PyNucleus_nl.fractionalOrders.leftRightFractionalOrder(REAL_t sll, REAL_t srr, REAL_t slr=np.nan, REAL_t srl=np.nan, REAL_t interface=0.)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.linearLeftRightFractionalOrder(REAL_t sl, REAL_t sr, REAL_t r=0.1, REAL_t interface=0.)

Bases: singleVariableUnsymmetricFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.linearStep(REAL_t sl, REAL_t sr, REAL_t r, REAL_t interface=0.)

Bases: extendedFunction

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.lookupExtended(meshBase mesh, DoFMap dm, REAL_t[::1] u, cellFinder2 cF=None)

Bases: extendedFunction

__init__(*args, **kwargs)

cellFinder: cellFinder: PyNucleus_fem.meshCy.cellFinder2

dm: dm: PyNucleus_fem.DoFMaps.DoFMap

u: u: ‘REAL_t[::1]’

class PyNucleus_nl.fractionalOrders.piecewiseConstantFractionalOrder(INDEX_t dim, function blockIndicator, REAL_t[:, ::1] sVals)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

blockIndicator: blockIndicator: PyNucleus_fem.functions.function

numBlocks

class PyNucleus_nl.fractionalOrders.singleVariableTwoPointFunction(extendedFunction fun)

Bases: twoPointFunction

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.singleVariableUnsymmetricFractionalOrder(extendedFunction sFun, REAL_t smin, REAL_t smax, INDEX_t numParameters=0)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

sFun: sFun: PyNucleus_nl.fractionalOrders.extendedFunction

class PyNucleus_nl.fractionalOrders.smoothLeftRight(REAL_t sl, REAL_t sr, REAL_t r=0.1, REAL_t slope=200.)

Bases: extendedFunction

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.smoothStep(REAL_t sl, REAL_t sr, REAL_t r, REAL_t interface=0.)

Bases: extendedFunction

__init__(*args, **kwargs)

interface: interface: ‘REAL_t’

r: r: ‘REAL_t’

sl: sl: ‘REAL_t’

slope: slope: ‘REAL_t’

sr: sr: ‘REAL_t’

class PyNucleus_nl.fractionalOrders.smoothStepRadial(REAL_t sl, REAL_t sr, REAL_t r, REAL_t radius=0.5)

Bases: extendedFunction

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.smoothedInnerOuterFractionalOrder(REAL_t sl, REAL_t sr, REAL_t r=0.1, REAL_t slope=200., REAL_t radius=0.5)

Bases: singleVariableUnsymmetricFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.smoothedLeftRightFractionalOrder(REAL_t sl, REAL_t sr, REAL_t r=0.1, REAL_t slope=200., REAL_t interface=0.)

Bases: singleVariableUnsymmetricFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.sumFractionalOrder(variableFractionalOrder s1, REAL_t fac1, variableFractionalOrder s2, REAL_t fac2)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

class PyNucleus_nl.fractionalOrders.variableConstFractionalOrder(REAL_t s)

Bases: variableFractionalOrder

__init__(*args, **kwargs)

value: value: ‘REAL_t’

class PyNucleus_nl.fractionalOrders.variableFractionalOrder(REAL_t smin, REAL_t smax, BOOL_t symmetric, INDEX_t numParameters=1)

Bases: fractionalOrderBase

__init__(*args, **kwargs)

PyNucleus_nl.kernelNormalization module

Defines normalizations for different types of kernels.

class PyNucleus_nl.kernelNormalization.constantFractionalLaplacianScaling(INDEX_t dim, REAL_t s, REAL_t horizon, REAL_t tempered)

Bases: constantTwoPoint

__init__(*args, **kwargs)

getLongDescription(self)

class PyNucleus_nl.kernelNormalization.constantFractionalLaplacianScalingBoundary: Bases: constantTwoPoint

class PyNucleus_nl.kernelNormalization.constantFractionalLaplacianScalingDerivative(INDEX_t dim, REAL_t s, REAL_t horizon, BOOL_t normalized, BOOL_t boundary, INDEX_t derivative, REAL_t tempered)

Bases: twoPointFunction

__init__(*args, **kwargs)

class PyNucleus_nl.kernelNormalization.constantIntegrableScaling(kernelType kType, interactionDomain interaction, INDEX_t dim, REAL_t horizon, REAL_t gaussian_variance=1.0, REAL_t exponentialRate=1.0)

Bases: constantTwoPoint

__init__(*args, **kwargs)

getLongDescription(self)

class PyNucleus_nl.kernelNormalization.memoizedDigamma: Bases: memoizedFun

class PyNucleus_nl.kernelNormalization.memoizedFun

Bases: object

__call__(*args, **kwargs): Call self as a function.

__init__(*args, **kwargs)

stats(self)

class PyNucleus_nl.kernelNormalization.variableFractionalLaplacianScaling(BOOL_t symmetric, BOOL_t normalized=True, BOOL_t boundary=False, INDEX_t derivative=0)

Bases: parametrizedTwoPointFunction

__init__(*args, **kwargs)

getLongDescription(self)

getScalingWithDifferentHorizon(self)

class PyNucleus_nl.kernelNormalization.variableFractionalLaplacianScalingBoundary: Bases: parametrizedTwoPointFunction

class PyNucleus_nl.kernelNormalization.variableFractionalLaplacianScalingWithDifferentHorizon(BOOL_t symmetric, BOOL_t normalized, BOOL_t boundary, INDEX_t derivative, function horizonFun)

Bases: variableFractionalLaplacianScaling

__init__(*args, **kwargs)

class PyNucleus_nl.kernelNormalization.variableIntegrableScaling(kernelType kType, interactionDomain interaction)

Bases: parametrizedTwoPointFunction

__init__(*args, **kwargs)

getScalingWithDifferentHorizon(self)

class PyNucleus_nl.kernelNormalization.variableIntegrableScalingWithDifferentHorizon(kernelType kType, interactionDomain interaction, function horizonFun)

Bases: variableIntegrableScaling

__init__(*args, **kwargs)

PyNucleus_nl.interactionDomains module

Defines different types of interaction domains.

class PyNucleus_nl.interactionDomains.ball1_barycenter(function horizonFun)

Bases: linearTransformInteraction

l1 ball interaction domain

__init__(*args, **kwargs)

getLongDescription(self)

class PyNucleus_nl.interactionDomains.ball1_retriangulation(function horizonFun)

Bases: linearTransformInteraction

l1 ball interaction domain

__init__(*args, **kwargs)

getLongDescription(self)

class PyNucleus_nl.interactionDomains.ball2Complement(function horizonFun)

Bases: retriangulationDomain

__init__(*args, **kwargs)

getComplement(self)

getLongDescription(self)

class PyNucleus_nl.interactionDomains.ball2_barycenter(function horizonFun)

Bases: barycenterDomain

l2 ball interaction domain

__init__(*args, **kwargs)

getComplement(self)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.ball2_dilation_barycenter(sqrtAffineFunction horizonFun)

Bases: barycenterDomain

__init__(*args, **kwargs)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.ball2_dilation_retriangulation(sqrtAffineFunction horizonFun)

Bases: retriangulationDomain

__init__(*args, **kwargs)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.ball2_retriangulation(function horizonFun)

Bases: retriangulationDomain

l2 ball interaction domain

__init__(*args, **kwargs)

getComplement(self)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.ballInf_barycenter(function horizonFun)

Bases: barycenterDomain

l-inf ball interaction domain

__init__(*args, **kwargs)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.ballInf_retriangulation(function horizonFun)

Bases: retriangulationDomain

l-inf ball interaction domain

__init__(*args, **kwargs)

getLongDescription(self)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.barycenterDomain(function horizonFun, BOOL_t isComplement, BOOL_t symmetric)

Bases: interactionDomain

__init__(*args, **kwargs)

class PyNucleus_nl.interactionDomains.ellipseTransform(function a, function b, function theta)

Bases: matrixFunction

__init__(*args, **kwargs)

class PyNucleus_nl.interactionDomains.ellipse_barycenter(function horizonFun, function a, function b, function theta)

Bases: linearTransformInteraction

Ellipse interaction domain

__init__(*args, **kwargs)

a: a: PyNucleus_fem.functions.function

b: b: PyNucleus_fem.functions.function

getLongDescription(self)

theta: theta: PyNucleus_fem.functions.function

class PyNucleus_nl.interactionDomains.ellipse_retriangulation(function horizonFun, function a, function b, function theta)

Bases: linearTransformInteraction

Ellipse interaction domain

__init__(*args, **kwargs)

a: a: PyNucleus_fem.functions.function

b: b: PyNucleus_fem.functions.function

theta: theta: PyNucleus_fem.functions.function

class PyNucleus_nl.interactionDomains.fullSpace

Bases: interactionDomain

Full space interaction domain, i.e. infinite interaction horizon.

__init__(*args, **kwargs)

getLongDescription(self)

class PyNucleus_nl.interactionDomains.interactionDomain(function horizonFun, BOOL_t isComplement, BOOL_t symmetric)

Bases: parametrizedTwoPointFunction

Base class for all interaction domains.

__init__(*args, **kwargs)

complement: complement: ‘BOOL_t’

dist2: dist2: ‘REAL_t’

getComplement(self)

getLongDescription(self)

getRelativePosition_py(self, REAL_t[:, ::1] simplex1, REAL_t[:, ::1] simplex2): Returns the relative position of two simplices.

get_Surface(self, REAL_t[::1] node1)

horizonFun: horizonFun: PyNucleus_fem.functions.function

nextSubSimplex_Node_py(self, REAL_t[:, ::1] A, REAL_t[::1] vol)

nextSubSimplex_Simplex_py(self, REAL_t[:, ::1] A, REAL_t[::1] b, REAL_t[::1] vol)

plot_Node(self, REAL_t[::1] node1, REAL_t[:, ::1] simplex2, BOOL_t plotMeshSimplex=True)

plot_Node_Mesh(self, REAL_t[::1] node1, meshBase mesh)

plot_Simplex(self, REAL_t[:, ::1] simplex1, REAL_t[:, ::1] simplex2, BOOL_t plotSurfaces=True)

plot_Simplex_Mesh(self, REAL_t[:, ::1] simplex2, meshBase mesh)

plot_Surface(self, REAL_t[::1] node1): Plot the surface of the interaction neighborhood.

relPos: relPos: ‘RELATIVE_POSITION_t’

startLoopSubSimplices_Node_py(self, REAL_t[::1] node1, REAL_t[:, ::1] simplex2)

startLoopSubSimplices_Simplex_py(self, REAL_t[:, ::1] simplex1, REAL_t[:, ::1] simplex2)

volume_Node(self, REAL_t[::1] node1, REAL_t[:, ::1] simplex2)

volume_Node_Mesh(self, REAL_t[::1] node1, meshBase mesh)

class PyNucleus_nl.interactionDomains.linearTransformInteraction(function horizonFun, interactionDomain baseInteraction, matrixFunction transform)

Bases: interactionDomain

A: A: ‘REAL_t[:, ::1]’

__init__(*args, **kwargs)

get_Surface(self, REAL_t[::1] node1)

class PyNucleus_nl.interactionDomains.retriangulationDomain(function horizonFun, BOOL_t isComplement, BOOL_t symmetric)

Bases: interactionDomain

__init__(*args, **kwargs)

PyNucleus_nl.kernels module

PyNucleus_nl.kernels.getFractionalKernel(dim, s, horizon=None, interaction=None, scaling=None, normalized=True, piecewise=True, phi=None, boundary=False, derivative=0, tempered=0.0, max_horizon=nan)[source]

PyNucleus_nl.kernels.getIntegrableKernel(dim, kernel, horizon, scaling=None, interaction=None, normalized=True, piecewise=True, phi=None, boundary=False, monomialPower=nan, variance=1.0, exponentialRate=1.0, a=1.0, max_horizon=nan)[source]

PyNucleus_nl.kernels.getKernel(dim, s=None, horizon=None, scaling=None, interaction=None, normalized=True, piecewise=True, phi=None, kernel=0, boundary=False, max_horizon=nan, variance=1.0, exponentialRate=1.0)[source]

PyNucleus_nl.kernelsCy module

class PyNucleus_nl.kernelsCy.ComplexKernel(INDEX_t dim, kernelType kType, function horizon, interactionDomain interaction, twoPointFunction scaling, twoPointFunction phi, BOOL_t piecewise=True, BOOL_t boundary=False, INDEX_t valueSize=1, REAL_t max_horizon=np.nan, **kwargs)

Bases: ComplextwoPointFunction

A kernel functions that can be used to define a nonlocal operator.

__call__(): Evaluate the kernel.

__init__(*args, **kwargs)

boundary: boundary: ‘BOOL_t’

complement: complement: ‘BOOL_t’

dim: dim: ‘INDEX_t’

evalParams_py(self, REAL_t[::1] x, REAL_t[::1] y): Evaluate the kernel parameters.

eval_py(self, REAL_t[::1] x, REAL_t[::1] y, double complex[::1] vec, BOOL_t callEvalParams=True): Evaluate the kernel.

finiteHorizon: finiteHorizon: ‘BOOL_t’

getBoundaryKernel(self): Get the boundary kernel. This is the kernel that corresponds to the elimination of a subdomain via Gauss theorem.

getComplementKernel(self): Get the complement kernel.

getModifiedKernel(self, function horizon=None, twoPointFunction scaling=None)

horizon: horizon: PyNucleus_fem.functions.function

horizonValue: The value of the interaction horizon.

horizonValue2

interaction: interaction: PyNucleus_nl.interactionDomains.interactionDomain

kernelType: kernelType: ‘kernelType’

max_horizon: max_horizon: ‘REAL_t’

max_singularity: max_singularity: ‘REAL_t’

min_singularity: min_singularity: ‘REAL_t’

phi: phi: PyNucleus_nl.twoPointFunctions.twoPointFunction

piecewise: piecewise: ‘BOOL_t’

plot(self, x0=None): Plot the kernel function.

scaling: scaling: PyNucleus_nl.twoPointFunctions.twoPointFunction

scalingValue: The value of the scaling factor.

singularityValue: The order of the singularity.

variable: variable: ‘BOOL_t’

variableHorizon: variableHorizon: ‘BOOL_t’

variableScaling: variableScaling: ‘BOOL_t’

variableSingularity: variableSingularity: ‘BOOL_t’

class PyNucleus_nl.kernelsCy.FractionalKernel(INDEX_t dim, fractionalOrderBase s, function horizon, interactionDomain interaction, twoPointFunction scaling, twoPointFunction phi=None, BOOL_t piecewise=True, BOOL_t boundary=False, INDEX_t derivative=0, REAL_t tempered=0., REAL_t max_horizon=np.nan)

Bases: Kernel

A kernel function that can be used to define a fractional operator.

__init__(*args, **kwargs)

derivative: derivative: ‘INDEX_t’

evalParams_py(self, REAL_t[::1] x, REAL_t[::1] y)

getBoundaryKernel(self): Get the boundary kernel. This is the kernel that corresponds to the elimination of a subdomain via Gauss theorem.

getComplementKernel(self)

getDerivativeKernel(self)

getHessianKernel(self)

getModifiedKernel(self, fractionalOrderBase s=None, function horizon=None, twoPointFunction scaling=None)

s: s: PyNucleus_nl.fractionalOrders.fractionalOrderBase

sValue: The value of the fractional order

temperedValue: The value of the tempering parameter

variableOrder: variableOrder: ‘BOOL_t’

class PyNucleus_nl.kernelsCy.Kernel(INDEX_t dim, kernelType kType, function horizon, interactionDomain interaction, twoPointFunction scaling, twoPointFunction phi, BOOL_t piecewise=True, BOOL_t boundary=False, INDEX_t valueSize=1, REAL_t max_horizon=np.nan, **kwargs)

Bases: twoPointFunction

A kernel functions that can be used to define a nonlocal operator.

__call__(): Evaluate the kernel.

__init__(*args, **kwargs)

boundary: The order of the boundary.

complement: complement: ‘BOOL_t’

dim: dim: ‘INDEX_t’

evalParams_py(self, REAL_t[::1] x, REAL_t[::1] y): Evaluate the kernel parameters.

eval_py(self, REAL_t[::1] x, REAL_t[::1] y, REAL_t[::1] vec, BOOL_t callEvalParams=True): Evaluate the kernel.

finiteHorizon: finiteHorizon: ‘BOOL_t’

getBoundaryKernel(self): Get the boundary kernel. This is the kernel that corresponds to the elimination of a subdomain via Gauss theorem.

getComplementKernel(self): Get the complement kernel.

getKernelParam(self, str param)

getKernelParams(self)

getLongDescription(self)

getModifiedKernel(self, function horizon=None, twoPointFunction scaling=None)

getParamPtrAddr(self)

horizon: horizon: PyNucleus_fem.functions.function

horizonValue: The value of the interaction horizon.

horizonValue2

interaction: interaction: PyNucleus_nl.interactionDomains.interactionDomain

kernelType: kernelType: ‘kernelType’

max_horizon: max_horizon: ‘REAL_t’

max_singularity: max_singularity: ‘REAL_t’

min_singularity: min_singularity: ‘REAL_t’

phi: phi: PyNucleus_nl.twoPointFunctions.twoPointFunction

piecewise: piecewise: ‘BOOL_t’

plot(self, x0=None): Plot the kernel function.

scaling: scaling: PyNucleus_nl.twoPointFunctions.twoPointFunction

scalingValue: The value of the scaling factor.

singularityValue: The order of the singularity.

variable: variable: ‘BOOL_t’

variableHorizon: variableHorizon: ‘BOOL_t’

variableScaling: variableScaling: ‘BOOL_t’

variableSingularity: variableSingularity: ‘BOOL_t’

class PyNucleus_nl.kernelsCy.RangedFractionalKernel(INDEX_t dim, admissibleOrders, function horizon, BOOL_t normalized=True, REAL_t tempered=0., REAL_t errorBound=-1., INDEX_t M_min=1, INDEX_t M_max=20, REAL_t xi=0.)

Bases: FractionalKernel

M_max: M_max: ‘INDEX_t’

M_min: M_min: ‘INDEX_t’

__init__(*args, **kwargs)

admissibleOrders: admissibleOrders: object

errorBound: errorBound: ‘REAL_t’

getFrozenKernel(self, REAL_t s)

normalized: normalized: ‘BOOL_t’

setOrder(self, REAL_t s)

tempered: tempered: ‘REAL_t’

xi: xi: ‘REAL_t’

class PyNucleus_nl.kernelsCy.RangedVariableFractionalKernel(INDEX_t dim, function blockIndicator, admissibleOrders, function horizon, BOOL_t normalized=True, REAL_t errorBound=-1., INDEX_t M_min=1, INDEX_t M_max=20, REAL_t xi=0.)

Bases: FractionalKernel

M_max: M_max: ‘INDEX_t’

M_min: M_min: ‘INDEX_t’

__init__(*args, **kwargs)

admissibleOrders: admissibleOrders: object

blockIndicator: blockIndicator: PyNucleus_fem.functions.function

errorBound: errorBound: ‘REAL_t’

getFrozenKernel(self, REAL_t[:, ::1] sVals)

normalized: normalized: ‘BOOL_t’

setOrder(self, REAL_t[:, ::1] sVals)

xi: xi: ‘REAL_t’

PyNucleus_nl.kernelsCy.getKernelEnum(str kernelTypeString)

PyNucleus_nl.nonlocalOperator module

class PyNucleus_nl.nonlocalOperator.Complexdouble_local_matrix_t(INDEX_t dim, INDEX_t manifold_dim1, INDEX_t manifold_dim2, DoFMap dm)

Bases: object

DoFMap: DoFMap: PyNucleus_fem.DoFMaps.DoFMap

__call__(*args, **kwargs): Call self as a function.

__init__(*args, **kwargs)

addQuadRule_py(self, panelType panel)

cellNo1: cellNo1: ‘INDEX_t’

cellNo2: cellNo2: ‘INDEX_t’

computeCellPairIdentifier_py(self)

distantQuadRules: distantQuadRules: dict

eval_py(self, double complex[:, ::1] contrib, panel)

getPanelType(self) → panelType

perm: perm: ‘INDEX_t[::1]’

perm1: perm1: ‘INDEX_t[::1]’

perm2: perm2: ‘INDEX_t[::1]’

precomputedDoFPermutations: precomputedDoFPermutations: ‘INDEX_t[:, ::1]’

precomputedSurfaceSimplexPermutations: precomputedSurfaceSimplexPermutations: ‘INDEX_t[:, ::1]’

precomputedVolumeSimplexPermutations: precomputedVolumeSimplexPermutations: ‘INDEX_t[:, ::1]’

setCell1_py(self, INDEX_t cellNo1)

setCell2_py(self, INDEX_t cellNo2)

setMesh1_py(self, meshBase mesh1)

setMesh2_py(self, meshBase mesh2)

setVerticesCells1_py(self, REAL_t[:, ::1] vertices1, INDEX_t[:, ::1] cells1)

setVerticesCells2_py(self, REAL_t[:, ::1] vertices2, INDEX_t[:, ::1] cells2)

symmetricCells: symmetricCells: ‘bool’

symmetricLocalMatrix: symmetricLocalMatrix: ‘bool’

vol1: vol1: ‘REAL_t’

vol2: vol2: ‘REAL_t’

class PyNucleus_nl.nonlocalOperator.ComplexnonlocalOperator(ComplexKernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, INDEX_t manifold_dim2=-1)

Bases: Complexdouble_local_matrix_t

H0: H0: ‘REAL_t’

__init__(*args, **kwargs)

getPanelType(self) → panelType

hmin: hmin: ‘REAL_t’

kernel: kernel: PyNucleus_nl.kernelsCy.ComplexKernel

n: n: ‘REAL_t[::1]’

num_dofs: num_dofs: ‘REAL_t’

setKernel(self, ComplexKernel kernel, quad_order_diagonal=None, target_order=None) → void

w: w: ‘REAL_t[::1]’

class PyNucleus_nl.nonlocalOperator.PermutationIndexer(N)

Bases: object

__init__(*args, **kwargs)

rank_py(self, INDEX_t[::1] perm)

class PyNucleus_nl.nonlocalOperator.double_local_matrix_t(INDEX_t dim, INDEX_t manifold_dim1, INDEX_t manifold_dim2, DoFMap dm)

Bases: object

DoFMap: DoFMap: PyNucleus_fem.DoFMaps.DoFMap

__call__(*args, **kwargs): Call self as a function.

__init__(*args, **kwargs)

addQuadRule_py(self, panelType panel)

cellNo1: cellNo1: ‘INDEX_t’

cellNo2: cellNo2: ‘INDEX_t’

computeCellPairIdentifier_py(self)

distantQuadRules: distantQuadRules: dict

eval_py(self, REAL_t[:, ::1] contrib, panel)

getPanelType(self) → panelType

perm: perm: ‘INDEX_t[::1]’

perm1: perm1: ‘INDEX_t[::1]’

perm2: perm2: ‘INDEX_t[::1]’

precomputedDoFPermutations: precomputedDoFPermutations: ‘INDEX_t[:, ::1]’

precomputedSurfaceSimplexPermutations: precomputedSurfaceSimplexPermutations: ‘INDEX_t[:, ::1]’

precomputedVolumeSimplexPermutations: precomputedVolumeSimplexPermutations: ‘INDEX_t[:, ::1]’

setCell1_py(self, INDEX_t cellNo1)

setCell2_py(self, INDEX_t cellNo2)

setMesh1_py(self, meshBase mesh1)

setMesh2_py(self, meshBase mesh2)

setVerticesCells1_py(self, REAL_t[:, ::1] vertices1, INDEX_t[:, ::1] cells1)

setVerticesCells2_py(self, REAL_t[:, ::1] vertices2, INDEX_t[:, ::1] cells2)

symmetricCells: symmetricCells: ‘bool’

symmetricLocalMatrix: symmetricLocalMatrix: ‘bool’

vol1: vol1: ‘REAL_t’

vol2: vol2: ‘REAL_t’

class PyNucleus_nl.nonlocalOperator.nonlocalLaplacian1D(Kernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, manifold_dim2=-1, **kwargs)

Bases: nonlocalOperator

__init__(*args, **kwargs)

quad_order_diagonal: quad_order_diagonal: ‘REAL_t’

target_order: target_order: ‘REAL_t’

class PyNucleus_nl.nonlocalOperator.nonlocalLaplacian2D(Kernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, manifold_dim2=-1, **kwargs)

Bases: nonlocalOperator

__init__(*args, **kwargs)

quad_order_diagonal: quad_order_diagonal: ‘REAL_t’

quad_order_diagonalV: quad_order_diagonalV: ‘REAL_t’

target_order: target_order: ‘REAL_t’

class PyNucleus_nl.nonlocalOperator.nonlocalOperator(Kernel kernel, meshBase mesh, DoFMap dm, num_dofs=None, INDEX_t manifold_dim2=-1)

Bases: double_local_matrix_t

H0: H0: ‘REAL_t’

__init__(*args, **kwargs)

getPanelType(self) → panelType

hmin: hmin: ‘REAL_t’

kernel: kernel: PyNucleus_nl.kernelsCy.Kernel

n: n: ‘REAL_t[::1]’

num_dofs: num_dofs: ‘REAL_t’

setKernel(self, Kernel kernel, quad_order_diagonal=None, target_order=None) → void

w: w: ‘REAL_t[::1]’

class PyNucleus_nl.nonlocalOperator.specialQuadRule(quadratureRule qr, REAL_t[:, ::1] PSI=None, REAL_t[:, :, ::1] PSI3=None, REAL_t[:, ::1] PHI=None, REAL_t[:, :, ::1] PHI3=None)

Bases: object

PHI: PHI: ‘REAL_t[:, ::1]’

PHI3: PHI3: ‘REAL_t[:, :, ::1]’

PSI: PSI: ‘REAL_t[:, ::1]’

PSI3: PSI3: ‘REAL_t[:, :, ::1]’

__init__(*args, **kwargs)

qr: qr: PyNucleus_fem.quadrature.quadratureRule

qrTransformed0: qrTransformed0: PyNucleus_fem.quadrature.transformQuadratureRule

qrTransformed1: qrTransformed1: PyNucleus_fem.quadrature.transformQuadratureRule

PyNucleus_nl.nonlocalBuilder module

nonlocalBuilder(DoFMap dm, Kernel kernel, dict params={}, bool zeroExterior=True, Comm comm=None, FakePLogger PLogger=None, DoFMap dm2=None, **kwargs)

PyNucleus_nl.nonlocalBuilder.__init__(self, /, *args, **kwargs): Initialize self. See help(type(self)) for accurate signature.

PyNucleus_nl.nonlocalProblems module

class PyNucleus_nl.nonlocalProblems.fractionalOrderFactoryClass[source]

Bases: factory

build(name, *args, **kwargs)[source]

class PyNucleus_nl.nonlocalProblems.nonlocalMeshFactoryClass[source]

Bases: factory

__init__()[source]

register(name, classTypeNoOverlap, classTypeOverlap, dim, indicators, paramsNoOverlap={}, paramsOverlap={}, aliases=[])[source]

build(name, kernel, boundaryCondition, noRef=0, useMulti=False, **kwargs)[source]

getDim(name)[source]

PyNucleus_nl.nonlocalProblems.intervalIndicators(a=-1, b=1, **kwargs)[source]

PyNucleus_nl.nonlocalProblems.squareIndicators(ax=-1.0, ay=-1.0, bx=1.0, by=1.0, **kwargs)[source]

PyNucleus_nl.nonlocalProblems.radialIndicators(*args, **kwargs)[source]

PyNucleus_nl.nonlocalProblems.twinDiscIndicators(radius=1.0, sep=0.1, **kwargs)[source]

PyNucleus_nl.nonlocalProblems.boxIndicators(ax=-1.0, ay=-1.0, az=-1.0, bx=1.0, by=1.0, bz=1.0, **kwargs)[source]

PyNucleus_nl.nonlocalProblems.ballWithInteractions(*args, **kwargs)[source]

class PyNucleus_nl.nonlocalProblems.nonlocalBaseProblem(driver)[source]

Bases: problem

__init__(driver)[source]

setDriverArgs()[source]

processCmdline(params)[source]

getDim(domain)[source]

constructAuxiliarySpace()[source]

processKernel(dim, kernelType, sType, sArgs, phiType, phiArgs, horizon, interaction, normalized, admissibleParams, discretizedOrder, dmAux, feOrder, gaussianVariance, exponentialRate)[source]

report(group)[source]

class PyNucleus_nl.nonlocalProblems.fractionalLaplacianProblem(driver, useMulti=False)[source]

Bases: nonlocalBaseProblem

__init__(driver, useMulti=False)[source]

setDriverArgs()[source]

processCmdline(params)[source]

getDomainParams(domain)[source]

processProblem(kernel, dim, domain, domainParams, problem, normalized)[source]

getApproximationParams(dim, domain, kernel, element)[source]

buildMesh(mesh_domain, mesh_params)[source]

constructAuxiliarySpace(dim, domain, domainParams, kernelType, horizon, targetDoFsAux)[source]

class PyNucleus_nl.nonlocalProblems.nonlocalPoissonProblem(driver)[source]

Bases: nonlocalBaseProblem

setDriverArgs()[source]

processCmdline(params)[source]

processProblem(kernel, domain, problem, normalized)[source]

getApproximationParams(dim, kernel, element, target_order)[source]

buildMesh(mesh_domain, mesh_params, hTarget)[source]

class PyNucleus_nl.nonlocalProblems.transientFractionalProblem(driver, useMulti=False)[source]

Bases: fractionalLaplacianProblem

__init__(driver, useMulti=False)[source]

setDriverArgs()[source]

processProblem(kernel, dim, domain, domainParams, problem, normalized)[source]

report(group)[source]

class PyNucleus_nl.nonlocalProblems.nonlocalInterfaceProblem(driver)[source]

Bases: problem

setDriverArgs()[source]

processProblem(domain, problem, element, kernel1Type, kernel2Type, horizon1, horizon2, hTarget, s11, s12, s21, s22, coeff11, coeff12, coeff21, coeff22)[source]

class PyNucleus_nl.nonlocalProblems.brusselatorProblem(driver)[source]

Bases: problem

Fractional order Brusselator system:

partial_t U = -(-Delta)^alpha U + (B-1)*U + Q^2 V + B/Q * U**2 + 2*Q*U*V + U**2 * V

eta**2 * partial_t V = -(-Delta)^beta U - B*U - Q^2 V - B/Q * U**2 - 2*Q*U*V - U**2 * V

with zero flux conditions on U and V.

s = beta/alpha eta = sqrt(D_X**s / D_Y) Q = A eta

setDriverArgs()[source]

processProblem(domain, bc, noRef, problem, T)[source]