esys.escript.linearPDEs Package

Classes

class esys.escript.linearPDEs.ContinuousDomain

Class representing continuous domains

__init__()

Raises an exception This class cannot be instantiated from Python

addPDEToRHS((ContinuousDomain)arg1, (Data)rhs, (Data)X, (Data)Y, (Data)y, (Data)y_contact, (Data)y_dirac)None :

adds a PDE onto the stiffness matrix mat and a rhs

Parameters
addPDEToSystem((ContinuousDomain)arg1, (Operator)mat, (Data)rhs, (Data)A, (Data)B, (Data)C, (Data)D, (Data)X, (Data)Y, (Data)d, (Data)y, (Data)d_contact, (Data)y_contact, (Data)d_dirac, (Data)y_dirac)None :

adds a PDE onto the stiffness matrix mat and a rhs

Parameters
addPDEToTransportProblem((ContinuousDomain)arg1, (TransportProblem)tp, (Data)source, (Data)M, (Data)A, (Data)B, (Data)C, (Data)D, (Data)X, (Data)Y, (Data)d, (Data)y, (Data)d_contact, (Data)y_contact, (Data)d_dirac, (Data)y_dirac)None :
Parameters
getDataShape((ContinuousDomain)arg1, (object)functionSpaceCode)object :
Returns

a pair (dps, ns) where dps=the number of data points per sample, and ns=the number of samples

Return type

tuple

getDescription((ContinuousDomain)arg1)str :
Returns

a description for this domain

Return type

string

getNumDataPointsGlobal((ContinuousDomain)arg1)int :
Returns

the number of data points summed across all MPI processes

Return type

int

getSystemMatrixTypeId((ContinuousDomain)arg1, (object)options)int :
Returns

the identifier of the matrix type to be used for the global stiffness matrix when particular solver options are used.

Return type

int

getTransportTypeId((ContinuousDomain)arg1, (object)solver, (object)preconditioner, (object)package, (object)symmetry)int
newOperator((ContinuousDomain)arg1, (object)row_blocksize, (FunctionSpace)row_functionspace, (object)column_blocksize, (FunctionSpace)column_functionspace, (object)type)Operator :

creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros

Parameters
  • row_blocksize (int) –

  • row_functionspace (FunctionSpace) –

  • column_blocksize (int) –

  • column_functionspace (FunctionSpace) –

  • type (int) –

newTransportProblem((ContinuousDomain)theta, (object)blocksize, (FunctionSpace)functionspace, (object)type)TransportProblem :

creates a TransportProblemAdapter

Parameters
  • theta (float) –

  • blocksize (int) –

  • functionspace (FunctionSpace) –

  • type (int) –

print_mesh_info((ContinuousDomain)arg1[, (object)full=False])None :
Parameters

full (bool) –

setX((ContinuousDomain)arg1, (Data)arg)None :

assigns new location to the domain

Parameters

arg (Data) –

class esys.escript.linearPDEs.Data

Represents a collection of datapoints. It is used to store the values of a function. For more details please consult the c++ class documentation.

__init__((object)arg1)None

__init__( (object)arg1, (object)value [, (object)p2 [, (object)p3 [, (object)p4]]]) -> None

conjugate((Data)arg1)Data
copy((Data)arg1, (Data)other)None :

Make this object a copy of other

note

The two objects will act independently from now on. That is, changing other after this call will not change this object and vice versa.

copy( (Data)arg1) -> Data :
note

In the no argument form, a new object will be returned which is an independent copy of this object.

copyWithMask((Data)arg1, (Data)other, (Data)mask)None :

Selectively copy values from other Data.Datapoints which correspond to positive values in mask will be copied from other

Parameters
  • other (Data) – source of values

  • mask (Scalar Data) –

delay((Data)arg1)Data :

Convert this object into lazy representation

dump((Data)arg1, (str)fileName)None :

Save the data as a netCDF file

Parameters

fileName (string) –

expand((Data)arg1)None :

Convert the data to expanded representation if it is not expanded already.

getDomain((Data)arg1)Domain :
Return type

Domain

getFunctionSpace((Data)arg1)FunctionSpace :
Return type

FunctionSpace

getNumberOfDataPoints((Data)arg1)int :
Return type

int

Returns

Number of datapoints in the object

getRank((Data)arg1)int :
Returns

the number of indices required to address a component of a datapoint

Return type

positive int

getShape((Data)arg1)tuple :

Returns the shape of the datapoints in this object as a python tuple. Scalar data has the shape ()

Return type

tuple

getTagNumber((Data)arg1, (object)dpno)int :

Return tag number for the specified datapoint

Return type

int

Parameters

dpno (int) – datapoint number

getTupleForDataPoint((Data)arg1, (object)dataPointNo)object :
Returns

Value of the specified datapoint

Return type

tuple

Parameters

dataPointNo (int) – datapoint to access

getTupleForGlobalDataPoint((Data)arg1, (object)procNo, (object)dataPointNo)object :

Get a specific datapoint from a specific process

Return type

tuple

Parameters
  • procNo (positive int) – MPI rank of the process

  • dataPointNo (int) – datapoint to access

getX((Data)arg1)Data :

Returns the spatial coordinates of the spatial nodes. :rtype: Data

hasInf((Data)arg1)bool :

Returns return true if data contains +-Inf. [Note that for complex values, hasNaN and hasInf are not mutually exclusive.]

hasNaN((Data)arg1)bool :

Returns return true if data contains NaN. [Note that for complex values, hasNaN and hasInf are not mutually exclusive.]

imag((Data)arg1)Data
internal_maxGlobalDataPoint((Data)arg1)tuple :

Please consider using getSupLocator() from pdetools instead.

internal_minGlobalDataPoint((Data)arg1)tuple :

Please consider using getInfLocator() from pdetools instead.

interpolate((Data)arg1, (FunctionSpace)functionspace)Data :

Interpolate this object’s values into a new functionspace.

interpolateTable((Data)arg1, (object)table, (object)Amin, (object)Astep, (Data)B, (object)Bmin, (object)Bstep[, (object)undef=1e+50[, (object)check_boundaries=False]])Data :
Creates a new Data object by interpolating using the source data (which are

looked up in table) A must be the outer dimension on the table

param table

two dimensional collection of values

param Amin

The base of locations in table

type Amin

float

param Astep

size of gap between each item in the table

type Astep

float

param undef

upper bound on interpolated values

type undef

float

param B

Scalar representing the second coordinate to be mapped into the table

type B

Data

param Bmin

The base of locations in table for 2nd dimension

type Bmin

float

param Bstep

size of gap between each item in the table for 2nd dimension

type Bstep

float

param check_boundaries

if true, then values outside the boundaries will be rejected. If false, then boundary values will be used.

raise RuntimeError(DataException)

if the coordinates do not map into the table or if the interpolated value is above undef

rtype

Data

interpolateTable( (Data)arg1, (object)table, (object)Amin, (object)Astep [, (object)undef=1e+50 [, (object)check_boundaries=False]]) -> Data

isComplex((Data)arg1)bool :
Return type

bool

Returns

True if this Data stores complex values.

isConstant((Data)arg1)bool :
Return type

bool

Returns

True if this Data is an instance of DataConstant

Note

This does not mean the data is immutable.

isEmpty((Data)arg1)bool :

Is this object an instance of DataEmpty

Return type

bool

Note

This is not the same thing as asking if the object contains datapoints.

isExpanded((Data)arg1)bool :
Return type

bool

Returns

True if this Data is expanded.

isLazy((Data)arg1)bool :
Return type

bool

Returns

True if this Data is lazy.

isProtected((Data)arg1)bool :

Can this instance be modified. :rtype: bool

isReady((Data)arg1)bool :
Return type

bool

Returns

True if this Data is not lazy.

isTagged((Data)arg1)bool :
Return type

bool

Returns

True if this Data is expanded.

nonuniformInterpolate((Data)arg1, (object)in, (object)out, (object)check_boundaries)Data :

1D interpolation with non equally spaced points

nonuniformSlope((Data)arg1, (object)in, (object)out, (object)check_boundaries)Data :

1D interpolation of slope with non equally spaced points

phase((Data)arg1)Data
promote((Data)arg1)None
real((Data)arg1)Data
replaceInf((Data)arg1, (object)value)None :

Replaces +-Inf values with value. [Note, for complex Data, both real and imaginary components are replaced even if only one part is Inf].

replaceNaN((Data)arg1, (object)value)None :

Replaces NaN values with value. [Note, for complex Data, both real and imaginary components are replaced even if only one part is NaN].

resolve((Data)arg1)None :

Convert the data to non-lazy representation.

setProtection((Data)arg1)None :

Disallow modifications to this data object

Note

This method does not allow you to undo protection.

setTaggedValue((Data)arg1, (object)tagKey, (object)value)None :

Set the value of tagged Data.

param tagKey

tag to update

type tagKey

int

setTaggedValue( (Data)arg1, (str)name, (object)value) -> None :
param name

tag to update

type name

string

param value

value to set tagged data to

type value

object which acts like an array, tuple or list

setToZero((Data)arg1)None :

After this call the object will store values of the same shape as before but all components will be zero.

setValueOfDataPoint((Data)arg1, (object)dataPointNo, (object)value)None

setValueOfDataPoint( (Data)arg1, (object)arg2, (object)arg3) -> None

setValueOfDataPoint( (Data)arg1, (object)arg2, (object)arg3) -> None :

Modify the value of a single datapoint.

param dataPointNo

type dataPointNo

int

param value

type value

float or an object which acts like an array, tuple or list

warning

Use of this operation is discouraged. It prevents some optimisations from operating.

tag((Data)arg1)None :

Convert data to tagged representation if it is not already tagged or expanded

toListOfTuples((Data)arg1[, (object)scalarastuple=False])object :

Return the datapoints of this object in a list. Each datapoint is stored as a tuple.

Parameters

scalarastuple – if True, scalar data will be wrapped as a tuple. True => [(0), (1), (2)]; False => [0, 1, 2]

class esys.escript.linearPDEs.Domain

Base class for all domains.

__init__()

Raises an exception This class cannot be instantiated from Python

MPIBarrier((Domain)arg1)None :

Wait until all processes have reached this point

dump((Domain)arg1, (str)filename)None :

Dumps the domain to a file

Parameters

filename (string) –

getDim((Domain)arg1)int :
Return type

int

Returns

Spatial dimension of the Domain

getMPIRank((Domain)arg1)int :
Returns

the rank of this process

Return type

int

getMPISize((Domain)arg1)int :
Returns

the number of processes used for this Domain

Return type

int

getNormal((Domain)arg1)Data :
Return type

escript

Returns

Boundary normals

getNumpyX((Domain)arg1)numpy.ndarray :
Return type

numpy ndarray

Returns

Locations in the`Domain`. FunctionSpace is chosen appropriately

getSize((Domain)arg1)Data :
Returns

the local size of samples. The function space is chosen appropriately

Return type

Data

getStatus((Domain)arg1)int :

The status of a domain changes whenever the domain is modified

Return type

int

getTag((Domain)arg1, (str)name)int :
Returns

tag id for name

Return type

string

getX((Domain)arg1)Data :
Return type

Data

Returns

Locations in the`Domain`. FunctionSpace is chosen appropriately

isCellOriented((Domain)arg1, (object)functionSpaceCode)bool :
Returns

true is the data is cell centered.

Return type

int

isValidTagName((Domain)arg1, (str)name)bool :
Returns

True is name corresponds to a tag

Return type

bool

onMasterProcessor((Domain)arg1)bool :
Returns

True if this code is executing on the master process

Return type

bool

setTagMap((Domain)arg1, (str)name, (object)tag)None :

Give a tag number a name.

Parameters
  • name (string) – Name for the tag

  • tag (int) – numeric id

Note

Tag names must be unique within a domain

showTagNames((Domain)arg1)str :
Returns

A space separated list of tag names

Return type

string

supportsContactElements((Domain)arg1)bool :

Does this domain support contact elements.

class esys.escript.linearPDEs.FileWriter(fn, append=False, createLocalFiles=False)

Interface to write data to a file. In essence this class wrappes the standard file object to write data that are global in MPI to a file. In fact, data are writen on the processor with MPI rank 0 only. It is recommended to use FileWriter rather than open in order to write code that is running with as well as with MPI. It is safe to use open onder MPI to read data which are global under MPI.

Variables
  • name – name of file

  • mode – access mode (=’w’ or =’a’)

  • closed – True to indicate closed file

  • newlines – line seperator

__init__(fn, append=False, createLocalFiles=False)

Opens a file of name fn for writing. If running under MPI only the first processor with rank==0 will open the file and write to it. If createLocalFiles each individual processor will create a file where for any processor with rank>0 the file name is extended by its rank. This option is normally only used for debug purposes.

Parameters
  • fn (str) – filename.

  • append (bool) – switches on the creation of local files.

  • createLocalFiles (bool) – switches on the creation of local files.

close()

Closes the file

flush()

Flush the internal I/O buffer.

write(txt)

Write string txt to file.

Parameters

txt (str) – string txt to be written to file

writelines(txts)

Write the list txt of strings to the file.

Parameters

txts (any iterable object producing strings) – sequense of strings to be written to file

Note

Note that newlines are not added. This method is equivalent to call write() for each string.

class esys.escript.linearPDEs.FunctionSpace

A FunctionSpace describes which points from the Domain to use to represent functions.

__init__((object)arg1)None
getApproximationOrder((FunctionSpace)arg1)int :
Returns

the approximation order referring to the maximum degree of a polynomial which can be represented exactly in interpolation and/or integration.

Return type

int

getDim((FunctionSpace)arg1)int :
Returns

the spatial dimension of the underlying domain.

Return type

int

getDomain((FunctionSpace)arg1)Domain :
Returns

the underlying Domain for this FunctionSpace.

Return type

Domain

getListOfTags((FunctionSpace)arg1)list :
Returns

a list of the tags used in this function space

Return type

list

getNormal((FunctionSpace)arg1)Data :
Returns

the surface normal field.

Return type

Data

getReferenceIDFromDataPointNo((FunctionSpace)arg1, (object)dataPointNo)int :
Returns

the reference number associated with dataPointNo

Return type

int

getSize((FunctionSpace)arg1)Data :
Returns

sample size

Return type

Data

getTagFromDataPointNo((FunctionSpace)arg1, (object)arg2)int :
Returns

the tag associated with the given sample number.

Return type

int

getTypeCode((FunctionSpace)arg1)int :
Return type

int

getX((FunctionSpace)arg1)Data :
Returns

a function whose values are its input coordinates. ie an identity function.

Return type

Data

setTags((FunctionSpace)arg1, (object)newtag, (Data)mask)None :

Set tags according to a mask

param newtag

tag number to set

type newtag

string, non-zero int

param mask

Samples which correspond to positive values in the mask will be set to newtag.

type mask

scalar Data

setTags( (FunctionSpace)arg1, (str)newtag, (Data)mask) -> None

class esys.escript.linearPDEs.Helmholtz(domain, debug=False)

Class to define a Helmholtz equation problem. This is generally a LinearPDE of the form

omega*u - grad(k*grad(u)[j])[j] = f

with natural boundary conditions

k*n[j]*grad(u)[j] = g- alphau

and constraints:

u=r where q>0

__init__(domain, debug=False)

Initializes a new Helmholtz equation.

Parameters
  • domain (Domain) – domain of the PDE

  • debug – if True debug information is printed

getCoefficient(name)

Returns the value of the coefficient name of the general PDE.

Parameters

name (string) – name of the coefficient requested

Returns

the value of the coefficient name

Return type

Data

Raises

IllegalCoefficient – invalid name

setValue(**coefficients)

Sets new values to coefficients.

Parameters
  • coefficients – new values assigned to coefficients

  • omega (any type that can be cast to a Scalar object on Function) – value for coefficient omega

  • k (any type that can be cast to a Scalar object on Function) – value for coefficient k

  • f (any type that can be cast to a Scalar object on Function) – value for right hand side f

  • alpha (any type that can be cast to a Scalar object on FunctionOnBoundary) – value for right hand side alpha

  • g (any type that can be cast to a Scalar object on FunctionOnBoundary) – value for right hand side g

  • r (any type that can be cast to a Scalar object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – prescribed values r for the solution in constraints

  • q (any type that can be cast to a Scalar object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – mask for the location of constraints

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.escript.linearPDEs.IllegalCoefficient

Exception that is raised if an illegal coefficient of the general or particular PDE is requested.

__init__(*args, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

class esys.escript.linearPDEs.IllegalCoefficientFunctionSpace

Exception that is raised if an incorrect function space for a coefficient is used.

__init__(*args, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

class esys.escript.linearPDEs.IllegalCoefficientValue

Exception that is raised if an incorrect value for a coefficient is used.

__init__(*args, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

class esys.escript.linearPDEs.Internal_SplitWorld

Manages a group of sub worlds. For internal use only.

__init__((object)arg1, (object)num_worlds)None
clearVariable((Internal_SplitWorld)arg1, (str)name)None :

Remove the value from the named variable

copyVariable((Internal_SplitWorld)arg1, (str)source, (str)destination)None :

Copy the contents of one variable to another

getDoubleVariable((Internal_SplitWorld)arg1, (str)arg2)float :

Return the value of floating point variable

getLocalObjectVariable((Internal_SplitWorld)arg1, (str)arg2)object :

Returns python object for a variable which is not shared between worlds

getSubWorldCount((Internal_SplitWorld)arg1)int
getSubWorldID((Internal_SplitWorld)arg1)int
getVarInfo((Internal_SplitWorld)arg1)object :

Lists variable descriptions known to the system

getVarList((Internal_SplitWorld)arg1)object :

Lists variables known to the system

removeVariable((Internal_SplitWorld)arg1, (str)name)None :

Remove the named variable from the SplitWorld

runJobs((Internal_SplitWorld)arg1)None :

Execute pending jobs.

class esys.escript.linearPDEs.LameEquation(domain, debug=False, useFast=True)

Class to define a Lame equation problem. This problem is defined as:

-grad(mu*(grad(u[i])[j]+grad(u[j])[i]))[j] - grad(lambda*grad(u[k])[k])[j] = F_i -grad(sigma[ij])[j]

with natural boundary conditions:

n[j]*(mu*(grad(u[i])[j]+grad(u[j])[i]) + lambda*grad(u[k])[k]) = f_i +n[j]*sigma[ij]

and constraints:

u[i]=r[i] where q[i]>0

__init__(domain, debug=False, useFast=True)

Initializes a new Lame equation.

Parameters
  • domain (Domain) – domain of the PDE

  • debug – if True debug information is printed

getCoefficient(name)

Returns the value of the coefficient name of the general PDE.

Parameters

name (string) – name of the coefficient requested

Returns

the value of the coefficient name

Return type

Data

Raises

IllegalCoefficient – invalid coefficient name

getSystem()

Returns the operator and right hand side of the PDE.

Returns

the discrete version of the PDE

Return type

tuple of Operator and Data

setValues(**coefficients)

Sets new values to coefficients.

Parameters
  • coefficients – new values assigned to coefficients

  • lame_mu (any type that can be cast to a Scalar object on Function) – value for coefficient mu

  • lame_lambda (any type that can be cast to a Scalar object on Function) – value for coefficient lambda

  • F (any type that can be cast to a Vector object on Function) – value for internal force F

  • sigma (any type that can be cast to a Tensor object on Function) – value for initial stress sigma

  • f (any type that can be cast to a Vector object on FunctionOnBoundary) – value for external force f

  • r (any type that can be cast to a Vector object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – prescribed values r for the solution in constraints

  • q (any type that can be cast to a Vector object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – mask for the location of constraints

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.escript.linearPDEs.LinearPDE(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)

This class is used to define a general linear, steady, second order PDE for an unknown function u on a given domain defined through a Domain object.

For a single PDE having a solution with a single component the linear PDE is defined in the following form:

-(grad(A[j,l]+A_reduced[j,l])*grad(u)[l]+(B[j]+B_reduced[j])u)[j]+(C[l]+C_reduced[l])*grad(u)[l]+(D+D_reduced)=-grad(X+X_reduced)[j,j]+(Y+Y_reduced)

where grad(F) denotes the spatial derivative of F. Einstein’s summation convention, ie. summation over indexes appearing twice in a term of a sum performed, is used. The coefficients A, B, C, D, X and Y have to be specified through Data objects in Function and the coefficients A_reduced, B_reduced, C_reduced, D_reduced, X_reduced and Y_reduced have to be specified through Data objects in ReducedFunction. It is also allowed to use objects that can be converted into such Data objects. A and A_reduced are rank two, B, C, X, B_reduced, C_reduced and X_reduced are rank one and D, D_reduced, Y and Y_reduced are scalar.

The following natural boundary conditions are considered:

n[j]*((A[i,j]+A_reduced[i,j])*grad(u)[l]+(B+B_reduced)[j]*u)+(d+d_reduced)*u=n[j]*(X[j]+X_reduced[j])+y

where n is the outer normal field. Notice that the coefficients A, A_reduced, B, B_reduced, X and X_reduced are defined in the PDE. The coefficients d and y are each a scalar in FunctionOnBoundary and the coefficients d_reduced and y_reduced are each a scalar in ReducedFunctionOnBoundary.

Constraints for the solution prescribe the value of the solution at certain locations in the domain. They have the form

u=r where q>0

r and q are each scalar where q is the characteristic function defining where the constraint is applied. The constraints override any other condition set by the PDE or the boundary condition.

The PDE is symmetrical if

A[i,j]=A[j,i] and B[j]=C[j] and A_reduced[i,j]=A_reduced[j,i] and B_reduced[j]=C_reduced[j]

For a system of PDEs and a solution with several components the PDE has the form

-grad((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])[j]+(C[i,k,l]+C_reduced[i,k,l])*grad(u[k])[l]+(D[i,k]+D_reduced[i,k]*u[k] =-grad(X[i,j]+X_reduced[i,j])[j]+Y[i]+Y_reduced[i]

A and A_reduced are of rank four, B, B_reduced, C and C_reduced are each of rank three, D, D_reduced, X_reduced and X are each of rank two and Y and Y_reduced are of rank one. The natural boundary conditions take the form:

n[j]*((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])+(d[i,k]+d_reduced[i,k])*u[k]=n[j]*(X[i,j]+X_reduced[i,j])+y[i]+y_reduced[i]

The coefficient d is of rank two and y is of rank one both in FunctionOnBoundary. The coefficients d_reduced is of rank two and y_reduced is of rank one both in ReducedFunctionOnBoundary.

Constraints take the form

u[i]=r[i] where q[i]>0

r and q are each rank one. Notice that at some locations not necessarily all components must have a constraint.

The system of PDEs is symmetrical if

  • A[i,j,k,l]=A[k,l,i,j]

  • A_reduced[i,j,k,l]=A_reduced[k,l,i,j]

  • B[i,j,k]=C[k,i,j]

  • B_reduced[i,j,k]=C_reduced[k,i,j]

  • D[i,k]=D[i,k]

  • D_reduced[i,k]=D_reduced[i,k]

  • d[i,k]=d[k,i]

  • d_reduced[i,k]=d_reduced[k,i]

LinearPDE also supports solution discontinuities over a contact region in the domain. To specify the conditions across the discontinuity we are using the generalised flux J which, in the case of a system of PDEs and several components of the solution, is defined as

J[i,j]=(A[i,j,k,l]+A_reduced[[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k]-X[i,j]-X_reduced[i,j]

For the case of single solution component and single PDE J is defined as

J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[j]+(B[i]+B_reduced[i])*u-X[i]-X_reduced[i]

In the context of discontinuities n denotes the normal on the discontinuity pointing from side 0 towards side 1 calculated from FunctionSpace.getNormal of FunctionOnContactZero. For a system of PDEs the contact condition takes the form

n[j]*J0[i,j]=n[j]*J1[i,j]=(y_contact[i]+y_contact_reduced[i])- (d_contact[i,k]+d_contact_reduced[i,k])*jump(u)[k]

where J0 and J1 are the fluxes on side 0 and side 1 of the discontinuity, respectively. jump(u), which is the difference of the solution at side 1 and at side 0, denotes the jump of u across discontinuity along the normal calculated by jump. The coefficient d_contact is of rank two and y_contact is of rank one both in FunctionOnContactZero or FunctionOnContactOne. The coefficient d_contact_reduced is of rank two and y_contact_reduced is of rank one both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne. In case of a single PDE and a single component solution the contact condition takes the form

n[j]*J0_{j}=n[j]*J1_{j}=(y_contact+y_contact_reduced)-(d_contact+y_contact_reduced)*jump(u)

In this case the coefficient d_contact and y_contact are each scalar both in FunctionOnContactZero or FunctionOnContactOne and the coefficient d_contact_reduced and y_contact_reduced are each scalar both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne.

Typical usage:

p = LinearPDE(dom)
p.setValue(A=kronecker(dom), D=1, Y=0.5)
u = p.getSolution()
__init__(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)

Initializes a new linear PDE.

Parameters
  • domain (Domain) – domain of the PDE

  • numEquations – number of equations. If None the number of equations is extracted from the PDE coefficients.

  • numSolutions – number of solution components. If None the number of solution components is extracted from the PDE coefficients.

  • debug – if True debug information is printed

checkSymmetry(verbose=True)

Tests the PDE for symmetry.

Parameters

verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed.

Returns

True if the PDE is symmetric

Return type

bool

Note

This is a very expensive operation. It should be used for degugging only! The symmetry flag is not altered.

createOperator()

Returns an instance of a new operator.

getFlux(u=None)

Returns the flux J for a given u.

J[i,j]=(A[i,j,k,l]+A_reduced[A[i,j,k,l]]*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])u[k]-X[i,j]-X_reduced[i,j]

or

J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[l]+(B[j]+B_reduced[j])u-X[j]-X_reduced[j]

Parameters

u (Data or None) – argument in the flux. If u is not present or equals None the current solution is used.

Returns

flux

Return type

Data

getRequiredOperatorType()

Returns the system type which needs to be used by the current set up.

getResidual(u=None)

Returns the residual of u or the current solution if u is not present.

Parameters

u (Data or None) – argument in the residual calculation. It must be representable in self.getFunctionSpaceForSolution(). If u is not present or equals None the current solution is used.

Returns

residual of u

Return type

Data

getSolution()

Returns the solution of the PDE.

Returns

the solution

Return type

Data

getSystem()

Returns the operator and right hand side of the PDE.

Returns

the discrete version of the PDE

Return type

tuple of Operator and Data

insertConstraint(rhs_only=False)

Applies the constraints defined by q and r to the PDE.

Parameters

rhs_only (bool) – if True only the right hand side is altered by the constraint

setValue(**coefficients)

Sets new values to coefficients.

Parameters
Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.escript.linearPDEs.LinearProblem(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)

This is the base class to define a general linear PDE-type problem for for an unknown function u on a given domain defined through a Domain object. The problem can be given as a single equation or as a system of equations.

The class assumes that some sort of assembling process is required to form a problem of the form

L u=f

where L is an operator and f is the right hand side. This operator problem will be solved to get the unknown u.

__init__(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)

Initializes a linear problem.

Parameters
  • domain (Domain) – domain of the PDE

  • numEquations – number of equations. If None the number of equations is extracted from the coefficients.

  • numSolutions – number of solution components. If None the number of solution components is extracted from the coefficients.

  • isComplex – if True this problem will have complex coefficients and a complex-valued result.

  • debug – if True debug information is printed

addPDEToLumpedSystem(operator, a, b, c, hrz_lumping)

adds a PDE to the lumped system, results depend on domain

Parameters
  • mat (OperatorAdapter) –

  • rhs (Data) –

  • a (Data) –

  • b (Data) –

  • c (Data) –

  • hrz_lumping (bool) –

addPDEToRHS(righthandside, X, Y, y, y_contact, y_dirac)

adds a PDE to the right hand side, results depend on domain

Parameters
  • mat (OperatorAdapter) –

  • righthandside (Data) –

  • X (Data) –

  • Y (Data) –

  • y (Data) –

  • y_contact (Data) –

  • y_dirac (Data) –

addPDEToSystem(operator, righthandside, A, B, C, D, X, Y, d, y, d_contact, y_contact, d_dirac, y_dirac)

adds a PDE to the system, results depend on domain

Parameters
addToRHS(rhs, data)

adds a PDE to the right hand side, results depend on domain

Parameters
  • mat (OperatorAdapter) –

  • righthandside (Data) –

  • data (list) –

addToSystem(op, rhs, data)

adds a PDE to the system, results depend on domain

Parameters
  • mat (OperatorAdapter) –

  • rhs (Data) –

  • data (list) –

alteredCoefficient(name)

Announces that coefficient name has been changed.

Parameters

name (string) – name of the coefficient affected

Raises

IllegalCoefficient – if name is not a coefficient of the PDE

Note

if name is q or r, the method will not trigger a rebuild of the system as constraints are applied to the solved system.

checkReciprocalSymmetry(name0, name1, verbose=True)

Tests two coefficients for reciprocal symmetry.

Parameters
  • name0 (str) – name of the first coefficient

  • name1 (str) – name of the second coefficient

  • verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed

Returns

True if coefficients name0 and name1 are reciprocally symmetric.

Return type

bool

checkSymmetricTensor(name, verbose=True)

Tests a coefficient for symmetry.

Parameters
  • name (str) – name of the coefficient

  • verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed.

Returns

True if coefficient name is symmetric

Return type

bool

checkSymmetry(verbose=True)

Tests the PDE for symmetry.

Parameters

verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed

Returns

True if the problem is symmetric

Return type

bool

Note

Typically this method is overwritten when implementing a particular linear problem.

createCoefficient(name)

Creates a Data object corresponding to coefficient name.

Returns

the coefficient name initialized to 0

Return type

Data

Raises

IllegalCoefficient – if name is not a coefficient of the PDE

createOperator()

Returns an instance of a new operator.

Note

This method is overwritten when implementing a particular linear problem.

createRightHandSide()

Returns an instance of a new right hand side.

createSolution()

Returns an instance of a new solution.

getCoefficient(name)

Returns the value of the coefficient name.

Parameters

name (string) – name of the coefficient requested

Returns

the value of the coefficient

Return type

Data

Raises

IllegalCoefficient – if name is not a coefficient of the PDE

getCurrentOperator()

Returns the operator in its current state.

getCurrentRightHandSide()

Returns the right hand side in its current state.

getCurrentSolution()

Returns the solution in its current state.

getDim()

Returns the spatial dimension of the PDE.

Returns

the spatial dimension of the PDE domain

Return type

int

getDomain()

Returns the domain of the PDE.

Returns

the domain of the PDE

Return type

Domain

getDomainStatus()

Return the status indicator of the domain

getFunctionSpaceForCoefficient(name)

Returns the FunctionSpace to be used for coefficient name.

Parameters

name (string) – name of the coefficient enquired

Returns

the function space to be used for coefficient name

Return type

FunctionSpace

Raises

IllegalCoefficient – if name is not a coefficient of the PDE

getFunctionSpaceForEquation()

Returns the FunctionSpace used to discretize the equation.

Returns

representation space of equation

Return type

FunctionSpace

getFunctionSpaceForSolution()

Returns the FunctionSpace used to represent the solution.

Returns

representation space of solution

Return type

FunctionSpace

getNumEquations()

Returns the number of equations.

Returns

the number of equations

Return type

int

Raises

UndefinedPDEError – if the number of equations is not specified yet

getNumSolutions()

Returns the number of unknowns.

Returns

the number of unknowns

Return type

int

Raises

UndefinedPDEError – if the number of unknowns is not specified yet

getOperator()

Returns the operator of the linear problem.

Returns

the operator of the problem

getOperatorType()

Returns the current system type.

getRequiredOperatorType()

Returns the system type which needs to be used by the current set up.

Note

Typically this method is overwritten when implementing a particular linear problem.

getRightHandSide()

Returns the right hand side of the linear problem.

Returns

the right hand side of the problem

Return type

Data

getShapeOfCoefficient(name)

Returns the shape of the coefficient name.

Parameters

name (string) – name of the coefficient enquired

Returns

the shape of the coefficient name

Return type

tuple of int

Raises

IllegalCoefficient – if name is not a coefficient of the PDE

getSolution(**options)

Returns the solution of the problem.

Returns

the solution

Return type

Data

Note

This method is overwritten when implementing a particular linear problem.

getSolverOptions()

Returns the solver options

Return type

SolverOptions

getSystem()

Returns the operator and right hand side of the PDE.

Returns

the discrete version of the PDE

Return type

tuple of Operator and Data.

Note

This method is overwritten when implementing a particular linear problem.

getSystemStatus()

Return the domain status used to build the current system

hasCoefficient(name)

Returns True if name is the name of a coefficient.

Parameters

name (string) – name of the coefficient enquired

Returns

True if name is the name of a coefficient of the general PDE, False otherwise

Return type

bool

initializeSystem()

Resets the system clearing the operator, right hand side and solution.

introduceCoefficients(**coeff)

Introduces new coefficients into the problem.

Use:

p.introduceCoefficients(A=PDECoef(…), B=PDECoef(…))

to introduce the coefficients A and B.

invalidateOperator()

Indicates the operator has to be rebuilt next time it is used.

invalidateRightHandSide()

Indicates the right hand side has to be rebuilt next time it is used.

invalidateSolution()

Indicates the PDE has to be resolved if the solution is requested.

invalidateSystem()

Announces that everything has to be rebuilt.

isComplex()

Returns true if this is a complex-valued LinearProblem, false if real-valued.

Return type

bool

isHermitian()

Checks if the pde is indicated to be Hermitian.

Returns

True if a Hermitian PDE is indicated, False otherwise

Return type

bool

Note

the method is equivalent to use getSolverOptions().isHermitian()

isOperatorValid()

Returns True if the operator is still valid.

isRightHandSideValid()

Returns True if the operator is still valid.

isSolutionValid()

Returns True if the solution is still valid.

isSymmetric()

Checks if symmetry is indicated.

Returns

True if a symmetric PDE is indicated, False otherwise

Return type

bool

Note

the method is equivalent to use getSolverOptions().isSymmetric()

isSystemValid()

Returns True if the system (including solution) is still vaild.

isUsingLumping()

Checks if matrix lumping is the current solver method.

Returns

True if the current solver method is lumping

Return type

bool

preservePreconditioner(preserve=True)

Notifies the PDE that the preconditioner should not be reset when making changes to the operator.

Building the preconditioner data can be quite expensive (e.g. for multigrid methods) so if it is known that changes to the operator are going to be minor calling this method can speed up successive PDE solves.

Note

Not all operator types support this.

Parameters

preserve (bool) – if True, preconditioner will be preserved, otherwise it will be reset when making changes to the operator, which is the default behaviour.

reduceEquationOrder()

Returns the status of order reduction for the equation.

Returns

True if reduced interpolation order is used for the representation of the equation, False otherwise

Return type

bool

reduceSolutionOrder()

Returns the status of order reduction for the solution.

Returns

True if reduced interpolation order is used for the representation of the solution, False otherwise

Return type

bool

resetAllCoefficients()

Resets all coefficients to their default values.

resetOperator()

Makes sure that the operator is instantiated and returns it initialized with zeros.

resetRightHandSide()

Sets the right hand side to zero.

resetRightHandSideCoefficients()

Resets all coefficients defining the right hand side

resetSolution()

Sets the solution to zero.

setDebug(flag)

Switches debug output on if flag is True otherwise it is switched off.

Parameters

flag (bool) – desired debug status

setDebugOff()

Switches debug output off.

setDebugOn()

Switches debug output on.

setHermitian(flag=False)

Sets the Hermitian flag to flag.

Parameters

flag (bool) – If True, the Hermitian flag is set otherwise reset.

Note

The method overwrites the Hermitian flag set by the solver options

setHermitianOff()

Clears the Hermitian flag. :note: The method overwrites the Hermitian flag set by the solver options

setHermitianOn()

Sets the Hermitian flag. :note: The method overwrites the Hermitian flag set by the solver options

setReducedOrderForEquationOff()

Switches reduced order off for equation representation.

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderForEquationOn()

Switches reduced order on for equation representation.

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderForEquationTo(flag=False)

Sets order reduction state for equation representation according to flag.

Parameters

flag (bool) – if flag is True, the order reduction is switched on for equation representation, otherwise or if flag is not present order reduction is switched off

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderForSolutionOff()

Switches reduced order off for solution representation

Raises

RuntimeError – if order reduction is altered after a coefficient has been set.

setReducedOrderForSolutionOn()

Switches reduced order on for solution representation.

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderForSolutionTo(flag=False)

Sets order reduction state for solution representation according to flag.

Parameters

flag (bool) – if flag is True, the order reduction is switched on for solution representation, otherwise or if flag is not present order reduction is switched off

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderOff()

Switches reduced order off for solution and equation representation

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderOn()

Switches reduced order on for solution and equation representation.

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setReducedOrderTo(flag=False)

Sets order reduction state for both solution and equation representation according to flag.

Parameters

flag (bool) – if True, the order reduction is switched on for both solution and equation representation, otherwise or if flag is not present order reduction is switched off

Raises

RuntimeError – if order reduction is altered after a coefficient has been set

setSolution(u, validate=True)

Sets the solution assuming that makes the system valid with the tolrance defined by the solver options

setSolverOptions(options=None)

Sets the solver options.

Parameters

options (SolverOptions or None) – the new solver options. If equal None, the solver options are set to the default.

Note

The symmetry flag of options is overwritten by the symmetry flag of the LinearProblem.

setSymmetry(flag=False)

Sets the symmetry flag to flag.

Parameters

flag (bool) – If True, the symmetry flag is set otherwise reset.

Note

The method overwrites the symmetry flag set by the solver options

setSymmetryOff()

Clears the symmetry flag. :note: The method overwrites the symmetry flag set by the solver options

setSymmetryOn()

Sets the symmetry flag. :note: The method overwrites the symmetry flag set by the solver options

setSystemStatus(status=None)

Sets the system status to status if status is not present the current status of the domain is used.

setValue(**coefficients)

Sets new values to coefficients.

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

shouldPreservePreconditioner()

Returns true if the preconditioner / factorisation should be kept even when resetting the operator.

Return type

bool

trace(text)

Prints the text message if debug mode is switched on.

Parameters

text (string) – message to be printed

validOperator()

Marks the operator as valid.

validRightHandSide()

Marks the right hand side as valid.

validSolution()

Marks the solution as valid.

class esys.escript.linearPDEs.Operator
__init__((object)arg1)None
isEmpty((Operator)arg1)bool :
Return type

bool

Returns

True if matrix is empty

nullifyRowsAndCols((Operator)arg1, (Data)arg2, (Data)arg3, (object)arg4)None
of((Operator)arg1, (Data)right)Data :

matrix*vector multiplication

resetValues((Operator)arg1, (object)arg2)None :

resets the matrix entries

saveHB((Operator)arg1, (str)filename)None :

writes the matrix to a file using the Harwell-Boeing file format

saveMM((Operator)arg1, (str)fileName)None :

writes the matrix to a file using the Matrix Market file format

solve((Operator)arg1, (Data)in, (object)options)Data :
Returns

the solution u of the linear system this*u=in

Parameters

in (Data) –

class esys.escript.linearPDEs.PDECoef(where, pattern, altering, isComplex=False)

A class for describing a PDE coefficient.

Variables
  • INTERIOR – indicator that coefficient is defined on the interior of the PDE domain

  • BOUNDARY – indicator that coefficient is defined on the boundary of the PDE domain

  • CONTACT – indicator that coefficient is defined on the contact region within the PDE domain

  • INTERIOR_REDUCED – indicator that coefficient is defined on the interior of the PDE domain using a reduced integration order

  • BOUNDARY_REDUCED – indicator that coefficient is defined on the boundary of the PDE domain using a reduced integration order

  • CONTACT_REDUCED – indicator that coefficient is defined on the contact region within the PDE domain using a reduced integration order

  • SOLUTION – indicator that coefficient is defined through a solution of the PDE

  • REDUCED – indicator that coefficient is defined through a reduced solution of the PDE

  • DIRACDELTA – indicator that coefficient is defined as Dirac delta functions

  • BY_EQUATION – indicator that the dimension of the coefficient shape is defined by the number of PDE equations

  • BY_SOLUTION – indicator that the dimension of the coefficient shape is defined by the number of PDE solutions

  • BY_DIM – indicator that the dimension of the coefficient shape is defined by the spatial dimension

  • OPERATOR – indicator that the coefficient alters the operator of the PDE

  • RIGHTHANDSIDE – indicator that the coefficient alters the right hand side of the PDE

  • BOTH – indicator that the coefficient alters the operator as well as the right hand side of the PDE

__init__(where, pattern, altering, isComplex=False)

Initialises a PDE coefficient type.

Parameters
  • where (one of INTERIOR, BOUNDARY, CONTACT, SOLUTION, REDUCED, INTERIOR_REDUCED, BOUNDARY_REDUCED, CONTACT_REDUCED, ‘DIRACDELTA’) – describes where the coefficient lives

  • pattern (tuple of BY_EQUATION, BY_SOLUTION, BY_DIM) – describes the shape of the coefficient and how the shape is built for a given spatial dimension and numbers of equations and solutions in then PDE. For instance, (BY_EQUATION,`BY_SOLUTION`,`BY_DIM`) describes a rank 3 coefficient which is instantiated as shape (3,2,2) in case of three equations and two solution components on a 2-dimensional domain. In the case of single equation and a single solution component the shape components marked by BY_EQUATION or BY_SOLUTION are dropped. In this case the example would be read as (2,).

  • altering (one of OPERATOR, RIGHTHANDSIDE, BOTH) – indicates what part of the PDE is altered if the coefficient is altered

  • isComplex (boolean) – if true, this coefficient is part of a complex-valued PDE and values will be converted to complex.

BOTH = 12
BOUNDARY = 1
BOUNDARY_REDUCED = 14
BY_DIM = 7
BY_EQUATION = 5
BY_SOLUTION = 6
CONTACT = 2
CONTACT_REDUCED = 15
DIRACDELTA = 16
INTERIOR = 0
INTERIOR_REDUCED = 13
OPERATOR = 10
REDUCED = 4
RIGHTHANDSIDE = 11
SOLUTION = 3
definesNumEquation()

Checks if the coefficient allows to estimate the number of equations.

Returns

True if the coefficient allows an estimate of the number of equations, False otherwise

Return type

bool

definesNumSolutions()

Checks if the coefficient allows to estimate the number of solution components.

Returns

True if the coefficient allows an estimate of the number of solution components, False otherwise

Return type

bool

estimateNumEquationsAndNumSolutions(domain, shape=())

Tries to estimate the number of equations and number of solutions if the coefficient has the given shape.

Parameters
  • domain (Domain) – domain on which the PDE uses the coefficient

  • shape (tuple of int values) – suggested shape of the coefficient

Returns

the number of equations and number of solutions of the PDE if the coefficient has given shape. If no appropriate numbers could be identified, None is returned

Return type

tuple of two int values or None

getFunctionSpace(domain, reducedEquationOrder=False, reducedSolutionOrder=False)

Returns the FunctionSpace of the coefficient.

Parameters
  • domain (Domain) – domain on which the PDE uses the coefficient

  • reducedEquationOrder (bool) – True to indicate that reduced order is used to represent the equation

  • reducedSolutionOrder (bool) – True to indicate that reduced order is used to represent the solution

Returns

FunctionSpace of the coefficient

Return type

FunctionSpace

getShape(domain, numEquations=1, numSolutions=1)

Builds the required shape of the coefficient.

Parameters
  • domain (Domain) – domain on which the PDE uses the coefficient

  • numEquations (int) – number of equations of the PDE

  • numSolutions (int) – number of components of the PDE solution

Returns

shape of the coefficient

Return type

tuple of int values

getValue()

Returns the value of the coefficient.

Returns

value of the coefficient

Return type

Data

isAlteringOperator()

Checks if the coefficient alters the operator of the PDE.

Returns

True if the operator of the PDE is changed when the coefficient is changed

Return type

bool

isAlteringRightHandSide()

Checks if the coefficient alters the right hand side of the PDE.

Return type

bool

Returns

True if the right hand side of the PDE is changed when the coefficient is changed, None otherwise.

isComplex()

Checks if the coefficient is complex-valued.

Return type

bool

Returns

True if the coefficient is complex-valued, False otherwise.

resetValue()

Resets the coefficient value to the default.

setValue(domain, numEquations=1, numSolutions=1, reducedEquationOrder=False, reducedSolutionOrder=False, newValue=None)

Sets the value of the coefficient to a new value.

Parameters
  • domain (Domain) – domain on which the PDE uses the coefficient

  • numEquations (int) – number of equations of the PDE

  • numSolutions (int) – number of components of the PDE solution

  • reducedEquationOrder (bool) – True to indicate that reduced order is used to represent the equation

  • reducedSolutionOrder (bool) – True to indicate that reduced order is used to represent the solution

  • newValue (any object that can be converted into a Data object with the appropriate shape and FunctionSpace) – new value of coefficient

Raises
class esys.escript.linearPDEs.Poisson(domain, debug=False)

Class to define a Poisson equation problem. This is generally a LinearPDE of the form

-grad(grad(u)[j])[j] = f

with natural boundary conditions

n[j]*grad(u)[j] = 0

and constraints:

u=0 where q>0

__init__(domain, debug=False)

Initializes a new Poisson equation.

Parameters
  • domain (Domain) – domain of the PDE

  • debug – if True debug information is printed

getCoefficient(name)

Returns the value of the coefficient name of the general PDE.

Parameters

name (string) – name of the coefficient requested

Returns

the value of the coefficient name

Return type

Data

Raises

IllegalCoefficient – invalid coefficient name

Note

This method is called by the assembling routine to map the Poisson equation onto the general PDE.

setValue(**coefficients)

Sets new values to coefficients.

Parameters
  • coefficients – new values assigned to coefficients

  • f (any type that can be cast to a Scalar object on Function) – value for right hand side f

  • q (any type that can be cast to a rank zero Data object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – mask for location of constraints

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.escript.linearPDEs.Reducer
__init__()

Raises an exception This class cannot be instantiated from Python

class esys.escript.linearPDEs.SolverBuddy
__init__((object)arg1)None
acceptConvergenceFailure((SolverBuddy)arg1)bool :

Returns True if a failure to meet the stopping criteria within the given number of iteration steps is not raising in exception. This is useful if a solver is used in a non-linear context where the non-linear solver can continue even if the returned the solution does not necessarily meet the stopping criteria. One can use the hasConverged method to check if the last call to the solver was successful.

Returns

True if a failure to achieve convergence is accepted.

Return type

bool

adaptInnerTolerance((SolverBuddy)arg1)bool :

Returns True if the tolerance of the inner solver is selected automatically. Otherwise the inner tolerance set by setInnerTolerance is used.

Returns

True if inner tolerance adaption is chosen.

Return type

bool

getAbsoluteTolerance((SolverBuddy)arg1)float :

Returns the absolute tolerance for the solver

Return type

float

getDiagnostics((SolverBuddy)arg1, (str)name)float :

Returns the diagnostic information name. Possible values are:

  • ‘num_iter’: the number of iteration steps

  • ‘cum_num_iter’: the cumulative number of iteration steps

  • ‘num_level’: the number of level in multi level solver

  • ‘num_inner_iter’: the number of inner iteration steps

  • ‘cum_num_inner_iter’: the cumulative number of inner iteration steps

  • ‘time’: execution time

  • ‘cum_time’: cumulative execution time

  • ‘set_up_time’: time to set up of the solver, typically this includes factorization and reordering

  • ‘cum_set_up_time’: cumulative time to set up of the solver

  • ‘net_time’: net execution time, excluding setup time for the solver and execution time for preconditioner

  • ‘cum_net_time’: cumulative net execution time

  • ‘preconditioner_size’: size of preconditioner [Bytes]

  • ‘converged’: return True if solution has converged.

  • ‘time_step_backtracking_used’: returns True if time step back tracking has been used.

  • ‘coarse_level_sparsity’: returns the sparsity of the matrix on the coarsest level

  • ‘num_coarse_unknowns’: returns the number of unknowns on the coarsest level

Parameters

name (str in the list above.) – name of diagnostic information to return

Returns

requested value. 0 is returned if the value is yet to be defined.

Note

If the solver has thrown an exception diagnostic values have an undefined status.

getDim((SolverBuddy)arg1)int :

Returns the dimension of the problem.

Return type

int

getDropStorage((SolverBuddy)arg1)float :

Returns the maximum allowed increase in storage for ILUT

Return type

float

getDropTolerance((SolverBuddy)arg1)float :

Returns the relative drop tolerance in ILUT

Return type

float

getInnerIterMax((SolverBuddy)arg1)int :

Returns maximum number of inner iteration steps

Return type

int

getInnerTolerance((SolverBuddy)arg1)float :

Returns the relative tolerance for an inner iteration scheme

Return type

float

getIterMax((SolverBuddy)arg1)int :

Returns maximum number of iteration steps

Return type

int

getName((SolverBuddy)arg1, (object)key)str :

Returns the name of a given key

Parameters

key – a valid key

getNumRefinements((SolverBuddy)arg1)int :

Returns the number of refinement steps to refine the solution when a direct solver is applied.

Return type

non-negative int

getNumSweeps((SolverBuddy)arg1)int :

Returns the number of sweeps in a Jacobi or Gauss-Seidel/SOR preconditioner.

Return type

int

getODESolver((SolverBuddy)arg1)SolverOptions :

Returns key of the solver method for ODEs.

Parameters

method (in CRANK_NICOLSON, BACKWARD_EULER, LINEAR_CRANK_NICOLSON) – key of the ODE solver method to be used.

getPackage((SolverBuddy)arg1)SolverOptions :

Returns the solver package key

Return type

in the list DEFAULT, PASO, CUSP, MKL, UMFPACK, MUMPS, TRILINOS

getPreconditioner((SolverBuddy)arg1)SolverOptions :

Returns the key of the preconditioner to be used.

Return type

in the list ILU0, ILUT, JACOBI, AMG, REC_ILU, GAUSS_SEIDEL, RILU, NO_PRECONDITIONER

getRelaxationFactor((SolverBuddy)arg1)float :

Returns the relaxation factor used to add dropped elements in RILU to the main diagonal.

Return type

float

getReordering((SolverBuddy)arg1)SolverOptions :

Returns the key of the reordering method to be applied if supported by the solver.

Return type

in NO_REORDERING, MINIMUM_FILL_IN, NESTED_DISSECTION, DEFAULT_REORDERING

getRestart((SolverBuddy)arg1)int :

Returns the number of iterations steps after which GMRES performs a restart. If 0 is returned no restart is performed.

Return type

int

getSolverMethod((SolverBuddy)arg1)SolverOptions :

Returns key of the solver method to be used.

Return type

in the list DEFAULT, DIRECT, CHOLEVSKY, PCG, CR, CGS, BICGSTAB, GMRES, PRES20, ROWSUM_LUMPING, HRZ_LUMPING, MINRES, ITERATIVE, NONLINEAR_GMRES, TFQMR

getSummary((SolverBuddy)arg1)str :

Returns a string reporting the current settings

getTolerance((SolverBuddy)arg1)float :

Returns the relative tolerance for the solver

Return type

float

getTrilinosParameters((SolverBuddy)arg1)dict :

Returns a dictionary of set Trilinos parameters.

:note This method returns an empty dictionary in a non-Trilinos build.

getTruncation((SolverBuddy)arg1)int :

Returns the number of residuals in GMRES to be stored for orthogonalization

Return type

int

hasConverged((SolverBuddy)arg1)bool :

Returns True if the last solver call has been finalized successfully.

Note

if an exception has been thrown by the solver the status of thisflag is undefined.

isComplex((SolverBuddy)arg1)bool :

Checks if the coefficient matrix is set to be complex-valued.

Returns

True if a complex-valued PDE is indicated, False otherwise

Return type

bool

isHermitian((SolverBuddy)arg1)bool :

Checks if the coefficient matrix is indicated to be Hermitian.

Returns

True if a hermitian PDE is indicated, False otherwise

Return type

bool

isSymmetric((SolverBuddy)arg1)bool :

Checks if symmetry of the coefficient matrix is indicated.

Returns

True if a symmetric PDE is indicated, False otherwise

Return type

bool

isVerbose((SolverBuddy)arg1)bool :

Returns True if the solver is expected to be verbose.

Returns

True if verbosity of switched on.

Return type

bool

resetDiagnostics((SolverBuddy)arg1[, (object)all=False])None :

Resets the diagnostics

Parameters

all (bool) – if all is True all diagnostics including accumulative counters are reset.

setAbsoluteTolerance((SolverBuddy)arg1, (object)atol)None :

Sets the absolute tolerance for the solver

Parameters

atol (non-negative float) – absolute tolerance

setAcceptanceConvergenceFailure((SolverBuddy)arg1, (object)accept)None :

Sets the flag to indicate the acceptance of a failure of convergence.

Parameters

accept (bool) – If True, any failure to achieve convergence is accepted.

setAcceptanceConvergenceFailureOff((SolverBuddy)arg1)None :

Switches the acceptance of a failure of convergence off.

setAcceptanceConvergenceFailureOn((SolverBuddy)arg1)None :

Switches the acceptance of a failure of convergence on

setComplex((SolverBuddy)arg1, (object)complex)None :

Sets the complex flag for the coefficient matrix to flag.

Parameters

flag (bool) – If True, the complex flag is set otherwise reset.

setDim((SolverBuddy)arg1, (object)dim)None :

Sets the dimension of the problem.

Parameters

dim – Either 2 or 3.

Return type

int

setDropStorage((SolverBuddy)arg1, (object)drop)None :

Sets the maximum allowed increase in storage for ILUT. storage =2 would mean that a doubling of the storage needed for the coefficient matrix is allowed in the ILUT factorization.

Parameters

storage (float) – allowed storage increase

setDropTolerance((SolverBuddy)arg1, (object)drop_tol)None :

Sets the relative drop tolerance in ILUT

Parameters

drop_tol (positive float) – drop tolerance

setHermitian((SolverBuddy)arg1, (object)hermitian)None :

Sets the hermitian flag for the coefficient matrix to flag.

Parameters

flag (bool) – If True, the hermitian flag is set otherwise reset.

setHermitianOff((SolverBuddy)arg1)None :

Clears the hermitian flag for the coefficient matrix.

setHermitianOn((SolverBuddy)arg1)None :

Sets the hermitian flag to indicate that the coefficient matrix is hermitian.

setInnerIterMax((SolverBuddy)arg1, (object)iter_max)None :

Sets the maximum number of iteration steps for the inner iteration.

Parameters

iter_max (int) – maximum number of inner iterations

setInnerTolerance((SolverBuddy)arg1, (object)rtol)None :

Sets the relative tolerance for an inner iteration scheme, for instance on the coarsest level in a multi-level scheme.

Parameters

rtol (positive float) – inner relative tolerance

setInnerToleranceAdaption((SolverBuddy)arg1, (object)adapt)None :

Sets the flag to indicate automatic selection of the inner tolerance.

Parameters

adapt (bool) – If True, the inner tolerance is selected automatically.

setInnerToleranceAdaptionOff((SolverBuddy)arg1)None :

Switches the automatic selection of inner tolerance off.

setInnerToleranceAdaptionOn((SolverBuddy)arg1)None :

Switches the automatic selection of inner tolerance on

setIterMax((SolverBuddy)arg1, (object)iter_max)None :

Sets the maximum number of iteration steps

Parameters

iter_max (int) – maximum number of iteration steps

setLocalPreconditioner((SolverBuddy)arg1, (object)local)None :

Sets the flag to use local preconditioning

Parameters

use (bool) – If True, local preconditioning on each MPI rank is applied

setLocalPreconditionerOff((SolverBuddy)arg1)None :

Sets the flag to use local preconditioning to off

setLocalPreconditionerOn((SolverBuddy)arg1)None :

Sets the flag to use local preconditioning to on

setNumRefinements((SolverBuddy)arg1, (object)refinements)None :

Sets the number of refinement steps to refine the solution when a direct solver is applied.

Parameters

refinements (non-negative int) – number of refinements

setNumSweeps((SolverBuddy)arg1, (object)sweeps)None :

Sets the number of sweeps in a Jacobi or Gauss-Seidel/SOR preconditioner.

Parameters

sweeps (positive int) – number of sweeps

setODESolver((SolverBuddy)arg1, (object)solver)None :

Set the solver method for ODEs.

Parameters

method (in CRANK_NICOLSON, BACKWARD_EULER, LINEAR_CRANK_NICOLSON) – key of the ODE solver method to be used.

setPackage((SolverBuddy)arg1, (object)package)None :

Sets the solver package to be used as a solver.

Parameters

package (in DEFAULT, PASO, CUSP, MKL, UMFPACK, MUMPS, TRILINOS) – key of the solver package to be used.

Note

Not all packages are support on all implementation. An exception may be thrown on some platforms if a particular package is requested.

setPreconditioner((SolverBuddy)arg1, (object)preconditioner)None :

Sets the preconditioner to be used.

Parameters

preconditioner (in ILU0, ILUT, JACOBI, AMG, , REC_ILU, GAUSS_SEIDEL, RILU, NO_PRECONDITIONER) – key of the preconditioner to be used.

Note

Not all packages support all preconditioner. It can be assumed that a package makes a reasonable choice if it encounters an unknownpreconditioner.

setRelaxationFactor((SolverBuddy)arg1, (object)relaxation)None :

Sets the relaxation factor used to add dropped elements in RILU to the main diagonal.

Parameters

factor (float) – relaxation factor

Note

RILU with a relaxation factor 0 is identical to ILU0

setReordering((SolverBuddy)arg1, (object)ordering)None :

Sets the key of the reordering method to be applied if supported by the solver. Some direct solvers support reordering to optimize compute time and storage use during elimination.

Parameters

ordering (in 'NO_REORDERING', 'MINIMUM_FILL_IN', 'NESTED_DISSECTION', 'DEFAULT_REORDERING') – selects the reordering strategy.

setRestart((SolverBuddy)arg1, (object)restart)None :

Sets the number of iterations steps after which GMRES performs a restart.

Parameters

restart (int) – number of iteration steps after which to perform a restart. If 0 no restart is performed.

setSolverMethod((SolverBuddy)arg1, (object)method)None :

Sets the solver method to be used. Use method``=``DIRECT to indicate that a direct rather than an iterative solver should be used and use method``=``ITERATIVE to indicate that an iterative rather than a direct solver should be used.

Parameters

method (in DEFAULT, DIRECT, CHOLEVSKY, PCG, CR, CGS, BICGSTAB, GMRES, PRES20, ROWSUM_LUMPING, HRZ_LUMPING, ITERATIVE, NONLINEAR_GMRES, TFQMR, MINRES) – key of the solver method to be used.

Note

Not all packages support all solvers. It can be assumed that a package makes a reasonable choice if it encounters an unknown solver method.

setSymmetry((SolverBuddy)arg1, (object)symmetry)None :

Sets the symmetry flag for the coefficient matrix to flag.

Parameters

flag (bool) – If True, the symmetry flag is set otherwise reset.

setSymmetryOff((SolverBuddy)arg1)None :

Clears the symmetry flag for the coefficient matrix.

setSymmetryOn((SolverBuddy)arg1)None :

Sets the symmetry flag to indicate that the coefficient matrix is symmetric.

setTolerance((SolverBuddy)arg1, (object)rtol)None :

Sets the relative tolerance for the solver

Parameters

rtol (non-negative float) – relative tolerance

setTrilinosParameter((SolverBuddy)arg1, (str)arg2, (object)arg3)None :

Sets a Trilinos preconditioner/solver parameter.

:note Escript does not check for validity of the parameter name (e.g. spelling mistakes). Parameters are passed 1:1 to escript’s Trilinos wrapper and from there to the relevant Trilinos package. See the relevant Trilinos documentation for valid parameter strings and values.:note This method does nothing in a non-Trilinos build.

setTruncation((SolverBuddy)arg1, (object)truncation)None :

Sets the number of residuals in GMRES to be stored for orthogonalization. The more residuals are stored the faster GMRES converged

Parameters

truncation (int) – truncation

setVerbosity((SolverBuddy)arg1, (object)verbosity)None :

Sets the verbosity flag for the solver to flag.

Parameters

verbose (bool) – If True, the verbosity of the solver is switched on.

setVerbosityOff((SolverBuddy)arg1)None :

Switches the verbosity of the solver off.

setVerbosityOn((SolverBuddy)arg1)None :

Switches the verbosity of the solver on.

useLocalPreconditioner((SolverBuddy)arg1)bool :

Returns True if the preconditoner is applied locally on each MPI. This reduces communication costs and speeds up the application of the preconditioner but at the costs of more iteration steps. This can be an advantage on clusters with slower interconnects.

Returns

True if local preconditioning is applied

Return type

bool

class esys.escript.linearPDEs.SolverOptions
__init__()

Initialize self. See help(type(self)) for accurate signature.

AMG = esys.escriptcore.escriptcpp.SolverOptions.AMG
BACKWARD_EULER = esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER
BICGSTAB = esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB
CGLS = esys.escriptcore.escriptcpp.SolverOptions.CGLS
CGS = esys.escriptcore.escriptcpp.SolverOptions.CGS
CHOLEVSKY = esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY
CLASSIC_INTERPOLATION = esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION
CLASSIC_INTERPOLATION_WITH_FF_COUPLING = esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION_WITH_FF_COUPLING
CR = esys.escriptcore.escriptcpp.SolverOptions.CR
CRANK_NICOLSON = esys.escriptcore.escriptcpp.SolverOptions.CRANK_NICOLSON
DEFAULT = esys.escriptcore.escriptcpp.SolverOptions.DEFAULT
DEFAULT_REORDERING = esys.escriptcore.escriptcpp.SolverOptions.DEFAULT_REORDERING
DIRECT = esys.escriptcore.escriptcpp.SolverOptions.DIRECT
DIRECT_INTERPOLATION = esys.escriptcore.escriptcpp.SolverOptions.DIRECT_INTERPOLATION
DIRECT_MUMPS = esys.escriptcore.escriptcpp.SolverOptions.DIRECT_MUMPS
DIRECT_PARDISO = esys.escriptcore.escriptcpp.SolverOptions.DIRECT_PARDISO
DIRECT_SUPERLU = esys.escriptcore.escriptcpp.SolverOptions.DIRECT_SUPERLU
DIRECT_TRILINOS = esys.escriptcore.escriptcpp.SolverOptions.DIRECT_TRILINOS
GAUSS_SEIDEL = esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL
GMRES = esys.escriptcore.escriptcpp.SolverOptions.GMRES
HRZ_LUMPING = esys.escriptcore.escriptcpp.SolverOptions.HRZ_LUMPING
ILU0 = esys.escriptcore.escriptcpp.SolverOptions.ILU0
ILUT = esys.escriptcore.escriptcpp.SolverOptions.ILUT
ITERATIVE = esys.escriptcore.escriptcpp.SolverOptions.ITERATIVE
JACOBI = esys.escriptcore.escriptcpp.SolverOptions.JACOBI
LINEAR_CRANK_NICOLSON = esys.escriptcore.escriptcpp.SolverOptions.LINEAR_CRANK_NICOLSON
LSQR = esys.escriptcore.escriptcpp.SolverOptions.LSQR
LUMPING = esys.escriptcore.escriptcpp.SolverOptions.LUMPING
MINIMUM_FILL_IN = esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN
MINRES = esys.escriptcore.escriptcpp.SolverOptions.MINRES
MKL = esys.escriptcore.escriptcpp.SolverOptions.MKL
MUMPS = esys.escriptcore.escriptcpp.SolverOptions.MUMPS
NESTED_DISSECTION = esys.escriptcore.escriptcpp.SolverOptions.NESTED_DISSECTION
NONLINEAR_GMRES = esys.escriptcore.escriptcpp.SolverOptions.NONLINEAR_GMRES
NO_PRECONDITIONER = esys.escriptcore.escriptcpp.SolverOptions.NO_PRECONDITIONER
NO_REORDERING = esys.escriptcore.escriptcpp.SolverOptions.NO_REORDERING
PASO = esys.escriptcore.escriptcpp.SolverOptions.PASO
PCG = esys.escriptcore.escriptcpp.SolverOptions.PCG
PRES20 = esys.escriptcore.escriptcpp.SolverOptions.PRES20
REC_ILU = esys.escriptcore.escriptcpp.SolverOptions.REC_ILU
RILU = esys.escriptcore.escriptcpp.SolverOptions.RILU
ROWSUM_LUMPING = esys.escriptcore.escriptcpp.SolverOptions.ROWSUM_LUMPING
TFQMR = esys.escriptcore.escriptcpp.SolverOptions.TFQMR
TRILINOS = esys.escriptcore.escriptcpp.SolverOptions.TRILINOS
UMFPACK = esys.escriptcore.escriptcpp.SolverOptions.UMFPACK
names = {'AMG': esys.escriptcore.escriptcpp.SolverOptions.AMG, 'BACKWARD_EULER': esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER, 'BICGSTAB': esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB, 'CGLS': esys.escriptcore.escriptcpp.SolverOptions.CGLS, 'CGS': esys.escriptcore.escriptcpp.SolverOptions.CGS, 'CHOLEVSKY': esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY, 'CLASSIC_INTERPOLATION': esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION, 'CLASSIC_INTERPOLATION_WITH_FF_COUPLING': esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION_WITH_FF_COUPLING, 'CR': esys.escriptcore.escriptcpp.SolverOptions.CR, 'CRANK_NICOLSON': esys.escriptcore.escriptcpp.SolverOptions.CRANK_NICOLSON, 'DEFAULT': esys.escriptcore.escriptcpp.SolverOptions.DEFAULT, 'DEFAULT_REORDERING': esys.escriptcore.escriptcpp.SolverOptions.DEFAULT_REORDERING, 'DIRECT': esys.escriptcore.escriptcpp.SolverOptions.DIRECT, 'DIRECT_INTERPOLATION': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_INTERPOLATION, 'DIRECT_MUMPS': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_MUMPS, 'DIRECT_PARDISO': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_PARDISO, 'DIRECT_SUPERLU': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_SUPERLU, 'DIRECT_TRILINOS': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_TRILINOS, 'GAUSS_SEIDEL': esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL, 'GMRES': esys.escriptcore.escriptcpp.SolverOptions.GMRES, 'HRZ_LUMPING': esys.escriptcore.escriptcpp.SolverOptions.HRZ_LUMPING, 'ILU0': esys.escriptcore.escriptcpp.SolverOptions.ILU0, 'ILUT': esys.escriptcore.escriptcpp.SolverOptions.ILUT, 'ITERATIVE': esys.escriptcore.escriptcpp.SolverOptions.ITERATIVE, 'JACOBI': esys.escriptcore.escriptcpp.SolverOptions.JACOBI, 'LINEAR_CRANK_NICOLSON': esys.escriptcore.escriptcpp.SolverOptions.LINEAR_CRANK_NICOLSON, 'LSQR': esys.escriptcore.escriptcpp.SolverOptions.LSQR, 'LUMPING': esys.escriptcore.escriptcpp.SolverOptions.LUMPING, 'MINIMUM_FILL_IN': esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN, 'MINRES': esys.escriptcore.escriptcpp.SolverOptions.MINRES, 'MKL': esys.escriptcore.escriptcpp.SolverOptions.MKL, 'MUMPS': esys.escriptcore.escriptcpp.SolverOptions.MUMPS, 'NESTED_DISSECTION': esys.escriptcore.escriptcpp.SolverOptions.NESTED_DISSECTION, 'NONLINEAR_GMRES': esys.escriptcore.escriptcpp.SolverOptions.NONLINEAR_GMRES, 'NO_PRECONDITIONER': esys.escriptcore.escriptcpp.SolverOptions.NO_PRECONDITIONER, 'NO_REORDERING': esys.escriptcore.escriptcpp.SolverOptions.NO_REORDERING, 'PASO': esys.escriptcore.escriptcpp.SolverOptions.PASO, 'PCG': esys.escriptcore.escriptcpp.SolverOptions.PCG, 'PRES20': esys.escriptcore.escriptcpp.SolverOptions.PRES20, 'REC_ILU': esys.escriptcore.escriptcpp.SolverOptions.REC_ILU, 'RILU': esys.escriptcore.escriptcpp.SolverOptions.RILU, 'ROWSUM_LUMPING': esys.escriptcore.escriptcpp.SolverOptions.ROWSUM_LUMPING, 'TFQMR': esys.escriptcore.escriptcpp.SolverOptions.TFQMR, 'TRILINOS': esys.escriptcore.escriptcpp.SolverOptions.TRILINOS, 'UMFPACK': esys.escriptcore.escriptcpp.SolverOptions.UMFPACK}
values = {0: esys.escriptcore.escriptcpp.SolverOptions.DEFAULT, 3: esys.escriptcore.escriptcpp.SolverOptions.MKL, 4: esys.escriptcore.escriptcpp.SolverOptions.PASO, 5: esys.escriptcore.escriptcpp.SolverOptions.TRILINOS, 6: esys.escriptcore.escriptcpp.SolverOptions.UMFPACK, 7: esys.escriptcore.escriptcpp.SolverOptions.MUMPS, 8: esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB, 9: esys.escriptcore.escriptcpp.SolverOptions.CGLS, 10: esys.escriptcore.escriptcpp.SolverOptions.CGS, 11: esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY, 12: esys.escriptcore.escriptcpp.SolverOptions.CR, 13: esys.escriptcore.escriptcpp.SolverOptions.DIRECT, 14: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_MUMPS, 15: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_PARDISO, 16: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_SUPERLU, 17: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_TRILINOS, 18: esys.escriptcore.escriptcpp.SolverOptions.GMRES, 19: esys.escriptcore.escriptcpp.SolverOptions.HRZ_LUMPING, 20: esys.escriptcore.escriptcpp.SolverOptions.ITERATIVE, 21: esys.escriptcore.escriptcpp.SolverOptions.LSQR, 22: esys.escriptcore.escriptcpp.SolverOptions.MINRES, 23: esys.escriptcore.escriptcpp.SolverOptions.NONLINEAR_GMRES, 24: esys.escriptcore.escriptcpp.SolverOptions.PCG, 25: esys.escriptcore.escriptcpp.SolverOptions.PRES20, 26: esys.escriptcore.escriptcpp.SolverOptions.ROWSUM_LUMPING, 27: esys.escriptcore.escriptcpp.SolverOptions.TFQMR, 28: esys.escriptcore.escriptcpp.SolverOptions.AMG, 29: esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL, 30: esys.escriptcore.escriptcpp.SolverOptions.ILU0, 31: esys.escriptcore.escriptcpp.SolverOptions.ILUT, 32: esys.escriptcore.escriptcpp.SolverOptions.JACOBI, 33: esys.escriptcore.escriptcpp.SolverOptions.NO_PRECONDITIONER, 34: esys.escriptcore.escriptcpp.SolverOptions.REC_ILU, 35: esys.escriptcore.escriptcpp.SolverOptions.RILU, 36: esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER, 37: esys.escriptcore.escriptcpp.SolverOptions.CRANK_NICOLSON, 38: esys.escriptcore.escriptcpp.SolverOptions.LINEAR_CRANK_NICOLSON, 39: esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION, 40: esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION_WITH_FF_COUPLING, 41: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_INTERPOLATION, 42: esys.escriptcore.escriptcpp.SolverOptions.DEFAULT_REORDERING, 43: esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN, 44: esys.escriptcore.escriptcpp.SolverOptions.NESTED_DISSECTION, 45: esys.escriptcore.escriptcpp.SolverOptions.NO_REORDERING}
class esys.escript.linearPDEs.SubWorld

Information about a group of workers.

__init__()

Raises an exception This class cannot be instantiated from Python

class esys.escript.linearPDEs.TestDomain

Test Class for domains with no structure. May be removed from future releases without notice.

__init__()

Raises an exception This class cannot be instantiated from Python

class esys.escript.linearPDEs.TransportPDE(domain, numEquations=None, numSolutions=None, useBackwardEuler=None, debug=False)

This class is used to define a transport problem given by a general linear, time dependent, second order PDE for an unknown, non-negative, time-dependent function u on a given domain defined through a Domain object.

For a single equation with a solution with a single component the transport problem is defined in the following form:

(M+M_reduced)*u_t=-(grad(A[j,l]+A_reduced[j,l]) * grad(u)[l]+(B[j]+B_reduced[j])u)[j]+(C[l]+C_reduced[l])*grad(u)[l]+(D+D_reduced)-grad(X+X_reduced)[j,j]+(Y+Y_reduced)

where u_t denotes the time derivative of u and grad(F) denotes the spatial derivative of F. Einstein’s summation convention, ie. summation over indexes appearing twice in a term of a sum performed, is used. The coefficients M, A, B, C, D, X and Y have to be specified through Data objects in Function and the coefficients M_reduced, A_reduced, B_reduced, C_reduced, D_reduced, X_reduced and Y_reduced have to be specified through Data objects in ReducedFunction. It is also allowed to use objects that can be converted into such Data objects. M and M_reduced are scalar, A and A_reduced are rank two, B, C, X, B_reduced, C_reduced and X_reduced are rank one and D, D_reduced, Y and Y_reduced are scalar.

The following natural boundary conditions are considered:

n[j]*((A[i,j]+A_reduced[i,j])*grad(u)[l]+(B+B_reduced)[j]*u+X[j]+X_reduced[j])+(d+d_reduced)*u+y+y_reduced=(m+m_reduced)*u_t

where n is the outer normal field. Notice that the coefficients A, A_reduced, B, B_reduced, X and X_reduced are defined in the transport problem. The coefficients m, d and y are each a scalar in FunctionOnBoundary and the coefficients m_reduced, d_reduced and y_reduced are each a scalar in ReducedFunctionOnBoundary.

Constraints for the solution prescribing the value of the solution at certain locations in the domain have the form

u_t=r where q>0

r and q are each scalar where q is the characteristic function defining where the constraint is applied. The constraints override any other condition set by the transport problem or the boundary condition.

The transport problem is symmetrical if

A[i,j]=A[j,i] and B[j]=C[j] and A_reduced[i,j]=A_reduced[j,i] and B_reduced[j]=C_reduced[j]

For a system and a solution with several components the transport problem has the form

(M[i,k]+M_reduced[i,k]) * u[k]_t=-grad((A[i,j,k,l]+A_reduced[i,j,k,l]) * grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k]) * u[k])[j]+(C[i,k,l]+C_reduced[i,k,l]) * grad(u[k])[l]+(D[i,k]+D_reduced[i,k] * u[k]-grad(X[i,j]+X_reduced[i,j])[j]+Y[i]+Y_reduced[i]

A and A_reduced are of rank four, B, B_reduced, C and C_reduced are each of rank three, M, M_reduced, D, D_reduced, X_reduced and X are each of rank two and Y and Y_reduced are of rank one. The natural boundary conditions take the form:

n[j]*((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k]+X[i,j]+X_reduced[i,j])+(d[i,k]+d_reduced[i,k])*u[k]+y[i]+y_reduced[i]= (m[i,k]+m_reduced[i,k])*u[k]_t

The coefficient d and m are of rank two and y is of rank one with all in FunctionOnBoundary. The coefficients d_reduced and m_reduced are of rank two and y_reduced is of rank one all in ReducedFunctionOnBoundary.

Constraints take the form

u[i]_t=r[i] where q[i]>0

r and q are each rank one. Notice that at some locations not necessarily all components must have a constraint.

The transport problem is symmetrical if

  • M[i,k]=M[i,k]

  • M_reduced[i,k]=M_reduced[i,k]

  • A[i,j,k,l]=A[k,l,i,j]

  • A_reduced[i,j,k,l]=A_reduced[k,l,i,j]

  • B[i,j,k]=C[k,i,j]

  • B_reduced[i,j,k]=C_reduced[k,i,j]

  • D[i,k]=D[i,k]

  • D_reduced[i,k]=D_reduced[i,k]

  • m[i,k]=m[k,i]

  • m_reduced[i,k]=m_reduced[k,i]

  • d[i,k]=d[k,i]

  • d_reduced[i,k]=d_reduced[k,i]

  • d_dirac[i,k]=d_dirac[k,i]

TransportPDE also supports solution discontinuities over a contact region in the domain. To specify the conditions across the discontinuity we are using the generalised flux J which, in the case of a system of PDEs and several components of the solution, is defined as

J[i,j]=(A[i,j,k,l]+A_reduced[[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k]+X[i,j]+X_reduced[i,j]

For the case of single solution component and single PDE J is defined as

J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[j]+(B[i]+B_reduced[i])*u+X[i]+X_reduced[i]

In the context of discontinuities n denotes the normal on the discontinuity pointing from side 0 towards side 1 calculated from FunctionSpace.getNormal of FunctionOnContactZero. For a system of transport problems the contact condition takes the form

n[j]*J0[i,j]=n[j]*J1[i,j]=(y_contact[i]+y_contact_reduced[i])- (d_contact[i,k]+d_contact_reduced[i,k])*jump(u)[k]

where J0 and J1 are the fluxes on side 0 and side 1 of the discontinuity, respectively. jump(u), which is the difference of the solution at side 1 and at side 0, denotes the jump of u across discontinuity along the normal calculated by jump. The coefficient d_contact is of rank two and y_contact is of rank one both in FunctionOnContactZero or FunctionOnContactOne. The coefficient d_contact_reduced is of rank two and y_contact_reduced is of rank one both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne. In case of a single PDE and a single component solution the contact condition takes the form

n[j]*J0_{j}=n[j]*J1_{j}=(y_contact+y_contact_reduced)-(d_contact+y_contact_reduced)*jump(u)

In this case the coefficient d_contact and y_contact are each scalar both in FunctionOnContactZero or FunctionOnContactOne and the coefficient d_contact_reduced and y_contact_reduced are each scalar both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne.

Typical usage:

p = TransportPDE(dom)
p.setValue(M=1., C=[-1.,0.])
p.setInitialSolution(u=exp(-length(dom.getX()-[0.1,0.1])**2)
t = 0
dt = 0.1
while (t < 1.):
    u = p.solve(dt)
__init__(domain, numEquations=None, numSolutions=None, useBackwardEuler=None, debug=False)

Initializes a transport problem.

Parameters
  • domain (Domain) – domain of the PDE

  • numEquations – number of equations. If None the number of equations is extracted from the coefficients.

  • numSolutions – number of solution components. If None the number of solution components is extracted from the coefficients.

  • debug – if True debug information is printed

addPDEToTransportProblem(operator, righthandside, M, A, B, C, D, X, Y, d, y, d_contact, y_contact, d_dirac, y_dirac)

Adds the PDE in the given form to the system matrix :param tp: :type tp: TransportProblemAdapter :param source: :type source: Data :param data: :type data: list” :param M: :type M: Data :param A: :type A: Data :param B: :type B: Data :param C: :type C: Data :param D: :type D: Data :param X: :type X: Data :param Y: :type Y: Data :param d: :type d: Data :param y: :type y: Data :param d_contact: :type d_contact: Data :param y_contact: :type y_contact: Data :param d_contact: :type d_contact: Data :param y_contact: :type y_contact: Data

checkSymmetry(verbose=True)

Tests the transport problem for symmetry.

Parameters

verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed.

Returns

True if the PDE is symmetric

Return type

bool

Note

This is a very expensive operation. It should be used for degugging only! The symmetry flag is not altered.

createOperator()

Returns an instance of a new transport operator.

getRequiredOperatorType()

Returns the system type which needs to be used by the current set up.

Returns

a code to indicate the type of transport problem scheme used

Return type

float

getSafeTimeStepSize()

Returns a safe time step size to do the next time step.

Returns

safe time step size

Return type

float

Note

If not getSafeTimeStepSize() < getUnlimitedTimeStepSize() any time step size can be used.

getSolution(dt=None, u0=None)

Returns the solution by marching forward by time step dt. If ‘’u0’’ is present, ‘’u0’’ is used as the initial value otherwise the solution from the last call is used.

Parameters
  • dt (positive float or None) – time step size. If None the last solution is returned.

  • u0 (any object that can be interpolated to a Data object on Solution or ReducedSolution) – new initial solution or None

Returns

the solution

Return type

Data

getSystem()

Returns the operator and right hand side of the PDE.

Returns

the discrete version of the PDE

Return type

tuple of Operator and Data

getUnlimitedTimeStepSize()

Returns the value returned by the getSafeTimeStepSize method to indicate no limit on the safe time step size.

return

the value used to indicate that no limit is set to the time step size

rtype

float

note

Typically the biggest positive float is returned

setDebug(flag)

Switches debug output on if flag is True, otherwise it is switched off.

Parameters

flag (bool) – desired debug status

setDebugOff()

Switches debug output off.

setDebugOn()

Switches debug output on.

setInitialSolution(u)

Sets the initial solution.

Parameters

u (any object that can be interpolated to a Data object on Solution or ReducedSolution) – initial solution

setValue(**coefficients)

Sets new values to coefficients.

Parameters
  • coefficients – new values assigned to coefficients

  • M (any type that can be cast to a Data object on Function) – value for coefficient M

  • M_reduced (any type that can be cast to a Data object on Function) – value for coefficient M_reduced

  • A (any type that can be cast to a Data object on Function) – value for coefficient A

  • A_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient A_reduced

  • B (any type that can be cast to a Data object on Function) – value for coefficient B

  • B_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient B_reduced

  • C (any type that can be cast to a Data object on Function) – value for coefficient C

  • C_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient C_reduced

  • D (any type that can be cast to a Data object on Function) – value for coefficient D

  • D_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient D_reduced

  • X (any type that can be cast to a Data object on Function) – value for coefficient X

  • X_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient X_reduced

  • Y (any type that can be cast to a Data object on Function) – value for coefficient Y

  • Y_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient Y_reduced

  • m (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient m

  • m_reduced (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient m_reduced

  • d (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient d

  • d_reduced (any type that can be cast to a Data object on ReducedFunctionOnBoundary) – value for coefficient d_reduced

  • y (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient y

  • d_contact (any type that can be cast to a Data object on FunctionOnContactOne or FunctionOnContactZero) – value for coefficient d_contact

  • d_contact_reduced (any type that can be cast to a Data object on ReducedFunctionOnContactOne or ReducedFunctionOnContactZero) – value for coefficient d_contact_reduced

  • y_contact (any type that can be cast to a Data object on FunctionOnContactOne or FunctionOnContactZero) – value for coefficient y_contact

  • y_contact_reduced (any type that can be cast to a Data object on ReducedFunctionOnContactOne or ReducedFunctionOnContactZero) – value for coefficient y_contact_reduced

  • d_dirac (any type that can be cast to a Data object on DiracDeltaFunctions) – value for coefficient d_dirac

  • y_dirac (any type that can be cast to a Data object on DiracDeltaFunctions) – value for coefficient y_dirac

  • r (any type that can be cast to a Data object on Solution or ReducedSolution depending on whether reduced order is used for the solution) – values prescribed to the solution at the locations of constraints

  • q (any type that can be cast to a Data object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – mask for the location of constraints

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.escript.linearPDEs.TransportProblem
__init__((object)arg1)None
getSafeTimeStepSize((TransportProblem)arg1)float
getUnlimitedTimeStepSize((TransportProblem)arg1)float
insertConstraint((TransportProblem)source, (Data)q, (Data)r, (Data)factor)None :

inserts constraint u_{,t}=r where q>0 into the problem using a weighting factor

isEmpty((TransportProblem)arg1)int :
Return type

int

reset((TransportProblem)arg1, (object)arg2)None :

resets the transport operator typically as they have been updated.

resetValues((TransportProblem)arg1, (object)arg2)None
solve((TransportProblem)arg1, (Data)u0, (Data)source, (object)dt, (object)options)Data :

returns the solution u for a time step dt>0 with initial value u0

Return type

Data

Parameters

source (Data) –

class esys.escript.linearPDEs.UndefinedPDEError

Exception that is raised if a PDE is not fully defined yet.

__init__(*args, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

class esys.escript.linearPDEs.WavePDE(domain, c, numEquations=None, numSolutions=None, debug=False)

A class specifically for waves, passes along values to native implementation to save computational time.

__init__(domain, c, numEquations=None, numSolutions=None, debug=False)

Initializes a new linear PDE.

Parameters
  • domain (Domain) – domain of the PDE

  • numEquations – number of equations. If None the number of equations is extracted from the PDE coefficients.

  • numSolutions – number of solution components. If None the number of solution components is extracted from the PDE coefficients.

  • debug – if True debug information is printed

getSystem()

Returns the operator and right hand side of the PDE.

Returns

the discrete version of the PDE

Return type

tuple of Operator and Data

Functions

esys.escript.linearPDEs.Abs(arg)

Returns the absolute value of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.C_GeneralTensorProduct((Data)arg0, (Data)arg1[, (object)axis_offset=0[, (object)transpose=0]])Data :

Compute a tensor product of two Data objects.

Return type

Data

Parameters
  • arg0

  • arg1

  • axis_offset (int) –

  • transpose (int) – 0: transpose neither, 1: transpose arg0, 2: transpose arg1

esys.escript.linearPDEs.ComplexData((object)value[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134890>[, (object)expanded=False]])Data
esys.escript.linearPDEs.ComplexScalar([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134120>[, (object)expanded=False]]])Data :

Construct a Data object containing scalar data-points.

Parameters
  • value (float) – scalar value for all points

  • what (FunctionSpace) – FunctionSpace for Data

  • expanded (bool) – If True, a value is stored for each point. If False, more efficient representations may be used

Return type

Data

esys.escript.linearPDEs.ComplexTensor([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421343c0>[, (object)expanded=False]]])Data :

Construct a Data object containing rank2 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

ComplexTensor( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421344a0> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.ComplexTensor3([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134580>[, (object)expanded=False]]])Data :

Construct a Data object containing rank3 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

ComplexTensor3( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421346d0> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.ComplexTensor4([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134740>[, (object)expanded=False]]])Data :

Construct a Data object containing rank4 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

ComplexTensor4( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134820> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.ComplexVector([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134200>[, (object)expanded=False]]])Data :

Construct a Data object containing rank1 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

ComplexVector( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421342e0> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.ContinuousFunction((Domain)domain)FunctionSpace :
Returns

a continuous FunctionSpace (overlapped node values)

Return type

FunctionSpace

esys.escript.linearPDEs.DiracDeltaFunctions((Domain)domain)FunctionSpace :
Return type

FunctionSpace

esys.escript.linearPDEs.Function((Domain)domain)FunctionSpace :
Returns

a function FunctionSpace

Return type

FunctionSpace

esys.escript.linearPDEs.FunctionOnBoundary((Domain)domain)FunctionSpace :
Returns

a function on boundary FunctionSpace

Return type

FunctionSpace

esys.escript.linearPDEs.FunctionOnContactOne((Domain)domain)FunctionSpace :
Returns

Return a FunctionSpace on right side of contact

Return type

FunctionSpace

esys.escript.linearPDEs.FunctionOnContactZero((Domain)domain)FunctionSpace :
Returns

Return a FunctionSpace on left side of contact

Return type

FunctionSpace

esys.escript.linearPDEs.L2(arg)

Returns the L2 norm of arg at where.

Parameters

arg (escript.Data or Symbol) – function of which the L2 norm is to be calculated

Returns

L2 norm of arg

Return type

float or Symbol

Note

L2(arg) is equivalent to sqrt(integrate(inner(arg,arg)))

esys.escript.linearPDEs.LinearPDESystem(domain, isComplex=False, debug=False)

Defines a system of linear PDEs.

Parameters
  • domain (Domain) – domain of the PDEs

  • isComplex (boolean) – if true, this coefficient is part of a complex-valued PDE and values will be converted to complex.

  • debug – if True debug information is printed

Return type

LinearPDE

esys.escript.linearPDEs.LinearSinglePDE(domain, isComplex=False, debug=False)

Defines a single linear PDE.

Parameters
  • domain (Domain) – domain of the PDE

  • isComplex (boolean) – if true, this coefficient is part of a complex-valued PDE and values will be converted to complex.

  • debug – if True debug information is printed

Return type

LinearPDE

esys.escript.linearPDEs.Lsup(arg)

Returns the Lsup-norm of argument arg. This is the maximum absolute value over all data points. This function is equivalent to sup(abs(arg)).

Parameters

arg (float, int, escript.Data, numpy.ndarray) – argument

Returns

maximum value of the absolute value of arg over all components and all data points

Return type

float

Raises

TypeError – if type of arg cannot be processed

esys.escript.linearPDEs.MPIBarrierWorld()None :

Wait until all MPI processes have reached this point.

esys.escript.linearPDEs.NcFType((str)filename)str :

Return a character indicating what netcdf format a file uses. c or C indicates netCDF3. 4 indicates netCDF4. u indicates unsupported format (eg netCDF4 file in an escript build which does not support it ? indicates unknown.

esys.escript.linearPDEs.NumpyToData(array, isComplex, functionspace)

Uses a numpy ndarray to create a Data object

Example usage: NewDataObject = NumpyToData(ndarray, isComplex, FunctionSpace)

esys.escript.linearPDEs.RandomData((tuple)shape, (FunctionSpace)fs[, (object)seed=0[, (tuple)filter=()]])Data :

Creates a new expanded Data object containing pseudo-random values. With no filter, values are drawn uniformly at random from [0,1].

Parameters
  • shape (tuple) – datapoint shape

  • fs (FunctionSpace) – function space for data object.

  • seed (long) – seed for random number generator.

esys.escript.linearPDEs.ReducedContinuousFunction((Domain)domain)FunctionSpace :
Returns

a continuous with reduced order FunctionSpace (overlapped node values on reduced element order)

Return type

FunctionSpace

esys.escript.linearPDEs.ReducedFunction((Domain)domain)FunctionSpace :
Returns

a function FunctionSpace with reduced integration order

Return type

FunctionSpace

esys.escript.linearPDEs.ReducedFunctionOnBoundary((Domain)domain)FunctionSpace :
Returns

a function on boundary FunctionSpace with reduced integration order

Return type

FunctionSpace

esys.escript.linearPDEs.ReducedFunctionOnContactOne((Domain)domain)FunctionSpace :
Returns

Return a FunctionSpace on right side of contact with reduced integration order

Return type

FunctionSpace

esys.escript.linearPDEs.ReducedFunctionOnContactZero((Domain)domain)FunctionSpace :
Returns

a FunctionSpace on left side of contact with reduced integration order

Return type

FunctionSpace

esys.escript.linearPDEs.ReducedSolution((Domain)domain)FunctionSpace :
Return type

FunctionSpace

esys.escript.linearPDEs.Scalar([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421340b0>[, (object)expanded=False]]])Data :

Construct a Data object containing scalar data-points.

Parameters
  • value (float) – scalar value for all points

  • what (FunctionSpace) – FunctionSpace for Data

  • expanded (bool) – If True, a value is stored for each point. If False, more efficient representations may be used

Return type

Data

esys.escript.linearPDEs.SingleTransportPDE(domain, debug=False)

Defines a single transport problem

Parameters
  • domain (Domain) – domain of the PDE

  • debug – if True debug information is printed

Return type

TransportPDE

esys.escript.linearPDEs.Solution((Domain)domain)FunctionSpace :
Return type

FunctionSpace

esys.escript.linearPDEs.Tensor([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134350>[, (object)expanded=False]]])Data :

Construct a Data object containing rank2 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

Tensor( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134430> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.Tensor3([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134510>[, (object)expanded=False]]])Data :

Construct a Data object containing rank3 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

Tensor3( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421345f0> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.Tensor4([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134660>[, (object)expanded=False]]])Data :

Construct a Data object containing rank4 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

Tensor4( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf421347b0> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.Vector([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134190>[, (object)expanded=False]]])Data :

Construct a Data object containing rank1 data-points.

param value

scalar value for all points

rtype

Data

type value

float

param what

FunctionSpace for Data

type what

FunctionSpace

param expanded

If True, a value is stored for each point. If False, more efficient representations may be used

type expanded

bool

Vector( (object)value [, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7faf42134270> [, (object)expanded=False]]) -> Data

esys.escript.linearPDEs.acos(arg)

Returns the inverse cosine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.acosh(arg)

Returns the inverse hyperbolic cosine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.antihermitian(arg)

Returns the anti-hermitian part of the square matrix arg. That is, (arg-adjoint(arg))/2.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.

Returns

anti-hermitian part of arg

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.antisymmetric(arg)

Returns the anti-symmetric part of the square matrix arg. That is, (arg-transpose(arg))/2.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.

Returns

anti-symmetric part of arg

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.asin(arg)

Returns the inverse sine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.asinh(arg)

Returns the inverse hyperbolic sine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.atan(arg)

Returns inverse tangent of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.atan2(arg0, arg1)

Returns inverse tangent of argument arg0 over arg1

esys.escript.linearPDEs.atanh(arg)

Returns the inverse hyperbolic tangent of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.boundingBox(domain)

Returns the bounding box of a domain

Parameters

domain (escript.Domain) – a domain

Returns

bounding box of the domain

Return type

list of pairs of float

esys.escript.linearPDEs.boundingBoxEdgeLengths(domain)

Returns the edge lengths of the bounding box of a domain

Parameters

domain (escript.Domain) – a domain

Return type

list of float

esys.escript.linearPDEs.canInterpolate((FunctionSpace)src, (FunctionSpace)dest)bool :
Parameters
  • src – Source FunctionSpace

  • dest – Destination FunctionSpace

Returns

True if src can be interpolated to dest

Return type

bool

esys.escript.linearPDEs.clip(arg, minval=None, maxval=None)

Cuts the values of arg between minval and maxval.

Parameters
  • arg (numpy.ndarray, escript.Data, Symbol, int or float) – argument

  • minval (float or None) – lower range. If None no lower range is applied

  • maxval (float or None) – upper range. If None no upper range is applied

Returns

an object that contains all values from arg between minval and maxval

Return type

numpy.ndarray, escript.Data, Symbol, int or float depending on the input

Raises

ValueError – if minval>maxval

esys.escript.linearPDEs.commonDim(*args)

Identifies, if possible, the spatial dimension across a set of objects which may or may not have a spatial dimension.

Parameters

args – given objects

Returns

the spatial dimension of the objects with identifiable dimension (see pokeDim). If none of the objects has a spatial dimension None is returned.

Return type

int or None

Raises

ValueError – if the objects with identifiable dimension don’t have the same spatial dimension.

esys.escript.linearPDEs.commonShape(arg0, arg1)

Returns a shape to which arg0 can be extended from the right and arg1 can be extended from the left.

Parameters
  • arg0 – an object with a shape (see getShape)

  • arg1 – an object with a shape (see getShape)

Returns

the shape of arg0 or arg1 such that the left part equals the shape of arg0 and the right end equals the shape of arg1

Return type

tuple of int

Raises

ValueError – if no shape can be found

esys.escript.linearPDEs.condEval(f, tval, fval)

Wrapper to allow non-data objects to be used.

esys.escript.linearPDEs.convertToNumpy(data)

Writes Data objects to a numpy array.

The keyword args are Data objects to save. If a scalar Data object is passed with the name mask, then only samples which correspond to positive values in mask will be output.

Example usage:

s=Scalar(..) v=Vector(..) t=Tensor(..) f=float() array = getNumpy(a=s, b=v, c=t, d=f)

esys.escript.linearPDEs.cos(arg)

Returns cosine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.cosh(arg)

Returns the hyperbolic cosine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.delay(arg)

Returns a lazy version of arg

esys.escript.linearPDEs.deviatoric(arg)

Returns the deviatoric version of arg.

esys.escript.linearPDEs.diameter(domain)

Returns the diameter of a domain.

Parameters

domain (escript.Domain) – a domain

Return type

float

esys.escript.linearPDEs.div(arg, where=None)

Returns the divergence of arg at where.

Parameters
  • arg (escript.Data or Symbol) – function of which the divergence is to be calculated. Its shape has to be (d,) where d is the spatial dimension.

  • where (None or escript.FunctionSpace) – FunctionSpace in which the divergence will be calculated. If not present or None an appropriate default is used.

Returns

divergence of arg

Return type

escript.Data or Symbol

esys.escript.linearPDEs.eigenvalues(arg)

Returns the eigenvalues of the square matrix arg.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – square matrix. Must have rank 2 and the first and second dimension must be equal. It must also be symmetric, ie. transpose(arg)==arg (this is not checked).

Returns

the eigenvalues in increasing order

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

Note

for escript.Data and Symbol objects the dimension is restricted to 3.

esys.escript.linearPDEs.eigenvalues_and_eigenvectors(arg)

Returns the eigenvalues and eigenvectors of the square matrix arg.

Parameters

arg (escript.Data) – square matrix. Must have rank 2 and the first and second dimension must be equal. It must also be symmetric, ie. transpose(arg)==arg (this is not checked).

Returns

the eigenvalues and eigenvectors. The eigenvalues are ordered by increasing value. The eigenvectors are orthogonal and normalized. If V are the eigenvectors then V[:,i] is the eigenvector corresponding to the i-th eigenvalue.

Return type

tuple of escript.Data

Note

The dimension is restricted to 3.

esys.escript.linearPDEs.erf(arg)

Returns the error function erf of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.escript_generalTensorProduct(arg0, arg1, axis_offset, transpose=0)

arg0 and arg1 are both Data objects but not necessarily on the same function space. They could be identical!!!

esys.escript.linearPDEs.escript_generalTensorTransposedProduct(arg0, arg1, axis_offset)

arg0 and arg1 are both Data objects but not necessarily on the same function space. They could be identical!!!

esys.escript.linearPDEs.escript_generalTransposedTensorProduct(arg0, arg1, axis_offset)

arg0 and arg1 are both Data objects but not necessarily on the same function space. They could be identical!!!

esys.escript.linearPDEs.escript_inverse(arg)

arg is a Data object!

esys.escript.linearPDEs.exp(arg)

Returns e to the power of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.generalTensorProduct(arg0, arg1, axis_offset=0)

Generalized tensor product.

out[s,t]=Sigma_r arg0[s,r]*arg1[r,t]

where
  • s runs through arg0.Shape[:arg0.ndim-axis_offset]

  • r runs through arg1.Shape[:axis_offset]

  • t runs through arg1.Shape[axis_offset:]

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol, float, int) – first argument

  • arg1 (numpy.ndarray, escript.Data, Symbol, float, int) – second argument

Returns

the general tensor product of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.generalTensorTransposedProduct(arg0, arg1, axis_offset=0)

Generalized tensor product of arg0 and transpose of arg1.

out[s,t]=Sigma_r arg0[s,r]*arg1[t,r]

where
  • s runs through arg0.Shape[:arg0.ndim-axis_offset]

  • r runs through arg0.Shape[arg1.ndim-axis_offset:]

  • t runs through arg1.Shape[arg1.ndim-axis_offset:]

The function call generalTensorTransposedProduct(arg0,arg1,axis_offset) is equivalent to generalTensorProduct(arg0,transpose(arg1,arg1.ndim-axis_offset),axis_offset).

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol, float, int) – first argument

  • arg1 (numpy.ndarray, escript.Data, Symbol, float, int) – second argument

Returns

the general tensor product of arg0 and transpose(arg1) at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.generalTransposedTensorProduct(arg0, arg1, axis_offset=0)

Generalized tensor product of transposed of arg0 and arg1.

out[s,t]=Sigma_r arg0[r,s]*arg1[r,t]

where
  • s runs through arg0.Shape[axis_offset:]

  • r runs through arg0.Shape[:axis_offset]

  • t runs through arg1.Shape[axis_offset:]

The function call generalTransposedTensorProduct(arg0,arg1,axis_offset) is equivalent to generalTensorProduct(transpose(arg0,arg0.ndim-axis_offset),arg1,axis_offset).

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol, float, int) – first argument

  • arg1 (numpy.ndarray, escript.Data, Symbol, float, int) – second argument

Returns

the general tensor product of transpose(arg0) and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.getClosestValue(arg, origin=0)

Returns the value in arg which is closest to origin.

Parameters
  • arg (escript.Data) – function

  • origin (float or escript.Data) – reference value

Returns

value in arg closest to origin

Return type

numpy.ndarray

esys.escript.linearPDEs.getEpsilon()
esys.escript.linearPDEs.getEscriptParamInt((str)name[, (object)sentinel=0])int :

Read the value of an escript tuning parameter

Parameters
  • name (string) – parameter to lookup

  • sentinel (int) – Value to be returned if name is not a known parameter

esys.escript.linearPDEs.getMPIRankWorld()int :

Return the rank of this process in the MPI World.

esys.escript.linearPDEs.getMPISizeWorld()int :

Return number of MPI processes in the job.

esys.escript.linearPDEs.getMPIWorldMax((object)arg1)int :

Each MPI process calls this function with a value for arg1. The maximum value is computed and returned.

Return type

int

esys.escript.linearPDEs.getMPIWorldSum((object)arg1)int :

Each MPI process calls this function with a value for arg1. The values are added up and the total value is returned.

Return type

int

esys.escript.linearPDEs.getMachinePrecision()float
esys.escript.linearPDEs.getMaxFloat()
esys.escript.linearPDEs.getNumberOfThreads()int :

Return the maximum number of threads available to OpenMP.

esys.escript.linearPDEs.getNumpy(**data)

Writes Data objects to a numpy array.

The keyword args are Data objects to save. If a scalar Data object is passed with the name mask, then only samples which correspond to positive values in mask will be output.

Example usage:

s=Scalar(..) v=Vector(..) t=Tensor(..) f=float() array = getNumpy(a=s, b=v, c=t, d=f)

esys.escript.linearPDEs.getRank(arg)

Identifies the rank of the argument.

Parameters

arg (numpy.ndarray, escript.Data, float, int, Symbol) – an object whose rank is to be returned

Returns

the rank of the argument

Return type

int

Raises

TypeError – if type of arg cannot be processed

esys.escript.linearPDEs.getShape(arg)

Identifies the shape of the argument.

Parameters

arg (numpy.ndarray, escript.Data, float, int, Symbol) – an object whose shape is to be returned

Returns

the shape of the argument

Return type

tuple of int

Raises

TypeError – if type of arg cannot be processed

esys.escript.linearPDEs.getTagNames(domain)

Returns a list of tag names used by the domain.

Parameters

domain (escript.Domain) – a domain object

Returns

a list of tag names used by the domain

Return type

list of str

esys.escript.linearPDEs.getTestDomainFunctionSpace((object)dpps, (object)samples[, (object)size=1])FunctionSpace :

For testing only. May be removed without notice.

esys.escript.linearPDEs.getVersion()int :

This method will only report accurate version numbers for clean checkouts.

esys.escript.linearPDEs.gmshGeo2Msh(geoFile, mshFile, numDim, order=1, verbosity=0)

Runs gmsh to mesh input geoFile. Returns 0 on success.

esys.escript.linearPDEs.grad(arg, where=None)

Returns the spatial gradient of arg at where.

If g is the returned object, then

  • if arg is rank 0 g[s] is the derivative of arg with respect to the s-th spatial dimension

  • if arg is rank 1 g[i,s] is the derivative of arg[i] with respect to the s-th spatial dimension

  • if arg is rank 2 g[i,j,s] is the derivative of arg[i,j] with respect to the s-th spatial dimension

  • if arg is rank 3 g[i,j,k,s] is the derivative of arg[i,j,k] with respect to the s-th spatial dimension.

Parameters
  • arg (escript.Data or Symbol) – function of which the gradient is to be calculated. Its rank has to be less than 3.

  • where (None or escript.FunctionSpace) – FunctionSpace in which the gradient is calculated. If not present or None an appropriate default is used.

Returns

gradient of arg

Return type

escript.Data or Symbol

esys.escript.linearPDEs.grad_n(arg, n, where=None)
esys.escript.linearPDEs.hasFeature((str)name)bool :

Check if escript was compiled with a certain feature

Parameters

name (string) – feature to lookup

esys.escript.linearPDEs.hermitian(arg)

Returns the hermitian part of the square matrix arg. That is, (arg+adjoint(arg))/2.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.

Returns

hermitian part of arg

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.identity(shape=())

Returns the shape x shape identity tensor.

Parameters

shape (tuple of int) – input shape for the identity tensor

Returns

array whose shape is shape x shape where u[i,k]=1 for i=k and u[i,k]=0 otherwise for len(shape)=1. If len(shape)=2: u[i,j,k,l]=1 for i=k and j=l and u[i,j,k,l]=0 otherwise.

Return type

numpy.ndarray of rank 1, rank 2 or rank 4

Raises

ValueError – if len(shape)>2

esys.escript.linearPDEs.identityTensor(d=3)

Returns the d x d identity matrix.

Parameters

d (int, escript.Domain or escript.FunctionSpace) – dimension or an object that has the getDim method defining the dimension

Returns

the object u of rank 2 with u[i,j]=1 for i=j and u[i,j]=0 otherwise

Return type

numpy.ndarray or escript.Data of rank 2

esys.escript.linearPDEs.identityTensor4(d=3)

Returns the d x d x d x d identity tensor.

Parameters

d (int or any object with a getDim method) – dimension or an object that has the getDim method defining the dimension

Returns

the object u of rank 4 with u[i,j,k,l]=1 for i=k and j=l and u[i,j,k,l]=0 otherwise

Return type

numpy.ndarray or escript.Data of rank 4

esys.escript.linearPDEs.inf(arg)

Returns the minimum value over all data points.

Parameters

arg (float, int, escript.Data, numpy.ndarray) – argument

Returns

minimum value of arg over all components and all data points

Return type

float

Raises

TypeError – if type of arg cannot be processed

esys.escript.linearPDEs.inner(arg0, arg1)

Inner product of the two arguments. The inner product is defined as:

out=Sigma_s arg0[s]*arg1[s]

where s runs through arg0.Shape.

arg0 and arg1 must have the same shape.

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol, float, int) – first argument

  • arg1 (numpy.ndarray, escript.Data, Symbol, float, int) – second argument

Returns

the inner product of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol, float depending on the input

Raises

ValueError – if the shapes of the arguments are not identical

esys.escript.linearPDEs.insertTagNames(domain, **kwargs)

Inserts tag names into the domain.

Parameters
  • domain (escript.Domain) – a domain object

  • <tag_name> (int) – tag key assigned to <tag_name>

esys.escript.linearPDEs.insertTaggedValues(target, **kwargs)

Inserts tagged values into the target using tag names.

Parameters
  • target (escript.Data) – data to be filled by tagged values

  • <tag_name> (float or numpy.ndarray) – value to be used for <tag_name>

Returns

target

Return type

escript.Data

esys.escript.linearPDEs.integrate(arg, where=None)

Returns the integral of the function arg over its domain. If where is present arg is interpolated to where before integration.

Parameters
  • arg (escript.Data or Symbol) – the function which is integrated

  • where (None or escript.FunctionSpace) – FunctionSpace in which the integral is calculated. If not present or None an appropriate default is used.

Returns

integral of arg

Return type

float, numpy.ndarray or Symbol

esys.escript.linearPDEs.internal_addJob()

object internal_addJob(tuple args, dict kwds)

esys.escript.linearPDEs.internal_addJobPerWorld()

object internal_addJobPerWorld(tuple args, dict kwds)

esys.escript.linearPDEs.internal_addVariable()

object internal_addVariable(tuple args, dict kwds)

esys.escript.linearPDEs.internal_buildDomains()

object internal_buildDomains(tuple args, dict kwds)

esys.escript.linearPDEs.internal_makeDataReducer((str)op)Reducer :

Create a reducer to work with Data and the specified operation.

esys.escript.linearPDEs.internal_makeLocalOnly()Reducer :

Create a variable which is not connected to copies in other worlds.

esys.escript.linearPDEs.internal_makeScalarReducer((str)op)Reducer :

Create a reducer to work with doubles and the specified operation.

esys.escript.linearPDEs.interpolate(arg, where)

Interpolates the function into the FunctionSpace where. If the argument arg has the requested function space where no interpolation is performed and arg is returned.

Parameters
  • arg (escript.Data or Symbol) – interpolant

  • where (escript.FunctionSpace) – FunctionSpace to be interpolated to

Returns

interpolated argument

Return type

escript.Data or Symbol

esys.escript.linearPDEs.interpolateTable(tab, dat, start, step, undef=1e+50, check_boundaries=False)
esys.escript.linearPDEs.inverse(arg)

Returns the inverse of the square matrix arg.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – square matrix. Must have rank 2 and the first and second dimension must be equal.

Returns

inverse of the argument. matrix_mult(inverse(arg),arg) will be almost equal to kronecker(arg.getShape()[0])

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

Note

for escript.Data objects the dimension is restricted to 3.

esys.escript.linearPDEs.jump(arg, domain=None)

Returns the jump of arg across the continuity of the domain.

Parameters
  • arg (escript.Data or Symbol) – argument

  • domain (None or escript.Domain) – the domain where the discontinuity is located. If domain is not present or equal to None the domain of arg is used.

Returns

jump of arg

Return type

escript.Data or Symbol

esys.escript.linearPDEs.kronecker(d=3)

Returns the kronecker delta-symbol.

Parameters

d (int, escript.Domain or escript.FunctionSpace) – dimension or an object that has the getDim method defining the dimension

Returns

the object u of rank 2 with u[i,j]=1 for i=j and u[i,j]=0 otherwise

Return type

numpy.ndarray or escript.Data of rank 2

esys.escript.linearPDEs.length(arg)

Returns the length (Euclidean norm) of argument arg at each data point.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol depending on the type of arg

esys.escript.linearPDEs.listEscriptParams()list :
Returns

A list of tuples (p,v,d) where p is the name of a parameter for escript, v is its current value, and d is a description.

esys.escript.linearPDEs.listFeatures()list :
Returns

A list of strings representing the features escript supports.

esys.escript.linearPDEs.load((str)fileName, (Domain)domain)Data :

reads Data on domain from file in netCDF format

Parameters
  • fileName (string) –

  • domain (Domain) –

esys.escript.linearPDEs.loadIsConfigured()bool :
Returns

True if the load function is configured.

esys.escript.linearPDEs.log(arg)

Returns the natural logarithm of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.log10(arg)

Returns base-10 logarithm of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.longestEdge(domain)

Returns the length of the longest edge of the domain

Parameters

domain (escript.Domain) – a domain

Returns

longest edge of the domain parallel to the Cartesian axis

Return type

float

esys.escript.linearPDEs.makeTagMap(fs)

Produce an expanded Data over the function space where the value is the tag associated with the sample

esys.escript.linearPDEs.matchShape(arg0, arg1)

Returns a representation of arg0 and arg1 which have the same shape.

Parameters
  • arg0 (numpy.ndarray,`escript.Data`,``float``, int, Symbol) – first argument

  • arg1 (numpy.ndarray,`escript.Data`,``float``, int, Symbol) – second argument

Returns

arg0 and arg1 where copies are returned when the shape has to be changed

Return type

tuple

esys.escript.linearPDEs.matchType(arg0=0.0, arg1=0.0)

Converts arg0 and arg1 both to the same type numpy.ndarray or escript.Data

Parameters
  • arg0 (numpy.ndarray,`escript.Data`,``float``, int, Symbol) – first argument

  • arg1 (numpy.ndarray,`escript.Data`,``float``, int, Symbol) – second argument

Returns

a tuple representing arg0 and arg1 with the same type or with at least one of them being a Symbol

Return type

tuple of two numpy.ndarray or two escript.Data

Raises

TypeError – if type of arg0 or arg1 cannot be processed

esys.escript.linearPDEs.matrix_mult(arg0, arg1)

matrix-matrix or matrix-vector product of the two arguments.

out[s0]=Sigma_{r0} arg0[s0,r0]*arg1[r0]

or

out[s0,s1]=Sigma_{r0} arg0[s0,r0]*arg1[r0,s1]

The second dimension of arg0 and the first dimension of arg1 must match.

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of at least rank 1

Returns

the matrix-matrix or matrix-vector product of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.escript.linearPDEs.matrix_transposed_mult(arg0, arg1)

matrix-transposed(matrix) product of the two arguments.

out[s0,s1]=Sigma_{r0} arg0[s0,r0]*arg1[s1,r0]

The function call matrix_transposed_mult(arg0,arg1) is equivalent to matrix_mult(arg0,transpose(arg1)).

The last dimensions of arg0 and arg1 must match.

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of rank 1 or 2

Returns

the product of arg0 and the transposed of arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.escript.linearPDEs.matrixmult(arg0, arg1)

See matrix_mult.

esys.escript.linearPDEs.maximum(*args)

The maximum over arguments args.

Parameters

args (numpy.ndarray, escript.Data, Symbol, int or float) – arguments

Returns

an object which in each entry gives the maximum of the corresponding values in args

Return type

numpy.ndarray, escript.Data, Symbol, int or float depending on the input

esys.escript.linearPDEs.maxval(arg)

Returns the maximum value over all components of arg at each data point.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.meanValue(arg)

return the mean value of the argument over its domain

Parameters

arg (escript.Data) – function

Returns

mean value

Return type

float or numpy.ndarray

esys.escript.linearPDEs.minimum(*args)

The minimum over arguments args.

Parameters

args (numpy.ndarray, escript.Data, Symbol, int or float) – arguments

Returns

an object which gives in each entry the minimum of the corresponding values in args

Return type

numpy.ndarray, escript.Data, Symbol, int or float depending on the input

esys.escript.linearPDEs.minval(arg)

Returns the minimum value over all components of arg at each data point.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.mkDir(*pathname)

creates a directory of name pathname if the directory does not exist.

Parameters

pathname (str or sequence of strings) – valid path name

Note

The method is MPI safe.

esys.escript.linearPDEs.mult(arg0, arg1)

Product of arg0 and arg1.

Parameters
  • arg0 (Symbol, float, int, escript.Data or numpy.ndarray) – first term

  • arg1 (Symbol, float, int, escript.Data or numpy.ndarray) – second term

Returns

the product of arg0 and arg1

Return type

Symbol, float, int, escript.Data or numpy.ndarray

Note

The shape of both arguments is matched according to the rules used in matchShape.

esys.escript.linearPDEs.negative(arg)

returns the negative part of arg

esys.escript.linearPDEs.nonsymmetric(arg)

Deprecated alias for antisymmetric

esys.escript.linearPDEs.normalize(arg, zerolength=0)

Returns the normalized version of arg (=``arg/length(arg)``).

Parameters
  • arg (escript.Data or Symbol) – function

  • zerolength (float) – relative tolerance for arg == 0

Returns

normalized arg where arg is non-zero, and zero elsewhere

Return type

escript.Data or Symbol

esys.escript.linearPDEs.outer(arg0, arg1)

The outer product of the two arguments. The outer product is defined as:

out[t,s]=arg0[t]*arg1[s]

where
  • s runs through arg0.Shape

  • t runs through arg1.Shape

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol, float, int) – first argument

  • arg1 (numpy.ndarray, escript.Data, Symbol, float, int) – second argument

Returns

the outer product of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.phase(arg)

return the “phase”/”arg”/”angle” of a number

esys.escript.linearPDEs.pokeDim(arg)

Identifies the spatial dimension of the argument.

Parameters

arg (any) – an object whose spatial dimension is to be returned

Returns

the spatial dimension of the argument, if available, or None

Return type

int or None

esys.escript.linearPDEs.polarToCart(r, phase)

conversion from cartesian to polar coordinates

Parameters
  • r (any float type object) – length

  • phase (any float type object) – the phase angle in rad

Returns

cartesian representation as complex number

Return type

appropriate complex

esys.escript.linearPDEs.positive(arg)

returns the positive part of arg

esys.escript.linearPDEs.printParallelThreadCounts()None
esys.escript.linearPDEs.releaseUnusedMemory()None
esys.escript.linearPDEs.reorderComponents(arg, index)

Resorts the components of arg according to index.

esys.escript.linearPDEs.resolve(arg)

Returns the value of arg resolved.

esys.escript.linearPDEs.resolveGroup((object)arg1)None
esys.escript.linearPDEs.runMPIProgram((list)arg1)int :

Spawns an external MPI program using a separate communicator.

esys.escript.linearPDEs.safeDiv(arg0, arg1, rtol=None)

returns arg0/arg1 but return 0 where arg1 is (almost) zero

esys.escript.linearPDEs.saveDataCSV(filename, append=False, refid=False, sep=', ', csep='_', **data)

Writes Data objects to a CSV file. These objects must have compatible FunctionSpaces, i.e. it must be possible to interpolate all data to one FunctionSpace. Note, that with more than one MPI rank this function will fail for some function spaces on some domains.

Parameters
  • filename (string) – file to save data to.

  • append (bool) – If True, then open file at end rather than beginning

  • refid (bool) – If True, then a list of reference ids will be printed in the first column

  • sep (string) – separator between fields

  • csep – separator for components of rank 2 and above (e.g. ‘_’ -> c0_1)

The keyword args are Data objects to save. If a scalar Data object is passed with the name mask, then only samples which correspond to positive values in mask will be output. Example:

s=Scalar(..)
v=Vector(..)
t=Tensor(..)
f=float()
saveDataCSV("f.csv", a=s, b=v, c=t, d=f)

Will result in a file

a, b0, b1, c0_0, c0_1, .., c1_1, d 1.0, 1.5, 2.7, 3.1, 3.4, .., 0.89, 0.0 0.9, 8.7, 1.9, 3.4, 7.8, .., 1.21, 0.0

The first line is a header, the remaining lines give the values.

esys.escript.linearPDEs.saveESD(datasetName, dataDir='.', domain=None, timeStep=0, deltaT=1, dynamicMesh=0, timeStepFormat='%04d', **data)

Saves Data objects to files and creates an escript dataset (ESD) file for convenient processing/visualisation.

Single timestep example:

tmp = Scalar(..)
v = Vector(..)
saveESD("solution", "data", temperature=tmp, velocity=v)

Time series example:

while t < t_end:
    tmp = Scalar(..)
    v = Vector(..)
    # save every 10 timesteps
    if t % 10 == 0:
        saveESD("solution", "data", timeStep=t, deltaT=10, temperature=tmp, velocity=v)
    t = t + 1

tmp, v and the domain are saved in native format in the “data” directory and the file “solution.esd” is created that refers to tmp by the name “temperature” and to v by the name “velocity”.

Parameters
  • datasetName (str) – name of the dataset, used to name the ESD file

  • dataDir (str) – optional directory where the data files should be saved

  • domain (escript.Domain) – domain of the Data object(s). If not specified, the domain of the given Data objects is used.

  • timeStep (int) – current timestep or sequence number - first one must be 0

  • deltaT (int) – timestep or sequence increment, see example above

  • dynamicMesh (int) – by default the mesh is assumed to be static and thus only saved once at timestep 0 to save disk space. Setting this to 1 changes the behaviour and the mesh is saved at each timestep.

  • timeStepFormat (str) – timestep format string (defaults to “%04d”)

  • <name> (Data object) – writes the assigned value to the file using <name> as identifier

Note

The ESD concept is experimental and the file format likely to change so use this function with caution.

Note

The data objects have to be defined on the same domain (but not necessarily on the same FunctionSpace).

Note

When saving a time series the first timestep must be 0 and it is assumed that data from all timesteps share the domain. The dataset file is updated in each iteration.

esys.escript.linearPDEs.setEscriptParamInt((str)name[, (object)value=0])None :

Modify the value of an escript tuning parameter

Parameters
  • name (string) –

  • value (int) –

esys.escript.linearPDEs.setNumberOfThreads((object)arg1)None :

Use of this method is strongly discouraged.

esys.escript.linearPDEs.showEscriptParams()

Displays the parameters escript recognises with an explanation and their current value.

esys.escript.linearPDEs.sign(arg)

Returns the sign of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.sin(arg)

Returns sine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.sinh(arg)

Returns the hyperbolic sine of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.sqrt(arg)

Returns the square root of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.sup(arg)

Returns the maximum value over all data points.

Parameters

arg (float, int, escript.Data, numpy.ndarray) – argument

Returns

maximum value of arg over all components and all data points

Return type

float

Raises

TypeError – if type of arg cannot be processed

esys.escript.linearPDEs.swap_axes(arg, axis0=0, axis1=1)

Returns the swap of arg by swapping the components axis0 and axis1.

Parameters
  • arg (escript.Data, Symbol, numpy.ndarray) – argument

  • axis0 (int) – first axis. axis0 must be non-negative and less than the rank of arg.

  • axis1 (int) – second axis. axis1 must be non-negative and less than the rank of arg.

Returns

arg with swapped components

Return type

escript.Data, Symbol or numpy.ndarray depending on the type of arg

esys.escript.linearPDEs.symmetric(arg)

Returns the symmetric part of the square matrix arg. That is, (arg+transpose(arg))/2.

Parameters

arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.

Returns

symmetric part of arg

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.tan(arg)

Returns tangent of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.tanh(arg)

Returns the hyperbolic tangent of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.tensor_mult(arg0, arg1)

The tensor product of the two arguments.

For arg0 of rank 2 this is

out[s0]=Sigma_{r0} arg0[s0,r0]*arg1[r0]

or

out[s0,s1]=Sigma_{r0} arg0[s0,r0]*arg1[r0,s1]

and for arg0 of rank 4 this is

out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[r0,r1,s2,s3]

or

out[s0,s1,s2]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[r0,r1,s2]

or

out[s0,s1]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[r0,r1]

In the first case the second dimension of arg0 and the last dimension of arg1 must match and in the second case the two last dimensions of arg0 must match the two first dimensions of arg1.

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater than 1 or 2 depending on the rank of arg0

Returns

the tensor product of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.tensor_transposed_mult(arg0, arg1)

The tensor product of the first and the transpose of the second argument.

For arg0 of rank 2 this is

out[s0,s1]=Sigma_{r0} arg0[s0,r0]*arg1[s1,r0]

and for arg0 of rank 4 this is

out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[s2,s3,r0,r1]

or

out[s0,s1,s2]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[s2,r0,r1]

In the first case the second dimension of arg0 and arg1 must match and in the second case the two last dimensions of arg0 must match the two last dimensions of arg1.

The function call tensor_transpose_mult(arg0,arg1) is equivalent to tensor_mult(arg0,transpose(arg1)).

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater of 1 or 2 depending on rank of arg0

Returns

the tensor product of the transposed of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.tensormult(arg0, arg1)

See tensor_mult.

esys.escript.linearPDEs.testForZero(arg)

Tests if the argument is identical to zero.

Parameters

arg (typically numpy.ndarray, escript.Data, float, int) – the object to test for zero

Returns

True if the argument is identical to zero, False otherwise

Return type

bool

esys.escript.linearPDEs.trace(arg, axis_offset=0)

Returns the trace of arg which is the sum of arg[k,k] over k.

Parameters
  • arg (escript.Data, Symbol, numpy.ndarray) – argument

  • axis_offset (int) – axis_offset to components to sum over. axis_offset must be non-negative and less than the rank of arg +1. The dimensions of component axis_offset and axis_offset+1 must be equal.

Returns

trace of arg. The rank of the returned object is rank of arg minus 2.

Return type

escript.Data, Symbol or numpy.ndarray depending on the type of arg

esys.escript.linearPDEs.transpose(arg, axis_offset=None)

Returns the transpose of arg by swapping the first axis_offset and the last rank-axis_offset components.

Parameters
  • arg (escript.Data, Symbol, numpy.ndarray, float, int) – argument

  • axis_offset (int) – the first axis_offset components are swapped with the rest. axis_offset must be non-negative and less or equal to the rank of arg. If axis_offset is not present int(r/2) where r is the rank of arg is used.

Returns

transpose of arg

Return type

escript.Data, Symbol, numpy.ndarray, float, int depending on the type of arg

esys.escript.linearPDEs.transposed_matrix_mult(arg0, arg1)

transposed(matrix)-matrix or transposed(matrix)-vector product of the two arguments.

out[s0]=Sigma_{r0} arg0[r0,s0]*arg1[r0]

or

out[s0,s1]=Sigma_{r0} arg0[r0,s0]*arg1[r0,s1]

The function call transposed_matrix_mult(arg0,arg1) is equivalent to matrix_mult(transpose(arg0),arg1).

The first dimension of arg0 and arg1 must match.

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of at least rank 1

Returns

the product of the transpose of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.escript.linearPDEs.transposed_tensor_mult(arg0, arg1)

The tensor product of the transpose of the first and the second argument.

For arg0 of rank 2 this is

out[s0]=Sigma_{r0} arg0[r0,s0]*arg1[r0]

or

out[s0,s1]=Sigma_{r0} arg0[r0,s0]*arg1[r0,s1]

and for arg0 of rank 4 this is

out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[r0,r1,s0,s1]*arg1[r0,r1,s2,s3]

or

out[s0,s1,s2]=Sigma_{r0,r1} arg0[r0,r1,s0,s1]*arg1[r0,r1,s2]

or

out[s0,s1]=Sigma_{r0,r1} arg0[r0,r1,s0,s1]*arg1[r0,r1]

In the first case the first dimension of arg0 and the first dimension of arg1 must match and in the second case the two first dimensions of arg0 must match the two first dimensions of arg1.

The function call transposed_tensor_mult(arg0,arg1) is equivalent to tensor_mult(transpose(arg0),arg1).

Parameters
  • arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4

  • arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater of 1 or 2 depending on the rank of arg0

Returns

the tensor product of transpose of arg0 and arg1 at each data point

Return type

numpy.ndarray, escript.Data, Symbol depending on the input

esys.escript.linearPDEs.unitVector(i=0, d=3)

Returns a unit vector u of dimension d whose non-zero element is at index i.

Parameters
  • i (int) – index for non-zero element

  • d (int, escript.Domain or escript.FunctionSpace) – dimension or an object that has the getDim method defining the dimension

Returns

the object u of rank 1 with u[j]=1 for j=index and u[j]=0 otherwise

Return type

numpy.ndarray or escript.Data of rank 1

esys.escript.linearPDEs.vol(arg)

Returns the volume or area of the oject arg

Parameters

arg (escript.FunctionSpace or escript.Domain) – a geometrical object

Return type

float

esys.escript.linearPDEs.whereNegative(arg)

Returns mask of negative values of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.whereNonNegative(arg)

Returns mask of non-negative values of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.whereNonPositive(arg)

Returns mask of non-positive values of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.whereNonZero(arg, tol=0.0)

Returns mask of values different from zero of argument arg.

Parameters
  • arg (float, escript.Data, Symbol, numpy.ndarray) – argument

  • tol (float) – absolute tolerance. Values with absolute value less than tol are accepted as zero. If tol is not present rtol``*```Lsup` (arg) is used.

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises
  • ValueError – if rtol is non-negative.

  • TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.wherePositive(arg)

Returns mask of positive values of argument arg.

Parameters

arg (float, escript.Data, Symbol, numpy.ndarray.) – argument

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises

TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.whereZero(arg, tol=None, rtol=1.4901161193847656e-08)

Returns mask of zero entries of argument arg.

Parameters
  • arg (float, escript.Data, Symbol, numpy.ndarray) – argument

  • tol (float) – absolute tolerance. Values with absolute value less than tol are accepted as zero. If tol is not present rtol``*```Lsup` (arg) is used.

  • rtol (non-negative float) – relative tolerance used to define the absolute tolerance if tol is not present.

Return type

float, escript.Data, Symbol, numpy.ndarray depending on the type of arg

Raises
  • ValueError – if rtol is non-negative.

  • TypeError – if the type of the argument is not expected

esys.escript.linearPDEs.zeros(shape=())

Returns the shape zero tensor.

Parameters

shape (tuple of int) – input shape for the identity tensor

Returns

array of shape filled with zeros

Return type

numpy.ndarray

Others

  • DBLE_MAX

  • EPSILON

Packages