int
setup()
{
int initial_set();
int prompt;
/* print banner, get initial parameters */
prompt = initial_set();
if(prompt == 2)return prompt;
/* initialize the node random number generator */
initialize_prn( &node_prn, iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
/* set up neighbor pointers and comlink structures
code for this routine is in com_machine.c */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
node0_printf("Finished setup\n"); fflush(stdout);
return prompt;
}
int setup() {
int prompt;
/* print banner, get volume */
prompt=initial_set();
if(prompt == 2)return prompt;
/* initialize the node random number generator */
initialize_prn( &node_prn, param.iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* Initialize fermion links as unallocated */
// init_ferm_links(&fn_links, &ks_act_paths);
// init_ferm_links(&fn_links_dmdu0, &ks_act_paths_dmdu0);
/* set up nearest neighbor gathers */
make_nn_gathers();
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
/* set up K-S phase vectors, boundary conditions */
phaseset();
return(prompt);
}
int setup(void) {
int prompt, dir;
/* print banner, get volume */
prompt=initial_set();
if(prompt == 2)return prompt;
/* initialize the node random number generator */
initialize_prn( &node_prn, param.iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
FORALLUPDIR(dir){
boundary_phase[dir] = 0.;
}
/* set up nearest neighbor gathers */
make_nn_gathers();
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
/* set up K-S phase vectors, boundary conditions */
phaseset();
twist_in = OFF;
/* Create clover structure */
gen_clov = create_clov();
return(prompt);
}
int
setup(void)
{
int prompt;
/* print banner, get volume, seed */
prompt = initial_set();
/* initialize the node random number generator */
initialize_prn( &node_prn, iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
/* set up neighbor pointers and comlink structures */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
node0_printf("Made 3nn gathers\n"); fflush(stdout);
/* set up K-S phase vectors, boundary conditions */
phaseset();
node0_printf("Finished setup\n"); fflush(stdout);
return( prompt );
}
int
setup()
{
int prompt;
/* print banner, get volume, nflavors1,nflavors2, seed */
prompt = initial_set();
if(prompt == 2)return prompt;
/* initialize the node random number generator */
initialize_prn( &node_prn, iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
/* Mark t_longlink and t_fatlink unallocted */
// init_ferm_links(&fn_links, &ks_act_paths);
/* set up neighbor pointers and comlink structures
code for this routine is in com_machine.c */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
node0_printf("Made 3nn gathers\n"); fflush(stdout);
/* set up K-S phase vectors, boundary conditions */
phaseset();
node0_printf("Finished setup\n"); fflush(stdout);
return( prompt );
}
int setup() {
int prompt;
/* print banner, get volume */
prompt=initial_set();
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* set up nearest neighbor gathers */
make_nn_gathers();
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
/* set up K-S phase vectors, boundary conditions */
phaseset();
/* Create clover structure */
gen_clov = create_clov();
#ifdef HAVE_QDP
{
int i;
for(i=0; i<4; ++i) {
shiftdirs[i] = QDP_neighbor[i];
shiftdirs[i+4] = neighbor3[i];
}
for(i=0; i<8; ++i) {
shiftfwd[i] = QDP_forward;
shiftbck[i] = QDP_backward;
}
}
#endif
return(prompt);
}
int setup() {
int initial_set();
void make_gen_pt();
void make_3n_gathers(),
setup_layout();
int prompt;
//#ifdef HAVE_QDP
// int i;
//#endif
/* print banner, get volume, seed */
prompt=initial_set();
/* initialize the node random number generator */
initialize_prn( &node_prn, iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
//init_ferm_links(&fn_links, &ks_act_paths);
/* set up neighbor pointers and comlink structures
code for this routine is in com_machine.c */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
#ifdef FN
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
node0_printf("Made 3nn gathers\n"); fflush(stdout);
#endif
/* set up K-S phase vectors, boundary conditions */
phaseset();
//#if HAVE_QOP
// /* Initialize QOP */
// if(initialize_qop() != QOP_SUCCESS){
// node0_printf("setup: Error initializing QOP\n");
// terminate(1);
// }
//#endif
//#ifdef HAVE_QDP
// make_rand_seed();
//node0_printf("Made random seed\n"); fflush(stdout);
//
// for(i=0; i<4; ++i) {
// shiftdirs[i] = QDP_neighbor[i];
// shiftdirs[i+4] = neighbor3[i];
// }
// for(i=0; i<8; ++i) {
// shiftfwd[i] = QDP_forward;
// shiftbck[i] = QDP_backward;
// }
//#endif
node0_printf("Finished setup\n"); fflush(stdout);
return( prompt );
}
void setup() {
/* Set up lattice */
broadcast_bytes((char *)&nx,sizeof(int));
broadcast_bytes((char *)&ny,sizeof(int));
broadcast_bytes((char *)&nz,sizeof(int));
broadcast_bytes((char *)&nt,sizeof(int));
setup_layout();
make_lattice();
}
int setup() {
int prompt;
/* print banner, get volume, nflavors, seed */
prompt=initial_set();
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* set up neighbor pointers and comlink structures */
make_nn_gathers();
return(prompt);
}
int setup_H_cl() {
int initial_set();
int prompt;
/* print banner, get volume */
prompt=initial_set();
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* set up nearest neighbor gathers */
make_nn_gathers();
return(prompt);
}
int
setup()
{
int prompt;
#ifdef HAVE_QDP
int i;
#endif
/* print banner, get volume, seed */
prompt = initial_set();
/* initialize the node random number generator */
initialize_prn( &node_prn, iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
/* Mark fermion links as unallocated */
init_ferm_links(&fn_links);
#ifdef DM_DU0
init_ferm_links(&fn_links_dmdu0);
#endif
/* set up neighbor pointers and comlink structures */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
make_3n_gathers();
node0_printf("Made 3nn gathers\n"); fflush(stdout);
/* set up K-S phase vectors, boundary conditions */
phaseset();
#ifdef HAVE_QDP
for(i=0; i<4; ++i) {
shiftdirs[i] = QDP_neighbor[i];
shiftdirs[i+4] = neighbor3[i];
}
for(i=0; i<8; ++i) {
shiftfwd[i] = QDP_forward;
shiftbck[i] = QDP_backward;
}
#endif
node0_printf("Finished setup\n"); fflush(stdout);
return( prompt );
}
int setup(void) {
int prompt;
/* print banner, get volume */
prompt=initial_set();
if(prompt == 2)return prompt;
/* initialize the node random number generator */
initialize_prn( &node_prn, param.iseed, volume+mynode() );
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* set up nearest neighbor gathers */
make_nn_gathers();
return(prompt);
}
int setup() {
int prompt;
/* print banner, get volume, nflavors, seed */
prompt=initial_set();
/* initialize the node random number generator */
initialize_prn(&node_prn,iseed,volume+mynode());
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* set up neighbor pointers and comlink structures */
make_nn_gathers();
/* Create clover structure */
gen_clov = create_clov();
return(prompt);
}
// -----------------------------------------------------------------
int setup() {
int prompt;
// Print banner, get volume, seed
prompt = initial_set();
// Initialize the node random number generator
initialize_prn(&node_prn, iseed, volume + mynode());
// Initialize the layout functions, which decide where sites live
setup_layout();
// Allocate space for lattice, set up coordinate fields
make_lattice();
// Set up neighbor pointers and comlink structures
make_nn_gathers();
// Allocate space for fields
make_fields();
// Set up staggered phase vectors, boundary conditions
phaseset();
return prompt;
}
int setup() {
int prompt;
/* print banner, get volume */
prompt=initial_set();
if(prompt == 2)return prompt;
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
/* Initialize fermion links as unallocated */
// init_ferm_links(&fn_links, &ks_act_paths);
// init_ferm_links(&fn_links_dmdu0, &ks_act_paths_dmdu0);
/* set up nearest neighbor gathers */
make_nn_gathers();
/* set up 3rd nearest neighbor pointers and comlink structures
code for this routine is below */
return(prompt);
}
int
setup()
{
int prompt;
/* print banner, get initial parameters */
prompt = initial_set();
/* Initialize the layout functions, which decide where sites live */
setup_layout();
/* allocate space for lattice, set up coordinate fields */
make_lattice();
node0_printf("Made lattice\n"); fflush(stdout);
/* set up neighbor pointers and comlink structures */
make_nn_gathers();
node0_printf("Made nn gathers\n"); fflush(stdout);
node0_printf("Finished setup\n"); fflush(stdout);
return prompt;
}
SearchScreen::SearchScreen()
{
int i;
setup_layout();
/* Connect 0-9 and A-Å */
for (i = 0; i < 39; i++) {
QObject::connect(&b_keys[i], &QPushButton::clicked,
this, &SearchScreen::key_pressed);
}
QObject::connect(&b_backspace, &QPushButton::clicked,
this, &SearchScreen::backspace_pressed);
QObject::connect(&b_enter, &QPushButton::clicked,
this, &SearchScreen::enter_pressed);
QObject::connect(&b_cancel, &QPushButton::clicked,
this, &SearchScreen::cancel_pressed);
QObject::connect(&b_spacebar, &QPushButton::clicked,
this, &SearchScreen::spacebar_pressed);
}
void
AngleControl::compute_layout(Rollout *ro, layout_data* pos, int& current_y)
{
setup_layout(ro, pos, current_y);
const TCHAR* label_text = caption->eval()->to_string();
int label_height = (_tcslen(label_text) != 0) ? ro->text_height + SPACING_BEFORE - 2 : 0;
Value *val;
if((val = control_param(diameter)) != &unsupplied)
m_diameter = val->to_int();
else if((val = control_param(width)) != &unsupplied)
m_diameter = val->to_int();
else if((val = control_param(height)) != &unsupplied)
m_diameter = val->to_int();
else
m_diameter = 64;
pos->width = m_diameter;
process_layout_params(ro, pos, current_y);
pos->height = label_height + m_diameter;
current_y = pos->top + pos->height;
}
void
FooControl::add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y)
{
HWND label, edit_box, spinner;
int left, top, width, height;
SIZE size;
const TCHAR* text = caption->eval()->to_string();
/* add 3 controls for a spinner: the label static, value custeditbox, & spinner itself,
* label & edit box are given IDs that are the spinner id * control_count & that + 1, to make
* sure they are unique and decodable */
parent_rollout = ro;
control_ID = next_id();
WORD label_id = next_id();
WORD edit_box_id = next_id();
// compute bounding box, apply layout params
layout_data pos;
setup_layout(ro, &pos, current_y);
Value* fw = control_param(fieldwidth);
int spin_width = (fw == &unsupplied) ? ro->current_width / 2 : fw->to_int() + 10;
GetTextExtentPoint32(ro->rollout_dc, text, static_cast<int>(_tcslen(text)), &size);
int lbl_width = size.cx;
int orig_width = lbl_width + spin_width;
pos.width = orig_width + 2;
pos.left = pos.left + ro->current_width - pos.width;
pos.height = ro->text_height + 3;
process_layout_params(ro, &pos, current_y);
// place spinner elements
int cex = (fw == &unsupplied) ? pos.width * lbl_width / orig_width : pos.width - spin_width;
cex = min(cex, pos.width);
width = lbl_width; height = ro->text_height;
left = pos.left + cex - width - 1; top = pos.top;
label = CreateWindow(_T("STATIC"),
text,
WS_VISIBLE | WS_CHILD | WS_GROUP,
left, top, width, height,
parent, (HMENU)label_id, hInstance, NULL);
width = pos.width - cex - 13; height = ro->text_height + 3;
left = pos.left + cex + 1;
edit_box = CreateWindowEx(0,
CUSTEDITWINDOWCLASS,
_T(""),
WS_VISIBLE | WS_CHILD | WS_TABSTOP | WS_GROUP,
left, top, width, height,
parent, (HMENU)edit_box_id, hInstance, NULL);
left += width; width = 10;
spinner = CreateWindowEx(0,
SPINNERWINDOWCLASS,
_T(""),
WS_VISIBLE | WS_CHILD,
left, top, width, height,
parent, (HMENU)control_ID, hInstance, NULL);
SendDlgItemMessage(parent, label_id, WM_SETFONT, (WPARAM)ro->font, 0L);
SendDlgItemMessage(parent, edit_box_id, WM_SETFONT, (WPARAM)ro->font, 0L);
/* setup the spinner control */
ISpinnerControl* spin = GetISpinner(spinner);
Value* range = control_param(range);
Value* type = control_param(type);
Value* scaleval = control_param(scale);
if (type == n_integer)
spin_type = EDITTYPE_INT;
else if (type == n_worldUnits)
spin_type = EDITTYPE_UNIVERSE;
else if (type == n_float || type == &unsupplied)
spin_type = EDITTYPE_FLOAT;
else
throw TypeError (MaxSDK::GetResourceStringAsMSTR(IDS_SPINNER_TYPE_MUST_BE_INTEGER_OR_FLOAT), type);
if (ro->init_values)
{
if (range == &unsupplied)
{
min = 0.0f; max = 100.0f; value = 0.0f;
}
else if (is_point3(range))
{
Point3 p = range->to_point3();
min = p.x; max = p.y; value = p.z;
}
else
throw TypeError (MaxSDK::GetResourceStringAsMSTR(IDS_SPINNER_RANGE_MUST_BE_A_VECTOR), range);
if (scaleval == &unsupplied)
{
scale = (spin_type == EDITTYPE_INT) ? 1.0f : 0.1f;
}
else
scale = scaleval->to_float();
}
spin->LinkToEdit(edit_box, spin_type);
spin->SetScale(scale);
if (spin_type == EDITTYPE_INT)
{
spin->SetLimits((int)min, (int)max, FALSE);
spin->SetValue((int)value, FALSE);
}
else if (spin_type == EDITTYPE_UNIVERSE)
{
spin->SetLimits(min, max, FALSE);
spin->SetValue(value, FALSE);
}
else
{
spin->SetLimits(min, max, FALSE);
spin->SetValue(value, FALSE);
}
ReleaseISpinner(spin);
}
static gauge_file *file_scan_scidac(char *filename, int serpar){
QIO_Layout layout;
QIO_Filesystem fs;
QIO_Reader *infile;
QIO_RecordInfo recinfo;
QIO_String *recxml;
int status;
int typesize;
su3_matrix *dest = NULL;
gauge_file *gf;
int ndim;
int dims[4];
/* Read header to get lattice dimensions and close the file */
read_lat_dim_scidac(filename, &ndim, dims);
nx = dims[0]; ny = dims[1]; nz = dims[2]; nt = dims[3];
volume = nx*ny*nz*nt;
/* Finish setting up, now we know the dimensions */
broadcast_bytes((char *)&nx,sizeof(int));
broadcast_bytes((char *)&ny,sizeof(int));
broadcast_bytes((char *)&nz,sizeof(int));
broadcast_bytes((char *)&nt,sizeof(int));
setup_layout();
/* Build the layout structure */
build_qio_layout(&layout);
/* Define the I/O nodes */
build_qio_filesystem(&fs);
/* Make a dummy gauge file structure for MILC use */
gf = setup_input_gauge_file(filename);
/* Set the filename in the gauge_file structure */
gf->filename = filename;
/* Reopen file for reading */
QIO_verbose(QIO_VERB_OFF);
infile = open_scidac_input(filename, &layout, &fs, serpar);
if(infile == NULL)terminate(1);
/* Check the record type (double or single precision) */
recxml = QIO_string_create();
status = QIO_read_record_info(infile, &recinfo, recxml);
if(status)terminate(1);
typesize = QIO_get_typesize(&recinfo);
/* Read the lattice field as single or double precision according to
the type size (bytes in a single SU(3) matrix) */
if(typesize == 72)
status = read_F3_M_to_null(infile, recxml, dest, LATDIM);
else if (typesize == 144)
status = read_D3_M_to_null(infile, recxml, dest, LATDIM);
else
{
node0_printf("file_scan_scidac: Bad typesize %d\n",typesize);
terminate(1);
}
if(status){
node0_printf("ERROR scanning file\n");
} else {
node0_printf("SUCCESS scanning file\n");
}
/* Discard for now */
QIO_string_destroy(recxml);
/* Close the file */
QIO_close_read(infile);
return gf;
}
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;
}
