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