/** write solution */ static void write_solution (hid_t id, struct fclib_solution *solution, hsize_t nv, hsize_t nr, hsize_t nl) { if (nv) IO (H5LTmake_dataset_double (id, "v", 1, &nv, solution->v)); if (nl) IO (H5LTmake_dataset_double (id, "l", 1, &nl, solution->l)); ASSERT (nr, "ERROR: contact constraints must be present"); IO (H5LTmake_dataset_double (id, "u", 1, &nr, solution->u)); IO (H5LTmake_dataset_double (id, "r", 1, &nr, solution->r)); }
void hdf5_save_float<double>(hid_t loc_id, const string& dataset_name, double f) { hsize_t one = 1; herr_t status = \ H5LTmake_dataset_double(loc_id, dataset_name.c_str(), 1, &one, &f); CHECK_GE(status, 0) << "Failed to save int dataset with name " << dataset_name; }
void hdf5_output(double *data, int ts, int rows, int cols, char *prefix) { char buffer [MAX_FILENAME_LENGTH]; snprintf(buffer, MAX_FILENAME_LENGTH, "%s-%d.h5", prefix, ts); printf("Outputting data for timestep %d to %s\n", ts, buffer); hid_t file_id = H5Fcreate(buffer, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); hsize_t dims[2] = {rows, cols}; H5LTmake_dataset_double(file_id, CCILK_DATASET, 2, dims, data); H5Fclose (file_id); }
/** write matrix */ static void write_matrix (hid_t id, struct fclib_matrix *mat) { hsize_t dim = 1; IO (H5LTmake_dataset_int (id, "nzmax", 1, &dim, &mat->nzmax)); IO (H5LTmake_dataset_int (id, "m", 1, &dim, &mat->m)); IO (H5LTmake_dataset_int (id, "n", 1, &dim, &mat->n)); IO (H5LTmake_dataset_int (id, "nz", 1, &dim, &mat->nz)); if (mat->nz >= 0) /* triplet */ { dim = mat->nz; IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p)); IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i)); } else if (mat->nz == -1) /* csc */ { dim = mat->n+1; IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p)); dim = mat->nzmax; IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i)); } else if (mat->nz == -2) /* csr */ { dim = mat->m+1; IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p)); dim = mat->nzmax; IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i)); } else ASSERT (0, "ERROR: unkown sparse matrix type => fclib_matrix->nz = %d\n", mat->nz); dim = mat->nzmax; IO (H5LTmake_dataset_double (id, "x", 1, &dim, mat->x)); if (mat->info) { dim = 1; if (mat->info->comment) IO (H5LTmake_dataset_string (id, "comment", mat->info->comment)); IO (H5LTmake_dataset_double (id, "conditioning", 1, &dim, &mat->info->conditioning)); IO (H5LTmake_dataset_double (id, "determinant", 1, &dim, &mat->info->determinant)); IO (H5LTmake_dataset_int (id, "rank", 1, &dim, &mat->info->rank)); } }
/** write local vectors */ static void write_local_vectors (hid_t id, struct fclib_local *problem) { hsize_t dim; dim = problem->W->m; ASSERT (problem->q, "ERROR: q must be given"); IO (H5LTmake_dataset_double (id, "q", 1, &dim, problem->q)); ASSERT (dim % problem->spacedim == 0, "ERROR: number of W rows is not divisble by the spatial dimension"); dim /= problem->spacedim; IO (H5LTmake_dataset_double (id, "mu", 1, &dim, problem->mu)); if (problem->V) { dim = problem->R->m; ASSERT (problem->s, "ERROR: s must be given if R is present"); IO (H5LTmake_dataset_double (id, "s", 1, &dim, problem->s)); } }
void hdf5_save_nd_dataset<double>( const hid_t file_id, const string dataset_name, const Blob<double>& blob) { hsize_t dims[HDF5_NUM_DIMS]; dims[0] = blob.num(); dims[1] = blob.channels(); dims[2] = blob.height(); dims[3] = blob.width(); herr_t status = H5LTmake_dataset_double( file_id, dataset_name.c_str(), HDF5_NUM_DIMS, dims, blob.cpu_data()); CHECK_GE(status, 0) << "Failed to make double dataset " << dataset_name; }
void write_hdf5_data_02() { hid_t file_id; file_id = H5Fcreate("xdmf2d_02.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Create the scalar data. double *pressure = (double *) malloc(NX*NY * sizeof(double)); for (int j = 0; j < NY; j++) { for (int i = 0; i < NX; i++) { int ndx = j * NX + i; pressure[ndx] = 2.0*((double) j); } } double *velocityx = (double *) malloc((NX+1)*(NY+1) * sizeof(double)); for (int j = 0; j < NY+1; j++) { for (int i = 0; i < NX+1; i++) { int ndx = j * (NX+1) + i; velocityx[ndx] = 3.0*((double) i); } } // Write the data file. hsize_t dims[1]; dims[0] = (NY + 1)*(NX + 1); H5LTmake_dataset_double(file_id,"VelocityX",1,dims,velocityx); dims[0] = NY*NX; H5LTmake_dataset_double(file_id,"Pressure",1,dims,pressure); free(pressure); free(velocityx); H5Fclose(file_id); }
/** write global vectors */ static void write_global_vectors (hid_t id, struct fclib_global *problem) { hsize_t dim; dim = problem->M->m; ASSERT (problem->f, "ERROR: f must be given"); IO (H5LTmake_dataset_double (id, "f", 1, &dim, problem->f)); dim = problem->H->n; ASSERT (problem->w && problem->mu, "ERROR: w and mu must be given"); IO (H5LTmake_dataset_double (id, "w", 1, &dim, problem->w)); ASSERT (dim % problem->spacedim == 0, "ERROR: number of H columns is not divisble by the spatial dimension"); dim /= problem->spacedim; IO (H5LTmake_dataset_double (id, "mu", 1, &dim, problem->mu)); if (problem->G) { dim = problem->G->n; ASSERT (problem->b, "ERROR: b must be given if G is present"); IO (H5LTmake_dataset_double (id, "b", 1, &dim, problem->b)); } }
void hdf5_save_nd_dataset<double>( hid_t file_id, const string& dataset_name, const Blob<double>& blob, bool write_diff) { int num_axes = blob.num_axes(); hsize_t *dims = new hsize_t[num_axes]; for (int i = 0; i < num_axes; ++i) { dims[i] = blob.shape(i); } const double* data; if (write_diff) { data = blob.cpu_diff(); } else { data = blob.cpu_data(); } herr_t status = H5LTmake_dataset_double( file_id, dataset_name.c_str(), num_axes, dims, data); CHECK_GE(status, 0) << "Failed to make double dataset " << dataset_name; delete[] dims; }
int write_output(char *output_file, struct input_config *p, double *x) { herr_t err = 0; hid_t output_file_id; int rank; hsize_t *dims = NULL; output_file_id = H5Fcreate(output_file, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); if (output_file_id <= 0) { printf("Error: Could not create \"%s\".\n", output_file); err = -1; goto cleanup; } rank = p->levy_basis_rank + 1; dims = malloc(rank * sizeof(hsize_t)); for (int i = 0; i < rank - 1; i++) dims[i] = p->levy_basis_dimension[i]; dims[rank - 1] = p->levy_seed_dimension; err = H5LTmake_dataset_double(output_file_id, "/levy_basis_realization", rank, dims, x); cleanup: return (int)err; }
static int test_dsets( void ) { int rank = 2; hsize_t dims[2] = {2,3}; hid_t file_id; hid_t dataset_id; char data_char_in[DIM] = {1,2,3,4,5,6}; char data_char_out[DIM]; short data_short_in[DIM] = {1,2,3,4,5,6}; short data_short_out[DIM]; int data_int_in[DIM] = {1,2,3,4,5,6}; int data_int_out[DIM]; long data_long_in[DIM] = {1,2,3,4,5,6}; long data_long_out[DIM]; float data_float_in[DIM] = {1,2,3,4,5,6}; float data_float_out[DIM]; double data_double_in[DIM] = {1,2,3,4,5,6}; double data_double_out[DIM]; const char *data_string_in = "This is a string"; char data_string_out[20]; int i; /* Create a new file using default properties. */ file_id = H5Fcreate( FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT ); /*------------------------------------------------------------------------- * H5LTmake_dataset test *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset"); /* Make dataset */ if ( H5LTmake_dataset( file_id, DSET0_NAME, rank, dims, H5T_NATIVE_INT, data_int_in ) < 0 ) goto out; /* Read dataset using the basic HDF5 API */ if ( ( dataset_id = H5Dopen2(file_id, DSET0_NAME, H5P_DEFAULT) ) < 0 ) goto out; if ( H5Dread ( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, data_int_out ) < 0 ) goto out; if ( H5Dclose( dataset_id ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_int_in[i] != data_int_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * read using the LT function H5LTread_dataset *------------------------------------------------------------------------- */ TESTING("H5LTread_dataset"); if ( H5LTread_dataset( file_id, DSET0_NAME, H5T_NATIVE_INT, data_int_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_int_in[i] != data_int_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * test the H5LTmake_dataset_ functions *------------------------------------------------------------------------- */ /*------------------------------------------------------------------------- * H5LTmake_dataset_char *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_char"); /* Make dataset char */ if ( H5LTmake_dataset_char( file_id, DSET1_NAME, rank, dims, data_char_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET1_NAME, H5T_NATIVE_CHAR, data_char_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_char_in[i] != data_char_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_char( file_id, DSET1_NAME, data_char_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_char_in[i] != data_char_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_short *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_short"); /* Make dataset short */ if ( H5LTmake_dataset_short( file_id, DSET2_NAME, rank, dims, data_short_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET2_NAME, H5T_NATIVE_SHORT, data_short_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_short_in[i] != data_short_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_short( file_id, DSET2_NAME, data_short_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_short_in[i] != data_short_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_int *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_int"); /* Make dataset int */ if ( H5LTmake_dataset_int( file_id, DSET3_NAME, rank, dims, data_int_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET3_NAME, H5T_NATIVE_INT, data_int_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_int_in[i] != data_int_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_int( file_id, DSET3_NAME, data_int_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_int_in[i] != data_int_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_long *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_long"); /* Make dataset long */ if ( H5LTmake_dataset_long( file_id, DSET4_NAME, rank, dims, data_long_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET4_NAME, H5T_NATIVE_LONG, data_long_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_long_in[i] != data_long_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_long( file_id, DSET4_NAME, data_long_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_long_in[i] != data_long_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_float *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_float"); /* Make dataset float */ if ( H5LTmake_dataset_float( file_id, DSET5_NAME, rank, dims, data_float_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET5_NAME, H5T_NATIVE_FLOAT, data_float_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_float_in[i] != data_float_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_float( file_id, DSET5_NAME, data_float_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_float_in[i] != data_float_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_double *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_double"); /* Make dataset double */ if ( H5LTmake_dataset_double( file_id, DSET6_NAME, rank, dims, data_double_in ) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset( file_id, DSET6_NAME, H5T_NATIVE_DOUBLE, data_double_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_double_in[i] != data_double_out[i] ) { goto out; } } /* Read dataset */ if ( H5LTread_dataset_double( file_id, DSET6_NAME, data_double_out ) < 0 ) goto out; for (i = 0; i < DIM; i++) { if ( data_double_in[i] != data_double_out[i] ) { goto out; } } PASSED(); /*------------------------------------------------------------------------- * H5LTmake_dataset_string *------------------------------------------------------------------------- */ TESTING("H5LTmake_dataset_string"); /* Make dataset string */ if ( H5LTmake_dataset_string(file_id,DSET7_NAME,data_string_in) < 0 ) goto out; /* Read dataset */ if ( H5LTread_dataset_string(file_id,DSET7_NAME,data_string_out) < 0 ) goto out; if ( strcmp(data_string_in,data_string_out) != 0 ) goto out; /*------------------------------------------------------------------------- * end tests *------------------------------------------------------------------------- */ /* Close the file. */ H5Fclose( file_id ); PASSED(); return 0; out: /* Close the file. */ H5_FAILED(); return -1; }
void write_hdf5_data_01() { hid_t file_id; file_id = H5Fcreate("xdmf2d_co.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Create the coordinate data. double *x = (double *) malloc((NX+1)*(NY+1) * sizeof(double)); double *y = (double *) malloc((NX+1)*(NY+1) * sizeof(double)); int ndx = 0; for (int j = 0; j < NY+1; j++) { double yt = double(j) / double(NY); double angle = yt * M_PI; for (int i = 0; i < NX+1; i++) { double xt = double(i) / double(NX); double R = (1.-xt)*2. + xt*5.; x[ndx] = R * cos(angle); y[ndx] = R * sin(angle); ndx++; } } hsize_t dims[1]; dims[0] = (NY + 1)*(NX + 1); H5LTmake_dataset_double(file_id,"X",1,dims,x); H5LTmake_dataset_double(file_id,"Y",1,dims,y); free(x); free(y); H5Fclose(file_id); file_id = H5Fcreate("xdmf2d_01.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Create the scalar data. double *pressure = (double *) malloc(NX*NY * sizeof(double)); for (int j = 0; j < NY; j++) { for (int i = 0; i < NX; i++) { int ndx = j * NX + i; pressure[ndx] = (double) j; } } double *velocityx = (double *) malloc((NX+1)*(NY+1) * sizeof(double)); for (int j = 0; j < NY+1; j++) { for (int i = 0; i < NX+1; i++) { int ndx = j * (NX+1) + i; velocityx[ndx] = (double) i; } } // Write the data file. H5LTmake_dataset_double(file_id,"VelocityX",1,dims,velocityx); dims[0] = NY*NX; H5LTmake_dataset_double(file_id,"Pressure",1,dims,pressure); free(pressure); free(velocityx); }
/*main mcmc loop, records sampled values, performs no tuning of the step size.*/ int /*always returns success*/ mcmc_foreach(int rank, /*MPI rank*/ int R, /*MPI Comm size*/ size_t SampleSize, /*number of iterations of MCMC*/ ode_model_parameters *omp, /*ODE problem cpecification and pre-allocated space*/ mcmc_kernel *kernel, /* MCMC kernel sturct, holds MCMC-algorithm's parameters*/ hdf5block_t *h5block, /*defines the hdf5 file to write into, holds ids and sizes*/ void *buffer, /* for MPI communication, similar to kernel*/ main_options *option)/*options from defaults, files and command line*/{ clock_t ct=clock(); gsl_matrix *log_para_chunk; gsl_vector *log_post_chunk; int D=get_number_of_MCMC_variables(omp); log_para_chunk=gsl_matrix_alloc(CHUNK,D); log_post_chunk=gsl_vector_alloc(CHUNK); gsl_vector_view current; gsl_vector_view x_state; int swaps = 0; // swap success counter int acc=no; // acceptance flag int acc_c=0; // acceptance counter double acc_rate=0.0; size_t it; int master=no; int DEST; double beta=mcmc_get_beta(kernel); herr_t status; int resume_EC; int last_chunk=no, not_written_yet=yes; for (it = 0; it < SampleSize; it++) { mcmc_sample(kernel, &acc); last_chunk=SampleSize-it<CHUNK; if (acc && last_chunk && not_written_yet){ resume_EC=write_resume_state(option->resume_file, rank, R, kernel); if (resume_EC==EXIT_SUCCESS){ not_written_yet=no; } } acc_c += acc; master=(it%2==rank%2); if (master){ DEST=(rank+1)%R; // this process is the master process for swap decisions } else { DEST=(R+rank-1)%R; // this process has to accept swap decisions from DEST } //their_beta=BETA(DEST,R); // the other proc's if (R>1){ mcmc_exchange_information(kernel,DEST,buffer); swaps+=mcmc_swap_chains(kernel,master,rank,DEST,buffer); } /* save sampled point for writing */ current=gsl_matrix_row(log_para_chunk,it%CHUNK); x_state=gsl_vector_view_array(kernel->x,D); gsl_vector_memcpy(&(current.vector),&(x_state.vector)); gsl_vector_set(log_post_chunk,it%CHUNK,kernel->fx[0]); /* print sample log and statistics every 100 samples */ if ( ((it + 1) % CHUNK) == 0 ) { acc_rate = ((double) acc_c) / ((double) CHUNK); fprintf(stdout, "# [rank % 2i/% 2i; β=%5f; %3li%% done] (it %5li)\tacc. rate: %3.2f;\t%3i %% swap success\t",rank,R,beta,(100*it)/SampleSize,it,acc_rate,swaps); mcmc_print_stats(kernel, stdout); acc_c = 0; // print chunk to hdf5 file status=h5write_current_chunk(h5block,log_para_chunk,log_post_chunk); h5block->offset[0]=it+1; swaps=0; } } assert(status==0); // write remaining data to the output hdf5 file int Rest=SampleSize % CHUNK; printf("[main] last iteration done %i points remain to write.\n",Rest); if (Rest > 0){ h5block->chunk_size[0]=Rest; h5block->chunk_size[1]=D; h5block->para_chunk_id=H5Screate_simple(2, h5block->chunk_size, NULL); h5block->chunk_size[0]=Rest; h5block->chunk_size[1]=1; h5block->post_chunk_id=H5Screate_simple(2, h5block->chunk_size, NULL); printf("[main] writing the remaining %i sampled parametrisations to file.\n",Rest); h5block->block[0]=Rest; h5block->block[1]=D; display_chunk_properties(h5block); status = H5Sselect_hyperslab(h5block->para_dataspace_id, H5S_SELECT_SET, h5block->offset, h5block->stride, h5block->count, h5block->block); H5Dwrite(h5block->parameter_set_id, H5T_NATIVE_DOUBLE, h5block->para_chunk_id, h5block->para_dataspace_id, H5P_DEFAULT, log_para_chunk->data); h5block->block[1]=1; printf("[main] writing their %i log-posterior values to file.\n",Rest); display_chunk_properties(h5block); status &= H5Sselect_hyperslab(h5block->post_dataspace_id, H5S_SELECT_SET, h5block->offset, h5block->stride, h5block->count, h5block->block); H5Dwrite(h5block->posterior_set_id, H5T_NATIVE_DOUBLE, h5block->post_chunk_id, h5block->post_dataspace_id, H5P_DEFAULT, log_post_chunk->data); assert(status>=0); } // annotate written sample with all necessary information //printf("[main] writing some annotation about the sampled points as hdf5 attributes.\n"); status&=H5LTset_attribute_int(h5block->file_id, "LogParameters", "MPI_RANK", &rank, 1); status&=H5LTset_attribute_ulong(h5block->file_id, "LogParameters", "SampleSize", &SampleSize, 1); status&=H5LTset_attribute_double(h5block->file_id, "LogParameters", "InverseTemperature_Beta", &beta, 1); ct=clock()-ct; double sampling_time=((double) ct)/((double) CLOCKS_PER_SEC); int ts=round(sampling_time); int hms[3]; // hours, minutes, seconds hms[0]=ts/3600; hms[1]=(ts%3600)/60; hms[2]=(ts%60); printf("# computation time spend sampling: %i:%i:%i\n",hms[0],hms[1],hms[2]); h5block->size[0]=1; status&=H5LTmake_dataset_double (h5block->file_id, "SamplingTime_s", 1, h5block->size, &sampling_time); h5block->size[0]=3; status&=H5LTmake_dataset_int(h5block->file_id, "SamplingTime_hms", 1, h5block->size, hms); if(status){ printf("[rank %i] statistics written to file.\n",rank); } return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { // test_dstegr(); if (argc != 4 + 1) { printf("Usage: %s N W K output.h5\n", argv[0]); return -1; } lapack_int N = atoi(argv[1]); double W = atof(argv[2]); lapack_int K = atoi(argv[3]); char *outname = argv[4]; // printf("N = %d\nW = %g\nK = %d\noutname = %s\n", N, W, K, outname); if (!(0 < K && K <= N && 0 < W && W < 0.5)) { printf("The arguments must satisfy 0 < K <= N and 0 < W < 0.5\n"); return -1; } double *d = calloc(N, sizeof(double)); double *e = calloc(N, sizeof(double)); double *w = calloc(N, sizeof(double)); double *z = calloc(K * N, sizeof(double)); lapack_int m = 0; lapack_int ldz = N; lapack_int *isuppz = calloc(2 * K, sizeof(lapack_int)); assert(d && e && w && z && isuppz); double cos_two_pi_W = cos(2 * 3.14159265358979323846 * W); double x; for (int i = 0; i < N; i++) { x = (0.5 * (N - 1) - i); d[i] = x * x * cos_two_pi_W; } for (int i = 0; i < N - 1; i++) e[i] = 0.5 * (i + 1) * (N - i - 1); /* lapack_int LAPACKE_dstegr( int matrix_order, char jobz, char range, */ /* lapack_int n, double* d, double* e, double vl, */ /* double vu, lapack_int il, lapack_int iu, */ /* double abstol, lapack_int* m, double* w, double* z, */ /* lapack_int ldz, lapack_int* isuppz ); */ printf("Before DSTEGR\n"); lapack_int info = LAPACKE_dstegr(LAPACK_COL_MAJOR, 'V', 'I', N, d, e, 0, 0, N - K + 1, N, 0, &m, w, z, ldz, isuppz); printf("After DSTEGR\n"); printf("K = %d\nm = %d\n", K, m); if (info) { printf("Some error occurred in DSTEGR, info = %d\n", info); return -1; } hid_t file_id; hsize_t dims_w[1] = {K}; hsize_t dims_z[2] = {K, N}; hsize_t dims_scalar[1] = {1}; herr_t status; file_id = H5Fcreate(outname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); assert(file_id >= 0); status = H5LTmake_dataset_double(file_id, "/eigenvalues", 1, dims_w, w); assert(status >= 0); status = H5LTmake_dataset_double(file_id, "/eigenvectors", 2, dims_z, z); assert(status >= 0); status = H5LTmake_dataset_double(file_id, "/W", 1, dims_scalar, &W); assert(status >= 0); status = H5LTmake_dataset_int(file_id, "/K", 1, dims_scalar, &K); assert(status >= 0); status = H5LTmake_dataset_int(file_id, "/N", 1, dims_scalar, &N); assert(status >= 0); status = H5Fclose (file_id); assert(status >= 0); /* free(d); */ /* free(e); */ /* free(w); */ /* free(z); */ /* free(isuppz); */ return 0; }
//! Export data to HDF5 file. DO NOT include 'output/' in string 'file'. void Surface::ExportHDF(const char* file, double xmin, double xmax, int Nx, double ymin, double ymax, int Ny, Interpolator* intpl) { char fname[strlen(file)+11]; strcpy(fname, "output/"); // Automatically export to directory 'output/' strcat(fname, file); // Allocate memory for output data double *x; x = new double[Nx]; double *y; y = new double[Ny]; double *data; data = new double[Ny*Nx]; // Generate output data double stepx = (xmax-xmin)/Nx; double stepy = (ymax-ymin)/Ny; herr_t status; for( int i = 0; i < Nx; i++) { x[i] = xmin + stepx * i; } for( int j = 0; j < Ny; j++) { y[j] = ymin + stepy * j; for( int i = 0; i < Nx; i++) { // The indexing is meant for consistency with python, VisIt, etc. data[i + j*Nx] = (*this)(x[i], y[j], intpl); } } // Create file and save data hid_t file_id; hsize_t dims[Dim2]; dims[0] = Ny; dims[1] = Nx; hsize_t dimx[Dim1]; dimx[0] = Nx; hsize_t dimy[Dim1]; dimy[0] = Ny; file_id = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Number of grids saved as attributes. Coodrinates saved as 1D arrays since the mesh is rectilinear. Data saved as 2D array. status = H5LTmake_dataset_double(file_id,"/x",Dim1,dimx,x); status = H5LTmake_dataset_double(file_id,"/y",Dim1,dimy,y); status = H5LTmake_dataset_double(file_id,"/data",Dim2,dims,data); status = H5LTset_attribute_int(file_id,"/x","size of x",&Nx,1); status = H5LTset_attribute_int(file_id,"/y","size of y",&Ny,1); status = H5Fclose(file_id); // Clear up memory delete [] x; delete [] y; delete [] data; // Create XMDF file that accompanies HDF5 file so as to enable VisIt reading. strcat(fname, ".xmf"); FILE *xmf = 0; xmf = fopen(fname, "w"); fprintf(xmf, "<?xml version=\"1.0\" ?>\n"); fprintf(xmf, "<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\" []>\n"); fprintf(xmf, "<Xdmf Version=\"2.0\">\n"); fprintf(xmf, " <Domain>\n"); fprintf(xmf, " <Grid Name=\"mesh\" GridType=\"Uniform\">\n"); fprintf(xmf, " <Topology TopologyType=\"2DRectMesh\" NumberOfElements=\"%d %d\"/>\n", Ny, Nx); fprintf(xmf, " <Geometry GeometryType=\"VXVY\">\n"); fprintf(xmf, " <DataItem Dimensions=\"%d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Nx); fprintf(xmf, " %s:/x\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " <DataItem Dimensions=\"%d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Ny); fprintf(xmf, " %s:/y\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " </Geometry>\n"); fprintf(xmf, " <Attribute Name=\"data\" AttributeType=\"Scalar\" Center=\"Node\">\n"); fprintf(xmf, " <DataItem Dimensions=\"%d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Ny, Nx); fprintf(xmf, " %s:/data\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " </Attribute>\n"); fprintf(xmf, " </Grid>\n"); fprintf(xmf, " </Domain>\n"); fprintf(xmf, "</Xdmf>\n"); fclose(xmf); }