t0 = 0. tn = 3500. # Simulation last 3.5 second (3500 ms) f0 = 0.025 # Source peak frequency is 25Hz (0.025 kHz) #NBVAL_IGNORE_OUTPUT from examples.seismic import plot_velocity, plot_perturbation from scipy import ndimage # Create true model from a preset model = create_model() # Create initial model and smooth the boundaries model0 = create_model(grid=model.grid) model0.vp = ndimage.gaussian_filter(model0.vp.data, sigma=filter_sigma, order=0) plot_velocity(model) plot_velocity(model0) plot_perturbation(model0, model) # ## Acquisition geometry # # In this tutorial, we will use the easiest case for inversion, namely a transmission experiment. The sources are located on one side of the model and the receivers on the other side. This allows to record most of the information necessary for inversion, as reflections usually lead to poor inversion results. # In[23]: #NBVAL_IGNORE_OUTPUT # Define acquisition geometry: source from examples.seismic import AcquisitionGeometry
#NBVAL_IGNORE_OUTPUT from examples.seismic import plot_velocity, plot_perturbation from scipy import ndimage # Create true model from a preset model = create_model() # Create initial model and smooth the boundaries model0 = create_model(grid=model.grid) model0.vp = ndimage.gaussian_filter(model0.vp.data, sigma=filter_sigma, order=0) # Plot the true and initial model and the perturbation between them plot_velocity(model) plot_velocity(model0) plot_perturbation(model0, model) # ## Acquisition geometry # # Next we define the positioning and the wave signal of our source, as well as the location of our receivers. To generate the wavelet for our source we require the discretized values of time that we are going to use to model a single "shot", # which again depends on the grid spacing used in our model. For consistency this initial setup will look exactly as in the previous modelling tutorial, although we will vary the position of our source later on during the actual imaging algorithm. # In[4]: #NBVAL_IGNORE_OUTPUT # Define acquisition geometry: source from examples.seismic import AcquisitionGeometry # First, position source centrally in all dimensions, then set depth
rec = Receiver(name='rec', npoint=nreceivers, ntime=nt, grid=model.grid, coordinates=rec_coords) # NOT FOR MANUSCRIPT from examples.seismic import RickerSource # At first, we want only a single shot. # Src is 5% across model, at depth of 500 m. z_locations = np.linspace(0, z_extent, num=nshots) src_coords = np.array([(z_extent / 50, z) for z in z_locations]) # NOT FOR MANUSCRIPT f0 = 0.010 # kHz, peak frequency. src = RickerSource(name='src', grid=model.grid, f0=f0, time=time, coordinates=src_coords[nshots // 2]) # NOT FOR MANUSCRIPT plt.plot(src.time, src.data) plt.xlabel("Time (ms)") plt.ylabel("Amplitude") plt.show() from examples.seismic import plot_velocity plot_velocity(model) plot_velocity(model0)
shape = (101, 101) # Number of grid point (nx, nz) spacing = (10., 10.) # Grid spacing in m. The domain size is now 1km by 1km origin = (0., 0.) # What is the location of the top left corner. This is necessary to define # the absolute location of the source and receivers # Define a velocity profile. The velocity is in km/s v = np.empty(shape, dtype=np.float32) v[:, :51] = 1.5 v[:, 51:] = 2.5 # With the velocity and model size defined, we can create the seismic model that # encapsulates this properties. We also define the size of the absorbing layer as 10 grid points model = Model(vp=v, origin=origin, shape=shape, spacing=spacing, space_order=2, nbpml=10) plot_velocity(model) ############################################################################################ from examples.seismic import TimeAxis t0 = 0. # Simulation starts a t=0 tn = 1000. # Simulation last 1 second (1000 ms) dt = model.critical_dt # Time step from model grid spacing time_range = TimeAxis(start=t0, stop=tn, step=dt) ############################################################################################## #NBVAL_IGNORE_OUTPUT from examples.seismic import RickerSource
def demo_fwi(preset, **kwargs): # Method to return preset-setups for a fwi aplication shape = kwargs.pop('shape', (101, 101)) # Number of grid point (nx, nz) spacing = kwargs.pop('spacing', tuple([10. for _ in shape])) # Grid spacing in m origin = kwargs.pop('origin', tuple([0. for _ in shape])) # Defines relative source and receiver locations nshots = kwargs.pop('nshots', int(shape[0]/2)) # One every two grid points nreceivers = kwargs.pop('nreceivers', int(shape[0])) # One recevier every grid point t0 = kwargs.pop('t0', 0.) # Simulation starts at t=0 tn = kwargs.pop('tn', 3500.) # Simulation last 3.5 seconds (3500 ms) f0 = kwargs.pop('f0', 0.025) # Source peak frequency is 25Hz (0.025 kHz) if preset.lower() in ['marmousi2d-isotropic', 'm2d']: shape = (1601, 401) spacing = (7.5, 7.5) origin = (0., 0.) nshots = 301 nreceivers = 601 nbl = kwargs.pop('nbl', 20) resolution_scale = kwargs.pop('resolution_scale', 3.0) # Scale to which the shape is rescaled filter_sigma = kwargs.pop('filter_sigma', 2.0) # Sigma to which the data is smoothened # Build the model based on the preset data if resolution_scale != 1: true_model = low_res_marmousi(resolution_scale) else: true_model = demo_model('marmousi2d-isotropic', data_path='data/', grid=None, nbpml=20) # Create initial model by smooth the boundaries fwi_model0 = smoothen_model(true_model, filter_sigma) # Position source src_coordinates = np.empty((1, 2)) src_coordinates[0, :] = np.array(true_model.domain_size) * .5 src_coordinates[0, 1] = 20. # Depth is 20m # Initialize receivers for synthetic and imaging data rec_coordinates = np.empty((nreceivers, 2)) rec_coordinates[:, 0] = np.linspace(0, true_model.domain_size[0], num=nreceivers) rec_coordinates[:, 1] = 20. # Depth(m) # Prepare the varying source locations sources source_locations = np.empty((nshots, 2), dtype=np.float32) source_locations[:, 1] = 30. source_locations[:, 0] = np.linspace(0., 7500, num=nshots) # Ready up the Geometry geometry = AcquisitionGeometry(true_model, rec_coordinates, src_coordinates, t0, tn, f0=f0, src_type='Ricker') # Construct the Solver solver = AcousticWaveSolver(true_model, geometry, space_order=4) # Attribute the number of fwi iterations fwi_iterations = 20 elif preset.lower() in ['circle-isotropic', 'c2d']: nshots = 9 tn = 1000. f0 = 0.010 # Build the model based on the preset data true_model = demo_model('circle-isotropic', vp_circle=3.0, vp_background=2.5, origin=origin, shape=shape, spacing=spacing, nbl=40) # Create initial model by smooth the boundaries fwi_model0 = demo_model('circle-isotropic', vp_circle=2.5, vp_background=2.5, origin=origin, shape=shape, spacing=spacing, nbl=40, grid = true_model.grid) # Position source src_coordinates = np.empty((1, 2)) src_coordinates[0, :] = np.array(true_model.domain_size) * .5 src_coordinates[0, 0] = 20. # Depth is 20m # Initialize receivers for synthetic and imaging data rec_coordinates = np.empty((nreceivers, 2)) rec_coordinates[:, 1] = np.linspace(0, true_model.domain_size[0], num=nreceivers) rec_coordinates[:, 0] = 980. # Prepare the varying source locations sources source_locations = np.empty((nshots, 2), dtype=np.float32) source_locations[:, 0] = 30. source_locations[:, 1] = np.linspace(0., 1000, num=nshots) # Ready up the Geometry geometry = AcquisitionGeometry(true_model, rec_coordinates, src_coordinates, t0, tn, f0=f0, src_type='Ricker') # Construct the Solver solver = AcousticWaveSolver(true_model, geometry, space_order=4) # Attribute the number of fwi iterations fwi_iterations = 5 # Show the plots if kwargs.pop('show_plots', False): print("True Model:") plot_velocity(true_model) print("FWI Model 0:") plot_velocity(fwi_model0) #print("True Model ad FWI Model 0 difference:") #plot_perturbation(fwi_model0, true_model) print("Sources and receivers positions:") plot_velocity(true_model, source=geometry.src_positions, receiver=geometry.rec_positions[::4, :]) print("Sources locations:") plot_velocity(true_model, source=source_locations) print("Geometry:") geometry.src.show() return true_model, fwi_model0, nshots, nreceivers, src_coordinates, rec_coordinates,\ source_locations, geometry, solver, fwi_iterations
def plot_model_to_file(model, filename, cmap="jet"): plt.clf() plot_velocity(model, cmap=cmap) plt.savefig(filename)