esys.downunder.forwardmodels.gravity Package¶

Forward model for gravity (Bouguer) anomaly

Classes¶

Data
FileWriter
ForwardModelWithPotential
GravityModel

class esys.downunder.forwardmodels.gravity.Data¶

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

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

conjugate((Data)arg1) → Data ¶

copy((Data)arg1, (Data)other) → None :¶

Make this object a copy of other

note

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

copy( (Data)arg1) -> Data :

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

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

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

Parameters

other (Data) – source of values
mask (Scalar Data) –

delay((Data)arg1) → Data :¶: Convert this object into lazy representation

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

Save the data as a netCDF file

Parameters: fileName (string) –

expand((Data)arg1) → None :¶: Convert the data to expanded representation if it is not expanded already.

getDomain((Data)arg1) → Domain :¶

Return type: Domain

getFunctionSpace((Data)arg1) → FunctionSpace :¶

Return type: FunctionSpace

getNumberOfDataPoints((Data)arg1) → int :¶

Return type: int
Returns: Number of datapoints in the object

getRank((Data)arg1) → int :¶

Returns: the number of indices required to address a component of a datapoint
Return type: positive int

getShape((Data)arg1) → tuple :¶

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

Return type: tuple

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

Return tag number for the specified datapoint

Return type: int
Parameters: dpno (int) – datapoint number

getTupleForDataPoint((Data)arg1, (object)dataPointNo) → object :¶

Returns: Value of the specified datapoint
Return type: tuple
Parameters: dataPointNo (int) – datapoint to access

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

Get a specific datapoint from a specific process

Return type

tuple

Parameters

procNo (positive int) – MPI rank of the process
dataPointNo (int) – datapoint to access

getX((Data)arg1) → Data :¶: Returns the spatial coordinates of the spatial nodes. :rtype: Data

hasInf((Data)arg1) → bool :¶: Returns return true if data contains +-Inf. [Note that for complex values, hasNaN and hasInf are not mutually exclusive.]

hasNaN((Data)arg1) → bool :¶: Returns return true if data contains NaN. [Note that for complex values, hasNaN and hasInf are not mutually exclusive.]

imag((Data)arg1) → Data ¶

internal_maxGlobalDataPoint((Data)arg1) → tuple :¶: Please consider using getSupLocator() from pdetools instead.

internal_minGlobalDataPoint((Data)arg1) → tuple :¶: Please consider using getInfLocator() from pdetools instead.

interpolate((Data)arg1, (FunctionSpace)functionspace) → Data :¶: Interpolate this object’s values into a new functionspace.

interpolateTable((Data)arg1, (object)table, (object)Amin, (object)Astep, (Data)B, (object)Bmin, (object)Bstep[, (object)undef=1e+50[, (object)check_boundaries=False]]) → Data :¶

Creates a new Data object by interpolating using the source data (which are

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

param table: two dimensional collection of values
param Amin: The base of locations in table
type Amin: float
param Astep: size of gap between each item in the table
type Astep: float
param undef: upper bound on interpolated values
type undef: float
param B: Scalar representing the second coordinate to be mapped into the table
type B: Data
param Bmin: The base of locations in table for 2nd dimension
type Bmin: float
param Bstep: size of gap between each item in the table for 2nd dimension
type Bstep: float
param check_boundaries: if true, then values outside the boundaries will be rejected. If false, then boundary values will be used.
raise RuntimeError(DataException): if the coordinates do not map into the table or if the interpolated value is above undef
rtype: Data

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

isComplex((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data stores complex values.

isConstant((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data is an instance of DataConstant
Note: This does not mean the data is immutable.

isEmpty((Data)arg1) → bool :¶

Is this object an instance of DataEmpty

Return type: bool
Note: This is not the same thing as asking if the object contains datapoints.

isExpanded((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data is expanded.

isLazy((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data is lazy.

isProtected((Data)arg1) → bool :¶: Can this instance be modified. :rtype: bool

isReady((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data is not lazy.

isTagged((Data)arg1) → bool :¶

Return type: bool
Returns: True if this Data is expanded.

nonuniformInterpolate((Data)arg1, (object)in, (object)out, (object)check_boundaries) → Data :¶: 1D interpolation with non equally spaced points

nonuniformSlope((Data)arg1, (object)in, (object)out, (object)check_boundaries) → Data :¶: 1D interpolation of slope with non equally spaced points

phase((Data)arg1) → Data ¶

promote((Data)arg1) → None¶

real((Data)arg1) → Data ¶

replaceInf((Data)arg1, (object)value) → None :¶: Replaces +-Inf values with value. [Note, for complex Data, both real and imaginary components are replaced even if only one part is Inf].

replaceNaN((Data)arg1, (object)value) → None :¶: Replaces NaN values with value. [Note, for complex Data, both real and imaginary components are replaced even if only one part is NaN].

resolve((Data)arg1) → None :¶: Convert the data to non-lazy representation.

setProtection((Data)arg1) → None :¶

Disallow modifications to this data object

Note: This method does not allow you to undo protection.

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

Set the value of tagged Data.

param tagKey

tag to update

type tagKey

int

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

param name: tag to update
type name: string
param value: value to set tagged data to
type value: object which acts like an array, tuple or list

setToZero((Data)arg1) → None :¶: After this call the object will store values of the same shape as before but all components will be zero.

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

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

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

Modify the value of a single datapoint.

param dataPointNo

type dataPointNo

int

param value

type value

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

warning

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

tag((Data)arg1) → None :¶: Convert data to tagged representation if it is not already tagged or expanded

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

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

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

class esys.downunder.forwardmodels.gravity.FileWriter(fn, append=False, createLocalFiles=False)¶

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

Variables

name – name of file
mode – access mode (=’w’ or =’a’)
closed – True to indicate closed file
newlines – line seperator

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

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

Parameters

fn (str) – filename.
append (bool) – switches on the creation of local files.
createLocalFiles (bool) – switches on the creation of local files.

close()¶: Closes the file

flush()¶: Flush the internal I/O buffer.

write(txt)¶

Write string txt to file.

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

writelines(txts)¶

Write the list txt of strings to the file.

Parameters: txts (any iterable object producing strings) – sequense of strings to be written to file
Note: Note that newlines are not added. This method is equivalent to call write() for each string.

class esys.downunder.forwardmodels.gravity.ForwardModelWithPotential(domain, w, data, coordinates=None, fixPotentialAtBottom=False, tol=1e-08)¶

Base class for a forward model using a potential such as magnetic or gravity. It defines a cost function:

defect = 1/2 sum_s integrate( ( weight_i[s] * ( r_i - data_i[s] ) )**2 )

where s runs over the survey, weight_i are weighting factors, data_i are the data, and r_i are the results produced by the forward model. It is assumed that the forward model is produced through postprocessing of the solution of a potential PDE.

__init__(domain, w, data, coordinates=None, fixPotentialAtBottom=False, tol=1e-08)¶

initializes a new forward model with potential.

Parameters

domain (Domain) – domain of the model
w (Vector or list of Vector) – data weighting factors
data (Vector or list of Vector) – data
coordinates (ReferenceSystem or SpatialCoordinateTransformation) – defines coordinate system to be used
fixPotentialAtBottom (bool) – if true potential is fixed to zero at the bottom of the domain in addition to the top.
tol (positive float) – tolerance of underlying PDE

getCoordinateTransformation()¶

returns the coordinate transformation being used

Return type: CoordinateTransformation

getData()¶

Returns the data

Return type: list of Data

getDataFunctionSpace()¶

Returns the FunctionSpace of the data

Return type: FunctionSpace

getDefectGradient(result)¶

getDomain()¶

Returns the domain of the forward model.

Return type: Domain

getMisfitWeights()¶

Returns the weights of the misfit function

Return type: list of Data

getPDE()¶

Return the underlying PDE.

Return type: LinearPDE

getSurvey(index=None)¶: Returns the pair (data_index, weight_index), where data_i is the data of survey i, weight_i is the weighting factor for survey i. If index is None, all surveys will be returned in a pair of lists.

class esys.downunder.forwardmodels.gravity.GravityModel(domain, w, g, gravity_constant=6.6742e-11, coordinates=None, fixPotentialAtBottom=False, tol=1e-08)¶

Forward Model for gravity inversion as described in the inversion cookbook.

__init__(domain, w, g, gravity_constant=6.6742e-11, coordinates=None, fixPotentialAtBottom=False, tol=1e-08)¶

Creates a new gravity model on the given domain with one or more surveys (w, g).

Parameters

domain (Domain) – domain of the model
w (Vector or list of Vector) – data weighting factors
g (Vector or list of Vector) – gravity anomaly data
coordinates (ReferenceSystem` or SpatialCoordinateTransformation) – defines coordinate system to be used
tol (positive float) – tolerance of underlying PDE
fixPotentialAtBottom (bool) – if true potential is fixed to zero at the base of the domain in addition to the top

Note

It is advisable to call rescaleWeights() to rescale weights before starting the inversion.

getArguments(rho)¶

Returns precomputed values shared by getDefect() and getGradient().

Parameters: rho (Scalar) – a suggestion for the density distribution
Returns: gravity potential and corresponding gravity field.
Return type: Scalar, Vector

getDefect(rho, phi, gravity_force)¶

Returns the value of the defect

Parameters

rho (Scalar) – density distribution
phi (Scalar) – corresponding potential
gravity_force (Vector) – gravity force

Return type

float

getGradient(rho, phi, gravity_force)¶

Returns the gradient of the defect with respect to density.

Parameters

rho (Scalar) – density distribution
phi (Scalar) – corresponding potential
gravity_force (Vector) – gravity force

Return type

Scalar

getPotential(rho)¶

Calculates the gravity potential for a given density distribution.

Parameters: rho (Scalar) – a suggestion for the density distribution
Returns: gravity potential
Return type: Scalar

rescaleWeights(scale=1.0, rho_scale=1.0)¶

rescales the weights such that

sum_s integrate( ( w_i[s] *g_i[s]) (w_j[s]*1/L_j) * L**2 * 4*pi*G*rho_scale )=scale

Parameters

scale (positive float) – scale of data weighting factors
rho_scale (Scalar) – scale of density.

Functions¶

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.C_GeneralTensorProduct((Data)arg0, (Data)arg1[, (object)axis_offset=0[, (object)transpose=0]]) → Data :¶

Compute a tensor product of two Data objects.

Return type

Data

Parameters

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.NumpyToData(array, isComplex, functionspace)¶

Uses a numpy ndarray to create a Data object

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.antihermitian(arg)¶

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

Parameters: arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.
Returns: anti-hermitian part of arg
Return type: numpy.ndarray, escript.Data, Symbol depending on the input

esys.downunder.forwardmodels.gravity.antisymmetric(arg)¶

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

Parameters: arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.
Returns: anti-symmetric part of arg
Return type: numpy.ndarray, escript.Data, Symbol depending on the input

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.atan2(arg0, arg1)¶: Returns inverse tangent of argument arg0 over arg1

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.condEval(f, tval, fval)¶: Wrapper to allow non-data objects to be used.

esys.downunder.forwardmodels.gravity.convertToNumpy(data)¶

Writes Data objects to a numpy array.

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

Example usage:

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.delay(arg)¶: Returns a lazy version of arg

esys.downunder.forwardmodels.gravity.deviatoric(arg)¶: Returns the deviatoric version of arg.

esys.downunder.forwardmodels.gravity.diameter(domain)¶

Returns the diameter of a domain.

Parameters: domain (escript.Domain) – a domain
Return type: float

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.escript_inverse(arg)¶: arg is a Data object!

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.generalTensorProduct(arg0, arg1, axis_offset=0)¶

Generalized tensor product.

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

where

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

Parameters

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

Returns

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

Return type

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

esys.downunder.forwardmodels.gravity.generalTensorTransposedProduct(arg0, arg1, axis_offset=0)¶

Generalized tensor product of arg0 and transpose of arg1.

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

where

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

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

Parameters

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

Returns

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

Return type

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

esys.downunder.forwardmodels.gravity.generalTransposedTensorProduct(arg0, arg1, axis_offset=0)¶

Generalized tensor product of transposed of arg0 and arg1.

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

where

s runs through arg0.Shape[axis_offset:]
r runs through arg0.Shape[:axis_offset]
t runs through arg1.Shape[axis_offset:]

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

Parameters

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

Returns

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

Return type

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.getEpsilon()¶

esys.downunder.forwardmodels.gravity.getMPIRankWorld() → int :¶: Return the rank of this process in the MPI World.

esys.downunder.forwardmodels.gravity.getMPIWorldMax((object)arg1) → int :¶

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

Return type: int

esys.downunder.forwardmodels.gravity.getMaxFloat()¶

esys.downunder.forwardmodels.gravity.getNumpy(**data)¶

Writes Data objects to a numpy array.

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

Example usage:

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.getVersion() → int :¶: This method will only report accurate version numbers for clean checkouts.

esys.downunder.forwardmodels.gravity.gmshGeo2Msh(geoFile, mshFile, numDim, order=1, verbosity=0)¶: Runs gmsh to mesh input geoFile. Returns 0 on success.

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.grad_n(arg, n, where=None)¶

esys.downunder.forwardmodels.gravity.hasFeature((str)name) → bool :¶

Check if escript was compiled with a certain feature

Parameters: name (string) – feature to lookup

esys.downunder.forwardmodels.gravity.hermitian(arg)¶

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

Parameters: arg (numpy.ndarray, escript.Data, Symbol) – input matrix. Must have rank 2 or 4 and be square.
Returns: hermitian part of arg
Return type: numpy.ndarray, escript.Data, Symbol depending on the input

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.inner(arg0, arg1)¶

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

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

where s runs through arg0.Shape.

arg0 and arg1 must have the same shape.

Parameters

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

Returns

the inner product of arg0 and arg1 at each data point

Return type

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

Raises

ValueError – if the shapes of the arguments are not identical

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.interpolateTable(tab, dat, start, step, undef=1e+50, check_boundaries=False)¶

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.listEscriptParams() → list :¶

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.makeTagMap(fs)¶: Produce an expanded Data over the function space where the value is the tag associated with the sample

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.matrix_mult(arg0, arg1)¶

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

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

or

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

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

Parameters

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

Returns

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

Return type

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

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.downunder.forwardmodels.gravity.matrix_transposed_mult(arg0, arg1)¶

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

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

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

The last dimensions of arg0 and arg1 must match.

Parameters

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

Returns

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

Return type

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

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.downunder.forwardmodels.gravity.matrixmult(arg0, arg1)¶: See matrix_mult.

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.negative(arg)¶: returns the negative part of arg

esys.downunder.forwardmodels.gravity.nonsymmetric(arg)¶: Deprecated alias for antisymmetric

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.phase(arg)¶: return the “phase”/”arg”/”angle” of a number

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.polarToCart(r, phase)¶

conversion from cartesian to polar coordinates

Parameters

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

Returns

cartesian representation as complex number

Return type

appropriate complex

esys.downunder.forwardmodels.gravity.positive(arg)¶: returns the positive part of arg

esys.downunder.forwardmodels.gravity.printParallelThreadCounts() → None¶

esys.downunder.forwardmodels.gravity.reorderComponents(arg, index)¶: Resorts the components of arg according to index.

esys.downunder.forwardmodels.gravity.resolve(arg)¶: Returns the value of arg resolved.

esys.downunder.forwardmodels.gravity.safeDiv(arg0, arg1, rtol=None)¶: returns arg0/arg1 but return 0 where arg1 is (almost) zero

esys.downunder.forwardmodels.gravity.saveDataCSV(filename, append=False, refid=False, sep=', ', csep='_', **data)¶

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

Parameters

filename (string) – file to save data to.
append (bool) – If True, then open file at end rather than beginning
refid (bool) – If True, then a list of reference ids will be printed in the first column
sep (string) – separator between fields
csep – separator for components of rank 2 and above (e.g. ‘_’ -> c0_1)

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

s=Scalar(..)
v=Vector(..)
t=Tensor(..)
f=float()
saveDataCSV("f.csv", a=s, b=v, c=t, d=f)

Will result in a file

a, b0, b1, c0_0, c0_1, .., c1_1, d 1.0, 1.5, 2.7, 3.1, 3.4, .., 0.89, 0.0 0.9, 8.7, 1.9, 3.4, 7.8, .., 1.21, 0.0

The first line is a header, the remaining lines give the values.

esys.downunder.forwardmodels.gravity.saveESD(datasetName, dataDir='.', domain=None, timeStep=0, deltaT=1, dynamicMesh=0, timeStepFormat='%04d', **data)¶

Saves Data objects to files and creates an escript dataset (ESD) file for convenient processing/visualisation.

Single timestep example:

tmp = Scalar(..)
v = Vector(..)
saveESD("solution", "data", temperature=tmp, velocity=v)

Time series example:

while t < t_end:
    tmp = Scalar(..)
    v = Vector(..)
    # save every 10 timesteps
    if t % 10 == 0:
        saveESD("solution", "data", timeStep=t, deltaT=10, temperature=tmp, velocity=v)
    t = t + 1

tmp, v and the domain are saved in native format in the “data” directory and the file “solution.esd” is created that refers to tmp by the name “temperature” and to v by the name “velocity”.

Parameters

datasetName (str) – name of the dataset, used to name the ESD file
dataDir (str) – optional directory where the data files should be saved
domain (escript.Domain) – domain of the Data object(s). If not specified, the domain of the given Data objects is used.
timeStep (int) – current timestep or sequence number - first one must be 0
deltaT (int) – timestep or sequence increment, see example above
dynamicMesh (int) – by default the mesh is assumed to be static and thus only saved once at timestep 0 to save disk space. Setting this to 1 changes the behaviour and the mesh is saved at each timestep.
timeStepFormat (str) – timestep format string (defaults to “%04d”)
<name> (Data object) – writes the assigned value to the file using <name> as identifier

Note

The ESD concept is experimental and the file format likely to change so use this function with caution.

Note

The data objects have to be defined on the same domain (but not necessarily on the same FunctionSpace).

Note

When saving a time series the first timestep must be 0 and it is assumed that data from all timesteps share the domain. The dataset file is updated in each iteration.

esys.downunder.forwardmodels.gravity.showEscriptParams()¶: Displays the parameters escript recognises with an explanation and their current value.

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.tensor_mult(arg0, arg1)¶

The tensor product of the two arguments.

For arg0 of rank 2 this is

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

or

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

and for arg0 of rank 4 this is

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

or

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

or

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

In the first case the second dimension of arg0 and the last dimension of arg1 must match and in the second case the two last dimensions of arg0 must match the two first dimensions of arg1.

Parameters

arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4
arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater than 1 or 2 depending on the rank of arg0

Returns

the tensor product of arg0 and arg1 at each data point

Return type

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

esys.downunder.forwardmodels.gravity.tensor_transposed_mult(arg0, arg1)¶

The tensor product of the first and the transpose of the second argument.

For arg0 of rank 2 this is

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

and for arg0 of rank 4 this is

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

or

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

In the first case the second dimension of arg0 and arg1 must match and in the second case the two last dimensions of arg0 must match the two last dimensions of arg1.

The function call tensor_transpose_mult(arg0,arg1) is equivalent to tensor_mult(arg0,transpose(arg1)).

Parameters

arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4
arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater of 1 or 2 depending on rank of arg0

Returns

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

Return type

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

esys.downunder.forwardmodels.gravity.tensormult(arg0, arg1)¶: See tensor_mult.

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.transposed_matrix_mult(arg0, arg1)¶

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

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

or

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

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

The first dimension of arg0 and arg1 must match.

Parameters

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

Returns

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

Return type

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

Raises

ValueError – if the shapes of the arguments are not appropriate

esys.downunder.forwardmodels.gravity.transposed_tensor_mult(arg0, arg1)¶

The tensor product of the transpose of the first and the second argument.

For arg0 of rank 2 this is

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

or

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

and for arg0 of rank 4 this is

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

or

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

or

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

In the first case the first dimension of arg0 and the first dimension of arg1 must match and in the second case the two first dimensions of arg0 must match the two first dimensions of arg1.

The function call transposed_tensor_mult(arg0,arg1) is equivalent to tensor_mult(transpose(arg0),arg1).

Parameters

arg0 (numpy.ndarray, escript.Data, Symbol) – first argument of rank 2 or 4
arg1 (numpy.ndarray, escript.Data, Symbol) – second argument of shape greater of 1 or 2 depending on the rank of arg0

Returns

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

Return type

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

esys.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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.downunder.forwardmodels.gravity.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
PI

esys.downunder.forwardmodels.gravity Package¶

Classes¶

Functions¶

Others¶

Packages¶

Table of Contents