diff --git a/applications/test/ensightFoamReader/Make/files b/applications/test/ensightFoamReader/Make/files new file mode 100644 index 0000000000..c8089bfc49 --- /dev/null +++ b/applications/test/ensightFoamReader/Make/files @@ -0,0 +1,3 @@ +udr_checker.c + +EXE = $(FOAM_USER_APPBIN)/ensightFoamReader-udr_checker diff --git a/applications/test/ensightFoamReader/Make/options b/applications/test/ensightFoamReader/Make/options new file mode 100644 index 0000000000..750aeb0d14 --- /dev/null +++ b/applications/test/ensightFoamReader/Make/options @@ -0,0 +1,5 @@ +EXE_INC = \ + -DUSERD_API_203 + +EXE_LIBS = \ + -luserd-foam diff --git a/applications/test/ensightFoamReader/README b/applications/test/ensightFoamReader/README new file mode 100644 index 0000000000..f12e6fd40f --- /dev/null +++ b/applications/test/ensightFoamReader/README @@ -0,0 +1,116 @@ +udr_checker +----------- + +udr_checker.c is a routine that can be used to debug EnSight User-defined +readers. It exists because of the difficulty of debugging dynamic shared +libraries when you don't have the source for the calling program (EnSight). + +If udr_checker.c is compiled and linked with your reader source code (including +access to any libraries needed, and the global_extern.h file), it will exercise +most options of you reader, giving feedback as it goes. The resulting +executable can be debugged using your favorite debugger. And if you have +memory/bounds checking software (such as purify), you can (and should) run it +with this executable to make sure that you are not overwriting things. Readers +that bash memory will cause problems when run with EnSight! + +You will note that the Makefile provided with the readers in the EnSight +distribution have a "checker" object. If you do a "make checker" instead of +just a "make", the "checker"executable will be produced. You may need to +modify these makefiles slightly if the locations of your reader files are +different than the normal. + + +-------------------------------------- +Once the "checker" executable exists, you can run the checker program by simply +invoking it: + +> checker + +And you will be prompted for the type of information that you provide in the +EnSight Data Reader dialog, namely: + +The path +filename_1 +[filename_2] Only if your reader uses two fields +swapbytes flag + Only if your reader implements extra GUI + one flag value per line + one field string per line + +There are certain command line options that you can use to control some aspects +of the checker program. One of the more useful is the ability to provide the +input just described in a file. This is done in this fashion: + +> checker -p + +And would be a simple ascii file with 3 [0r 4] lines: +line 1: the path +line 2: filename_1 +line 3: [filename_2] (if two_fields is TRUE) +line 3 or 4: 0 or 1, for swapbytes (0 is FALSE, 1 is TRUE) +remaining lines 0 or 1 for toggle disable enabled + one line for each toggle + 0 - num_pulldown_values for pulldown choice + one line for each pulldown + strings + one line for each field + +example playfile for an EnSight Gold reader casefile (entitled cube.play) +could look something like the following: (Note: two_fields is FALSE) +------------------- + +/usr/local/bin/data/ens +cube.case +0 + + +And you would invoke checker as: + +> checker -p check.play + +Another example playfile +with swapbytes 0, +two enabled toggles, +three pulldowns with the value 0 chosen +and a single field "sample field value" + +could look something like the following:: +---------------------- + +/mydirectory/subdir/ +myfile +0 +1 +1 +0 +0 +0 +sample field value + + +Other command line arguments are: +--------------------------------- +-server_number For checking server number routines. If you use this + option, you will be prompted for the total number of + servers and the current server number. These will then be + used in the calls to the server number routines. + +-gts # For specifying the geometry timestep to test. The default + is step 0. + The # is the (zero based) time step to read for geometry. + +-vts # For specifying the variable timestep to test. The default + is step 0. + The # is the (zero based) time step to read for variables. + + + +Testing optional routines using #defines +----------------------------------------- +For optional routines, such as the extra_gui, or var_extract_gui routines, you +must uncomment the proper #define in udr_checker.c + +Currently the ones available are: + +#define _EGS for extra gui routines +#define _VES for var extract gui routines diff --git a/applications/test/ensightFoamReader/ensightFoamReaderTest b/applications/test/ensightFoamReader/ensightFoamReaderTest new file mode 100755 index 0000000000..5dafa8dfaf --- /dev/null +++ b/applications/test/ensightFoamReader/ensightFoamReaderTest @@ -0,0 +1,92 @@ +#!/bin/sh +#------------------------------------------------------------------------------ +# ========= | +# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox +# \\ / O peration | +# \\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd. +# \\/ M anipulation | +#------------------------------------------------------------------------------- +# License +# This file is part of OpenFOAM. +# +# OpenFOAM is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# OpenFOAM is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with OpenFOAM; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +# +# Script +# ensightFoamReaderTest +# +# Description +# start ensightFoamReader-udr_checker +# +#------------------------------------------------------------------------------ +usage() { + while [ "$#" -ge 1 ]; do echo "$1"; shift; done + cat</dev/null || usage "directory does not exist: '$2'" + shift 2 + ;; + *) + usage "unknown option/argument: '$*'" + ;; + esac +done + + +# check existence of essential files +for check in system/controlDict system/fvSchemes system/fvSolution +do + [ -s "$check" ] || usage "file does not exist: '$check'" +done + + +# export values that might be needed +export FOAM_CASE=$PWD +export FOAM_CASENAME=${PWD##*/} + +pathName=${PWD%/*} + +playFile=/tmp/ensightFoamReader.$$ +trap "rm -f $playFile 2>/dev/null; exit 0" EXIT TERM INT + +cat << PLAY_FILE > $playFile +$pathName +$FOAM_CASENAME +0 +PLAY_FILE + +echo "ensightFoamReader-udr_checker -p $playFile" + +ensightFoamReader-udr_checker -p $playFile + +#------------------------------------------------------------------------------ diff --git a/applications/test/ensightFoamReader/global_extern.h b/applications/test/ensightFoamReader/global_extern.h new file mode 120000 index 0000000000..09b4ffb70c --- /dev/null +++ b/applications/test/ensightFoamReader/global_extern.h @@ -0,0 +1 @@ +../../utilities/postProcessing/graphics/ensightFoamReader/global_extern.h \ No newline at end of file diff --git a/applications/test/ensightFoamReader/global_extern_proto.h b/applications/test/ensightFoamReader/global_extern_proto.h new file mode 120000 index 0000000000..7c23ba48d9 --- /dev/null +++ b/applications/test/ensightFoamReader/global_extern_proto.h @@ -0,0 +1 @@ +../../utilities/postProcessing/graphics/ensightFoamReader/global_extern_proto.h \ No newline at end of file diff --git a/applications/test/ensightFoamReader/udr_checker-80.c b/applications/test/ensightFoamReader/udr_checker-80.c new file mode 100644 index 0000000000..0cbbceba18 --- /dev/null +++ b/applications/test/ensightFoamReader/udr_checker-80.c @@ -0,0 +1,5396 @@ +/*---------------------------------- + * User Defined Reader - checker + *----------------------------------*/ + +/******************************************************************** + * + * **************************************** + * Copyright 2004 Computational Engineering International, Inc. + * All Rights Reserved. + * + * Restricted Rights Legend + * + * Use, duplication, or disclosure of this + * software and its documentation by the + * Government is subject to restrictions as + * set forth in subdivision [(b)(3)(ii)] of + * the Rights in Technical Data and Computer + * Software clause at 52.227-7013. + *******************************************************************/ + +/*---------------------------------------------------------------------- + * MAJOR ROUTINES ACCESS: (VERSION 2.00) Gold_Userd API + * + * Get the name of the reader + * ========================== + * USERD_get_name_of_reader + * USERD_get_extra_gui_numbers (optional) + * USERD_get_extra_gui_defaults (optional) + * + * Get the reader version + * ====================== + * USERD_get_reader_version + * + * Set the filenames, gather timeset and time info + * =============================================== + * USERD_set_extra_gui_data (optional) + * USERD_set_server_number + * USERD_set_filenames + * USERD_get_number_of_timesets + * USERD_get_geom_timeset_number + * + * for each timeset: + * USERD_get_timeset_description + * USERD_get_num_of_time_steps + * USERD_get_sol_times + * + * USERD_set_time_set_and_step + * + * + * Gather variable and time info + * ============================= + * USERD_get_number_of_variables + * USERD_get_gold_variable_info + * + * + * Get initial part building info + * ============================== + * USERD_set_time_set_and_step + * USERD_get_changing_geometry_status + * USERD_get_node_label_status + * USERD_get_element_label_status + * USERD_get_number_of_files_in_dataset + * USERD_get_dataset_query_file_info + * USERD_get_descrip_lines (geometry) + * USERD_get_number_of_model_parts + * USERD_get_gold_part_build_info + * USERD_get_ghosts_in_model_flag + * USERD_get_maxsize_info + * USERD_get_ghosts_in_block_flag (if any ghost cells in model) + * USERD_get_model_extents **OR** + * USERD_get_part_coords **AND/OR** + * USERD_get_block_coords_by_component + * + * + * + * Part Builder + * ============ + * + * both unstructured and structured + * -------------------------------- + * USERD_set_time_set_and_step + * + * if unstructured + * --------------- + * USERD_get_part_element_ids_by_type + * USERD_get_part_elements_by_type + * + * if any nsided elements: + * USERD_get_nsided_conn + * + * if any nfaced elements: + * USERD_get_nfaced_nodes_per_face + * USERD_get_nfaced_conn + * + * USERD_get_part_coords + * USERD_get_part_node_ids + * + * else if structured + * ------------------ + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * USERD_get_block_ghost_flags + * USERD_get_part_node_ids (If node ids given) + * USERD_get_part_element_ids_by_type (If element ids given) + * + * both again + * ---------- + * USERD_get_border_availability (If border representation + * USERD_get_border_elements_by_type is selected) + * + * USERD_stop_part_building + * + * + * Changing geometry + * ================= + * + * changing coords only + * -------------------- + * USERD_set_time_set_and_step + * USERD_get_descrip_lines + * USERD_get_part_coords + * USERD_get_block_coords_by_component + * + * changing connectivity + * --------------------- + * USERD_set_time_set_and_step + * USERD_get_descrip_lines + * USERD_get_number_of_model_parts + * USERD_get_gold_part_build_info + * USERD_get_ghosts_in_model_flag + * USERD_get_ghosts_in_block_flag (If any ghost cells in model) + * USERD_get_model_extents **OR** + * USERD_get_part_coords **AND/OR** + * USERD_get_block_coords_by_component + * USERD_get_part_element_ids_by_type + * USERD_get_part_elements_by_type + * USERD_get_part_coords + * USERD_get_part_node_ids + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * USERD_get_block_ghost_flags (If ghost cells in part) + * USERD_get_part_node_ids (If node ids given) + * USERD_get_part_element_ids_by_type (If element ids given) + * + * USERD_get_border_availability (If border representation + * USERD_get_border_elements_by_type is selected) + * + * + * Loading Variables + * ================== + * + * constants + * --------- + * USERD_set_time_set_and_step + * USERD_get_constant_val + * + * scalars/vectors/tensors + * ----------------------- + * USERD_get_description_lines + * USERD_set_time_set_and_step + * USERD_get_var_by_component + * + * + * Node or Element queries over time + * ================================= + * USERD_get_var_value_at_specific + * + * + * At 2.03, added: + * --------------- + * + * Materials + * ========= + * USERD_get_number_of_material_sets + * USERD_get_matf_set_info + * + * If any material sets in the model (calls once per material set) + * USERD_get_number_of_materials + * USERD_get_matf_var_info + * + * For each element type of each part containing material ids + * USERD_size_matf_data + * USERD_load_matf_data + * + * + * At 2.04, added: + * --------------- + * USERD_get_uns_failed_params - Sets params used in element failure + * + * + *----------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------- + * MAJOR ROUTINES ACCESS: (Version 1.00) original API + * + * Get the name of the reader + * ========================== + * USERD_get_name_of_reader + * USERD_get_extra_gui_numbers (optional #define _EGS) + * USERD_get_extra_gui_defaults (optional #define _EGS) + * + * Set the filenames + * ================= + * USERD_set_extra_gui_data (optional #define _EGS) + * USERD_set_filenames + * USERD_get_number_of_time_steps + * USERD_get_solution_times + * USERD_set_time_step + * + * + * Gather variable and time info + * ============================= + * USERD_get_number_of_variables + * USERD_get_variable_info + * + * + * Get initial part building info + * ============================== + * USERD_set_time_step + * USERD_get_changing_geometry_status + * USERD_get_node_label_status + * USERD_get_element_label_status + * USERD_get_number_of_files_in_dataset + * USERD_get_dataset_query_file_info + * USERD_get_description_lines (geometry) + * USERD_get_number_of_model_parts + * USERD_get_part_build_info + * USERD_get_number_global_nodes + * USERD_get_global_coords + * USERD_get_block_coords_by_component + * + * Failure Info + * ============ + * USERD_get_uns_failed_params + * + * + * Part Builder + * ============ + * USERD_set_time_step + * USERD_get_global_coords + * USERD_get_global_node_ids + * USERD_get_element_connectivities_for_part + * USERD_get_element_ids_for_part + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * + * USERD_stop_part_building + * + * + * Changing geometry + * ================= + * + * changing coords only + * -------------------- + * USERD_set_time_step + * USERD_get_global_coords + * USERD_get_block_coords_by_component + * + * changing connectivity + * --------------------- + * USERD_set_time_step + * USERD_get_number_of_model_parts + * USERD_get_part_build_info + * USERD_get_number_global_nodes + * USERD_get_global_coords + * USERD_get_global_node_ids + * USERD_get_element_connectivities_for_part + * USERD_get_element_ids_for_part + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * + * Loading Variables + * ================= + * + * constants: + * ---------- + * USERD_set_time_step + * USERD_get_constant_value + * + * scalars: + * -------- + * USERD_get_description_lines + * USERD_set_time_step + * USERD_get_scalar_values + * USERD_get_block_scalar_values + * + * vectors: + * -------- + * USERD_get_description_lines + * USERD_set_time_step + * USERD_get_vector_values + * USERD_get_block_vector_values_by_component + * + * + * Node or Element queries over time + * ================================= + * USERD_get_variable_value_at_specific + * + *----------------------------------------------------------------------*/ +#include +#include +#ifndef WIN32 +#include +#endif +#include +#include +#include +#ifndef CONVEX +#include +#endif +#include + +#include "global_extern.h" + +/* ----------------------------------------------- + * If you wish to test out the Extra GUI stuff + * you need to uncomment this section + * + * #define _EGS + * + * ----------------------------------------------- */ + +#if (!defined USERD_API_100) +#define GT_USERD_API_100 +#endif + +#if (!defined USERD_API_100 && !defined USERD_API_200) +#define GT_USERD_API_200 +#endif + +#if (!defined USERD_API_100 && !defined USERD_API_200 && !defined USERD_API_201 && !defined USERD_API_202) +#define GT_USERD_API_202 +#endif + +#if (!defined USERD_API_100 && !defined USERD_API_200 && !defined USERD_API_201 && !defined USERD_API_202 && !defined USERD_API_203) +#define GT_USERD_API_203 +#endif + + +#define EOS '\0' + +typedef struct { + int id; /* part_id */ + char desc[Z_BUFL]; /* description given in the file */ + int type; /* Z_UNSTRUCTURED, Z_STRUCTURED, Z_IBLANKED */ + int ne[Z_MAXTYPE]; /* Number of elements per type (Z_UNSTRUCTURED) */ + /* or ne[0] = I dimension (Z_STRUCTURED) */ + /* ne[1] = J dimension */ + /* ne[2] = K dimension */ + int nn; /* Num of unstructured nodes (All_Local only) */ + int ghosts; /* TRUE if ghost cells, FALSE otherwise */ +}BUILDINFO; + +typedef struct { + char description[Z_BUFL]; /* description */ + char filename[Z_BUFL]; /* real filename */ + char ifilename[Z_BUFL]; /* imaginary filename */ + int type; + int classify; + int complex; + float freq; + int contran; + int timeset; +}VARINFO; + + +typedef struct { + char name[12]; /* Z_POINT, Z_G_POINT, Z_BAR02, ... */ + int con_len; /* Number of nodes per element */ +}EINFO; + + +/* Global variables + *-----------------*/ +int Geom_status; +int Node_labels; +int Element_labels; +int Ghosts_in_model; +int Num_parts; +int Num_vars; +int Num_materials_sets; +BUILDINFO *Pbuild; +VARINFO *Varinfo; +char Version_number[Z_MAX_USERD_NAME]; +int Num_time_sets; +int Num_time_steps; + +/* ------------------ + * Extra GUI stuff + * ------------------ */ +int Num_toggles = 0; +int Num_pulldowns = 0; +int Num_fields = 0; +char **Toggle_title; +int *Toggle_default_status; +char **Pulldown_title; +int *Pulldown_number_in_list; +int *Pulldown_default_selection; +char ***Pulldown_item_strings; +char **Field_title; +char **Field_user_string; +int *Toggle_choice; /* user choice */ +int *Pulldown_choice; /* user choice */ + +/* --------------------------- + * Failed elements (API 2.04) + * --------------------------- */ +int Any_uns_failed_model_elems = FALSE; + + +#if (defined USERD_API_100 || defined USERD_API_200) +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT",1, + "Z_BAR02",2, + "Z_BAR03",3, + "Z_TRI03",3, + "Z_TRI06",6, + "Z_QUA04",4, + "Z_QUA08",8, + "Z_TET04",4, + "Z_TET10",10, + "Z_PYR05",5, + "Z_PYR13",13, + "Z_PEN06",6, + "Z_PEN15",15, + "Z_HEX08",8, + "Z_HEX20",20}; +#elif defined USERD_API_201 +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT", 1, + "Z_G_POINT",1, + "Z_BAR02", 2, + "Z_G_BAR02",2, + "Z_BAR03", 3, + "Z_G_BAR03",3, + "Z_TRI03", 3, + "Z_G_TRI03",3, + "Z_TRI06", 6, + "Z_G_TRI06",6, + "Z_QUA04", 4, + "Z_G_QUA04",4, + "Z_QUA08", 8, + "Z_G_QUA08",8, + "Z_TET04", 4, + "Z_G_TET04",4, + "Z_TET10", 10, + "Z_G_TET10",10, + "Z_PYR05", 5, + "Z_G_PYR05",5, + "Z_PYR13", 13, + "Z_G_PYR13",13, + "Z_PEN06", 6, + "Z_G_PEN06",6, + "Z_PEN15", 15, + "Z_G_PEN15",15, + "Z_HEX08", 8, + "Z_G_HEX08",8, + "Z_HEX20", 20, + "Z_G_HEX20",20}; +#else +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT", 1, + "Z_G_POINT",1, + "Z_BAR02", 2, + "Z_G_BAR02",2, + "Z_BAR03", 3, + "Z_G_BAR03",3, + "Z_TRI03", 3, + "Z_G_TRI03",3, + "Z_TRI06", 6, + "Z_G_TRI06",6, + "Z_QUA04", 4, + "Z_G_QUA04",4, + "Z_QUA08", 8, + "Z_G_QUA08",8, + "Z_TET04", 4, + "Z_G_TET04",4, + "Z_TET10", 10, + "Z_G_TET10",10, + "Z_PYR05", 5, + "Z_G_PYR05",5, + "Z_PYR13", 13, + "Z_G_PYR13",13, + "Z_PEN06", 6, + "Z_G_PEN06",6, + "Z_PEN15", 15, + "Z_G_PEN15",15, + "Z_HEX08", 8, + "Z_G_HEX08",8, + "Z_HEX20", 20, + "Z_G_HEX20",20, + "Z_NSIDED", 1, /* Not yet implemented */ + "Z_G_NSIDED",1, /* Not yet implemented */ + "Z_NFACED", 1, /* Not yet implemented */ + "Z_G_NFACED",1}; /* Not yet implemented */ +#endif + + +/* Prototypes + *-----------*/ +static int load_fail_defaults(void); +static int prelim_info(int *two_fields, int *any_extra_gui); +static int get_input(int set_server_number, + int use_playfile, + char playfile[Z_MAXFILENP], + int two_fields, + int any_extra_gui, + int *swapbytes); +static int time_info( void ); +static int part_build_info(int geom_time_step); +static int variable_info( void ); + +#if (defined GT_USERD_API_100) +static int gold_part_builder(int geom_time_step); +static int gold_var_loader(int var_time_step); +#else +static int part_builder(int geom_time_step); +static int var_loader(int var_time_step); +#endif + +#if (defined GT_USERD_API_100) +static int materials_info( void ); +static int gold_materials_loader(int geom_time_step); +#endif + +static int entity_querys(int var_time_step); +static int exercise_bkup( void ); +static void usage( void ); + + +/*============= + * Main Routine + *=============*/ +#ifdef WIN32 +int main(int argc, char *argv[]) +#else +int main(int argc, char *argv[]) +#endif +{ + /* Command line option variables + *------------------------------*/ + int set_server_number = FALSE; + int use_playfile = FALSE; + char playfile[Z_MAXFILENP]; + FILE *fplay; + int geom_time_step = 0; + int var_time_step = 0; + + /* Other local variables + *----------------------*/ + int i, j; + int err; + int two_fields; + int any_extra_gui = FALSE; + int swapbytes; + int indx; + + /*---------------------------- + * Command argument processing + *----------------------------*/ + fprintf(stderr,"\n"); + fprintf(stderr,"\n"); + fprintf(stderr,"********************************************\n"); + fprintf(stderr,"* EnSight User Defined Reader Debug Tool *\n"); + fprintf(stderr,"********************************************\n"); + fprintf(stderr,"\n"); + + indx = 1; + while(indx < argc) { + + if(!strcmp("-h",argv[indx])) { + usage(); + } + else if(!strcmp("-help",argv[indx])) { + usage(); + } + + /* if you want to test the server number routines + * + * Use: + * > checker -server_number + * + * You will then be prompted for the current and total + * number of servers + *-----------------------------------------------*/ + else if(!strcmp("-server_number",argv[indx])) { + set_server_number = TRUE; + } + + + /* if you want to use a "playfile" instead of being prompted + * for the data loader information + * + * Use: + * > checker -p + * + * This playfile should have 3 [or 4] lines: + * line 1: the path + * line 2: filename_1 + * line 3: [filename_2] (if two_fields is TRUE) + * line 4: 0 or 1, for swapytes (0 is FALSE, 1 is TRUE) + * + * example (two_fields is FALSE, so only 3 lines): + * + * /usr/scratch/stealth/bjn/dat/sp_gold/binary + * simple.case + * 1 + * + *------------------------------------------------------*/ + else if(!strcmp("-p",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + use_playfile = TRUE; + memset(playfile,EOS,Z_MAXFILENP); + strcpy(playfile,argv[indx]); + } + else { + usage(); + } + } + + /* if you want to specify the geometry timestep to test (default is step 0) + * + * Use: + * > checker -gts # + * + * Where # is the step number (zero based) + *-------------------------------------------------------------------------*/ + else if(!strcmp("-gts",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + geom_time_step = atoi(argv[indx]); + } + else { + usage(); + } + } + + /* if you want to specify the variable timestep to test (default is step 0) + * (will use this step for the appropriate timeset of each variable) + * + * Use: + * > checker -vts # + * + * Where # is the step number (zero based) + *-------------------------------------------------------------------------*/ + else if(!strcmp("-vts",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + var_time_step = atoi(argv[indx]); + } + else { + usage(); + } + } + else { + usage(); + } + + indx++; + } + + + /*------------------------------------------------------------- + * + * Now start exercising EnSight + * + *--------------------------------------------------------------*/ + + /*----------------- + * Preliminary info + *-----------------*/ + err = prelim_info(&two_fields,&any_extra_gui); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in prelim_info\n"); + exit(1); + } + + + /*------------------ + * User input needed + *------------------*/ + err = get_input(set_server_number, + use_playfile, + playfile, + two_fields, + any_extra_gui, + &swapbytes); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in get_input\n"); + exit(1); + } + + + /*---------- + * Time info + *----------*/ + err = time_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in time_info\n"); + exit(1); + } + + + /*---------------- + * Part build info + *----------------*/ + err = part_build_info(geom_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in part_build_info\n"); + exit(1); + } + + + /*------------------ + * Get Variable Info + *------------------*/ + err = variable_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in variable_info\n"); + exit(1); + } + + +#if (defined GT_USERD_API_202) + /*------------------- + * Get Materials Info + *-------------------*/ + err = materials_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in materials_info\n"); + exit(1); + } +#endif + +#if (defined GT_USERD_API_203) + if (Z_ERR == load_fail_defaults()) { + fprintf(stderr,"Stopping due to error in failed element flag routine\n"); + exit(1); + } +#endif + + /*------------------------ + * Act like building parts + *------------------------*/ + if(Num_parts > 0) { + +#if (defined GT_USERD_API_100) + err = gold_part_builder(geom_time_step); +#else + err = part_builder(geom_time_step); +#endif + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in part_builder\n"); + exit(1); + } + else { + USERD_stop_part_building(); + } + } + + + /*--------------------------- + * Act like loading variables + *---------------------------*/ + if(Num_vars > 0) { + +#if (defined GT_USERD_API_100) + err = gold_var_loader(var_time_step); +#else + err = var_loader(var_time_step); +#endif + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in var_loader\n"); + exit(1); + } + } + +#if (defined GT_USERD_API_202) + /*--------------------------- + * Act like loading materials + *---------------------------*/ + if(Num_materials_sets > 0) { + err = gold_materials_loader(geom_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in materials_loader\n"); + exit(1); + } + } +#endif + + + + /*---------------------------------------------------- + * See if can do node and/or element queries over time + *----------------------------------------------------*/ + if(Num_parts > 0 && + Num_vars > 0) { + err = entity_querys(var_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in entity_querys\n"); + exit(1); + } + } + + /*---------------------------------------- + * Call the bkup file once in save mode, + * then again in restore mode - so someone + * could debug if desired + *----------------------------------------*/ + err = exercise_bkup(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping due to error in saving and/or restoring archive\n"); + exit(1); + } + + /*------------- + * Exit Routine + *-------------*/ + fprintf(stderr,"\n----------------- exiting ---------------\n"); + +#if (defined GT_USERD_API_100) + USERD_exit_routine(); +#endif + + fprintf(stderr,"\n\n"); +} + +/*-------------- + * Usage routine + *--------------*/ +static void +usage( void ) +{ + fprintf(stderr,"------------------------------------------------------------\n"); + fprintf(stderr,"USAGE: checker [-p pfile] [-server_number] [-gts #] [-vts #]\n"); + fprintf(stderr,"------------------------------------------------------------\n"); + fprintf(stderr," -h, -help Prints out this USAGE text.\n"); + fprintf(stderr," -gts # Specify the geometry times step to use.)\n"); + fprintf(stderr," -p pfile Plays the checker playfile (pfile).\n"); + fprintf(stderr," -server_number Cause servers numbers to be prompted for.\n"); + fprintf(stderr," -vts # Specify the variable times step to use.)\n"); + fprintf(stderr,"\n"); + exit(1); +} + + + + +/*------------ + * prelim_info + *------------*/ +static int +prelim_info(int *two_fields, int *any_extra_gui) +{ + int err; + char reader_name[Z_MAX_USERD_NAME]; + char release_number[Z_MAX_USERD_NAME]; + char description[Z_MAXFILENP]; + int i,j; + + *any_extra_gui = FALSE; + + /* Get the reader name + *--------------------*/ + err = USERD_get_name_of_reader(reader_name,two_fields); + if(err == Z_OK) { + fprintf(stderr," Name of reader: %s\n",reader_name); + if(*two_fields==1) { + fprintf(stderr," two_fields: TRUE\n"); + } + else if(*two_fields==0){ + fprintf(stderr," two_fields: FALSE\n"); + } + else if(*two_fields < 0) { + fprintf(stderr," two_fields: -1 (optional string) \n"); + } + } + else { + fprintf(stderr,"Error: Could not get name of reader\n"); + return(Z_ERR); + } + + /* Get the Extra GUI stuff (optional) + * ---------------------------------------------------------- */ +#ifdef _EGS + + /* Get the Extra GUI numbers of toggles, pulldowns, & fields + * ---------------------------------------------------------- */ + + USERD_get_extra_gui_numbers( &Num_toggles, + &Num_pulldowns, + &Num_fields ); + + if ( Num_toggles > 0 || Num_pulldowns > 0 || Num_fields > 0 ) { + + + *any_extra_gui = TRUE; + + if (Num_toggles>0) { + Toggle_title = (char **) calloc(Num_toggles,sizeof(char*)); + if (Toggle_title == (char **)NULL) return(Z_ERR); + for (i=0; i 0) { + Pulldown_title = (char **) calloc( Num_pulldowns , sizeof(char*) ); + if (Pulldown_title == (char **)NULL) return(Z_ERR); + + Pulldown_item_strings = (char ***) calloc( Num_pulldowns , sizeof(char**) ); + if (Pulldown_item_strings == (char ***)NULL) return(Z_ERR); + + for (i=0; i 0) { + Field_title = (char **) calloc(Num_fields,sizeof(char*)); + Field_user_string = (char **) calloc(Num_fields,sizeof(char*)); + if (Field_title == (char **) NULL) return(Z_ERR); + for (i=0; i 0) { + fprintf(stderr,"Error: timeset numbers must be 1 or greater\n"); + fprintf(stderr," (unless Num_time_sets is zero also)\n"); + } + + + /* For each timeset + *-----------------*/ + for(ts=1; ts<=Num_time_sets; ++ts) { + + fprintf(stderr," Timeset %d:\n",ts); + + /* Get the timeset descriptions + *-----------------------------*/ + err = USERD_get_timeset_description(ts,ts_desc); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting timeset description\n"); + return(Z_ERR); + } + else { + fprintf(stderr," description: %s\n",ts_desc); + } + + /* Get the number of time steps + *-----------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(ts); + fprintf(stderr," number of time steps: %d\n",Num_time_steps); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + + + /* Get the solution times + *-----------------------*/ + if(Num_time_steps > 0) { + sol_times = (float *) calloc(Num_time_steps,sizeof(float)); + if(sol_times == (float *)NULL) { + fprintf(stderr,"Error: allocating for solution times\n"); + return(Z_ERR); + } + else { + err = USERD_get_sol_times(ts,sol_times); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting solution times\n"); + return(Z_ERR); + } + else { + for(i=0; i0 to be okay)\n"); + return(Z_ERR); + } + + + /* Get the solution times + *-----------------------*/ + if(Num_time_steps > 0) { + sol_times = (float *) calloc(Num_time_steps,sizeof(float)); + if(sol_times == (float *)NULL) { + fprintf(stderr,"Error: allocating for solution times\n"); + return(Z_ERR); + } + else { + err = USERD_get_solution_times(sol_times); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting solution times\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + + qfiles = (Z_QFILES *) calloc(num_dataset_files,sizeof(Z_QFILES)); + if(qfiles == (Z_QFILES *)NULL) { + fprintf(stderr,"Error: allocating for dataset query files\n"); + return(Z_ERR); + } + else { + + for(i=0; i 0) { + fprintf(stderr," Number of parts: %d\n",Num_parts); + } + else { + fprintf(stderr," Problems getting number of parts\n"); + return(Z_ERR); + } + + + + /* Get the gold part build info + *-----------------------------*/ + Pbuild = (BUILDINFO *) calloc(Num_parts,sizeof(BUILDINFO)); + if(Pbuild == (BUILDINFO *)NULL) { + fprintf(stderr," Problems allocating for Pbuild structure\n"); + return(Z_ERR); + } + + + part_ids = (int *) calloc(Num_parts,sizeof(int)); + if(part_ids == (int *)NULL) { + fprintf(stderr," Problems allocating for part ids\n"); + return(Z_ERR); + } + + part_types = (int *) calloc(Num_parts,sizeof(int)); + if(part_types == (int *)NULL) { + fprintf(stderr," Problems allocating for part types\n"); + return(Z_ERR); + } + + part_descriptions = (char **) calloc(Num_parts,sizeof(char *)); + if(part_descriptions == (char **)NULL) { + fprintf(stderr," Problems allocating for part descriptions\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," # %s elements: %d\n", + Elem_info[j].name,num_elems[i][j]); + Pbuild[i].ne[j] = num_elems[i][j]; + } + } + + if(part_types[i] != Z_UNSTRUCTURED) { + + /* For this checker, we will place the following in the + * Pbuild[].ne[] structure: + * + * Note this is can be used for block size whether ranges or not + * ------------------------------------------------------------- + * Pbuild[].ne[0] = i dim of current block (to the range selected) + * Pbuild[].ne[1] = j dim of current block (to the range selected) + * Pbuild[].ne[2] = k dim of current block (to the range selected) + * + * Thus if ranges: + * --------------- + * Pbuild[].ne[3] = i min range (-1 indicates no ranges) + * Pbuild[].ne[4] = i max range + * Pbuild[].ne[5] = i min range + * Pbuild[].ne[6] = i max range + * Pbuild[].ne[7] = i min range + * Pbuild[].ne[8] = i max range + * + * Pbuild[].ne[9] = i dim of total block (if ranges) + * Pbuild[].ne[10] = j dim of total block (if ranges) + * Pbuild[].ne[11] = k dim of total block (if ranges) + * + * What comes back from the api is: + * -------------------------------- + * before 2.03 (no ranges) + * ----------------------- + * ijk_dimensions[][0] = i dim of block + * ijk_dimensions[][1] = j dim of block + * ijk_dimensions[][2] = k dim of block + * + * at 2.03 (if no ranges) + * ------- + * ijk_dimensions[][0] = i dim of block + * ijk_dimensions[][1] = j dim of block + * ijk_dimensions[][2] = k dim of block + * ijk_dimensions[][3] = -1 + * + * at 2.03 (if ranges) + * ------- + * ijk_dimensions[][0] = i dim of total block + * ijk_dimensions[][1] = j dim of total block + * ijk_dimensions[][2] = k dim of total block + * ijk_dimensions[][3] = i min range + * ijk_dimensions[][4] = i max range + * ijk_dimensions[][5] = j min range + * ijk_dimensions[][6] = j max range + * ijk_dimensions[][7] = k min range + * ijk_dimensions[][8] = k max range + *--------------------------------------------------------------*/ + +#if (defined GT_USERD_API_202) + if(ijk_dimensions[i][3] == -1) { + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = ijk_dimensions[i][3]; + } + else { + + /* If empty part + *--------------*/ + if(ijk_dimensions[i][0] == 0 && + ijk_dimensions[i][1] == 0 && + ijk_dimensions[i][2] == 0) { + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = -1; + } + + /* range part + *-----------*/ + else { + Pbuild[i].ne[0] = ijk_dimensions[i][4] - ijk_dimensions[i][3] + 1; + Pbuild[i].ne[1] = ijk_dimensions[i][6] - ijk_dimensions[i][5] + 1; + Pbuild[i].ne[2] = ijk_dimensions[i][8] - ijk_dimensions[i][7] + 1; + + Pbuild[i].ne[3] = ijk_dimensions[i][3]; + Pbuild[i].ne[4] = ijk_dimensions[i][4]; + Pbuild[i].ne[5] = ijk_dimensions[i][5]; + Pbuild[i].ne[6] = ijk_dimensions[i][6]; + Pbuild[i].ne[7] = ijk_dimensions[i][7]; + Pbuild[i].ne[8] = ijk_dimensions[i][8]; + + Pbuild[i].ne[9] = ijk_dimensions[i][0]; + Pbuild[i].ne[10] = ijk_dimensions[i][1]; + Pbuild[i].ne[11] = ijk_dimensions[i][2]; + + fprintf(stderr," Part has ranges:\n"); + fprintf(stderr," ijk dimensions of total block: %d %d %d\n", + Pbuild[i].ne[9], + Pbuild[i].ne[10], + Pbuild[i].ne[11]); + fprintf(stderr," i range: %d to %d\n", + Pbuild[i].ne[3], + Pbuild[i].ne[4]); + fprintf(stderr," j range: %d to %d\n", + Pbuild[i].ne[5], + Pbuild[i].ne[6]); + fprintf(stderr," k range: %d to %d\n", + Pbuild[i].ne[7], + Pbuild[i].ne[8]); + fprintf(stderr," ijk dimensions of range portion: %d %d %d\n", + Pbuild[i].ne[0], + Pbuild[i].ne[1], + Pbuild[i].ne[2]); + } + } +#else + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = -1; +#endif + if(part_types[i] == Z_IBLANKED) { + fprintf(stderr," Ibanking options on:\n"); + if(iblanking_options[i][Z_EXT]) { + fprintf(stderr," Z_EXT\n"); + } + if(iblanking_options[i][Z_INT]) { + fprintf(stderr," Z_INT\n"); + } + if(iblanking_options[i][Z_BND]) { + fprintf(stderr," Z_BND\n"); + } + if(iblanking_options[i][Z_INTBND]) { + fprintf(stderr," Z_INTBND\n"); + } + if(iblanking_options[i][Z_SYM]) { + fprintf(stderr," Z_SYM\n"); + } + } + } + } + } + + +#if (defined GT_USERD_API_200) + + /* Get ghosts in model flag + *-------------------------*/ + Ghosts_in_model = USERD_get_ghosts_in_model_flag(); + if(Ghosts_in_model) { + fprintf(stderr," Ghosts in Model: TRUE\n"); + } + else { + fprintf(stderr," Ghosts in Model: FALSE\n"); + } + + /* Get ghosts in block flag - if needed + *-------------------------------------*/ + for(i=1; i<=Num_parts; ++i) { + if(part_types[i-1] != Z_UNSTRUCTURED && Ghosts_in_model) { + ghosts_in_block = USERD_get_ghosts_in_block_flag(i); + Pbuild[i-1].ghosts = ghosts_in_block; + if(ghosts_in_block) { + fprintf(stderr," Ghosts in block part %d: TRUE\n",i); + } + else { + fprintf(stderr," Ghosts in block part %d: FALSE\n",i); + } + } + } + +#endif + + +#if (defined GT_USERD_API_100) + + /* Get maxsize info + *-----------------*/ + max_num_nodes = (int *) calloc(Num_parts,sizeof(int)); + if(max_num_nodes == (int *)NULL) { + fprintf(stderr," Problems allocating for part max num of nodes\n"); + return(Z_ERR); + } + + max_num_elems = (int **) calloc(Num_parts,sizeof(int *)); + if(max_num_elems == (int **)NULL) { + fprintf(stderr," Problems allocating for part max num of elements\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," max # %s elems: %d\n", + Elem_info[j].name,max_num_elems[i][j]); + } + } + + if(part_types[i] != Z_UNSTRUCTURED) { + fprintf(stderr," max_ijk_dimensions: %d %d %d\n", + max_ijk_dimensions[i][0], + max_ijk_dimensions[i][1], + max_ijk_dimensions[i][2]); + } + } + } + + /* Get model extents - if given + *-----------------------------*/ + err = USERD_get_model_extents(extents); + if(err == Z_ERR) { + fprintf(stderr," No extents given\n"); + } + else { + fprintf(stderr," Min x: %g\n",extents[0]); + fprintf(stderr," Max x: %g\n",extents[1]); + fprintf(stderr," Min y: %g\n",extents[2]); + fprintf(stderr," Max y: %g\n",extents[3]); + fprintf(stderr," Min z: %g\n",extents[4]); + fprintf(stderr," Max z: %g\n",extents[5]); + } + +#endif + + /* Free the allocated memory + *--------------------------*/ + free(part_ids); + free(part_types); + free(number_of_nodes); + + for(i=0; i 0) { + /* Get the timeset used for the geometry + *--------------------------------------*/ + geom_timeset = USERD_get_geom_timeset_number(); + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(geom_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(geom_timeset,geom_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + geom_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",geom_time_step); + } + + for(p=0; p 0) { + + pdata = (int *)calloc(ne*Elem_info[et].con_len,sizeof(int)); + if(pdata == (int *) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + else { + conns = (int **) calloc(ne,sizeof(int *)); + if(conns == (int **) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + for(i=0; i 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[i]); + } + fprintf(stderr," connectivity:"); + + for(j=nsid_len-conns[i][0]; j Pbuild[p].nn ) { + fprintf(stderr,"\n****************************\n"); + fprintf(stderr,"Connectivity value out of bounds: \n"); + fprintf(stderr,"Either less than zero or greater than \n"); + fprintf(stderr," number of nodes in part!! \n"); + fprintf(stderr,"i = %d j = %d conns[i][j] = %d \n",i,j,conns[i][j]); + fprintf(stderr,"****************************\n"); + } + } + /* ---------- uncomment to print out connectivity values ---------- */ +/* fprintf(stderr,"\n"); */ + } +#endif + /* Last element of the type + *-------------------------*/ + i = ne - 1; + if(i > 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + + coords = (float **) calloc(3,sizeof(float *)); + if(coords == (float **) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + else { + for(i=0; i<3; ++i) { + coords[i] = (float *) calloc((nn+1),sizeof(float)); + if(coords[i] == (float *) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + } + } + + if(Node_labels) { + nodeids = (int *) calloc((nn+1),sizeof(int)); + if(nodeids == (int *) NULL) { + fprintf(stderr,"Error: allocating nodeids array\n"); + return(Z_ERR); + } + } + + + err = USERD_get_part_coords(pn,coords); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting unstructured coords\n"); + return(Z_ERR); + } + + if(Node_labels) { + err = USERD_get_part_node_ids(pn,nodeids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting nodeids\n"); + return(Z_ERR); + } + } + + /* Echo "some" info + *-----------------*/ + + /* First node + *-----------*/ + i = 1; + fprintf(stderr," Node %d of %d:\n",i,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + + + /* Last node + *----------*/ + i = nn; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=2; i<=nn; ++i) { + if(coords[0][i] < mm[0]) { + mm[0] = coords[0][i]; + } + if(coords[0][i] > mm[1]) { + mm[1] = coords[0][i]; + } + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + + + /* Free the allocated memory + *--------------------------*/ + for(i=0; i<3; ++i) { + free(coords[i]); + } + free(coords); + if(Node_labels) { + free(nodeids); + } + } + } + + + /*--------------------- + * For structured parts + *---------------------*/ + else { + + empty_part = FALSE; + if(Pbuild[p].ne[0] == 0 && + Pbuild[p].ne[1] == 0 && + Pbuild[p].ne[2] == 0) { + empty_part = TRUE; + } + + if(!empty_part) { + + /* Get the block coords + *---------------------*/ + for(comp=0; comp<3; ++comp) { + if(Pbuild[p].ne[comp] < 1) { + bdim[comp] = 1; + } + else { + bdim[comp] = Pbuild[p].ne[comp]; + } + } + nn = bdim[0] * bdim[1] * bdim[2]; + + bd1 = bdim[0]-1; + if(bd1 < 1) { + bd1 = 1; + } + bd2 = bdim[1]-1; + if(bd2 < 1) { + bd2 = 1; + } + bd3 = bdim[2]-1; + if(bd3 < 1) { + bd3 = 1; + } + ne = bd1 * bd2 * bd3; + + /* Determine cell type + *--------------------*/ + num_dims = 3; + for(i=0; i<3; ++i) { + if(bdim[i] == 1) { + --num_dims; + } + } + if(num_dims == 3) { + cell_type = Z_HEX08; + } + else if(num_dims == 2) { + cell_type = Z_QUA04; + } + else { + cell_type = Z_BAR02; + } + + coords = (float **) calloc(num_dims,sizeof(float *)); + if(coords == (float **) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + +#if (defined GT_USERD_API_200) + + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } +#endif + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + mm[0] = mm[1] = coords[0][i]; + } + + + /* Last node + *----------*/ + i = nn-1; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + +#if (defined GT_USERD_API_200) + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } +#endif + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + } + } + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=1; i mm[1]) { + mm[1] = coords[0][i]; + } + if(num_dims > 1) { + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + } + if(num_dims > 2) { + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + if(num_dims > 1) { + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + } + if(num_dims > 2) { + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + } + + /* Free the allocated memory - so far + *-----------------------------------*/ + for(i=0; i 0) { + ++num_ghosts; + } + } + + fprintf(stderr," Block Ghost flag breakdown:\n"); + fprintf(stderr," %d ghost cells out of %d total cells\n", + num_ghosts,ne); + + free(ghost_flag); + } + + /* Get the element ids - if any + *-----------------------------*/ + if(Element_labels) { + + elemids = (int *) calloc(ne,sizeof(int)); + if(elemids == (int *) NULL) { + fprintf(stderr,"Error: allocating elemids array\n"); + return(Z_ERR); + } + + + et = cell_type; + err = USERD_get_part_element_ids_by_type(pn,et,elemids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting element ids\n"); + return(Z_ERR); + } + + /* First element of the type + *--------------------------*/ + i = 0; + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + fprintf(stderr," id: %d\n",elemids[i]); + + /* Last element of the type + *-------------------------*/ + i = ne - 1; + if(i > 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + fprintf(stderr," id: %d\n",elemids[i]); + } + + free(elemids); + } +#endif + } + else { + fprintf(stderr," Empty structured part\n"); + } + } + + /* Get border availability + *------------------------*/ + err = USERD_get_border_availability(pn,num_elems); + if(err == Z_OK) { + + /* Get border elements - if any + *-----------------------------*/ + for(et=0; et 0) { + + conns = (int **) calloc(ne,sizeof(int *)); + if(conns == (int **) NULL) { + fprintf(stderr,"Error: allocating border conns array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," %s border element %d of %d:\n", + Elem_info[et].name,i+1,ne); + fprintf(stderr," Parent type: %s\n", + Elem_info[parent_type[i]].name); + fprintf(stderr," Parent num: %d\n",parent_num[i]); + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + fprintf(stderr,"\n"); + } + if(Varinfo[v].classify == Z_PER_NODE) { + fprintf(stderr," Z_PER_NODE Variable %d:\n",vn); + } + else { + fprintf(stderr," Z_PER_ELEM Variable %d:\n",vn); + } + + + if(Num_time_sets > 0) { + /* Get the timeset used for the variable + *---------------------------------------*/ + var_timeset = Varinfo[v].timeset; + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(var_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n", + Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(var_timeset,var_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + var_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",var_time_step); + } + + + /* Constants + *----------*/ + if(Varinfo[v].type == Z_CONSTANT) { + + constant_val = USERD_get_constant_val(vn,FALSE); + fprintf(stderr," Constant (%s):\n",Varinfo[v].description); + fprintf(stderr," value: %g\n",constant_val); + + if(Varinfo[v].complex) { + constant_val = USERD_get_constant_val(vn,TRUE); + fprintf(stderr," value (imag): %g\n",constant_val); + } + } + + /* Scalars, Vectors, Tensors + *--------------------------*/ + else { + + /* Get the var description line + *-----------------------------*/ + err = USERD_get_descrip_lines(Z_VARI,vn,FALSE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + if(Varinfo[v].complex) { + err = USERD_get_descrip_lines(Z_VARI,vn,TRUE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line (imag): %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line (imag)\n"); + return(Z_ERR); + } + } + + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + else if(Varinfo[v].type == Z_TENSOR) { + num_comps = 6; + } + else if(Varinfo[v].type == Z_TENSOR9) { + num_comps = 9; + } + + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + values = (float *) calloc((nsize+1),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + for(comp=0; comp maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d: \n",comp); + fprintf(stderr," node %10d value: %g\n",1,values[1]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + if(Varinfo[v].complex) { + err = USERD_get_var_by_component(vn, + pn, + Varinfo[v].type, + 0, + FALSE, + comp, + values); + if(err == Z_UNDEF) { + fprintf(stderr," Variable not defined on this part\n"); + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv = maxv = values[1]; + for(i=2; i<=nsize; ++i) { + if(values[i] < minv) { + minv = values[i]; + } + if(values[i] > maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d (imag): \n",comp); + fprintf(stderr," node %10d value: %g\n",1,values[1]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + } + } + free(values); + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + fprintf(stderr," For part %d, with %d elems of type %s:\n", + pn,nsize,Elem_info[et].name); + + + values = (float *) calloc((nsize+1),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + for(comp=0; comp maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d: \n",comp); + fprintf(stderr," elem %10d value: %g\n",1,values[1]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + if(Varinfo[v].complex) { + err = USERD_get_var_by_component(vn, + pn, + Varinfo[v].type, + et, + FALSE, + comp, + values); + if(err == Z_UNDEF) { + fprintf(stderr," Variable not defined on this part\n"); + } + + /* For the component, show 1st elem, last elem, min, max values + *-------------------------------------------------------------*/ + minv = maxv = values[1]; + for(i=2; i<=nsize; ++i) { + if(values[i] < minv) { + minv = values[i]; + } + if(values[i] > maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d (imag): \n",comp); + fprintf(stderr," elem %10d value: %g\n",1,values[1]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + } + } + free(values); + } + } + } + } + } + } + + return(Z_OK); +} + +#else + +/*------------- + * part_builder + *-------------*/ +static int +part_builder(int geom_time_step) +{ + int i, j; + int err; + int p, pn; + int et, ne; + int *elemids[Z_MAXTYPE]; + int **conns[Z_MAXTYPE]; + int nn; + int comp; + int bdim[3]; + int ib[5]; + int num_dims; + int cell_type; + float mm[6]; + float **coords; + int *nodeids; + int *iblanking; + CRD *crds; + int bd1,bd2,bd3; + + + fprintf(stderr,"\n------------- part_builder --------------\n"); + + + if(Num_time_steps > 1) { + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------*/ + USERD_set_time_step(geom_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d\n", + geom_time_step,0,Num_time_steps-1); + } + + + /* Get the global coords + *----------------------*/ + nn = USERD_get_number_of_global_nodes(); + + if(nn > 0) { + + crds = (CRD *) calloc(nn,sizeof(CRD)); + if(crds == (CRD *) NULL) { + fprintf(stderr,"Error: allocating crds array\n"); + return(Z_ERR); + } + + if(Node_labels) { + nodeids = (int *) calloc(nn,sizeof(int)); + if(nodeids == (int *) NULL) { + fprintf(stderr,"Error: allocating nodeids array\n"); + return(Z_ERR); + } + } + + + err = USERD_get_global_coords(crds); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting unstructured coords\n"); + return(Z_ERR); + } + + if(Node_labels) { + err = USERD_get_global_node_ids(nodeids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting nodeids\n"); + return(Z_ERR); + } + } + + /* Echo "some" info + *-----------------*/ + + /* First node + *-----------*/ + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + crds[i].xyz[0], crds[i].xyz[1], crds[i].xyz[2]); + mm[0] = mm[1] = crds[i].xyz[0]; + mm[2] = mm[3] = crds[i].xyz[1]; + mm[4] = mm[5] = crds[i].xyz[2]; + + + /* Last node + *----------*/ + i = nn-1; + if(i > 0) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + crds[i].xyz[0], crds[i].xyz[1], crds[i].xyz[2]); + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=1; i mm[1]) { + mm[1] = crds[i].xyz[0]; + } + if(crds[i].xyz[1] < mm[2]) { + mm[2] = crds[i].xyz[1]; + } + if(crds[i].xyz[1] > mm[3]) { + mm[3] = crds[i].xyz[1]; + } + if(crds[i].xyz[2] < mm[4]) { + mm[4] = crds[i].xyz[2]; + } + if(crds[i].xyz[2] > mm[5]) { + mm[5] = crds[i].xyz[2]; + } + } + + fprintf(stderr," Global coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + + + /* Free the allocated memory + *--------------------------*/ + free(crds); + if(Node_labels) { + free(nodeids); + } + } + + + + for(p=0; p 0) { + + conns[et] = (int **) calloc(ne,sizeof(int *)); + if(conns[et] == (int **) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + + /* First element of the type + *--------------------------*/ + i = 0; + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[et][i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[et][i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + for(i=0; i 0) { + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + mm[0] = mm[1] = coords[0][i]; + } + + + /* Last node + *----------*/ + i = nn-1; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + } + } + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=2; i<=nn; ++i) { + if(coords[0][i] < mm[0]) { + mm[0] = coords[0][i]; + } + if(coords[0][i] > mm[1]) { + mm[1] = coords[0][i]; + } + if(num_dims > 1) { + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + } + if(num_dims > 2) { + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + if(num_dims > 1) { + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + } + if(num_dims > 2) { + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + } + + /* Free the allocated memory - so far + *-----------------------------------*/ + for(i=0; i 1 && v == 0) { + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_step(var_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d)\n\n", + var_time_step,0,Num_time_steps-1); + } + + for(v=0; v 0) { + fprintf(stderr,"\n"); + } + if(Varinfo[v].classify == Z_PER_NODE) { + fprintf(stderr," Z_PER_NODE Variable %d:\n",vn); + } + else { + fprintf(stderr," Z_PER_ELEM Variable %d:\n",vn); + } + + /* Constants + *----------*/ + if(Varinfo[v].type == Z_CONSTANT) { + + constant_val = USERD_get_constant_value(vn); + fprintf(stderr," Constant (%s):\n",Varinfo[v].description); + fprintf(stderr," value: %g\n",constant_val); + } + + + /* Scalars, Vectors, Tensors + *--------------------------*/ + else { + + /* Get the var description line + *-----------------------------*/ + err = USERD_get_description_lines(Z_VARI,vn,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + else if(Varinfo[v].type == Z_TENSOR) { + num_comps = 6; + } + else if(Varinfo[v].type == Z_TENSOR9) { + num_comps = 9; + } + + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + values = (float *) calloc((num_comps * nsize),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + if(num_comps == 1) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_scalar_values(vn, + pn, + 0, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting scalar values\n"); + return(Z_ERR); + } + } + else { + err = USERD_get_block_scalar_values(pn, + vn, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting block scalar values\n"); + return(Z_ERR); + } + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv[0] = maxv[0] = values[0]; + for(i=0; i maxv[0]) { + maxv[0] = values[i]; + } + } + + fprintf(stderr," node %10d value: %g\n",1,values[0]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize-1]); + fprintf(stderr," min value: %g\n",minv[0]); + fprintf(stderr," max value: %g\n",maxv[0]); + + } + + else if(num_comps == 3) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_vector_values(vn, + pn, + 0, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + } + else { + + tvalues = (float *) calloc(nsize,sizeof(float)); + if(tvalues == (float *) NULL) { + fprintf(stderr,"Error: alocating tvalues array\n"); + return(Z_ERR); + } + + for(i=0; i<3; ++i) { + err = USERD_get_block_vector_values_by_component(pn, + vn, + i, + tvalues); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + for(j=0; j maxv[k]) { + maxv[k] = values[j+k]; + } + } + } + + fprintf(stderr," node %10d values: %g %g %g\n",1, + values[0],values[1],values[2]); + fprintf(stderr," node %10d values: %g %g %g\n",nsize, + values[3*nsize-3],values[3*nsize-2],values[3*nsize-1]); + fprintf(stderr," min values: %g %g %g\n", + minv[0],minv[1],minv[2]); + fprintf(stderr," max values: %g %g %g\n", + maxv[0],maxv[1],maxv[2]); + + } + free(values); + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + fprintf(stderr," For part %d, with %d elems of type %s:\n", + pn,nsize,Elem_info[et].name); + + values = (float *) calloc((num_comps * nsize),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + if(num_comps == 1) { + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_scalar_values(vn, + pn, + et, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting scalar values\n"); + return(Z_ERR); + } + } + else { + err = USERD_get_block_scalar_values(pn, + vn, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting block scalar values\n"); + return(Z_ERR); + } + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv[0] = maxv[0] = values[0]; + for(i=1; i maxv[0]) { + maxv[0] = values[i]; + } + } + + fprintf(stderr," elem %10d value: %g\n",1,values[0]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize-1]); + fprintf(stderr," min value: %g\n",minv[0]); + fprintf(stderr," max value: %g\n",maxv[0]); + + } + + else if(num_comps == 3) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_vector_values(vn, + pn, + et, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + } + else { + + tvalues = (float *) calloc(nsize,sizeof(float)); + if(tvalues == (float *) NULL) { + fprintf(stderr,"Error: alocating tvalues array\n"); + return(Z_ERR); + } + + for(i=0; i<3; ++i) { + err = USERD_get_block_vector_values_by_component(pn, + vn, + i, + tvalues); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + for(j=0; j maxv[k]) { + maxv[k] = values[j+k]; + } + } + } + + fprintf(stderr," elem %10d values: %g %g %g\n",1, + values[0],values[1],values[2]); + fprintf(stderr," elem %10d values: %g %g %g\n",nsize, + values[3*nsize-3],values[3*nsize-2],values[3*nsize-1]); + fprintf(stderr," min values: %g %g %g\n", + minv[0],minv[1],minv[2]); + fprintf(stderr," max values: %g %g %g\n", + maxv[0],maxv[1],maxv[2]); + + } + free(values); + } + } + } + } + } + } + + return(Z_OK); +} + +#endif + + +#if (defined GT_USERD_API_202) + + +/*--------------- + * materials_info + *---------------*/ +static int +materials_info( void ) +{ + int i,j; + int err; + int *num_materials; + int *msids; + char **msname; + int *mids; + char **mdesc; + + + fprintf(stderr,"\n------------ materials_info --------------\n"); + + /* Get the number of variables + *----------------------------*/ + Num_materials_sets = USERD_get_number_of_material_sets(); + if(Num_materials_sets < 0) { + fprintf(stderr,"Error: getting the number of material sets\n"); + return(Z_ERR); + } + else { + if(Num_materials_sets == 0) { + fprintf(stderr," No materials sets in the model\n"); + return (Z_OK); + } + else if(Num_materials_sets > 1) { + fprintf(stderr," Number of materials sets: %d\n",Num_materials_sets); + fprintf(stderr," Currently, EnSight 7.6 only supports 1 material set\n"); + return(Z_ERR); + } + else { + fprintf(stderr," Number of materials sets: %d\n",Num_materials_sets); + } + } + + /* Get the material set index list and names + *------------------------------------------*/ + msids = (int *) calloc(Num_materials_sets,sizeof(int)); + if(msids == (int *)NULL) { + fprintf(stderr," Problems allocating for material set ids\n"); + return(Z_ERR); + } + + num_materials = (int *) calloc(Num_materials_sets,sizeof(int)); + if(num_materials == (int *)NULL) { + fprintf(stderr," Problems allocating for material set num materials\n"); + return(Z_ERR); + } + + msname = (char **) calloc(Num_materials_sets,sizeof(char *)); + if(msname == (char **)NULL) { + fprintf(stderr," Problems allocating for material set names\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + /* Get the timeset used for the geometry + *--------------------------------------*/ + geom_timeset = USERD_get_geom_timeset_number(); + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(geom_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Num time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(geom_timeset,geom_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + geom_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",geom_time_step); + } + + for(ms=0; ms 0) { + + /* Get the material ids, if any + *-----------------------------*/ + err = USERD_size_matf_data(ms, + pn, + et, + Z_MAT_INDEX, + &matf_size); + if(err == Z_OK && matf_size > 0) { + + + /* Go get the material ids + *------------------------*/ + ivals = (int *) calloc(matf_size,sizeof(int)); + if(ivals == (int *)NULL) { + fprintf(stderr," Problems allocating for material ids\n"); + return(Z_ERR); + } + err = USERD_load_matf_data(ms, + pn, + et, + Z_MAT_INDEX, + ivals, + fvals); + if(err == Z_OK) { + if(matf_size < 20) { + fprintf(stderr," Printing all mat ids for %s elements\n", + Elem_info[et].name); + do_num = matf_size; + } + else { + fprintf(stderr," Printing first 20 mat ids for %s elements\n", + Elem_info[et].name); + do_num = 20; + } + + /* See if any mixed materials + *---------------------------*/ + mixed_present = FALSE; + for(k=0; k 0 && + matfv_size > 0) { + + /* Go get the material ids + *------------------------*/ + ivals = (int *) calloc(matf_size,sizeof(int)); + if(ivals == (int *)NULL) { + fprintf(stderr," Problems allocating for mixed material ids\n"); + return(Z_ERR); + } + fvals = (float *) calloc(matfv_size,sizeof(float)); + if(fvals == (float *)NULL) { + fprintf(stderr," Problems allocating for mixed material values\n"); + return(Z_ERR); + } + + err1 = USERD_load_matf_data(ms, + pn, + et, + Z_MIX_INDEX, + ivals, + fvals); + + err2 = USERD_load_matf_data(ms, + pn, + et, + Z_MIX_VALUE, + ivals, + fvals); + if(err1 == Z_OK && + err2 == Z_OK) { + if(matf_size < 20) { + fprintf(stderr," Printing all mixed mat ids for %s elements\n", + Elem_info[et].name); + do_num = matf_size; + } + else { + fprintf(stderr," Printing first 20 mixed mat ids for %s elements\n", + Elem_info[et].name); + do_num = 20; + } + for(k=0; k 1) { + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_step(var_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d)\n\n", + var_time_step,0,Num_time_steps-1); + } +#endif + + for(v=0; v 0) { + /* Get the timeset used for the variable + *---------------------------------------*/ + var_timeset = Varinfo[v].timeset; + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(var_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n", + Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(var_timeset,var_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + var_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",var_time_step); + } +#endif + + + /* Get the var description line + *-----------------------------*/ +#if (defined GT_USERD_API_100) + err = USERD_get_descrip_lines(Z_VARI,vn,FALSE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + if(Varinfo[v].complex) { + err = USERD_get_descrip_lines(Z_VARI,vn,TRUE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line (imag): %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line (imag)\n"); + return(Z_ERR); + } + } +#else + + err = USERD_get_description_lines(Z_VARI,vn,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + +#endif + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + + fprintf(stderr," For part %d, using node %d:\n",pn,nsize); + +#if (defined GT_USERD_API_100) + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals, + FALSE); +#else + err = USERD_get_variable_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals); +#endif + if(err == Z_NOT_IMPLEMENTED) { + fprintf(stderr," Node and element queries not implemented\n"); + return(Z_OK); + } + else if(err == Z_ERR) { + fprintf(stderr," Could not get value\n"); + } + else { + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + +#if (defined GT_USERD_API_100) + if(Varinfo[v].complex) { + + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals, + TRUE); + + if(err == Z_ERR) { + fprintf(stderr," Could not get imag value\n"); + } + else { + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value (imag) is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values (imag) are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + } + } +#endif + + } + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + + fprintf(stderr," For part %d, using elem %d of type %s:\n", + pn,nsize,Elem_info[et].name); + + +#if (defined GT_USERD_API_100) + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals, + FALSE); +#else + err = USERD_get_variable_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals); +#endif + + if(err == Z_NOT_IMPLEMENTED) { + fprintf(stderr," Node and element queries not implemented\n"); + return(Z_OK); + } + else if(err == Z_ERR) { + fprintf(stderr," Could not get value\n"); + } + else { + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + +#if (defined GT_USERD_API_100) + if(Varinfo[v].complex) { + + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals, + TRUE); + if(err == Z_ERR) { + fprintf(stderr," Could not get imag value\n"); + } + else { + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value (imag) is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values (imag) are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + } + } +#endif + } + } + } + } + } + } + } + + return(Z_OK); +} + + +/*-------------- + * exercise_bkup + *--------------*/ +static int +exercise_bkup( void ) +{ + int err; + FILE *arcfile; + + fprintf(stderr,"\n------------ exercise_archive -----------\n"); + + arcfile = fopen("test.arc","wb"); + if(arcfile == (FILE *)NULL) { + fprintf(stderr,"Error: opening test archive file\n"); + return(Z_ERR); + } + err = USERD_bkup(arcfile,Z_SAVE_ARCHIVE); + if(err == Z_ERR) { + fprintf(stderr,"Error: saving to test archive file\n"); + return(Z_ERR); + } + fclose(arcfile); + + arcfile = fopen("test.arc","rb"); + err = USERD_bkup(arcfile,Z_REST_ARCHIVE); + if(err == Z_ERR) { + fprintf(stderr,"Error: restoring from test archive file\n"); + return(Z_ERR); + } + + fprintf(stderr," Archive test completed\n"); + + fclose(arcfile); + + return(Z_OK); +} + +/* ------------------------------------------------------- + * threshold_operator1 & 2 can be one of the following + * Z_ELE_FAILED_NONE, - disables checking + * Z_ELE_FAILED_GREATER, - greater than + * Z_ELE_FAILED_LESS, - less than + * Z_ELE_FAILED_EQUAL, - equal + * Z_ELE_FAILED_NOT_EQUAL, - not equal + * Z_ELE_FAILED_MANY - not used + * + * logic_criteria2 + * Z_ELE_FAILED_LOGIC_NONE, + * Z_ELE_FAILED_LOGIC_AND, + * Z_ELE_FAILED_LOGIC_OR, + * Z_ELE_FAILED_LOGIC_MANY + * + * ------------------------------------------------------ */ +int load_fail_defaults(void) +{ + int check_for_failed = FALSE; + int cri1 = 0; /* Criteria1 ELE_FAILED_GREATER, etc */ + int cri2 = 0; + int logic_cri2 = 0; /* Logic for criteria 2 ELE_FAILED_LOGIC_NONE, AND, etc */ + float val1 = 0.0; /* failure threshold 1 */ + float val2= 0.0; /* failure threshold 2 */ + char failed_var_name[Z_MXVARIABLEDESC]={EOS}; + + check_for_failed = USERD_get_uns_failed_params( failed_var_name, + &val1, &val2, &cri1, &cri2, + &logic_cri2 ); + if (check_for_failed == TRUE) { + fprintf(stderr,"Failed element criteria info \n"); + fprintf(stderr,"Variable name = %s\n",failed_var_name); + fprintf(stderr,"Criteria 1 = %d\n",cri1); + fprintf(stderr,"Criteria 2 = %d\n",cri1); + fprintf(stderr,"Logic criteria = %d\n",logic_cri2); + fprintf(stderr,"Value 1 = %f\n",val1); + fprintf(stderr,"Value 2 = %f\n",val2); + } else { + fprintf(stderr,"No Failed elements\n"); + } + return(Z_OK); +} + + +/* End of File */ diff --git a/applications/test/ensightFoamReader/udr_checker-82.c b/applications/test/ensightFoamReader/udr_checker-82.c new file mode 100644 index 0000000000..8e0c572db6 --- /dev/null +++ b/applications/test/ensightFoamReader/udr_checker-82.c @@ -0,0 +1,5884 @@ +/*---------------------------------- + * User Defined Reader - checker + *----------------------------------*/ + +/******************************************************************** + * + * **************************************** + * Copyright 2004 Computational Engineering International, Inc. + * All Rights Reserved. + * + * Restricted Rights Legend + * + * Use, duplication, or disclosure of this + * software and its documentation by the + * Government is subject to restrictions as + * set forth in subdivision [(b)(3)(ii)] of + * the Rights in Technical Data and Computer + * Software clause at 52.227-7013. + *******************************************************************/ + +/*---------------------------------------------------------------------- + * MAJOR ROUTINES ACCESS: (VERSION 2.00) Gold_Userd API + * + * Get the name of the reader + * ========================== + * USERD_get_name_of_reader + * USERD_get_extra_gui_numbers (optional) + * USERD_get_extra_gui_defaults (optional) + * + * Get the reader version + * ====================== + * USERD_get_reader_version + * + * Set the filenames, gather timeset and time info + * =============================================== + * USERD_set_extra_gui_data (optional) + * USERD_set_server_number + * USERD_set_filenames + * USERD_get_number_of_timesets + * USERD_get_geom_timeset_number + * + * for each timeset: + * USERD_get_timeset_description + * USERD_get_num_of_time_steps + * USERD_get_sol_times + * + * USERD_set_time_set_and_step + * + * + * Gather variable and time info + * ============================= + * USERD_get_number_of_variables + * USERD_get_gold_variable_info + * + * + * Get initial part building info + * ============================== + * USERD_set_time_set_and_step + * USERD_get_changing_geometry_status + * USERD_get_node_label_status + * USERD_get_element_label_status + * USERD_get_number_of_files_in_dataset + * USERD_get_dataset_query_file_info + * USERD_get_descrip_lines (geometry) + * USERD_get_number_of_model_parts + * USERD_get_gold_part_build_info + * USERD_get_ghosts_in_model_flag + * USERD_get_maxsize_info + * USERD_get_ghosts_in_block_flag (if any ghost cells in model) + * USERD_get_model_extents **OR** + * USERD_get_part_coords **AND/OR** + * USERD_get_block_coords_by_component + * + * + * + * Part Builder + * ============ + * + * both unstructured and structured + * -------------------------------- + * USERD_set_time_set_and_step + * + * if unstructured + * --------------- + * USERD_get_part_element_ids_by_type + * USERD_get_part_elements_by_type + * + * if any nsided elements: + * USERD_get_nsided_conn + * + * if any nfaced elements: + * USERD_get_nfaced_nodes_per_face + * USERD_get_nfaced_conn + * + * USERD_get_part_coords + * USERD_get_part_node_ids + * + * else if structured + * ------------------ + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * USERD_get_block_ghost_flags + * USERD_get_part_node_ids (If node ids given) + * USERD_get_part_element_ids_by_type (If element ids given) + * + * both again + * ---------- + * USERD_get_border_availability (If border representation + * USERD_get_border_elements_by_type is selected) + * + * USERD_stop_part_building + * + * + * Changing geometry + * ================= + * + * changing coords only + * -------------------- + * USERD_set_time_set_and_step + * USERD_get_descrip_lines + * USERD_get_part_coords + * USERD_get_block_coords_by_component + * + * changing connectivity + * --------------------- + * USERD_set_time_set_and_step + * USERD_get_descrip_lines + * USERD_get_number_of_model_parts + * USERD_get_gold_part_build_info + * USERD_get_ghosts_in_model_flag + * USERD_get_ghosts_in_block_flag (If any ghost cells in model) + * USERD_get_model_extents **OR** + * USERD_get_part_coords **AND/OR** + * USERD_get_block_coords_by_component + * USERD_get_part_element_ids_by_type + * USERD_get_part_elements_by_type + * USERD_get_part_coords + * USERD_get_part_node_ids + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * USERD_get_block_ghost_flags (If ghost cells in part) + * USERD_get_part_node_ids (If node ids given) + * USERD_get_part_element_ids_by_type (If element ids given) + * + * USERD_get_border_availability (If border representation + * USERD_get_border_elements_by_type is selected) + * + * + * Loading Variables + * ================== + * + * constants + * --------- + * USERD_set_time_set_and_step + * USERD_get_constant_val + * + * scalars/vectors/tensors + * ----------------------- + * USERD_get_description_lines + * USERD_set_time_set_and_step + * USERD_get_var_by_component + * + * + * Node or Element queries over time + * ================================= + * USERD_get_var_value_at_specific + * + * + * At 2.03, added: + * --------------- + * + * Materials + * ========= + * USERD_get_number_of_material_sets + * USERD_get_matf_set_info + * + * If any material sets in the model (calls once per material set) + * USERD_get_number_of_materials + * USERD_get_matf_var_info + * + * For each element type of each part containing material ids + * USERD_size_matf_data + * USERD_load_matf_data + * + * + * At 2.04, added: + * --------------- + * USERD_get_uns_failed_params - Sets params used in element failure + * + * + *----------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------- + * MAJOR ROUTINES ACCESS: (Version 1.00) original API + * + * Get the name of the reader + * ========================== + * USERD_get_name_of_reader + * USERD_get_extra_gui_numbers (optional -extra_gui on command line) + * USERD_get_extra_gui_defaults (optional -extra_gui on command line) + * + * Set the filenames + * ================= + * USERD_set_extra_gui_data (optional -extra_gui on command line) + * USERD_set_filenames + * USERD_get_number_of_time_steps + * USERD_get_solution_times + * USERD_set_time_step + * + * + * Gather variable and time info + * ============================= + * USERD_get_number_of_variables + * USERD_get_variable_info + * + * + * Get initial part building info + * ============================== + * USERD_set_time_step + * USERD_get_changing_geometry_status + * USERD_get_node_label_status + * USERD_get_element_label_status + * USERD_get_number_of_files_in_dataset + * USERD_get_dataset_query_file_info + * USERD_get_description_lines (geometry) + * USERD_get_number_of_model_parts + * USERD_get_part_build_info + * USERD_get_number_global_nodes + * USERD_get_global_coords + * USERD_get_block_coords_by_component + * + * Failure Info + * ============ + * USERD_get_uns_failed_params + * + * + * Part Builder + * ============ + * USERD_set_time_step + * USERD_get_global_coords + * USERD_get_global_node_ids + * USERD_get_element_connectivities_for_part + * USERD_get_element_ids_for_part + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * + * USERD_stop_part_building + * + * + * Changing geometry + * ================= + * + * changing coords only + * -------------------- + * USERD_set_time_step + * USERD_get_global_coords + * USERD_get_block_coords_by_component + * + * changing connectivity + * --------------------- + * USERD_set_time_step + * USERD_get_number_of_model_parts + * USERD_get_part_build_info + * USERD_get_number_global_nodes + * USERD_get_global_coords + * USERD_get_global_node_ids + * USERD_get_element_connectivities_for_part + * USERD_get_element_ids_for_part + * USERD_get_block_iblanking + * USERD_get_block_coords_by_component + * + * Loading Variables + * ================= + * + * constants: + * ---------- + * USERD_set_time_step + * USERD_get_constant_value + * + * scalars: + * -------- + * USERD_get_description_lines + * USERD_set_time_step + * USERD_get_scalar_values + * USERD_get_block_scalar_values + * + * vectors: + * -------- + * USERD_get_description_lines + * USERD_set_time_step + * USERD_get_vector_values + * USERD_get_block_vector_values_by_component + * + * + * Node or Element queries over time + * ================================= + * USERD_get_variable_value_at_specific + * + *----------------------------------------------------------------------*/ +#include +#include +#ifndef WIN32 +#include +#endif +#include +#include +#include +#ifndef CONVEX +#include +#endif +#include + +#include "global_extern.h" + +/* ----------------------------------------------- + * If you wish to test out various optional routines + * you must uncomment the proper #define below + * + * #define _EGS is for extra_gui routines + * #define _VES is for var_extract_gui routines + *---------------------------------------------------*/ +/* #define _EGS */ +/* #define _VES */ + + +#if (defined USERD_API_209) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 +#define GT_USERD_API_204 +#define GT_USERD_API_205 +#define GT_USERD_API_206 +#define GT_USERD_API_207 +#define GT_USERD_API_208 + +#elif (defined USERD_API_208) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 +#define GT_USERD_API_204 +#define GT_USERD_API_205 +#define GT_USERD_API_206 +#define GT_USERD_API_207 + +#elif (defined USERD_API_207) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 +#define GT_USERD_API_204 +#define GT_USERD_API_205 +#define GT_USERD_API_206 + +#elif (defined USERD_API_206) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 +#define GT_USERD_API_204 +#define GT_USERD_API_205 + +#elif (defined USERD_API_205) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 +#define GT_USERD_API_204 + +#elif (defined USERD_API_204) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 +#define GT_USERD_API_203 + +#elif (defined USERD_API_203) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 +#define GT_USERD_API_202 + +#elif (defined USERD_API_202) +#define GT_USERD_API_100 +#define GT_USERD_API_200 +#define GT_USERD_API_201 + +#elif (defined USERD_API_201) +#define GT_USERD_API_100 +#define GT_USERD_API_200 + +#elif (defined USERD_API_200) +#define GT_USERD_API_100 +#endif + + +#define EOS '\0' + +typedef struct { + int id; /* part_id */ + char desc[Z_BUFL]; /* description given in the file */ + int type; /* Z_UNSTRUCTURED, Z_STRUCTURED, Z_IBLANKED */ + int ne[Z_MAXTYPE]; /* Number of elements per type (Z_UNSTRUCTURED) */ + /* or ne[0] = I dimension (Z_STRUCTURED) */ + /* ne[1] = J dimension */ + /* ne[2] = K dimension */ + int nn; /* Num of unstructured nodes (All_Local only) */ + int ghosts; /* TRUE if ghost cells, FALSE otherwise */ +}BUILDINFO; + +typedef struct { + char description[Z_BUFL]; /* description */ + char filename[Z_BUFL]; /* real filename */ + char ifilename[Z_BUFL]; /* imaginary filename */ + int type; + int classify; + int complex; + float freq; + int contran; + int timeset; +}VARINFO; + + +typedef struct { + char name[12]; /* Z_POINT, Z_G_POINT, Z_BAR02, ... */ + int con_len; /* Number of nodes per element */ +}EINFO; + + +/* Global variables + *-----------------*/ +int Geom_status; +int Node_labels; +int Element_labels; +int Ghosts_in_model; +int Num_parts; +int Num_vars; +int Num_materials_sets; +BUILDINFO *Pbuild; +VARINFO *Varinfo; +char Version_number[Z_MAX_USERD_NAME]; +int Num_time_sets; +int Num_time_steps; + +/* ------------------ + * Extra GUI stuff + * ------------------ */ +int Num_toggles = 0; +int Num_pulldowns = 0; +int Num_fields = 0; +char **Toggle_title; +int *Toggle_default_status; +char **Pulldown_title; +int *Pulldown_number_in_list; +int *Pulldown_default_selection; +char ***Pulldown_item_strings; +char **Field_title; +char **Field_user_string; +int *Toggle_choice; /* user choice */ +int *Pulldown_choice; /* user choice */ + +/* ------------------ + * Var Extract stuff + * ------------------ */ +int Num_ve_toggles = 0; +int Num_ve_pulldowns = 0; +int Num_ve_fields = 0; +char **Toggle_ve_title; +int *Toggle_ve_default_status; +char **Pulldown_ve_title; +int *Pulldown_ve_number_in_list; +int *Pulldown_ve_default_selection; +char ***Pulldown_ve_item_strings; +char **Field_ve_title; +char **Field_ve_user_string; +int *Toggle_ve_choice; /* user choice */ +int *Pulldown_ve_choice; /* user choice */ + +/* --------------------------- + * Failed elements (API 2.04) + * --------------------------- */ +int Any_uns_failed_model_elems = FALSE; + +/* --------------------------- + * Rigidbody (API 2.05) + * --------------------------- */ +int Any_Rigid_Body_Present = FALSE; + +/* --------------------------- + * Structured Reader Cinching (API 2.06) + * --------------------------- */ +int Doing_Structured_Cinching = FALSE; + + + +#if (defined USERD_API_100 || defined USERD_API_200) +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT",1, + "Z_BAR02",2, + "Z_BAR03",3, + "Z_TRI03",3, + "Z_TRI06",6, + "Z_QUA04",4, + "Z_QUA08",8, + "Z_TET04",4, + "Z_TET10",10, + "Z_PYR05",5, + "Z_PYR13",13, + "Z_PEN06",6, + "Z_PEN15",15, + "Z_HEX08",8, + "Z_HEX20",20}; +#elif defined USERD_API_201 +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT", 1, + "Z_G_POINT",1, + "Z_BAR02", 2, + "Z_G_BAR02",2, + "Z_BAR03", 3, + "Z_G_BAR03",3, + "Z_TRI03", 3, + "Z_G_TRI03",3, + "Z_TRI06", 6, + "Z_G_TRI06",6, + "Z_QUA04", 4, + "Z_G_QUA04",4, + "Z_QUA08", 8, + "Z_G_QUA08",8, + "Z_TET04", 4, + "Z_G_TET04",4, + "Z_TET10", 10, + "Z_G_TET10",10, + "Z_PYR05", 5, + "Z_G_PYR05",5, + "Z_PYR13", 13, + "Z_G_PYR13",13, + "Z_PEN06", 6, + "Z_G_PEN06",6, + "Z_PEN15", 15, + "Z_G_PEN15",15, + "Z_HEX08", 8, + "Z_G_HEX08",8, + "Z_HEX20", 20, + "Z_G_HEX20",20}; +#else +EINFO Elem_info[Z_MAXTYPE] = {"Z_POINT", 1, + "Z_G_POINT",1, + "Z_BAR02", 2, + "Z_G_BAR02",2, + "Z_BAR03", 3, + "Z_G_BAR03",3, + "Z_TRI03", 3, + "Z_G_TRI03",3, + "Z_TRI06", 6, + "Z_G_TRI06",6, + "Z_QUA04", 4, + "Z_G_QUA04",4, + "Z_QUA08", 8, + "Z_G_QUA08",8, + "Z_TET04", 4, + "Z_G_TET04",4, + "Z_TET10", 10, + "Z_G_TET10",10, + "Z_PYR05", 5, + "Z_G_PYR05",5, + "Z_PYR13", 13, + "Z_G_PYR13",13, + "Z_PEN06", 6, + "Z_G_PEN06",6, + "Z_PEN15", 15, + "Z_G_PEN15",15, + "Z_HEX08", 8, + "Z_G_HEX08",8, + "Z_HEX20", 20, + "Z_G_HEX20",20, + "Z_NSIDED", 1, /* Not yet implemented */ + "Z_G_NSIDED",1, /* Not yet implemented */ + "Z_NFACED", 1, /* Not yet implemented */ + "Z_G_NFACED",1}; /* Not yet implemented */ +#endif + + +/* Prototypes + *-----------*/ +static int load_fail_defaults(void); +static int prelim_info(int *two_fields, + int *any_extra_gui, + int *any_var_extract); +static int get_input(int set_server_number, + int use_playfile, + char playfile[Z_MAXFILENP], + int two_fields, + int any_extra_gui, + int any_var_extract, + int *swapbytes); +static int time_info( void ); +static int part_build_info(int geom_time_step); +static int variable_info( void ); + +#if (defined GT_USERD_API_100) +static int gold_part_builder(int geom_time_step); +static int gold_var_loader(int var_time_step); +#else +static int part_builder(int geom_time_step); +static int var_loader(int var_time_step); +#endif + +#if (defined GT_USERD_API_100) +static int materials_info( void ); +static int gold_materials_loader(int geom_time_step); +#endif + +static int entity_querys(int var_time_step); +static int exercise_bkup( void ); +static void usage( void ); + + +/*============= + * Main Routine + *=============*/ +#ifdef WIN32 +int main(int argc, char *argv[]) +#else +int main(int argc, char *argv[]) +#endif +{ + /* Command line option variables + *------------------------------*/ + int set_server_number = FALSE; + int use_playfile = FALSE; + char playfile[Z_MAXFILENP]; + FILE *fplay; + int geom_time_step = 0; + int var_time_step = 0; + + /* Other local variables + *----------------------*/ + int i, j; + int err; + int two_fields; + int any_extra_gui = FALSE; + int any_var_extract = FALSE; + int swapbytes; + int indx; + + /*---------------------------- + * Command argument processing + *----------------------------*/ + fprintf(stderr,"\n"); + fprintf(stderr,"\n"); + fprintf(stderr,"********************************************\n"); + fprintf(stderr,"* EnSight User Defined Reader Debug Tool *\n"); + fprintf(stderr,"********************************************\n"); + fprintf(stderr,"\n"); + + indx = 1; + while(indx < argc) { + + if(!strcmp("-h",argv[indx])) { + usage(); + } + else if(!strcmp("-help",argv[indx])) { + usage(); + } + + /* if you want to test the server number routines + * + * Use: + * > checker -server_number + * + * You will then be prompted for the current and total + * number of servers + *-----------------------------------------------*/ + else if(!strcmp("-server_number",argv[indx])) { + set_server_number = TRUE; + } + + /* if you want to use a "playfile" instead of being prompted + * for the data loader information + * + * Use: + * > checker -p + * + * This playfile should have 3 [or 4] lines: + * line 1: the path + * line 2: filename_1 + * line 3: [filename_2] (if two_fields is TRUE) + * line 4: 0 or 1, for swapytes (0 is FALSE, 1 is TRUE) + * + * example (two_fields is FALSE, so only 3 lines): + * + * /usr/scratch/stealth/bjn/dat/sp_gold/binary + * simple.case + * 1 + * + *------------------------------------------------------*/ + else if(!strcmp("-p",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + use_playfile = TRUE; + memset(playfile,EOS,Z_MAXFILENP); + strcpy(playfile,argv[indx]); + } + else { + usage(); + } + } + + /* if you want to specify the geometry timestep to test (default is step 0) + * + * Use: + * > checker -gts # + * + * Where # is the step number (zero based) + *-------------------------------------------------------------------------*/ + else if(!strcmp("-gts",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + geom_time_step = atoi(argv[indx]); + } + else { + usage(); + } + } + + /* if you want to specify the variable timestep to test (default is step 0) + * (will use this step for the appropriate timeset of each variable) + * + * Use: + * > checker -vts # + * + * Where # is the step number (zero based) + *-------------------------------------------------------------------------*/ + else if(!strcmp("-vts",argv[indx])) { + indx++; + if((indx < argc) && (argv[indx][0] != '-')) { + var_time_step = atoi(argv[indx]); + } + else { + usage(); + } + } + else { + usage(); + } + + indx++; + } + + + /*------------------------------------------------------------- + * + * Now start exercising EnSight + * + *--------------------------------------------------------------*/ + + /*----------------- + * Preliminary info + *-----------------*/ + err = prelim_info(&two_fields,&any_extra_gui,&any_var_extract); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in prelim_info\n"); + exit(1); + } + + + /*------------------ + * User input needed + *------------------*/ + err = get_input(set_server_number, + use_playfile, + playfile, + two_fields, + any_extra_gui, + any_var_extract, + &swapbytes); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in get_input\n"); + exit(1); + } + + + /*---------- + * Time info + *----------*/ + err = time_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in time_info\n"); + exit(1); + } + + + /*---------------- + * Part build info + *----------------*/ + err = part_build_info(geom_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in part_build_info\n"); + exit(1); + } + + + /*------------------ + * Get Variable Info + *------------------*/ + err = variable_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in variable_info\n"); + exit(1); + } + + +#if (defined GT_USERD_API_202) + /*------------------- + * Get Materials Info + *-------------------*/ + err = materials_info(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in materials_info\n"); + exit(1); + } +#endif + +#if (defined GT_USERD_API_203) + if (Z_ERR == load_fail_defaults()) { + fprintf(stderr,"Stopping due to error in failed element flag routine\n"); + exit(1); + } +#endif + +#if (defined GT_USERD_API_204) + + /*----------------------------------------------- + * Mel needs to do these species routines yet!!! + *----------------------------------------------*/ + /* USERD_get_matsp_info + USERD_get_number_of_species */ + + + /* See if any rigid body in model + *-------------------------------*/ + fprintf(stderr,"\n------------- rigid body existence -------------\n"); + if(USERD_rigidbody_existence() == Z_OK) { + fprintf(stderr," Rigid Body values exist in the model\n"); + Any_Rigid_Body_Present = TRUE; + } + else { + fprintf(stderr," N0 Rigid Body values exist in the model\n"); + } + +#endif + + +#if (defined GT_USERD_API_205) + + /* See if doing structured cinching + *---------------------------------*/ + fprintf(stderr,"\n------------- structured reader cinching existence -------------\n"); + if(USERD_get_structured_reader_cinching() == Z_OK) { + fprintf(stderr," Doing structured reader cinching\n"); + fprintf(stderr," for each of the i,j,k directions,\n"); + fprintf(stderr," will send in min and max unchanged, but\n"); + fprintf(stderr," will send in stride as 2\n"); + Doing_Structured_Cinching = TRUE; + } + else { + fprintf(stderr," NOT doing structured reader cinching\n"); + } +#endif + +#if (defined GT_USERD_API_206) + + /* Probably won't do either of these - trivial + *--------------------------------------------*/ + /* USERD_prefer_auto_distribute */ + /* USERD_set_filename_button_labels */ +#endif + + +#if (defined GT_USERD_API_207) + + /* If we choose to do these, Bruce should implement them + *------------------------------------------------------*/ + /* All the _buffer routines! */ + + /* If we choose to do these, Bill should implement them + *-----------------------------------------------------*/ + /* USERD_get_num_xy_queries + USERD_get_xy_query_data + USERD_get_xy_query_info */ + +#endif + +#if (defined GT_USERD_API_208) + + /* If we choose to do these, Bruce should implement them + *------------------------------------------------------*/ + /* VGLYPH routines */ +#endif + + /*------------------------ + * Act like building parts + *------------------------*/ + if(Num_parts > 0) { + +#if (defined GT_USERD_API_100) + err = gold_part_builder(geom_time_step); +#else + err = part_builder(geom_time_step); +#endif + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in part_builder\n"); + exit(1); + } + else { + USERD_stop_part_building(); + } + } + + + /*--------------------------- + * Act like loading variables + *---------------------------*/ + if(Num_vars > 0) { + +#if (defined GT_USERD_API_100) + err = gold_var_loader(var_time_step); +#else + err = var_loader(var_time_step); +#endif + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in var_loader\n"); + exit(1); + } + } + +#if (defined GT_USERD_API_202) + /*--------------------------- + * Act like loading materials + *---------------------------*/ + if(Num_materials_sets > 0) { + err = gold_materials_loader(geom_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in materials_loader\n"); + exit(1); + } + } +#endif + + + + /*---------------------------------------------------- + * See if can do node and/or element queries over time + *----------------------------------------------------*/ + if(Num_parts > 0 && + Num_vars > 0) { + err = entity_querys(var_time_step); + if(err == Z_ERR) { + fprintf(stderr,"Stopping because of error in entity_querys\n"); + exit(1); + } + } + + /*---------------------------------------- + * Call the bkup file once in save mode, + * then again in restore mode - so someone + * could debug if desired + *----------------------------------------*/ + err = exercise_bkup(); + if(err == Z_ERR) { + fprintf(stderr,"Stopping due to error in saving and/or restoring archive\n"); + exit(1); + } + + /*------------- + * Exit Routine + *-------------*/ + fprintf(stderr,"\n----------------- exiting ---------------\n"); + +#if (defined GT_USERD_API_100) + USERD_exit_routine(); +#endif + + fprintf(stderr,"\n\n"); + + return(0); +} + +/*-------------- + * Usage routine + *--------------*/ +static void +usage( void ) +{ + fprintf(stderr,"------------------------------------------------------------\n"); + fprintf(stderr,"USAGE: checker [-p pfile] [-server_number] [-gts #] [-vts #]\n"); + fprintf(stderr,"------------------------------------------------------------\n"); + fprintf(stderr," -h, -help Prints out this USAGE text.\n"); + fprintf(stderr," -gts # Specify the geometry time step to use.)\n"); + fprintf(stderr," -p pfile Plays the checker playfile (pfile).\n"); + fprintf(stderr," -server_number Cause servers numbers to be prompted for.\n"); + fprintf(stderr," -vts # Specify the variable time step to use.)\n"); + fprintf(stderr,"\n"); + exit(1); +} + + + + +/*------------ + * prelim_info + *------------*/ +static int +prelim_info(int *two_fields, int *any_extra_gui, int *any_var_extract) +{ + int err; + char reader_name[Z_MAX_USERD_NAME]; + char release_number[Z_MAX_USERD_NAME]; + char description[Z_MAXFILENP]; + int i,j; + + *any_extra_gui = FALSE; + *any_var_extract = FALSE; + + /* Get the reader name + *--------------------*/ + err = USERD_get_name_of_reader(reader_name,two_fields); + if(err == Z_OK) { + fprintf(stderr," Name of reader: %s\n",reader_name); + if(*two_fields==1) { + fprintf(stderr," two_fields: TRUE\n"); + } + else if(*two_fields==0){ + fprintf(stderr," two_fields: FALSE\n"); + } + else if(*two_fields < 0) { + fprintf(stderr," two_fields: -1 (optional string) \n"); + } + } + else { + fprintf(stderr,"Error: Could not get name of reader\n"); + return(Z_ERR); + } + + /* Get the Extra GUI stuff (optional) + * ---------------------------------------------------------- */ +#ifdef _EGS + + /* Get the Extra GUI numbers of toggles, pulldowns, & fields + * ---------------------------------------------------------- */ + + USERD_get_extra_gui_numbers( &Num_toggles, + &Num_pulldowns, + &Num_fields ); + + if ( Num_toggles > 0 || Num_pulldowns > 0 || Num_fields > 0 ) { + + *any_extra_gui = TRUE; + + if (Num_toggles>0) { + Toggle_title = (char **) calloc(Num_toggles,sizeof(char*)); + if (Toggle_title == (char **)NULL) return(Z_ERR); + for (i=0; i 0) { + Pulldown_title = (char **) calloc( Num_pulldowns , sizeof(char*) ); + if (Pulldown_title == (char **)NULL) return(Z_ERR); + + Pulldown_item_strings = (char ***) calloc( Num_pulldowns , sizeof(char**) ); + if (Pulldown_item_strings == (char ***)NULL) return(Z_ERR); + + for (i=0; i 0) { + Field_title = (char **) calloc(Num_fields,sizeof(char*)); + Field_user_string = (char **) calloc(Num_fields,sizeof(char*)); + if (Field_title == (char **) NULL) return(Z_ERR); + for (i=0; i 0 || Num_ve_pulldowns > 0 || Num_ve_fields > 0 ) { + + *any_var_extract = TRUE; + + if (Num_ve_toggles > 0) { + Toggle_ve_title = (char **) calloc(Num_ve_toggles,sizeof(char*)); + if (Toggle_ve_title == (char **)NULL) return(Z_ERR); + for (i=0; i 0) { + Pulldown_ve_title = (char **) calloc( Num_ve_pulldowns , sizeof(char*) ); + if (Pulldown_ve_title == (char **)NULL) return(Z_ERR); + + Pulldown_ve_item_strings = (char ***) calloc( Num_ve_pulldowns , sizeof(char**) ); + if (Pulldown_ve_item_strings == (char ***)NULL) return(Z_ERR); + + for (i=0; i 0) { + Field_ve_title = (char **) calloc(Num_ve_fields,sizeof(char*)); + Field_ve_user_string = (char **) calloc(Num_ve_fields,sizeof(char*)); + if (Field_ve_title == (char **) NULL) return(Z_ERR); + for (i=0; i 0) { + fprintf(stderr,"Error: timeset numbers must be 1 or greater\n"); + fprintf(stderr," (unless Num_time_sets is zero also)\n"); + } + + + /* For each timeset + *-----------------*/ + for(ts=1; ts<=Num_time_sets; ++ts) { + + fprintf(stderr," Timeset %d:\n",ts); + + /* Get the timeset descriptions + *-----------------------------*/ + err = USERD_get_timeset_description(ts,ts_desc); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting timeset description\n"); + return(Z_ERR); + } + else { + fprintf(stderr," description: %s\n",ts_desc); + } + + /* Get the number of time steps + *-----------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(ts); + fprintf(stderr," number of time steps: %d\n",Num_time_steps); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + + + /* Get the solution times + *-----------------------*/ + if(Num_time_steps > 0) { + sol_times = (float *) calloc(Num_time_steps,sizeof(float)); + if(sol_times == (float *)NULL) { + fprintf(stderr,"Error: allocating for solution times\n"); + return(Z_ERR); + } + else { + err = USERD_get_sol_times(ts,sol_times); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting solution times\n"); + return(Z_ERR); + } + else { + for(i=0; i0 to be okay)\n"); + return(Z_ERR); + } + + + /* Get the solution times + *-----------------------*/ + if(Num_time_steps > 0) { + sol_times = (float *) calloc(Num_time_steps,sizeof(float)); + if(sol_times == (float *)NULL) { + fprintf(stderr,"Error: allocating for solution times\n"); + return(Z_ERR); + } + else { + err = USERD_get_solution_times(sol_times); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting solution times\n"); + return(Z_ERR); + } + else { + for(i=0; i0 to be okay)\n"); + return(Z_ERR); + } + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step + *-----------------------------------------*/ + USERD_set_time_set_and_step(geom_time_set,geom_time_step); + +#else + + /* Set the time step - to first step + *----------------------------------*/ + USERD_set_time_step(geom_time_step); + +#endif + + /* Get the changing geometry status + *---------------------------------*/ + Geom_status = USERD_get_changing_geometry_status(); + if(Geom_status == Z_STATIC) { + fprintf(stderr," Geom changing status: Z_STATIC\n"); + } + else if(Geom_status == Z_CHANGE_COORDS) { + fprintf(stderr," Geom changing status: Z_CHANGE_COORDS\n"); + } + else if(Geom_status == Z_CHANGE_CONN) { + fprintf(stderr," Geom changing status: Z_CHANGE_CONN\n"); + } + else { + fprintf(stderr," Invalid Geom changing status!!\n"); + } + + + /* Get the node label status + *--------------------------*/ + Node_labels = USERD_get_node_label_status(); + if(Node_labels) { + fprintf(stderr," Node labels will be provided\n"); + } + else { + fprintf(stderr," Node labels will NOT be provided\n"); + } + + /* Get the element label status + *-----------------------------*/ + Element_labels = USERD_get_element_label_status(); + if(Element_labels) { + fprintf(stderr," Element labels will be provided\n"); + } + else { + fprintf(stderr," Element labels will NOT be provided\n"); + } + + fprintf(stderr,"\n"); + + /* Get the number of files in the dataset + *---------------------------------------*/ + num_dataset_files = USERD_get_number_of_files_in_dataset(); + fprintf(stderr," Number of files in dataset: %d\n",num_dataset_files); + + + /* Get the dataset query file info + *--------------------------------*/ + if(num_dataset_files > 0) { + + qfiles = (Z_QFILES *) calloc(num_dataset_files,sizeof(Z_QFILES)); + if(qfiles == (Z_QFILES *)NULL) { + fprintf(stderr,"Error: allocating for dataset query files\n"); + return(Z_ERR); + } + else { + + for(i=0; i 0) { + fprintf(stderr," Number of parts: %d\n",Num_parts); + } + else { + fprintf(stderr," Problems getting number of parts\n"); + return(Z_ERR); + } + + + + /* Get the gold part build info + *-----------------------------*/ + Pbuild = (BUILDINFO *) calloc(Num_parts,sizeof(BUILDINFO)); + if(Pbuild == (BUILDINFO *)NULL) { + fprintf(stderr," Problems allocating for Pbuild structure\n"); + return(Z_ERR); + } + + + part_ids = (int *) calloc(Num_parts,sizeof(int)); + if(part_ids == (int *)NULL) { + fprintf(stderr," Problems allocating for part ids\n"); + return(Z_ERR); + } + + part_types = (int *) calloc(Num_parts,sizeof(int)); + if(part_types == (int *)NULL) { + fprintf(stderr," Problems allocating for part types\n"); + return(Z_ERR); + } + + part_descriptions = (char **) calloc(Num_parts,sizeof(char *)); + if(part_descriptions == (char **)NULL) { + fprintf(stderr," Problems allocating for part descriptions\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," # %s elements: %d\n", + Elem_info[j].name,num_elems[i][j]); + Pbuild[i].ne[j] = num_elems[i][j]; + } + } + + if(part_types[i] != Z_UNSTRUCTURED) { + + /* For this checker, we will place the following in the + * Pbuild[].ne[] structure: + * + * Note this can be used for block size whether ranges or not + * ------------------------------------------------------------- + * Pbuild[].ne[0] = i dim of current block (to the range selected) + * Pbuild[].ne[1] = j dim of current block (to the range selected) + * Pbuild[].ne[2] = k dim of current block (to the range selected) + * + * Thus if ranges: + * --------------- + * Pbuild[].ne[3] = i min range (-1 indicates no ranges) + * Pbuild[].ne[4] = i max range + * Pbuild[].ne[5] = i min range + * Pbuild[].ne[6] = i max range + * Pbuild[].ne[7] = i min range + * Pbuild[].ne[8] = i max range + * + * Pbuild[].ne[9] = i dim of total block (if ranges) + * Pbuild[].ne[10] = j dim of total block (if ranges) + * Pbuild[].ne[11] = k dim of total block (if ranges) + * + * What comes back from the api is: + * -------------------------------- + * before 2.03 (no ranges) + * ----------------------- + * ijk_dimensions[][0] = i dim of block + * ijk_dimensions[][1] = j dim of block + * ijk_dimensions[][2] = k dim of block + * + * at 2.03 (if no ranges) + * ------- + * ijk_dimensions[][0] = i dim of block + * ijk_dimensions[][1] = j dim of block + * ijk_dimensions[][2] = k dim of block + * ijk_dimensions[][3] = -1 + * + * at 2.03 (if ranges) + * ------- + * ijk_dimensions[][0] = i dim of total block + * ijk_dimensions[][1] = j dim of total block + * ijk_dimensions[][2] = k dim of total block + * ijk_dimensions[][3] = i min range + * ijk_dimensions[][4] = i max range + * ijk_dimensions[][5] = j min range + * ijk_dimensions[][6] = j max range + * ijk_dimensions[][7] = k min range + * ijk_dimensions[][8] = k max range + *--------------------------------------------------------------*/ + +#if (defined GT_USERD_API_202) + if(ijk_dimensions[i][3] == -1) { + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = ijk_dimensions[i][3]; + } + else { + + /* If empty part + *--------------*/ + if(ijk_dimensions[i][0] == 0 && + ijk_dimensions[i][1] == 0 && + ijk_dimensions[i][2] == 0) { + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = -1; + } + + /* range part + *-----------*/ + else { + Pbuild[i].ne[0] = ijk_dimensions[i][4] - ijk_dimensions[i][3] + 1; + Pbuild[i].ne[1] = ijk_dimensions[i][6] - ijk_dimensions[i][5] + 1; + Pbuild[i].ne[2] = ijk_dimensions[i][8] - ijk_dimensions[i][7] + 1; + + Pbuild[i].ne[3] = ijk_dimensions[i][3]; + Pbuild[i].ne[4] = ijk_dimensions[i][4]; + Pbuild[i].ne[5] = ijk_dimensions[i][5]; + Pbuild[i].ne[6] = ijk_dimensions[i][6]; + Pbuild[i].ne[7] = ijk_dimensions[i][7]; + Pbuild[i].ne[8] = ijk_dimensions[i][8]; + + Pbuild[i].ne[9] = ijk_dimensions[i][0]; + Pbuild[i].ne[10] = ijk_dimensions[i][1]; + Pbuild[i].ne[11] = ijk_dimensions[i][2]; + + fprintf(stderr," Part has ranges:\n"); + fprintf(stderr," ijk dimensions of total block: %d %d %d\n", + Pbuild[i].ne[9], + Pbuild[i].ne[10], + Pbuild[i].ne[11]); + fprintf(stderr," i range: %d to %d\n", + Pbuild[i].ne[3], + Pbuild[i].ne[4]); + fprintf(stderr," j range: %d to %d\n", + Pbuild[i].ne[5], + Pbuild[i].ne[6]); + fprintf(stderr," k range: %d to %d\n", + Pbuild[i].ne[7], + Pbuild[i].ne[8]); + fprintf(stderr," ijk dimensions of range portion: %d %d %d\n", + Pbuild[i].ne[0], + Pbuild[i].ne[1], + Pbuild[i].ne[2]); + } + } +#else + fprintf(stderr," ijk_dimensions: %d %d %d\n", + ijk_dimensions[i][0], + ijk_dimensions[i][1], + ijk_dimensions[i][2]); + Pbuild[i].ne[0] = ijk_dimensions[i][0]; + Pbuild[i].ne[1] = ijk_dimensions[i][1]; + Pbuild[i].ne[2] = ijk_dimensions[i][2]; + Pbuild[i].ne[3] = -1; +#endif + if(part_types[i] == Z_IBLANKED) { + fprintf(stderr," Ibanking options on:\n"); + if(iblanking_options[i][Z_EXT]) { + fprintf(stderr," Z_EXT\n"); + } + if(iblanking_options[i][Z_INT]) { + fprintf(stderr," Z_INT\n"); + } + if(iblanking_options[i][Z_BND]) { + fprintf(stderr," Z_BND\n"); + } + if(iblanking_options[i][Z_INTBND]) { + fprintf(stderr," Z_INTBND\n"); + } + if(iblanking_options[i][Z_SYM]) { + fprintf(stderr," Z_SYM\n"); + } + } + } + } + } + + +#if (defined GT_USERD_API_200) + + /* Get ghosts in model flag + *-------------------------*/ + Ghosts_in_model = USERD_get_ghosts_in_model_flag(); + if(Ghosts_in_model) { + fprintf(stderr," Ghosts in Model: TRUE\n"); + } + else { + fprintf(stderr," Ghosts in Model: FALSE\n"); + } + + /* Get ghosts in block flag - if needed + *-------------------------------------*/ + for(i=1; i<=Num_parts; ++i) { + if(part_types[i-1] != Z_UNSTRUCTURED && Ghosts_in_model) { + ghosts_in_block = USERD_get_ghosts_in_block_flag(i); + Pbuild[i-1].ghosts = ghosts_in_block; + if(ghosts_in_block) { + fprintf(stderr," Ghosts in block part %d: TRUE\n",i); + } + else { + fprintf(stderr," Ghosts in block part %d: FALSE\n",i); + } + } + } + +#endif + + +#if (defined GT_USERD_API_100) + + /* Get maxsize info + *-----------------*/ + max_num_nodes = (int *) calloc(Num_parts,sizeof(int)); + if(max_num_nodes == (int *)NULL) { + fprintf(stderr," Problems allocating for part max num of nodes\n"); + return(Z_ERR); + } + + max_num_elems = (int **) calloc(Num_parts,sizeof(int *)); + if(max_num_elems == (int **)NULL) { + fprintf(stderr," Problems allocating for part max num of elements\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," max # %s elems: %d\n", + Elem_info[j].name,max_num_elems[i][j]); + } + } + + if(part_types[i] != Z_UNSTRUCTURED) { + fprintf(stderr," max_ijk_dimensions: %d %d %d\n", + max_ijk_dimensions[i][0], + max_ijk_dimensions[i][1], + max_ijk_dimensions[i][2]); + } + } + } + + /* Get model extents - if given + *-----------------------------*/ + err = USERD_get_model_extents(extents); + if(err == Z_ERR) { + fprintf(stderr," No extents given\n"); + } + else { + fprintf(stderr," Min x: %g\n",extents[0]); + fprintf(stderr," Max x: %g\n",extents[1]); + fprintf(stderr," Min y: %g\n",extents[2]); + fprintf(stderr," Max y: %g\n",extents[3]); + fprintf(stderr," Min z: %g\n",extents[4]); + fprintf(stderr," Max z: %g\n",extents[5]); + } + +#endif + + /* Free the allocated memory + *--------------------------*/ + free(part_ids); + free(part_types); + free(number_of_nodes); + + for(i=0; i 0) { + /* Get the timeset used for the geometry + *--------------------------------------*/ + geom_timeset = USERD_get_geom_timeset_number(); + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(geom_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(geom_timeset,geom_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + geom_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",geom_time_step); + } + + for(p=0; p 0) { + + pdata = (int *)calloc(ne*Elem_info[et].con_len,sizeof(int)); + if(pdata == (int *) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + else { + conns = (int **) calloc(ne,sizeof(int *)); + if(conns == (int **) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + for(i=0; i 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[i]); + } + fprintf(stderr," connectivity:"); + + for(j=nsid_len-conns[i][0]; j Pbuild[p].nn ) { + fprintf(stderr,"\n****************************\n"); + fprintf(stderr,"Connectivity value out of bounds: \n"); + fprintf(stderr,"Either less than zero or greater than \n"); + fprintf(stderr," number of nodes in part!! \n"); + fprintf(stderr,"i = %d j = %d conns[i][j] = %d \n",i,j,conns[i][j]); + fprintf(stderr,"****************************\n"); + } + } + /* ---------- uncomment to print out connectivity values ---------- */ +/* fprintf(stderr,"\n"); */ + } +#endif + /* Last element of the type + *-------------------------*/ + i = ne - 1; + if(i > 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + + coords = (float **) calloc(3,sizeof(float *)); + if(coords == (float **) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + else { + for(i=0; i<3; ++i) { + coords[i] = (float *) calloc((nn+1),sizeof(float)); + if(coords[i] == (float *) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + } + } + + if(Node_labels) { + nodeids = (int *) calloc((nn+1),sizeof(int)); + if(nodeids == (int *) NULL) { + fprintf(stderr,"Error: allocating nodeids array\n"); + return(Z_ERR); + } + } + + + err = USERD_get_part_coords(pn,coords); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting unstructured coords\n"); + return(Z_ERR); + } + + if(Node_labels) { + err = USERD_get_part_node_ids(pn,nodeids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting nodeids\n"); + return(Z_ERR); + } + } + + /* Echo "some" info + *-----------------*/ + + /* First node + *-----------*/ + i = 1; + fprintf(stderr," Node %d of %d:\n",i,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + + + /* Last node + *----------*/ + i = nn; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=2; i<=nn; ++i) { + if(coords[0][i] < mm[0]) { + mm[0] = coords[0][i]; + } + if(coords[0][i] > mm[1]) { + mm[1] = coords[0][i]; + } + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + + + /* Free the allocated memory + *--------------------------*/ + for(i=0; i<3; ++i) { + free(coords[i]); + } + free(coords); + if(Node_labels) { + free(nodeids); + } + } + } + + + /*--------------------- + * For structured parts + *---------------------*/ + else { + + empty_part = FALSE; + if(Pbuild[p].ne[0] == 0 && + Pbuild[p].ne[1] == 0 && + Pbuild[p].ne[2] == 0) { + empty_part = TRUE; + } + + if(!empty_part) { + + /* Get the block coords + *---------------------*/ + for(comp=0; comp<3; ++comp) { + if(Pbuild[p].ne[comp] < 1) { + bdim[comp] = 1; + } + else { + + if(Doing_Structured_Cinching) { + bdim[comp] = Pbuild[p].ne[comp]; + + /* even */ + if((bdim[comp] % 2) == 0) { + bdim[comp] = (bdim[comp]/2) + 1; + } + /* odd */ + else { + bdim[comp] = ((bdim[comp]-1)/2) + 1; + } + } + + else { + bdim[comp] = Pbuild[p].ne[comp]; + } + } + } + + nn = bdim[0] * bdim[1] * bdim[2]; + + bd1 = bdim[0]-1; + if(bd1 < 1) { + bd1 = 1; + } + bd2 = bdim[1]-1; + if(bd2 < 1) { + bd2 = 1; + } + bd3 = bdim[2]-1; + if(bd3 < 1) { + bd3 = 1; + } + ne = bd1 * bd2 * bd3; + + /* Determine cell type + *--------------------*/ + num_dims = 3; + for(i=0; i<3; ++i) { + if(bdim[i] == 1) { + --num_dims; + } + } + if(num_dims == 3) { + cell_type = Z_HEX08; + } + else if(num_dims == 2) { + cell_type = Z_QUA04; + } + else { + cell_type = Z_BAR02; + } + + coords = (float **) calloc(num_dims,sizeof(float *)); + if(coords == (float **) NULL) { + fprintf(stderr,"Error: allocating coords array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + +#if (defined GT_USERD_API_200) + + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } +#endif + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + mm[0] = mm[1] = coords[0][i]; + } + + + /* Last node + *----------*/ + i = nn-1; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + +#if (defined GT_USERD_API_200) + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } +#endif + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + } + } + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=1; i mm[1]) { + mm[1] = coords[0][i]; + } + if(num_dims > 1) { + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + } + if(num_dims > 2) { + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + if(num_dims > 1) { + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + } + if(num_dims > 2) { + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + } + + /* Free the allocated memory - so far + *-----------------------------------*/ + for(i=0; i 0) { + ++num_ghosts; + } + } + + fprintf(stderr," Block Ghost flag breakdown:\n"); + fprintf(stderr," %d ghost cells out of %d total cells\n", + num_ghosts,ne); + + free(ghost_flag); + } + + /* Get the element ids - if any + *-----------------------------*/ + if(Element_labels) { + + elemids = (int *) calloc(ne,sizeof(int)); + if(elemids == (int *) NULL) { + fprintf(stderr,"Error: allocating elemids array\n"); + return(Z_ERR); + } + + + et = cell_type; + err = USERD_get_part_element_ids_by_type(pn,et,elemids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting element ids\n"); + return(Z_ERR); + } + + /* First element of the type + *--------------------------*/ + i = 0; + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + fprintf(stderr," id: %d\n",elemids[i]); + + /* Last element of the type + *-------------------------*/ + i = ne - 1; + if(i > 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + fprintf(stderr," id: %d\n",elemids[i]); + } + + free(elemids); + } +#endif + } + else { + fprintf(stderr," Empty structured part\n"); + } + } + + /* Get border availability + *------------------------*/ + err = USERD_get_border_availability(pn,num_elems); + if(err == Z_OK) { + + /* Get border elements - if any + *-----------------------------*/ + for(et=0; et 0) { + + conns = (int **) calloc(ne,sizeof(int *)); + if(conns == (int **) NULL) { + fprintf(stderr,"Error: allocating border conns array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + fprintf(stderr," %s border element %d of %d:\n", + Elem_info[et].name,i+1,ne); + fprintf(stderr," Parent type: %s\n", + Elem_info[parent_type[i]].name); + fprintf(stderr," Parent num: %d\n",parent_num[i]); + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + fprintf(stderr,"\n"); + } + if(Varinfo[v].classify == Z_PER_NODE) { + fprintf(stderr," Z_PER_NODE Variable %d:\n",vn); + } + else { + fprintf(stderr," Z_PER_ELEM Variable %d:\n",vn); + } + + + if(Num_time_sets > 0) { + /* Get the timeset used for the variable + *---------------------------------------*/ + var_timeset = Varinfo[v].timeset; + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(var_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n", + Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(var_timeset,var_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + var_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",var_time_step); + } + + + /* Constants + *----------*/ + if(Varinfo[v].type == Z_CONSTANT) { + + constant_val = USERD_get_constant_val(vn,FALSE); + fprintf(stderr," Constant (%s):\n",Varinfo[v].description); + fprintf(stderr," value: %g\n",constant_val); + + if(Varinfo[v].complex) { + constant_val = USERD_get_constant_val(vn,TRUE); + fprintf(stderr," value (imag): %g\n",constant_val); + } + } + + /* Scalars, Vectors, Tensors + *--------------------------*/ + else { + + /* Get the var description line + *-----------------------------*/ + err = USERD_get_descrip_lines(Z_VARI,vn,FALSE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + if(Varinfo[v].complex) { + err = USERD_get_descrip_lines(Z_VARI,vn,TRUE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line (imag): %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line (imag)\n"); + return(Z_ERR); + } + } + + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + else if(Varinfo[v].type == Z_TENSOR) { + num_comps = 6; + } + else if(Varinfo[v].type == Z_TENSOR9) { + num_comps = 9; + } + + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + values = (float *) calloc((nsize+1),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + for(comp=0; comp maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d: \n",comp); + fprintf(stderr," node %10d value: %g\n",1,values[1]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + if(Varinfo[v].complex) { + err = USERD_get_var_by_component(vn, + pn, + Varinfo[v].type, + 0, + FALSE, + comp, + values); + if(err == Z_UNDEF) { + fprintf(stderr," Variable not defined on this part\n"); + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv = maxv = values[1]; + for(i=2; i<=nsize; ++i) { + if(values[i] < minv) { + minv = values[i]; + } + if(values[i] > maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d (imag): \n",comp); + fprintf(stderr," node %10d value: %g\n",1,values[1]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + } + } + free(values); + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + fprintf(stderr," For part %d, with %d elems of type %s:\n", + pn,nsize,Elem_info[et].name); + + + values = (float *) calloc((nsize+1),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + for(comp=0; comp maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d: \n",comp); + fprintf(stderr," elem %10d value: %g\n",1,values[1]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + if(Varinfo[v].complex) { + err = USERD_get_var_by_component(vn, + pn, + Varinfo[v].type, + et, + FALSE, + comp, + values); + if(err == Z_UNDEF) { + fprintf(stderr," Variable not defined on this part\n"); + } + + /* For the component, show 1st elem, last elem, min, max values + *-------------------------------------------------------------*/ + minv = maxv = values[1]; + for(i=2; i<=nsize; ++i) { + if(values[i] < minv) { + minv = values[i]; + } + if(values[i] > maxv) { + maxv = values[i]; + } + } + + fprintf(stderr," For component %d (imag): \n",comp); + fprintf(stderr," elem %10d value: %g\n",1,values[1]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize]); + fprintf(stderr," min value: %g\n",minv); + fprintf(stderr," max value: %g\n",maxv); + + } + } + free(values); + } + } + } + } + } + } + + return(Z_OK); +} + +#else + +/*------------- + * part_builder + *-------------*/ +static int +part_builder(int geom_time_step) +{ + int i, j; + int err; + int p, pn; + int et, ne; + int *elemids[Z_MAXTYPE]; + int **conns[Z_MAXTYPE]; + int nn; + int comp; + int bdim[3]; + int ib[5]; + int num_dims; + int cell_type; + float mm[6]; + float **coords; + int *nodeids; + int *iblanking; + CRD *crds; + int bd1,bd2,bd3; + + + fprintf(stderr,"\n------------- part_builder --------------\n"); + + + if(Num_time_steps > 1) { + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------*/ + USERD_set_time_step(geom_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d\n", + geom_time_step,0,Num_time_steps-1); + } + + + /* Get the global coords + *----------------------*/ + nn = USERD_get_number_of_global_nodes(); + + if(nn > 0) { + + crds = (CRD *) calloc(nn,sizeof(CRD)); + if(crds == (CRD *) NULL) { + fprintf(stderr,"Error: allocating crds array\n"); + return(Z_ERR); + } + + if(Node_labels) { + nodeids = (int *) calloc(nn,sizeof(int)); + if(nodeids == (int *) NULL) { + fprintf(stderr,"Error: allocating nodeids array\n"); + return(Z_ERR); + } + } + + + err = USERD_get_global_coords(crds); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting unstructured coords\n"); + return(Z_ERR); + } + + if(Node_labels) { + err = USERD_get_global_node_ids(nodeids); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting nodeids\n"); + return(Z_ERR); + } + } + + /* Echo "some" info + *-----------------*/ + + /* First node + *-----------*/ + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + crds[i].xyz[0], crds[i].xyz[1], crds[i].xyz[2]); + mm[0] = mm[1] = crds[i].xyz[0]; + mm[2] = mm[3] = crds[i].xyz[1]; + mm[4] = mm[5] = crds[i].xyz[2]; + + + /* Last node + *----------*/ + i = nn-1; + if(i > 0) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + if(Node_labels) { + fprintf(stderr," id: %d\n",nodeids[i]); + } + fprintf(stderr," x y z coordinates: %g %g %g\n", + crds[i].xyz[0], crds[i].xyz[1], crds[i].xyz[2]); + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=1; i mm[1]) { + mm[1] = crds[i].xyz[0]; + } + if(crds[i].xyz[1] < mm[2]) { + mm[2] = crds[i].xyz[1]; + } + if(crds[i].xyz[1] > mm[3]) { + mm[3] = crds[i].xyz[1]; + } + if(crds[i].xyz[2] < mm[4]) { + mm[4] = crds[i].xyz[2]; + } + if(crds[i].xyz[2] > mm[5]) { + mm[5] = crds[i].xyz[2]; + } + } + + fprintf(stderr," Global coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + + + /* Free the allocated memory + *--------------------------*/ + free(crds); + if(Node_labels) { + free(nodeids); + } + } + + + + for(p=0; p 0) { + + conns[et] = (int **) calloc(ne,sizeof(int *)); + if(conns[et] == (int **) NULL) { + fprintf(stderr,"Error: allocating conns array\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + + /* First element of the type + *--------------------------*/ + i = 0; + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[et][i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + fprintf(stderr," %s Element %d of %d:\n",Elem_info[et].name,i+1,ne); + if(Element_labels) { + fprintf(stderr," id: %d\n",elemids[et][i]); + } + fprintf(stderr," connectivity:"); + for(j=0; j 0) { + for(i=0; i 0) { + i = 0; + fprintf(stderr," Node %d of %d:\n",i+1,nn); + + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + mm[4] = mm[5] = coords[2][i]; + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + mm[0] = mm[1] = coords[0][i]; + mm[2] = mm[3] = coords[1][i]; + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + mm[0] = mm[1] = coords[0][i]; + } + + + /* Last node + *----------*/ + i = nn-1; + if(i > 1) { + fprintf(stderr," Node %d of %d:\n",i+1,nn); + + if(num_dims == 3) { + fprintf(stderr," x y z coordinates: %g %g %g\n", + coords[0][i], coords[1][i], coords[2][i]); + } + else if(num_dims == 2) { + fprintf(stderr," x y coordinates: %g %g\n", + coords[0][i], coords[1][i]); + } + else { + fprintf(stderr," x coordinates: %g\n", + coords[0][i]); + } + } + } + + /* Min and max coordinate values + *------------------------------*/ + for(i=2; i<=nn; ++i) { + if(coords[0][i] < mm[0]) { + mm[0] = coords[0][i]; + } + if(coords[0][i] > mm[1]) { + mm[1] = coords[0][i]; + } + if(num_dims > 1) { + if(coords[1][i] < mm[2]) { + mm[2] = coords[1][i]; + } + if(coords[1][i] > mm[3]) { + mm[3] = coords[1][i]; + } + } + if(num_dims > 2) { + if(coords[2][i] < mm[4]) { + mm[4] = coords[2][i]; + } + if(coords[2][i] > mm[5]) { + mm[5] = coords[2][i]; + } + } + } + + fprintf(stderr," Coordinate ranges:\n"); + fprintf(stderr," min x: %g\n",mm[0]); + fprintf(stderr," max x: %g\n",mm[1]); + if(num_dims > 1) { + fprintf(stderr," min y: %g\n",mm[2]); + fprintf(stderr," max y: %g\n",mm[3]); + } + if(num_dims > 2) { + fprintf(stderr," min z: %g\n",mm[4]); + fprintf(stderr," max z: %g\n",mm[5]); + } + + /* Free the allocated memory - so far + *-----------------------------------*/ + for(i=0; i 1 && v == 0) { + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_step(var_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d)\n\n", + var_time_step,0,Num_time_steps-1); + } + + for(v=0; v 0) { + fprintf(stderr,"\n"); + } + if(Varinfo[v].classify == Z_PER_NODE) { + fprintf(stderr," Z_PER_NODE Variable %d:\n",vn); + } + else { + fprintf(stderr," Z_PER_ELEM Variable %d:\n",vn); + } + + /* Constants + *----------*/ + if(Varinfo[v].type == Z_CONSTANT) { + + constant_val = USERD_get_constant_value(vn); + fprintf(stderr," Constant (%s):\n",Varinfo[v].description); + fprintf(stderr," value: %g\n",constant_val); + } + + + /* Scalars, Vectors, Tensors + *--------------------------*/ + else { + + /* Get the var description line + *-----------------------------*/ + err = USERD_get_description_lines(Z_VARI,vn,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + else if(Varinfo[v].type == Z_TENSOR) { + num_comps = 6; + } + else if(Varinfo[v].type == Z_TENSOR9) { + num_comps = 9; + } + + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + values = (float *) calloc((num_comps * nsize),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + if(num_comps == 1) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_scalar_values(vn, + pn, + 0, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting scalar values\n"); + return(Z_ERR); + } + } + else { + err = USERD_get_block_scalar_values(pn, + vn, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting block scalar values\n"); + return(Z_ERR); + } + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv[0] = maxv[0] = values[0]; + for(i=0; i maxv[0]) { + maxv[0] = values[i]; + } + } + + fprintf(stderr," node %10d value: %g\n",1,values[0]); + fprintf(stderr," node %10d value: %g\n",nsize,values[nsize-1]); + fprintf(stderr," min value: %g\n",minv[0]); + fprintf(stderr," max value: %g\n",maxv[0]); + + } + + else if(num_comps == 3) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_vector_values(vn, + pn, + 0, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + } + else { + + tvalues = (float *) calloc(nsize,sizeof(float)); + if(tvalues == (float *) NULL) { + fprintf(stderr,"Error: alocating tvalues array\n"); + return(Z_ERR); + } + + for(i=0; i<3; ++i) { + err = USERD_get_block_vector_values_by_component(pn, + vn, + i, + tvalues); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + for(j=0; j maxv[k]) { + maxv[k] = values[j+k]; + } + } + } + + fprintf(stderr," node %10d values: %g %g %g\n",1, + values[0],values[1],values[2]); + fprintf(stderr," node %10d values: %g %g %g\n",nsize, + values[3*nsize-3],values[3*nsize-2],values[3*nsize-1]); + fprintf(stderr," min values: %g %g %g\n", + minv[0],minv[1],minv[2]); + fprintf(stderr," max values: %g %g %g\n", + maxv[0],maxv[1],maxv[2]); + + } + free(values); + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + fprintf(stderr," For part %d, with %d elems of type %s:\n", + pn,nsize,Elem_info[et].name); + + values = (float *) calloc((num_comps * nsize),sizeof(float)); + if(values == (float *) NULL) { + fprintf(stderr,"Error: alocating variable values\n"); + return(Z_ERR); + } + + if(num_comps == 1) { + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_scalar_values(vn, + pn, + et, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting scalar values\n"); + return(Z_ERR); + } + } + else { + err = USERD_get_block_scalar_values(pn, + vn, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting block scalar values\n"); + return(Z_ERR); + } + } + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + minv[0] = maxv[0] = values[0]; + for(i=1; i maxv[0]) { + maxv[0] = values[i]; + } + } + + fprintf(stderr," elem %10d value: %g\n",1,values[0]); + fprintf(stderr," elem %10d value: %g\n",nsize,values[nsize-1]); + fprintf(stderr," min value: %g\n",minv[0]); + fprintf(stderr," max value: %g\n",maxv[0]); + + } + + else if(num_comps == 3) { + + if(Pbuild[p].type == Z_UNSTRUCTURED) { + err = USERD_get_vector_values(vn, + pn, + et, + values); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + } + else { + + tvalues = (float *) calloc(nsize,sizeof(float)); + if(tvalues == (float *) NULL) { + fprintf(stderr,"Error: alocating tvalues array\n"); + return(Z_ERR); + } + + for(i=0; i<3; ++i) { + err = USERD_get_block_vector_values_by_component(pn, + vn, + i, + tvalues); + if(err == Z_ERR) { + fprintf(stderr,"Error: getting vector values\n"); + return(Z_ERR); + } + for(j=0; j maxv[k]) { + maxv[k] = values[j+k]; + } + } + } + + fprintf(stderr," elem %10d values: %g %g %g\n",1, + values[0],values[1],values[2]); + fprintf(stderr," elem %10d values: %g %g %g\n",nsize, + values[3*nsize-3],values[3*nsize-2],values[3*nsize-1]); + fprintf(stderr," min values: %g %g %g\n", + minv[0],minv[1],minv[2]); + fprintf(stderr," max values: %g %g %g\n", + maxv[0],maxv[1],maxv[2]); + + } + free(values); + } + } + } + } + } + } + + return(Z_OK); +} + +#endif + + +#if (defined GT_USERD_API_202) + + +/*--------------- + * materials_info + *---------------*/ +static int +materials_info( void ) +{ + int i,j; + int err; + int *num_materials; + int *msids; + char **msname; + int *mids; + char **mdesc; + + + fprintf(stderr,"\n------------- materials info --------------\n"); + + /* Get the number of variables + *----------------------------*/ + Num_materials_sets = USERD_get_number_of_material_sets(); + if(Num_materials_sets < 0) { + fprintf(stderr,"Error: getting the number of material sets\n"); + return(Z_ERR); + } + else { + if(Num_materials_sets == 0) { + fprintf(stderr," No materials sets in the model\n"); + return (Z_OK); + } + else if(Num_materials_sets > 1) { + fprintf(stderr," Number of materials sets: %d\n",Num_materials_sets); + fprintf(stderr," Currently, EnSight 7.6 only supports 1 material set\n"); + return(Z_ERR); + } + else { + fprintf(stderr," Number of materials sets: %d\n",Num_materials_sets); + } + } + + /* Get the material set index list and names + *------------------------------------------*/ + msids = (int *) calloc(Num_materials_sets,sizeof(int)); + if(msids == (int *)NULL) { + fprintf(stderr," Problems allocating for material set ids\n"); + return(Z_ERR); + } + + num_materials = (int *) calloc(Num_materials_sets,sizeof(int)); + if(num_materials == (int *)NULL) { + fprintf(stderr," Problems allocating for material set num materials\n"); + return(Z_ERR); + } + + msname = (char **) calloc(Num_materials_sets,sizeof(char *)); + if(msname == (char **)NULL) { + fprintf(stderr," Problems allocating for material set names\n"); + return(Z_ERR); + } + else { + for(i=0; i 0) { + /* Get the timeset used for the geometry + *--------------------------------------*/ + geom_timeset = USERD_get_geom_timeset_number(); + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(geom_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Num time steps returned: %d\n",Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(geom_time_step > (Num_time_steps - 1)) { + geom_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -gts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(geom_timeset,geom_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + geom_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",geom_time_step); + } + + for(ms=0; ms 0) { + + /* Get the material ids, if any + *-----------------------------*/ + err = USERD_size_matf_data(ms, + pn, + et, + Z_MAT_INDEX, + &matf_size); + if(err == Z_OK && matf_size > 0) { + + + /* Go get the material ids + *------------------------*/ + ivals = (int *) calloc(matf_size,sizeof(int)); + if(ivals == (int *)NULL) { + fprintf(stderr," Problems allocating for material ids\n"); + return(Z_ERR); + } + err = USERD_load_matf_data(ms, + pn, + et, + Z_MAT_INDEX, + ivals, + fvals); + if(err == Z_OK) { + if(matf_size < 20) { + fprintf(stderr," Printing all mat ids for %s elements\n", + Elem_info[et].name); + do_num = matf_size; + } + else { + fprintf(stderr," Printing first 20 mat ids for %s elements\n", + Elem_info[et].name); + do_num = 20; + } + + /* See if any mixed materials + *---------------------------*/ + mixed_present = FALSE; + for(k=0; k 0 && + matfv_size > 0) { + + /* Go get the material ids + *------------------------*/ + ivals = (int *) calloc(matf_size,sizeof(int)); + if(ivals == (int *)NULL) { + fprintf(stderr," Problems allocating for mixed material ids\n"); + return(Z_ERR); + } + fvals = (float *) calloc(matfv_size,sizeof(float)); + if(fvals == (float *)NULL) { + fprintf(stderr," Problems allocating for mixed material values\n"); + return(Z_ERR); + } + + err1 = USERD_load_matf_data(ms, + pn, + et, + Z_MIX_INDEX, + ivals, + fvals); + + err2 = USERD_load_matf_data(ms, + pn, + et, + Z_MIX_VALUE, + ivals, + fvals); + if(err1 == Z_OK && + err2 == Z_OK) { + if(matf_size < 20) { + fprintf(stderr," Printing all mixed mat ids for %s elements\n", + Elem_info[et].name); + do_num = matf_size; + } + else { + fprintf(stderr," Printing first 20 mixed mat ids for %s elements\n", + Elem_info[et].name); + do_num = 20; + } + for(k=0; k 1) { + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the time step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_step(var_time_step); + + fprintf(stderr," Using time step: %d (where range is %d through %d)\n\n", + var_time_step,0,Num_time_steps-1); + } +#endif + + for(v=0; v 0) { + /* Get the timeset used for the variable + *---------------------------------------*/ + var_timeset = Varinfo[v].timeset; + + /* Get the number of time steps for this timeset + *----------------------------------------------*/ + Num_time_steps = USERD_get_num_of_time_steps(var_timeset); + if(Num_time_steps < 1) { + fprintf(stderr," Error: Number of time steps returned: %d\n", + Num_time_steps); + fprintf(stderr," (Must be >0 to be okay)\n"); + return(Z_ERR); + } + if(var_time_step > (Num_time_steps - 1)) { + var_time_step = Num_time_steps - 1; + } + + /* Set the timeset and step - to first step by default, but + * can set it at others using -vts command argument + *---------------------------------------------------------*/ + USERD_set_time_set_and_step(var_timeset,var_time_step); + + fprintf(stderr," Using timeset: %d (step range is %d through %d)\n", + var_timeset,0,Num_time_steps-1); + fprintf(stderr," Using time step: %d\n",var_time_step); + } +#endif + + + /* Get the var description line + *-----------------------------*/ +#if (defined GT_USERD_API_100) + err = USERD_get_descrip_lines(Z_VARI,vn,FALSE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + + if(Varinfo[v].complex) { + err = USERD_get_descrip_lines(Z_VARI,vn,TRUE,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line (imag): %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line (imag)\n"); + return(Z_ERR); + } + } +#else + + err = USERD_get_description_lines(Z_VARI,vn,line1,line2); + if(err == Z_OK) { + fprintf(stderr," Desc line: %s\n",line1); + } + else { + fprintf(stderr,"Error: getting var description line\n"); + return(Z_ERR); + } + +#endif + + /* Get the values by component + *-----------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + num_comps = 1; + } + else if(Varinfo[v].type == Z_VECTOR) { + num_comps = 3; + } + + /* Per_Node + *---------*/ + if(Varinfo[v].classify == Z_PER_NODE) { + + for(p=0; p 0) { + + fprintf(stderr," For part %d, using node %d:\n",pn,nsize); + +#if (defined GT_USERD_API_100) + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals, + FALSE); +#else + err = USERD_get_variable_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals); +#endif + if(err == Z_NOT_IMPLEMENTED) { + fprintf(stderr," Node and element queries not implemented\n"); + return(Z_OK); + } + else if(err == Z_ERR) { + fprintf(stderr," Could not get value\n"); + } + else { + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + +#if (defined GT_USERD_API_100) + if(Varinfo[v].complex) { + + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + 0, + var_time_step, + qvals, + TRUE); + + if(err == Z_ERR) { + fprintf(stderr," Could not get imag value\n"); + } + else { + + /* For the component, show 1st node, last node, min, max values + *-------------------------------------------------------------*/ + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value (imag) is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values (imag) are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + } + } +#endif + + } + } + } + } + + /* Per_Elem + *---------*/ + else { + for(p=0; p 0) { + + + fprintf(stderr," For part %d, using elem %d of type %s:\n", + pn,nsize,Elem_info[et].name); + + +#if (defined GT_USERD_API_100) + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals, + FALSE); +#else + err = USERD_get_variable_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals); +#endif + + if(err == Z_NOT_IMPLEMENTED) { + fprintf(stderr," Node and element queries not implemented\n"); + return(Z_OK); + } + else if(err == Z_ERR) { + fprintf(stderr," Could not get value\n"); + } + else { + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + +#if (defined GT_USERD_API_100) + if(Varinfo[v].complex) { + + err = USERD_get_var_value_at_specific(vn, + nsize, + pn, + et, + var_time_step, + qvals, + TRUE); + if(err == Z_ERR) { + fprintf(stderr," Could not get imag value\n"); + } + else { + if(Varinfo[v].type == Z_SCALAR) { + fprintf(stderr," Scalar value (imag) is: %g\n",qvals[0]); + } + else { + fprintf(stderr," Vector values (imag) are: %g %g %g\n", + qvals[0],qvals[1],qvals[2]); + } + } + } +#endif + } + } + } + } + } + } + } + + return(Z_OK); +} + + +/*-------------- + * exercise_bkup + *--------------*/ +static int +exercise_bkup( void ) +{ + int err; + FILE *arcfile; + + fprintf(stderr,"\n------------ exercise_archive -----------\n"); + + arcfile = fopen("test.arc","wb"); + if(arcfile == (FILE *)NULL) { + fprintf(stderr,"Error: opening test archive file\n"); + return(Z_ERR); + } + err = USERD_bkup(arcfile,Z_SAVE_ARCHIVE); + if(err == Z_ERR) { + fprintf(stderr,"Error: saving to test archive file\n"); + return(Z_ERR); + } + fclose(arcfile); + + arcfile = fopen("test.arc","rb"); + err = USERD_bkup(arcfile,Z_REST_ARCHIVE); + if(err == Z_ERR) { + fprintf(stderr,"Error: restoring from test archive file\n"); + return(Z_ERR); + } + + fprintf(stderr," Archive test completed\n"); + + fclose(arcfile); + + return(Z_OK); +} + +/* ------------------------------------------------------- + * threshold_operator1 & 2 can be one of the following + * Z_ELE_FAILED_NONE, - disables checking + * Z_ELE_FAILED_GREATER, - greater than + * Z_ELE_FAILED_LESS, - less than + * Z_ELE_FAILED_EQUAL, - equal + * Z_ELE_FAILED_NOT_EQUAL, - not equal + * Z_ELE_FAILED_MANY - not used + * + * logic_criteria2 + * Z_ELE_FAILED_LOGIC_NONE, + * Z_ELE_FAILED_LOGIC_AND, + * Z_ELE_FAILED_LOGIC_OR, + * Z_ELE_FAILED_LOGIC_MANY + * + * ------------------------------------------------------ */ +int load_fail_defaults(void) +{ + int check_for_failed = FALSE; + int cri1 = 0; /* Criteria1 ELE_FAILED_GREATER, etc */ + int cri2 = 0; + int logic_cri2 = 0; /* Logic for criteria 2 ELE_FAILED_LOGIC_NONE, AND, etc */ + float val1 = 0.0; /* failure threshold 1 */ + float val2= 0.0; /* failure threshold 2 */ + char failed_var_name[Z_MXVARIABLEDESC]={EOS}; + + check_for_failed = USERD_get_uns_failed_params( failed_var_name, + &val1, &val2, &cri1, &cri2, + &logic_cri2 ); + fprintf(stderr,"\n------------- failed element info -------------\n"); + if (check_for_failed == TRUE) { + fprintf(stderr," Failed element criteria info \n"); + fprintf(stderr," Variable name = %s\n",failed_var_name); + fprintf(stderr," Criteria 1 = %d\n",cri1); + fprintf(stderr," Criteria 2 = %d\n",cri1); + fprintf(stderr," Logic criteria = %d\n",logic_cri2); + fprintf(stderr," Value 1 = %f\n",val1); + fprintf(stderr," Value 2 = %f\n",val2); + } else { + fprintf(stderr," No Failed elements\n"); + } + return(Z_OK); +} + + +/* End of File */ diff --git a/applications/test/ensightFoamReader/udr_checker.c b/applications/test/ensightFoamReader/udr_checker.c new file mode 120000 index 0000000000..2e9390c310 --- /dev/null +++ b/applications/test/ensightFoamReader/udr_checker.c @@ -0,0 +1 @@ +udr_checker-80.c \ No newline at end of file