Skip to content

GitLab

N
NIFTy
Commit 1b7e9fb4 authored by Martin Reinecke's avatar Martin Reinecke
Browse files
Options

merge cleanups from dobj_experiments

parent c7beff09
Pipeline #21556 passed with stage
    in 4 minutes and 50 seconds
    Hide whitespace changes
    Inline Side-by-side
    Showing with 155 additions and 124 deletions
    demos/critical_filtering.py
    View file @ 1b7e9fb4
    ......@@ -59,7 +59,7 @@ if __name__ == "__main__":
    S = ift.create_power_operator(h_space, power_spectrum=p_spec)
    # Draw a sample sh from the prior distribution in harmonic space
    sp = ift.Field(p_space, val=p_spec(p_space.k_lengths))
    sp = ift.PS_field(p_space, p_spec)
    sh = ift.power_synthesize(sp, real_signal=True)
    # Choose the measurement instrument
    ......@@ -106,7 +106,9 @@ if __name__ == "__main__":
    def ps0(k):
    return (1./(1.+k)**2)
    t0 = ift.Field(p_space, val=np.log(1./(1+p_space.k_lengths)**2))
    t0 = ift.Field(p_space,
    val=ift.dobj.from_global_data(np.log(1./(1+p_space.k_lengths)**2)))
    for i in range(500):
    S0 = ift.create_power_operator(h_space, power_spectrum=ps0)
    ......@@ -138,6 +140,6 @@ if __name__ == "__main__":
    t0 = power_energy.position.real
    # Plot current estimate
    print(i)
    ift.dobj.mprint(i)
    if i % 5 == 0:
    plot_parameters(m0, t0, ift.log(sp), data_power)
    demos/log_normal_wiener_filter.py
    View file @ 1b7e9fb4
    ......@@ -3,35 +3,38 @@ import numpy as np
    if __name__ == "__main__":
    np.random.seed(42)
    # Setting up parameters |\label{code:wf_parameters}|
    # Setting up parameters
    correlation_length = 1. # Typical distance over which the field is correlated
    field_variance = 2. # Variance of field in position space
    response_sigma = 0.02 # Smoothing length of response (in same unit as L)
    signal_to_noise = 100 # The signal to noise ratio
    np.random.seed(43) # Fixing the random seed
    def power_spectrum(k): # Defining the power spectrum
    a = 4 * correlation_length * field_variance**2
    return a / (1 + k * correlation_length) ** 4
    # Setting up the geometry |\label{code:wf_geometry}|
    L = 2. # Total side-length of the domain
    N_pixels = 128 # Grid resolution (pixels per axis)
    #signal_space = ift.RGSpace([N_pixels, N_pixels], distances=L/N_pixels)
    # Setting up the geometry
    L = 2. # Total side-length of the domain
    N_pixels = 128 # Grid resolution (pixels per axis)
    # signal_space = ift.RGSpace([N_pixels, N_pixels], distances=L/N_pixels)
    signal_space = ift.HPSpace(16)
    harmonic_space = signal_space.get_default_codomain()
    fft = ift.FFTOperator(harmonic_space, target=signal_space)
    power_space = ift.PowerSpace(harmonic_space)
    # Creating the mock signal |\label{code:wf_mock_signal}|
    S = ift.create_power_operator(harmonic_space, power_spectrum=power_spectrum)
    mock_power = ift.Field(power_space, val=power_spectrum(power_space.k_lengths))
    # Creating the mock signal
    S = ift.create_power_operator(harmonic_space,
    power_spectrum=power_spectrum)
    mock_power = ift.PS_field(power_space, power_spectrum)
    mock_signal = fft(ift.power_synthesize(mock_power, real_signal=True))
    # Setting up an exemplary response
    mask = ift.Field.ones(signal_space)
    N10 = int(N_pixels/10)
    #mask.val[N10*5:N10*9, N10*5:N10*9] = 0.
    R = ift.ResponseOperator(signal_space, sigma=(response_sigma,), exposure=(mask,)) #|\label{code:wf_response}|
    # mask.val[N10*5:N10*9, N10*5:N10*9] = 0.
    R = ift.ResponseOperator(signal_space, sigma=(response_sigma,),
    exposure=(mask,))
    data_domain = R.target[0]
    R_harmonic = ift.ComposedOperator([fft, R])
    ......@@ -39,40 +42,52 @@ if __name__ == "__main__":
    ndiag = ift.Field.full(data_domain, mock_signal.var()/signal_to_noise)
    N = ift.DiagonalOperator(ndiag.weight(1))
    noise = ift.Field.from_random(domain=data_domain, random_type='normal',
    std=mock_signal.std()/np.sqrt(signal_to_noise), mean=0)
    data = R(ift.exp(mock_signal)) + noise #|\label{code:wf_mock_data}|
    std=mock_signal.std()/np.sqrt(signal_to_noise), mean=0)
    data = R(ift.exp(mock_signal)) + noise
    # Wiener filter
    m0 = ift.Field.zeros(harmonic_space)
    ctrl = ift.GradientNormController(verbose=False,tol_abs_gradnorm=1)
    ctrl2 = ift.GradientNormController(verbose=True,tol_abs_gradnorm=0.1, name="outer")
    ctrl = ift.GradientNormController(verbose=False, tol_abs_gradnorm=1)
    ctrl2 = ift.GradientNormController(verbose=True, tol_abs_gradnorm=0.1,
    name="outer")
    inverter = ift.ConjugateGradient(controller=ctrl)
    energy = ift.library.LogNormalWienerFilterEnergy(m0, data, R_harmonic, N, S, inverter=inverter)
    minimizer1 = ift.VL_BFGS(controller=ctrl2,max_history_length=20)
    energy = ift.library.LogNormalWienerFilterEnergy(m0, data, R_harmonic,
    N, S, inverter=inverter)
    # minimizer1 = ift.VL_BFGS(controller=ctrl2, max_history_length=20)
    minimizer2 = ift.RelaxedNewton(controller=ctrl2)
    minimizer3 = ift.SteepestDescent(controller=ctrl2)
    # minimizer3 = ift.SteepestDescent(controller=ctrl2)
    #me1 = minimizer1(energy)
    # me1 = minimizer1(energy)
    me2 = minimizer2(energy)
    #me3 = minimizer3(energy)
    # me3 = minimizer3(energy)
    #m1 = fft(me1[0].position)
    # m1 = fft(me1[0].position)
    m2 = fft(me2[0].position)
    #m3 = fft(me3[0].position)
    # m3 = fft(me3[0].position)
    #Plotting #|\label{code:wf_plotting}|
    ift.plotting.plot(mock_signal.real,name='mock_signal.pdf', colormap="plasma",xlabel="Pixel Index",ylabel="Pixel Index")
    ift.plotting.plot(ift.Field(signal_space, val=np.log(data.val.real).reshape(signal_space.shape)),name="log_of_data.pdf", colormap="plasma",xlabel="Pixel Index",ylabel="Pixel Index")
    #ift.plotting.plot(m1.real,name='m_LBFGS.pdf', colormap="plasma",xlabel="Pixel Index",ylabel="Pixel Index")
    ift.plotting.plot(m2.real,name='m_Newton.pdf', colormap="plasma",xlabel="Pixel Index",ylabel="Pixel Index")
    #ift.plotting.plot(m3.real,name='m_SteepestDescent.pdf', colormap="plasma",xlabel="Pixel Index",ylabel="Pixel Index")
    # Plotting
    ift.plotting.plot(mock_signal.real, name='mock_signal.pdf',
    colormap="plasma", xlabel="Pixel Index",
    ylabel="Pixel Index")
    logdata = np.log(ift.dobj.to_global_data(data.val.real)).reshape(signal_space.shape)
    ift.plotting.plot(ift.Field(signal_space,
    val=ift.dobj.from_global_data(logdata)),
    name="log_of_data.pdf", colormap="plasma",
    xlabel="Pixel Index", ylabel="Pixel Index")
    # ift.plotting.plot(m1.real,name='m_LBFGS.pdf', colormap="plasma",
    # xlabel="Pixel Index", ylabel="Pixel Index")
    ift.plotting.plot(m2.real, name='m_Newton.pdf', colormap="plasma",
    xlabel="Pixel Index", ylabel="Pixel Index")
    # ift.plotting.plot(m3.real, name='m_SteepestDescent.pdf',
    # colormap="plasma", xlabel="Pixel Index",
    # ylabel="Pixel Index")
    # Probing the variance
    class Proby(ift.DiagonalProberMixin, ift.Prober): pass
    class Proby(ift.DiagonalProberMixin, ift.Prober):
    pass
    proby = Proby(signal_space, probe_count=1)
    proby(lambda z: fft(me2[0].curvature.inverse_times(fft.adjoint_times(z))))
    sm = ift.FFTSmoothingOperator(signal_space, sigma=0.02)
    variance = sm(proby.diagonal.weight(-1))
    ift.plotting.plot(variance, name = 'variance.pdf')
    ift.plotting.plot(variance, name='variance.pdf')
    demos/paper_demos/cartesian_wiener_filter.py
    View file @ 1b7e9fb4
    ......@@ -2,82 +2,82 @@ import numpy as np
    import nifty2go as ift
    if __name__ == "__main__":
    signal_to_noise = 1.5 # The signal to noise ratio
    signal_to_noise = 1.5 # The signal to noise ratio
    # Setting up parameters |\label{code:wf_parameters}|
    correlation_length_1 = 1. # Typical distance over which the field is correlated
    field_variance_1 = 2. # Variance of field in position space
    # Setting up parameters
    correlation_length_1 = 1. # Typical distance over which the field is correlated
    field_variance_1 = 2. # Variance of field in position space
    response_sigma_1 = 0.05 # Smoothing length of response (in same unit as L)
    response_sigma_1 = 0.05 # Smoothing length of response (in same unit as L)
    def power_spectrum_1(k): # note: field_variance**2 = a*k_0/4.
    def power_spectrum_1(k): # note: field_variance**2 = a*k_0/4.
    a = 4 * correlation_length_1 * field_variance_1**2
    return a / (1 + k * correlation_length_1) ** 4.
    # Setting up the geometry |\label{code:wf_geometry}|
    L_1 = 2. # Total side-length of the domain
    N_pixels_1 = 512 # Grid resolution (pixels per axis)
    # Setting up the geometry
    L_1 = 2. # Total side-length of the domain
    N_pixels_1 = 512 # Grid resolution (pixels per axis)
    signal_space_1 = ift.RGSpace([N_pixels_1], distances=L_1/N_pixels_1)
    harmonic_space_1 = signal_space_1.get_default_codomain()
    # Setting up the geometry |\label{code:wf_geometry}|
    L_2 = 2. # Total side-length of the domain
    N_pixels_2 = 512 # Grid resolution (pixels per axis)
    # Setting up the geometry
    L_2 = 2. # Total side-length of the domain
    N_pixels_2 = 512 # Grid resolution (pixels per axis)
    signal_space_2 = ift.RGSpace([N_pixels_2], distances=L_2/N_pixels_2)
    harmonic_space_2 = signal_space_2.get_default_codomain()
    signal_domain = ift.DomainTuple.make((signal_space_1, signal_space_2))
    mid_domain = ift.DomainTuple.make((signal_space_1, harmonic_space_2))
    harmonic_domain = ift.DomainTuple.make((harmonic_space_1, harmonic_space_2))
    harmonic_domain = ift.DomainTuple.make((harmonic_space_1,
    harmonic_space_2))
    fft_1 = ift.FFTOperator(harmonic_domain, space=0)
    power_space_1 = ift.PowerSpace(harmonic_space_1)
    mock_power_1 = ift.Field(power_space_1, val=power_spectrum_1(power_space_1.k_lengths))
    mock_power_1 = ift.PS_field(power_space_1, power_spectrum_1)
    # Setting up parameters
    correlation_length_2 = 1. # Typical distance over which the field is correlated
    field_variance_2 = 2. # Variance of field in position space
    response_sigma_2 = 0.01 # Smoothing length of response (in same unit as L)
    # Setting up parameters |\label{code:wf_parameters}|
    correlation_length_2 = 1. # Typical distance over which the field is correlated
    field_variance_2 = 2. # Variance of field in position space
    response_sigma_2 = 0.01 # Smoothing length of response (in same unit as L)
    def power_spectrum_2(k): # note: field_variance**2 = a*k_0/4.
    def power_spectrum_2(k): # note: field_variance**2 = a*k_0/4.
    a = 4 * correlation_length_2 * field_variance_2**2
    return a / (1 + k * correlation_length_2) ** 2.5
    fft_2 = ift.FFTOperator(mid_domain, space=1)
    power_space_2 = ift.PowerSpace(harmonic_space_2)
    mock_power_2 = ift.Field(power_space_2, val=power_spectrum_2(power_space_2.k_lengths))
    mock_power_2 = ift.PS_field(power_space_2, power_spectrum_2)
    fft = ift.ComposedOperator((fft_1, fft_2))
    mock_power = ift.Field(domain=(power_space_1, power_space_2),
    val=np.outer(mock_power_1.val, mock_power_2.val))
    val=ift.dobj.from_global_data(np.outer(ift.dobj.to_global_data(mock_power_1.val), ift.dobj.to_global_data(mock_power_2.val))))
    diagonal = ift.power_synthesize_special(mock_power, spaces=(0, 1))**2
    diagonal = diagonal.real
    S = ift.DiagonalOperator(diagonal)
    np.random.seed(10)
    mock_signal = fft(ift.power_synthesize(mock_power, real_signal=True))
    # Setting up a exemplary response
    N1_10 = int(N_pixels_1/10)
    mask_1 = ift.Field.ones(signal_space_1)
    mask_1.val[N1_10*7:N1_10*9] = 0.
    mask_1 = np.ones(signal_space_1.shape)
    mask_1[N1_10*7:N1_10*9] = 0.
    mask_1 = ift.Field(signal_space_1, ift.dobj.from_global_data(mask_1))
    N2_10 = int(N_pixels_2/10)
    mask_2 = ift.Field.ones(signal_space_2)
    mask_2.val[N2_10*7:N2_10*9] = 0.
    mask_2 = np.ones(signal_space_2.shape)
    mask_2[N2_10*7:N2_10*9] = 0.
    mask_2 = ift.Field(signal_space_2, ift.dobj.from_global_data(mask_2))
    R = ift.ResponseOperator(signal_domain,spaces=(0,1),
    R = ift.ResponseOperator(signal_domain, spaces=(0, 1),
    sigma=(response_sigma_1, response_sigma_2),
    exposure=(mask_1, mask_2)) #|\label{code:wf_response}|
    exposure=(mask_1, mask_2))
    data_domain = R.target
    R_harmonic = ift.ComposedOperator([fft, R])
    ......@@ -87,21 +87,23 @@ if __name__ == "__main__":
    noise = ift.Field.from_random(domain=data_domain, random_type='normal',
    std=mock_signal.std()/np.sqrt(signal_to_noise),
    mean=0)
    data = R(mock_signal) + noise #|\label{code:wf_mock_data}|
    data = R(mock_signal) + noise
    # Wiener filter
    j = R_harmonic.adjoint_times(N.inverse_times(data))
    ctrl = ift.GradientNormController(verbose=True, tol_abs_gradnorm=0.1)
    inverter = ift.ConjugateGradient(controller=ctrl)
    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N, R=R_harmonic)
    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N,
    R=R_harmonic)
    wiener_curvature = ift.InversionEnabler(wiener_curvature, inverter)
    m_k = wiener_curvature.inverse_times(j) #|\label{code:wf_wiener_filter}|
    m_k = wiener_curvature.inverse_times(j)
    m = fft(m_k)
    # Probing the variance
    class Proby(ift.DiagonalProberMixin, ift.Prober): pass
    proby = Proby((signal_space_1, signal_space_2), probe_count=1,ncpu=1)
    class Proby(ift.DiagonalProberMixin, ift.Prober):
    pass
    proby = Proby((signal_space_1, signal_space_2), probe_count=1, ncpu=1)
    proby(lambda z: fft(wiener_curvature.inverse_times(fft.inverse_times(z))))
    # sm = SmoothingOperator(signal_space, sigma=0.02)
    # variance = sm(proby.diagonal.weight(-1))
    ......
    demos/paper_demos/wiener_filter.py
    View file @ 1b7e9fb4
    ......@@ -3,34 +3,38 @@ import numpy as np
    if __name__ == "__main__":
    # Setting up parameters |\label{code:wf_parameters}|
    # Setting up parameters
    correlation_length_scale = 1. # Typical distance over which the field is correlated
    fluctuation_scale = 2. # Variance of field in position space
    response_sigma = 0.05 # Smoothing length of response (in same unit as L)
    signal_to_noise = 1.5 # The signal to noise ratio
    np.random.seed(43) # Fixing the random seed
    def power_spectrum(k): # Defining the power spectrum
    a = 4 * correlation_length_scale * fluctuation_scale**2
    return a / (1 + (k * correlation_length_scale)**2) ** 2
    # Setting up the geometry |\label{code:wf_geometry}|
    # Setting up the geometry
    L = 2. # Total side-length of the domain
    N_pixels = 512 # Grid resolution (pixels per axis)
    signal_space = ift.RGSpace([N_pixels, N_pixels], distances=L/N_pixels)
    harmonic_space = signal_space.get_default_codomain()
    fft = ift.FFTOperator(harmonic_space, target=signal_space)
    power_space = ift.PowerSpace(harmonic_space,binbounds=ift.PowerSpace.useful_binbounds(harmonic_space,logarithmic=True))
    power_space = ift.PowerSpace(harmonic_space, binbounds=ift.PowerSpace.useful_binbounds(harmonic_space,logarithmic=True))
    # Creating the mock signal |\label{code:wf_mock_signal}|
    S = ift.create_power_operator(harmonic_space, power_spectrum=power_spectrum)
    mock_power = ift.Field(power_space, val=power_spectrum(power_space.k_lengths))
    # Creating the mock signal
    S = ift.create_power_operator(harmonic_space,
    power_spectrum=power_spectrum)
    mock_power = ift.PS_field(power_space, power_spectrum)
    mock_signal = fft(ift.power_synthesize(mock_power, real_signal=True))
    # Setting up an exemplary response
    mask = ift.Field.ones(signal_space)
    mask = np.ones(signal_space.shape)
    N10 = int(N_pixels/10)
    mask.val[N10*5:N10*9, N10*5:N10*9] = 0.
    R = ift.ResponseOperator(signal_space, sigma=(response_sigma,), exposure=(mask,)) #|\label{code:wf_response}|
    mask[N10*5:N10*9, N10*5:N10*9] = 0.
    mask = ift.Field(signal_space, ift.dobj.from_global_data(mask))
    R = ift.ResponseOperator(signal_space, sigma=(response_sigma,),
    exposure=(mask,))
    data_domain = R.target[0]
    R_harmonic = ift.ComposedOperator([fft, R])
    ......@@ -39,28 +43,29 @@ if __name__ == "__main__":
    N = ift.DiagonalOperator(ndiag.weight(1))
    noise = ift.Field.from_random(domain=data_domain, random_type='normal',
    std=mock_signal.std()/np.sqrt(signal_to_noise), mean=0)
    data = R(mock_signal) + noise #|\label{code:wf_mock_data}|
    data = R(mock_signal) + noise
    # Wiener filter
    j = R_harmonic.adjoint_times(N.inverse_times(data))
    ctrl = ift.GradientNormController(verbose=True,tol_abs_gradnorm=0.1)
    ctrl = ift.GradientNormController(verbose=True, tol_abs_gradnorm=0.1)
    inverter = ift.ConjugateGradient(controller=ctrl)
    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N, R=R_harmonic)
    wiener_curvature =ift.InversionEnabler(wiener_curvature, inverter)
    m_k = wiener_curvature.inverse_times(j) #|\label{code:wf_wiener_filter}|
    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N,
    R=R_harmonic)
    wiener_curvature = ift.InversionEnabler(wiener_curvature, inverter)
    m_k = wiener_curvature.inverse_times(j)
    m = fft(m_k)
    # Probing the uncertainty |\label{code:wf_uncertainty_probing}|
    class Proby(ift.DiagonalProberMixin, ift.Prober): pass
    proby = Proby(signal_space, probe_count=1,ncpu=1)
    proby(lambda z: fft(wiener_curvature.inverse_times(fft.inverse_times(z)))) #|\label{code:wf_variance_fft_wrap}|
    # Probing the uncertainty
    class Proby(ift.DiagonalProberMixin, ift.Prober):
    pass
    proby = Proby(signal_space, probe_count=1, ncpu=1)
    proby(lambda z: fft(wiener_curvature.inverse_times(fft.inverse_times(z))))
    sm = ift.FFTSmoothingOperator(signal_space, sigma=0.03)
    variance = ift.sqrt(sm(proby.diagonal.weight(-1))) #|\label{code:wf_variance_weighting}|
    variance = ift.sqrt(sm(proby.diagonal.weight(-1)))
    # Plotting #|\label{code:wf_plotting}|
    # Plotting
    ift.plotting.plot(variance,name="uncertainty.pdf",xlabel='Pixel index', ylabel='Pixel index')
    ift.plotting.plot(mock_signal,name="mock_signal.pdf",xlabel='Pixel index', ylabel='Pixel index')
    ift.plotting.plot(ift.Field(signal_space, val=data.val),name="data.pdf",xlabel='Pixel index', ylabel='Pixel index')
    ift.plotting.plot(m,name="map.pdf",xlabel='Pixel index', ylabel='Pixel index')
    demos/probing.py
    View file @ 1b7e9fb4
    from __future__ import print_function
    import nifty2go as ift
    import numpy as np
    np.random.seed(42)
    class DiagonalProber(ift.DiagonalProberMixin, ift.Prober):
    pass
    ......@@ -19,9 +19,9 @@ diagOp = ift.DiagonalOperator(f)
    diagProber = DiagonalProber(domain=x)
    diagProber(diagOp)
    print((f - diagProber.diagonal).norm())
    ift.dobj.mprint((f - diagProber.diagonal).norm())
    multiProber = MultiProber(domain=x)
    multiProber(diagOp)
    print((f - multiProber.diagonal).norm())
    print(f.sum() - multiProber.trace)
    ift.dobj.mprint((f - multiProber.diagonal).norm())
    ift.dobj.mprint(f.sum() - multiProber.trace)
    demos/wiener_filter_via_curvature.py
    View file @ 1b7e9fb4
    ......@@ -3,6 +3,8 @@ import nifty2go as ift
    import numericalunits as nu
    if __name__ == "__main__":
    # In MPI mode, the random seed for numericalunits must be set by hand
    nu.reset_units(43)
    dimensionality = 2
    np.random.seed(43)
    ......@@ -43,8 +45,7 @@ if __name__ == "__main__":
    power_spectrum=power_spectrum)
    np.random.seed(43)
    mock_power = ift.Field(power_space,
    val=power_spectrum(power_space.k_lengths))
    mock_power = ift.PS_field(power_space, power_spectrum)
    mock_harmonic = ift.power_synthesize(mock_power, real_signal=True)
    mock_harmonic = mock_harmonic.real
    mock_signal = fft(mock_harmonic)
    ......@@ -80,7 +81,7 @@ if __name__ == "__main__":
    ift.plotting.plot(ift.Field(sspace2, mock_signal.real.val)/nu.K,
    name="mock_signal.pdf")
    ift.plotting.plot(ift.Field(
    sspace2, val=data.val.real.reshape(signal_space.shape))/nu.K,
    name="data.pdf")
    data = ift.dobj.to_global_data(data.val.real).reshape(sspace2.shape)/nu.K
    data = ift.Field(sspace2, val=ift.dobj.from_global_data(data))/nu.K
    ift.plotting.plot(ift.Field(sspace2, val=data), name="data.pdf")
    ift.plotting.plot(ift.Field(sspace2, m_s.real.val)/nu.K, name="map.pdf")
    demos/wiener_filter_via_hamiltonian.py
    View file @ 1b7e9fb4
    ......@@ -50,14 +50,15 @@ if __name__ == "__main__":
    S = ift.create_power_operator(h_space, power_spectrum=p_spec)
    # Drawing a sample sh from the prior distribution in harmonic space
    sp = ift.Field(p_space, val=p_spec(p_space.k_lengths))
    sp = ift.PS_field(p_space, p_spec)
    sh = ift.power_synthesize(sp, real_signal=True)
    ss = fft.adjoint_times(sh)
    # Choosing the measurement instrument
    # Instrument = ift.FFTSmoothingOperator(s_space, sigma=0.05)
    diag = ift.Field.ones(s_space)
    diag.val[20:80, 20:80] = 0
    diag = np.ones(s_space.shape)
    diag[20:80, 20:80] = 0
    diag = ift.Field(s_space, ift.dobj.from_global_data(diag))
    Instrument = ift.DiagonalOperator(diag)
    # Adding a harmonic transformation to the instrument
    ......
    nifty/data_objects/numpy_do.py
    View file @ 1b7e9fb4
    # Data object module for NIFTy that uses simple numpy ndarrays.
    from __future__ import print_function
    import numpy as np
    from numpy import ndarray as data_object
    from numpy import full, empty, empty_like, sqrt, ones, zeros, vdot, abs, \
    bincount, exp, log
    exp, log
    from .random import Random
    __all__ = ["ntask", "rank", "master", "local_shape", "data_object", "full",
    "empty", "zeros", "ones", "empty_like", "vdot", "abs", "exp",
    "log", "sqrt", "bincount", "from_object", "from_random",
    "local_data", "ibegin", "np_allreduce_sum", "distaxis",
    "from_local_data", "from_global_data", "to_global_data",
    "redistribute", "default_distaxis"]
    ntask = 1
    rank = 0
    master = True
    def mprint(*args):
    print(*args)
    def from_object(object, dtype=None, copy=True):
    return np.array(object, dtype=dtype, copy=copy)
    ......
    nifty/dobj.py
    View file @ 1b7e9fb4
    from .data_objects.numpy_do import *
    __all__ = ["ntask", "rank", "master", "local_shape", "data_object", "full",
    "empty", "zeros", "ones", "empty_like", "vdot", "abs", "exp",
    "log", "sqrt", "from_object", "from_random",
    "local_data", "ibegin", "np_allreduce_sum", "distaxis",
    "from_local_data", "from_global_data", "to_global_data",
    "redistribute", "default_distaxis", "mprint"]
    nifty/sugar.py
    View file @ 1b7e9fb4
    ......@@ -17,18 +17,12 @@
    # and financially supported by the Studienstiftung des deutschen Volkes.
    import numpy as np
    from . import Space,\
    PowerSpace,\
    Field,\
    ComposedOperator,\
    DiagonalOperator,\
    PowerProjectionOperator,\
    FFTOperator,\
    sqrt,\
    DomainTuple
    from . import Space, PowerSpace, Field, ComposedOperator, DiagonalOperator,\
    PowerProjectionOperator, FFTOperator, sqrt, DomainTuple, dobj
    from . import nifty_utilities as utilities
    __all__ = ['power_analyze',
    __all__ = ['PS_field',
    'power_analyze',
    'power_synthesize',
    'power_synthesize_special',
    'create_power_field',
    ......@@ -37,6 +31,13 @@ __all__ = ['power_analyze',
    'create_composed_fft_operator']
    def PS_field(pspace, func, dtype=None):
    if not isinstance(pspace, PowerSpace):
    raise TypeError
    data = dobj.from_global_data(func(pspace.k_lengths))
    return Field(pspace, val=data, dtype=dtype)
    def _single_power_analyze(field, idx, binbounds):
    from .operators.power_projection_operator import PowerProjectionOperator
    power_domain = PowerSpace(field.domain[idx], binbounds)
    ......@@ -91,8 +92,8 @@ def power_analyze(field, spaces=None, binbounds=None,
    # power_space instances
    for sp in field.domain:
    if not sp.harmonic and not isinstance(sp, PowerSpace):
    print("WARNING: Field has a space in `domain` which is "
    "neither harmonic nor a PowerSpace.")
    dobj.mprint("WARNING: Field has a space in `domain` which is "
    "neither harmonic nor a PowerSpace.")
    # check if the `spaces` input is valid
    if spaces is None:
    ......@@ -222,8 +223,7 @@ def create_power_field(domain, power_spectrum, dtype=None):
    fp = Field(power_domain, val=power_spectrum.val, dtype=dtype)
    else:
    power_domain = PowerSpace(domain)
    fp = Field(power_domain, val=power_spectrum(power_domain.k_lengths),
    dtype=dtype)
    fp = PS_field(power_domain, power_spectrum, dtype)
    P = PowerProjectionOperator(domain, power_domain)
    f = P.adjoint_times(fp)
    ......@@ -258,7 +258,7 @@ def create_power_operator(domain, power_spectrum, space=None, dtype=None):
    """
    domain = DomainTuple.make(domain)
    if space is None:
    if len(domain)!=1:
    if len(domain) != 1:
    raise ValueError("space keyword must be set")
    else:
    space = 0
    ......
    Markdown is supported
    0% or .
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment