Package petsc4py :: Module PETSc :: Class Vec

[hide private]
[frames] | no frames]

# Class Vec

Nested Classes | [hide private]

| Option
| Type

Instance Methods | [hide private]

__abs__() <==> abs(x) |

__add__(y) x+y |

__delitem__(y) del x[y] |

__div__(y) x/y |

__enter__(self) |

__exit__(self, *exc) |

__getitem__(y) x[y] |

__iadd__(y) x+=y |

__idiv__(y) x/=y |

__imul__(y) x*=y |

__isub__(y) x-=y |

__itruediv__(y) x/=y |

__mul__(y) x*y |

__neg__() -x |

a new object with type S, a subtype of T

__new__(S, ...) |

__pos__() +x |

__radd__(y) y+x |

__rdiv__(y) y/x |

__rmul__(y) y*x |

__rsub__(y) y-x |

__rtruediv__(y) y/x |

__setitem__(i, y) x[i]=y |

__sub__(y) x-y |

__truediv__(y) x/y |

abs(self) |

assemble(self) |

assemblyBegin(self) |

assemblyEnd(self) |

attachDLPackInfo(self, Vec vec=None, dltensor=None) Attach the tensor information from an input vector (vec) or a DLPack tensor if it is not available in current vector. |

axpby(self, alpha, beta, Vec y) |

axpy(self, alpha, Vec x) |

aypx(self, alpha, Vec x) |

bindToCPU(self, flg) If *flg* is *True*, all subsequent operations of *self* would be performed on CPU. |

chop(self, tol) |

clearDLPackInfo(self) Clear the tensor information See also :meth:`Vec.attachDLPackInfo`. |

conjugate(self) |

copy(self, Vec result=None) |

create(self, comm=None) |

createCUDAWithArrays(self, cpuarray=None, cudahandle=None, size=None, bsize=None, comm=None) Returns an instance of :class:`Vec`, a VECCUDA with user provided memory spaces for CPU and GPU arrays. |

createGhost(self, ghosts, size, bsize=None, comm=None) |

createGhostWithArray(self, ghosts, array, size=None, bsize=None, comm=None) |

createMPI(self, size, bsize=None, comm=None) |

createNest(self, vecs, isets=None, comm=None) |

createSeq(self, size, bsize=None, comm=None) |

createShared(self, size, bsize=None, comm=None) |

createViennaCLWithArrays(self, cpuarray=None, viennaclvechandle=None, size=None, bsize=None, comm=None) Returns an instance :class:`Vec`, a VECVIENNACL with user provided memory spaces for CPU and GPU arrays. |

createWithArray(self, array, size=None, bsize=None, comm=None) |

createWithDLPack(self, dltensor, size=None, bsize=None, comm=None) Returns an instance :class:`Vec`, a PETSc vector from a DLPack object sharing the same memory. |

destroy(self) |

dot(self, Vec vec) |

dotBegin(self, Vec vec) |

dotEnd(self, Vec vec) |

duplicate(self, array=None) |

equal(self, Vec vec) |

exp(self) |

getArray(self, readonly=False) |

getBlockSize(self) |

getBuffer(self, readonly=False) |

getCLContextHandle(self) Returns a Vec's CL Context as :class:`int`. |

getCLMemHandle(self, mode='rw') Returns a Vec's CL buffer as :class:`int`. |

getCLQueueHandle(self) Returns a Vec's CL Context as :class:`int`. |

getCUDAHandle(self, mode='rw') |

getLGMap(self) |

getLocalSize(self) |

getNestSubVecs(self) |

getOffloadMask(self) Returns :class:`int` of the Vec's PetscOffloadMask enum value. |

getOptionsPrefix(self) |

getOwnershipRange(self) |

getOwnershipRanges(self) |

getSize(self) |

getSizes(self) |

getSubVector(self, IS iset, Vec subvec=None) |

getType(self) |

getValue(self, index) |

getValues(self, indices, values=None) |

getValuesStagStencil(self, indices, values=None) |

ghostUpdate(self, addv=None, mode=None) |

ghostUpdateBegin(self, addv=None, mode=None) |

ghostUpdateEnd(self, addv=None, mode=None) |

isaxpy(self, IS idx, alpha, Vec x) |

isset(self, IS idx, alpha) |

load(self, Viewer viewer) |

localForm(self) Intended for use in context manager: |

log(self) |

mDot(self, vecs, out=None) |

mDotBegin(self, vecs, out=None) |

mDotEnd(self, vecs, out=None) |

max(self) |

maxPointwiseDivide(self, Vec vec) |

maxpy(self, alphas, vecs) |

min(self) |

mtDot(self, vecs, out=None) |

mtDotBegin(self, vecs, out=None) |

mtDotEnd(self, vecs, out=None) |

norm(self, norm_type=None) |

normBegin(self, norm_type=None) |

normEnd(self, norm_type=None) |

normalize(self) |

permute(self, IS order, invert=False) |

placeArray(self, array) |

pointwiseDivide(self, Vec x, Vec y) |

pointwiseMax(self, Vec x, Vec y) |

pointwiseMaxAbs(self, Vec x, Vec y) |

pointwiseMin(self, Vec x, Vec y) |

pointwiseMult(self, Vec x, Vec y) |

reciprocal(self) |

resetArray(self, force=False) |

restoreCLMemHandle(self) To be called after accessing a Vec's cl_mem in 'w' or 'rw' modes. |

restoreCUDAHandle(self, handle, mode='rw') |

restoreSubVector(self, IS iset, Vec subvec) |

scale(self, alpha) |

set(self, alpha) |

setArray(self, array) |

setBlockSize(self, bsize) |

setFromOptions(self) |

setLGMap(self, LGMap lgmap) |

setMPIGhost(self, ghosts) Alternative to createGhost() |

setNestSubVecs(self, sx, idxm=None) |

setOption(self, option, flag) |

setOptionsPrefix(self, prefix) |

setRandom(self, Random random=None) |

setSizes(self, size, bsize=None) |

setType(self, vec_type) |

setUp(self) |

setValue(self, index, value, addv=None) |

setValueLocal(self, index, value, addv=None) |

setValues(self, indices, values, addv=None) |

setValuesBlocked(self, indices, values, addv=None) |

setValuesBlockedLocal(self, indices, values, addv=None) |

setValuesLocal(self, indices, values, addv=None) |

setValuesStagStencil(self, indices, values, addv=None) |

shift(self, alpha) |

sqrtabs(self) |

strideGather(self, field, Vec vec, addv=None) |

strideMax(self, field) |

strideMin(self, field) |

strideNorm(self, field, norm_type=None) |

strideScale(self, field, alpha) |

strideScatter(self, field, Vec vec, addv=None) |

strideSum(self, field) |

sum(self) |

swap(self, Vec vec) |

tDot(self, Vec vec) |

tDotBegin(self, Vec vec) |

tDotEnd(self, Vec vec) |

toDLPack(self) Return a DLPack tensor. |

view(self, Viewer viewer=None) |

waxpy(self, alpha, Vec x, Vec y) |

zeroEntries(self) |

Inherited from `Object`: `__copy__`, `__deepcopy__`, `__eq__`, `__ge__`, `__gt__`, `__le__`, `__lt__`, `__ne__`, `__nonzero__`, `compose`, `decRef`, `getAttr`, `getClassId`, `getClassName`, `getComm`, `getDict`, `getName`, `getRefCount`, `getTabLevel`, `incRef`, `incrementTabLevel`, `query`, `setAttr`, `setName`, `setTabLevel`, `stateIncrease`, `viewFromOptions`

Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__init__`, `__reduce__`, `__reduce_ex__`, `__repr__`, `__setattr__`, `__sizeof__`, `__str__`, `__subclasshook__`

Properties | [hide private]

| __array_interface__
| array
| array_r Vec array (read-only)
| array_w Vec array (writable)
| block_size
| buffer
| buffer_r Vec buffer (read-only)
| buffer_w Vec buffer (writable)
| local_size
| owner_range
| owner_ranges
| size
| sizes
Inherited from `Object`: `classid`, `comm`, `fortran`, `handle`, `klass`, `name`, `prefix`, `refcount`, `type` Inherited from `object`: `__class__`

Method Details | [hide private]

### __new__(S, ...)

Returns: a new object with type S, a subtype of T
Overrides: object.__new__

### attachDLPackInfo(self, Vec vec=None, dltensor=None)

    Attach the tensor information from an input vector (vec) or a
    DLPack tensor if it is not available in current vector. The input
    vector is typically created with createWithDlpack(). This operation
    does not copy the data from the input parameters, it simply uses
    their meta information.

    Note that the auxiliary tensor information is required when converting
    a PETSc vector to a DLPack object.

    See also :meth:`Vec.clearDLPackInfo`.

    :arg vec: A :class:'Vec' containing auxiliary tensor information
    :arg dltensor: A DLPack tensor object

### bindToCPU(self, flg)

    If *flg* is *True*, all subsequent operations of *self* would be
    performed on CPU. If *flg* is *False*, all subsequent operations of
    *self* would be offloaded to the device, provided that the VecType is
    capable of offloading.

    :arg flg: An instance of :class:`bool`.

### createCUDAWithArrays(self, cpuarray=None, cudahandle=None, size=None, bsize=None, comm=None)

    Returns an instance of :class:`Vec`, a VECCUDA with user provided
    memory spaces for CPU and GPU arrays.

    :arg cpuarray: A :class:`numpy.ndarray`. Will be lazily allocated if
        *None*.
    :arg cudahandle: Address of the array on the GPU. Will be lazily
        allocated if *None*.
    :arg size: A :class:`int` denoting the size of the Vec.
    :arg bsize: A :class:`int` denoting the block size.

### createViennaCLWithArrays(self, cpuarray=None, viennaclvechandle=None, size=None, bsize=None, comm=None)

    Returns an instance :class:`Vec`, a VECVIENNACL with user provided memory
    spaces for CPU and GPU arrays.

    :arg cpuarray: A :class:`numpy.ndarray`. Will be lazily allocated if
        *None*.
    :arg viennaclvechandle: Address of the array on the GPU. Will be lazily
        allocated if *None*.
    :arg size: A :class:`int` denoting the size of the Vec.
    :arg size: A :class:`int` denoting the block size.

### createWithDLPack(self, dltensor, size=None, bsize=None, comm=None)

    Returns an instance :class:`Vec`, a PETSc vector from a DLPack object
    sharing the same memory.
    This operation does not modify the storage of the original tensor and
    should be used with contiguous tensors only. If the tensor is stored in
    row-major order (e.g. PyTorch tensors), the resulting vector will look
    like an unrolled tensor using row-major order.

    :arg dltensor: An object with a __dlpack__ method or a DLPack tensor object (for backward compatibility)
    :arg size: A :class:`int` denoting the size of the Vec.
    :arg bsize: A :class:`int` denoting the block size.

### destroy(self)

Overrides: Object.destroy

### getCLContextHandle(self)

    Returns a Vec's CL Context as :class:`int`.

    To interface with :mod:`pyopencl` refer
    :meth:`pyopencl.Context.from_int_ptr`

### getCLMemHandle(self, mode='rw')

    Returns a Vec's CL buffer as :class:`int`.

    To interface with :mod:`pyopencl` refer
    :meth:`pyopencl.MemoryObject.from_int_ptr`.

    :arg mode: An instance of class:`str` denoting the intended access
        usage to the CL buffer. Can be one of 'r'(read-only), 'w'
        (write-only) or 'rw' (read-write). See also
        :meth:`Vec.restoreCLMemHandle`.

### getCLQueueHandle(self)

    Returns a Vec's CL Context as :class:`int`.

    To interface with :mod:`pyopencl` refer
    :meth:`pyopencl.Context.from_int_ptr`

### getOptionsPrefix(self)

Overrides: Object.getOptionsPrefix

### getType(self)

Overrides: Object.getType

### restoreCLMemHandle(self)

    To be called after accessing a Vec's cl_mem in 'w' or 'rw' modes.
    See also :meth:`Vec.getCLMemHandle`.

### setFromOptions(self)

Overrides: Object.setFromOptions

### setOptionsPrefix(self, prefix)

Overrides: Object.setOptionsPrefix

### toDLPack(self)

    Return a DLPack tensor. Error out if the tensor information is missing.
    buildTensorInfo() can be used to get tensor information from an input
    vector that already has tensor information. This input vector is
    typically created with createWithDlpack().

    One can do the following to convert vector X to a DLPack tensor whose
    anxiliary information inherits from Y.
      X.buildTensorInfo(Y)
      X.toDLPack()

### view(self, Viewer viewer=None)

Overrides: Object.view