/* Close file */
static void
close_vector_current_file(QIO_Writer *outfile){
QIO_close_write(outfile);
}
int qio_test(int output_volfmt, int output_serpar, int ildgstyle,
int input_volfmt, int input_serpar, int argc, char *argv[]){
float array_in[NARRAY], array_out[NARRAY];
float *field_in[NREAL], *subset_in[NREAL],
*field_out[NREAL], *subset_out[NREAL];
suN_matrix *field_su3_out[NMATRIX], *field_su3_in[NMATRIX];
QIO_Writer *outfile;
QIO_Reader *infile;
float diff_field = 0, diff_array = 0, diff_su3 = 0, diff_subset = 0;
QMP_thread_level_t provided;
int status;
int sites_on_node = 0;
int i,volume;
char filename[] = "binary_test";
int dim = 4;
int lower[4] = {1, 0, 0, 2};
int upper[4] = {2, 3, 3, 2};
char myname[] = "qio_test";
/* Start message passing */
QMP_init_msg_passing(&argc, &argv, QMP_THREAD_SINGLE, &provided);
this_node = mynode();
printf("%s(%d) QMP_init_msg_passing done\n",myname,this_node);
/* Lattice dimensions */
lattice_dim = 4;
lattice_size[0] = 8;
lattice_size[1] = 4;
lattice_size[2] = 4;
lattice_size[3] = 4;
volume = 1;
for(i = 0; i < lattice_dim; i++){
volume *= lattice_size[i];
}
/* Set the mapping of coordinates to nodes */
if(setup_layout(lattice_size, 4, QMP_get_number_of_nodes())!=0)
return 1;
printf("%s(%d) layout set for %d nodes\n",myname,this_node,
QMP_get_number_of_nodes());
sites_on_node = num_sites(this_node);
/* Build the layout structure */
layout.node_number = node_number;
layout.node_index = node_index;
layout.get_coords = get_coords;
layout.num_sites = num_sites;
layout.latsize = lattice_size;
layout.latdim = lattice_dim;
layout.volume = volume;
layout.sites_on_node = sites_on_node;
layout.this_node = this_node;
layout.number_of_nodes = QMP_get_number_of_nodes();
/* Open the test output file */
outfile = open_test_output(filename, output_volfmt, output_serpar,
ildgstyle, myname);
if(outfile == NULL)return 1;
/* If this is not the ILDG file test */
if(ildgstyle == QIO_ILDGNO){
/* Create the test output field */
status = vcreate_R(field_out, NREAL);
if(status)return status;
/* Set some values for the field */
vset_R(field_out, NREAL);
/* Write the real test field */
status = write_real_field(outfile, NREAL, field_out, myname);
if(status)return status;
/* Write a subset of the real test field */
status = write_real_field_subset(outfile, NREAL, field_out,
lower, upper, dim, myname);
if(status)return status;
/* Set some values for the global array */
for(i = 0; i < NARRAY; i++)
array_out[i] = i;
/* Write the real global array */
status = write_real_global(outfile, NARRAY, array_out, myname);
if(status)return status;
}
/* Create the test output su3 field */
status = vcreate_M(field_su3_out, NMATRIX);
if(status)return status;
/* Set some values for the su3 field */
vset_M(field_su3_out, NMATRIX);
/* Write the su3 test field */
status = write_su3_field(outfile, NMATRIX, field_su3_out, myname);
if(status)return status;
/* Close the file */
QIO_close_write(outfile);
printf("%s(%d): Closed file for writing\n",myname,this_node);
/* Set up a dummy input field */
status = vcreate_R(field_in, NREAL);
if(status)return status;
/* Set up a dummy input field for subset */
status = vcreate_R(subset_in, NREAL);
if(status)return status;
/* Set up a dummy input SU(N) field */
status = vcreate_M(field_su3_in, NMATRIX);
if(status)return status;
/* Open the test file for reading */
infile = open_test_input(filename, input_volfmt, input_serpar, myname);
if(infile == NULL)return 1;
if(ildgstyle == QIO_ILDGNO){
/* Peek at the field record */
status = peek_record_info(infile, myname);
if(status != QIO_SUCCESS)return status;
/* Skip the record */
#if(0)
/* Skip the field */
status = QIO_next_record(infile);
if(status != QIO_SUCCESS)return status;
#else
/* Read the field record */
printf("%s(%d) reading real field\n",myname,this_node); fflush(stdout);
status = read_real_field(infile, NREAL, field_in, myname);
if(status)return status;
#endif
/* Read the subset of the field */
printf("%s(%d) reading subset of real field\n",
myname,this_node); fflush(stdout);
status = read_real_field_subset(infile, NREAL, subset_in, myname);
if(status)return status;
/* Read the global array record */
printf("%s(%d) reading global field\n",myname,this_node); fflush(stdout);
status = read_real_global(infile, NARRAY, array_in, myname);
if(status)return status;
}
/* Read the su3 field record */
printf("%s(%d) reading su3 field\n",myname,this_node); fflush(stdout);
status = read_su3_field(infile, NMATRIX, field_su3_in, myname);
if(status)return status;
/* Close the file */
QIO_close_read(infile);
printf("%s(%d): Closed file for reading\n",myname,this_node);
if(ildgstyle == QIO_ILDGNO){
/* Compare the input and output fields */
diff_field = vcompare_R(field_out, field_in, NREAL);
if(this_node == 0){
printf("%s(%d): Comparison of in and out real fields |in - out|^2 = %e\n",
myname,this_node,diff_field);
}
/* Create the subset output field */
status = vcreate_R(subset_out, NREAL);
if(status)return status;
/* Copy the subset */
vsubset_R(subset_out, field_out, lower, upper, NREAL);
/* Compare the input and output subsets */
diff_subset = vcompare_R(subset_out, subset_in, NREAL);
if(this_node == 0){
printf("%s(%d): Comparison of subsets of in and out real fields |in - out|^2 = %e\n",
myname,this_node,diff_subset);
}
/* Compare the input and output global arrays */
diff_array = vcompare_r(array_out, array_in, NREAL);
if(this_node == 0){
printf("%s(%d): Comparison of in and out real global arrays |in - out|^2 = %e\n",
myname, this_node, diff_array);
}
}
/* Compare the input and output suN fields */
diff_su3 = vcompare_M(field_su3_out, field_su3_in, NMATRIX);
if(this_node == 0){
printf("%s(%d): Comparison of in and out suN fields |in - out|^2 = %e\n",
myname, this_node, diff_field);
}
/* Clean up */
if(ildgstyle == QIO_ILDGNO){
vdestroy_R(field_out, NREAL);
vdestroy_R(field_in, NREAL);
vdestroy_R(subset_in, NREAL);
vdestroy_R(subset_out, NREAL);
}
vdestroy_M(field_su3_in, NMATRIX);
vdestroy_M(field_su3_out, NMATRIX);
/* Shut down QMP */
QMP_finalize_msg_passing();
/* Report result */
if(diff_field + diff_subset + diff_su3 + diff_array > 0){
printf("%s(%d): Test failed\n",myname,this_node);
return 1;
}
printf("%s(%d): Test passed\n",myname,this_node);
return 0;
}
/* The QIO file is closed after writing the lattice */
gauge_file *save_scidac(char *filename, int volfmt, int serpar, int ildgstyle,
char *stringLFN){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Writer *outfile;
int status;
field_offset src = F_OFFSET(link[0]);
gauge_file *gf;
char *info;
QIO_String *filexml;
QIO_String *recxml;
char default_file_xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><title>MILC ILDG archival gauge configuration</title>";
QIO_verbose(QIO_VERB_OFF);
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O system */
build_qio_filesystem(&fs);
/* Make a dummy gauge file structure for MILC use */
gf = setup_output_gauge_file();
/* Set the filename in the gauge_file structure */
gf->filename = filename;
/* Open file for writing */
filexml = QIO_string_create();
QIO_string_set(filexml, default_file_xml);
outfile = open_scidac_output(filename, volfmt, serpar, ildgstyle,
stringLFN, &layout, &fs, filexml);
if(outfile == NULL)terminate(1);
QIO_string_destroy(filexml);
/* Create the QCDML string for this configuration */
info = create_QCDML();
recxml = QIO_string_create();
QIO_string_set(recxml, info);
/* Write the lattice field */
status = write_F3_M_from_site(outfile, recxml, src, LATDIM);
if(status)terminate(1);
/* Discard for now */
QIO_string_destroy(recxml);
/* Write information */
if(volfmt == QIO_SINGLEFILE){
node0_printf("Saved gauge configuration serially to binary file %s\n",
filename);
}
else if(volfmt == QIO_MULTIFILE){
node0_printf("Saved gauge configuration as multifile to binary file %s\n",
filename);
}
else if(volfmt == QIO_PARTFILE){
node0_printf("Saved gauge configuration in partition format to binary file %s\n",
filename);
}
node0_printf("Time stamp %s\n",gf->header->time_stamp);
node0_printf("Checksums %x %x\n",
QIO_get_writer_last_checksuma(outfile),
QIO_get_writer_last_checksumb(outfile));
/* Close the file */
QIO_close_write(outfile);
free_QCDML(info);
return gf;
}
void w_close_complex_scidac_file(QIO_Writer *outfile)
{
QIO_close_write(outfile);
}
void close_scidac_output(QIO_Writer *outfile)
{
QIO_close_write(outfile);
}
