Part 0: Preliminaries and Problem Formulation

Resources and Code Setup

These exercises are best solved using a single python script file, which we will call (but you can name it whatever you wish). A starter is provided.

We suggest you develop your solutions inside this file, and then run the script in an IPython console. This is accomplished by starting an IPython console, from an command prompt, with the command:

ipython --pylab

and running the script with the ‘magic’ run command:


You will need a wave velocity model for these problems. This is provided in the accompanying file The funcion basic_model, which generates a simple model velocity, is imported at the top of the provided using the command:

from models import basic_model

In Part 1: The Foward Problem, we will explore this model further.

Problem Configuration

In this exercise, the physical configuration in which we are working will have a significant amount of problem setup data (or meta data, if you will). It will be convenient to have a central place to store this.

To store this meta data, we could use a Python class, as if we had a MATLAB or C-style struct, however it is much easier to use Python’s built-in dictionary type dict.

In PySIT, this information is stored in two classes: a domain class and a mesh class, which store information about the physical domain and the computational mesh, respectively. For these exercises, we will store information about both in a dictionary called config.

This configuration dictionary config will be passed to all of your routines and should contain the physical and numerical/computational parameters of the problem, e.g., physical domain, number of points, time step, CFL factor, etc.

The configuration dictionary is initialized in the sample by:

config = dict()


import numpy as np
import matplotlib.pyplot as plt


from __future__ import division

import numpy as np

def basic_model(config):
    """Returns 1D derivative of Gaussian reflector model.

    Given a configuration dictionary that specifies:

    1) 'x_limits': A tuple specifying the left and right bound of the domain
    2) 'nx': The number of nodes or degrees of freedom, including the end
    3) 'dx': The spatial step

    returns a 2-tuple containing the true velocity model C and the background
    velocity C0.


    x_limits = config['x_limits']
    nx = config['nx']
    dx = config['dx']

    xs = x_limits[0] + np.arange(nx)*dx

    C0 = np.ones(nx)

    dC = -100.0*(xs-0.5)*np.exp(-((xs-0.5)**2)/(1e-4))
    dC[np.where(abs(dC) < 1e-7)] = 0

    C = C0 + dC

    return C, C0