def test_utils_circular_points():
"utils.circular_points return diff sequence"
area = [-1000, 1200, -40, 200]
size = 1300
for i in xrange(20):
x1, y1 = utils.circular_points(area, size, random=True).T
x2, y2 = utils.circular_points(area, size, random=True).T
assert numpy.all(x1 != x2) and numpy.all(y1 != y2)
def test_utils_circular_points_seed():
"utils.circular_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.circular_points(area, size, random=True, seed=seed).T
x2, y2 = utils.circular_points(area, size, random=True, seed=seed).T
assert numpy.all(x1 == x2) and numpy.all(y1 == y2)
def test_utils_circular_points():
"utils.circular_points return diff sequence"
area = [-1000, 1200, -40, 200]
size = 1300
for i in xrange(20):
x1, y1 = utils.circular_points(area, size, random=True).T
x2, y2 = utils.circular_points(area, size, random=True).T
assert numpy.all(x1 != x2) and numpy.all(y1 != y2)
def test_utils_circular_points_seed():
"utils.circular_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.circular_points(area, size, random=True, seed=seed).T
x2, y2 = utils.circular_points(area, size, random=True, seed=seed).T
assert numpy.all(x1 == x2) and numpy.all(y1 == y2)
def test_utils_circular_points_seed_noseed():
"utils.circular_points returns diff sequence after using random seed"
area = [0, 1000, 0, 1000]
size = 1000
seed = 1242
x1, y1 = utils.circular_points(area, size, random=True, seed=seed).T
x2, y2 = utils.circular_points(area, size, random=True, seed=seed).T
assert numpy.all(x1 == x2) and numpy.all(y1 == y2)
x3, y3 = utils.circular_points(area, size, random=True).T
assert numpy.all(x1 != x3) and numpy.all(y1 != y3)
def test_utils_circular_points_seed_noseed():
"utils.circular_points returns diff sequence after using random seed"
area = [0, 1000, 0, 1000]
size = 1000
seed = 1242
x1, y1 = utils.circular_points(area, size, random=True, seed=seed).T
x2, y2 = utils.circular_points(area, size, random=True, seed=seed).T
assert numpy.all(x1 == x2) and numpy.all(y1 == y2)
x3, y3 = utils.circular_points(area, size, random=True).T
assert numpy.all(x1 != x3) and numpy.all(y1 != y3)
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,
regularization, [10**i for i in np.arange(0, 10, 1)],
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
log.info("Assumed error: %g" % (error))
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
mesh.addprop('vp', seismic.srtomo.slowness2vel(estimate))
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)
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()
cb.set_label('Velocidade')
