# esys.downunder.forwardmodels.gravity Package

Forward model for gravity (Bouguer) anomaly

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

  Bases: `esys.downunder.forwardmodels.base.ForwardModelWithPotential`

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

  `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`

  `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`

  `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`

  `getDefectGradient`(result)
  `getDomain`()

    Returns the domain of the forward model.

    Return type: | `Domain`

  `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`

  `getMisfitWeights`()

    Returns the weights of the misfit function

    Return type: | `list` of `Data`

  `getPDE`()

    Return the underlying PDE.

    Return type: | `LinearPDE`

  `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`

  `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.

  `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.

## Classes

- `Data`
- `FileWriter`
- `ForwardModelWithPotential`
- `GravityModel`

class `esys.downunder.forwardmodels.gravity.``Data`

  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.

  `__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, (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

  `hasNaN`((Data)arg1) → bool :

    Returns return true if data contains NaN.

  `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, (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

  `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, (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

  `phase`((Data)arg1) → Data
  `promote`((Data)arg1) → None
  `real`((Data)arg1) → Data
  `replaceNaN`((Data)arg1, (object)value) → None :

    Replaces NaN values with value

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

  `__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)

  Bases: `esys.downunder.forwardmodels.base.ForwardModel`

  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

  `getArguments`(x)
  `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`

  `getDefect`(x, *args)
  `getDefectGradient`(result)
  `getDomain`()

    Returns the domain of the forward model.

    Return type: | `Domain`

  `getGradient`(x, *args)
  `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)

  Bases: `esys.downunder.forwardmodels.base.ForwardModelWithPotential`

  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`

  `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`

  `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`

  `getDefectGradient`(result)
  `getDomain`()

    Returns the domain of the forward model.

    Return type: | `Domain`

  `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`

  `getMisfitWeights`()

    Returns the weights of the misfit function

    Return type: | `list` of `Data`

  `getPDE`()

    Return the underlying PDE.

    Return type: | `LinearPDE`

  `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`

  `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.

  `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[, (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.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.``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.``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`((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.downunder.forwardmodels.gravity.``getMaxFloat`()

`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.``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.``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, 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.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
- __all__
- __builtins__
- __copyright__
- __doc__
- __file__
- __license__
- __name__
- __package__
- __url__
- division
- print_function