def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1, terms=False):
"""
Hilterman (1989) approximation.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts.
:param vp1: The p-wave velocity of the upper medium.
:param vs1: The s-wave velocity of the upper medium.
:param rho1: The density of the upper medium.
:param vp2: The p-wave velocity of the lower medium.
:param vs2: The s-wave velocity of the lower medium.
:param rho2: The density of the lower medium.
:param theta1: An array of incident angles to use for reflectivity
calculation [degrees].
:returns: a vector of len(theta1) containing the reflectivity
value corresponding to each angle.
"""
theta1 = np.radians(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rpp0 = (ip2 - ip1) / (ip2 + ip1)
dpr = moduli.pr(vp2, vs2) - moduli.pr(vp1, vs1)
term1 = rpp0 * np.cos(theta1)**2
term2 = 2.25 * dpr * np.sin(theta1)**2
if terms:
return term1, term2
else:
return (term1 + term2)
def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1, terms=False):
"""
Hilterman (1989) approximation.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts.
:param vp1: The p-wave velocity of the upper medium.
:param vs1: The s-wave velocity of the upper medium.
:param rho1: The density of the upper medium.
:param vp2: The p-wave velocity of the lower medium.
:param vs2: The s-wave velocity of the lower medium.
:param rho2: The density of the lower medium.
:param theta1: An array of incident angles to use for reflectivity
calculation [degrees].
:returns: a vector of len(theta1) containing the reflectivity
value corresponding to each angle.
"""
theta1 = np.radians(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rpp0 = (ip2 - ip1) / (ip2 + ip1)
dpr = moduli.pr(vp2, vs2) - moduli.pr(vp1, vs1)
term1 = rpp0 * np.cos(theta1)**2
term2 = 2.25 * dpr * np.sin(theta1)**2
if terms:
return term1, term2
else:
return (term1 + term2)
def test_vpvs(self):
self.assertAlmostEqual(m.youngs(vp=vp, vs=vs, rho=rho),
youngs, places=-2)
self.assertAlmostEqual(m.mu(vp=vp, vs=vs, rho=rho), mu, places=-2)
self.assertAlmostEqual(m.pr(vp=vp, vs=vs, rho=rho), pr)
self.assertAlmostEqual(m.lam(vp=vp, vs=vs, rho=rho), lam, places=-2)
self.assertAlmostEqual(m.bulk(vp=vp, vs=vs, rho=rho), bulk, places=-2)
self.assertAlmostEqual(m.pmod(vp=vp, vs=vs, rho=rho), pmod, places=-2)
def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, terms=False):
"""
Not recommended, only seems to match Zoeppritz to about 10 deg.
Hilterman (1989) approximation from Mavko et al. Rock Physics Handbook.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts. Real
numbers only.
Args:
vp1 (ndarray): The upper P-wave velocity; float or 1D array length m.
vs1 (ndarray): The upper S-wave velocity; float or 1D array length m.
rho1 (ndarray): The upper layer's density; float or 1D array length m.
vp2 (ndarray): The lower P-wave velocity; float or 1D array length m.
vs2 (ndarray): The lower S-wave velocity; float or 1D array length m.
rho2 (ndarray): The lower layer's density; float or 1D array length m.
theta1 (ndarray): The incidence angle; float or 1D array length n.
terms (bool): Whether or not to return a tuple of the terms of the
equation. The first term is the acoustic impedance.
Returns:
ndarray. The Hilterman approximation for P-P reflectivity at the
interface. Will be a float (for float inputs and one angle), a
1 x n array (for float inputs and an array of angles), a 1 x m
array (for float inputs and one angle), or an n x m array (for
array inputs and an array of angles).
"""
theta1 = np.real(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rp0 = (ip2 - ip1) / (ip2 + ip1)
pr2, pr1 = moduli.pr(vp2, vs2), moduli.pr(vp1, vs1)
pravg = (pr2 + pr1) / 2.
pr = (pr2 - pr1) / (1 - pravg)**2.
term1 = rp0 * np.cos(theta1)**2.
term2 = pr * np.sin(theta1)**2.
if terms:
fields = ['term1', 'term2']
Hilterman = namedtuple('Hilterman', fields)
return Hilterman(np.squeeze(term1), np.squeeze(term2))
else:
return np.squeeze(term1 + term2)
def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, terms=False):
"""
Not recommended, only seems to match Zoeppritz to about 10 deg.
Hilterman (1989) approximation from Mavko et al. Rock Physics Handbook.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts.
Args:
vp1 (ndarray): The upper P-wave velocity; float or 1D array length m.
vs1 (ndarray): The upper S-wave velocity; float or 1D array length m.
rho1 (ndarray): The upper layer's density; float or 1D array length m.
vp2 (ndarray): The lower P-wave velocity; float or 1D array length m.
vs2 (ndarray): The lower S-wave velocity; float or 1D array length m.
rho2 (ndarray): The lower layer's density; float or 1D array length m.
theta1 (ndarray): The incidence angle; float or 1D array length n.
terms (bool): Whether or not to return a tuple of the terms of the
equation. The first term is the acoustic impedance.
Returns:
ndarray. The Hilterman approximation for P-P reflectivity at the
interface. Will be a float (for float inputs and one angle), a
1 x n array (for float inputs and an array of angles), a 1 x m
array (for float inputs and one angle), or an n x m array (for
array inputs and an array of angles).
"""
theta1 = np.radians(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rp0 = (ip2 - ip1) / (ip2 + ip1)
pr2, pr1 = moduli.pr(vp2, vs2), moduli.pr(vp1, vs1)
pravg = (pr2 + pr1) / 2.
pr = (pr2 - pr1) / (1 - pravg)**2.
term1 = rp0 * np.cos(theta1)**2.
term2 = pr * np.sin(theta1)**2.
if terms:
fields = ['term1', 'term2']
Hilterman = namedtuple('Hilterman', fields)
return Hilterman(np.squeeze(term1), np.squeeze(term2))
else:
return np.squeeze(term1 + term2)
def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, terms=False):
"""
Not recommended, only seems to match Zoeppritz to about 10 deg.
Hilterman (1989) approximation from Mavko et al. Rock Physics Handbook.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts.
:param vp1: The p-wave velocity of the upper medium.
:param vs1: The s-wave velocity of the upper medium.
:param rho1: The density of the upper medium.
:param vp2: The p-wave velocity of the lower medium.
:param vs2: The s-wave velocity of the lower medium.
:param rho2: The density of the lower medium.
:param theta1: An array of incident angles to use for reflectivity
calculation [degrees].
:returns: a vector of len(theta1) containing the reflectivity
value corresponding to each angle.
"""
theta1 = np.radians(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rp0 = (ip2 - ip1) / (ip2 + ip1)
pr2, pr1 = moduli.pr(vp2, vs2), moduli.pr(vp1, vs1)
pravg = (pr2 + pr1) / 2.
pr = (pr2 - pr1) / (1 - pravg)**2.
term1 = rp0 * np.cos(theta1)**2.
term2 = pr * np.sin(theta1)**2.
if terms:
fields = ['term1', 'term2']
Hilterman = namedtuple('Hilterman', fields)
return Hilterman(term1, term2)
else:
return (term1 + term2)
def hilterman(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, terms=False):
"""
Not recommended, only seems to match Zoeppritz to about 10 deg.
Hilterman (1989) approximation from Mavko et al. Rock Physics Handbook.
According to Dvorkin: "arguably the simplest and a very convenient
[approximation]." At least for small angles and small contrasts.
:param vp1: The p-wave velocity of the upper medium.
:param vs1: The s-wave velocity of the upper medium.
:param rho1: The density of the upper medium.
:param vp2: The p-wave velocity of the lower medium.
:param vs2: The s-wave velocity of the lower medium.
:param rho2: The density of the lower medium.
:param theta1: An array of incident angles to use for reflectivity
calculation [degrees].
:returns: a vector of len(theta1) containing the reflectivity
value corresponding to each angle.
"""
theta1 = np.radians(theta1)
ip1 = vp1 * rho1
ip2 = vp2 * rho2
rp0 = (ip2 - ip1) / (ip2 + ip1)
pr2, pr1 = moduli.pr(vp2, vs2), moduli.pr(vp1, vs1)
pravg = (pr2 + pr1) / 2.
pr = (pr2 - pr1) / (1 - pravg)**2.
term1 = rp0 * np.cos(theta1)**2.
term2 = pr * np.sin(theta1)**2.
if terms:
fields = ['term1', 'term2']
Hilterman = namedtuple('Hilterman', fields)
return Hilterman(term1, term2)
else:
return (term1 + term2)
def test_youngslam(self):
self.assertAlmostEqual(m.mu(youngs=youngs, lam=lam), mu, places=-2)
self.assertAlmostEqual(m.pr(youngs=youngs, lam=lam), pr, places=-2)
self.assertAlmostEqual(m.bulk(youngs=youngs, lam=lam), bulk, places=-2)
self.assertAlmostEqual(m.pmod(youngs=youngs, lam=lam), pmod, places=-2)
def test_lammu(self):
self.assertAlmostEqual(m.vp(lam=lam, mu=mu, rho=rho), vp, places=2)
self.assertAlmostEqual(m.youngs(lam=lam, mu=mu), youngs, places=-2)
self.assertAlmostEqual(m.pr(lam=lam, mu=mu), pr)
self.assertAlmostEqual(m.bulk(lam=lam, mu=mu), bulk, places=-2)
self.assertAlmostEqual(m.pmod(lam=lam, mu=mu), pmod, places=-2)
