esys.downunder.forwardmodels.dcresistivity Package¶
Forward model for DC Resistivity
Classes¶
-
class
esys.downunder.forwardmodels.dcresistivity.
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 inmask
will be copied fromother
Parameters:
-
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
- procNo (positive
-
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, (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 tableparam 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 ofDataConstant
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¶
-
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, (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
orlist
-
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
orlist
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.dcresistivity.
DcRes
(domain, locator, delphiIn, sampleTags, phiPrimary, sigmaPrimary, w=1.0, coordinates=None, tol=1e-08, saveMemory=True, b=None)¶ Bases:
esys.downunder.forwardmodels.base.ForwardModel
Forward Model for DC resistivity, with a given source pair. The cost function is defined as:
Math: defect = 1/2 (sum_s sum_pq w_pqs * ((phi_sp-phi_sq)-v_pqs)**2 -
__init__
(domain, locator, delphiIn, sampleTags, phiPrimary, sigmaPrimary, w=1.0, coordinates=None, tol=1e-08, saveMemory=True, b=None)¶ setup new forward model
Parameters: - domain – the domain of the model
- locator – contains locator to the measurement pairs
- sampleTags (list of tuples) – tags of measurement points from which potential differences will be calculated.
- phiPrimary (
Scalar
) – primary potential.
Type: escript domain
Type: list
ofLocator
Param: delphiIn: this is v_pq, the potential difference for the current source and a set of measurement pairs. A list of measured potential differences is expected. Note this should be the secondary potential only.
-
getArguments
(sigma)¶ Returns precomputed values shared by
getDefect()
andgetGradient()
.Parameters: sigma ( Data
of shape (1,)) – conductivityReturns: phi Return type: Data
of shape (1,)
-
getCoordinateTransformation
()¶ returns the coordinate transformation being used
Return type: CoordinateTransformation
-
getDefect
(sigma, phi, loc_phi)¶ Returns the defect value.
Parameters: - sigma (
Data
of shape (1,)) – a suggestion for conductivity - phi (
Data
of shape (1,)) – potential field
Return type: float
- sigma (
-
getDomain
()¶ Returns the domain of the forward model.
Return type: Domain
-
getGradient
(sigma, phi, loc_phi)¶ Returns the gradient of the defect with respect to density.
Parameters: - sigma (
Data
of shape (1,)) – a suggestison for conductivity - phi (
Data
of shape (1,)) – potential field
- sigma (
-
-
class
esys.downunder.forwardmodels.dcresistivity.
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 useFileWriter
rather thanopen
in order to write code that is running with as well as with MPI. It is safe to useopen
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. IfcreateLocalFiles
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.
- fn (
-
close
()¶ Closes the file
-
flush
()¶ Flush the internal I/O buffer.
-
write
(txt)¶ Write string
txt
to file.Parameters: txt ( str
) – stringtxt
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.dcresistivity.
ForwardModel
¶ Bases:
object
An abstract forward model that can be plugged into a cost function. Subclasses need to implement
getDefect()
,getGradient()
, and possiblygetArguments()
and ‘getCoordinateTransformation’.-
__init__
()¶ Initialize self. See help(type(self)) for accurate signature.
-
getArguments
(x)¶
-
getCoordinateTransformation
()¶
-
getDefect
(x, *args)¶
-
getGradient
(x, *args)¶
-
-
class
esys.downunder.forwardmodels.dcresistivity.
LinearPDE
(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)¶ Bases:
esys.escriptcore.linearPDEs.LinearProblem
This class is used to define a general linear, steady, second order PDE for an unknown function u on a given domain defined through a
Domain
object.For a single PDE having a solution with a single component the linear PDE is defined in the following form:
-(grad(A[j,l]+A_reduced[j,l])*grad(u)[l]+(B[j]+B_reduced[j])u)[j]+(C[l]+C_reduced[l])*grad(u)[l]+(D+D_reduced)=-grad(X+X_reduced)[j,j]+(Y+Y_reduced)
where grad(F) denotes the spatial derivative of F. Einstein’s summation convention, ie. summation over indexes appearing twice in a term of a sum performed, is used. The coefficients A, B, C, D, X and Y have to be specified through
Data
objects inFunction
and the coefficients A_reduced, B_reduced, C_reduced, D_reduced, X_reduced and Y_reduced have to be specified throughData
objects inReducedFunction
. It is also allowed to use objects that can be converted into suchData
objects. A and A_reduced are rank two, B, C, X, B_reduced, C_reduced and X_reduced are rank one and D, D_reduced, Y and Y_reduced are scalar.The following natural boundary conditions are considered:
n[j]*((A[i,j]+A_reduced[i,j])*grad(u)[l]+(B+B_reduced)[j]*u)+(d+d_reduced)*u=n[j]*(X[j]+X_reduced[j])+y
where n is the outer normal field. Notice that the coefficients A, A_reduced, B, B_reduced, X and X_reduced are defined in the PDE. The coefficients d and y are each a scalar in
FunctionOnBoundary
and the coefficients d_reduced and y_reduced are each a scalar inReducedFunctionOnBoundary
.Constraints for the solution prescribe the value of the solution at certain locations in the domain. They have the form
u=r where q>0
r and q are each scalar where q is the characteristic function defining where the constraint is applied. The constraints override any other condition set by the PDE or the boundary condition.
The PDE is symmetrical if
A[i,j]=A[j,i] and B[j]=C[j] and A_reduced[i,j]=A_reduced[j,i] and B_reduced[j]=C_reduced[j]
For a system of PDEs and a solution with several components the PDE has the form
-grad((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])[j]+(C[i,k,l]+C_reduced[i,k,l])*grad(u[k])[l]+(D[i,k]+D_reduced[i,k]*u[k] =-grad(X[i,j]+X_reduced[i,j])[j]+Y[i]+Y_reduced[i]
A and A_reduced are of rank four, B, B_reduced, C and C_reduced are each of rank three, D, D_reduced, X_reduced and X are each of rank two and Y and Y_reduced are of rank one. The natural boundary conditions take the form:
n[j]*((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])+(d[i,k]+d_reduced[i,k])*u[k]=n[j]*(X[i,j]+X_reduced[i,j])+y[i]+y_reduced[i]
The coefficient d is of rank two and y is of rank one both in
FunctionOnBoundary
. The coefficients d_reduced is of rank two and y_reduced is of rank one both inReducedFunctionOnBoundary
.Constraints take the form
u[i]=r[i] where q[i]>0
r and q are each rank one. Notice that at some locations not necessarily all components must have a constraint.
The system of PDEs is symmetrical if
- A[i,j,k,l]=A[k,l,i,j]
- A_reduced[i,j,k,l]=A_reduced[k,l,i,j]
- B[i,j,k]=C[k,i,j]
- B_reduced[i,j,k]=C_reduced[k,i,j]
- D[i,k]=D[i,k]
- D_reduced[i,k]=D_reduced[i,k]
- d[i,k]=d[k,i]
- d_reduced[i,k]=d_reduced[k,i]
LinearPDE
also supports solution discontinuities over a contact region in the domain. To specify the conditions across the discontinuity we are using the generalised flux J which, in the case of a system of PDEs and several components of the solution, is defined asJ[i,j]=(A[i,j,k,l]+A_reduced[[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k]-X[i,j]-X_reduced[i,j]
For the case of single solution component and single PDE J is defined as
J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[j]+(B[i]+B_reduced[i])*u-X[i]-X_reduced[i]
In the context of discontinuities n denotes the normal on the discontinuity pointing from side 0 towards side 1 calculated from
FunctionSpace.getNormal
ofFunctionOnContactZero
. For a system of PDEs the contact condition takes the formn[j]*J0[i,j]=n[j]*J1[i,j]=(y_contact[i]+y_contact_reduced[i])- (d_contact[i,k]+d_contact_reduced[i,k])*jump(u)[k]
where J0 and J1 are the fluxes on side 0 and side 1 of the discontinuity, respectively. jump(u), which is the difference of the solution at side 1 and at side 0, denotes the jump of u across discontinuity along the normal calculated by
jump
. The coefficient d_contact is of rank two and y_contact is of rank one both inFunctionOnContactZero
orFunctionOnContactOne
. The coefficient d_contact_reduced is of rank two and y_contact_reduced is of rank one both inReducedFunctionOnContactZero
orReducedFunctionOnContactOne
. In case of a single PDE and a single component solution the contact condition takes the formn[j]*J0_{j}=n[j]*J1_{j}=(y_contact+y_contact_reduced)-(d_contact+y_contact_reduced)*jump(u)
In this case the coefficient d_contact and y_contact are each scalar both in
FunctionOnContactZero
orFunctionOnContactOne
and the coefficient d_contact_reduced and y_contact_reduced are each scalar both inReducedFunctionOnContactZero
orReducedFunctionOnContactOne
.Typical usage:
p = LinearPDE(dom) p.setValue(A=kronecker(dom), D=1, Y=0.5) u = p.getSolution()
-
__init__
(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)¶ Initializes a new linear PDE.
Parameters: - domain (
Domain
) – domain of the PDE - numEquations – number of equations. If
None
the number of equations is extracted from the PDE coefficients. - numSolutions – number of solution components. If
None
the number of solution components is extracted from the PDE coefficients. - debug – if True debug information is printed
- domain (
-
addPDEToLumpedSystem
(operator, a, b, c, hrz_lumping)¶ adds a PDE to the lumped system, results depend on domain
Parameters:
-
addPDEToRHS
(righthandside, X, Y, y, y_contact, y_dirac)¶ adds a PDE to the right hand side, results depend on domain
Parameters:
-
addPDEToSystem
(operator, righthandside, A, B, C, D, X, Y, d, y, d_contact, y_contact, d_dirac, y_dirac)¶ adds a PDE to the system, results depend on domain
Parameters:
-
addToRHS
(rhs, data)¶ adds a PDE to the right hand side, results depend on domain
Parameters: - mat (
OperatorAdapter
) – - righthandside (
Data
) – - data (
list
) –
- mat (
-
addToSystem
(op, rhs, data)¶ adds a PDE to the system, results depend on domain
Parameters: - mat (
OperatorAdapter
) – - rhs (
Data
) – - data (
list
) –
- mat (
-
alteredCoefficient
(name)¶ Announces that coefficient
name
has been changed.Parameters: name ( string
) – name of the coefficient affectedRaises: IllegalCoefficient – if name
is not a coefficient of the PDENote: if name
is q or r, the method will not trigger a rebuild of the system as constraints are applied to the solved system.
-
checkReciprocalSymmetry
(name0, name1, verbose=True)¶ Tests two coefficients for reciprocal symmetry.
Parameters: - name0 (
str
) – name of the first coefficient - name1 (
str
) – name of the second coefficient - verbose (
bool
) – if set to True or not present a report on coefficients which break the symmetry is printed
Returns: True if coefficients
name0
andname1
are reciprocally symmetric.Return type: bool
- name0 (
-
checkSymmetricTensor
(name, verbose=True)¶ Tests a coefficient for symmetry.
Parameters: - name (
str
) – name of the coefficient - verbose (
bool
) – if set to True or not present a report on coefficients which break the symmetry is printed.
Returns: True if coefficient
name
is symmetricReturn type: bool
- name (
-
checkSymmetry
(verbose=True)¶ Tests the PDE for symmetry.
Parameters: verbose ( bool
) – if set to True or not present a report on coefficients which break the symmetry is printed.Returns: True if the PDE is symmetric Return type: bool
Note: This is a very expensive operation. It should be used for degugging only! The symmetry flag is not altered.
-
createCoefficient
(name)¶ Creates a
Data
object corresponding to coefficientname
.Returns: the coefficient name
initialized to 0Return type: Data
Raises: IllegalCoefficient – if name
is not a coefficient of the PDE
-
createOperator
()¶ Returns an instance of a new operator.
-
createRightHandSide
()¶ Returns an instance of a new right hand side.
-
createSolution
()¶ Returns an instance of a new solution.
-
getCoefficient
(name)¶ Returns the value of the coefficient
name
.Parameters: name ( string
) – name of the coefficient requestedReturns: the value of the coefficient Return type: Data
Raises: IllegalCoefficient – if name
is not a coefficient of the PDE
-
getCurrentOperator
()¶ Returns the operator in its current state.
-
getCurrentRightHandSide
()¶ Returns the right hand side in its current state.
-
getCurrentSolution
()¶ Returns the solution in its current state.
-
getDim
()¶ Returns the spatial dimension of the PDE.
Returns: the spatial dimension of the PDE domain Return type: int
-
getDomain
()¶ Returns the domain of the PDE.
Returns: the domain of the PDE Return type: Domain
-
getDomainStatus
()¶ Return the status indicator of the domain
-
getFlux
(u=None)¶ Returns the flux J for a given u.
J[i,j]=(A[i,j,k,l]+A_reduced[A[i,j,k,l]]*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])u[k]-X[i,j]-X_reduced[i,j]
or
J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[l]+(B[j]+B_reduced[j])u-X[j]-X_reduced[j]
Parameters: u ( Data
or None) – argument in the flux. If u is not present or equalsNone
the current solution is used.Returns: flux Return type: Data
-
getFunctionSpaceForCoefficient
(name)¶ Returns the
FunctionSpace
to be used for coefficientname
.Parameters: name ( string
) – name of the coefficient enquiredReturns: the function space to be used for coefficient name
Return type: FunctionSpace
Raises: IllegalCoefficient – if name
is not a coefficient of the PDE
-
getFunctionSpaceForEquation
()¶ Returns the
FunctionSpace
used to discretize the equation.Returns: representation space of equation Return type: FunctionSpace
-
getFunctionSpaceForSolution
()¶ Returns the
FunctionSpace
used to represent the solution.Returns: representation space of solution Return type: FunctionSpace
-
getNumEquations
()¶ Returns the number of equations.
Returns: the number of equations Return type: int
Raises: UndefinedPDEError – if the number of equations is not specified yet
-
getNumSolutions
()¶ Returns the number of unknowns.
Returns: the number of unknowns Return type: int
Raises: UndefinedPDEError – if the number of unknowns is not specified yet
-
getOperator
()¶ Returns the operator of the linear problem.
Returns: the operator of the problem
-
getOperatorType
()¶ Returns the current system type.
-
getRequiredOperatorType
()¶ Returns the system type which needs to be used by the current set up.
-
getResidual
(u=None)¶ Returns the residual of u or the current solution if u is not present.
Parameters: u ( Data
or None) – argument in the residual calculation. It must be representable inself.getFunctionSpaceForSolution()
. If u is not present or equalsNone
the current solution is used.Returns: residual of u Return type: Data
-
getRightHandSide
()¶ Returns the right hand side of the linear problem.
Returns: the right hand side of the problem Return type: Data
-
getShapeOfCoefficient
(name)¶ Returns the shape of the coefficient
name
.Parameters: name ( string
) – name of the coefficient enquiredReturns: the shape of the coefficient name
Return type: tuple
ofint
Raises: IllegalCoefficient – if name
is not a coefficient of the PDE
-
getSolverOptions
()¶ Returns the solver options
Return type: SolverOptions
-
getSystem
()¶ Returns the operator and right hand side of the PDE.
Returns: the discrete version of the PDE Return type: tuple
ofOperator
andData
-
getSystemStatus
()¶ Return the domain status used to build the current system
-
hasCoefficient
(name)¶ Returns True if
name
is the name of a coefficient.Parameters: name ( string
) – name of the coefficient enquiredReturns: True if name
is the name of a coefficient of the general PDE, False otherwiseReturn type: bool
-
initializeSystem
()¶ Resets the system clearing the operator, right hand side and solution.
-
insertConstraint
(rhs_only=False)¶ Applies the constraints defined by q and r to the PDE.
Parameters: rhs_only ( bool
) – if True only the right hand side is altered by the constraint
-
introduceCoefficients
(**coeff)¶ Introduces new coefficients into the problem.
Use:
p.introduceCoefficients(A=PDECoef(…), B=PDECoef(…))
to introduce the coefficients A and B.
-
invalidateOperator
()¶ Indicates the operator has to be rebuilt next time it is used.
-
invalidateRightHandSide
()¶ Indicates the right hand side has to be rebuilt next time it is used.
-
invalidateSolution
()¶ Indicates the PDE has to be resolved if the solution is requested.
-
invalidateSystem
()¶ Announces that everything has to be rebuilt.
-
isComplex
()¶ Returns true if this is a complex-valued LinearProblem, false if real-valued.
Return type: bool
-
isHermitian
()¶ Checks if the pde is indicated to be Hermitian.
Returns: True if a Hermitian PDE is indicated, False otherwise Return type: bool
Note: the method is equivalent to use getSolverOptions().isHermitian()
-
isOperatorValid
()¶ Returns True if the operator is still valid.
-
isRightHandSideValid
()¶ Returns True if the operator is still valid.
-
isSolutionValid
()¶ Returns True if the solution is still valid.
-
isSymmetric
()¶ Checks if symmetry is indicated.
Returns: True if a symmetric PDE is indicated, False otherwise Return type: bool
Note: the method is equivalent to use getSolverOptions().isSymmetric()
-
isSystemValid
()¶ Returns True if the system (including solution) is still vaild.
-
isUsingLumping
()¶ Checks if matrix lumping is the current solver method.
Returns: True if the current solver method is lumping Return type: bool
-
preservePreconditioner
(preserve=True)¶ Notifies the PDE that the preconditioner should not be reset when making changes to the operator.
Building the preconditioner data can be quite expensive (e.g. for multigrid methods) so if it is known that changes to the operator are going to be minor calling this method can speed up successive PDE solves.
Note: Not all operator types support this. Parameters: preserve ( bool
) – if True, preconditioner will be preserved, otherwise it will be reset when making changes to the operator, which is the default behaviour.
-
reduceEquationOrder
()¶ Returns the status of order reduction for the equation.
Returns: True if reduced interpolation order is used for the representation of the equation, False otherwise Return type: bool
-
reduceSolutionOrder
()¶ Returns the status of order reduction for the solution.
Returns: True if reduced interpolation order is used for the representation of the solution, False otherwise Return type: bool
-
resetAllCoefficients
()¶ Resets all coefficients to their default values.
-
resetOperator
()¶ Makes sure that the operator is instantiated and returns it initialized with zeros.
-
resetRightHandSide
()¶ Sets the right hand side to zero.
-
resetRightHandSideCoefficients
()¶ Resets all coefficients defining the right hand side
-
resetSolution
()¶ Sets the solution to zero.
-
setDebug
(flag)¶ Switches debug output on if
flag
is True otherwise it is switched off.Parameters: flag ( bool
) – desired debug status
-
setDebugOff
()¶ Switches debug output off.
-
setDebugOn
()¶ Switches debug output on.
-
setHermitian
(flag=False)¶ Sets the Hermitian flag to
flag
.Parameters: flag ( bool
) – If True, the Hermitian flag is set otherwise reset.Note: The method overwrites the Hermitian flag set by the solver options
-
setHermitianOff
()¶ Clears the Hermitian flag. :note: The method overwrites the Hermitian flag set by the solver options
-
setHermitianOn
()¶ Sets the Hermitian flag. :note: The method overwrites the Hermitian flag set by the solver options
-
setReducedOrderForEquationOff
()¶ Switches reduced order off for equation representation.
Raises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderForEquationOn
()¶ Switches reduced order on for equation representation.
Raises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderForEquationTo
(flag=False)¶ Sets order reduction state for equation representation according to flag.
Parameters: flag ( bool
) – if flag is True, the order reduction is switched on for equation representation, otherwise or if flag is not present order reduction is switched offRaises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderForSolutionOff
()¶ Switches reduced order off for solution representation
Raises: RuntimeError – if order reduction is altered after a coefficient has been set.
-
setReducedOrderForSolutionOn
()¶ Switches reduced order on for solution representation.
Raises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderForSolutionTo
(flag=False)¶ Sets order reduction state for solution representation according to flag.
Parameters: flag ( bool
) – if flag is True, the order reduction is switched on for solution representation, otherwise or if flag is not present order reduction is switched offRaises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderOff
()¶ Switches reduced order off for solution and equation representation
Raises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderOn
()¶ Switches reduced order on for solution and equation representation.
Raises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setReducedOrderTo
(flag=False)¶ Sets order reduction state for both solution and equation representation according to flag.
Parameters: flag ( bool
) – if True, the order reduction is switched on for both solution and equation representation, otherwise or if flag is not present order reduction is switched offRaises: RuntimeError – if order reduction is altered after a coefficient has been set
-
setSolution
(u, validate=True)¶ Sets the solution assuming that makes the system valid with the tolrance defined by the solver options
-
setSolverOptions
(options=None)¶ Sets the solver options.
Parameters: options ( SolverOptions
orNone
) – the new solver options. If equalNone
, the solver options are set to the default.Note: The symmetry flag of options is overwritten by the symmetry flag of the LinearProblem
.
-
setSymmetry
(flag=False)¶ Sets the symmetry flag to
flag
.Parameters: flag ( bool
) – If True, the symmetry flag is set otherwise reset.Note: The method overwrites the symmetry flag set by the solver options
-
setSymmetryOff
()¶ Clears the symmetry flag. :note: The method overwrites the symmetry flag set by the solver options
-
setSymmetryOn
()¶ Sets the symmetry flag. :note: The method overwrites the symmetry flag set by the solver options
-
setSystemStatus
(status=None)¶ Sets the system status to
status
ifstatus
is not present the current status of the domain is used.
-
setValue
(**coefficients)¶ Sets new values to coefficients.
Parameters: - coefficients – new values assigned to coefficients
- A (any type that can be cast to a
Data
object onFunction
) – value for coefficientA
- A_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientA_reduced
- B (any type that can be cast to a
Data
object onFunction
) – value for coefficientB
- B_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientB_reduced
- C (any type that can be cast to a
Data
object onFunction
) – value for coefficientC
- C_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientC_reduced
- D (any type that can be cast to a
Data
object onFunction
) – value for coefficientD
- D_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientD_reduced
- X (any type that can be cast to a
Data
object onFunction
) – value for coefficientX
- X_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientX_reduced
- Y (any type that can be cast to a
Data
object onFunction
) – value for coefficientY
- Y_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientY_reduced
- d (any type that can be cast to a
Data
object onFunctionOnBoundary
) – value for coefficientd
- d_reduced (any type that can be cast to a
Data
object onReducedFunctionOnBoundary
) – value for coefficientd_reduced
- y (any type that can be cast to a
Data
object onFunctionOnBoundary
) – value for coefficienty
- d_contact (any type that can be cast to a
Data
object onFunctionOnContactOne
orFunctionOnContactZero
) – value for coefficientd_contact
- d_contact_reduced (any type that can be cast to a
Data
object onReducedFunctionOnContactOne
orReducedFunctionOnContactZero
) – value for coefficientd_contact_reduced
- y_contact (any type that can be cast to a
Data
object onFunctionOnContactOne
orFunctionOnContactZero
) – value for coefficienty_contact
- y_contact_reduced (any type that can be cast to a
Data
object onReducedFunctionOnContactOne
orReducedFunctionOnContactZero
) – value for coefficienty_contact_reduced
- d_dirac (any type that can be cast to a
Data
object onDiracDeltaFunctions
) – value for coefficientd_dirac
- y_dirac (any type that can be cast to a
Data
object onDiracDeltaFunctions
) – value for coefficienty_dirac
- r (any type that can be cast to a
Data
object onSolution
orReducedSolution
depending on whether reduced order is used for the solution) – values prescribed to the solution at the locations of constraints - q (any type that can be cast to a
Data
object onSolution
orReducedSolution
depending on whether reduced order is used for the representation of the equation) – mask for location of constraints
Raises: IllegalCoefficient – if an unknown coefficient keyword is used
-
shouldPreservePreconditioner
()¶ Returns true if the preconditioner / factorisation should be kept even when resetting the operator.
Return type: bool
-
trace
(text)¶ Prints the text message if debug mode is switched on.
Parameters: text ( string
) – message to be printed
-
validOperator
()¶ Marks the operator as valid.
-
validRightHandSide
()¶ Marks the right hand side as valid.
-
validSolution
()¶ Marks the solution as valid.
-
class
esys.downunder.forwardmodels.dcresistivity.
Locator
(where, x=array([0., 0., 0.]))¶ Bases:
object
Locator provides access to the values of data objects at a given spatial coordinate x.
In fact, a Locator object finds the sample in the set of samples of a given function space or domain which is closest to the given point x.
-
__init__
(where, x=array([0., 0., 0.]))¶ Initializes a Locator to access values in Data objects on the Doamin or FunctionSpace for the sample point which is closest to the given point x.
Parameters: - where (
escript.FunctionSpace
) – function space - x (
numpy.ndarray
orlist
ofnumpy.ndarray
) – location(s) of the Locator
- where (
-
getFunctionSpace
()¶ Returns the function space of the Locator.
-
getId
(item=None)¶ Returns the identifier of the location.
-
getValue
(data)¶ Returns the value of
data
at the Locator ifdata
is aData
object otherwise the object is returned.
-
getX
()¶ Returns the exact coordinates of the Locator.
-
setValue
(data, v)¶ Sets the value of the
data
at the Locator.
-
Functions¶
-
esys.downunder.forwardmodels.dcresistivity.
Abs
(arg)¶ Returns the absolute value of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
C_GeneralTensorProduct
((Data)arg0, (Data)arg1[, (int)axis_offset=0[, (int)transpose=0]]) → Data :¶ Compute a tensor product of two Data objects.
Return type: Parameters: - arg0 –
- arg1 –
- axis_offset (
int
) – - transpose (int) – 0: transpose neither, 1: transpose arg0, 2: transpose arg1
-
esys.downunder.forwardmodels.dcresistivity.
DiracDeltaFunctions
((Domain)domain) → FunctionSpace :¶ Return type: FunctionSpace
-
esys.downunder.forwardmodels.dcresistivity.
L2
(arg)¶ Returns the L2 norm of
arg
atwhere
.Parameters: arg ( escript.Data
orSymbol
) – function of which the L2 norm is to be calculatedReturns: L2 norm of arg
Return type: float
orSymbol
Note: L2(arg) is equivalent to sqrt(integrate(inner(arg,arg)))
-
esys.downunder.forwardmodels.dcresistivity.
Lsup
(arg)¶ Returns the Lsup-norm of argument
arg
. This is the maximum absolute value over all data points. This function is equivalent tosup(abs(arg))
.Parameters: arg ( float
,int
,escript.Data
,numpy.ndarray
) – argumentReturns: maximum value of the absolute value of arg
over all components and all data pointsReturn type: float
Raises: TypeError – if type of arg
cannot be processed
-
esys.downunder.forwardmodels.dcresistivity.
NumpyToData
(array, isComplex, functionspace)¶ Uses a numpy ndarray to create a
Data
objectExample usage: NewDataObject = NumpyToData(ndarray, isComplex, FunctionSpace)
-
esys.downunder.forwardmodels.dcresistivity.
Scalar
([(object)value=0.0[, (FunctionSpace)what=<esys.escriptcore.escriptcpp.FunctionSpace object at 0x7fa05352ad50>[, (bool)expanded=False]]]) → Data :¶ Construct a Data object containing scalar data-points.
Parameters: - value (float) – scalar value for all points
- what (
FunctionSpace
) – FunctionSpace for Data - expanded (
bool
) – If True, a value is stored for each point. If False, more efficient representations may be used
Return type:
-
esys.downunder.forwardmodels.dcresistivity.
acos
(arg)¶ Returns the inverse cosine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
acosh
(arg)¶ Returns the inverse hyperbolic cosine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
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.dcresistivity.
asin
(arg)¶ Returns the inverse sine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
asinh
(arg)¶ Returns the inverse hyperbolic sine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
atan
(arg)¶ Returns inverse tangent of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
atan2
(arg0, arg1)¶ Returns inverse tangent of argument
arg0
overarg1
-
esys.downunder.forwardmodels.dcresistivity.
atanh
(arg)¶ Returns the inverse hyperbolic tangent of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
boundingBox
(domain)¶ Returns the bounding box of a domain
Parameters: domain ( escript.Domain
) – a domainReturns: bounding box of the domain Return type: list
of pairs offloat
-
esys.downunder.forwardmodels.dcresistivity.
boundingBoxEdgeLengths
(domain)¶ Returns the edge lengths of the bounding box of a domain
Parameters: domain ( escript.Domain
) – a domainReturn type: list
offloat
-
esys.downunder.forwardmodels.dcresistivity.
clip
(arg, minval=None, maxval=None)¶ Cuts the values of
arg
betweenminval
andmaxval
.Parameters: - arg (
numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
) – argument - minval (
float
orNone
) – lower range. If None no lower range is applied - maxval (
float
orNone
) – upper range. If None no upper range is applied
Returns: an object that contains all values from
arg
betweenminval
andmaxval
Return type: numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
depending on the inputRaises: ValueError – if
minval>maxval
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
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 dimensionNone
is returned.Return type: int
orNone
Raises: ValueError – if the objects with identifiable dimension don’t have the same spatial dimension.
-
esys.downunder.forwardmodels.dcresistivity.
commonShape
(arg0, arg1)¶ Returns a shape to which
arg0
can be extended from the right andarg1
can be extended from the left.Parameters: Returns: the shape of
arg0
orarg1
such that the left part equals the shape ofarg0
and the right end equals the shape ofarg1
Return type: tuple
ofint
Raises: ValueError – if no shape can be found
-
esys.downunder.forwardmodels.dcresistivity.
condEval
(f, tval, fval)¶ Wrapper to allow non-data objects to be used.
-
esys.downunder.forwardmodels.dcresistivity.
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 namemask
, then only samples which correspond to positive values inmask
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.dcresistivity.
cos
(arg)¶ Returns cosine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
cosh
(arg)¶ Returns the hyperbolic cosine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
delay
(arg)¶ Returns a lazy version of arg
-
esys.downunder.forwardmodels.dcresistivity.
deviatoric
(arg)¶ Returns the deviatoric version of
arg
.
-
esys.downunder.forwardmodels.dcresistivity.
diameter
(domain)¶ Returns the diameter of a domain.
Parameters: domain ( escript.Domain
) – a domainReturn type: float
-
esys.downunder.forwardmodels.dcresistivity.
div
(arg, where=None)¶ Returns the divergence of
arg
atwhere
.Parameters: - arg (
escript.Data
orSymbol
) – function of which the divergence is to be calculated. Its shape has to be (d,) where d is the spatial dimension. - where (
None
orescript.FunctionSpace
) –FunctionSpace
in which the divergence will be calculated. If not present orNone
an appropriate default is used.
Returns: divergence of
arg
Return type: escript.Data
orSymbol
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
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 inputNote: for escript.Data
andSymbol
objects the dimension is restricted to 3.
-
esys.downunder.forwardmodels.dcresistivity.
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
ofescript.Data
Note: The dimension is restricted to 3.
-
esys.downunder.forwardmodels.dcresistivity.
erf
(arg)¶ Returns the error function erf of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
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.dcresistivity.
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.dcresistivity.
escript_inverse
(arg)¶ arg is a Data object!
-
esys.downunder.forwardmodels.dcresistivity.
exp
(arg)¶ Returns e to the power of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type of argRaises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
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:]
- s runs through
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
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
generalTensorTransposedProduct
(arg0, arg1, axis_offset=0)¶ Generalized tensor product of
arg0
and transpose ofarg1
.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:]
- s runs through
The function call
generalTensorTransposedProduct(arg0,arg1,axis_offset)
is equivalent togeneralTensorProduct(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
andtranspose(arg1)
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
generalTransposedTensorProduct
(arg0, arg1, axis_offset=0)¶ Generalized tensor product of transposed of
arg0
andarg1
.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:]
- s runs through
The function call
generalTransposedTensorProduct(arg0,arg1,axis_offset)
is equivalent togeneralTensorProduct(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)
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
getClosestValue
(arg, origin=0)¶ Returns the value in
arg
which is closest to origin.Parameters: - arg (
escript.Data
) – function - origin (
float
orescript.Data
) – reference value
Returns: value in
arg
closest to originReturn type: numpy.ndarray
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
getEpsilon
()¶
-
esys.downunder.forwardmodels.dcresistivity.
getMPIRankWorld
() → int :¶ Return the rank of this process in the MPI World.
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
getMaxFloat
()¶
-
esys.downunder.forwardmodels.dcresistivity.
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 namemask
, then only samples which correspond to positive values inmask
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.dcresistivity.
getRank
(arg)¶ Identifies the rank of the argument.
Parameters: arg ( numpy.ndarray
,escript.Data
,float
,int
,Symbol
) – an object whose rank is to be returnedReturns: the rank of the argument Return type: int
Raises: TypeError – if type of arg
cannot be processed
-
esys.downunder.forwardmodels.dcresistivity.
getShape
(arg)¶ Identifies the shape of the argument.
Parameters: arg ( numpy.ndarray
,escript.Data
,float
,int
,Symbol
) – an object whose shape is to be returnedReturns: the shape of the argument Return type: tuple
ofint
Raises: TypeError – if type of arg
cannot be processed
-
esys.downunder.forwardmodels.dcresistivity.
getTagNames
(domain)¶ Returns a list of tag names used by the domain.
Parameters: domain ( escript.Domain
) – a domain objectReturns: a list of tag names used by the domain Return type: list
ofstr
-
esys.downunder.forwardmodels.dcresistivity.
getVersion
() → int :¶ This method will only report accurate version numbers for clean checkouts.
-
esys.downunder.forwardmodels.dcresistivity.
gmshGeo2Msh
(geoFile, mshFile, numDim, order=1, verbosity=0)¶ Runs gmsh to mesh input
geoFile
. Returns 0 on success.
-
esys.downunder.forwardmodels.dcresistivity.
grad
(arg, where=None)¶ Returns the spatial gradient of
arg
atwhere
.If
g
is the returned object, then- if
arg
is rank 0g[s]
is the derivative ofarg
with respect to thes
-th spatial dimension - if
arg
is rank 1g[i,s]
is the derivative ofarg[i]
with respect to thes
-th spatial dimension - if
arg
is rank 2g[i,j,s]
is the derivative ofarg[i,j]
with respect to thes
-th spatial dimension - if
arg
is rank 3g[i,j,k,s]
is the derivative ofarg[i,j,k]
with respect to thes
-th spatial dimension.
Parameters: - arg (
escript.Data
orSymbol
) – function of which the gradient is to be calculated. Its rank has to be less than 3. - where (
None
orescript.FunctionSpace
) – FunctionSpace in which the gradient is calculated. If not present orNone
an appropriate default is used.
Returns: gradient of
arg
Return type: escript.Data
orSymbol
- if
-
esys.downunder.forwardmodels.dcresistivity.
grad_n
(arg, n, where=None)¶
-
esys.downunder.forwardmodels.dcresistivity.
hasFeature
((str)name) → bool :¶ Check if escript was compiled with a certain feature
Parameters: name ( string
) – feature to lookup
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
identity
(shape=())¶ Returns the
shape
xshape
identity tensor.Parameters: shape ( tuple
ofint
) – input shape for the identity tensorReturns: 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 4Raises: ValueError – if len(shape)>2
-
esys.downunder.forwardmodels.dcresistivity.
identityTensor
(d=3)¶ Returns the
d
xd
identity matrix.Parameters: d ( int
,escript.Domain
orescript.FunctionSpace
) – dimension or an object that has thegetDim
method defining the dimensionReturns: the object u of rank 2 with u[i,j]=1 for i=j and u[i,j]=0 otherwise Return type: numpy.ndarray
orescript.Data
of rank 2
-
esys.downunder.forwardmodels.dcresistivity.
identityTensor4
(d=3)¶ Returns the
d
xd
xd
xd
identity tensor.Parameters: d ( int
or any object with agetDim
method) – dimension or an object that has thegetDim
method defining the dimensionReturns: 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
orescript.Data
of rank 4
-
esys.downunder.forwardmodels.dcresistivity.
inf
(arg)¶ Returns the minimum value over all data points.
Parameters: arg ( float
,int
,escript.Data
,numpy.ndarray
) – argumentReturns: minimum value of arg
over all components and all data pointsReturn type: float
Raises: TypeError – if type of arg
cannot be processed
-
esys.downunder.forwardmodels.dcresistivity.
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
andarg1
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
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
,float
depending on the inputRaises: ValueError – if the shapes of the arguments are not identical
- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
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>
- domain (
-
esys.downunder.forwardmodels.dcresistivity.
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
ornumpy.ndarray
) – value to be used for <tag_name>
Returns: target
Return type: escript.Data
- target (
-
esys.downunder.forwardmodels.dcresistivity.
integrate
(arg, where=None)¶ Returns the integral of the function
arg
over its domain. Ifwhere
is presentarg
is interpolated towhere
before integration.Parameters: - arg (
escript.Data
orSymbol
) – the function which is integrated - where (
None
orescript.FunctionSpace
) – FunctionSpace in which the integral is calculated. If not present orNone
an appropriate default is used.
Returns: integral of
arg
Return type: float
,numpy.ndarray
orSymbol
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
interpolate
(arg, where)¶ Interpolates the function into the
FunctionSpace
where
. If the argumentarg
has the requested function spacewhere
no interpolation is performed andarg
is returned.Parameters: - arg (
escript.Data
orSymbol
) – interpolant - where (
escript.FunctionSpace
) –FunctionSpace
to be interpolated to
Returns: interpolated argument
Return type: escript.Data
orSymbol
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
interpolateTable
(tab, dat, start, step, undef=1e+50, check_boundaries=False)¶
-
esys.downunder.forwardmodels.dcresistivity.
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 tokronecker(arg.getShape()[0])
Return type: numpy.ndarray
,escript.Data
,Symbol
depending on the inputNote: for escript.Data
objects the dimension is restricted to 3.
-
esys.downunder.forwardmodels.dcresistivity.
jump
(arg, domain=None)¶ Returns the jump of
arg
across the continuity of the domain.Parameters: - arg (
escript.Data
orSymbol
) – argument - domain (
None
orescript.Domain
) – the domain where the discontinuity is located. If domain is not present or equal toNone
the domain ofarg
is used.
Returns: jump of
arg
Return type: escript.Data
orSymbol
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
kronecker
(d=3)¶ Returns the kronecker delta-symbol.
Parameters: d ( int
,escript.Domain
orescript.FunctionSpace
) – dimension or an object that has thegetDim
method defining the dimensionReturns: the object u of rank 2 with u[i,j]=1 for i=j and u[i,j]=0 otherwise Return type: numpy.ndarray
orescript.Data
of rank 2
-
esys.downunder.forwardmodels.dcresistivity.
length
(arg)¶ Returns the length (Euclidean norm) of argument
arg
at each data point.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
depending on the type ofarg
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
log
(arg)¶ Returns the natural logarithm of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
log10
(arg)¶ Returns base-10 logarithm of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
longestEdge
(domain)¶ Returns the length of the longest edge of the domain
Parameters: domain ( escript.Domain
) – a domainReturns: longest edge of the domain parallel to the Cartesian axis Return type: float
-
esys.downunder.forwardmodels.dcresistivity.
makeTagMap
(fs)¶ Produce an expanded Data over the function space where the value is the tag associated with the sample
-
esys.downunder.forwardmodels.dcresistivity.
makeTransformation
(domain, coordinates=None)¶ returns a
SpatialCoordinateTransformation
for the given domainParameters: - domain (
esys.escript.AbstractDomain
) – domain in the domain of the coordinate transformation - coordinates (
ReferenceSystem
orSpatialCoordinateTransformation
) – the reference system or spatial coordinate system.
Returns: the spatial coordinate system for the given domain of the specified reference system
coordinates
. Ifcoordinates
is already spatial coordinate system based on the riven domaincoordinates
is returned. Otherwise an appropriate spatial coordinate system is created.Return type: SpatialCoordinateTransformation
- domain (
-
esys.downunder.forwardmodels.dcresistivity.
matchShape
(arg0, arg1)¶ Returns a representation of
arg0
andarg1
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
andarg1
where copies are returned when the shape has to be changedReturn type: tuple
- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
matchType
(arg0=0.0, arg1=0.0)¶ Converts
arg0
andarg1
both to the same typenumpy.ndarray
orescript.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
andarg1
with the same type or with at least one of them being aSymbol
Return type: tuple
of twonumpy.ndarray
or twoescript.Data
Raises: TypeError – if type of
arg0
orarg1
cannot be processed- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
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 ofarg1
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
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the inputRaises: ValueError – if the shapes of the arguments are not appropriate
- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
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 tomatrix_mult(arg0,transpose(arg1))
.The last dimensions of
arg0
andarg1
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 ofarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the inputRaises: ValueError – if the shapes of the arguments are not appropriate
- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
matrixmult
(arg0, arg1)¶ See
matrix_mult
.
-
esys.downunder.forwardmodels.dcresistivity.
maximum
(*args)¶ The maximum over arguments
args
.Parameters: args ( numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
) – argumentsReturns: an object which in each entry gives the maximum of the corresponding values in args
Return type: numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
maxval
(arg)¶ Returns the maximum value over all components of
arg
at each data point.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
meanValue
(arg)¶ return the mean value of the argument over its domain
Parameters: arg ( escript.Data
) – functionReturns: mean value Return type: float
ornumpy.ndarray
-
esys.downunder.forwardmodels.dcresistivity.
minimum
(*args)¶ The minimum over arguments
args
.Parameters: args ( numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
) – argumentsReturns: an object which gives in each entry the minimum of the corresponding values in args
Return type: numpy.ndarray
,escript.Data
,Symbol
,int
orfloat
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
minval
(arg)¶ Returns the minimum value over all components of
arg
at each data point.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
mkDir
(*pathname)¶ creates a directory of name
pathname
if the directory does not exist.Parameters: pathname ( str
orsequence of strings
) – valid path nameNote: The method is MPI safe.
-
esys.downunder.forwardmodels.dcresistivity.
mult
(arg0, arg1)¶ Product of
arg0
andarg1
.Parameters: - arg0 (
Symbol
,float
,int
,escript.Data
ornumpy.ndarray
) – first term - arg1 (
Symbol
,float
,int
,escript.Data
ornumpy.ndarray
) – second term
Returns: the product of
arg0
andarg1
Return type: Symbol
,float
,int
,escript.Data
ornumpy.ndarray
Note: The shape of both arguments is matched according to the rules used in
matchShape
.- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
negative
(arg)¶ returns the negative part of arg
-
esys.downunder.forwardmodels.dcresistivity.
nonsymmetric
(arg)¶ Deprecated alias for antisymmetric
-
esys.downunder.forwardmodels.dcresistivity.
normalize
(arg, zerolength=0)¶ Returns the normalized version of
arg
(=``arg/length(arg)``).Parameters: - arg (
escript.Data
orSymbol
) – function - zerolength (
float
) – relative tolerance for arg == 0
Returns: normalized
arg
wherearg
is non-zero, and zero elsewhereReturn type: escript.Data
orSymbol
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
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
- s runs through
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
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input
-
esys.downunder.forwardmodels.dcresistivity.
phase
(arg)¶ return the “phase”/”arg”/”angle” of a number
-
esys.downunder.forwardmodels.dcresistivity.
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
orNone
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
positive
(arg)¶ returns the positive part of arg
-
esys.downunder.forwardmodels.dcresistivity.
printParallelThreadCounts
() → None¶
-
esys.downunder.forwardmodels.dcresistivity.
reorderComponents
(arg, index)¶ Resorts the components of
arg
according to index.
-
esys.downunder.forwardmodels.dcresistivity.
resolve
(arg)¶ Returns the value of arg resolved.
-
esys.downunder.forwardmodels.dcresistivity.
safeDiv
(arg0, arg1, rtol=None)¶ returns arg0/arg1 but return 0 where arg1 is (almost) zero
-
esys.downunder.forwardmodels.dcresistivity.
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 oneFunctionSpace
. 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
) – IfTrue
, then open file at end rather than beginning - refid (
bool
) – IfTrue
, 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 namemask
, then only samples which correspond to positive values inmask
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.
- filename (
-
esys.downunder.forwardmodels.dcresistivity.
saveESD
(datasetName, dataDir='.', domain=None, timeStep=0, deltaT=1, dynamicMesh=0, timeStepFormat='%04d', **data)¶ Saves
Data
objects to files and creates anescript 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 theData
object(s). If not specified, the domain of the givenData
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.
- datasetName (
-
esys.downunder.forwardmodels.dcresistivity.
showEscriptParams
()¶ Displays the parameters escript recognises with an explanation and their current value.
-
esys.downunder.forwardmodels.dcresistivity.
sign
(arg)¶ Returns the sign of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
sin
(arg)¶ Returns sine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
sinh
(arg)¶ Returns the hyperbolic sine of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
sqrt
(arg)¶ Returns the square root of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
sup
(arg)¶ Returns the maximum value over all data points.
Parameters: arg ( float
,int
,escript.Data
,numpy.ndarray
) – argumentReturns: maximum value of arg
over all components and all data pointsReturn type: float
Raises: TypeError – if type of arg
cannot be processed
-
esys.downunder.forwardmodels.dcresistivity.
swap_axes
(arg, axis0=0, axis1=1)¶ Returns the swap of
arg
by swapping the componentsaxis0
andaxis1
.Parameters: - arg (
escript.Data
,Symbol
,numpy.ndarray
) – argument - axis0 (
int
) – first axis.axis0
must be non-negative and less than the rank ofarg
. - axis1 (
int
) – second axis.axis1
must be non-negative and less than the rank ofarg
.
Returns: arg
with swapped componentsReturn type: escript.Data
,Symbol
ornumpy.ndarray
depending on the type ofarg
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
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.dcresistivity.
tan
(arg)¶ Returns tangent of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
tanh
(arg)¶ Returns the hyperbolic tangent of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
tensor_mult
(arg0, arg1)¶ The tensor product of the two arguments.
For
arg0
of rank 2 this isout[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 isout[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 ofarg1
must match and in the second case the two last dimensions ofarg0
must match the two first dimensions ofarg1
.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 ofarg0
Returns: the tensor product of
arg0
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
tensor_transposed_mult
(arg0, arg1)¶ The tensor product of the first and the transpose of the second argument.
For
arg0
of rank 2 this isout[s0,s1]=Sigma_{r0} arg0[s0,r0]*arg1[s1,r0]
and for
arg0
of rank 4 this isout[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
andarg1
must match and in the second case the two last dimensions ofarg0
must match the two last dimensions ofarg1
.The function call
tensor_transpose_mult(arg0,arg1)
is equivalent totensor_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 ofarg0
Returns: the tensor product of the transposed of
arg0
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the input- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
tensormult
(arg0, arg1)¶ See
tensor_mult
.
-
esys.downunder.forwardmodels.dcresistivity.
testForZero
(arg)¶ Tests if the argument is identical to zero.
Parameters: arg (typically numpy.ndarray
,escript.Data
,float
,int
) – the object to test for zeroReturns: True if the argument is identical to zero, False otherwise Return type: bool
-
esys.downunder.forwardmodels.dcresistivity.
trace
(arg, axis_offset=0)¶ Returns the trace of
arg
which is the sum ofarg[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 ofarg
+1. The dimensions of componentaxis_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
ornumpy.ndarray
depending on the type ofarg
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
transpose
(arg, axis_offset=None)¶ Returns the transpose of
arg
by swapping the firstaxis_offset
and the lastrank-axis_offset
components.Parameters: - arg (
escript.Data
,Symbol
,numpy.ndarray
,float
,int
) – argument - axis_offset (
int
) – the firstaxis_offset
components are swapped with the rest.axis_offset
must be non-negative and less or equal to the rank ofarg
. Ifaxis_offset
is not presentint(r/2)
where r is the rank ofarg
is used.
Returns: transpose of
arg
Return type: escript.Data
,Symbol
,numpy.ndarray
,float
,int
depending on the type ofarg
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
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 tomatrix_mult(transpose(arg0),arg1)
.The first dimension of
arg0
andarg1
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
andarg1
at each data pointReturn type: numpy.ndarray
,escript.Data
,Symbol
depending on the inputRaises: ValueError – if the shapes of the arguments are not appropriate
- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
transposed_tensor_mult
(arg0, arg1)¶ The tensor product of the transpose of the first and the second argument.
For
arg0
of rank 2 this isout[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 isout[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 ofarg1
must match and in the second case the two first dimensions ofarg0
must match the two first dimensions ofarg1
.The function call
transposed_tensor_mult(arg0,arg1)
is equivalent totensor_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 ofarg0
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- arg0 (
-
esys.downunder.forwardmodels.dcresistivity.
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
orescript.FunctionSpace
) – dimension or an object that has thegetDim
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
orescript.Data
of rank 1- i (
-
esys.downunder.forwardmodels.dcresistivity.
vol
(arg)¶ Returns the volume or area of the oject
arg
Parameters: arg ( escript.FunctionSpace
orescript.Domain
) – a geometrical objectReturn type: float
-
esys.downunder.forwardmodels.dcresistivity.
whereNegative
(arg)¶ Returns mask of negative values of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
whereNonNegative
(arg)¶ Returns mask of non-negative values of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
whereNonPositive
(arg)¶ Returns mask of non-positive values of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
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. Iftol
is not presentrtol``*```Lsup` (arg)
is used.
Return type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: - ValueError – if
rtol
is non-negative. - TypeError – if the type of the argument is not expected
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
wherePositive
(arg)¶ Returns mask of positive values of argument
arg
.Parameters: arg ( float
,escript.Data
,Symbol
,numpy.ndarray
.) – argumentReturn type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: TypeError – if the type of the argument is not expected
-
esys.downunder.forwardmodels.dcresistivity.
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. Iftol
is not presentrtol``*```Lsup` (arg)
is used. - rtol (non-negative
float
) – relative tolerance used to define the absolute tolerance iftol
is not present.
Return type: float
,escript.Data
,Symbol
,numpy.ndarray
depending on the type ofarg
Raises: - ValueError – if
rtol
is non-negative. - TypeError – if the type of the argument is not expected
- arg (
-
esys.downunder.forwardmodels.dcresistivity.
zeros
(shape=())¶ Returns the
shape
zero tensor.Parameters: shape ( tuple
ofint
) – input shape for the identity tensorReturns: array of shape filled with zeros Return type: numpy.ndarray
Others¶
- DBLE_MAX
- EPSILON


Base price: $10, additional topping selections increase as such:
Please select Size:
Quantity of Pizza(s):
Want to try flirting with the server for a discount? It could go well, or perhaps not...


pips Red=99 White=133
(CorrectAnswer= 0/0, ErrorScore= 0)
On Armistice Day it seems appropriate to remind ourselves that backgammon is, like many ancient games, a representation of war. Its origins are long lost in the sands of time but the two armies have now been battling it out for 5,000 years or more. The second oldest game in the world, Go, is a mere fledgling with only 2,500 years of history.
The themes of warfare are constantly repeated in backgammon and indeed I have detailed presentation entitled “The Lessons of War” which I frequently use when teaching.
It is well known that if you can divide an opposing army into two parts with little or no communication between those parts then you will derive an advantage by doing so. That concept is ably demonstrated by this position, taken from a match during a tournament at Mayfair’s 5, Hertford Street Club earlier this week.
The player of the Black checkers moved bar/20, 16/10 with his 65 but that allows White to attack the checker left on White’s 5-pt with any 1, 2, 3 or 8. The better move is bar/20/14 leaving a double direct shot. However, it is not only the number of shots that matter but the quality of the shots and the impact that hitting will have on the position.
After bar/20/14 White cannot hit and make a new point unless he rolls 44 and so Black will still have a three-point board on which to enter. Bar/20, 16/10 allows Black nine devastating pointing rolls against the blot on the White’s 5-pt. Secondly, and very importantly, if White hits from his mid-point he has to give up that point to do so and then White’s army will be split in two with his two rear checkers stranded on Black’s 3-pt. Extricating them will be difficult without the mid-point for communication with the rest of his army.
The risk and rewards of leaving blots in front of a stripped point (one with only two checkers on it) have been much better understood since the advent of computers. Like warfare new ideas and methods are constantly being developed and brought into play. Unlike warfare, where new weapons and tactics normally cost lives, the development of backgammon theory merely brings greater understanding and more enjoyment in the game.
The themes of warfare are constantly repeated in backgammon and indeed I have detailed presentation entitled “The Lessons of War” which I frequently use when teaching.
It is well known that if you can divide an opposing army into two parts with little or no communication between those parts then you will derive an advantage by doing so. That concept is ably demonstrated by this position, taken from a match during a tournament at Mayfair’s 5, Hertford Street Club earlier this week.
The player of the Black checkers moved bar/20, 16/10 with his 65 but that allows White to attack the checker left on White’s 5-pt with any 1, 2, 3 or 8. The better move is bar/20/14 leaving a double direct shot. However, it is not only the number of shots that matter but the quality of the shots and the impact that hitting will have on the position.
After bar/20/14 White cannot hit and make a new point unless he rolls 44 and so Black will still have a three-point board on which to enter. Bar/20, 16/10 allows Black nine devastating pointing rolls against the blot on the White’s 5-pt. Secondly, and very importantly, if White hits from his mid-point he has to give up that point to do so and then White’s army will be split in two with his two rear checkers stranded on Black’s 3-pt. Extricating them will be difficult without the mid-point for communication with the rest of his army.
The risk and rewards of leaving blots in front of a stripped point (one with only two checkers on it) have been much better understood since the advent of computers. Like warfare new ideas and methods are constantly being developed and brought into play. Unlike warfare, where new weapons and tactics normally cost lives, the development of backgammon theory merely brings greater understanding and more enjoyment in the game.
1. Cubeful 2-ply bar/14 Eq.: +0.217 0.559 0.153 0.003 - 0.441 0.096 0.003 2. Cubeful 2-ply bar/20 16/10 Eq.: +0.158 (-0.059) 0.522 0.193 0.003 - 0.478 0.082 0.003


| Opcode*/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
| 0F 51 /r SQRTPS xmm1, xmm2/m128 | RM | V/V | SSE | Computes square roots of the packed singleprecision floating-point values in xmm2/m128 and stores the results in xmm1. |
| VEX.128.0F.WIG 51 /r VSQRTPS xmm1, xmm2/m128 | RM | V/V | AVX | Computes Square Roots of the packed singleprecision floating-point values in xmm2/m128 and stores the result in xmm1. |
| VEX.256.0F.WIG 51/r VSQRTPS ymm1, ymm2/m256 | RM | V/V | AVX | Computes Square Roots of the packed singleprecision floating-point values in ymm2/m256 and stores the result in ymm1. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (w) | ModRM:r/m (r) | NA | NA |
Performs a SIMD computation of the square roots of the four packed single-precision floating-point values in the source operand (second operand) stores the packed single-precision floating-point results in the destination operand. The source operand can be an XMM register or a 128-bit memory location. The destination operand is an XMM register. See Figure 10-5 in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1, for an illustration of a SIMD single-precision floating-point operation.
In 64-bit mode, using a REX prefix in the form of REX.R permits this instruction to access additional registers (XMM8-XMM15). 128-bit Legacy SSE version: The second source can be an XMM register or 128-bit memory location. The destination is not distinct from the first source XMM register and the upper bits (VLMAX-1:128) of the corresponding YMM register destination are unmodified. VEX.128 encoded version: the source operand second source operand or a 128-bit memory location. The destination operand is an XMM register. The upper bits (VLMAX-1:128) of the corresponding YMM register destination are zeroed. VEX.256 encoded version: The source operand is a YMM register or a 256-bit memory location. The destination operand is a YMM register. Note: In VEX-encoded versions, VEX.vvvv is reserved and must be 1111b otherwise instructions will #UD.
SQRTPS (128-bit Legacy SSE version) DEST[31:0] ← SQRT(SRC[31:0]) DEST[63:32] ← SQRT(SRC[63:32]) DEST[95:64] ← SQRT(SRC[95:64]) DEST[127:96] ← SQRT(SRC[127:96]) DEST[VLMAX-1:128] (Unmodified) VSQRTPS (VEX.128 encoded version) DEST[31:0] ← SQRT(SRC[31:0]) DEST[63:32] ← SQRT(SRC[63:32]) DEST[95:64] ← SQRT(SRC[95:64]) DEST[127:96] ← SQRT(SRC[127:96]) DEST[VLMAX-1:128] ← 0 VSQRTPS (VEX.256 encoded version) DEST[31:0] ← SQRT(SRC[31:0]) DEST[63:32] ← SQRT(SRC[63:32]) DEST[95:64] ← SQRT(SRC[95:64]) DEST[127:96] ← SQRT(SRC[127:96]) DEST[159:128] ← SQRT(SRC[159:128]) DEST[191:160] ← SQRT(SRC[191:160]) DEST[223:192] ← SQRT(SRC[223:192]) DEST[255:224] ← SQRT(SRC[255:224])
| SQRTPS: | __m128 _mm_sqrt_ps(__m128 a) |
| SQRTPS: | __m256 _mm256_sqrt_ps (__m256 a); |
Invalid, Precision, Denormal.
See Exceptions Type 2; additionally
| #UD | If VEX.vvvv != 1111B. |


|
Background
Text
|
|
|---|---|
|
Text
|
|
|
AAA Pass, AAA (7+)
AA Pass, AA (4.5+)
AA18 Pass, Large Text Only (3+)
DNP Does Not Pass
|


Pushy is a Java library for sending APNs (iOS and OS X) push notifications. Pushy is written by the engineers at Turo.
Pushy sends push notifications using Apple's HTTP/2-based APNs protocol. It distinguishes itself from other push notification libraries with a focus on thorough documentation, asynchronous operation, and design for industrial-scale operation; with Pushy, it's easy and efficient to maintain multiple parallel connections to the APNs gateway to send large numbers of notifications to many different applications ("topics").
Pushy is available under the MIT License.


SenseTile Summary
The UCD CASL SenseTile System is a large-scale, general-purpose sensor system installed at the University College Dublin in Dublin, Ireland. Our facility provides a capability, unique in the world in terms of its scale and flexibility, for performing in-depth investigation of both the specific and general issues in large-scale sensor networking.
This system integrates a sensor platform, a datastore, and a compute farm. The sensor platform (called the SenseTile Unit) is a custom-designed, but inexpensive sensor platform. Each unit is composed of one or more SenseTile Sensor Boards paired with a SenseTile Processor Unit, the latter of which includes everything from PDAs to powerful touchscreen-based portable computers. Communication between the Sensor Board and the Processor Unit takes place over a USB bus using a streaming packet-based protocol.
There are over a dozen sensors on the SenseTile Sensor Board itself, and new sensors are added either using expansion slots on the SenseTile Sensor Board, or by adding them directly to the USB bus.
The datastore is a multi-terabyte scale scientific datastore into which sensor data flows, and in which online and offline scientific computation of sensor and other scientific data takes place. The compute farm is a large-scale Linux, Solaris, and Mac OS X-based compute farm used by scientists for these online and offline scientific computations. Our facility aims to provide a scalable and extensible infrastructure for performing in-depth investigation of both the specific and general issues in large-scale sensor networking.
Development of SenseTile is hosted at GitHub.


|
Filter functions and methods | |
Filter by: |
|
Filter: |
| Size | 6 x 1 |
|---|---|
| Class | double |
| Complex | No |
| Size | 3 x 6 |
|---|---|
| Class | double |
| Complex | No |
| Size | 1 x 1 |
|---|---|
| Class | double |
| Complex | No |
| Size | 3 x 1 |
|---|---|
| Class | double |
| Complex | No |
| Size | 1 x 1 |
|---|---|
| Class | logical |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 30 |
|---|---|
| Class | char |
| Size | 1 x 1 |
|---|---|
| Class | cell |
| Size | 1 x 1 |
|---|---|
| Class | mxArray |
| Size | 1 x 4 |
|---|---|
| Class | char |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 0 |
|---|---|
| Class | cell |
| Size | 1 x 5 |
|---|---|
| Class | char |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 2 |
|---|---|
| Class | cell |
| Size | 1 x 6 |
|---|---|
| Class | char |
| Size | 1 x 14 |
|---|---|
| Class | char |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 1 |
|---|---|
| Class | double |
| Complex | No |
| Size | 1 x 31 |
|---|---|
| Class | char |
| Size | 1 x 3 |
|---|---|
| Class | char |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 1 x 1 |
|---|---|
| Class | function_handle |
| Size | 3 x 3 |
|---|---|
| Class | double |
| Complex | No |
| Size | 1 x 1 |
|---|---|
| Class | char |
| Size | 1 x 3 |
|---|---|
| Class | double |
| Complex | No |
| Size | 6 x 6 |
|---|---|
| Class | double |
| Complex | No |
| Size | 1 x 6 |
|---|---|
| Class | double |
| Complex | No |
| Size | 3 x 1 |
|---|---|
| Class | double |
| Complex | No |
| Value | z |
|---|
| Value | r |
|---|
| Value | y |
|---|
| Value | x |
|---|
| Value | 0.8797 1.2146 2.9741 3.3090 5.0685 5.4034 |
|---|
| Value | 0.1002 1.9942 2.1946 4.0886 4.2890 6.1830 |
|---|
| Value | [3x6 double] |
|---|
| Value | [3x6 double] |
|---|
| MATLAB code generation attempted on: | 13-Nov-2019 15:28:29 |
| Number of errors: | 24 |
| Number of warnings: | 0 |
| Number of notices: | 0 |
| Tell Us What You Think |
| We value your feedback. Please take a few minutes to answer this short questionnaire regarding the Code Generation Report. |
| >>Provide Feedback |
| 1 | p_IK |
21 |
Undefined function or variable 'l'. The first assignment to a local variable determines its class. |
|
| 2 | p_IK |
22 |
Undefined function or variable 'l'. The first assignment to a local variable determines its class. |
|
| 3 | p_IK |
23 |
Undefined function or variable 'q'. The first assignment to a local variable determines its class. |
|
| 4 | p_IK |
24 |
Undefined function or variable 'l'. The first assignment to a local variable determines its class. |
|
| 5 | p_IK |
26 |
Undefined function or variable 'lam'. The first assignment to a local variable determines its class. |
|
| 6 | p_IK |
27 |
Undefined function or variable 'lam'. The first assignment to a local variable determines its class. |
|
| 7 | p_IK |
28 |
Undefined function or variable 'al'. The first assignment to a local variable determines its class. |
|
| 8 | p_IK |
29 |
Undefined function or variable 'lam'. The first assignment to a local variable determines its class. |
|
| 9 | p_IK |
30 |
Undefined function or variable 'cl'. The first assignment to a local variable determines its class. |
|
| 10 | p_IK |
32 |
Undefined function or variable 'R1_3'. The first assignment to a local variable determines its class. |
|
| 11 | p_IK |
33 |
Undefined function or variable 'Rz_b'. The first assignment to a local variable determines its class. |
|
| 12 | p_IK |
34 |
Undefined function or variable 'Rz_a'. The first assignment to a local variable determines its class. |
|
| 13 | p_IK |
35 |
Undefined function or variable 'R1_3'. The first assignment to a local variable determines its class. |
|
| 14 | p_IK |
37 |
Undefined function or variable 'R4_6'. The first assignment to a local variable determines its class. |
|
| 15 | p_IK |
38 |
Undefined function or variable 'R4_6'. The first assignment to a local variable determines its class. |
|
| 16 | p_IK |
39 |
Undefined function or variable 'R4_6'. The first assignment to a local variable determines its class. |
|
| 17 | fcn |
15 |
Function call failed. |
|
| 18 | fcn |
15 |
Undefined function or variable 'lam'. The first assignment to a local variable determines its class. |
|
| 19 | fcn |
15 |
Undefined function or variable 'th_i'. The first assignment to a local variable determines its class. |
|
| 20 | fcn |
18 |
Undefined function or variable 'th_i'. The first assignment to a local variable determines its class. |
|
| 21 | fcn |
18 |
Undefined function or variable 'X_p'. The first assignment to a local variable determines its class. |
|
| 22 | fcn |
18 |
Undefined function or variable 'Jac'. The first assignment to a local variable determines its class. |
|
| 23 | fcn |
18 |
Undefined function or variable 't_dot'. The first assignment to a local variable determines its class. |
|
| 24 | fcn |
21 |
Error limit reached. Suppressing further error messages. |


| Rank | Name | Level | XP |
|---|---|---|---|
| 1 | Tai | 99 | 200,000,000 |
| 2 | Unohdettu2 | 99 | 200,000,000 |
| 3 | Drakon | 99 | 200,000,000 |
| 4 | Ame Umehara | 99 | 200,000,000 |
| 5 | Jakee | 99 | 200,000,000 |
| 6 | Aravt | 99 | 200,000,000 |
| 7 | Howson | 99 | 200,000,000 |
| 8 | Dr PFAFF | 99 | 200,000,000 |
| 9 | Lickeys | 99 | 200,000,000 |
| 10 | Burned | 99 | 200,000,000 |
| 11 | Blue Limes | 99 | 200,000,000 |
| 12 | Mini Aurelia | 99 | 200,000,000 |
| 13 | Unohdettu3 | 99 | 200,000,000 |
| 14 | Eslihero | 99 | 200,000,000 |
| 15 | Lynx Titan | 99 | 200,000,000 |
| 16 | AndrewWigins | 99 | 200,000,000 |
| 17 | iMelee | 99 | 200,000,000 |
| 18 | Portuguese | 99 | 200,000,000 |
| 19 | MarkoOSRS | 99 | 200,000,000 |
| 20 | Cairo | 99 | 200,000,000 |
| 21 | Hey Jase | 99 | 200,000,000 |
| 22 | H D M P | 99 | 200,000,000 |
| 23 | Yumemi | 99 | 200,000,000 |
| 24 | Fiiggy | 99 | 200,000,000 |
| 25 | Edgecrusher | 99 | 200,000,000 |
This website and its contents are copyright © 1999 - 2022 Jagex
Ltd, 220 Science Park, Cambridge, CB4 0WA, United Kingdom.
Use of
this website is subject to our
Terms & Conditions
and
Privacy Policy.
Rules of Old School RuneScape
|
Change Cookie Settings


Your ship lurches unexpectedly. Your eyes turn to the fuel gauge-- Empty!
In the void of space, there is very little friction. Because of this you can coast for some time. However, without the power of auxilery thrusters, you are unable to avoid a fatal collision.
At least you've got eachother...?
Try Again