def perform_inversion(data, init, sigma, vel):
op = LymanAlphaHydrogen(domain,
parameters_inversion,
redshift,
redshift,
hubble,
hubble,
vel_pec=vel,
codomain=codomain)
setting = HilbertSpaceSetting(op=op, Hdomain=L2, Hcodomain=L2)
richardson = RLHydrogen(op)
richardson_lucy = Richardson_Lucy(setting, data, init, richardson, m=3)
energy = EnergyNorm(sigma)
stoprule = (rules.CombineRules(
(rules.CountIterations(300),
rules.Discrepancy(energy.norm,
data,
noiselevel=np.sqrt(N_spect),
tau=1),
rules.RelativeChangeData(energy.norm, data, 0.0001))))
return richardson_lucy.run(stoprule)
def _next(self):
self.log.info('Running Tikhonov solver.')
step, _ = TikhonovCG(setting=HilbertSpaceSetting(
self.deriv, self.setting.Hdomain, self.setting.Hcodomain),
data=self.data - self.y,
regpar=self.regpar,
xref=self.init - self.x,
**self.cgpars).run()
self.x += step
self.y, self.deriv = self.setting.op.linearize(self.x)
self.regpar *= self.regpar_step
def perform_inversion(data, init, sigma, vel):
C_D = sigma
op = LymanAlphaBar(domain,
parameters_inversion,
redshift,
redshift,
hubble,
hubble,
vel,
gamma=True,
codomain=codomain)
setting = HilbertSpaceSetting(op=op, Hdomain=L2, Hcodomain=L2)
solver = IRGN(setting,
data,
init,
C_0,
M_0,
C_D**2,
maxit=15,
tol=1e-3,
restart=10)
energy = EnergyNorm(sigma)
stoprule = (rules.CombineRules(
(rules.CountIterations(10),
rules.Discrepancy(energy.norm,
data,
noiselevel=np.sqrt(N_spect),
tau=1),
rules.RelativeChangeData(energy.norm, data, 0.1))))
return solver.run(stoprule)
fes_noise = ngs.L2(fes_codomain.mesh, order=1)
gfu_noise_order1 = ngs.GridFunction(fes_noise)
gfu_noise_order1.vec.FV().NumPy()[:] = 0.0001 * np.random.randn(fes_noise.ndof)
gfu_noise = ngs.GridFunction(fes_codomain)
gfu_noise.Set(gfu_noise_order1)
noise = gfu_noise.vec.FV().NumPy()
data = exact_data + noise
init = 1 + ngs.x**2
init_gfu = ngs.GridFunction(op.fes_domain)
init_gfu.Set(init)
init_solution = init_gfu.vec.FV().NumPy().copy()
init_data = op(init_solution)
setting = HilbertSpaceSetting(op=op, Hdomain=L2, Hcodomain=Sobolev)
landweber = Landweber(setting, data, init_solution, stepsize=1)
stoprule = (rules.CountIterations(1000) +
rules.Discrepancy(setting.Hcodomain.norm,
data,
noiselevel=setting.Hcodomain.norm(noise),
tau=1.1))
reco, reco_data = landweber.run(stoprule)
ngs.Draw(exact_solution_coeff, op.fes_domain.mesh, "exact")
ngs.Draw(init, op.fes_domain.mesh, "init")
# Draw recondtructed solution
gfu_reco = ngs.GridFunction(op.fes_domain)
scattering.domain,
scattering.support
)
embedding = projection.adjoint
op = scattering * embedding
exact_solution = projection(contrast)
exact_data = op(exact_solution)
noise = 0.03 * op.codomain.randn()
data = exact_data + noise
init = op.domain.zeros()
setting = HilbertSpaceSetting(
op=op,
# Define Sobolev norm on support via embedding
Hdomain=HilbertPullBack(Sobolev(index=2), embedding, inverse='cholesky'),
Hcodomain=L2
)
solver = IrgnmCG(
setting, data,
regpar=1, regpar_step=0.8,
init=init,
cgpars=dict(
tol=1e-8,
reltolx=1e-8,
reltoly=1e-8
)
)
stoprule = (
rules.CountIterations(100) +
reco = np.zeros((Nr_LOS, N_space))
H1_domain = Sobolev(domain, index=1)
L2_domain = L2(domain)
penalty = lambda x: H1_domain.gram(x) - L2_domain.gram(x)
Preprocess = ProbData(0.99, 0, mu, sigma)
Probability_data, Delta_bright = Preprocess.perform(data)
Probability_data.reshape((Nr_LOS, N_spect))
op = ProbCons(domain, mu, sigma, Delta_bright, codomain=codomain, exp=True)
setting = HilbertSpaceSetting(op=op,
Hdomain=Sobolev(index=0),
Hcodomain=Sobolev(index=0))
def perform_inversion(Probability_data, init):
descent = Gradient_Descent(setting,
Probability_data,
np.log(init),
stepsize=0.5,
alpha=0.2,
penalty=penalty)
stoprule = (rules.CombineRules(
(rules.CountIterations(500),
rules.RelativeChangeData(setting.Hcodomain.norm, Probability_data,
# Exact coils are Gaussians centered on points on a circle
centers = util.linspace_circle(exact_coils.shape[0]) / np.sqrt(2)
for coil, center in zip(exact_coils, centers):
r = np.linalg.norm(grid.coords - center[:, np.newaxis, np.newaxis], axis=0)
coil[...] = np.exp(-r**2 / 2)
# Construct data (criminally), add noise
exact_data = mri_op(exact_solution)
data = exact_data + noiselevel * mri_op.codomain.randn()
# Initial guess: constant density, zero coils
init = smoothed_op.domain.zeros()
init_density, _ = smoothed_op.domain.split(init)
init_density[...] = 1
setting = HilbertSpaceSetting(op=smoothed_op, Hdomain=L2, Hcodomain=L2)
solver = IrgnmCG(setting=setting,
data=data,
regpar=10,
regpar_step=0.8,
init=init)
stoprule = (
rules.CountIterations(max_iterations=100) +
rules.Discrepancy(setting.Hcodomain.norm,
data,
noiselevel=setting.Hcodomain.norm(exact_data - data),
tau=1.1))
# Plotting setup