esys.escript Package

Classes

class esys.escript.ContinuousDomain

Bases: esys.escriptcore.escriptcpp.Domain

Class representing continuous domains

MPIBarrier((Domain)arg1) → None :

Wait until all processes have reached this point

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:
dump((Domain)arg1, (str)filename) → None :

Dumps the domain to a file:param filename: :type filename: string

getDataShape((ContinuousDomain)arg1, (int)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
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
getNumDataPointsGlobal((ContinuousDomain)arg1) → int :
Returns:the number of data points summed across all MPI processes
Return type:int
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
getSystemMatrixTypeId((ContinuousDomain)arg1, (int)solver, (int)preconditioner, (int)package, (bool)symmetry) → int :
Returns:the identifier of the matrix type to be used for the global stiffness matrix when a particular solver package and symmetric matrix is used.
Return type:int
getTag((Domain)arg1, (str)name) → int :
Returns:tag id for name
Return type:string
getTransportTypeId((ContinuousDomain)arg1, (int)solver, (int)preconditioner, (int)package, (bool)symmetry) → int
getX((Domain)arg1) → Data :
Return type:Data
Returns:Locations in the`Domain`. FunctionSpace is chosen appropriately
isValidTagName((Domain)arg1, (str)name) → bool :
Returns:True is name corresponds to a tag
Return type:bool
newOperator((ContinuousDomain)arg1, (int)row_blocksize, (FunctionSpace)row_functionspace, (int)column_blocksize, (FunctionSpace)column_functionspace, (int)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, (int)blocksize, (FunctionSpace)functionspace, (int)type) → TransportProblem :

creates a TransportProblemAdapter

Parameters:
  • theta (float) –
  • blocksize (int) –
  • functionspace (FunctionSpace) –
  • type (int) –
onMasterProcessor((Domain)arg1) → bool :
Returns:True if this code is executing on the master process
Return type:bool
print_mesh_info((ContinuousDomain)arg1[, (bool)full=False]) → None :
Parameters:full (bool) –
setTagMap((Domain)arg1, (str)name, (int)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

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

assigns new location to the domain

Parameters:arg (Data) –
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.Data((object)arg1)

Bases: Boost.Python.instance

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

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, (int)dpno) → int :

Return tag number for the specified datapoint

Return type:int
Parameters:dpno (int) – datapoint number
getTupleForDataPoint((Data)arg1, (int)dataPointNo) → object :
Returns:Value of the specified datapoint
Return type:tuple
Parameters:dataPointNo (int) – datapoint to access
getTupleForGlobalDataPoint((Data)arg1, (int)procNo, (int)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
interpolate((Data)arg1, (FunctionSpace)functionspace) → Data :

Interpolate this object’s values into a new functionspace.

interpolateTable((Data)arg1, (object)table, (float)Amin, (float)Astep, (Data)B, (float)Bmin, (float)Bstep[, (float)undef=1e+50[, (bool)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, (float)Amin, (float)Astep [, (float)undef=1e+50 [, (bool)check_boundaries=False]]) -> Data

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.
maxGlobalDataPoint((Data)arg1) → tuple :

Please consider using getSupLocator() from pdetools instead.

minGlobalDataPoint((Data)arg1) → tuple :

Please consider using getInfLocator() from pdetools instead.

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

1D interpolation with non equally spaced points

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

1D interpolation of slope with non equally spaced points

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, (int)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, (int)dataPointNo, (object)value) → None

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

setValueOfDataPoint( (Data)arg1, (int)arg2, (float)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[, (bool)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.DataManager(formats=[0], work_dir='.', restart_prefix='restart', do_restart=True)

Bases: object

Escript data import/export manager.

Example:

dm=DataManager(formats=[DataManager.RESTART,DataManager.VTK])
if dm.hasData():
    dom = dm.getDomain()
    time = dm.getValue("time")
    dt = dm.getValue("dt")
    T = dm.getValue("T")
    u = dm.getValue("u")
else:
    T = ...
    u = ...
dm.addData(time=time,dt=dt,T=T,u=u) # add data and variables
dm.setTime(time)                    # set the simulation timestamp
dm.export()                         # write out data
RESTART = 0
SILO = 1
VISIT = 2
VTK = 3
addData(**data)

Adds ‘escript.Data’ objects and other data to be exported to this manager.

Note:This method does not make copies of Data objects so any modifications will be carried over until export() is called.
export()

Executes the actual data export. Depending on the formats parameter used in the constructor all data added by addData() is written to disk (RESTART,SILO,VTK) or made available through the VisIt simulation interface (VISIT).

getCycle()

Returns the export cycle (=number of times export() has been called)

getDomain()

Returns the domain as recovered from restart files.

getValue(value_name)

Returns an ‘escript.Data’ object or other value that has been loaded from restart files.

hasData()

Returns True if the manager holds data for restart

setCheckpointFrequency(freq)

Sets the number of calls to export() before new restart files are generated.

setDomain(domain)

Sets the domain without adding data.

setMeshLabels(x, y, z='')

Sets labels for the mesh axes. These are currently only used by the Silo exporter.

setMeshUnits(x, y, z='')

Sets units for the mesh axes. These are currently only used by the Silo exporter.

setMetadataSchemaString(schema, metadata='')

Sets metadata namespaces and the corresponding metadata. Only used for the VTK file format at the moment.

Parameters:
  • schema – A dictionary that maps namespace prefixes to namespace names, e.g. {‘gml’:’http://www.opengis.net/gml‘}
  • metadata – The actual metadata string which will be enclosed in ‘<MetaData>’ tags.
setTime(time)

Sets the simulation timestamp.

class esys.escript.Domain

Bases: Boost.Python.instance

Base class for all domains.

MPIBarrier((Domain)arg1) → None :

Wait until all processes have reached this point

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

Dumps the domain to a file:param filename: :type 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
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
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, (int)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.Evaluator(*expressions)

Bases: object

addExpression(expression)

Adds an expression to this evaluator.

Returns:the modified Evaluator object
evaluate(evalf=False, **args)

Evaluates all expressions in this evaluator and returns the result as a tuple.

Returns:the evaluated expressions in the order they were added to this Evaluator.
subs(**args)

Symbol substitution.

Returns:the modified Evaluator object
class esys.escript.FileWriter(fn, append=False, createLocalFiles=False)

Bases: object

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. :var name: name of file :var mode: access mode (=’w’ or =’a’) :var closed: True to indicate closed file :var newlines: line seperator

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.FunctionSpace((object)arg1)

Bases: Boost.Python.instance

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

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, (int)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, (int)arg2) → int :
Returns:the tag associated with the given sample number.
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, (int)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.NonlinearPDE(domain, u, debug=0)

Bases: object

This class is used to define a general nonlinear, 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 nonlinear PDE is defined in the following form:

-div(X) + Y = 0

where X,*Y*=f(u,*grad(u)*). div(F) denotes the divergence of F and grad(F) is the spatial derivative of F.

The coefficients X (rank 1) and Y (scalar) have to be specified through Symbol objects.

The following natural boundary conditions are considered:

n[j]*X[j] + y = 0

where n is the outer normal field. Notice that the coefficient X is defined in the PDE. The coefficient y is a scalar Symbol.

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.

For a system of PDEs and a solution with several components, u is rank one, while the PDE coefficient X is rank two and y is rank one.

The PDE is solved by linearising the coefficients and iteratively solving the corresponding linear PDE until the error is smaller than a tolerance or a maximum number of iterations is reached.

Typical usage:

u = Symbol('u', dim=dom.getDim())
p = NonlinearPDE(dom, u)
p.setValue(X=grad(u), Y=1+5*u)
v = p.getSolution(u=0.)
DEBUG0 = 0
DEBUG1 = 1
DEBUG2 = 2
DEBUG3 = 3
DEBUG4 = 4
ORDER = 0
createCoefficient(name)

Creates a new coefficient name as Symbol

Parameters:name (string) – name of the coefficient requested
Returns:the value of the coefficient
Return type:Symbol or Data (for name = “q”)
Raises IllegalCoefficient:
 if name is not a coefficient of the PDE
getCoefficient(name)

Returns the value of the coefficient name as Symbol

Parameters:name (string) – name of the coefficient requested
Returns:the value of the coefficient
Return type:Symbol
Raises IllegalCoefficient:
 if name is not a coefficient of the PDE
getLinearPDE()

Returns the linear PDE used to calculate the Newton-Raphson update

Return type:LinearPDE
getLinearSolverOptions()

Returns the options of the linear PDE solver class

getNumSolutions()

Returns the number of the solution components :rtype: int

getSensitivity(f, g=None, **subs)

Calculates the sensitivity of the solution of an input factor f in direction g.

Parameters:
  • f (Symbol) – the input factor to be investigated. f may be of rank 0 or 1.
  • g (list or single of float, numpy.array or Data.) – the direction(s) of change. If not present, it is g=eye(n) where n is the number of components of f.
  • subs – Substitutions for all symbols used in the coefficients including unknown u and the input factor f to be investigated
Returns:

the sensitivity

Return type:

Data with shape u.getShape()+(len(g),) if len(g)>1 or u.getShape() if len(g)==1

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(**subs)

Returns the solution of the PDE.

Parameters:subs – Substitutions for all symbols used in the coefficients including the initial value for the unknown u.
Returns:the solution
Return type:Data
getUnknownSymbol()

Returns the symbol of the PDE unknown

Returns:the symbol of the PDE unknown
Return type:Symbol
setOptions(**opts)

Allows setting options for the nonlinear PDE.

The supported options are:
tolerance
error tolerance for the Newton method
iteration_steps_max
maximum number of Newton iterations
omega_min
minimum relaxation factor
atol
solution norms less than atol are assumed to be atol. This can be useful if one of your solutions is expected to be zero.
quadratic_convergence_limit
if the norm of the Newton-Raphson correction is reduced by less than quadratic_convergence_limit between two iteration steps quadratic convergence is assumed.
simplified_newton_limit
if the norm of the defect is reduced by less than simplified_newton_limit between two iteration steps and quadratic convergence is detected the iteration switches to the simplified Newton-Raphson scheme.
setValue(**coefficients)

Sets new values to one or more coefficients.

Parameters:
  • coefficients – new values assigned to coefficients
  • coefficients – new values assigned to coefficients
  • X (Symbol or any type that can be cast to a Data object) – value for coefficient X
  • Y (Symbol or any type that can be cast to a Data object) – value for coefficient Y
  • y (Symbol or any type that can be cast to a Data object) – value for coefficient y
  • y_contact (Symbol or any type that can be cast to a Data object) – value for coefficient y_contact
  • y_dirac (Symbol or any type that can be cast to a Data object) – value for coefficient y_dirac
  • q (any type that can be cast to a Data object) – mask for location of constraint
  • r (Symbol or any type that can be cast to a Data object) – value of solution prescribed by constraint
Raises:
  • IllegalCoefficient – if an unknown coefficient keyword is used
  • IllegalCoefficientValue – if a supplied coefficient value has an invalid shape
trace1(text)

Prints the text message if the debug level is greater than DEBUG0

Parameters:text (string) – message to be printed
trace3(text)

Prints the text message if the debug level is greater than DEBUG3

Parameters:text (string) – message to be printed
class esys.escript.Operator((object)arg1)

Bases: Boost.Python.instance

isEmpty((Operator)arg1) → int :
Return type:bool
Returns:True if matrix is empty
nullifyRowsAndCols((Operator)arg1, (Data)arg2, (Data)arg3, (float)arg4) → None
of((Operator)arg1, (Data)right) → Data :

matrix*vector multiplication

resetValues((Operator)arg1) → 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.SolverBuddy((object)arg1)

Bases: Boost.Python.instance

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
getAMGInterpolation((SolverBuddy)arg1) → SolverOptions :

Returns key of the interpolation method for the SAMG preconditioner

Return type:in the list CLASSIC_INTERPOLATION_WITH_FF_COUPLING, CLASSIC_INTERPOLATION, DIRECT_INTERPOLATION
getAbsoluteTolerance((SolverBuddy)arg1) → float :

Returns the absolute tolerance for the solver

Return type:float
getCoarsening((SolverBuddy)arg1) → SolverOptions :

Returns the key of the coarsening algorithm to be applied AMG, AMLI or BoomerAMG

Return type:in the list DEFAULT, YAIR_SHAPIRA_COARSENING, RUGE_STUEBEN_COARSENING, AGGREGATION_COARSENING, CIJP_FIXED_RANDOM_COARSENING, CIJP_COARSENING, FALGOUT_COARSENING, PMIS_COARSENING, HMIS_COARSENING
getCoarseningThreshold((SolverBuddy)arg1) → float :

Returns the threshold for coarsening in the algebraic multi level solver or preconditioner

Return type:float
getCycleType((SolverBuddy)arg1) → int :

Returns the cyle type (V- or W-cycle) to be used in an algebraic multi level solver or preconditioner

Return type:int
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.
getDiagonalDominanceThreshold((SolverBuddy)arg1) → float :

Returns the threshold for diagonal dominant rows which are eliminated during AMG coarsening.

Return type:float
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
getLevelMax((SolverBuddy)arg1) → int :

Returns the maximum number of coarsening levels to be used in an algebraic multi level solver or preconditioner

Return type:int
getMinCoarseMatrixSize((SolverBuddy)arg1) → int :

Returns the minimum size of the coarsest level matrix in AMG or AMLI

getMinCoarseMatrixSparsity((SolverBuddy)arg1) → float :

Returns the minimum sparsity on the coarsest level. Typically a direct solver is used when the sparsity becomes bigger than the set limit.

Returns:minimal sparsity
Return type:float
getName((SolverBuddy)arg1, (int)key) → str :

Returns the name of a given key

Parameters:key – a valid key
getNumCoarseMatrixRefinements((SolverBuddy)arg1) → int :

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

Return type:non-negative int
getNumPostSweeps((SolverBuddy)arg1) → int :

Returns he number of sweeps in the post-smoothing step of a multi level solver or preconditioner

Return type:int
getNumPreSweeps((SolverBuddy)arg1) → int :

Returns he number of sweeps in the pre-smoothing step of a multi level solver or preconditioner

Return type:int
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, SUPER_LU, PASTIX, MKL, UMFPACK, TRILINOS
getPreconditioner((SolverBuddy)arg1) → SolverOptions :

Returns the key of the preconditioner to be used.

Return type:in the list ILU0, ILUT, JACOBI, AMLI, AMG, REC_ILU, GAUSS_SEIDEL, RILU, BOOMERAMG, 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
getSmoother((SolverBuddy)arg1) → SolverOptions :

Returns key of the smoother to be used.

Return type:in the list JACOBI, GAUSS_SEIDEL
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
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 this

flag is undefined.

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[, (bool)all=False]) → None :

Resets the diagnostics

Parameters:all (bool) – if all is True all diagnostics including accumulative counters are reset.
setAMGInterpolation((SolverBuddy)arg1, (int)interpolation) → None :

Set the interpolation method for the AMG preconditioner.

Parameters:method (in CLASSIC_INTERPOLATION_WITH_FF_COUPLING, CLASSIC_INTERPOLATION, DIRECT_INTERPOLATION) – key of the interpolation method to be used.
setAbsoluteTolerance((SolverBuddy)arg1, (float)atol) → None :

Sets the absolute tolerance for the solver

Parameters:atol (non-negative float) – absolute tolerance
setAcceptanceConvergenceFailure((SolverBuddy)arg1, (bool)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

setCoarsening((SolverBuddy)arg1, (int)coarsening) → None :

Sets the key of the coarsening method to be applied in AMG or AMLI or BoomerAMG

Parameters:method (in DEFAULT, YAIR_SHAPIRA_COARSENING, RUGE_STUEBEN_COARSENING, AGGREGATION_COARSENING, CIJP_FIXED_RANDOM_COARSENING, CIJP_COARSENING, FALGOUT_COARSENING, PMIS_COARSENING, HMIS_COARSENING) – selects the coarsening method .
setCoarseningThreshold((SolverBuddy)arg1, (float)theta) → None :

Sets the threshold for coarsening in the algebraic multi level solver or preconditioner

Parameters:theta (positive float) – threshold for coarsening
setCycleType((SolverBuddy)arg1, (int)cycle_type) → None :

Sets the cycle type (V-cycle or W-cycle) to be used in an algebraic multi-level solver or preconditioner

Parameters:cycle_type (int) – the type of cycle
setDiagonalDominanceThreshold((SolverBuddy)arg1, (float)threshold) → None :

Sets the threshold for diagonal dominant rows which are eliminated during AMG coarsening.

Parameters:value (float) – threshold
setDropStorage((SolverBuddy)arg1, (float)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, (float)drop_tol) → None :

Sets the relative drop tolerance in ILUT

Parameters:drop_tol (positive float) – drop tolerance
setInnerIterMax((SolverBuddy)arg1, (int)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, (float)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, (bool)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, (int)iter_max) → None :

Sets the maximum number of iteration steps

Parameters:iter_max (int) – maximum number of iteration steps
setLevelMax((SolverBuddy)arg1, (int)level_max) → None :

Sets the maximum number of coarsening levels to be used in an algebraic multi-level solver or preconditioner

Parameters:level_max (int) – maximum number of levels
setLocalPreconditioner((SolverBuddy)arg1, (bool)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

setMinCoarseMatrixSize((SolverBuddy)arg1, (int)size) → None :

Sets the minimum size of the coarsest level matrix in AMG or AMLI

Parameters:size (positive int) – minimum size of the coarsest level matrix .
setMinCoarseMatrixSparsity((SolverBuddy)arg1, (float)sparsity) → None :

Sets the minimum sparsity on the coarsest level. Typically a direct solver is used when the sparsity becomes bigger than the set limit.

Parameters:sparsity (float) – minimal sparsity
setNumCoarseMatrixRefinements((SolverBuddy)arg1, (int)refinements) → None :

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

Parameters:refinements (non-negative int) – number of refinements
setNumPostSweeps((SolverBuddy)arg1, (int)sweeps) → None :

Sets the number of sweeps in the post-smoothing step of a multi level solver or preconditioner

Parameters:sweeps (positive int) – number of sweeps
setNumPreSweeps((SolverBuddy)arg1, (int)sweeps) → None :

Sets the number of sweeps in the pre-smoothing step of a multi level solver or preconditioner

Parameters:sweeps (positive int) – number of sweeps
setNumRefinements((SolverBuddy)arg1, (int)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, (int)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, (int)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, (int)package) → None :

Sets the solver package to be used as a solver.

Parameters:package (in DEFAULT, PASO, SUPER_LU, PASTIX, MKL, UMFPACK, 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, (int)preconditioner) → None :

Sets the preconditioner to be used.

Parameters:preconditioner (in ILU0, ILUT, JACOBI, AMG, AMLI, REC_ILU, GAUSS_SEIDEL, RILU, BOOMERAMG, 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 unknown

preconditioner.

setRelaxationFactor((SolverBuddy)arg1, (float)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, (int)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, (int)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.
setSmoother((SolverBuddy)arg1, (int)smoother) → None :

Sets the smoother to be used.

Parameters:smoother (in JACOBI, GAUSS_SEIDEL) – key of the smoother to be used.
Note:Not all packages support all smoothers. It can be assumed that a package makes a reasonable choice if it encounters an unknown smoother.
setSolverMethod((SolverBuddy)arg1, (int)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, (bool)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, (float)rtol) → None :

Sets the relative tolerance for the solver

Parameters:rtol (non-negative float) – relative tolerance
setTruncation((SolverBuddy)arg1, (int)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
setUsePanel((SolverBuddy)arg1, (bool)use) → None :

Sets the flag to use a panel to find unknowns in AMG coarsening

Parameters:use (bool) – If True,a panel is used to find unknowns in AMG coarsening
setUsePanelOff((SolverBuddy)arg1) → None :

Sets the flag to use a panel to find unknowns in AMG coarsening to off

setUsePanelOn((SolverBuddy)arg1) → None :

Sets the flag to use a panel to find unknowns in AMG coarsening

setVerbosity((SolverBuddy)arg1, (bool)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
usePanel((SolverBuddy)arg1) → bool :

Returns True if a panel is used to search for unknown in the AMG coarsening, The panel approach is normally faster but can lead to larger coarse level systems.

Returns:True if a panel is used to find unknowns in AMG coarsening
Return type:bool
class esys.escript.SolverOptions

Bases: Boost.Python.enum

AGGREGATION_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.AGGREGATION_COARSENING
AMG = esys.escriptcore.escriptcpp.SolverOptions.AMG
AMLI = esys.escriptcore.escriptcpp.SolverOptions.AMLI
BACKWARD_EULER = esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER
BICGSTAB = esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB
BOOMERAMG = esys.escriptcore.escriptcpp.SolverOptions.BOOMERAMG
CGS = esys.escriptcore.escriptcpp.SolverOptions.CGS
CHOLEVSKY = esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY
CIJP_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.CIJP_COARSENING
CIJP_FIXED_RANDOM_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.CIJP_FIXED_RANDOM_COARSENING
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
FALGOUT_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.FALGOUT_COARSENING
GAUSS_SEIDEL = esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL
GMRES = esys.escriptcore.escriptcpp.SolverOptions.GMRES
HMIS_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.HMIS_COARSENING
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
LUMPING = esys.escriptcore.escriptcpp.SolverOptions.LUMPING
MINIMUM_FILL_IN = esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN
MINRES = esys.escriptcore.escriptcpp.SolverOptions.MINRES
MIN_COARSE_MATRIX_SIZE = esys.escriptcore.escriptcpp.SolverOptions.MIN_COARSE_MATRIX_SIZE
MKL = esys.escriptcore.escriptcpp.SolverOptions.MKL
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
PASTIX = esys.escriptcore.escriptcpp.SolverOptions.PASTIX
PCG = esys.escriptcore.escriptcpp.SolverOptions.PCG
PMIS_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.PMIS_COARSENING
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
RUGE_STUEBEN_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.RUGE_STUEBEN_COARSENING
STANDARD_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.STANDARD_COARSENING
SUPER_LU = esys.escriptcore.escriptcpp.SolverOptions.SUPER_LU
TFQMR = esys.escriptcore.escriptcpp.SolverOptions.TFQMR
TRILINOS = esys.escriptcore.escriptcpp.SolverOptions.TRILINOS
UMFPACK = esys.escriptcore.escriptcpp.SolverOptions.UMFPACK
YAIR_SHAPIRA_COARSENING = esys.escriptcore.escriptcpp.SolverOptions.YAIR_SHAPIRA_COARSENING
bit_length() → int

Number of bits necessary to represent self in binary. >>> bin(37) ‘0b100101’ >>> (37).bit_length() 6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

imag

the imaginary part of a complex number

name
names = {'BICGSTAB': esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB, 'RILU': esys.escriptcore.escriptcpp.SolverOptions.RILU, 'DEFAULT_REORDERING': esys.escriptcore.escriptcpp.SolverOptions.DEFAULT_REORDERING, 'ILU0': esys.escriptcore.escriptcpp.SolverOptions.ILU0, 'TFQMR': esys.escriptcore.escriptcpp.SolverOptions.TFQMR, 'DEFAULT': esys.escriptcore.escriptcpp.SolverOptions.DEFAULT, 'MKL': esys.escriptcore.escriptcpp.SolverOptions.MKL, 'ITERATIVE': esys.escriptcore.escriptcpp.SolverOptions.ITERATIVE, 'DIRECT': esys.escriptcore.escriptcpp.SolverOptions.DIRECT, 'MIN_COARSE_MATRIX_SIZE': esys.escriptcore.escriptcpp.SolverOptions.MIN_COARSE_MATRIX_SIZE, 'BACKWARD_EULER': esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER, 'BOOMERAMG': esys.escriptcore.escriptcpp.SolverOptions.BOOMERAMG, 'GAUSS_SEIDEL': esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL, 'CIJP_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.CIJP_COARSENING, 'PCG': esys.escriptcore.escriptcpp.SolverOptions.PCG, 'NO_PRECONDITIONER': esys.escriptcore.escriptcpp.SolverOptions.NO_PRECONDITIONER, 'LUMPING': esys.escriptcore.escriptcpp.SolverOptions.LUMPING, 'PRES20': esys.escriptcore.escriptcpp.SolverOptions.PRES20, 'STANDARD_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.STANDARD_COARSENING, 'CIJP_FIXED_RANDOM_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.CIJP_FIXED_RANDOM_COARSENING, 'PMIS_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.PMIS_COARSENING, 'UMFPACK': esys.escriptcore.escriptcpp.SolverOptions.UMFPACK, 'AMG': esys.escriptcore.escriptcpp.SolverOptions.AMG, 'RUGE_STUEBEN_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.RUGE_STUEBEN_COARSENING, 'MINRES': esys.escriptcore.escriptcpp.SolverOptions.MINRES, 'CLASSIC_INTERPOLATION_WITH_FF_COUPLING': esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION_WITH_FF_COUPLING, 'MINIMUM_FILL_IN': esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN, 'CGS': esys.escriptcore.escriptcpp.SolverOptions.CGS, 'CRANK_NICOLSON': esys.escriptcore.escriptcpp.SolverOptions.CRANK_NICOLSON, 'NESTED_DISSECTION': esys.escriptcore.escriptcpp.SolverOptions.NESTED_DISSECTION, 'LINEAR_CRANK_NICOLSON': esys.escriptcore.escriptcpp.SolverOptions.LINEAR_CRANK_NICOLSON, 'NONLINEAR_GMRES': esys.escriptcore.escriptcpp.SolverOptions.NONLINEAR_GMRES, 'AMLI': esys.escriptcore.escriptcpp.SolverOptions.AMLI, 'CHOLEVSKY': esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY, 'CLASSIC_INTERPOLATION': esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION, 'HRZ_LUMPING': esys.escriptcore.escriptcpp.SolverOptions.HRZ_LUMPING, 'AGGREGATION_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.AGGREGATION_COARSENING, 'ROWSUM_LUMPING': esys.escriptcore.escriptcpp.SolverOptions.ROWSUM_LUMPING, 'TRILINOS': esys.escriptcore.escriptcpp.SolverOptions.TRILINOS, 'PASO': esys.escriptcore.escriptcpp.SolverOptions.PASO, 'NO_REORDERING': esys.escriptcore.escriptcpp.SolverOptions.NO_REORDERING, 'HMIS_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.HMIS_COARSENING, 'YAIR_SHAPIRA_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.YAIR_SHAPIRA_COARSENING, 'CR': esys.escriptcore.escriptcpp.SolverOptions.CR, 'PASTIX': esys.escriptcore.escriptcpp.SolverOptions.PASTIX, 'ILUT': esys.escriptcore.escriptcpp.SolverOptions.ILUT, 'FALGOUT_COARSENING': esys.escriptcore.escriptcpp.SolverOptions.FALGOUT_COARSENING, 'DIRECT_INTERPOLATION': esys.escriptcore.escriptcpp.SolverOptions.DIRECT_INTERPOLATION, 'SUPER_LU': esys.escriptcore.escriptcpp.SolverOptions.SUPER_LU, 'REC_ILU': esys.escriptcore.escriptcpp.SolverOptions.REC_ILU, 'GMRES': esys.escriptcore.escriptcpp.SolverOptions.GMRES, 'JACOBI': esys.escriptcore.escriptcpp.SolverOptions.JACOBI}
numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

values = {0: esys.escriptcore.escriptcpp.SolverOptions.DEFAULT, 1: esys.escriptcore.escriptcpp.SolverOptions.DIRECT, 2: esys.escriptcore.escriptcpp.SolverOptions.CHOLEVSKY, 3: esys.escriptcore.escriptcpp.SolverOptions.PCG, 4: esys.escriptcore.escriptcpp.SolverOptions.CR, 5: esys.escriptcore.escriptcpp.SolverOptions.CGS, 6: esys.escriptcore.escriptcpp.SolverOptions.BICGSTAB, 8: esys.escriptcore.escriptcpp.SolverOptions.ILU0, 9: esys.escriptcore.escriptcpp.SolverOptions.ILUT, 10: esys.escriptcore.escriptcpp.SolverOptions.JACOBI, 11: esys.escriptcore.escriptcpp.SolverOptions.GMRES, 12: esys.escriptcore.escriptcpp.SolverOptions.PRES20, 13: esys.escriptcore.escriptcpp.SolverOptions.ROWSUM_LUMPING, 14: esys.escriptcore.escriptcpp.SolverOptions.HRZ_LUMPING, 15: esys.escriptcore.escriptcpp.SolverOptions.MKL, 16: esys.escriptcore.escriptcpp.SolverOptions.UMFPACK, 17: esys.escriptcore.escriptcpp.SolverOptions.NO_REORDERING, 18: esys.escriptcore.escriptcpp.SolverOptions.MINIMUM_FILL_IN, 19: esys.escriptcore.escriptcpp.SolverOptions.NESTED_DISSECTION, 20: esys.escriptcore.escriptcpp.SolverOptions.ITERATIVE, 21: esys.escriptcore.escriptcpp.SolverOptions.PASO, 22: esys.escriptcore.escriptcpp.SolverOptions.AMG, 23: esys.escriptcore.escriptcpp.SolverOptions.REC_ILU, 24: esys.escriptcore.escriptcpp.SolverOptions.TRILINOS, 25: esys.escriptcore.escriptcpp.SolverOptions.NONLINEAR_GMRES, 26: esys.escriptcore.escriptcpp.SolverOptions.TFQMR, 27: esys.escriptcore.escriptcpp.SolverOptions.MINRES, 28: esys.escriptcore.escriptcpp.SolverOptions.GAUSS_SEIDEL, 29: esys.escriptcore.escriptcpp.SolverOptions.RILU, 30: esys.escriptcore.escriptcpp.SolverOptions.DEFAULT_REORDERING, 31: esys.escriptcore.escriptcpp.SolverOptions.SUPER_LU, 32: esys.escriptcore.escriptcpp.SolverOptions.PASTIX, 33: esys.escriptcore.escriptcpp.SolverOptions.YAIR_SHAPIRA_COARSENING, 34: esys.escriptcore.escriptcpp.SolverOptions.RUGE_STUEBEN_COARSENING, 35: esys.escriptcore.escriptcpp.SolverOptions.AGGREGATION_COARSENING, 36: esys.escriptcore.escriptcpp.SolverOptions.NO_PRECONDITIONER, 37: esys.escriptcore.escriptcpp.SolverOptions.MIN_COARSE_MATRIX_SIZE, 38: esys.escriptcore.escriptcpp.SolverOptions.AMLI, 39: esys.escriptcore.escriptcpp.SolverOptions.STANDARD_COARSENING, 50: esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION_WITH_FF_COUPLING, 51: esys.escriptcore.escriptcpp.SolverOptions.CLASSIC_INTERPOLATION, 52: esys.escriptcore.escriptcpp.SolverOptions.DIRECT_INTERPOLATION, 60: esys.escriptcore.escriptcpp.SolverOptions.BOOMERAMG, 61: esys.escriptcore.escriptcpp.SolverOptions.CIJP_FIXED_RANDOM_COARSENING, 62: esys.escriptcore.escriptcpp.SolverOptions.CIJP_COARSENING, 63: esys.escriptcore.escriptcpp.SolverOptions.FALGOUT_COARSENING, 64: esys.escriptcore.escriptcpp.SolverOptions.PMIS_COARSENING, 65: esys.escriptcore.escriptcpp.SolverOptions.HMIS_COARSENING, 66: esys.escriptcore.escriptcpp.SolverOptions.LINEAR_CRANK_NICOLSON, 67: esys.escriptcore.escriptcpp.SolverOptions.CRANK_NICOLSON, 68: esys.escriptcore.escriptcpp.SolverOptions.BACKWARD_EULER}
class esys.escript.Symbol(*args, **kwargs)

Bases: object

Symbol objects are placeholders for a single mathematical symbol, such as ‘x’, or for arbitrarily complex mathematical expressions such as ‘c*x**4+alpha*exp(x)-2*sin(beta*x)’, where ‘alpha’, ‘beta’, ‘c’, and ‘x’ are also Symbols (the symbolic ‘atoms’ of the expression).

With the help of the ‘Evaluator’ class these symbols and expressions can be resolved by substituting numeric values and/or escript Data objects for the atoms. To facilitate the use of Data objects a Symbol has a shape (and thus a rank) as well as a dimension (see constructor). Symbols are useful to perform mathematical simplifications, compute derivatives and as coefficients for nonlinear PDEs which can be solved by the NonlinearPDE class.

applyfunc(f, on_type=None)

Applies the function f to all elements (if on_type is None) or to all elements of type on_type.

atoms(*types)

Returns the atoms that form the current Symbol.

By default, only objects that are truly atomic and cannot be divided into smaller pieces are returned: symbols, numbers, and number symbols like I and pi. It is possible to request atoms of any type, however.

Note that if this symbol contains components such as [x]_i_j then only their main symbol ‘x’ is returned.

Parameters:types – types to restrict result to
Returns:list of atoms of specified type
Return type:set
coeff(x, expand=True)

Returns the coefficient of the term “x” or 0 if there is no “x”.

If “x” is a scalar symbol then “x” is searched in all components of this symbol. Otherwise the shapes must match and the coefficients are checked component by component.

Example:

x=Symbol('x', (2,2))
y=3*x
print y.coeff(x)
print y.coeff(x[1,1])

will print:

[[3 3]
 [3 3]]

[[0 0]
 [0 3]]
Parameters:x (Symbol, numpy.ndarray, list) – the term whose coefficients are to be found
Returns:the coefficient(s) of the term
Return type:Symbol
diff(*symbols, **assumptions)
evalf()

Applies the sympy.evalf operation on all elements in this symbol

expand()

Applies the sympy.expand operation on all elements in this symbol

getDataSubstitutions()

Returns a dictionary of symbol names and the escript Data objects they represent within this Symbol.

Returns:the dictionary of substituted Data objects
Return type:dict
getDim()

Returns the spatial dimensionality of this symbol.

Returns:the symbol’s spatial dimensionality, or -1 if undefined
Return type:int
getRank()

Returns the rank of this symbol.

Returns:the symbol’s rank which is equal to the length of the shape.
Return type:int
getShape()

Returns the shape of this symbol.

Returns:the symbol’s shape
Return type:tuple of int
grad(where=None)

Returns a symbol which represents the gradient of this symbol. :type where: Symbol, FunctionSpace

inverse()
is_Add = False
is_Float = False
item(*args)

Returns an element of this symbol. This method behaves like the item() method of numpy.ndarray. If this is a scalar Symbol, no arguments are allowed and the only element in this Symbol is returned. Otherwise, ‘args’ specifies a flat or nd-index and the element at that index is returned.

Parameters:args – index of item to be returned
Returns:the requested element
Return type:sympy.Symbol, int, or float
lambdarepr()
simplify()

Applies the sympy.simplify operation on all elements in this symbol

subs(old, new)

Substitutes an expression.

swap_axes(axis0, axis1)
tensorProduct(other, axis_offset)
tensorTransposedProduct(other, axis_offset)
trace(axis_offset)

Returns the trace of this Symbol.

transpose(axis_offset)

Returns the transpose of this Symbol.

transposedTensorProduct(other, axis_offset)
class esys.escript.TestDomain

Bases: esys.escriptcore.escriptcpp.Domain

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

MPIBarrier((Domain)arg1) → None :

Wait until all processes have reached this point

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

Dumps the domain to a file:param filename: :type 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
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
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, (int)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.TransportProblem((object)arg1)

Bases: Boost.Python.instance

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) → None :

resets the transport operator typically as they have been updated.

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

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

Return type:Data
Parameters:source (Data) –

Functions

esys.escript.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.C_GeneralTensorProduct((Data)arg0, (Data)arg1[, (int)axis_offset=0[, (int)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.ContinuousFunction((Domain)domain) → FunctionSpace :
Returns:a continuous FunctionSpace (overlapped node values)
Return type:FunctionSpace
esys.escript.DiracDeltaFunctions((Domain)domain) → FunctionSpace :
Return type:FunctionSpace
esys.escript.Function((Domain)domain) → FunctionSpace :
Returns:a function FunctionSpace
Return type:FunctionSpace
esys.escript.FunctionOnBoundary((Domain)domain) → FunctionSpace :
Returns:a function on boundary FunctionSpace
Return type:FunctionSpace
esys.escript.FunctionOnContactOne((Domain)domain) → FunctionSpace :
Returns:Return a FunctionSpace on right side of contact
Return type:FunctionSpace
esys.escript.FunctionOnContactZero((Domain)domain) → FunctionSpace :
Returns:Return a FunctionSpace on left side of contact
Return type:FunctionSpace
esys.escript.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.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.MPIBarrierWorld() → None :

Wait until all MPI processes have reached this point.

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

Creates a new expanded Data object containing pseudo-random values.

Parameters:
  • shape (tuple) – datapoint shape
  • fs (FunctionSpace) – function space for data object.
  • seed (long) – seed for random number generator.
esys.escript.ReducedContinuousFunction((Domain)domain) → FunctionSpace :
Returns:a continuous with reduced order FunctionSpace (overlapped node values on reduced element order)
Return type:FunctionSpace
esys.escript.ReducedFunction((Domain)domain) → FunctionSpace :
Returns:a function FunctionSpace with reduced integration order
Return type:FunctionSpace
esys.escript.ReducedFunctionOnBoundary((Domain)domain) → FunctionSpace :
Returns:a function on boundary FunctionSpace with reduced integration order
Return type:FunctionSpace
esys.escript.ReducedFunctionOnContactOne((Domain)domain) → FunctionSpace :
Returns:Return a FunctionSpace on right side of contact with reduced integration order
Return type:FunctionSpace
esys.escript.ReducedFunctionOnContactZero((Domain)domain) → FunctionSpace :
Returns:a FunctionSpace on left side of contact with reduced integration order
Return type:FunctionSpace
esys.escript.ReducedSolution((Domain)domain) → FunctionSpace :
Return type:FunctionSpace
esys.escript.Scalar([(float)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fd151a8f750>[, (bool)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.Solution((Domain)domain) → FunctionSpace :
Return type:FunctionSpace
esys.escript.Tensor([(float)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fd151a8f8d0>[, (bool)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 0x7fd151a8f950> [, (bool)expanded=False]]) -> Data

esys.escript.Tensor3([(float)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fd151a8f9d0>[, (bool)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 0x7fd151a8fa50> [, (bool)expanded=False]]) -> Data

esys.escript.Tensor4([(float)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fd151a8fad0>[, (bool)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 0x7fd151a8fb50> [, (bool)expanded=False]]) -> Data

esys.escript.Vector([(float)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fd151a8f7d0>[, (bool)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 0x7fd151a8f850> [, (bool)expanded=False]]) -> Data

esys.escript.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.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.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.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.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.atan2(arg0, arg1)

Returns inverse tangent of argument arg0 over arg1

esys.escript.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.blocktimer_increment((str)arg1, (float)arg2) → None
esys.escript.blocktimer_initialize() → None
esys.escript.blocktimer_reportSortByName() → None
esys.escript.blocktimer_reportSortByTime() → None
esys.escript.blocktimer_time() → float
esys.escript.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.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.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.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.combineData(array, shape)
esys.escript.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.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.condEval(f, tval, fval)

Wrapper to allow non-data objects to be used.

esys.escript.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.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.delay(arg)

Returns a lazy version of arg

esys.escript.deviatoric(arg)

Returns the deviatoric version of arg.

esys.escript.diameter(domain)

Returns the diameter of a domain.

Parameters:domain (escript.Domain) – a domain
Return type:float
esys.escript.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.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.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.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.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.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.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.escript_inverse(arg)

arg is a Data object!

esys.escript.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.generalTensorProduct(arg0, arg1, axis_offset=0)

Generalized tensor product.

C{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.generalTensorTransposedProduct(arg0, arg1, axis_offset=0)

Generalized tensor product of arg0 and transpose of arg1.

C{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.generalTransposedTensorProduct(arg0, arg1, axis_offset=0)

Generalized tensor product of transposed of arg0 and arg1.

C{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.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.getEpsilon()
esys.escript.getEscriptParamInt((str)name[, (int)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.getMPIRankWorld() → int :

Return the rank of this process in the MPI World.

esys.escript.getMPISizeWorld() → int :

Return number of MPI processes in the job.

esys.escript.getMPIWorldMax((int)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.getMPIWorldSum((int)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.getMachinePrecision() → float
esys.escript.getMaxFloat()
esys.escript.getNumberOfThreads() → int :

Return the maximum number of threads available to OpenMP.

esys.escript.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.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.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.getTestDomainFunctionSpace((int)dpps, (int)samples[, (int)size=1]) → FunctionSpace :

For testing only. May be removed without notice.

esys.escript.getTotalDifferential(f, x, order=0)

This function computes:

| Df/Dx = del_f/del_x + del_f/del_grad(x)*del_grad(x)/del_x + ...
|            \   /         \   /
|              a             b
esys.escript.getVersion() → int :

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

esys.escript.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.grad_n(arg, n, where=None)
esys.escript.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.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.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.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.inner(arg0, arg1)

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

C{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.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.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.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.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.interpolateTable(tab, dat, start, step, undef=1e+50, check_boundaries=False)
esys.escript.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.isSymbol(arg)

Returns True if the argument arg is an escript Symbol or sympy.Basic object, False otherwise.

esys.escript.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.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.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.listEscriptParams() → list :
Returns:A list of pairs (p,d) where p is the name of a parameter for escript and d is a description.
esys.escript.load((str)fileName, (Domain)domain) → Data :

reads Data on domain from file in netCDF format

Parameters:
  • fileName (string) –
  • domain (Domain) –
esys.escript.loadIsConfigured() → bool :
Returns:True if the load function is configured.
esys.escript.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.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.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.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.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.matrix_mult(arg0, arg1)

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

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

or

C{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.matrix_transposed_mult(arg0, arg1)

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

C{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.matrixmult(arg0, arg1)

See matrix_mult.

esys.escript.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.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.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.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.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.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.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.negative(arg)

returns the negative part of arg

esys.escript.nonsymmetric(arg)

Returns the non-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:non-symmetric part of arg
Return type:numpy.ndarray, escript.Data, Symbol depending on the input
esys.escript.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.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.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.positive(arg)

returns the positive part of arg

esys.escript.pprint(expr, use_unicode=None)

Prints expr in pretty form.

pprint is just a shortcut for this function

esys.escript.pretty_print(expr, use_unicode=None)

Prints expr in pretty form.

pprint is just a shortcut for this function

esys.escript.printParallelThreadCounts() → None
esys.escript.releaseUnusedMemory() → None
esys.escript.removeFsFromGrad(sym)

Returns sym with all occurrences grad_n(a,b,c) replaced by grad_n(a,b). That is, all functionspace parameters are removed.

esys.escript.reorderComponents(arg, index)

Resorts the components of arg according to index.

esys.escript.resolve(arg)

Returns the value of arg resolved.

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

Spawns an external MPI program using a separate communicator.

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

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

esys.escript.saveDataCSV(filename, append=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
  • 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.saveESD(datasetName, dataDir='.', domain=None, timeStep=0, deltaT=1, dynamicMesh=0, timeStepFormat='%04d', **data)

Saves Data objects to files and creates an I{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.setEscriptParamInt((str)name[, (int)value=0]) → None :

Modify the value of an escript tuning parameter

Parameters:
  • name (string) –
  • value (int) –
esys.escript.setNumberOfThreads((int)arg1) → None :

Use of this method is strongly discouraged.

esys.escript.showEscriptParams()

Displays the parameters escript recognises with an explanation and their current value.

esys.escript.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.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.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.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.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.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.symbols(*names, **kwargs)

Emulates the behaviour of sympy.symbols.

esys.escript.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.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.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.tensor_mult(arg0, arg1)

The tensor product of the two arguments.

For arg0 of rank 2 this is

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

or

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

and for arg0 of rank 4 this is

C{out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[r0,r1,s2,s3]}

or

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

or

C{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.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

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

and for arg0 of rank 4 this is

C{out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[s0,s1,r0,r1]*arg1[s2,s3,r0,r1]}

or

C{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.tensormult(arg0, arg1)

See tensor_mult.

esys.escript.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.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.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.transposed_matrix_mult(arg0, arg1)

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

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

or

C{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.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

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

or

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

and for arg0 of rank 4 this is

C{out[s0,s1,s2,s3]=Sigma_{r0,r1} arg0[r0,r1,s0,s1]*arg1[r0,r1,s2,s3]}

or

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

or

C{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.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.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.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.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.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.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.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.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.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
  • HAVE_SYMBOLS
  • __builtins__
  • __copyright__
  • __doc__
  • __file__
  • __license__
  • __name__
  • __package__
  • __path__
  • __url__