std::size_t grid::save(FILE* fp) const {
std::size_t cnt = 0;
auto foo = std::fwrite;
{
static hpx::mutex mtx;
std::lock_guard < hpx::mutex > lock(mtx);
cnt += foo(&scaling_factor, sizeof(real), 1, fp) * sizeof(real);
cnt += foo(&max_level, sizeof(integer), 1, fp) * sizeof(integer);
cnt += foo(&Acons, sizeof(real), 1, fp) * sizeof(real);
cnt += foo(&Bcons, sizeof(integer), 1, fp) * sizeof(integer);
}
cnt += foo(&is_leaf, sizeof(bool), 1, fp) * sizeof(bool);
cnt += foo(&is_root, sizeof(bool), 1, fp) * sizeof(bool);
for (integer f = 0; f != NF; ++f) {
for (integer i = H_BW; i < H_NX - H_BW; ++i) {
for (integer j = H_BW; j < H_NX - H_BW; ++j) {
const integer iii = hindex(i, j, H_BW);
cnt += foo(&(U[f][iii]), sizeof(real), INX, fp) * sizeof(real);
}
}
}
for (integer i = 0; i < G_NX; ++i) {
for (integer j = 0; j < G_NX; ++j) {
for (integer k = 0; k < G_NX; ++k) {
const integer iii = gindex(i, j, k);
cnt += foo(&(G[iii][0]), sizeof(real), NGF, fp) * sizeof(real);
}
}
}
cnt += foo(U_out.data(), sizeof(real), U_out.size(), fp) * sizeof(real);
return cnt;
}
grid::output_list_type grid::get_output_list(bool analytic) const {
auto& V = TLS_V();
compute_primitives();
output_list_type rc;
const integer vertex_order[8] = { 0, 1, 3, 2, 4, 5, 7, 6 };
std::set<node_point>& node_list = rc.nodes;
std::vector<zone_int_type>& zone_list = rc.zones;
std::array < std::vector<real>, NF + NGF + NPF > &data = rc.data;
std::array < std::vector<real>, NF > &A = rc.analytic;
for (integer field = 0; field != NF + NGF + NPF; ++field) {
data[field].reserve(INX * INX * INX);
if (analytic) {
A[field].reserve(INX * INX * INX);
}
}
const integer this_bw = H_BW;
zone_list.reserve(std::pow(H_NX - 2 * this_bw, NDIM) * NCHILD);
for (integer i = this_bw; i != H_NX - this_bw; ++i) {
for (integer j = this_bw; j != H_NX - this_bw; ++j) {
for (integer k = this_bw; k != H_NX - this_bw; ++k) {
const integer iii = hindex(i, j, k);
const integer iiig = gindex(i - H_BW, j - H_BW, k - H_BW);
#ifdef EQ_ONLY
if (!(std::abs(X[ZDIM][iii]) < dx) && !(std::abs(X[YDIM][iii]) < dx)) {
continue;
}
#endif
for (integer ci = 0; ci != NVERTEX; ++ci) {
const integer vi = vertex_order[ci];
const integer xi = (vi >> 0) & 1;
const integer yi = (vi >> 1) & 1;
const integer zi = (vi >> 2) & 1;
node_point this_x;
this_x.pt[XDIM] = X[XDIM][iii] + (real(xi) - HALF) * dx;
this_x.pt[YDIM] = X[YDIM][iii] + (real(yi) - HALF) * dx;
this_x.pt[ZDIM] = X[ZDIM][iii] + (real(zi) - HALF) * dx;
auto iter = node_list.find(this_x);
integer index;
if (iter != node_list.end()) {
index = iter->index;
} else {
index = node_list.size();
this_x.index = index;
node_list.insert(this_x);
}
zone_list.push_back(index);
}
if (analytic) {
for (integer field = 0; field != NF; ++field) {
A[field].push_back(Ua[field][iii]);
}
}
for (integer field = 0; field != NF; ++field) {
data[field].push_back(U[field][iii]);
}
for (integer field = 0; field != NGF; ++field) {
data[field + NF].push_back(G[iiig][field]);
}
data[NGF + NF + 0].push_back(V[vx_i][iii]);
data[NGF + NF + 1].push_back(V[vy_i][iii]);
data[NGF + NF + 2].push_back(V[vz_i][iii]);
if (V[egas_i][iii] * V[rho_i][iii] < de_switch2 * U[egas_i][iii]) {
data[NGF + NF + 3].push_back(std::pow(V[tau_i][iii], fgamma) / V[rho_i][iii]);
} else {
data[NGF + NF + 3].push_back(V[egas_i][iii]);
}
data[NGF + NF + 4].push_back(V[zz_i][iii]);
}
}
}
return rc;
}
/*--------------------------------------------------------------------------*/
int fuzzygridder2d(double *x, double *y, double *data, unsigned int n,
unsigned int nx, unsigned int ny,
double xmin, double xmax, double ymin, double ymax,
double *odata, double *norm, double wx, double wy,
int flags)
{
double *gnorm;
unsigned int offset, offsetx1, offsetx2, offsety1, offsety2;
unsigned int ntot = nx * ny; /* total number of points on the grid */
unsigned int noutofbounds = 0; /* number of points out of bounds */
double fractionx, fractiony, dwx, dwy; /* variables for the fuzzy part */
double dx = delta(xmin, xmax, nx);
double dy = delta(ymin, ymax, ny);
unsigned int i, j, k; /* loop indices */
/* initialize data if requested */
if (!(flags & NO_DATA_INIT)) {
set_array(odata, ntot, 0.);
}
/* check if normalization array is passed */
if (norm == NULL) {
gnorm = malloc(sizeof(double) * (nx * ny));
if (gnorm == NULL) {
fprintf(stderr, "XU.FuzzyGridder2D(c): Cannot allocate memory for"
" normalization buffer!\n");
return -1;
}
/* initialize memory for norm */
set_array(gnorm, nx * ny, 0.);
}
else {
if (flags & VERBOSE) {
fprintf(stdout, "XU.FuzzyGridder2D(c): use user provided buffer "
"for normalization data\n");
}
gnorm = norm;
}
/* calculate the fuzzy spread in number of bin sizes */
dwx = wx / dx;
dwy = wy / dy;
if (flags & VERBOSE) {
fprintf(stdout, "XU.FuzzyGridder2D(c): fuzzyness: %f %f %f %f\n",
wx, wy, dwx, dwy);
}
/* the master loop over all data points */
for (i = 0; i < n; i++) {
/* if data point is nan ignore it */
if (!isnan(data[i])) {
/* if the x and y values are outside the grids boundaries
* continue with the next point */
if ((x[i] < xmin) || (x[i] > xmax)) {
noutofbounds++;
continue;
}
if ((y[i] < ymin) || (y[i] > ymax)) {
noutofbounds++;
continue;
}
/* compute the linear offset and distribute the data to the bins */
if ((x[i] - wx / 2.) <= xmin) {
offsetx1 = 0;
}
else {
offsetx1 = gindex(x[i] - wx / 2., xmin, dx);
}
offsetx2 = gindex(x[i] + wx / 2., xmin, dx);
offsetx2 = offsetx2 < nx ? offsetx2 : nx - 1;
if ((y[i] - wy / 2.) <= ymin) {
offsety1 = 0;
}
else {
offsety1 = gindex(y[i] - wy / 2., ymin, dy);
}
offsety2 = gindex(y[i] + wy / 2., ymin, dy);
offsety2 = offsety2 < ny ? offsety2 : ny - 1;
for(j = offsetx1; j <= offsetx2; j++) {
if (offsetx1 == offsetx2) {
fractionx = 1.;
}
else if (j == offsetx1) {
fractionx = (j + 1 - (x[i] - wx / 2. - xmin + dx / 2.) / dx) / dwx;
}
else if (j == offsetx2) {
fractionx = ((x[i] + wx / 2. - xmin + dx / 2.) / dx - j) / dwx;
}
else {
fractionx = 1 / dwx;
}
for(k = offsety1; k <= offsety2; k++) {
if (offsety1 == offsety2) {
fractiony = 1.;
}
else if (k == offsety1) {
fractiony = (k + 1 - (y[i] - wy / 2. - ymin + dy / 2.) / dy) / dwy;
}
else if (k == offsety2) {
fractiony = ((y[i] + wy / 2. - ymin + dy / 2.) / dy - k) / dwy;
}
else {
fractiony = 1 / dwy;
}
offset = j * ny + k;
odata[offset] += data[i]*fractionx*fractiony;
gnorm[offset] += fractionx*fractiony;
}
}
}
}
/* perform normalization */
if (!(flags & NO_NORMALIZATION)) {
if (flags & VERBOSE)
fprintf(stdout, "XU.FuzzyGridder2D(c): perform normalization\n");
for (i = 0; i < nx * ny; i++) {
if (gnorm[i] > 1.e-16) {
odata[i] = odata[i] / gnorm[i];
}
}
}
/* free the norm buffer if it has been locally allocated */
if (norm == NULL) {
free(gnorm);
}
/* warn the user in case more than half the data points where out
* of the gridding area */
if (noutofbounds > n / 2) {
fprintf(stdout,"XU.FuzzyGridder2D(c): more than half of the datapoints"
" out of the data range, consider regridding with"
" extended range!\n");
}
return 0;
}
/*--------------------------------------------------------------------------*/
int gridder2d(double *x, double *y, double *data, unsigned int n,
unsigned int nx, unsigned int ny,
double xmin, double xmax, double ymin, double ymax,
double *odata, double *norm, int flags)
{
double *gnorm;
unsigned int offset;
unsigned int ntot = nx * ny; /* total number of points on the grid */
unsigned int noutofbounds = 0; /* number of points out of bounds */
double dx = delta(xmin, xmax, nx);
double dy = delta(ymin, ymax, ny);
unsigned int i; /* loop index */
/* initialize data if requested */
if (!(flags & NO_DATA_INIT)) {
set_array(odata, ntot, 0.);
}
/* check if normalization array is passed */
if (norm == NULL) {
gnorm = malloc(sizeof(double) * (nx * ny));
if (gnorm == NULL) {
fprintf(stderr, "XU.Gridder2D(c): Cannot allocate memory for "
"normalization buffer!\n");
return -1;
}
/* initialize memory for norm */
set_array(gnorm, nx * ny, 0.);
}
else {
if (flags & VERBOSE) {
fprintf(stdout, "XU.Gridder2D(c): use user provided buffer for "
"normalization data\n");
}
gnorm = norm;
}
/* the master loop over all data points */
for (i = 0; i < n; i++) {
/* if data point is nan ignore it */
if (!isnan(data[i])) {
/* if the x and y values are outside the grids boundaries
* continue with the next point */
if ((x[i] < xmin) || (x[i] > xmax)) {
noutofbounds++;
continue;
}
if ((y[i] < ymin) || (y[i] > ymax)) {
noutofbounds++;
continue;
}
/* compute the linear offset and set the data */
offset = gindex(x[i], xmin, dx) * ny + gindex(y[i], ymin, dy);
odata[offset] += data[i];
gnorm[offset] += 1.;
}
}
/* perform normalization */
if (!(flags & NO_NORMALIZATION)) {
if (flags & VERBOSE)
fprintf(stdout, "XU.Gridder2D(c): perform normalization ...\n");
for (i = 0; i < nx * ny; i++) {
if (gnorm[i] > 1.e-16) {
odata[i] = odata[i] / gnorm[i];
}
}
}
/* free the norm buffer if it has been locally allocated */
if (norm == NULL) {
free(gnorm);
}
/* warn the user in case more than half the data points where out
* of the gridding area */
if (noutofbounds > n / 2) {
fprintf(stdout,"XU.Gridder2D(c): more than half of the datapoints out "
"of the data range, consider regridding with extended "
"range!\n");
}
return 0;
}
