def test_reflections(): # 3. reflections dat = DATAKERNEL['refl'][()] for key, val in dat.items(): Rp, Rm = kernel.reflections(**val[0]) assert_allclose(Rp, val[1]) assert_allclose(Rm, val[2]) val[0]['use_ne_eval'] = use_ne_eval Rp, Rm = kernel.reflections(**val[0]) assert_allclose(Rp, val[1]) assert_allclose(Rm, val[2])
def test_fields(): Gam = np.sqrt((etaH/etaV)[:, None, :, None] * (lambd**2)[None, :, None, :] + (zeta**2)[:, None, :, None]) for lay in [0, 1, 5]: # Src/rec in first, second, and last layer inp1 = {'depth': depth[:-1], 'e_zH': etaH, 'Gam': Gam, 'lrec': np.array(lay), 'lsrc': np.array(lay)} Rp1, Rm1 = kernel.reflections(**inp1) inp2 = {'depth': depth[:-1], 'Gam': Gam, 'Rp': Rp1, 'Rm': Rm1, 'lrec': np.array(lay), 'lsrc': np.array(lay), 'zsrc': depth[lay+1]-50} for TM in [True, False]: inp2['TM'] = TM # empymod-version out = kernel.fields(ab=11, **inp2) # empymod.scripts-version TMTE = tmtemod.fields(**inp2) # Check assert_allclose(out[0], TMTE[0] + TMTE[1]) assert_allclose(out[1], TMTE[2] + TMTE[3])
def get_rp_rm(z_eta): r"""Return Rp, Rm.""" # Get Rp/Rm for lambd=0 Rp, Rm = reflections(depth, z_eta, Gam, lrec, lsrc) # Depending on model Rp/Rm have 3 or 4 dimensions. Last two are # wavenumbers and layers btw src and rec, which both are 1. if Rp.ndim == 4: Rp = np.squeeze(Rp, axis=3) if Rm.ndim == 4: Rm = np.squeeze(Rm, axis=3) Rp = np.squeeze(Rp, axis=2) Rm = np.squeeze(Rm, axis=2) # Calculate reverberation M and general factor npfct Ms = 1 - Rp * Rm * np.exp(-2 * iGam * ds) npfct = ang_fact * zetaH[:, lsrc] / (fact * off * lgam * Ms) return Rp, Rm, npfct
def greenfct(zsrc, zrec, lsrc, lrec, depth, etaH, etaV, zetaH, zetaV, lambd): r"""Calculate Green's function for TM and TE. This is a modified version of empymod.kernel.greenfct(). See the original version for more information. """ # GTM/GTE have shape (frequency, offset, lambda). # gamTM/gamTE have shape (frequency, offset, layer, lambda): for TM in [True, False]: # Define eta/zeta depending if TM or TE if TM: e_zH, e_zV, z_eH = etaH, etaV, zetaH # TM: zetaV not used else: e_zH, e_zV, z_eH = zetaH, zetaV, etaH # TE: etaV not used # Uppercase gamma Gam = np.sqrt((e_zH / e_zV)[:, None, :, None] * (lambd * lambd)[None, :, None, :] + (z_eH * e_zH)[:, None, :, None]) # Gamma in receiver layer lrecGam = Gam[:, :, lrec, :] # Reflection (coming from below (Rp) and above (Rm) rec) Rp, Rm = reflections(depth, e_zH, Gam, lrec, lsrc) # Field propagators # (Up- (Wu) and downgoing (Wd), in rec layer); Eq 74 if lrec != depth.size - 1: # No upgoing field prop. if rec in last ddepth = depth[lrec + 1] - zrec Wu = np.exp(-lrecGam * ddepth) else: Wu = np.full_like(lrecGam, 0 + 0j) if lrec != 0: # No downgoing field propagator if rec in first ddepth = zrec - depth[lrec] Wd = np.exp(-lrecGam * ddepth) else: Wd = np.full_like(lrecGam, 0 + 0j) # Field at rec level (coming from below (Pu) and above (Pd) rec) Puu, Pud, Pdu, Pdd = fields(depth, Rp, Rm, Gam, lrec, lsrc, zsrc, TM) # Store in corresponding variable PT* = [T*uu, T*ud, T*du, T*dd] df = np.exp(-lrecGam * abs(zsrc - zrec)) # direct field fTM = Gam[:, :, lrec, :] / etaH[:, None, lrec, None] fTE = zetaH[:, None, lsrc, None] / Gam[:, :, lsrc, :] if TM: PTM = [ Puu * Wu * fTM, Pud * Wu * fTM, Pdu * Wd * fTM, Pdd * Wd * fTM, -df * fTM ] else: PTE = [ Puu * Wu * fTE, Pud * Wu * fTE, Pdu * Wd * fTE, Pdd * Wd * fTE, df * fTE ] # Return Green's functions return PTM, PTE
res3 = kernel.greenfct(ab=val[2], msrc=val[0], mrec=val[1], **inp4) green[key] = (val[2], val[0], val[1], inp2, res1, inp3, res2, inp4, res3) # # D -- REFLECTIONS # # refl = {} # Standard example Gam = np.sqrt((etaH/etaV)[:, None, :, None] * (lambd**2)[None, :, None, :] + (zetaH**2)[:, None, :, None]) inp5 = {'depth': depth, 'e_zH': etaH, 'Gam': Gam, 'lrec': inp1['lrec'], 'lsrc': inp1['lsrc']} Rp1, Rm1 = kernel.reflections(**inp5) refl[0] = (inp5, Rp1, Rm1) # Source and receiver in same layer, but not last inp6 = {'depth': inp2['depth'], 'e_zH': etaH, 'Gam': Gam, 'lrec': np.array(3), 'lsrc': np.array(3)} Rp2, Rm2 = kernel.reflections(**inp6) refl[1] = (inp6, Rp2, Rm2) # # E -- FIELDS # # # Standard example inp7 = {'depth': depth,