예제 #1
0
  def __init__(self, sig, err_lvl, x_true, PSF, recon=False, cmap='Greys',
               per_BC=False, per_BC_pad=False, per_t=0.0, 
               restrict_dom=(None,None)):
    """
    class representing a system we wish to invert.
    INPUT:
      sig          - x_true_ftn parameter.
      err_lvl      - desired noise level (ratio of 100).
      x_true       - function from functions.py representing the true solution.
      PSF          - Point Spread Function.
      recon        - weather or not this is a PSF reconstruction problem. 
      cmap         - matplotlib colormap string name.
      per_BC       - use periodic boundary condtions?
      per_BC_pad   - pad the image to apply periodic BC without distortion?
      per_t        - truncate amount (left, right, top, and bottom).
      restrict_dom - 2-tuple index to restrict (left, right) = (top, bottom) 
    """
    super(Inverse_System_2D, self).__init__()
    self.per_BC     = per_BC
    self.per_BC_pad = per_BC_pad

    nx, ny  = shape(x_true)
    nx      = float(nx)
    ny      = float(ny)
    n       = nx * ny
    hx      = 1/nx
    hy      = 1/ny

    if not per_BC:
      tx      = arange(0, 1, hx)
      ty      = arange(0, 1, hy)
      # A discritization :
      if not recon:
        A1       = d_psf(tx, hx, PSF(tx, hx, sig=sig))
        A2       = d_psf(ty, hy, PSF(ty, hy, sig=sig))
      else:
        A1       = d_int(tx, hx)
        A2       = d_int(ty, hy)

      # Set up true solution x_true and data b = A*x_true + error :
      Ax      = dot(dot(A1, x_true), A2.T)
      sigma   = err_lvl/100.0 * norm(Ax) / sqrt(n)
      eta     = sigma * randn(nx, ny)
      b       = Ax + eta
   
      U1,S1,V1 = svd(A1)
      U2,S2,V2 = svd(A2)
      S        = tensordot(S2, S1, 0)
      UTb      = dot(dot(U1.T, b), U2)
      Vx       = dot(V1.T, dot(x_true, V2))
      
      self.A1  = A1
      self.A2  = A2
      self.U1  = U1
      self.U2  = U2
      self.V1  = V1
      self.V2  = V2
      self.S1  = S1
      self.S2  = S2
    
    else:
      left    = -per_t
      right   =  per_t
      bottom  = -per_t
      top     =  per_t
      tx      = arange(left,   right, hx)
      ty      = arange(bottom, top,   hy)
      
      # A discritization :
      if not recon:
        X,Y      = meshgrid(tx,ty)
        ahat     = fft2(fftshift(PSF(X, Y, hx, hy, sig=sig)))
      else:
        print "reconstruction not implemented"
        exit(1)

      # Set up true solution x_true and data b = A*x_true + error :
      l       = restrict_dom[0]
      r       = restrict_dom[1]
      Ax      = real(ifft2(ahat * fft2(x_true)))
      Ax      = Ax[l:r, l:r]
      x_true  = x_true[l:r, l:r]
      nx2,ny2 = shape(Ax)
      nx2     = float(nx2)
      ny2     = float(ny2)
      n2      = nx2 * ny2
      sigma   = err_lvl/100.0 * norm(Ax) / sqrt(n2)
      eta     = sigma * randn(nx2, ny2)
      b       = Ax + eta
      bhat    = fft2(b)
     
      if self.per_BC_pad:
        p_d   = ((ny/4, ny/4), (nx/4, nx/4))
        b_pad = pad(b, p_d, 'constant')
        bphat = fft2(b_pad)
        DT    = pad(ones(ny2), (ny/4, ny/4), 'constant')
        D     = pad(ones(nx2), (nx/4, nx/4), 'constant')
        M     = tensordot(DT, D, 0) # mask array
        ATDb  = real(ifft2(conj(ahat) * fft2(b_pad)))
        UTb   = bphat

        self.D     = D
        self.DT    = DT
        self.M     = M
        self.ATDb  = ATDb
        self.bphat = bphat
        self.b_pad = b_pad

      else:
        if l is not None and r is not None:
          ml = 0.5*(r - l)
          mr = 1.5*(r - l)
        else:
          ml = 0
          mr = nx
        ahat  = ahat[ml:mr, ml:mr]
        UTb   = bhat
        
      S       = abs(ahat)
      Vx      = fft2(x_true)

      self.ahat = ahat
    
    # 2D problems can only be filtered by Tikhonov regularization
    self.filt_type = 'Tikhonov'
    
    self.cmap        = cmap
    self.per_BC      = per_BC
    self.per_BC_pad  = per_BC_pad
    self.rng         = arange(0, 1, 0.1)
    self.n           = n
    self.nx          = nx
    self.ny          = ny
    self.tx          = tx
    self.ty          = ty
    self.x_true      = x_true
    self.Ax          = Ax
    self.err_lvl     = err_lvl
    self.sigma       = sigma
    self.b           = b
    self.S           = S
    self.UTb         = UTb
    self.Vx          = Vx
예제 #2
0
  def __init__(self, xi, xf, n, sig, err_lvl, x_true_ftn, PSF, recon=False):
    """
    class representing a 1D system we wish to invert.
    INPUT:
      xi      - begin of domain.
      xf      - end of domain.
      n       - number of cells.
      sig     - x_true_ftn parameter.
      err_lvl - desired noise level (ratio of 100).
      x_true  - function from functions.py representing the true solution.
      PSF     - Point Spread Function for reconstruction problem
      recon   - weather or not this is a PSF reconstruction problem. 
    """
    super(Inverse_System_1D, self).__init__()
    n       = float(n)
    omega   = xf - xi
    h       = omega/n
    t       = arange(xi, xf, h)

    # A discritization :
    if not recon:
      A     = d_psf(t, h, PSF(t, h, sig))
    else:
      A     = d_int(t, h)
    
    # Set up true solution x_true and data b = A*x_true + error :
    x_true  = x_true_ftn(t, h, sig)
    Ax      = dot(A, x_true)
    sigma   = err_lvl/100.0 * norm(Ax) / sqrt(n)
    eta     = sigma * randn(n, 1)
    b       = Ax + eta.T[0]
    x_ls    = solve(A,b)
   
    U,S,V   = svd(A)
    UTb     = dot(U.T, b)

    # create regularization matrices for GMRF :
    diags = [-ones(n+1), ones(n+1)]
    D     = array(spdiags(diags, [0, 1], n-1, n).todense())
    L     = dot(D.T, D)
      
    # by default, filter by Tikhonov parameterization
    self.filt_type = 'Tikhonov'
    
    self.rng     = arange(0, 1, 0.1)
    self.omega   = omega 
    self.n       = n
    self.h       = h
    self.t       = t
    self.A       = A
    self.x_true  = x_true
    self.x_ls    = x_ls
    self.Ax      = Ax
    self.err_lvl = err_lvl
    self.sigma   = sigma
    self.b       = b
    self.U       = U
    self.S       = S
    self.V       = V
    self.Vx      = dot(V, x_true)
    self.UTb     = UTb
    self.D       = D
    self.L       = L