const struct operator_s* nufft_precond_create(const struct linop_s* nufft_op)
{
const auto data = CAST_DOWN(nufft_data, linop_get_data(nufft_op));
PTR_ALLOC(struct nufft_precond_data, pdata);
SET_TYPEID(nufft_precond_data, pdata);
assert(data->conf.toeplitz);
int N = data->N;
int ND = N + 1;
pdata->N = N;
pdata->cim_dims = *TYPE_ALLOC(long[ND]);
pdata->pre_dims = *TYPE_ALLOC(long[ND]);
pdata->cim_strs = *TYPE_ALLOC(long[ND]);
pdata->pre_strs = *TYPE_ALLOC(long[ND]);
md_copy_dims(ND, pdata->cim_dims, data->cim_dims);
md_select_dims(ND, data->flags, pdata->pre_dims, pdata->cim_dims);
md_calc_strides(ND, pdata->cim_strs, pdata->cim_dims, CFL_SIZE);
md_calc_strides(ND, pdata->pre_strs, pdata->pre_dims, CFL_SIZE);
pdata->pre = compute_precond(pdata->N, pdata->pre_dims, pdata->pre_strs, data->psf_dims, data->psf_strs, data->psf, data->linphase);
pdata->fft_op = linop_fft_create(pdata->N, pdata->cim_dims, data->flags);
const long* cim_dims = pdata->cim_dims; // need to dereference pdata before PTR_PASS
return operator_create(N, cim_dims, N, cim_dims, CAST_UP(PTR_PASS(pdata)), nufft_precond_apply, nufft_precond_del);
}
/**
* Perform iterative, multi-regularized least-squares reconstruction
*/
void lsqr2( unsigned int N, const struct lsqr_conf* conf,
italgo_fun2_t italgo, void* iconf,
const struct linop_s* model_op,
unsigned int num_funs,
const struct operator_p_s** prox_funs,
const struct linop_s** prox_linops,
const long x_dims[N], _Complex float* x,
const long y_dims[N], const _Complex float* y,
const complex float* x_truth,
void* obj_eval_data,
float (*obj_eval)(const void*, const float*))
{
// -----------------------------------------------------------
// normal equation right hand side
complex float* x_adj = md_alloc_sameplace(N, x_dims, CFL_SIZE, y);
linop_adjoint(model_op, N, x_dims, x_adj, N, y_dims, y);
// -----------------------------------------------------------
// initialize data: struct to hold all data and operators
struct lsqr_data data;
data.l2_lambda = conf->lambda;
data.model_op = model_op;
data.G_ops = prox_linops;
data.prox_ops = prox_funs;
data.size = 2 * md_calc_size(N, x_dims);
// -----------------------------------------------------------
// run recon
const struct operator_s* normaleq_op = operator_create(N, x_dims, N, x_dims, (void*)&data, normaleq_l2_apply, NULL);
italgo(iconf, normaleq_op, num_funs, prox_funs, prox_linops, NULL,
data.size, (float*)x, (const float*)x_adj,
(const float*)x_truth, obj_eval_data, obj_eval);
// -----------------------------------------------------------
// clean up
md_free(x_adj);
operator_free(normaleq_op);
}
Operator Operator::create(
MemoryManager memory_manager,
const char* name,
ib_flags_t capabilities,
operator_generator_t generator
)
{
return create<void>(
memory_manager,
name,
capabilities,
operator_create(generator),
operator_destroy,
operator_execute
);
}