Exemplo n.º 1
0
def thomson(data, cube, u=.5, **kwargs):
    """
    Defines a Thomson scattering model for white light coronographs.

    Parameters
    ----------
    data: 3D InfoArray
      Data stack.
    cube: 3D FitsArray
      Map cube.

    Returns
    -------
    P : The projector with masking
    D : Smoothness priors
    obj_mask : object mask array
    data_mask : data mask array
    """
    # data mask
    data_mask = solar.define_data_mask(data, **kwargs)
    # projector
    pb = kwargs.get('pb', 'pb')
    if pb == 'pb':
        P = pb_thomson_lo(data, cube, u, mask=data_mask)
    else:
        raise ValueError('Only pb implemented for now.')
    # priors
    D = [lo.diff(cube.shape, axis=i) for i in xrange(cube.ndim)]
    # masks
    kwargs['remove_nan'] = True
    P, D, obj_mask = _apply_object_mask(P, D, cube, **kwargs)
    return P, D, obj_mask, data_mask
Exemplo n.º 2
0
def stsrt(data, cube, **kwargs):
    """
    Smooth Temporal Solar Rotational Tomography.
    Assumes data is sorted by observation time 'DATE_OBS'.
    """
    # Parse kwargs.
    obj_rmin = kwargs.get('obj_rmin', None)
    obj_rmax = kwargs.get('obj_rmax', None)
    data_rmin = kwargs.get('data_rmin', None)
    data_rmax = kwargs.get('data_rmax', None)
    mask_negative = kwargs.get('mask_negative', False)
    # define temporal groups
    times = [secchi.convert_time(t) for t in data.header['DATE_OBS']]
    ## if no interval is given separate every image
    dt_min = kwargs.get('dt_min', np.max(np.diff(times)) + 1)
    #groups = secchi.temporal_groups(data, dt_min)
    ind = secchi.temporal_groups_indexes(data, dt_min)
    n = len(ind)
    # 4d model
    cube_header = cube.header.copy()
    cube_header.update('NAXIS', 4)
    cube_header.update('NAXIS4', data.shape[-1])
    P = siddon4d_lo(data.header, cube_header, obstacle="sun")
    # define per group summation of maps
    # define new 4D cube
    cube4 = cube.reshape(cube.shape + (1,)).repeat(n, axis=-1)
    cube4.header.update('NAXIS', 4)
    cube4.header.update('NAXIS4', cube4.shape[3])
    cube4.header.update('CRVAL4', 0.)
    cube4.header.update('CDELT4', dt_min)
    S = group_sum(ind, cube, data)
    P = P * S.T
    # priors
    D = [lo.diff(cube4.shape, axis=i) for i in xrange(cube.ndim)]
    # mask object
    if obj_rmin is not None or obj_rmax is not None:
        Mo, obj_mask = mask_object(cube, kwargs)
        obj_mask = obj_mask.reshape(obj_mask.shape + (1,)).repeat(n, axis=-1)
        Mo = lo.mask(obj_mask)
        P = P * Mo.T
        D = [Di * Mo.T for Di in D]
    else:
        obj_mask = None
    # mask data
    if (data_rmin is not None or
        data_rmax is not None or
        mask_negative is not None):
        data_mask = secchi.define_data_mask(data,
                                            Rmin=data_rmin,
                                            Rmax=data_rmax,
                                            mask_negative=True)
        Md = lo.mask(data_mask)
        P = Md * P
    else:
        data_mask = None
    return P, D, obj_mask, data_mask, cube4
Exemplo n.º 3
0
def srt(data, cube, **kwargs):
    """
    Define Solar Rotational Tomography model with optional masking of
    data and map areas. Can also define priors.
    
    Parameters
    ----------
    data: InfoArray
        data cube
    cube: FitsArray
        map cube
    obj_rmin: float
        Object minimal radius. Areas below obj_rmin are masked out.
    obj_rmax: float
        Object maximal radius. Areas above obj_rmax are masked out.
    data_rmin: float
        Data minimal radius. Areas below data_rmin are masked out.
    data_rmax: float
        Data maximal radius. Areas above data_rmax are masked out.
    mask_negative: boolean
        If true, negative values in the data are masked out.

    Returns
    -------
    P : The projector with masking
    D : Smoothness priors

    """
    # Parse kwargs.
    obj_rmin = kwargs.get('obj_rmin', None)
    obj_rmax = kwargs.get('obj_rmax', None)
    data_rmin = kwargs.get('data_rmin', None)
    data_rmax = kwargs.get('data_rmax', None)
    mask_negative = kwargs.get('mask_negative', None)
    # Model : it is Solar rotational tomography, so obstacle="sun".
    P = siddon_lo(data.header, cube.header, obstacle="sun")
    D = [lo.diff(cube.shape, axis=i) for i in xrange(cube.ndim)]
    # Define masking.
    if obj_rmin is not None or obj_rmax is not None:
        Mo, obj_mask = mask_object(cube, kwargs)
        P = P * Mo.T
        D = [Di * Mo.T for Di in D]
    else:
        obj_mask = None
    if (data_rmin is not None or
        data_rmax is not None or
        mask_negative is not None):
        data_mask = secchi.define_data_mask(data,
                                            Rmin=data_rmin,
                                            Rmax=data_rmax,
                                            mask_negative=True)
        Md = lo.mask(data_mask)
        P = Md * P
    else:
        data_mask = None
    return P, D, obj_mask, data_mask
Exemplo n.º 4
0
def smoothness_prior(my_map, height_prior=False):
    """
    Defines a smoothness prior.
    """
    D = [lo.diff(my_map.shape, axis=i) for i in xrange(my_map.ndim)]
    if height_prior:
        r = _radius_map(my_map)
        R = lo.diag(r.ravel())
        D = [Di * R for Di in D]
    return D
Exemplo n.º 5
0
obj = tomograpy.centered_cubic_map(3, 32)
obj[:] = tomograpy.phantom.shepp_logan(obj.shape)
# data
radius = 200.
a = tomograpy.fov(obj.header, radius)
data = tomograpy.centered_stack(a,
                                128,
                                n_images=60,
                                radius=radius,
                                max_lon=np.pi)
# projector
P = tomograpy.lo(data.header, obj.header)
# projection
t = time.time()
data = tomograpy.projector(data, obj)
print("projection time : " + str(time.time() - t))
# data
y = data.flatten()
# backprojection
t = time.time()
x0 = P.T * y
bpj = x0.reshape(obj.shape)
print("projection time : " + str(time.time() - t))
# priors
Ds = [lo.diff(obj.shape, axis=i) for i in xrange(3)]
# inversion using scipy.sparse.linalg
t = time.time()
sol = lo.acg(P, y, Ds, 1e-2 * np.ones(3), maxiter=100, tol=1e-20)
sol = sol.reshape(bpj.shape)
print("inversion time : " + str(time.time() - t))
Exemplo n.º 6
0
#!/usr/bin/env python
from tamasis import *
import numpy as np
import lo
import scipy.sparse.linalg as spl

# data
pacs = PacsObservation(filename=tamasis_dir + 'tests/frames_blue.fits',
                       fine_sampling_factor=1,
                       keep_bad_detectors=False)
tod = pacs.get_tod()
# projector
projection = Projection(pacs,
                        resolution=3.2,
                        oversampling=False,
                        npixels_per_sample=6)
model = projection
# naive map
backmap = model.transpose(tod)
# transform to lo
P = lo.ndsubclass(backmap, tod, matvec=model.direct, rmatvec=model.transpose)
# priors
Dx = lo.diff(backmap.shape, axis=0, dtype=np.float64)
Dy = lo.diff(backmap.shape, axis=1, dtype=np.float64)
#Dw = lo.pywt_lo.wavedec2(backmap.shape, "haar")
# inversion
y = tod.flatten()
x = lo.iterative.acg(P, (Dx, Dy), (1e1, 1e1), y)
sol = backmap.zeros(backmap.shape)
sol[:] = x.reshape(sol.shape)
Exemplo n.º 7
0
deglitch_l2mad(tod, projection)
# model
masking = Masking(tod.mask)
model = masking * projection
P = lo.aslinearoperator(model.aslinearoperator())
# derive filter
#tod = filter_median(tod, length=9999)
#kernel = filt.kernel_from_tod(tod, length=1000)
kernel =  (1 + (10. / np.arange(500)) ** .25)
kernel = np.concatenate((kernel[::-1], kernel))
#kern = np.mean(kernel, axis=0)
N = filt.kernels_convolve(tod.shape, 1 / np.sqrt(kernel))
# apply to data
yn = N * tod.flatten()
# apply to model
M = N * P
# first map
backmap = model.transpose(tod)
# define algo
# priors
Dx = lo.diff(backmap.shape, axis=0, dtype=np.float64)
Dy = lo.diff(backmap.shape, axis=1, dtype=np.float64)
#Dw = lo.pywt_lo.wavedec2(backmap.shape, "haar", level=3)
# inversion
x, conv = lo.rls(M, (Dx, Dy), (1e1, 1e1),  yn, tol=1e-10)
sol = backmap.zeros(backmap.shape)
sol[:] = x.reshape(sol.shape)
# save
sol.writefits(os.path.join(os.getenv('HOME'), 'data', 'csh', 'output',
                           'ngc6946__filter_rls.fits'))
Exemplo n.º 8
0
#!/usr/bin/env python
from tamasis import *
import numpy as np
import lo
import scipy.sparse.linalg as spl

# data
pacs = PacsObservation(filename=tamasis_dir + 'tests/frames_blue.fits',
                       fine_sampling_factor=1,
                       keep_bad_detectors=False)
tod = pacs.get_tod()
# projector
projection = Projection(pacs,
                        resolution=3.2,
                        oversampling=False,
                        npixels_per_sample=6)
model = projection
# naive map
backmap = model.transpose(tod)
# transform to lo
P = lo.ndsubclass(backmap, tod, matvec=model.direct, rmatvec=model.transpose)
# priors
Dx = lo.diff(backmap.shape, axis=0)
Dy = lo.diff(backmap.shape, axis=1)
#Dw = lo.pywt_lo.wavedec2(backmap.shape, "haar")
# inversion
y = tod.flatten()
x = lo.iterative.npacg(P, (Dx, Dy), (1e1, 1e1), (2, 1.5, 1.5), y)
sol = backmap.zeros(backmap.shape)
sol[:] = x.reshape(sol.shape)
Exemplo n.º 9
0
projection = tm.Projection(obs, npixels_per_sample=4)
P = lo.aslinearoperator(projection)
# simulate data
x0 = tm.gaussian(projection.shapein, 3)  # map with gaussian source
tod0 = projection(x0)  # data
n = np.random.randn(*tod0.shape)  # noise
nsr = 1e-2
tod = tod0 + nsr * n  # noisy data
y = tod.ravel()  # as 1d array

# load compression matrix
filename = os.path.join(os.getenv("HOME"), "data", "pacs",
                        "mmc_cam_angle_0_scan_angle_0_speed60.fits")
c = fa.FitsArray(file=filename).astype(np.float64)
cmm = csh.compression.AnyOperator(c)
C = cmm((projection.shapeout[0], projection.shapeout[1][0]), )
# compress
z = C * y

# inversion
H = C * P
Ds = [lo.diff(x0.shape, axis=i) for i in (0, 1)]
x_inv = lo.acg(H, z, Ds, 1e-1 * np.ones(2), tol=1e-10, maxiter=100)
x_inv.resize(x0.shape)

# condition number
#M = H.T * H
#Md = M.todense()
#print np.linalg.cond(Md)
#print lo.iterative.utils.cond(H.T * H)
Exemplo n.º 10
0
import lo
import csh.filter as filt
from time import time
import scipy.sparse.linalg as spl

# data
pacs = tm.PacsObservation(filename=tm.tamasis_dir+'tests/frames_blue.fits')
tod = pacs.get_tod()
# projector
model = tm.Projection(pacs, resolution=3.2, oversampling=False, npixels_per_sample=6)
# naive map
backmap = model.transpose(tod)
# transform to lo
P = lo.aslinearoperator(model.aslinearoperator())
# derive filter
kernel = filt.kernel_from_tod(tod, length=10)
#kern = np.mean(kernel, axis=0)
N = filt.kernels_convolve(tod.shape, 1 / np.sqrt(kernel))
# apply to data
yn = N * tod.flatten()
# apply to model
M = N * P
# priors
Ds = [lo.diff(backmap.shape, axis=axis) for axis in xrange(backmap.ndim)]
#Ds.append(lo.pywt_lo.wavelet2(backmap.shape, "haar"))
# inversion
#y = tod.flatten()
x, conv = lo.rls(M, Ds, (1e1, 1e1, 1e-1),  yn, spl.bicgstab)
sol = backmap.zeros(backmap.shape)
sol[:] = x.reshape(sol.shape)
Exemplo n.º 11
0
# ---------------------------------------------
# convert LinearOperator to dense matrix (ndarray)
Hd = H.todense()
Hd = np.asmatrix(Hd)
# convert into my FitsArray :
Hd_fits = fa.FitsArray(data=Hd)
# save the model to defined filename
filename = os.path.join(os.getenv("HOME"), "data", "pacs",
                        "mmc_model_cam_angle_0_scan_angle_0_speed60.fits")
Hd_fits.tofits(filename)

# Define and store mini ma-pmaking matrix
# ---------------------------------------
# (H^T H + a D^T D)^{-1} H^T
# prior is "smoothness" along each axis (0 and 1)
D = [lo.diff(projection.shapein, axis=i) for i in (0, 1)]
# apply the same decimation to priors
D = [Di * M.T for Di in D]
# can sum LinearOperators
DD = sum([Di.T * Di for Di in D])
# convert to dense matrix (ndarray)
DDd = DD.todense()
# Use numpy routines to compute the exact dense map-making matrix.
# This is possible since we have only 8 frames here.
# Otherwise conjugate gradient inversions are mandatory.
# The following line can be longer (approx 1 minute).
H_inv = np.linalg.inv(Hd.T * Hd + DDd) * Hd.T
# save to FITS files
H_inv_fits = fa.FitsArray(data=H_inv)
filename = os.path.join(os.getenv("HOME"), "data", "pacs",
                        "mmc_cam_angle_0_scan_angle_0_speed60.fits")
Exemplo n.º 12
0
model = masking * projection
# naive map
backmap = model.transpose(tod)
# coverage map
weights = model.transpose(tod.ones(tod.shape))
# mask on map
mask = weights == 0
M = lo.mask(mask)
# preconditionner
iweights = 1 / weights
iweights[np.where(np.isfinite(iweights) == 0)] = 0.
M0 = lo.diag(iweights.flatten())
# transform to lo
P = lo.aslinearoperator(model.aslinearoperator())
# priors
Dx = lo.diff(backmap.shape, axis=0)
Dy = lo.diff(backmap.shape, axis=1)
# inversion
y = (masking.T * tod).flatten()
# algos
algos = [spl.cg, spl.cgs, spl.bicg, spl.bicgstab]
models = [P.T * P, P.T * P + Dx.T * Dx + Dy.T * Dy,]
n_iterations = []
resid = []
for algo in algos:
    for A in models:
        for is_masked in (False, True):
            callback = lo.CallbackFactory(verbose=True)
            if is_masked:
                A = M * A * M.T
                b = M * P.T * y
Exemplo n.º 13
0
# data 
path = os.path.join(os.getenv('HOME'), 'data', '171dec08')
obsrvtry = 'STEREO_A'
time_window = ['2008-12-01T00:00:00.000', '2008-12-03T00:00:00.000']
# one image every time_step seconds
time_step = 4 * 3600.
data = siddon.secchi.read_data(path, bin_factor=4,
                               obsrvtry=obsrvtry,
                               time_window=time_window, 
                               time_step=time_step)
# cube
shape = 3 * (128,)
header = {'CRPIX1':64., 'CRPIX2':64., 'CRPIX3':64.,
          'CDELT1':0.0234375, 'CDELT2':0.0234375, 'CDELT3':0.0234375,
          'CRVAL1':0., 'CRVAL2':0., 'CRVAL3':0.,}
cube = fa.zeros(shape, header=header)
# model
P = siddon.siddon_lo(data.header, cube.header)
D = [lo.diff(cube.shape, axis=i) for i in xrange(cube.ndim)]
hypers = cube.ndim * (1e0, )
# inversion
t = time.time()
A = P.T * P + np.sum([h * d.T * d for h, d in zip(hypers, D)])
b = P.T * data.flatten()
#callback = lo.iterative.CallbackFactory(verbose=True)
#x, info = spl.bicgstab(A, b, maxiter=100, callback=callback)
x, info = lo.acg(P, data.flatten(), D, hypers, maxiter=100,)
sol = cube.copy()
sol[:] = x.reshape(cube.shape)
print(time.time() - t)
Exemplo n.º 14
0
ctod = tm.filter_median(ctod, length=filter_length / factor)
cov = noise_covariance(ctod, obs)
S = cov.aslinearoperator()

# model with compression
M = lo.aslinearoperator(model.aslinearoperator())
M = C * M
# noise covariance
cov = noise_covariance(ctod, obs)
S = lo.aslinearoperator(cov.aslinearoperator())
#S = C * S * C.T
#S = None
# backprojection
backmap = (M.T * ctod.flatten()).reshape(projection.shapein)
# priors
Ds = [lo.diff(backmap.shape, axis=0, dtype=np.float64),]
Ds.append(lo.diff(backmap.shape, axis=1, dtype=np.float64))
# weights
weights = projection.transpose(tod.ones(tod.shape))
# masking the map
MM = lo.mask(weights == 0)
M = M * MM.T
Ds = [D * MM.T for D in Ds]
# inversion
x, conv = algo(M, Ds, hypers, ctod.flatten(), S=S, tol=1e-5)
# reshape map
sol = tm.Map(np.zeros(backmap.shape))
sol[:] = (MM.T * x).reshape(sol.shape)
sol.header = header
sol.writefits(os.path.join(output_path, 'sol_madmap.fits'))
Exemplo n.º 15
0
mask = Masking(coverage < 10.)
# The model is the masking of the sky map then the projection
# This is basically matrix multiplication
model = projection * mask

# Performing inversion
# ---------------------

#  with TAMASIS
x_tm = mapper_rls(tod, model, hyper=1e-1, tol=1e-10, maxiter=100)

#  with lo routines
# transform to lo
H = lo.aslinearoperator(model * mask)
# smoothness priors
Ds = [lo.diff(backmap.shape, axis=axis) for axis in (0, 1)]
# inversion
y = tod.ravel()  # requires 1d input
x_lo = lo.acg(H, y, Ds, 1e-1 * np.ones(3), tol=1e-10, maxiter=100)
x_lo.resize(backmap.shape)  # output is 1d so need reshaping

# with sparsity assumptions (using Huber algorithm)
x_h = lo.hacg(H,
              y,
              Ds,
              1e1 * np.ones(3),
              np.asarray((None, 1e-6, 1e-6, 1e-6)),
              x0=x_lo.flatten(),
              tol=1e-7,
              maxiter=200)
x_h.resize(backmap.shape)
Exemplo n.º 16
0
tod = pacs.get_tod()
# projector
projection = tm.Projection(pacs, resolution=3.2, 
                           oversampling=True, npixels_per_sample=6)
masking = tm.Masking(tod.mask)
compression = tm.CompressionAverage(pacs.compression_factor)
model = masking * compression * projection
# naive map
naive = model.transpose(tod)
# coverage map
coverage = model.transpose(tod.ones(tod.shape))
# noise covariance
length = 2**np.ceil(np.log2(np.array(tod.nsamples) + 200))
invNtt = tm.InvNtt(length, pacs.get_filter_uncorrelated())
fft = tm.Fft(length)
padding = tm.Padding(left=invNtt.ncorrelations, 
                     right=length - tod.nsamples - invNtt.ncorrelations)
weight = padding.T * fft.T * invNtt * fft * padding
W = lo.aslinearoperator(weight.aslinearoperator())
# transform to lo
P = lo.aslinearoperator(model.aslinearoperator())
# priors
Ds = [lo.diff(naive.shape, axis=axis) for axis in xrange(naive.ndim)]
# inversion
hypers = [1e6, 1e6, ]
y = tod.flatten()
M = P.T * W * P + np.sum([h * D.T * D for h, D in zip(hypers, Ds)])
x, conv = spl.cgs(M, P.T * W * y, callback=lo.CallbackFactory(verbose=True))
sol = naive.zeros(naive.shape)
sol[:] = x.reshape(sol.shape)
Exemplo n.º 17
0
# create projector
projection = tm.Projection(obs, npixels_per_sample=4)
P = lo.aslinearoperator(projection)
# simulate data
x0 = tm.gaussian(projection.shapein, 3)  # map with gaussian source
tod0 = projection(x0)  # data
n = np.random.randn(*tod0.shape)  # noise
nsr = 1e-2
tod = tod0 + nsr * n  # noisy data
y = tod.ravel()  # as 1d array

# load compression matrix
filename = os.path.join(os.getenv("HOME"), "data", "pacs", "mmc_cam_angle_0_scan_angle_0_speed60.fits")
c = fa.FitsArray(file=filename).astype(np.float64)
cmm = csh.compression.AnyOperator(c)
C = cmm((projection.shapeout[0], projection.shapeout[1][0]))
# compress
z = C * y

# inversion
H = C * P
Ds = [lo.diff(x0.shape, axis=i) for i in (0, 1)]
x_inv = lo.acg(H, z, Ds, 1e-1 * np.ones(2), tol=1e-10, maxiter=100)
x_inv.resize(x0.shape)

# condition number
# M = H.T * H
# Md = M.todense()
# print np.linalg.cond(Md)
# print lo.iterative.utils.cond(H.T * H)
Exemplo n.º 18
0
coverage = projection.T(np.ones(tod.shape))
# naive map
naive = backmap / coverage
# mask according to coverage (everything that is covered by less than 10.)
mask = Masking(coverage < 10.)
# The model is the masking of the sky map then the projection
# This is basically matrix multiplication
model = projection * mask

# Performing inversion
# ---------------------

#  with TAMASIS
x_tm = mapper_rls(tod, model, hyper=1e-1, tol=1e-10, maxiter=100)

#  with lo routines
# transform to lo
H = lo.aslinearoperator(model * mask)
# smoothness priors
Ds = [lo.diff(backmap.shape, axis=axis) for axis in (0, 1)]
# inversion
y = tod.ravel() # requires 1d input
x_lo = lo.acg(H, y, Ds, 1e-1 * np.ones(3), tol=1e-10, maxiter=100)
x_lo.resize(backmap.shape) # output is 1d so need reshaping

# with sparsity assumptions (using Huber algorithm)
x_h = lo.hacg(H, y, Ds, 1e1 * np.ones(3),
            np.asarray((None, 1e-6, 1e-6, 1e-6)),
            x0=x_lo.flatten(), tol=1e-7, maxiter=200)
x_h.resize(backmap.shape)
Exemplo n.º 19
0
# ---------------------------------------------
# convert LinearOperator to dense matrix (ndarray)
Hd = H.todense()
Hd = np.asmatrix(Hd)
# convert into my FitsArray :
Hd_fits = fa.FitsArray(data=Hd)
# save the model to defined filename
filename = os.path.join(os.getenv("HOME"), "data", "pacs",
                        "mmc_model_cam_angle_0_scan_angle_0_speed60.fits")
Hd_fits.tofits(filename)

# Define and store mini ma-pmaking matrix
# ---------------------------------------
# (H^T H + a D^T D)^{-1} H^T
# prior is "smoothness" along each axis (0 and 1)
D = [lo.diff(projection.shapein, axis=i) for i in (0, 1)]
# apply the same decimation to priors
D = [Di * M.T for Di in D]
# can sum LinearOperators
DD = sum([Di.T * Di for Di in D])
# convert to dense matrix (ndarray)
DDd = DD.todense()
# Use numpy routines to compute the exact dense map-making matrix.
# This is possible since we have only 8 frames here.
# Otherwise conjugate gradient inversions are mandatory.
# The following line can be longer (approx 1 minute).
H_inv = np.linalg.inv(Hd.T * Hd + DDd) * Hd.T
# save to FITS files
H_inv_fits = fa.FitsArray(data=H_inv)
filename = os.path.join(os.getenv("HOME"), "data", "pacs",
                        "mmc_cam_angle_0_scan_angle_0_speed60.fits")
Exemplo n.º 20
0
data = siddon.simu.circular_trajectory_data(**image_header)
data[:] = np.zeros(data.shape)
# projector
P = siddon.siddon_lo(data.header, obj.header)
# projection
t = time.time()
data = siddon.projector(data, obj)
print("projection time : " + str(time.time() - t))
# data
y = data.flatten()
# backprojection
t = time.time()
x0 = P.T * y
bpj = x0.reshape(obj.shape)
print("projection time : " + str(time.time() - t))
# coverage map
weights = (P.T * np.ones(y.size)).reshape(obj.shape)
# priors
Ds = [lo.diff(obj.shape, axis=i) for i in xrange(3)]
hypers = 1e-2 * np.ones(3)
#Ds, hypers = [], []
# inversion using scipy.sparse.linalg
t = time.time()
tol = 1e-5
sol, info = lo.rls(P, y, Ds, hypers,  maxiter=100, tol=tol)
sol = sol.reshape(bpj.shape)
if info != 0:
    print("Inversion algorithm did not converge to " + str(tol))

print("inversion time : " + str(time.time() - t))
Exemplo n.º 21
0
# data 
path = os.path.join(os.getenv('HOME'), 'data', '171dec08')
obsrvtry = 'STEREO_A'
time_window = ['2008-12-01T00:00:00.000', '2008-12-03T00:00:00.000']
# one image every time_step seconds
time_step = 4 * 3600.
data = tomograpy.secchi.read_data(path, bin_factor=4,
                               obsrvtry=obsrvtry,
                               time_window=time_window, 
                               time_step=time_step)
# cube
shape = 3 * (128,)
header = {'CRPIX1':64., 'CRPIX2':64., 'CRPIX3':64.,
          'CDELT1':0.0234375, 'CDELT2':0.0234375, 'CDELT3':0.0234375,
          'CRVAL1':0., 'CRVAL2':0., 'CRVAL3':0.,}
cube = fa.zeros(shape, header=header)
# model
P = tomograpy.lo(data.header, cube.header)
D = [lo.diff(cube.shape, axis=i) for i in xrange(cube.ndim)]
hypers = cube.ndim * (1e0, )
# inversion
t = time.time()
A = P.T * P + np.sum([h * d.T * d for h, d in zip(hypers, D)])
b = P.T * data.flatten()
#callback = lo.iterative.CallbackFactory(verbose=True)
#x, info = spl.bicgstab(A, b, maxiter=100, callback=callback)
x, info = lo.acg(P, data.flatten(), D, hypers, maxiter=100,)
sol = cube.copy()
sol[:] = x.reshape(cube.shape)
print(time.time() - t)