aboutsummaryrefslogtreecommitdiff
path: root/mg2d.c
diff options
context:
space:
mode:
Diffstat (limited to 'mg2d.c')
-rw-r--r--mg2d.c70
1 files changed, 35 insertions, 35 deletions
diff --git a/mg2d.c b/mg2d.c
index 3255ce7..08a91df 100644
--- a/mg2d.c
+++ b/mg2d.c
@@ -26,6 +26,7 @@
#include <threadpool.h>
#include <mpi.h>
+#include <ndarray.h>
#include "common.h"
#include "components.h"
@@ -36,7 +37,6 @@
#include "mg2d_boundary.h"
#include "mg2d_boundary_internal.h"
#include "mg2d_constants.h"
-#include "ndarray.h"
#include "timer.h"
#include "transfer.h"
@@ -505,7 +505,7 @@ static int restrict_diff_coeffs(MG2DContext *ctx, MG2DLevel *l)
NDArray *a_dc = l->depth > 0 ? l->solver->diff_coeffs[dc_idx] : priv->diff_coeffs_tmp[dc_idx];
if (!l->depth)
- mg2di_ndarray_copy(a_dc, priv->root->solver->diff_coeffs[dc_idx]);
+ ndarray_copy(a_dc, priv->root->solver->diff_coeffs[dc_idx]);
for (int bnd_idx = 0; bnd_idx < ARRAY_ELEMS(dc->boundaries); bnd_idx++) {
const int ci = mg2d_bnd_coord_idx(bnd_idx);
@@ -636,12 +636,12 @@ static int diff_coeffs_fixup(MG2DContext *ctx, MG2DLevel *l)
const ptrdiff_t stride_dst = a_dst->stride[ci];
const size_t size_dst = l->solver->domain_size[!ci];
- ret = mg2di_ndarray_slice(&dc_src, priv->dc_bnd_val[i][bnd_idx],
- &SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1));
+ ret = ndarray_slice(&dc_src, priv->dc_bnd_val[i][bnd_idx],
+ &NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1));
if (ret < 0)
goto fail;
- ret = mg2di_ndarray_alloc(&dc_dst, 1, &size_dst, 0);
+ ret = ndarray_alloc(&dc_dst, 1, &size_dst, 0);
if (ret < 0)
goto fail;
@@ -675,8 +675,8 @@ static int diff_coeffs_fixup(MG2DContext *ctx, MG2DLevel *l)
fail:
mg2di_gt_free(&gt_bnd);
- mg2di_ndarray_free(&dc_src);
- mg2di_ndarray_free(&dc_dst);
+ ndarray_free(&dc_src);
+ ndarray_free(&dc_dst);
if (ret < 0)
return ret;
}
@@ -788,26 +788,26 @@ static int mg_levels_init(MG2DContext *ctx)
prev = NULL;
if (priv->u) {
- ret = mg2di_ndarray_copy(cur->solver->u, priv->u);
+ ret = ndarray_copy(cur->solver->u, priv->u);
if (ret < 0)
return ret;
- mg2di_ndarray_free(&priv->u);
+ ndarray_free(&priv->u);
ctx->u = cur->solver->u->data;
ctx->u_stride = cur->solver->u->stride[0];
}
if (priv->rhs) {
- ret = mg2di_ndarray_copy(cur->solver->rhs, priv->rhs);
+ ret = ndarray_copy(cur->solver->rhs, priv->rhs);
if (ret < 0)
return ret;
- mg2di_ndarray_free(&priv->rhs);
+ ndarray_free(&priv->rhs);
ctx->rhs = cur->solver->rhs->data;
ctx->rhs_stride = cur->solver->rhs->stride[0];
}
if (ctx->diff_coeffs[0]->data == priv->diff_coeffs_tmp[0]->data) {
for (int i = 0; i < ARRAY_ELEMS(ctx->diff_coeffs); i++) {
- mg2di_ndarray_copy(cur->solver->diff_coeffs[i], priv->diff_coeffs_tmp[i]);
+ ndarray_copy(cur->solver->diff_coeffs[i], priv->diff_coeffs_tmp[i]);
ctx->diff_coeffs[i]->data = cur->solver->diff_coeffs[i]->data;
ctx->diff_coeffs[i]->stride = cur->solver->diff_coeffs[i]->stride[0];
}
@@ -1139,7 +1139,7 @@ int mg2d_solve(MG2DContext *ctx)
mg2di_log(&priv->logger, MG2D_LOG_INFO, "converged on iteration %d, residual %g\n",
i, res_cur);
- //mg2di_ndarray_copy(priv->u, s_root->u);
+ //ndarray_copy(priv->u, s_root->u);
goto finish;
}
@@ -1214,11 +1214,11 @@ static void mg_level_free(MG2DLevel **plevel)
free(level->prolong_recvcounts);
free(level->prolong_recvdispl);
- mg2di_ndarray_free(&level->restrict_dst);
- mg2di_ndarray_free(&level->prolong_dst);
+ ndarray_free(&level->restrict_dst);
+ ndarray_free(&level->prolong_dst);
- mg2di_ndarray_free(&level->prolong_tmp);
- mg2di_ndarray_free(&level->prolong_tmp_base);
+ ndarray_free(&level->prolong_tmp);
+ ndarray_free(&level->prolong_tmp_base);
mg2di_egs_free(&level->solver);
mg2di_gt_free(&level->transfer_restrict);
@@ -1247,12 +1247,12 @@ static MG2DLevel *mg_level_alloc(const DomainGeometry *dg,
level->mpi_comm = comm;
- ret = mg2di_ndarray_alloc(&level->prolong_tmp_base, 2,
+ ret = ndarray_alloc(&level->prolong_tmp_base, 2,
(size_t [2]){dc->interior.size[1] + 1, dc->interior.size[0] + 1}, 0);
if (ret < 0)
goto fail;
- ret = mg2di_ndarray_slice(&level->prolong_tmp, level->prolong_tmp_base, (Slice [2]){ SLICE(0, -1, 1), SLICE(0, -1, 1) });
+ ret = ndarray_slice(&level->prolong_tmp, level->prolong_tmp_base, (NDASlice [2]){ NDASLICE(0, -1, 1), NDASLICE(0, -1, 1) });
if (ret < 0)
goto fail;
@@ -1359,12 +1359,12 @@ static int mg_interdomain_setup(MG2DContext *ctx, MG2DLevel *level)
if (dg_fine->nb_components == 1)
goto finish;
- ret = mg2di_ndarray_alloc(&level->restrict_dst, 2,
+ ret = ndarray_alloc(&level->restrict_dst, 2,
(size_t [2]){ restrict_components[lc].size[1], restrict_components[lc].size[0] }, 0);
if (ret < 0)
goto finish;
- ret = mg2di_ndarray_alloc(&level->prolong_dst, 2,
+ ret = ndarray_alloc(&level->prolong_dst, 2,
(size_t [2]){ prolong_components[lc].size[1], prolong_components[lc].size[0] }, 0);
if (ret < 0)
goto finish;
@@ -1600,14 +1600,14 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen
}
}
- ret = mg2di_ndarray_alloc(&priv->u, 2, (size_t [2]){ domain_size[1], domain_size[0] },
+ ret = ndarray_alloc(&priv->u, 2, (size_t [2]){ domain_size[1], domain_size[0] },
NDARRAY_ALLOC_ZERO);
if (ret < 0)
goto fail;
ctx->u = priv->u->data;
ctx->u_stride = priv->u->stride[0];
- ret = mg2di_ndarray_alloc(&priv->rhs, 2, (size_t [2]){ domain_size[1], domain_size[0] },
+ ret = ndarray_alloc(&priv->rhs, 2, (size_t [2]){ domain_size[1], domain_size[0] },
NDARRAY_ALLOC_ZERO);
if (ret < 0)
goto fail;
@@ -1616,17 +1616,17 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen
for (int i = 0; i < ARRAY_ELEMS(ctx->diff_coeffs); i++) {
MG2DDiffCoeffs *dc;
- const Slice slice[2] = { SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1),
- SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1) };
+ const NDASlice slice[2] = { NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1),
+ NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1) };
- ret = mg2di_ndarray_alloc(&priv->diff_coeffs_base[i], 2,
+ ret = ndarray_alloc(&priv->diff_coeffs_base[i], 2,
(size_t [2]){ domain_size[1] + 2 * FD_STENCIL_MAX,
domain_size[0] + 2 * FD_STENCIL_MAX },
NDARRAY_ALLOC_ZERO);
if (ret < 0)
goto fail;
- ret = mg2di_ndarray_slice(&priv->diff_coeffs_tmp[i], priv->diff_coeffs_base[i], slice);
+ ret = ndarray_slice(&priv->diff_coeffs_tmp[i], priv->diff_coeffs_base[i], slice);
if (ret < 0)
goto fail;
@@ -1641,7 +1641,7 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen
for (int bnd_idx = 0; bnd_idx < ARRAY_ELEMS(dc->boundaries); bnd_idx++) {
const int ci = mg2d_bnd_coord_idx(bnd_idx);
- ret = mg2di_ndarray_alloc(&priv->dc_bnd_val[i][bnd_idx], 1,
+ ret = ndarray_alloc(&priv->dc_bnd_val[i][bnd_idx], 1,
(size_t [1]){ dg->domain_size[!ci] + 2 * FD_STENCIL_MAX },
NDARRAY_ALLOC_ZERO);
if (ret < 0)
@@ -1820,15 +1820,15 @@ void mg2d_solver_free(MG2DContext **pctx)
mg2di_gt_free(&ctx->priv->transfer_init);
- mg2di_ndarray_free(&ctx->priv->u);
- mg2di_ndarray_free(&ctx->priv->rhs);
+ ndarray_free(&ctx->priv->u);
+ ndarray_free(&ctx->priv->rhs);
for (int i = 0; i < ARRAY_ELEMS(ctx->priv->diff_coeffs_base); i++) {
for (int j = 0; j < ARRAY_ELEMS(ctx->priv->dc_bnd_val[i]); j++)
- mg2di_ndarray_free(&ctx->priv->dc_bnd_val[i][j]);
+ ndarray_free(&ctx->priv->dc_bnd_val[i][j]);
free(ctx->diff_coeffs[i]);
- mg2di_ndarray_free(&ctx->priv->diff_coeffs_tmp[i]);
- mg2di_ndarray_free(&ctx->priv->diff_coeffs_base[i]);
+ ndarray_free(&ctx->priv->diff_coeffs_tmp[i]);
+ ndarray_free(&ctx->priv->diff_coeffs_base[i]);
}
mg2di_dg_free(&ctx->priv->dg);
@@ -2019,13 +2019,13 @@ int mg2d_init_guess(MG2DContext *ctx, const double *src,
return ret;
}
- ret = mg2di_ndarray_wrap(&a_src, 2, (size_t [2]){ src_size[1], src_size[0] }, src,
+ ret = ndarray_wrap(&a_src, 2, (size_t [2]){ src_size[1], src_size[0] }, src,
(ptrdiff_t [2]){ src_stride, 1 });
if (ret < 0)
return ret;
ret = mg2di_gt_transfer(priv->transfer_init, priv->u ? priv->u : priv->root->solver->u, a_src);
- mg2di_ndarray_free(&a_src);
+ ndarray_free(&a_src);
return ret;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-05 17:15:53 +0000