VAMPyR

VAMPyR makes the MRCPP functionality available through a Python interface.

class vampyr.InterpolatingBasis

Bases: vampyr._vampyr.ScalingBasis

class vampyr.Iterator

Bases: pybind11_builtins.pybind11_object

Members:

Lebesgue

Hilbert

Hilbert = <Iterator.Hilbert: 1>

Lebesgue = <Iterator.Lebesgue: 0>

property name

property value

class vampyr.LegendreBasis

Bases: vampyr._vampyr.ScalingBasis

class vampyr.Polynomial

Bases: vampyr._vampyr.vampyr1d.RepresentableFunction

class vampyr.ScalingBasis

Bases: pybind11_builtins.pybind11_object

quadratureOrder(self: vampyr._vampyr.ScalingBasis) → int

scaling(self: vampyr._vampyr.ScalingBasis, i: int, l: int = 0, n: int = 0) → vampyr._vampyr.ScalingFunction

scalingOrder(self: vampyr._vampyr.ScalingBasis) → int

scalingType(self: vampyr._vampyr.ScalingBasis) → int

wavelet(self: vampyr._vampyr.ScalingBasis, i: int, l: int = 0, n: int = 0) → vampyr._vampyr.WaveletFunction

class vampyr.ScalingFunction

Bases: vampyr._vampyr.Polynomial

class vampyr.Traverse

Bases: pybind11_builtins.pybind11_object

Members:

TopDown

BottomUp

BottomUp = <Traverse.BottomUp: 1>

TopDown = <Traverse.TopDown: 0>

property name

property value

class vampyr.WaveletFunction

Bases: vampyr._vampyr.vampyr1d.RepresentableFunction

vampyr.mrcpp_version() → str

Return version of the underlying MRCPP library.

We offer bindings for functions in 1-, 2-, and 3-dimensional space in separate submodules

1-dimensional bindings

VAMPyR 1D

1-dimensional bindings to MRCPP.

class vampyr.vampyr1d.ABGVDerivative

Bases: vampyr._vampyr.vampyr1d.DerivativeOperator

class vampyr.vampyr1d.BSDerivative

Bases: vampyr._vampyr.vampyr1d.DerivativeOperator

class vampyr.vampyr1d.BoundingBox

Bases: pybind11_builtins.pybind11_object

boxLength(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) → float

boxLengths(self: vampyr._vampyr.vampyr1d.BoundingBox) → List[float[1]]

isPeriodic(self: vampyr._vampyr.vampyr1d.BoundingBox) → bool

lowerBound(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) → float

lowerBounds(self: vampyr._vampyr.vampyr1d.BoundingBox) → List[float[1]]

scale(self: vampyr._vampyr.vampyr1d.BoundingBox) → int

scalingFactor(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) → float

scalingFactors(self: vampyr._vampyr.vampyr1d.BoundingBox) → List[float[1]]

size(*args, **kwargs)

Overloaded function.

1. size(self: vampyr._vampyr.vampyr1d.BoundingBox) -> int

2. size(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) -> int

unitLength(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) → float

unitLengths(self: vampyr._vampyr.vampyr1d.BoundingBox) → List[float[1]]

upperBound(self: vampyr._vampyr.vampyr1d.BoundingBox, dim: int) → float

upperBounds(self: vampyr._vampyr.vampyr1d.BoundingBox) → List[float[1]]

class vampyr.vampyr1d.ConvolutionOperator

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr1d.DerivativeOperator

Bases: pybind11_builtins.pybind11_object

getOrder(self: vampyr._vampyr.vampyr1d.DerivativeOperator) → int

class vampyr.vampyr1d.FunctionNode

Bases: vampyr._vampyr.vampyr1d.MWNode

integrate(self: vampyr._vampyr.vampyr1d.FunctionNode) → float

class vampyr.vampyr1d.FunctionTree

Bases: vampyr._vampyr.vampyr1d.MWTree, vampyr._vampyr.vampyr1d.RepresentableFunction

add(self: vampyr._vampyr.vampyr1d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr1d.FunctionTree) → None

crop(self: vampyr._vampyr.vampyr1d.FunctionTree, prec: float, abs_prec: bool = False) → vampyr._vampyr.vampyr1d.FunctionTree

deepCopy(self: vampyr._vampyr.vampyr1d.FunctionTree) → vampyr._vampyr.vampyr1d.FunctionTree

deleteGenerated(self: vampyr._vampyr.vampyr1d.FunctionTree) → None

integrate(self: vampyr._vampyr.vampyr1d.FunctionTree) → float

loadTree(self: vampyr._vampyr.vampyr1d.FunctionTree, filename: str) → None

multiply(self: vampyr._vampyr.vampyr1d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr1d.FunctionTree) → None

nGenNodes(self: vampyr._vampyr.vampyr1d.FunctionTree) → int

normalize(self: vampyr._vampyr.vampyr1d.FunctionTree) → None

power(self: vampyr._vampyr.vampyr1d.FunctionTree, pow: float) → None

rescale(self: vampyr._vampyr.vampyr1d.FunctionTree, coef: float) → None

saveTree(self: vampyr._vampyr.vampyr1d.FunctionTree, filename: str) → None

square(self: vampyr._vampyr.vampyr1d.FunctionTree) → None

class vampyr.vampyr1d.GaussExp

Bases: vampyr._vampyr.vampyr1d.RepresentableFunction

append(self: vampyr._vampyr.vampyr1d.GaussExp, arg0: vampyr._vampyr.vampyr1d.Gaussian) → None

calcCoulombEnergy(self: vampyr._vampyr.vampyr1d.GaussExp) → float

differentiate(self: vampyr._vampyr.vampyr1d.GaussExp, dir: int) → vampyr._vampyr.vampyr1d.GaussExp

func(self: vampyr._vampyr.vampyr1d.GaussExp, term: int) → vampyr._vampyr.vampyr1d.Gaussian

periodify(self: vampyr._vampyr.vampyr1d.GaussExp, period: List[float[1]], std_dev: float = 4.0) → vampyr._vampyr.vampyr1d.GaussExp

size(self: vampyr._vampyr.vampyr1d.GaussExp) → int

squaredNorm(self: vampyr._vampyr.vampyr1d.GaussExp) → float

class vampyr.vampyr1d.GaussFunc

Bases: vampyr._vampyr.vampyr1d.Gaussian

calcCoulombEnergy(self: vampyr._vampyr.vampyr1d.GaussFunc, arg0: vampyr._vampyr.vampyr1d.GaussFunc) → float

differentiate(self: vampyr._vampyr.vampyr1d.GaussFunc, dir: int) → mrcpp::GaussExp<1>

squaredNorm(self: vampyr._vampyr.vampyr1d.GaussFunc) → float

class vampyr.vampyr1d.Gaussian

Bases: vampyr._vampyr.vampyr1d.RepresentableFunction

coef(self: vampyr._vampyr.vampyr1d.Gaussian) → float

exp(self: vampyr._vampyr.vampyr1d.Gaussian, dim: int = 0) → float

overlap(self: vampyr._vampyr.vampyr1d.Gaussian, inp: vampyr._vampyr.vampyr1d.Gaussian) → float

periodify(self: vampyr._vampyr.vampyr1d.Gaussian, period: List[float[1]], std_dev: float = 4.0) → mrcpp::GaussExp<1>

pos(self: vampyr._vampyr.vampyr1d.Gaussian) → List[float[1]]

pow(self: vampyr._vampyr.vampyr1d.Gaussian, dim: int) → int

class vampyr.vampyr1d.IdentityConvolution

Bases: vampyr._vampyr.vampyr1d.ConvolutionOperator

class vampyr.vampyr1d.MWNode

Bases: pybind11_builtins.pybind11_object

componentNorm(self: vampyr._vampyr.vampyr1d.MWNode, arg0: int) → float

depth(self: vampyr._vampyr.vampyr1d.MWNode) → int

hasCoefs(self: vampyr._vampyr.vampyr1d.MWNode) → bool

hasParent(self: vampyr._vampyr.vampyr1d.MWNode) → bool

index(self: vampyr._vampyr.vampyr1d.MWNode) → mrcpp::NodeIndex<1>

isAllocated(self: vampyr._vampyr.vampyr1d.MWNode) → bool

isBranchNode(self: vampyr._vampyr.vampyr1d.MWNode) → bool

isEndNode(self: vampyr._vampyr.vampyr1d.MWNode) → bool

isGenNode(self: vampyr._vampyr.vampyr1d.MWNode) → bool

isLeafNode(self: vampyr._vampyr.vampyr1d.MWNode) → bool

isRootNode(self: vampyr._vampyr.vampyr1d.MWNode) → bool

nChildren(self: vampyr._vampyr.vampyr1d.MWNode) → int

nCoefs(self: vampyr._vampyr.vampyr1d.MWNode) → int

norm(self: vampyr._vampyr.vampyr1d.MWNode) → float

scale(self: vampyr._vampyr.vampyr1d.MWNode) → int

scalingNorm(self: vampyr._vampyr.vampyr1d.MWNode) → float

squaredNorm(self: vampyr._vampyr.vampyr1d.MWNode) → float

waveletNorm(self: vampyr._vampyr.vampyr1d.MWNode) → float

class vampyr.vampyr1d.MWProjector

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr1d.MWTree

Bases: pybind11_builtins.pybind11_object

MRA(self: vampyr._vampyr.vampyr1d.MWTree) → mrcpp::MultiResolutionAnalysis<1>

clear(self: vampyr._vampyr.vampyr1d.MWTree) → None

depth(self: vampyr._vampyr.vampyr1d.MWTree) → int

fetchEndNode(self: vampyr._vampyr.vampyr1d.MWTree, arg0: int) → mrcpp::MWNode<1>

fetchNode(self: vampyr._vampyr.vampyr1d.MWTree, arg0: mrcpp::NodeIndex<1>) → mrcpp::MWNode<1>

fetchRootNode(self: vampyr._vampyr.vampyr1d.MWTree, arg0: int) → mrcpp::MWNode<1>

nEndNodes(self: vampyr._vampyr.vampyr1d.MWTree) → int

nNodes(self: vampyr._vampyr.vampyr1d.MWTree) → int

nRootNodes(self: vampyr._vampyr.vampyr1d.MWTree) → int

name(self: vampyr._vampyr.vampyr1d.MWTree) → str

norm(self: vampyr._vampyr.vampyr1d.MWTree) → float

rootScale(self: vampyr._vampyr.vampyr1d.MWTree) → int

setName(self: vampyr._vampyr.vampyr1d.MWTree, arg0: str) → None

setZero(self: vampyr._vampyr.vampyr1d.MWTree) → None

squaredNorm(self: vampyr._vampyr.vampyr1d.MWTree) → float

class vampyr.vampyr1d.MultiResolutionAnalysis

Bases: pybind11_builtins.pybind11_object

basis(self: vampyr._vampyr.vampyr1d.MultiResolutionAnalysis) → mrcpp::ScalingBasis

maxDepth(self: vampyr._vampyr.vampyr1d.MultiResolutionAnalysis) → int

maxScale(self: vampyr._vampyr.vampyr1d.MultiResolutionAnalysis) → int

world(self: vampyr._vampyr.vampyr1d.MultiResolutionAnalysis) → vampyr._vampyr.vampyr1d.BoundingBox

class vampyr.vampyr1d.NodeIndex

Bases: pybind11_builtins.pybind11_object

child(self: vampyr._vampyr.vampyr1d.NodeIndex, arg0: int) → vampyr._vampyr.vampyr1d.NodeIndex

parent(self: vampyr._vampyr.vampyr1d.NodeIndex) → vampyr._vampyr.vampyr1d.NodeIndex

scale(self: vampyr._vampyr.vampyr1d.NodeIndex) → int

setScale(self: vampyr._vampyr.vampyr1d.NodeIndex, arg0: int) → None

setTranslation(self: vampyr._vampyr.vampyr1d.NodeIndex, arg0: List[int[1]]) → None

translation(*args, **kwargs)

Overloaded function.

1. translation(self: vampyr._vampyr.vampyr1d.NodeIndex) -> List[int[1]]

2. translation(self: vampyr._vampyr.vampyr1d.NodeIndex, arg0: int) -> int

class vampyr.vampyr1d.PHDerivative

Bases: vampyr._vampyr.vampyr1d.DerivativeOperator

class vampyr.vampyr1d.RepresentableFunction

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr1d.TreeIterator

Bases: pybind11_builtins.pybind11_object

get(self: vampyr._vampyr.vampyr1d.TreeIterator) → vampyr._vampyr.vampyr1d.MWNode

init(self: vampyr._vampyr.vampyr1d.TreeIterator, arg0: vampyr._vampyr.vampyr1d.MWTree) → None

next(self: vampyr._vampyr.vampyr1d.TreeIterator) → bool

setIterator(self: vampyr._vampyr.vampyr1d.TreeIterator, arg0: int) → None

setMaxDepth(self: vampyr._vampyr.vampyr1d.TreeIterator, arg0: int) → None

setReturnGenNodes(self: vampyr._vampyr.vampyr1d.TreeIterator, arg0: bool) → None

setTraverse(self: vampyr._vampyr.vampyr1d.TreeIterator, arg0: int) → None

vampyr.vampyr1d.add(*args, **kwargs)

Overloaded function.

1. add(prec: float = -1.0, out: mrcpp::FunctionTree<1>, a: float = 1.0, inp_a: mrcpp::FunctionTree<1>, b: float = 1.0, inp_b: mrcpp::FunctionTree<1>, max_iter: int = -1, abs_prec: bool = False) -> None

2. add(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: List[mrcpp::FunctionTree<1>], max_iter: int = -1, abs_prec: bool = False) -> None

3. add(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: List[Tuple[float, mrcpp::FunctionTree<1>]], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr1d.apply(*args, **kwargs)

Overloaded function.

1. apply(prec: float, out: mrcpp::FunctionTree<1>, oper: mrcpp::ConvolutionOperator<1>, inp: mrcpp::FunctionTree<1>, max_iter: int = -1, abs_prec: bool = False) -> None

2. apply(out: mrcpp::FunctionTree<1>, oper: mrcpp::DerivativeOperator<1>, inp: mrcpp::FunctionTree<1>, dir: int = -1) -> None

vampyr.vampyr1d.build_grid(*args, **kwargs)

Overloaded function.

1. build_grid(out: mrcpp::FunctionTree<1>, scales: int) -> None

2. build_grid(out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>, max_iter: int = -1) -> None

3. build_grid(out: mrcpp::FunctionTree<1>, inp: mrcpp::RepresentableFunction<1>, max_iter: int = -1) -> None

4. build_grid(out: mrcpp::FunctionTree<1>, inp: List[mrcpp::FunctionTree<1>], max_iter: int = -1) -> None

5. build_grid(out: mrcpp::FunctionTree<1>, inp: List[Tuple[float, mrcpp::FunctionTree<1>]], max_iter: int = -1) -> None

vampyr.vampyr1d.clear_grid(out: mrcpp::FunctionTree<1>) → None

vampyr.vampyr1d.copy_func(out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>) → None

vampyr.vampyr1d.copy_grid(out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>) → None

vampyr.vampyr1d.divergence(oper: mrcpp::DerivativeOperator<1>, inp: List[mrcpp::FunctionTree<1>]) → mrcpp::FunctionTree<1>

vampyr.vampyr1d.dot(bra: mrcpp::FunctionTree<1>, ket: mrcpp::FunctionTree<1>) → float

vampyr.vampyr1d.gradient(oper: mrcpp::DerivativeOperator<1>, inp: mrcpp::FunctionTree<1>) → List[mrcpp::FunctionTree<1>]

vampyr.vampyr1d.multiply(*args, **kwargs)

Overloaded function.

1. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<1>, c: float = 1.0, inp_a: mrcpp::FunctionTree<1>, inp_b: mrcpp::FunctionTree<1>, max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

2. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: List[mrcpp::FunctionTree<1>], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

3. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: List[Tuple[float, mrcpp::FunctionTree<1>]], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

vampyr.vampyr1d.power(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>, pow: float, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr1d.prod(*args, **kwargs)

Overloaded function.

1. prod(inp: List[mrcpp::FunctionTree<1>]) -> mrcpp::FunctionTree<1>

2. prod(inp: List[Tuple[float, mrcpp::FunctionTree<1>]]) -> mrcpp::FunctionTree<1>

vampyr.vampyr1d.project(*args, **kwargs)

Overloaded function.

1. project(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: mrcpp::RepresentableFunction<1>, max_iter: int = -1, abs_prec: bool = False) -> None

2. project(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: Callable[[List[float[1]]], float], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr1d.refine_grid(*args, **kwargs)

Overloaded function.

1. refine_grid(out: mrcpp::FunctionTree<1>, scales: int) -> int

2. refine_grid(out: mrcpp::FunctionTree<1>, prec: float, abs_prec: bool = False) -> int

3. refine_grid(out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>) -> int

vampyr.vampyr1d.square(prec: float = -1.0, out: mrcpp::FunctionTree<1>, inp: mrcpp::FunctionTree<1>, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr1d.sum(*args, **kwargs)

Overloaded function.

1. sum(inp: List[mrcpp::FunctionTree<1>]) -> mrcpp::FunctionTree<1>

2. sum(inp: List[Tuple[float, mrcpp::FunctionTree<1>]]) -> mrcpp::FunctionTree<1>

2-dimensional bindings

VAMPyR 2D

2-dimensional bindings to MRCPP.

class vampyr.vampyr2d.ABGVDerivative

Bases: vampyr._vampyr.vampyr2d.DerivativeOperator

class vampyr.vampyr2d.BSDerivative

Bases: vampyr._vampyr.vampyr2d.DerivativeOperator

class vampyr.vampyr2d.BoundingBox

Bases: pybind11_builtins.pybind11_object

boxLength(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) → float

boxLengths(self: vampyr._vampyr.vampyr2d.BoundingBox) → List[float[2]]

isPeriodic(self: vampyr._vampyr.vampyr2d.BoundingBox) → bool

lowerBound(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) → float

lowerBounds(self: vampyr._vampyr.vampyr2d.BoundingBox) → List[float[2]]

scale(self: vampyr._vampyr.vampyr2d.BoundingBox) → int

scalingFactor(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) → float

scalingFactors(self: vampyr._vampyr.vampyr2d.BoundingBox) → List[float[2]]

size(*args, **kwargs)

Overloaded function.

1. size(self: vampyr._vampyr.vampyr2d.BoundingBox) -> int

2. size(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) -> int

unitLength(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) → float

unitLengths(self: vampyr._vampyr.vampyr2d.BoundingBox) → List[float[2]]

upperBound(self: vampyr._vampyr.vampyr2d.BoundingBox, dim: int) → float

upperBounds(self: vampyr._vampyr.vampyr2d.BoundingBox) → List[float[2]]

class vampyr.vampyr2d.ConvolutionOperator

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr2d.DerivativeOperator

Bases: pybind11_builtins.pybind11_object

getOrder(self: vampyr._vampyr.vampyr2d.DerivativeOperator) → int

class vampyr.vampyr2d.FunctionNode

Bases: vampyr._vampyr.vampyr2d.MWNode

integrate(self: vampyr._vampyr.vampyr2d.FunctionNode) → float

class vampyr.vampyr2d.FunctionTree

Bases: vampyr._vampyr.vampyr2d.MWTree, vampyr._vampyr.vampyr2d.RepresentableFunction

add(self: vampyr._vampyr.vampyr2d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr2d.FunctionTree) → None

crop(self: vampyr._vampyr.vampyr2d.FunctionTree, prec: float, abs_prec: bool = False) → vampyr._vampyr.vampyr2d.FunctionTree

deepCopy(self: vampyr._vampyr.vampyr2d.FunctionTree) → vampyr._vampyr.vampyr2d.FunctionTree

deleteGenerated(self: vampyr._vampyr.vampyr2d.FunctionTree) → None

integrate(self: vampyr._vampyr.vampyr2d.FunctionTree) → float

loadTree(self: vampyr._vampyr.vampyr2d.FunctionTree, filename: str) → None

multiply(self: vampyr._vampyr.vampyr2d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr2d.FunctionTree) → None

nGenNodes(self: vampyr._vampyr.vampyr2d.FunctionTree) → int

normalize(self: vampyr._vampyr.vampyr2d.FunctionTree) → None

power(self: vampyr._vampyr.vampyr2d.FunctionTree, pow: float) → None

rescale(self: vampyr._vampyr.vampyr2d.FunctionTree, coef: float) → None

saveTree(self: vampyr._vampyr.vampyr2d.FunctionTree, filename: str) → None

square(self: vampyr._vampyr.vampyr2d.FunctionTree) → None

class vampyr.vampyr2d.GaussExp

Bases: vampyr._vampyr.vampyr2d.RepresentableFunction

append(self: vampyr._vampyr.vampyr2d.GaussExp, arg0: vampyr._vampyr.vampyr2d.Gaussian) → None

calcCoulombEnergy(self: vampyr._vampyr.vampyr2d.GaussExp) → float

differentiate(self: vampyr._vampyr.vampyr2d.GaussExp, dir: int) → vampyr._vampyr.vampyr2d.GaussExp

func(self: vampyr._vampyr.vampyr2d.GaussExp, term: int) → vampyr._vampyr.vampyr2d.Gaussian

periodify(self: vampyr._vampyr.vampyr2d.GaussExp, period: List[float[2]], std_dev: float = 4.0) → vampyr._vampyr.vampyr2d.GaussExp

size(self: vampyr._vampyr.vampyr2d.GaussExp) → int

squaredNorm(self: vampyr._vampyr.vampyr2d.GaussExp) → float

class vampyr.vampyr2d.GaussFunc

Bases: vampyr._vampyr.vampyr2d.Gaussian

calcCoulombEnergy(self: vampyr._vampyr.vampyr2d.GaussFunc, arg0: vampyr._vampyr.vampyr2d.GaussFunc) → float

differentiate(self: vampyr._vampyr.vampyr2d.GaussFunc, dir: int) → mrcpp::GaussExp<2>

squaredNorm(self: vampyr._vampyr.vampyr2d.GaussFunc) → float

class vampyr.vampyr2d.Gaussian

Bases: vampyr._vampyr.vampyr2d.RepresentableFunction

coef(self: vampyr._vampyr.vampyr2d.Gaussian) → float

exp(self: vampyr._vampyr.vampyr2d.Gaussian, dim: int = 0) → float

overlap(self: vampyr._vampyr.vampyr2d.Gaussian, inp: vampyr._vampyr.vampyr2d.Gaussian) → float

periodify(self: vampyr._vampyr.vampyr2d.Gaussian, period: List[float[2]], std_dev: float = 4.0) → mrcpp::GaussExp<2>

pos(self: vampyr._vampyr.vampyr2d.Gaussian) → List[float[2]]

pow(self: vampyr._vampyr.vampyr2d.Gaussian, dim: int) → int

class vampyr.vampyr2d.IdentityConvolution

Bases: vampyr._vampyr.vampyr2d.ConvolutionOperator

class vampyr.vampyr2d.MWNode

Bases: pybind11_builtins.pybind11_object

componentNorm(self: vampyr._vampyr.vampyr2d.MWNode, arg0: int) → float

depth(self: vampyr._vampyr.vampyr2d.MWNode) → int

hasCoefs(self: vampyr._vampyr.vampyr2d.MWNode) → bool

hasParent(self: vampyr._vampyr.vampyr2d.MWNode) → bool

index(self: vampyr._vampyr.vampyr2d.MWNode) → mrcpp::NodeIndex<2>

isAllocated(self: vampyr._vampyr.vampyr2d.MWNode) → bool

isBranchNode(self: vampyr._vampyr.vampyr2d.MWNode) → bool

isEndNode(self: vampyr._vampyr.vampyr2d.MWNode) → bool

isGenNode(self: vampyr._vampyr.vampyr2d.MWNode) → bool

isLeafNode(self: vampyr._vampyr.vampyr2d.MWNode) → bool

isRootNode(self: vampyr._vampyr.vampyr2d.MWNode) → bool

nChildren(self: vampyr._vampyr.vampyr2d.MWNode) → int

nCoefs(self: vampyr._vampyr.vampyr2d.MWNode) → int

norm(self: vampyr._vampyr.vampyr2d.MWNode) → float

scale(self: vampyr._vampyr.vampyr2d.MWNode) → int

scalingNorm(self: vampyr._vampyr.vampyr2d.MWNode) → float

squaredNorm(self: vampyr._vampyr.vampyr2d.MWNode) → float

waveletNorm(self: vampyr._vampyr.vampyr2d.MWNode) → float

class vampyr.vampyr2d.MWProjector

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr2d.MWTree

Bases: pybind11_builtins.pybind11_object

MRA(self: vampyr._vampyr.vampyr2d.MWTree) → mrcpp::MultiResolutionAnalysis<2>

clear(self: vampyr._vampyr.vampyr2d.MWTree) → None

depth(self: vampyr._vampyr.vampyr2d.MWTree) → int

fetchEndNode(self: vampyr._vampyr.vampyr2d.MWTree, arg0: int) → mrcpp::MWNode<2>

fetchNode(self: vampyr._vampyr.vampyr2d.MWTree, arg0: mrcpp::NodeIndex<2>) → mrcpp::MWNode<2>

fetchRootNode(self: vampyr._vampyr.vampyr2d.MWTree, arg0: int) → mrcpp::MWNode<2>

nEndNodes(self: vampyr._vampyr.vampyr2d.MWTree) → int

nNodes(self: vampyr._vampyr.vampyr2d.MWTree) → int

nRootNodes(self: vampyr._vampyr.vampyr2d.MWTree) → int

name(self: vampyr._vampyr.vampyr2d.MWTree) → str

norm(self: vampyr._vampyr.vampyr2d.MWTree) → float

rootScale(self: vampyr._vampyr.vampyr2d.MWTree) → int

setName(self: vampyr._vampyr.vampyr2d.MWTree, arg0: str) → None

setZero(self: vampyr._vampyr.vampyr2d.MWTree) → None

squaredNorm(self: vampyr._vampyr.vampyr2d.MWTree) → float

class vampyr.vampyr2d.MultiResolutionAnalysis

Bases: pybind11_builtins.pybind11_object

basis(self: vampyr._vampyr.vampyr2d.MultiResolutionAnalysis) → mrcpp::ScalingBasis

maxDepth(self: vampyr._vampyr.vampyr2d.MultiResolutionAnalysis) → int

maxScale(self: vampyr._vampyr.vampyr2d.MultiResolutionAnalysis) → int

world(self: vampyr._vampyr.vampyr2d.MultiResolutionAnalysis) → vampyr._vampyr.vampyr2d.BoundingBox

class vampyr.vampyr2d.NodeIndex

Bases: pybind11_builtins.pybind11_object

child(self: vampyr._vampyr.vampyr2d.NodeIndex, arg0: int) → vampyr._vampyr.vampyr2d.NodeIndex

parent(self: vampyr._vampyr.vampyr2d.NodeIndex) → vampyr._vampyr.vampyr2d.NodeIndex

scale(self: vampyr._vampyr.vampyr2d.NodeIndex) → int

setScale(self: vampyr._vampyr.vampyr2d.NodeIndex, arg0: int) → None

setTranslation(self: vampyr._vampyr.vampyr2d.NodeIndex, arg0: List[int[2]]) → None

translation(*args, **kwargs)

Overloaded function.

1. translation(self: vampyr._vampyr.vampyr2d.NodeIndex) -> List[int[2]]

2. translation(self: vampyr._vampyr.vampyr2d.NodeIndex, arg0: int) -> int

class vampyr.vampyr2d.PHDerivative

Bases: vampyr._vampyr.vampyr2d.DerivativeOperator

class vampyr.vampyr2d.RepresentableFunction

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr2d.TreeIterator

Bases: pybind11_builtins.pybind11_object

get(self: vampyr._vampyr.vampyr2d.TreeIterator) → vampyr._vampyr.vampyr2d.MWNode

init(self: vampyr._vampyr.vampyr2d.TreeIterator, arg0: vampyr._vampyr.vampyr2d.MWTree) → None

next(self: vampyr._vampyr.vampyr2d.TreeIterator) → bool

setIterator(self: vampyr._vampyr.vampyr2d.TreeIterator, arg0: int) → None

setMaxDepth(self: vampyr._vampyr.vampyr2d.TreeIterator, arg0: int) → None

setReturnGenNodes(self: vampyr._vampyr.vampyr2d.TreeIterator, arg0: bool) → None

setTraverse(self: vampyr._vampyr.vampyr2d.TreeIterator, arg0: int) → None

vampyr.vampyr2d.add(*args, **kwargs)

Overloaded function.

1. add(prec: float = -1.0, out: mrcpp::FunctionTree<2>, a: float = 1.0, inp_a: mrcpp::FunctionTree<2>, b: float = 1.0, inp_b: mrcpp::FunctionTree<2>, max_iter: int = -1, abs_prec: bool = False) -> None

2. add(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: List[mrcpp::FunctionTree<2>], max_iter: int = -1, abs_prec: bool = False) -> None

3. add(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: List[Tuple[float, mrcpp::FunctionTree<2>]], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr2d.apply(*args, **kwargs)

Overloaded function.

1. apply(prec: float, out: mrcpp::FunctionTree<2>, oper: mrcpp::ConvolutionOperator<2>, inp: mrcpp::FunctionTree<2>, max_iter: int = -1, abs_prec: bool = False) -> None

2. apply(out: mrcpp::FunctionTree<2>, oper: mrcpp::DerivativeOperator<2>, inp: mrcpp::FunctionTree<2>, dir: int = -1) -> None

vampyr.vampyr2d.build_grid(*args, **kwargs)

Overloaded function.

1. build_grid(out: mrcpp::FunctionTree<2>, scales: int) -> None

2. build_grid(out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>, max_iter: int = -1) -> None

3. build_grid(out: mrcpp::FunctionTree<2>, inp: mrcpp::RepresentableFunction<2>, max_iter: int = -1) -> None

4. build_grid(out: mrcpp::FunctionTree<2>, inp: List[mrcpp::FunctionTree<2>], max_iter: int = -1) -> None

5. build_grid(out: mrcpp::FunctionTree<2>, inp: List[Tuple[float, mrcpp::FunctionTree<2>]], max_iter: int = -1) -> None

vampyr.vampyr2d.clear_grid(out: mrcpp::FunctionTree<2>) → None

vampyr.vampyr2d.copy_func(out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>) → None

vampyr.vampyr2d.copy_grid(out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>) → None

vampyr.vampyr2d.divergence(oper: mrcpp::DerivativeOperator<2>, inp: List[mrcpp::FunctionTree<2>]) → mrcpp::FunctionTree<2>

vampyr.vampyr2d.dot(bra: mrcpp::FunctionTree<2>, ket: mrcpp::FunctionTree<2>) → float

vampyr.vampyr2d.gradient(oper: mrcpp::DerivativeOperator<2>, inp: mrcpp::FunctionTree<2>) → List[mrcpp::FunctionTree<2>]

vampyr.vampyr2d.multiply(*args, **kwargs)

Overloaded function.

1. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<2>, c: float = 1.0, inp_a: mrcpp::FunctionTree<2>, inp_b: mrcpp::FunctionTree<2>, max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

2. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: List[mrcpp::FunctionTree<2>], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

3. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: List[Tuple[float, mrcpp::FunctionTree<2>]], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

vampyr.vampyr2d.power(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>, pow: float, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr2d.prod(*args, **kwargs)

Overloaded function.

1. prod(inp: List[mrcpp::FunctionTree<2>]) -> mrcpp::FunctionTree<2>

2. prod(inp: List[Tuple[float, mrcpp::FunctionTree<2>]]) -> mrcpp::FunctionTree<2>

vampyr.vampyr2d.project(*args, **kwargs)

Overloaded function.

1. project(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: mrcpp::RepresentableFunction<2>, max_iter: int = -1, abs_prec: bool = False) -> None

2. project(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: Callable[[List[float[2]]], float], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr2d.refine_grid(*args, **kwargs)

Overloaded function.

1. refine_grid(out: mrcpp::FunctionTree<2>, scales: int) -> int

2. refine_grid(out: mrcpp::FunctionTree<2>, prec: float, abs_prec: bool = False) -> int

3. refine_grid(out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>) -> int

vampyr.vampyr2d.square(prec: float = -1.0, out: mrcpp::FunctionTree<2>, inp: mrcpp::FunctionTree<2>, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr2d.sum(*args, **kwargs)

Overloaded function.

1. sum(inp: List[mrcpp::FunctionTree<2>]) -> mrcpp::FunctionTree<2>

2. sum(inp: List[Tuple[float, mrcpp::FunctionTree<2>]]) -> mrcpp::FunctionTree<2>

3-dimensional bindings

VAMPyR 3D

3-dimensional bindings to MRCPP.

class vampyr.vampyr3d.ABGVDerivative

Bases: vampyr._vampyr.vampyr3d.DerivativeOperator

class vampyr.vampyr3d.BSDerivative

Bases: vampyr._vampyr.vampyr3d.DerivativeOperator

class vampyr.vampyr3d.BoundingBox

Bases: pybind11_builtins.pybind11_object

boxLength(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) → float

boxLengths(self: vampyr._vampyr.vampyr3d.BoundingBox) → List[float[3]]

isPeriodic(self: vampyr._vampyr.vampyr3d.BoundingBox) → bool

lowerBound(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) → float

lowerBounds(self: vampyr._vampyr.vampyr3d.BoundingBox) → List[float[3]]

scale(self: vampyr._vampyr.vampyr3d.BoundingBox) → int

scalingFactor(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) → float

scalingFactors(self: vampyr._vampyr.vampyr3d.BoundingBox) → List[float[3]]

size(*args, **kwargs)

Overloaded function.

1. size(self: vampyr._vampyr.vampyr3d.BoundingBox) -> int

2. size(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) -> int

unitLength(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) → float

unitLengths(self: vampyr._vampyr.vampyr3d.BoundingBox) → List[float[3]]

upperBound(self: vampyr._vampyr.vampyr3d.BoundingBox, dim: int) → float

upperBounds(self: vampyr._vampyr.vampyr3d.BoundingBox) → List[float[3]]

class vampyr.vampyr3d.ConvolutionOperator

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr3d.DerivativeOperator

Bases: pybind11_builtins.pybind11_object

getOrder(self: vampyr._vampyr.vampyr3d.DerivativeOperator) → int

class vampyr.vampyr3d.FunctionNode

Bases: vampyr._vampyr.vampyr3d.MWNode

integrate(self: vampyr._vampyr.vampyr3d.FunctionNode) → float

class vampyr.vampyr3d.FunctionTree

Bases: vampyr._vampyr.vampyr3d.MWTree, vampyr._vampyr.vampyr3d.RepresentableFunction

add(self: vampyr._vampyr.vampyr3d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr3d.FunctionTree) → None

crop(self: vampyr._vampyr.vampyr3d.FunctionTree, prec: float, abs_prec: bool = False) → vampyr._vampyr.vampyr3d.FunctionTree

deepCopy(self: vampyr._vampyr.vampyr3d.FunctionTree) → vampyr._vampyr.vampyr3d.FunctionTree

deleteGenerated(self: vampyr._vampyr.vampyr3d.FunctionTree) → None

integrate(self: vampyr._vampyr.vampyr3d.FunctionTree) → float

loadTree(self: vampyr._vampyr.vampyr3d.FunctionTree, filename: str) → None

multiply(self: vampyr._vampyr.vampyr3d.FunctionTree, coef: float = 1.0, inp: vampyr._vampyr.vampyr3d.FunctionTree) → None

nGenNodes(self: vampyr._vampyr.vampyr3d.FunctionTree) → int

normalize(self: vampyr._vampyr.vampyr3d.FunctionTree) → None

power(self: vampyr._vampyr.vampyr3d.FunctionTree, pow: float) → None

rescale(self: vampyr._vampyr.vampyr3d.FunctionTree, coef: float) → None

saveTree(self: vampyr._vampyr.vampyr3d.FunctionTree, filename: str) → None

square(self: vampyr._vampyr.vampyr3d.FunctionTree) → None

class vampyr.vampyr3d.GaussExp

Bases: vampyr._vampyr.vampyr3d.RepresentableFunction

append(self: vampyr._vampyr.vampyr3d.GaussExp, arg0: vampyr._vampyr.vampyr3d.Gaussian) → None

calcCoulombEnergy(self: vampyr._vampyr.vampyr3d.GaussExp) → float

differentiate(self: vampyr._vampyr.vampyr3d.GaussExp, dir: int) → vampyr._vampyr.vampyr3d.GaussExp

func(self: vampyr._vampyr.vampyr3d.GaussExp, term: int) → vampyr._vampyr.vampyr3d.Gaussian

periodify(self: vampyr._vampyr.vampyr3d.GaussExp, period: List[float[3]], std_dev: float = 4.0) → vampyr._vampyr.vampyr3d.GaussExp

size(self: vampyr._vampyr.vampyr3d.GaussExp) → int

squaredNorm(self: vampyr._vampyr.vampyr3d.GaussExp) → float

class vampyr.vampyr3d.GaussFunc

Bases: vampyr._vampyr.vampyr3d.Gaussian

calcCoulombEnergy(self: vampyr._vampyr.vampyr3d.GaussFunc, arg0: vampyr._vampyr.vampyr3d.GaussFunc) → float

differentiate(self: vampyr._vampyr.vampyr3d.GaussFunc, dir: int) → mrcpp::GaussExp<3>

squaredNorm(self: vampyr._vampyr.vampyr3d.GaussFunc) → float

class vampyr.vampyr3d.Gaussian

Bases: vampyr._vampyr.vampyr3d.RepresentableFunction

coef(self: vampyr._vampyr.vampyr3d.Gaussian) → float

exp(self: vampyr._vampyr.vampyr3d.Gaussian, dim: int = 0) → float

overlap(self: vampyr._vampyr.vampyr3d.Gaussian, inp: vampyr._vampyr.vampyr3d.Gaussian) → float

periodify(self: vampyr._vampyr.vampyr3d.Gaussian, period: List[float[3]], std_dev: float = 4.0) → mrcpp::GaussExp<3>

pos(self: vampyr._vampyr.vampyr3d.Gaussian) → List[float[3]]

pow(self: vampyr._vampyr.vampyr3d.Gaussian, dim: int) → int

class vampyr.vampyr3d.HelmholtzOperator

Bases: vampyr._vampyr.vampyr3d.ConvolutionOperator

class vampyr.vampyr3d.IdentityConvolution

Bases: vampyr._vampyr.vampyr3d.ConvolutionOperator

class vampyr.vampyr3d.MWNode

Bases: pybind11_builtins.pybind11_object

componentNorm(self: vampyr._vampyr.vampyr3d.MWNode, arg0: int) → float

depth(self: vampyr._vampyr.vampyr3d.MWNode) → int

hasCoefs(self: vampyr._vampyr.vampyr3d.MWNode) → bool

hasParent(self: vampyr._vampyr.vampyr3d.MWNode) → bool

index(self: vampyr._vampyr.vampyr3d.MWNode) → mrcpp::NodeIndex<3>

isAllocated(self: vampyr._vampyr.vampyr3d.MWNode) → bool

isBranchNode(self: vampyr._vampyr.vampyr3d.MWNode) → bool

isEndNode(self: vampyr._vampyr.vampyr3d.MWNode) → bool

isGenNode(self: vampyr._vampyr.vampyr3d.MWNode) → bool

isLeafNode(self: vampyr._vampyr.vampyr3d.MWNode) → bool

isRootNode(self: vampyr._vampyr.vampyr3d.MWNode) → bool

nChildren(self: vampyr._vampyr.vampyr3d.MWNode) → int

nCoefs(self: vampyr._vampyr.vampyr3d.MWNode) → int

norm(self: vampyr._vampyr.vampyr3d.MWNode) → float

scale(self: vampyr._vampyr.vampyr3d.MWNode) → int

scalingNorm(self: vampyr._vampyr.vampyr3d.MWNode) → float

squaredNorm(self: vampyr._vampyr.vampyr3d.MWNode) → float

waveletNorm(self: vampyr._vampyr.vampyr3d.MWNode) → float

class vampyr.vampyr3d.MWProjector

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr3d.MWTree

Bases: pybind11_builtins.pybind11_object

MRA(self: vampyr._vampyr.vampyr3d.MWTree) → mrcpp::MultiResolutionAnalysis<3>

clear(self: vampyr._vampyr.vampyr3d.MWTree) → None

depth(self: vampyr._vampyr.vampyr3d.MWTree) → int

fetchEndNode(self: vampyr._vampyr.vampyr3d.MWTree, arg0: int) → mrcpp::MWNode<3>

fetchNode(self: vampyr._vampyr.vampyr3d.MWTree, arg0: mrcpp::NodeIndex<3>) → mrcpp::MWNode<3>

fetchRootNode(self: vampyr._vampyr.vampyr3d.MWTree, arg0: int) → mrcpp::MWNode<3>

nEndNodes(self: vampyr._vampyr.vampyr3d.MWTree) → int

nNodes(self: vampyr._vampyr.vampyr3d.MWTree) → int

nRootNodes(self: vampyr._vampyr.vampyr3d.MWTree) → int

name(self: vampyr._vampyr.vampyr3d.MWTree) → str

norm(self: vampyr._vampyr.vampyr3d.MWTree) → float

rootScale(self: vampyr._vampyr.vampyr3d.MWTree) → int

setName(self: vampyr._vampyr.vampyr3d.MWTree, arg0: str) → None

setZero(self: vampyr._vampyr.vampyr3d.MWTree) → None

squaredNorm(self: vampyr._vampyr.vampyr3d.MWTree) → float

class vampyr.vampyr3d.MultiResolutionAnalysis

Bases: pybind11_builtins.pybind11_object

basis(self: vampyr._vampyr.vampyr3d.MultiResolutionAnalysis) → mrcpp::ScalingBasis

maxDepth(self: vampyr._vampyr.vampyr3d.MultiResolutionAnalysis) → int

maxScale(self: vampyr._vampyr.vampyr3d.MultiResolutionAnalysis) → int

world(self: vampyr._vampyr.vampyr3d.MultiResolutionAnalysis) → vampyr._vampyr.vampyr3d.BoundingBox

class vampyr.vampyr3d.NodeIndex

Bases: pybind11_builtins.pybind11_object

child(self: vampyr._vampyr.vampyr3d.NodeIndex, arg0: int) → vampyr._vampyr.vampyr3d.NodeIndex

parent(self: vampyr._vampyr.vampyr3d.NodeIndex) → vampyr._vampyr.vampyr3d.NodeIndex

scale(self: vampyr._vampyr.vampyr3d.NodeIndex) → int

setScale(self: vampyr._vampyr.vampyr3d.NodeIndex, arg0: int) → None

setTranslation(self: vampyr._vampyr.vampyr3d.NodeIndex, arg0: List[int[3]]) → None

translation(*args, **kwargs)

Overloaded function.

1. translation(self: vampyr._vampyr.vampyr3d.NodeIndex) -> List[int[3]]

2. translation(self: vampyr._vampyr.vampyr3d.NodeIndex, arg0: int) -> int

class vampyr.vampyr3d.PHDerivative

Bases: vampyr._vampyr.vampyr3d.DerivativeOperator

class vampyr.vampyr3d.PoissonOperator

Bases: vampyr._vampyr.vampyr3d.ConvolutionOperator

class vampyr.vampyr3d.RepresentableFunction

Bases: pybind11_builtins.pybind11_object

class vampyr.vampyr3d.TreeIterator

Bases: pybind11_builtins.pybind11_object

get(self: vampyr._vampyr.vampyr3d.TreeIterator) → vampyr._vampyr.vampyr3d.MWNode

init(self: vampyr._vampyr.vampyr3d.TreeIterator, arg0: vampyr._vampyr.vampyr3d.MWTree) → None

next(self: vampyr._vampyr.vampyr3d.TreeIterator) → bool

setIterator(self: vampyr._vampyr.vampyr3d.TreeIterator, arg0: int) → None

setMaxDepth(self: vampyr._vampyr.vampyr3d.TreeIterator, arg0: int) → None

setReturnGenNodes(self: vampyr._vampyr.vampyr3d.TreeIterator, arg0: bool) → None

setTraverse(self: vampyr._vampyr.vampyr3d.TreeIterator, arg0: int) → None

vampyr.vampyr3d.add(*args, **kwargs)

Overloaded function.

1. add(prec: float = -1.0, out: mrcpp::FunctionTree<3>, a: float = 1.0, inp_a: mrcpp::FunctionTree<3>, b: float = 1.0, inp_b: mrcpp::FunctionTree<3>, max_iter: int = -1, abs_prec: bool = False) -> None

2. add(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: List[mrcpp::FunctionTree<3>], max_iter: int = -1, abs_prec: bool = False) -> None

3. add(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: List[Tuple[float, mrcpp::FunctionTree<3>]], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr3d.apply(*args, **kwargs)

Overloaded function.

1. apply(prec: float, out: mrcpp::FunctionTree<3>, oper: mrcpp::ConvolutionOperator<3>, inp: mrcpp::FunctionTree<3>, max_iter: int = -1, abs_prec: bool = False) -> None

2. apply(out: mrcpp::FunctionTree<3>, oper: mrcpp::DerivativeOperator<3>, inp: mrcpp::FunctionTree<3>, dir: int = -1) -> None

vampyr.vampyr3d.build_grid(*args, **kwargs)

Overloaded function.

1. build_grid(out: mrcpp::FunctionTree<3>, scales: int) -> None

2. build_grid(out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>, max_iter: int = -1) -> None

3. build_grid(out: mrcpp::FunctionTree<3>, inp: mrcpp::RepresentableFunction<3>, max_iter: int = -1) -> None

4. build_grid(out: mrcpp::FunctionTree<3>, inp: List[mrcpp::FunctionTree<3>], max_iter: int = -1) -> None

5. build_grid(out: mrcpp::FunctionTree<3>, inp: List[Tuple[float, mrcpp::FunctionTree<3>]], max_iter: int = -1) -> None

vampyr.vampyr3d.clear_grid(out: mrcpp::FunctionTree<3>) → None

vampyr.vampyr3d.copy_func(out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>) → None

vampyr.vampyr3d.copy_grid(out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>) → None

vampyr.vampyr3d.divergence(oper: mrcpp::DerivativeOperator<3>, inp: List[mrcpp::FunctionTree<3>]) → mrcpp::FunctionTree<3>

vampyr.vampyr3d.dot(bra: mrcpp::FunctionTree<3>, ket: mrcpp::FunctionTree<3>) → float

vampyr.vampyr3d.gradient(oper: mrcpp::DerivativeOperator<3>, inp: mrcpp::FunctionTree<3>) → List[mrcpp::FunctionTree<3>]

vampyr.vampyr3d.multiply(*args, **kwargs)

Overloaded function.

1. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<3>, c: float = 1.0, inp_a: mrcpp::FunctionTree<3>, inp_b: mrcpp::FunctionTree<3>, max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

2. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: List[mrcpp::FunctionTree<3>], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

3. multiply(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: List[Tuple[float, mrcpp::FunctionTree<3>]], max_iter: int = -1, abs_prec: bool = False, use_max_norms: bool = False) -> None

vampyr.vampyr3d.power(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>, pow: float, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr3d.prod(*args, **kwargs)

Overloaded function.

1. prod(inp: List[mrcpp::FunctionTree<3>]) -> mrcpp::FunctionTree<3>

2. prod(inp: List[Tuple[float, mrcpp::FunctionTree<3>]]) -> mrcpp::FunctionTree<3>

vampyr.vampyr3d.project(*args, **kwargs)

Overloaded function.

1. project(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: mrcpp::RepresentableFunction<3>, max_iter: int = -1, abs_prec: bool = False) -> None

2. project(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: Callable[[List[float[3]]], float], max_iter: int = -1, abs_prec: bool = False) -> None

vampyr.vampyr3d.refine_grid(*args, **kwargs)

Overloaded function.

1. refine_grid(out: mrcpp::FunctionTree<3>, scales: int) -> int

2. refine_grid(out: mrcpp::FunctionTree<3>, prec: float, abs_prec: bool = False) -> int

3. refine_grid(out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>) -> int

vampyr.vampyr3d.square(prec: float = -1.0, out: mrcpp::FunctionTree<3>, inp: mrcpp::FunctionTree<3>, max_iter: int = -1, abs_prec: bool = False) → None

vampyr.vampyr3d.sum(*args, **kwargs)

Overloaded function.

1. sum(inp: List[mrcpp::FunctionTree<3>]) -> mrcpp::FunctionTree<3>

2. sum(inp: List[Tuple[float, mrcpp::FunctionTree<3>]]) -> mrcpp::FunctionTree<3>