def prism_bz(x, y, z, prism, incf, decf, incs=None, decs=None, azim=0.):
# Shape condition
if x.shape != y.shape:
raise ValueError("All inputs must have same shape!")
# Stablish some constants
t2nt = 1.e9 # Testa to nT - conversion
cm = 1.e-7 # Magnetization constant
# Condition for directions
if incs == None:
incs = incf
if decs == None:
decs = decf
# Calculate the directions for the source magnetization
mx, my, mz = aux.dircos(incs, decs, azim)
# Create the zero array
bz = numpy.zeros_like(x)
# Calculate the z - component
bz += (kernelxz(x, y, z, prism) * mx + kernelyz(x, y, z, prism) * my +
kernelzz(x, y, z, prism) * mz)
# Conversion
bz *= cm * t2nt
# Return the final output
return bz
def sphere_by(x, y, z, sphere, mag, incs, decs):
'''
It is a Python implementation for a Fortran subroutine contained in Blakely (1995). It
computes the Y component of the magnetic induction caused by a sphere with uniform
distribution of magnetization. The direction X represents the north and Z represents
growth downward. This function receives the coordinates of the points of observation
(X, Y, Z - arrays), the coordinates of the center of the sphere (Xe, Ye, Ze), the
magnetization intensity M and the values for inclination and declination (in degrees).
The observation values are given in meters.
Inputs:
x, y, z - numpy arrays - position of the observation points
sphere[0, 1, 2] - arrays - position of the center of the sphere
sphere[3] - float - value for the spehre radius
sphere[4] - flaot - magnetization intensity value
direction - numpy array - inclination, declination values
Outputs:
By - induced field on Y direction
Ps. The value for Z can be a scalar in the case of one depth, otherwise it can be a
set of points.
'''
# Stablishing some conditions
if x.shape != y.shape:
raise ValueError("All inputs must have same shape!")
# Calculates some constants
t2nt = 1.e9 # Testa to nT - conversion
cm = 1.e-7 # Magnetization constant
#Setting some constants
xe, ye, ze = sphere[0], sphere[1], sphere[2]
radius = sphere[3]
# Distances in all axis directions - x, y e z
rx = x - xe
ry = y - ye
rz = z - ze
# Computes the distance (r) as the module of the other three components
r2 = rx**2 + ry**2 + rz**2
# Computes the magnetization values for all directions
mx, my, mz = aux.dircos(incs, decs)
# Auxiliars calculations
dot = rx * mx + ry * my + rz * mz # Scalar product
m = (4. * np.pi * (radius**3) * mag) / 3. # Magnetic moment
# Component calculation - By
by = m * (3. * dot * ry - (r2 * my)) / (r2**(2.5))
# Final component calculation
by *= cm * t2nt
# Return the final output
return by
def sphere_tfa(x, y, z, sphere, mag, incf, decf, incs=None, decs=None):
'''
This function computes the total field anomaly produced due to a solid sphere, which has
its center located in xe, ye and ze, radius equals to r and also the magnetic property
(magnetic intensity). This function receives the coordinates of the points of observation
(X, Y, Z - arrays), the elements of the sphere, the values for inclination, declination
and azimuth (in one array only!) and the elements of the field (intensity, inclination,
declination and azimuth - IN THAT ORDER!). The observation values are given in meters.
Inputs:
x, y, z - numpy arrays - position of the observation points
sphere[0, 1, 2] - arrays - position of the center of the sphere
sphere[3] - float - value for the spehre radius
sphere[4] - flaot - magnetization intensity value
direction - numpy array - inclination and declination values
field - numpy array - inclination and declination values for the field
Outputs:
tf_aprox - numpy array - approximated total field anomaly
Ps. The value for Z can be a scalar in the case of one depth, otherwise it can be a
set of points.
'''
# Stablishing some conditions
if x.shape != y.shape:
raise ValueError("All inputs must have same shape!")
# Compute de regional field
fx, fy, fz = aux.dircos(incf, decf)
if incs == None:
incs = incf
if decs == None:
decs = decf
# Computing the components and the regional field
bx = sphere_bx(x, y, z, sphere, mag, incs, decs)
by = sphere_by(x, y, z, sphere, mag, incs, decs)
bz = sphere_bz(x, y, z, sphere, mag, incs, decs)
# Final value for the total field anomaly
tf_aprox = fx * bx + fy * by + fz * bz
# Return the final output
return tf_aprox
def prism_tf(x, y, z, prism, incf, decf, incs=None, decs=None, azim=0.):
'''
This function calculates the total field anomaly produced by a rectangular prism located under
surface; it is a Python implementation for the Subroutin MBox which is contained on Blakely (1995).
It recieves: the coordinates of the positions in all directions, the elements of the prims, the
angle directions and the elements of the field. That function also uses the auxilary function
DIR_COSSINE to calculate the projections due to the field F and the source S.
Inputs:
x, y - numpy arrays - observation points in x and y directions
z - numpy array/float - height for the observation
prism - numpy array - all elements for the prims
prism[0, 1] - initial and final coordinates at X (dimension at X axis!)
prism[2, 3] - initial and final coordinates at Y (dimension at Y axis!)
prism[4, 5] - initial and final coordinates at Z (dimension at Z axis!)
prism[6] - magnetic intensity
directions - numpy array - elements for source directions
directions[0] - float - source inclination
directions[1] - float - source declination
field - numpy array - elementes for regional field
field[0] - float - magnetic field inclination
field[1] - float - magnetic field declination
Output:
tfa - numpy array - calculated total field anomaly
X and Y represents North and East; Z is positive downward.
Ps. Z can be a array with all elements for toppography or a float point as a flight height.
'''
# Stablishing some conditions
if x.shape != y.shape:
raise ValueError("All inputs must have same shape!")
# Stablish some constants
t2nt = 1.e9 # Testa to nT - conversion
cm = 1.e-7 # Magnetization constant
if incs == None:
incs = incf
if decs == None:
decs = decf
# Calculate the directions for the source magnetization and for the field
Ma, Mb, Mc = aux.dircos(incs, decs, azim) # s -> source
Fa, Fb, Fc = aux.dircos(incf, decf, azim) # f -> field
# Aranges all values as a vector
MF = [
Ma * Fb + Mb * Fa, Ma * Fc + Mc * Fa, Mb * Fc + Mc * Fb, Ma * Fa,
Mb * Fb, Mc * Fc
]
# Limits for initial and final position along the directions
A = [prism[1] - x, prism[0] - x]
B = [prism[3] - y, prism[2] - y]
H = [prism[5] - z, prism[4] - z]
# Create the zero array to allocate the total field result
tfa = numpy.zeros_like(x)
# Magnetization
mag = prism[6]
# Loop for controling the signal of the function
for k in range(2):
mag *= -1
H2 = H[k]**2
for j in range(2):
Y2 = B[j]**2
for i in range(2):
X2 = A[i]**2
AxB = A[i] * B[j]
R2 = X2 + Y2 + H2
R = numpy.sqrt(R2)
HxR = H[k] * R
tfa += ((-1.)**(i + j)) * mag * (
0.5 * (MF[2]) * aux.my_log(
(R - A[i]) / (R + A[i])) + 0.5 * (MF[1]) * aux.my_log(
(R - B[j]) /
(R + B[j])) - (MF[0]) * aux.my_log(R + H[k]) -
(MF[3]) * aux.my_atan(AxB, X2 + HxR + H2) -
(MF[4]) * aux.my_atan(AxB, R2 + HxR - X2) +
(MF[5]) * aux.my_atan(AxB, HxR))
# Multiplying for constants conversion
tfa *= t2nt * cm
# Return the final output
return tfa
