/** 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);
}
