/*---------------------------------- * 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 */