Example #1
0
def test_EdgeRupture_vs_QuadRupture():
    # Sites stuff
    sites = Sites.fromCenter(-122.15, 37.15, 1.5, 1.5, 0.01, 0.01)
    sm_dict = sites._GeoDict
    west = sm_dict.xmin
    east = sm_dict.xmax
    south = sm_dict.ymin
    north = sm_dict.ymax
    nx = sm_dict.nx
    ny = sm_dict.ny
    lats = np.linspace(north, south, ny)
    lons = np.linspace(west, east, nx)
    lon, lat = np.meshgrid(lons, lats)
    dep = np.zeros_like(lon)

    # Construct QuadRupture
    xp0 = np.array([-122.0, -122.5])
    yp0 = np.array([37.1, 37.4])
    xp1 = np.array([-121.7, -122.3])
    yp1 = np.array([37.2, 37.2])
    zp = np.array([0, 6])
    widths = np.array([30, 20])
    dips = np.array([30, 40])

    origin = Origin({"lat": 0, "lon": 0, "depth": 0, "mag": 7.2, "id": ""})
    qrup = QuadRupture.fromTrace(xp0, yp0, xp1, yp1, zp, widths, dips, origin)
    rrup_q = qrup.computeRrup(lon, lat, dep)
    rjb_q = qrup.computeRjb(lon, lat, dep)

    # Construct equivalent EdgeRupture
    toplons = np.array([-122.0, -121.7, -122.5, -122.3])
    toplats = np.array([37.1, 37.2, 37.4, 37.2])
    topdeps = np.array([0, 0, 6, 6])
    botlons = np.array([-121.886864, -121.587568, -122.635467, -122.435338])
    botlats = np.array([36.884527, 36.984246, 37.314035, 37.114261])
    botdeps = np.array([15.0000, 14.9998, 18.8558, 18.8559])
    group_index = [0, 0, 1, 1]

    erup = EdgeRupture.fromArrays(toplons, toplats, topdeps, botlons, botlats, botdeps, origin, group_index)
    rrup_e = erup.computeRrup(lon, lat, dep)
    rjb_e = erup.computeRjb(lon, lat, dep)

    # Check that QuadRupture and EdgeRupture give the same result
    # (we check the absolute values of QuadRupture elsewhere)
    np.testing.assert_allclose(rrup_e, rrup_q, atol=0.35)
    np.testing.assert_allclose(rjb_e, rjb_q, atol=0.35)
Example #2
0
def test_exceptions():
    vs30file = os.path.join(shakedir, 'tests/data/Vs30_test.grd')
    cx = -118.2
    cy = 34.1
    dx = 0.0083
    dy = 0.0083
    xspan = 0.0083 * 5
    yspan = 0.0083 * 5
    site = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                            vs30File=vs30file,
                            padding=True, resample=False)
    # Make souce instance
    lat0 = np.array([34.1])
    lon0 = np.array([-118.2])
    lat1 = np.array([34.2])
    lon1 = np.array([-118.15])
    z = np.array([1.0])
    W = np.array([3.0])
    dip = np.array([30.])

    # Rupture requires an origin even when not used:
    origin = Origin({'id':'test','lat':0,'lon':0,'depth':5.0,'mag':7.0})
    rup = QuadRupture.fromTrace(lon0, lat0, lon1, lat1, z, W, dip, 
                                origin)

    event = {'lat': 34.1, 'lon': -118.2, 'depth': 1, 'mag': 6,
             'id': '', 'locstring': '', 'type': 'U', 'mech':'RS',
             'rake':90, 'timezone': 'UTC'}
    origin = Origin(event)

    gmpelist = ["Primate"]
    with pytest.raises(Exception) as e:
        dists = Distance.fromSites(gmpelist, origin, site, rup)

    gmpelist = [AbrahamsonEtAl2014()]
    sctx = site.getSitesContext()
    dist_types = ['repi', 'rhypo', 'rjb', 'rrup', 'rx', 'ry', 'ry0', 'U', 'V']
    with pytest.raises(Exception) as e:
        dists = get_distance(dist_types, sctx.lats, sctx.lons,
                             np.zeros_like(sctx.lons), rup)

    dist_types = ['repi', 'rhypo', 'rjb', 'rrup', 'rx', 'ry', 'ry0', 'U', 'T']
    with pytest.raises(Exception) as e:
        dists = get_distance(dist_types, sctx.lats, sctx.lons[0:4,],
                             np.zeros_like(sctx.lons), rup)
Example #3
0
def test_exceptions():
    vs30file = os.path.join(shakedir, 'tests/data/Vs30_test.grd')
    cx = -118.2
    cy = 34.1
    dx = 0.0083
    dy = 0.0083
    xspan = 0.0083 * 5
    yspan = 0.0083 * 5
    site = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                                  vs30File=vs30file,
                                  padding=True, resample=False)
    # Make souce instance
    lat0 = np.array([34.1])
    lon0 = np.array([-118.2])
    lat1 = np.array([34.2])
    lon1 = np.array([-118.15])
    z = np.array([1.0])
    W = np.array([3.0])
    dip = np.array([30.])

    flt = Fault.fromTrace(lon0, lat0, lon1, lat1, z, W, dip)
    event = {'lat': 34.1, 'lon': -118.2, 'depth': 1, 'mag': 6,
             'id': '', 'locstring': '', 'type': 'U', 'mech':'RS',
             'rake':90,
             'time': ShakeDateTime.utcfromtimestamp(int(time.time())),
             'timezone': 'UTC'}
    source = Source(event, flt)

    gmpelist = ["Primate"]
    with pytest.raises(Exception) as e:
        dists = Distance.fromSites(gmpelist, source, site)

    gmpelist = [AbrahamsonEtAl2014()]
    sctx = site.getSitesContext()
    dist_types = ['repi', 'rhypo', 'rjb', 'rrup', 'rx', 'ry', 'ry0', 'U', 'V']
    with pytest.raises(Exception) as e:
        dists = get_distance(dist_types, sctx.lats, sctx.lons,
                             np.zeros_like(sctx.lons), source)

    dist_types = ['repi', 'rhypo', 'rjb', 'rrup', 'rx', 'ry', 'ry0', 'U', 'T']
    with pytest.raises(Exception) as e:
        dists = get_distance(dist_types, sctx.lats, sctx.lons[0:4,],
                             np.zeros_like(sctx.lons), source)
Example #4
0
def test_virtualipe():

    #
    # Set up the GMPE, IPE, and GMICE
    #
    gmpe_cy14 = ChiouYoungs2014()
    gmpe = MultiGMPE.from_list([gmpe_cy14], [1.0])
    gmice = WGRW12()
    ipe = VirtualIPE.fromFuncs(gmpe, gmice)

    #
    # Use the Calexico event info
    #
    homedir = os.path.dirname(os.path.abspath(__file__))
    datadir = os.path.abspath(os.path.join(homedir, '..', 'data',
            'eventdata', 'Calexico', 'input'))

    #
    # Read the event, origin, and rupture files and produce Rupture and Origin
    # objects
    #
    inputfile = os.path.join(datadir, 'stationlist_dat.xml')
    dyfifile = os.path.join(datadir, 'ciim3_dat.xml')
    eventfile = os.path.join(datadir, 'event.xml')
    rupturefile = os.path.join(datadir, 'wei_fault.txt')

    origin_obj = Origin.fromFile(eventfile)
    rupture_obj = read_rupture_file(origin_obj, rupturefile)
    rx = rupture_obj.getRuptureContext([gmpe])
    rx.rake = 45.

    smdx = 0.0083333333
    smdy = 0.0083333333
    lonspan = 6.0
    latspan = 4.0
    vs30filename = os.path.join(datadir, '..', 'vs30', 'vs30.grd')

    sites_obj_grid = Sites.fromCenter(
            rx.hypo_lon, rx.hypo_lat, lonspan, latspan,
            smdx, smdy, defaultVs30=760.0, vs30File=vs30filename,
            vs30measured_grid=None, padding=False, resample=False
        )

    npts = 200
    lats = np.empty(npts)
    lons = np.empty(npts)
    depths = np.zeros(npts)
    for i in range(npts):
        lats[i] = rx.hypo_lat
        lons[i] = rx.hypo_lon + i * 0.01
    lldict = {'lats': lats, 'lons': lons}

    sx = sites_obj_grid.getSitesContext(lldict=lldict, rock_vs30=760.0)

    dobj = Distance(gmpe, lons, lats, depths, rupture_obj)
    dx = dobj.getDistanceContext()

    sd_types = [oqconst.StdDev.TOTAL]
    mmi_const_vs30, mmi_sd_const_vs30 = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)

# These prints are just so a human can examine the outputs
#    print(mmi_const_vs30)
#    print(mmi_sd_const_vs30)

    sx = sites_obj_grid.getSitesContext(lldict=lldict)
    mmi_variable_vs30, mmi_sd_variable_vs30 = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)

#    print(mmi_variable_vs30)
#    print(mmi_sd_variable_vs30)

    sd_types = [oqconst.StdDev.TOTAL, oqconst.StdDev.INTRA_EVENT, 
                oqconst.StdDev.INTER_EVENT]
    mmi_variable_vs30_intra, mmi_sd_variable_vs30_intra = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)

#    print(mmi_variable_vs30_intra)
#    print(mmi_sd_variable_vs30_intra)
#    assert(0)      # Assert causes test to fail and prints to be displayed

    #
    # Try with PGA
    #
    gmpe.DEFINED_FOR_INTENSITY_MEASURE_TYPES.remove(PGV)
    gmpe.ALL_GMPES_HAVE_PGV = False
    ipe = VirtualIPE.fromFuncs(gmpe, gmice)
    mmi_pga, mmi_sd_pga = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)
    #
    # Try with SA(1.0)
    #
    gmpe.DEFINED_FOR_INTENSITY_MEASURE_TYPES.remove(PGA)
    ipe = VirtualIPE.fromFuncs(gmpe, gmice)
    mmi_psa, mmi_sd_psa = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)

    #
    # This should raise an exception because the IMT isn't MMI
    #
    with pytest.raises(ValueError) as e:
        mmi_psa, mmi_sd_psa = \
                ipe.get_mean_and_stddevs(sx, rx, dx, PGA(), sd_types)
    #
    # This should raise an exception because no valid IMTs are available
    #
    gmpe.DEFINED_FOR_INTENSITY_MEASURE_TYPES.remove(SA)
    with pytest.raises(ShakeMapException) as e:
        ipe = VirtualIPE.fromFuncs(gmpe, gmice)

    #
    # Now do a GMPE that uses Rjb instead of Rrup
    #
    gmpe_ba14 = BooreEtAl2014()
    gmpe = MultiGMPE.from_list([gmpe_ba14], [1.0])
    ipe = VirtualIPE.fromFuncs(gmpe, gmice)
    rx = rupture_obj.getRuptureContext([gmpe])
    rx.rake = 45.
    dobj = Distance(gmpe, lons, lats, depths, rupture_obj)
    dx = dobj.getDistanceContext()

    mmi_rjb, mmi_sd_rjb = \
            ipe.get_mean_and_stddevs(sx, rx, dx, MMI(), sd_types)
    
    #
    # Test the results against a known standard
    #
    savefile = os.path.abspath(os.path.join(homedir, '..', 'data',
            'eventdata', 'Calexico', 'virtualipe_test', 'savefile.npz'))

    #
    # If things change, set remake_save to True, and it will rebuild the
    # saved data file against which the comparisons are done
    # Remember to set this back to False once you've remade the test datafile
    #
    remake_save = False
    if remake_save:
        np.savez_compressed(savefile,
                mmi_const_vs30 = mmi_const_vs30,
                mmi_sd_const_vs30 = mmi_sd_const_vs30[0],
                mmi_variable_vs30 = mmi_variable_vs30,
                mmi_sd_variable_vs30 = mmi_sd_variable_vs30[0],
                mmi_variable_vs30_intra = mmi_variable_vs30_intra,
                mmi_sd_variable_vs30_total = mmi_sd_variable_vs30_intra[0],
                mmi_sd_variable_vs30_intra = mmi_sd_variable_vs30_intra[1],
                mmi_sd_variable_vs30_inter = mmi_sd_variable_vs30_intra[2],
                mmi_pga = mmi_pga,
                mmi_sd_pga = mmi_sd_pga[0],
                mmi_psa = mmi_psa,
                mmi_sd_psa = mmi_sd_psa[0],
                mmi_rjb = mmi_rjb,
                mmi_sd_rjb = mmi_sd_rjb[0])

    td = np.load(savefile)

    assert(np.allclose(td['mmi_const_vs30'], mmi_const_vs30))
    assert(np.allclose(td['mmi_sd_const_vs30'], mmi_sd_const_vs30[0]))
    assert(np.allclose(td['mmi_variable_vs30'], mmi_variable_vs30))
    assert(np.allclose(td['mmi_sd_variable_vs30'], mmi_sd_variable_vs30[0]))
    assert(np.allclose(td['mmi_variable_vs30_intra'], mmi_variable_vs30_intra))
    assert(np.allclose(td['mmi_sd_variable_vs30_total'], 
        mmi_sd_variable_vs30_intra[0]))
    assert(np.allclose(td['mmi_sd_variable_vs30_intra'], 
        mmi_sd_variable_vs30_intra[1]))
    assert(np.allclose(td['mmi_sd_variable_vs30_inter'], 
        mmi_sd_variable_vs30_intra[2]))
    assert(np.allclose(td['mmi_pga'], mmi_pga))
    assert(np.allclose(td['mmi_sd_pga'], mmi_sd_pga[0]))
    assert(np.allclose(td['mmi_psa'], mmi_psa))
    assert(np.allclose(td['mmi_sd_psa'], mmi_sd_psa[0]))
    assert(np.allclose(td['mmi_rjb'], mmi_rjb))
    assert(np.allclose(td['mmi_sd_rjb'], mmi_sd_rjb[0]))

    # The total uncertainties should be greater than the intra-event
    assert(np.all(mmi_sd_variable_vs30[0] > mmi_sd_variable_vs30_intra[1]))

    # The combined intra and inter-event uncertainty should be equal
    # to the total
    tot = np.sqrt(mmi_sd_variable_vs30_intra[1]**2 + mmi_sd_variable_vs30_intra[2]**2)
    assert(np.allclose(tot, mmi_sd_variable_vs30_intra[0], rtol=1e-2))
Example #5
0
def test_sites(vs30file=None):
    vs30file = os.path.join(shakedir, 'tests/data/Vs30_test.grd')
    cx = -118.2
    cy = 34.1
    dx = 0.0083
    dy = 0.0083
    xspan = 0.0083 * 5
    yspan = 0.0083 * 5
    mysite = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                                    vs30File=vs30file, padding=True,
                                    resample=False)
    grd = mysite.getVs30Grid().getData()
    grd_target = np.array([[ 426.64892578,  398.89712524,  428.88549805,  428.78335571,
         428.58578491,  430.54354858,  433.59750366],
       [ 426.20635986,  425.57946777,  428.21954346,  426.06726074,
         421.86233521,  423.53192139,  426.25296021],
       [ 428.14602661,  430.05944824,  429.3427124 ,  426.13626099,
         409.76391602,  383.07299805,  372.39117432],
       [ 432.64077759,  434.55209351,  432.21600342,  395.53771973,
         419.31866455,  421.67749023,  426.23449707],
       [ 345.14605713,  403.78097534,  385.49118042,  413.04779053,
         428.22869873,  427.00268555,  426.8951416 ],
       [ 336.48217773,  347.82220459,  425.96798706,  432.0640564 ,
         429.40097046,  427.74179077,  427.00006104],
       [ 330.57504272,  392.33255005,  430.33862305,  432.01391602,
         429.43969727,  427.30435181,  425.96151733]])
    np.testing.assert_allclose(grd, grd_target)

    sc = mysite.getSitesContext()
    scr = mysite.getSitesContext(rock_vs30 = 760.0)

    grd = sc.backarc
    grdt = np.array([[False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False]], dtype=bool)
    np.testing.assert_allclose(grd, grdt)

    grd = sc.lats
    grdt = np.array([ 34.075     ,  34.08333333,  34.09166667,  34.1       ,
        34.10833333,  34.11666667,  34.125     ])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.lons
    grdt = np.array([-118.225     , -118.21666667, -118.20833333, -118.2       ,
       -118.19166667, -118.18333333, -118.175     ])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.vs30
    grdt = np.array([[ 426.64892578,  398.89712524,  428.88549805,  428.78335571,
         428.58578491,  430.54354858,  433.59750366],
       [ 426.20635986,  425.57946777,  428.21954346,  426.06726074,
         421.86233521,  423.53192139,  426.25296021],
       [ 428.14602661,  430.05944824,  429.3427124 ,  426.13626099,
         409.76391602,  383.07299805,  372.39117432],
       [ 432.64077759,  434.55209351,  432.21600342,  395.53771973,
         419.31866455,  421.67749023,  426.23449707],
       [ 345.14605713,  403.78097534,  385.49118042,  413.04779053,
         428.22869873,  427.00268555,  426.8951416 ],
       [ 336.48217773,  347.82220459,  425.96798706,  432.0640564 ,
         429.40097046,  427.74179077,  427.00006104],
       [ 330.57504272,  392.33255005,  430.33862305,  432.01391602,
         429.43969727,  427.30435181,  425.96151733]])
    np.testing.assert_allclose(grd, grdt)

    grd = scr.vs30
    grdt = np.array([[ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.],
       [ 760.,  760.,  760.,  760.,  760.,  760.,  760.]])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.vs30measured
    grdt = np.array([[False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False]], dtype=bool)
    np.testing.assert_allclose(grd, grdt)

    grd = sc.z1pt0_ask14_cal
    grdt = np.array([[ 335.06579012,  366.39725582,  332.4593083 ,  332.57855835,
         332.80916279,  330.52077553,  326.93706615],
       [ 335.58036296,  336.30856215,  333.23643861,  335.74201097,
         340.60915547,  338.68122322,  335.52619949],
       [ 333.32217548,  331.08730312,  331.92526979,  335.66183031,
         354.37798647,  383.19730994,  394.00166561],
       [ 328.06152136,  325.81357093,  328.56025522,  370.03738338,
         343.53423548,  340.82221914,  335.54765968],
       [ 419.3225465 ,  361.03999163,  380.68893324,  350.67806177,
         333.2257608 ,  334.65418562,  334.77934134],
       [ 426.64586941,  416.9870982 ,  335.85735317,  328.73858131,
         331.85719411,  333.79341356,  334.65724021],
       [ 431.42758271,  373.4746626 ,  330.76064671,  328.79741743,
         331.81193751,  334.30299304,  335.86486938]])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.z1pt0_cy08
    grdt = np.array([[ 183.2043947 ,  217.27787758,  180.56690603,  180.68687904,
         180.91907101,  178.625999  ,  175.08452094],
       [ 183.72884833,  184.47314285,  181.34994816,  183.89385557,
         188.91901585,  186.91536614,  183.67358657],
       [ 181.43651087,  179.19139187,  180.03044953,  183.81199342,
         203.71493023,  237.03939223,  250.05192732],
       [ 176.18920323,  173.98674225,  176.68107716,  221.49002942,
         191.99154431,  189.14149784,  183.69548028],
       [ 280.25774719,  211.16371072,  234.04298229,  199.65723106,
         181.33916991,  182.78577761,  182.91298179],
       [ 288.5669674 ,  277.54780981,  184.01166928,  176.85723522,
         179.96216197,  181.91290358,  182.78888133],
       [ 293.80330679,  225.506479  ,  178.86520526,  176.91538893,
         179.91677656,  182.42922842,  184.01934871]])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.z1pt0_cy14_cal
    grdt = np.array([[ 322.09231215,  357.07647045,  319.22097485,  319.3522119 ,
         319.60603217,  317.08933532,  313.15733537],
       [ 322.65987959,  323.46347258,  320.07644714,  322.83822344,
         328.21884905,  326.08502532,  322.60012698],
       [ 320.17085962,  317.71195569,  318.63340828,  322.74975843,
         343.55342441,  376.19315199,  388.62006436],
       [ 314.38985785,  311.92697475,  314.93687894,  361.19727923,
         331.46256533,  328.4548676 ,  322.62380134],
       [ 418.15243574,  351.03313981,  373.32295288,  339.41631214,
         320.0646893 ,  321.63848529,  321.7764637 ],
       [ 426.80110483,  415.40447342,  322.96549285,  315.13252356,
         318.55852723,  320.68989724,  321.64185267],
       [ 432.47426567,  365.09924657,  317.35292206,  315.19707981,
         318.50874868,  321.25138528,  322.9737867 ]])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.z2pt5_cb07
    grdt = np.array([[ 1177.61979893,  1300.11396989,  1168.13802718,  1168.56933015,
         1169.4040603 ,  1161.16046639,  1148.4288528 ],
       [ 1179.50520975,  1182.18094855,  1170.95306363,  1180.09841078,
         1198.16386197,  1190.96074128,  1179.30654372],
       [ 1171.26425658,  1163.19305376,  1166.20946607,  1179.80411634,
         1251.35517419,  1371.15661506,  1417.9366787 ],
       [ 1152.40018562,  1144.48233838,  1154.16847239,  1315.25665576,
         1209.20960179,  1198.96368474,  1179.3852516 ],
       [ 1526.52660116,  1278.13354004,  1360.38452132,  1236.76774567,
         1170.91431583,  1176.11487052,  1176.57216955],
       [ 1556.3982478 ,  1516.78437627,  1180.52195107,  1154.8017606 ,
         1165.96397227,  1172.97688837,  1176.12602836],
       [ 1575.22288791,  1329.69579201,  1162.02041292,  1155.01082322,
         1165.80081172,  1174.83307617,  1180.5495586 ]])
    np.testing.assert_allclose(grd, grdt)

    grd = sc.z2pt5_cb14_cal
    grdt = np.array([[ 1.17466154,  1.26861168,  1.1676564 ,  1.16797461,  1.16859058,
         1.16251358,  1.15315136],
       [ 1.17605704,  1.17803908,  1.16973403,  1.17649629,  1.18992131,
         1.18455663,  1.17590996],
       [ 1.16996381,  1.16401074,  1.166234  ,  1.17627836,  1.230198  ,
         1.32873844,  1.37243028],
       [ 1.15606906,  1.15025389,  1.15736893,  1.2809454 ,  1.19818264,
         1.19051805,  1.17596823],
       [ 1.49705669,  1.25107322,  1.31920733,  1.21901552,  1.16970542,
         1.1735483 ,  1.17388652],
       [ 1.54123541,  1.48388699,  1.17680997,  1.15783457,  1.16605299,
         1.17122878,  1.17355655],
       [ 1.57278236,  1.29292406,  1.1631469 ,  1.1579883 ,  1.16593269,
         1.17260055,  1.17683042]])
    np.testing.assert_allclose(grd, grdt)

    lldict = {'lats':np.array([34.1, 34.111]),
              'lons':np.array([-118.2, -118.222])}
    scsamp = mysite.getSitesContext(lldict)

    vs30 = scsamp.vs30
    vs30t = np.array([ 395.53771973,  428.14602661])
    np.testing.assert_allclose(vs30, vs30t)

    lldict = {'lats':np.array([34.1, 34.111]),
              'lons':np.array([-118.2, -118.222])}
    scrsamp = mysite.getSitesContext(lldict, rock_vs30=760)
    vs30 = scrsamp.vs30
    vs30t = np.array([ 760.,  760.])
    np.testing.assert_allclose(vs30, vs30t)
    

    lats = np.array([34.1, 34.111])
    lons = np.array([-118.2, -118.222])
    lldict = {'lats':lats, 'lons':lons}
    scsamp = mysite.getSitesContext(lldict)
    grd = scsamp.vs30measured
    grdt = np.array([False, False], dtype=bool)
    np.testing.assert_allclose(grd, grdt)

    with pytest.raises(Exception) as e:
        scsamp = mysite.getSitesContextFromLatLon(
            np.array([34.1, 34.111, 34.5]),
            np.array([-118.2, -118.222]))

    mysite = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                                    vs30File=None, padding=True,
                                    resample=False)
    grd = mysite.getVs30Grid().getData()
    grd_target = np.array(
      [[ 686.,  686.,  686.,  686.,  686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.]])
    np.testing.assert_allclose(grd, grd_target)

    xmin = -118.2
    xmax = -118.12
    ymin = 34.05
    ymax = 34.1
    dx = 0.0083
    dy = 0.0083
    mysite = Sites.fromBounds(xmin, xmax, ymin, ymax, dx, dy,
                                    vs30File=vs30file, padding=False,
                                    resample=False)
    grd = mysite.getVs30Grid().getData()
    grd_target = np.array([[ 395.53771973,  419.31866455,  421.67749023,  426.23449707,
         427.32818604,  424.84860229,  415.17590332,  407.5760498 ,
         404.54788208,  402.28500366],
       [ 413.04779053,  428.22869873,  427.00268555,  426.8951416 ,
         425.62023926,  419.60952759,  411.7961731 ,  407.53509521,
         406.22122192,  405.31622314],
       [ 432.0640564 ,  429.40097046,  427.74179077,  427.00006104,
         419.5062561 ,  411.10830688,  407.48901367,  406.53305054,
         406.59658813,  406.24887085],
       [ 432.01391602,  429.43969727,  427.30435181,  425.96151733,
         426.15856934,  427.56121826,  397.67102051,  399.21054077,
         404.54968262,  407.18515015],
       [ 426.76913452,  428.86270142,  425.99606323,  423.5692749 ,
         423.59835815,  425.92758179,  408.44885254,  406.55810547,
         409.06945801,  413.75210571],
       [ 423.1892395 ,  427.91104126,  424.53796387,  419.47485352,
         418.177948  ,  424.14065552,  428.57913208,  432.95300293,
         427.77731323,  431.46524048],
       [ 410.56729126,  423.15557861,  424.48355103,  419.27658081,
         418.60211182,  423.86721802,  428.06176758,  432.42089844,
         438.54446411,  448.37237549]])
    np.testing.assert_allclose(grd, grd_target)

    mysite = Sites.fromBounds(xmin, xmax, ymin, ymax, dx, dy,
                                    vs30File=None, padding=False,
                                    resample=False)
    grd = mysite.getVs30Grid().getData()
    grd_target = np.array([[ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.],
       [ 686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,  686.,
         686.,  686.]])
    np.testing.assert_allclose(grd, grd_target)
Example #6
0
def test_distance_from_sites_origin():
    # Make sites instance
    vs30file = os.path.join(shakedir, 'tests/data/Vs30_test.grd')
    cx = -118.2
    cy = 34.1
    dx = 0.0083
    dy = 0.0083
    xspan = 0.0083 * 5
    yspan = 0.0083 * 5
    site = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                            vs30File=vs30file,
                            padding=True, resample=False)
    # Make souce instance
    lat0 = np.array([34.1])
    lon0 = np.array([-118.2])
    lat1 = np.array([34.2])
    lon1 = np.array([-118.15])
    z = np.array([1.0])
    W = np.array([3.0])
    dip = np.array([30.])

    event = {'lat': 34.1, 'lon': -118.2, 'depth': 1, 'mag': 6,
             'id': '', 'locstring': '', 'type': 'ALL',
             'timezone': 'UTC'}
    origin = Origin(event)

    rup = QuadRupture.fromTrace(lon0, lat0, lon1, lat1, z, W, dip, origin)
    gmpelist = [AbrahamsonEtAl2014(), BergeThierryEtAl2003SIGMA()]
    dists = Distance.fromSites(gmpelist, site, rup)
    dctx = dists.getDistanceContext()

    rhypo = np.array([[ 3.74498133,  3.32896405,  3.05225679,  2.95426722,  3.05225679,
         3.32896405,  3.74498133],
       [ 3.11965436,  2.60558436,  2.24124201,  2.10583262,  2.24124201,
         2.60558436,  3.11965436],
       [ 2.67523213,  2.05265767,  1.564393  ,  1.36331682,  1.564393  ,
         2.05265767,  2.67523213],
       [ 2.50973226,  1.83166664,  1.26045653,  1.        ,  1.26045653,
         1.83166664,  2.50973226],
       [ 2.67542717,  2.05277065,  1.56443006,  1.36331682,  1.56443006,
         2.05277065,  2.67542717],
       [ 3.11998886,  2.60576236,  2.24129374,  2.10583262,  2.24129374,
         2.60576236,  3.11998886],
       [ 3.74539929,  3.32917303,  3.05231378,  2.95426722,  3.05231378,
         3.32917303,  3.74539929]])
    np.testing.assert_allclose(
        rhypo, dctx.rhypo, rtol=0, atol=0.01)

    rx = np.array([[ -3.18894050e+00,  -2.48001769e+00,  -1.77111874e+00,
         -1.06224366e+00,  -3.53392480e-01,   3.55434794e-01,
          1.06423815e+00],
       [ -2.83506890e+00,  -2.12607622e+00,  -1.41710740e+00,
         -7.08162466e-01,   7.58576362e-04,   7.09655709e-01,
          1.41852892e+00],
       [ -2.48119723e+00,  -1.77213470e+00,  -1.06309603e+00,
         -3.54081243e-01,   3.54909645e-01,   1.06387662e+00,
          1.77281967e+00],
       [ -2.12732550e+00,  -1.41819312e+00,  -7.09084619e-01,
          2.56774082e-12,   7.09060719e-01,   1.41809752e+00,
          2.12711040e+00],
       [ -1.77345370e+00,  -1.06425151e+00,  -3.55073182e-01,
          3.54081255e-01,   1.06321179e+00,   1.77231841e+00,
          2.48140110e+00],
       [ -1.41958186e+00,  -7.10309855e-01,  -1.06172493e-03,
          7.08162516e-01,   1.41736285e+00,   2.12653927e+00,
          2.83569175e+00],
       [ -1.06570997e+00,  -3.56368176e-01,   3.52949744e-01,
          1.06224377e+00,   1.77151390e+00,   2.48076010e+00,
          3.18998236e+00]])

    np.testing.assert_allclose(
        rx, dctx.rx, rtol=0, atol=0.01)

    rjb = np.array([[  3.19372137e+00,   2.48373511e+00,   1.77377308e+00,
          1.06383562e+00,   3.53925643e-01,   2.25816823e-03,
          2.45009861e-03],
       [  2.83931844e+00,   2.12926243e+00,   1.41923064e+00,
          7.09223517e-01,   1.57594916e-03,   1.86044244e-03,
          2.05239165e-03],
       [  2.48510934e+00,   1.77479025e+00,   1.06468863e+00,
          3.54611655e-01,   1.04375185e-03,   1.32827303e-03,
          1.52024106e-03],
       [  2.30690967e+00,   1.53793979e+00,   7.68969896e-01,
          5.88918451e-12,   3.77111295e-04,   6.61660373e-04,
          8.53647223e-04],
       [  2.48531877e+00,   1.79442084e+00,   1.20242597e+00,
          8.54793253e-01,   5.62052963e-01,   2.69254693e-01,
          5.26105100e-05],
       [  2.95646628e+00,   2.40489915e+00,   2.00231070e+00,
          1.70958533e+00,   1.41681634e+00,   1.12398937e+00,
          8.63761551e-01],
       [  3.60741953e+00,   3.17112489e+00,   2.85711592e+00,
          2.56437623e+00,   2.27157856e+00,   1.97872291e+00,
          1.78518260e+00]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    ry0 = np.array([[  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00],
       [  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00],
       [  2.29490054e-02,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00],
       [  8.79341006e-01,   5.86285236e-01,   2.93171565e-01,
          6.21003581e-12,   0.00000000e+00,   0.00000000e+00,
          0.00000000e+00],
       [  1.73573289e+00,   1.44264826e+00,   1.14950573e+00,
          8.56305300e-01,   5.63046975e-01,   2.69730762e-01,
          0.00000000e+00],
       [  2.59212463e+00,   2.29901116e+00,   2.00583977e+00,
          1.71261048e+00,   1.41932329e+00,   1.12597821e+00,
          8.32575235e-01],
       [  3.44851622e+00,   3.15537391e+00,   2.86217367e+00,
          2.56891553e+00,   2.27559947e+00,   1.98222553e+00,
          1.68879368e+00]])

    np.testing.assert_allclose(
        ry0, dctx.ry0, rtol=0, atol=0.01)

    rrup = np.array([[ 3.34678672,  2.67788811,  2.03697073,  1.46129187,  1.06271102,
         1.06352692,  1.40073832],
       [ 3.01030105,  2.3526499 ,  1.73673635,  1.22706347,  1.00157564,
         1.22283363,  1.57764099],
       [ 2.67858182,  2.03712377,  1.46095502,  1.06170931,  1.06220616,
         1.39958479,  1.75442695],
       [ 2.51415965,  1.8343632 ,  1.26143652,  1.        ,  1.2212501 ,
         1.57621925,  1.9310962 ],
       [ 2.67877609,  2.05412785,  1.56384179,  1.3617346 ,  1.50608502,
         1.77308319,  2.10764873],
       [ 3.12078859,  2.6043486 ,  2.23799413,  2.09885629,  2.11696797,
         2.23191013,  2.4299612 ],
       [ 3.74318473,  3.32482368,  3.04635272,  2.9183523 ,  2.86659485,
         2.88815116,  2.98141559]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)
Example #7
0
def test_distance_no_rupture():
    event = {'lat': 34.1, 'lon': -118.2, 'depth': 1, 'mag': 6,
             'id': '', 'locstring': '', 'timezone': 'UTC'}
    origin = Origin(event)
    origin.setMechanism('ALL')
    # Make sites instance
    vs30file = os.path.join(shakedir, 'tests/data/Vs30_test.grd')
    cx = -118.2
    cy = 34.1
    dx = 0.0083
    dy = 0.0083
    xspan = 0.0083 * 5
    yspan = 0.0083 * 5
    site = Sites.fromCenter(cx, cy, xspan, yspan, dx, dy,
                            vs30File=vs30file,
                            padding=True, resample=False)
    # Make souce instance
    #  - Unknown/no tectonic region
    #  - Mech is ALL

    gmpe = AbrahamsonEtAl2014()
    rupture = PointRupture(origin)
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.03475736,  0.82507289,  0.69891123,  0.6553167 ,  0.69891123,
                      0.82507289,  1.03475736],
                    [ 0.72918893,  0.50725874,  0.36675284,  0.31957002,  0.36675284,
                        0.50725874,  0.72918893],
                    [ 0.53487557,  0.30135487,  0.14776055,  0.09290799,  0.14776055,
                      0.30135487,  0.53487557],
                    [ 0.46963915,  0.2280053 ,  0.06643829,  0.        ,  0.06643829,
                      0.2280053 ,  0.46963915],
                    [ 0.53495323,  0.30139344,  0.14777086,  0.09290799,  0.14777086,
                      0.30139344,  0.53495323],
                    [ 0.72933979,  0.50732902,  0.36677229,  0.31957002,  0.36677229,
                      0.50732902,  0.72933979],
                    [ 1.03497272,  0.82517579,  0.69893672,  0.6553167 ,  0.69893672,
                      0.82517579,  1.03497272]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 8.26004043,  8.11921658,  8.11376473,  8.09579991,  8.11376473,
                       8.11921658,  8.26004043],
                       [ 8.12023764,  8.01816823,  7.93517669,  7.9600631 ,  7.93517669,
                         8.01816823,  8.12023764],
                       [ 8.00702434,  7.95888951,  7.8881565 ,  7.88352525,  7.8881565 ,
                         7.95888951,  8.00702434],
                       [ 8.02022568,  7.90722113,  7.85639147,  0.        ,  7.85639147,
                         7.90722113,  8.02022568],
                         [ 8.00698213,  7.95890141,  7.88813785,  7.88352525,  7.88813785,
                           7.95890141,  8.00698213],
                           [ 8.12025813,  8.01814988,  7.93520725,  7.9600631 ,  7.93520725,
                             8.01814988,  8.12025813],
                             [ 8.26012423,  8.11931772,  8.1137722 ,  8.09579991,  8.1137722 ,
                               8.11931772,  8.26012423]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region unsupported
    #  - Mech is ALL
    origin._tectonic_region = 'Volcano'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()
    rjbt = np.array([[ 1.03475736,  0.82507289,  0.69891123,  0.6553167 ,  0.69891123,
         0.82507289,  1.03475736],
       [ 0.72918893,  0.50725874,  0.36675284,  0.31957002,  0.36675284,
         0.50725874,  0.72918893],
       [ 0.53487557,  0.30135487,  0.14776055,  0.09290799,  0.14776055,
         0.30135487,  0.53487557],
       [ 0.46963915,  0.2280053 ,  0.06643829,  0.        ,  0.06643829,
         0.2280053 ,  0.46963915],
       [ 0.53495323,  0.30139344,  0.14777086,  0.09290799,  0.14777086,
         0.30139344,  0.53495323],
       [ 0.72933979,  0.50732902,  0.36677229,  0.31957002,  0.36677229,
         0.50732902,  0.72933979],
       [ 1.03497272,  0.82517579,  0.69893672,  0.6553167 ,  0.69893672,
         0.82517579,  1.03497272]])
    np.testing.assert_allclose(
        rjbt, dctx.rjb, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: active
    #  - Mech is ALL

    origin.setMechanism('ALL')
    origin._tectonic_region = 'Active Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.10115976,  0.88331216,  0.75077594,  0.70491937,  0.75077594,
         0.88331216,  1.10115976],
       [ 0.78261273,  0.54865189,  0.39914713,  0.34852149,  0.39914713,
         0.54865189,  0.78261273],
       [ 0.57800579,  0.32895654,  0.16294131,  0.10290794,  0.16294131,
         0.32895654,  0.57800579],
       [ 0.50865092,  0.25000954,  0.07371315,  0.        ,  0.07371315,
         0.25000954,  0.50865092],
       [ 0.57808833,  0.32899797,  0.16295256,  0.10290794,  0.16295256,
         0.32899797,  0.57808833],
       [ 0.78277133,  0.5487266 ,  0.39916785,  0.34852149,  0.39916785,
         0.5487266 ,  0.78277133],
       [ 1.10138329,  0.88341918,  0.75080275,  0.70491937,  0.75080275,
         0.88341918,  1.10138329]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 8.72726953,  8.58534811,  8.58323541,  8.5654409 ,  8.58323541,
         8.58534811,  8.72726953],
       [ 8.58922774,  8.4871601 ,  8.40244887,  8.4297141 ,  8.40244887,
         8.4871601 ,  8.58922774],
       [ 8.47470803,  8.42880892,  8.35631312,  8.35201539,  8.35631312,
         8.42880892,  8.47470803],
       [ 8.49021276,  8.37536496,  8.32350188,  0.        ,  8.32350188,
         8.37536496,  8.49021276],
       [ 8.47466149,  8.42882081,  8.35629324,  8.35201539,  8.35629324,
         8.42882081,  8.47466149],
       [ 8.58924512,  8.48713903,  8.4024808 ,  8.4297141 ,  8.4024808 ,
         8.48713903,  8.58924512],
       [ 8.72735075,  8.58545174,  8.5832426 ,  8.5654409 ,  8.5832426 ,
         8.58545174,  8.72735075]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: active
    #  - Mech is RS

    origin.setMechanism('RS')
    origin._tectonic_region = 'Active Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 0.94405696,  0.73298036,  0.61025288,  0.56806407,  0.61025288,
         0.73298036,  0.94405696],
       [ 0.63960501,  0.42680989,  0.29738908,  0.25562246,  0.29738908,
         0.42680989,  0.63960501],
       [ 0.45239173,  0.23958848,  0.10874248,  0.06508855,  0.10874248,
         0.23958848,  0.45239173],
       [ 0.39203111,  0.17571632,  0.04480241,  0.        ,  0.04480241,
         0.17571632,  0.39203111],
       [ 0.45246373,  0.2396224 ,  0.1087508 ,  0.06508855,  0.1087508 ,
         0.2396224 ,  0.45246373],
       [ 0.63975135,  0.42687494,  0.29740691,  0.25562246,  0.29740691,
         0.42687494,  0.63975135],
       [ 0.94427453,  0.73308353,  0.61027758,  0.56806407,  0.61027758,
         0.73308353,  0.94427453]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 8.81700098,  8.67259556,  8.6707467 ,  8.65288076,  8.6707467 ,
         8.67259556,  8.81700098],
       [ 8.67672238,  8.57444747,  8.49014736,  8.5183922 ,  8.49014736,
         8.57444747,  8.67672238],
       [ 8.56159881,  8.51774523,  8.44708824,  8.44391005,  8.44708824,
         8.51774523,  8.56159881],
       [ 8.57788943,  8.46484058,  8.41567031,  0.        ,  8.41567031,
         8.46484058,  8.57788943],
       [ 8.56155103,  8.51775668,  8.44706792,  8.44391005,  8.44706792,
         8.51775668,  8.56155103],
       [ 8.67673955,  8.5744255 ,  8.49017946,  8.5183922 ,  8.49017946,
         8.5744255 ,  8.67673955],
       [ 8.81708413,  8.67270074,  8.67075389,  8.65288076,  8.67075389,
         8.67270074,  8.81708413]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: active
    #  - Mech is NM

    origin.setMechanism('NM')
    origin._tectonic_region = 'Active Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 0.7899535 ,  0.61128249,  0.50843465,  0.47310349,  0.50843465,
         0.61128249,  0.7899535 ],
       [ 0.53301769,  0.35495992,  0.24706995,  0.21231668,  0.24706995,
         0.35495992,  0.53301769],
       [ 0.37628889,  0.19897762,  0.09028387,  0.05409271,  0.09028387,
         0.19897762,  0.37628889],
       [ 0.32596438,  0.14586493,  0.03728933,  0.        ,  0.03728933,
         0.14586493,  0.32596438],
       [ 0.37634892,  0.19900584,  0.09029076,  0.05409271,  0.09029076,
         0.19900584,  0.37634892],
       [ 0.53314026,  0.35501415,  0.24708481,  0.21231668,  0.24708481,
         0.35501415,  0.53314026],
       [ 0.79013775,  0.61136979,  0.50845534,  0.47310349,  0.50845534,
         0.61136979,  0.79013775]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 7.94857792,  7.8097532 ,  7.80275055,  7.78489184,  7.80275055,
         7.8097532 ,  7.94857792],
       [ 7.80938707,  7.70839546,  7.62713392,  7.65061937,  7.62713392,
         7.70839546,  7.80938707],
       [ 7.69799123,  7.64933048,  7.58013644,  7.57530397,  7.58013644,
         7.64933048,  7.69799123],
       [ 7.7099614 ,  7.59905656,  7.54904995,  0.        ,  7.54904995,
         7.59905656,  7.7099614 ],
       [ 7.69795153,  7.64934225,  7.58011859,  7.57530397,  7.58011859,
         7.64934225,  7.69795153],
       [ 7.80940883,  7.70837861,  7.62716348,  7.65061937,  7.62716348,
         7.70837861,  7.80940883],
       [ 7.94866209,  7.80985208,  7.80275807,  7.78489184,  7.80275807,
         7.80985208,  7.94866209]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: active
    #  - Mech is SS

    origin.setMechanism('SS')
    origin._tectonic_region = 'Active Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 2.00333625,  1.69987873,  1.49778447,  1.42682201,  1.49778447,
         1.69987873,  2.00333625],
       [ 1.54679373,  1.17582687,  0.914992  ,  0.81812345,  0.914992  ,
         1.17582687,  1.54679373],
       [ 1.22626178,  0.78021345,  0.43426687,  0.29180829,  0.43426687,
         0.78021345,  1.22626178],
       [ 1.10672645,  0.62338097,  0.21787328,  0.        ,  0.21787328,
         0.62338097,  1.10672645],
       [ 1.22640328,  0.7802939 ,  0.43429295,  0.29180829,  0.43429295,
         0.7802939 ,  1.22640328],
       [ 1.54703738,  1.17595553,  0.9150287 ,  0.81812345,  0.9150287 ,
         1.17595553,  1.54703738],
       [ 2.00364385,  1.7000298 ,  1.49782584,  1.42682201,  1.49782584,
         1.7000298 ,  2.00364385]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 7.97494557,  7.79806013,  7.76281765,  7.735536  ,  7.76281765,
         7.79806013,  7.97494557],
       [ 7.77614524,  7.62644695,  7.5120851 ,  7.52225031,  7.5120851 ,
         7.62644695,  7.77614524],
       [ 7.62326525,  7.51608628,  7.40624352,  7.38577101,  7.40624352,
         7.51608628,  7.62326525],
       [ 7.61851685,  7.44728324,  7.35263272,  0.        ,  7.35263272,
         7.44728324,  7.61851685],
       [ 7.62324614,  7.51610811,  7.40622914,  7.38577101,  7.40622914,
         7.51610811,  7.62324614],
       [ 7.77620063,  7.62644821,  7.51211876,  7.52225031,  7.51211876,
         7.62644821,  7.77620063],
       [ 7.97507013,  7.798177  ,  7.76283076,  7.735536  ,  7.76283076,
         7.798177  ,  7.97507013]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: stable
    #  - Mech is all

    origin.setMechanism('ALL')
    origin._tectonic_region = 'Stable Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.25490086,  1.00456938,  0.85266727,  0.80013341,  0.85266727,
         1.00456938,  1.25490086],
       [ 0.8891456 ,  0.621322  ,  0.4507253 ,  0.39310934,  0.4507253 ,
         0.621322  ,  0.8891456 ],
       [ 0.65483395,  0.37085259,  0.18246645,  0.11472522,  0.18246645,
         0.37085259,  0.65483395],
       [ 0.57566287,  0.28111922,  0.08186392,  0.        ,  0.08186392,
         0.28111922,  0.57566287],
       [ 0.65492818,  0.37089972,  0.18247916,  0.11472522,  0.18247916,
         0.37089972,  0.65492818],
       [ 0.88932733,  0.62140729,  0.45074894,  0.39310934,  0.45074894,
         0.62140729,  0.88932733],
       [ 1.2551578 ,  1.00469232,  0.85269799,  0.80013341,  0.85269799,
         1.00469232,  1.2551578 ]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 6.37308879,  6.21401632,  6.17868645,  6.15460391,  6.17868645,
         6.21401632,  6.37308879],
       [ 6.19096821,  6.06108712,  5.96682577,  5.97487576,  5.96682577,
         6.06108712,  6.19096821],
       [ 6.05926472,  5.97000316,  5.88510619,  5.87109182,  5.88510619,
         5.97000316,  6.05926472],
       [ 6.05384337,  5.91573235,  5.84608701,  0.        ,  5.84608701,
         5.91573235,  6.05384337],
       [ 6.05925153,  5.97002045,  5.88509436,  5.87109182,  5.88509436,
         5.97002045,  6.05925153],
       [ 6.1910207 ,  6.0610899 ,  5.96685295,  5.97487576,  5.96685295,
         6.0610899 ,  6.1910207 ],
       [ 6.37320723,  6.21411804,  6.17869829,  6.15460391,  6.17869829,
         6.21411804,  6.37320723]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: stable
    #  - Mech is RS

    origin.setMechanism('RS')
    origin._tectonic_region = 'Stable Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.06775489,  0.83169032,  0.69344486,  0.645892  ,  0.69344486,
         0.83169032,  1.06775489],
       [ 0.72652464,  0.48639585,  0.33959401,  0.2920419 ,  0.33959401,
         0.48639585,  0.72652464],
       [ 0.51540522,  0.27378007,  0.12450057,  0.07451822,  0.12450057,
         0.27378007,  0.51540522],
       [ 0.44695345,  0.20099496,  0.05123817,  0.        ,  0.05123817,
         0.20099496,  0.44695345],
       [ 0.51548687,  0.2738187 ,  0.12451008,  0.07451822,  0.12451008,
         0.2738187 ,  0.51548687],
       [ 0.72668956,  0.48646962,  0.33961424,  0.2920419 ,  0.33961424,
         0.48646962,  0.72668956],
       [ 1.06799812,  0.83180576,  0.6934727 ,  0.645892  ,  0.6934727 ,
         0.83180576,  1.06799812]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 6.34187696,  6.18689857,  6.15537676,  6.13263668,  6.15537676,
         6.18689857,  6.34187696],
       [ 6.1667275 ,  6.04409157,  5.9555343 ,  5.96586226,  5.9555343 ,
         6.04409157,  6.1667275 ],
       [ 6.04113522,  5.96186983,  5.88482917,  5.87387645,  5.88482917,
         5.96186983,  6.04113522],
       [ 6.03838637,  5.91117189,  5.85034216,  0.        ,  5.85034216,
         5.91117189,  6.03838637],
       [ 6.04111884,  5.96188527,  5.88481675,  5.87387645,  5.88481675,
         5.96188527,  6.04111884],
       [ 6.16677535,  6.04409147,  5.9555607 ,  5.96586226,  5.9555607 ,
         6.04409147,  6.16677535],
       [ 6.34199129,  6.18699823,  6.15538781,  6.13263668,  6.15538781,
         6.18699823,  6.34199129]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: stable
    #  - Mech is NM

    origin.setMechanism('NM')
    origin._tectonic_region = 'Stable Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.11595412,  0.87047978,  0.72608143,  0.6763976 ,  0.72608143,
         0.87047978,  1.11595412],
       [ 0.7606424 ,  0.50965507,  0.35594865,  0.30612448,  0.35594865,
         0.50965507,  0.7606424 ],
       [ 0.5400275 ,  0.28698884,  0.13052973,  0.0781228 ,  0.13052973,
         0.28698884,  0.5400275 ],
       [ 0.46835876,  0.21071547,  0.05370847,  0.        ,  0.05370847,
         0.21071547,  0.46835876],
       [ 0.54011298,  0.28702933,  0.1305397 ,  0.0781228 ,  0.1305397 ,
         0.28702933,  0.54011298],
       [ 0.76081471,  0.50973231,  0.35596982,  0.30612448,  0.35596982,
         0.50973231,  0.76081471],
       [ 1.116207  ,  0.87059985,  0.72611052,  0.6763976 ,  0.72611052,
         0.87059985,  1.116207  ]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 6.09163676,  5.92783781,  5.88815939,  5.8632258 ,  5.88815939,
         5.92783781,  6.09163676],
       [ 5.9012656 ,  5.76798442,  5.67370059,  5.68021406,  5.67370059,
         5.76798442,  5.9012656 ],
       [ 5.76720934,  5.67516593,  5.59187321,  5.57813972,  5.59187321,
         5.67516593,  5.76720934],
       [ 5.75981247,  5.62205686,  5.55427369,  0.        ,  5.55427369,
         5.62205686,  5.75981247],
       [ 5.76719951,  5.67518325,  5.59186206,  5.57813972,  5.59186206,
         5.67518325,  5.76719951],
       [ 5.90132265,  5.76798949,  5.67372705,  5.68021406,  5.67372705,
         5.76798949,  5.90132265],
       [ 6.09176251,  5.92794056,  5.88817184,  5.8632258 ,  5.88817184,
         5.92794056,  6.09176251]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)

    # Souce instance
    #  - Tectonic region: stable
    #  - Mech is SS

    origin.setMechanism('SS')
    origin._tectonic_region = 'Stable Shallow Crust'
    dists = Distance.fromSites(gmpe, site, rupture)
    dctx = dists.getDistanceContext()

    rjb = np.array([[ 1.7978181 ,  1.48474703,  1.28392745,  1.21396452,  1.28392745,
         1.48474703,  1.7978181 ],
       [ 1.3323943 ,  0.97123526,  0.72919945,  0.64364445,  0.72919945,
         0.97123526,  1.3323943 ],
       [ 1.01846151,  0.61039475,  0.3191157 ,  0.20751973,  0.3191157 ,
         0.61039475,  1.01846151],
       [ 0.90673813,  0.47477623,  0.15160737,  0.        ,  0.15160737,
         0.47477623,  0.90673813],
       [ 1.01859418,  0.61046522,  0.3191364 ,  0.20751973,  0.3191364 ,
         0.61046522,  1.01859418],
       [ 1.33263554,  0.97135557,  0.72923321,  0.64364445,  0.72923321,
         0.97135557,  1.33263554],
       [ 1.79813761,  1.48490175,  1.28396831,  1.21396452,  1.28396831,
         1.48490175,  1.79813761]])

    np.testing.assert_allclose(
        rjb, dctx.rjb, rtol=0, atol=0.01)

    rrup = np.array([[ 5.27459324,  5.06456452,  4.9821571 ,  4.94467172,  4.9821571 ,
         5.06456452,  5.27459324],
       [ 5.00483041,  4.80820132,  4.67381918,  4.65867853,  4.67381918,
         4.80820132,  5.00483041],
       [ 4.81923672,  4.64680257,  4.514164  ,  4.47986499,  4.514164  ,
         4.64680257,  4.81923672],
       [ 4.78581905,  4.57286829,  4.44979468,  0.        ,  4.44979468,
         4.57286829,  4.78581905],
       [ 4.81926166,  4.64683299,  4.51415954,  4.47986499,  4.51415954,
         4.64683299,  4.81926166],
       [ 5.00493679,  4.80823501,  4.67384847,  4.65867853,  4.67384847,
         4.80823501,  5.00493679],
       [ 5.27477487,  5.06468553,  4.98217732,  4.94467172,  4.98217732,
         5.06468553,  5.27477487]])

    np.testing.assert_allclose(
        rrup, dctx.rrup, rtol=0, atol=0.01)
Example #8
0
def test_station(tmpdir):

    homedir = os.path.dirname(os.path.abspath(__file__))
    datadir = os.path.abspath(os.path.join(homedir, '..', 'data', 
            'eventdata', 'Calexico', 'input'))

    #
    # Read the event, source, and rupture files and produce a Source object
    #
    inputfile = os.path.join(datadir, 'stationlist_dat.xml')
    dyfifile = os.path.join(datadir, 'ciim3_dat.xml')
    eventfile = os.path.join(datadir, 'event.xml')
    rupturefile = os.path.join(datadir, 'wei_fault.txt')

    source_obj = Source.fromFile(eventfile, rupturefile=rupturefile)

    #
    # Set up the GMPE, IPE, and GMICE
    #
    gmpe_cy14 = ChiouYoungs2014()

    gmpe = MultiGMPE.from_list([gmpe_cy14], [1.0])

    gmice = WGRW12()

    ipe = AllenEtAl2012()

    #
    # 
    #
    rupture_ctx = source_obj.getRuptureContext([gmpe])

    smdx = 0.0083333333
    smdy = 0.0083333333
    lonspan = 6.0
    latspan = 4.0
    vs30filename = os.path.join(datadir, '..', 'vs30', 'vs30.grd')

    sites_obj_grid = Sites.fromCenter(
            rupture_ctx.hypo_lon, rupture_ctx.hypo_lat, lonspan, latspan, 
            smdx, smdy, defaultVs30=760.0, vs30File=vs30filename, 
            vs30measured_grid=None, padding=False, resample=False
        )

    xmlfiles = [inputfile, dyfifile]
#    dbfile = str(tmpdir.join('stations.db'))
    dbfile = os.path.join(str(tmpdir), 'stations.db')

    stations = StationList.fromXML(xmlfiles, dbfile, source_obj, 
            sites_obj_grid, gmpe, ipe, gmice)

    df1 = stations.getStationDataframe(1, sort=True)
    df2 = stations.getStationDataframe(0, sort=True)


    #
    # In case the test starts failing because of some minor change
    # in one of the prediction or conversion equations (or roundoff
    # or whatever), but the code is running correctly, uncomment 
    # these lines and re-run the test. Then, copy the new stations.db
    # file into tests/data/eventdata/Calexico/database/. Then
    # recomment these lines and rerun the test. It should succeed.
    #
    #shutil.copy(dbfile,'./stations.db')
    #print(os.getcwd())

    #
    # We should probably check these dataframes against some established
    # set, and also check the database against a known database. 
    #

    ref_dbfile = os.path.join(datadir, '..', 'database', 'stations.db')

    stations2 = StationList(ref_dbfile)

    ref_df1 = stations2.getStationDataframe(1, sort=True)
    ref_df2 = stations2.getStationDataframe(0, sort=True)

#    assert ref_df1.equals(df1)
#    assert ref_df2.equals(df2)

    pdt.assert_frame_equal(df1, ref_df1)
    pdt.assert_frame_equal(df2, ref_df2)