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);
}
/**
* Efficiently chain two matrix linops by multiplying the actual matrices together.
* Stores a copy of the new matrix.
* Returns: C = B A
*
* @param a first matrix (applied to input)
* @param b second matrix (applied to output of first matrix)
*/
struct linop_s* linop_matrix_chain(const struct linop_s* a, const struct linop_s* b)
{
const struct operator_matrix_s* a_data = linop_get_data(a);
const struct operator_matrix_s* b_data = linop_get_data(b);
// check compatibility
assert(linop_codomain(a)->N == linop_domain(b)->N);
assert(md_calc_size(linop_codomain(a)->N, linop_codomain(a)->dims) == md_calc_size(linop_domain(b)->N, linop_domain(b)->dims));
assert(a_data->K_dim != b_data->T_dim); // FIXME error for now -- need to deal with this specially.
assert((a_data->T_dim == b_data->K_dim) && (a_data->T == b_data->K));
unsigned int N = linop_domain(a)->N;
long max_dims[N];
md_singleton_dims(N, max_dims);
max_dims[a_data->T_dim] = a_data->T;
max_dims[a_data->K_dim] = a_data->K;
max_dims[b_data->T_dim] = b_data->T;
long matrix_dims[N];
long matrix_strs[N];
md_select_dims(N, ~MD_BIT(a_data->T_dim), matrix_dims, max_dims);
md_calc_strides(N, matrix_strs, matrix_dims, CFL_SIZE);
complex float* matrix = md_alloc_sameplace(N, matrix_dims, CFL_SIZE, a_data->mat);
md_clear(N, matrix_dims, matrix, CFL_SIZE);
md_zfmac2(N, max_dims, matrix_strs, matrix, a_data->mat_iovec->strs, a_data->mat, b_data->mat_iovec->strs, b_data->mat);
struct linop_s* c = linop_matrix_create(N, linop_codomain(b)->dims, linop_domain(a)->dims, matrix_dims, matrix);
md_free(matrix);
return c;
}
void fd_proj_noninc(const struct linop_s* o, complex float* optr, const complex float* iptr)
{
struct fdiff_s* data = (struct fdiff_s*)linop_get_data(o); // FIXME: CAST?
dump_cfl("impre", data->D, data->dims, iptr);
complex float* tmp2 = md_alloc_sameplace(data->D, data->dims, CFL_SIZE, optr);
linop_forward_unchecked(o, tmp2, iptr);
long tmpdim = data->dims[0];
long dims2[data->D];
md_select_dims(data->D, ~0u, dims2, data->dims);
dims2[0] *= 2;
dump_cfl("dxpre", data->D, data->dims, tmp2);
md_smin(data->D, dims2, (float*)optr, (float*)tmp2, 0.);
// add back initial value
dims2[0] = tmpdim;
for (unsigned int i = 0; i < data->D; i++) {
if (MD_IS_SET(data->flags, i)) {
dims2[i] = 1;
md_copy2(data->D, dims2, data->str, optr, data->str, tmp2, CFL_SIZE);
break;
}
}
dump_cfl("dxpost", data->D, data->dims, optr);
linop_norm_inv_unchecked(o, 0., optr, optr);
dump_cfl("impost", data->D, data->dims, optr);
md_free(tmp2);
}
/**
* Efficiently chain two matrix linops by multiplying the actual matrices together.
* Stores a copy of the new matrix.
* Returns: C = B A
*
* @param a first matrix (applied to input)
* @param b second matrix (applied to output of first matrix)
*/
struct linop_s* linop_matrix_chain(const struct linop_s* a, const struct linop_s* b)
{
const struct operator_matrix_s* a_data = CAST_DOWN(operator_matrix_s, linop_get_data(a));
const struct operator_matrix_s* b_data = CAST_DOWN(operator_matrix_s, linop_get_data(b));
// check compatibility
assert(linop_codomain(a)->N == linop_domain(b)->N);
assert(md_check_compat(linop_codomain(a)->N, 0u, linop_codomain(a)->dims, linop_domain(b)->dims));
unsigned int D = linop_domain(a)->N;
unsigned long outB_flags = md_nontriv_dims(D, linop_codomain(b)->dims);
unsigned long inB_flags = md_nontriv_dims(D, linop_domain(b)->dims);
unsigned long delB_flags = inB_flags & ~outB_flags;
unsigned int N = a_data->N;
assert(N == 2 * D);
long in_dims[N];
md_copy_dims(N, in_dims, a_data->in_dims);
long matA_dims[N];
md_copy_dims(N, matA_dims, a_data->mat_dims);
long matB_dims[N];
md_copy_dims(N, matB_dims, b_data->mat_dims);
long out_dims[N];
md_copy_dims(N, out_dims, b_data->out_dims);
for (unsigned int i = 0; i < D; i++) {
if (MD_IS_SET(delB_flags, i)) {
matA_dims[2 * i + 0] = a_data->mat_dims[2 * i + 1];
matA_dims[2 * i + 1] = a_data->mat_dims[2 * i + 0];
in_dims[2 * i + 0] = a_data->in_dims[2 * i + 1];
in_dims[2 * i + 1] = a_data->in_dims[2 * i + 0];
}
}
long matrix_dims[N];
md_singleton_dims(N, matrix_dims);
unsigned long iflags = md_nontriv_dims(N, in_dims);
unsigned long oflags = md_nontriv_dims(N, out_dims);
unsigned long flags = iflags | oflags;
// we combine a and b and sum over dims not in input or output
md_max_dims(N, flags, matrix_dims, matA_dims, matB_dims);
debug_printf(DP_DEBUG1, "tensor chain: %ld x %ld -> %ld\n",
md_calc_size(N, matA_dims), md_calc_size(N, matB_dims), md_calc_size(N, matrix_dims));
complex float* matrix = md_alloc(N, matrix_dims, CFL_SIZE);
debug_print_dims(DP_DEBUG2, N, matrix_dims);
debug_print_dims(DP_DEBUG2, N, in_dims);
debug_print_dims(DP_DEBUG2, N, matA_dims);
debug_print_dims(DP_DEBUG2, N, matB_dims);
debug_print_dims(DP_DEBUG2, N, out_dims);
md_ztenmul(N, matrix_dims, matrix, matA_dims, a_data->mat, matB_dims, b_data->mat);
// priv2 takes our doubled dimensions
struct operator_matrix_s* data = linop_matrix_priv2(N, out_dims, in_dims, matrix_dims, matrix);
/* although we internally use different dimensions we define the
* correct interface
*/
struct linop_s* c = linop_create(linop_codomain(b)->N, linop_codomain(b)->dims,
linop_domain(a)->N, linop_domain(a)->dims, CAST_UP(data),
linop_matrix_apply, linop_matrix_apply_adjoint,
linop_matrix_apply_normal, NULL, linop_matrix_del);
md_free(matrix);
return c;
}