def test_utils_random_points(): "utils.random_points return diff sequence" area = [-1000, 1200, -40, 200] size = 1300 for i in xrange(20): x1, y1 = utils.random_points(area, size).T x2, y2 = utils.random_points(area, size).T assert numpy.all(x1 != x2) and numpy.all(y1 != y2)
def test_utils_random_points_seed(): "utils.random_points returns same sequence using same random seed" area = [0, 1000, 0, 1000] size = 1000 for seed in numpy.random.randint(low=0, high=10000, size=20): x1, y1 = utils.random_points(area, size, seed=seed).T x2, y2 = utils.random_points(area, size, seed=seed).T assert numpy.all(x1 == x2) and numpy.all(y1 == y2)
def test_utils_random_points_seed_noseed(): "utils.random_points returns diff sequence after using random seed" area = [0, 1000, 0, 1000] size = 1000 seed = 1242 x1, y1 = utils.random_points(area, size, seed=seed).T x2, y2 = utils.random_points(area, size, seed=seed).T assert numpy.all(x1 == x2) and numpy.all(y1 == y2) x3, y3 = utils.random_points(area, size).T assert numpy.all(x1 != x3) and numpy.all(y1 != y3)
from fatiando.mesher import SquareMesh from fatiando.seismic import ttime2d, srtomo from fatiando.inversion.regularization import Smoothness2D, LCurve from fatiando.vis import mpl from fatiando import utils area = (0, 500000, 0, 500000) shape = (30, 30) model = SquareMesh(area, shape) vel = 4000 * np.ones(shape) vel[5:25, 5:25] = 10000 model.addprop('vp', vel.ravel()) # Make some travel time data and add noise seed = 0 # Set the random seed so that points are the same every time src_loc = utils.random_points(area, 80, seed=seed) rec_loc = utils.circular_points(area, 30, random=True, seed=seed) srcs, recs = utils.connect_points(src_loc, rec_loc) tts = ttime2d.straight(model, 'vp', srcs, recs) tts, error = utils.contaminate(tts, 0.02, percent=True, return_stddev=True, seed=seed) # Make the mesh mesh = SquareMesh(area, shape) # and run the inversion misfit = srtomo.SRTomo(tts, srcs, recs, mesh) regularization = Smoothness2D(mesh.shape) # Will use the l-curve criterion to find the best regularization parameter tomo = LCurve(misfit,
from fatiando import logger, mesher, utils, seismic, vis log = logger.get() log.info(logger.header()) log.info(__doc__) area = (0, 500000, 0, 500000) shape = (30, 30) model = mesher.SquareMesh(area, shape) # Fetch the image from the online docs urllib.urlretrieve("http://fatiando.readthedocs.org/en/latest/_static/logo.png", "logo.png") model.img2prop("logo.png", 4000, 10000, "vp") # Make some travel time data and add noise log.info("Generating synthetic travel-time data") src_loc = utils.random_points(area, 80) rec_loc = utils.circular_points(area, 30, random=True) srcs, recs = utils.connect_points(src_loc, rec_loc) start = time.time() tts = seismic.ttime2d.straight(model, "vp", srcs, recs, par=True) log.info(" time: %s" % (utils.sec2hms(time.time() - start))) tts, error = utils.contaminate(tts, 0.01, percent=True, return_stddev=True) # Make the mesh mesh = mesher.SquareMesh(area, shape) # and run the inversion estimate, residuals = seismic.srtomo.run(tts, srcs, recs, mesh, damping=10 ** 9) # Convert the slowness estimate to velocities and add it the mesh mesh.addprop("vp", seismic.srtomo.slowness2vel(estimate)) # Calculate and print the standard deviation of the residuals # it should be close to the data error if the inversion was able to fit the data
import urllib from os import path import numpy from fatiando import mesher, utils, seismic, vis area = (0, 500000, 0, 500000) shape = (30, 30) model = mesher.SquareMesh(area, shape) # Fetch the image from the online docs urllib.urlretrieve( 'http://fatiando.readthedocs.org/en/latest/_static/logo.png', 'logo.png') model.img2prop('logo.png', 4000, 10000, 'vp') # Make some travel time data and add noise seed = 0 # Set the random seed so that points are the same everythime src_loc = utils.random_points(area, 80, seed=seed) rec_loc = utils.circular_points(area, 30, random=True, seed=seed) srcs, recs = utils.connect_points(src_loc, rec_loc) tts = seismic.ttime2d.straight(model, 'vp', srcs, recs, par=True) tts, error = utils.contaminate(tts, 0.01, percent=True, return_stddev=True) # Make the mesh mesh = mesher.SquareMesh(area, shape) # and run the inversion estimate, residuals = seismic.srtomo.run(tts, srcs, recs, mesh, smooth=2*10**9) # Convert the slowness estimate to velocities and add it the mesh mesh.addprop('vp', seismic.srtomo.slowness2vel(estimate)) # Calculate and print the standard deviation of the residuals # it should be close to the data error if the inversion was able to fit the data print "Assumed error: %g" % (error) print "Standard deviation of residuals: %g" % (numpy.std(residuals))
""" import urllib from os import path import numpy from fatiando import mesher, utils, seismic, vis, inversion area = (0, 100000, 0, 100000) shape = (100, 100) model = mesher.SquareMesh(area, shape) # Fetch the image from the online docs urllib.urlretrieve( 'http://fatiando.readthedocs.org/en/latest/_static/logo.png', 'logo.png') model.img2prop('logo.png', 4000, 10000, 'vp') # Make some travel time data and add noise src_loc = utils.random_points(area, 200) rec_loc = utils.circular_points(area, 80, random=True) srcs, recs = utils.connect_points(src_loc, rec_loc) ttimes = seismic.ttime2d.straight(model, 'vp', srcs, recs, par=True) ttimes, error = utils.contaminate(ttimes, 0.01, percent=True, return_stddev=True) # Make the mesh mesh = mesher.SquareMesh(area, shape) # Since the matrices are big, use the Steepest Descent solver to avoid dealing # with Hessian matrices. It needs a starting guess, so start with 1000 inversion.gradient.use_sparse() solver = inversion.gradient.steepest(1000*numpy.ones(mesh.size)) # and run the inversion estimate, residuals = seismic.srtomo.run(ttimes, srcs, recs, mesh, sparse=True, solver=solver, smooth=0.01) # Convert the slowness estimate to velocities and add it the mesh
from matplotlib import pyplot import numpy from fatiando.mesher.dd import SquareMesh from fatiando.seismic import traveltime from fatiando import vis, logger, utils, inversion import cPickle as pickle params = __import__('exercicio1_entrada') imgfile = params.imagem area = (0, 5, 0, 5) shape = params.tamanho model = SquareMesh(area, shape) model.img2prop(imgfile, params.vmin, params.vmax, 'vp') src_loc = utils.random_points(area, params.epicentros) rec_loc = utils.circular_points(area, params.sismometros, random=True) srcs, recs = utils.connect_points(src_loc, rec_loc) tts, error = utils.contaminate(traveltime.straight_ray_2d( model, 'vp', srcs, recs), params.ruido, percent=True, return_stddev=True) with open(params.dados, 'w') as f: data = [model, src_loc, rec_loc, tts, error] pickle.dump(data, f) pyplot.figure(figsize=(7, 5)) pyplot.axis('scaled') pyplot.title('Modelo de velocidades')
from matplotlib import pyplot import numpy from fatiando.mesher.dd import SquareMesh from fatiando.seismic import traveltime from fatiando import vis, logger, utils, inversion import cPickle as pickle params = __import__('exercicio1_entrada') imgfile = params.imagem area = (0, 5, 0, 5) shape = params.tamanho model = SquareMesh(area, shape) model.img2prop(imgfile, params.vmin, params.vmax, 'vp') src_loc = utils.random_points(area, params.epicentros) rec_loc = utils.circular_points(area, params.sismometros, random=True) srcs, recs = utils.connect_points(src_loc, rec_loc) tts, error = utils.contaminate( traveltime.straight_ray_2d(model, 'vp', srcs, recs), params.ruido, percent=True, return_stddev=True) with open(params.dados, 'w') as f: data = [model, src_loc, rec_loc, tts, error] pickle.dump(data, f) pyplot.figure(figsize=(7, 5)) pyplot.axis('scaled') pyplot.title('Modelo de velocidades') vis.map.squaremesh(model, model.props['vp'], cmap=pyplot.cm.seismic) cb = pyplot.colorbar()