/* * Copyright (C) 1998 by Southwest Research Institute (SwRI) * * All rights reserved under U.S. Copyright Law and International Conventions. * * The development of this Software was supported by contracts NAG5-3148, * NAG5-6855, NAS8-36840, NAG5-2323, and NAG5-7043 issued on behalf of * the United States Government by its National Aeronautics and Space * Administration. Southwest Research Institute grants to the Government, * and others acting on its behalf, a paid-up nonexclusive, irrevocable, * worldwide license to reproduce, prepare derivative works, and perform * publicly and display publicly, by or on behalf of the Government. * Other than those rights granted to the United States Government, no part * of this Software may be reproduced in any form or by any means, electronic * or mechanical, including photocopying, without permission in writing from * Southwest Research Institute. All inquiries should be addressed to: * * Director of Contracts * Southwest Research Institute * P. O. Drawer 28510 * San Antonio, Texas 78228-0510 * * * Use of this Software is governed by the terms of the end user license * agreement, if any, which accompanies or is included with the Software * (the "License Agreement"). An end user will be unable to install any * Software that is accompanied by or includes a License Agreement, unless * the end user first agrees to the terms of the License Agreement. Except * as set forth in the applicable License Agreement, any further copying, * reproduction or distribution of this Software is expressly prohibited. * Installation assistance, product support and maintenance, if any, of the * Software is available from SwRI and/or the Third Party Providers, as the * case may be. * * Disclaimer of Warranty * * SOFTWARE IS WARRANTED, IF AT ALL, IN ACCORDANCE WITH THESE TERMS OF THE * LICENSE AGREEMENT. UNLESS OTHERWISE EXPLICITLY STATED, THIS SOFTWARE IS * PROVIDED "AS IS", IS EXPERIMENTAL, AND IS FOR NON-COMMERCIAL USE ONLY, * AND ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR * PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED, EXCEPT TO THE EXTENT THAT * SUCH DISCLAIMERS ARE HELD TO BE LEGALLY INVALID. * * Limitation of Liability * * SwRI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED AS A RESULT OF USING, * MODIFYING, CONTRIBUTING, COPYING, DISTRIBUTING, OR DOWNLOADING THIS * SOFTWARE. IN NO EVENT SHALL SwRI BE LIABLE FOR ANY INDIRECT, PUNITIVE, * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGE (INCLUDING LOSS OF BUSINESS, * REVENUE, PROFITS, USE, DATA OR OTHER ECONOMIC ADVANTAGE) HOWEVER IT ARISES, * WHETHER FOR BREACH OF IN TORT, EVEN IF SwRI HAS BEEN PREVIOUSLY ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. YOU HAVE SOLE RESPONSIBILITY FOR ADEQUATE * PROTECTION AND BACKUP OF DATA AND/OR EQUIPMENT USED IN CONNECTION WITH THE * SOFTWARE AND WILL NOT MAKE A CLAIM AGAINST SwRI FOR LOST DATA, RE-RUN TIME, * INACCURATE OUTPUT, WORK DELAYS OR LOST PROFITS RESULTING FROM THE USE OF * THIS SOFTWARE. YOU AGREE TO HOLD SwRI HARMLESS FROM, AND YOU COVENANT NOT * TO SUE SwRI FOR, ANY CLAIMS BASED ON USING THE SOFTWARE. * * Local Laws: Export Control * * You acknowledge and agree this Software is subject to the U.S. Export * Administration Laws and Regulations. Diversion of such Software contrary * to U.S. law is prohibited. You agree that none of the Software, nor any * direct product therefrom, is being or will be acquired for, shipped, * transferred, or reexported, directly or indirectly, to proscribed or * embargoed countries or their nationals, nor be used for nuclear activities, * chemical biological weapons, or missile projects unless authorized by U.S. * Government. Proscribed countries are set forth in the U.S. Export * Administration Regulations. Countries subject to U.S embargo are: Cuba, * Iran, Iraq, Libya, North Korea, Syria, and the Sudan. This list is subject * to change without further notice from SwRI, and you must comply with the * list as it exists in fact. You certify that you are not on the U.S. * Department of Commerce's Denied Persons List or affiliated lists or on the * U.S. Department of Treasury's Specially Designated Nationals List. You agree * to comply strictly with all U.S. export laws and assume sole responsibilities * for obtaining licenses to export or reexport as may be required. * * General * * These Terms represent the entire understanding relating to the use of the * Software and prevail over any prior or contemporaneous, conflicting or * additional, communications. SwRI can revise these Terms at any time * without notice by updating this posting. * * Trademarks * * The SwRI logo is a trademark of SwRI in the United States and other countries. * */ #ident "@(#) $Id: libtrec_err_msg.c 21490 2011-08-31 19:18:38Z carrie $ SwRI" #include #include #include "ret_codes.h" #include "libbase_idfs.h" /***************************************************************************** * * * LIBTREC_IDFS_ERROR_MESSAGE_STR SUBROUTINE * * * * DESCRIPTION * * This routine is called to compose the error string encountered from * * the libtrec_idfs generic utility software. * * * * INPUT VARIABLES * * SDDAS_SHORT error_code the error code to be processed * * SDDAS_CHAR *e_str ptr to area where string is to be returned * * * * USAGE * * libtrec_idfs_error_message_str (error_code, e_str) * * * * NECESSARY SUBPROGRAMS * * sprintf() creates a string based upon arguments and * * conversion characters * * strcpy() copies a string to another string variable * * * * EXTERNAL VARIABLES * * struct general_info structure holding information concerning * * ginfo the experiment that is being processed * * * * INTERNAL VARIABLES * * struct experiment_info a pointer to the structure that holds * * *ex specific experiment information * * * * SUBSYSTEM * * Display Level * * * *****************************************************************************/ void libtrec_idfs_error_message_str (SDDAS_SHORT error_code, SDDAS_CHAR *e_str) { extern struct general_info ginfo; struct experiment_info *ex; /************************************************************************/ /* Error code generated by libtrec_idfs generic software? */ /************************************************************************/ switch (error_code) { case BUF_BIN_NOT_FOUND: strcpy (e_str, "BUFFER_BIN_FILL: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case BUF_BIN_MALLOC: strcpy (e_str, "BUFFER_BIN_FILL: NO MEMORY FOR BIN_STAT TEMPORARY ARRAY."); break; case CENTER_NOT_FOUND: strcpy (e_str, "CENTER_AND_BAND_VALUES: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case BPTR_NOT_FOUND: strcpy (e_str, "CENTER_AND_BAND_VALUES: THE BIN_INFO STRUCTURE HAS NEVER BEEN ALLOCATED."); break; case CENTER_NO_SENSOR: strcpy (e_str, "CENTER_AND_BAND_VALUES: THE SPECIFIED SENSOR IS NOT FLAGGED AS A SENSOR THAT IS BEING PROCESSED."); break; case BAD_VFMT: strcpy (e_str, "IR_CALC_BAND_WIDTHS: BAD FORMAT CHARACTER FOR VARIABLE WIDTH PROCESSING."); break; case CALC_CENTER_DREC: strcpy (e_str, "IR_CALC_CENTER_SWEEP: READ_DREC ERROR WAS ENCOUNTERED."); break; case CENTER_MALLOC: strcpy (e_str, "IR_ALLOCATE_CENTER: NO MEMORY FOR CENTER SWEEP VALUES."); break; case CENTER_TMP_MALLOC: strcpy (e_str, "IR_ALLOCATE_CENTER: NO MEMORY FOR TEMPORARY SCRATCH SPACE."); break; case BAND_MALLOC: strcpy (e_str, "IR_ALLOCATE_BANDS: NO MEMORY FOR SWEEP BAND VALUES."); break; case FILL_NOT_FOUND: strcpy (e_str, "FILL_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_BASE_TIME_MISSING: strcpy (e_str, "FILL_DATA: THE ROUTINE SET_TIME_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA ROUTINE."); break; case FILL_BIN_MISSING: strcpy (e_str, "FILL_DATA: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA ROUTINE."); break; case FILL_CENTER_BAND_MISSING: strcpy (e_str, "FILL_DATA: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA ROUTINE."); break; case FILL_WITH_SWEEP: strcpy (e_str, "FILL_DATA: SWEEP_DATA AND FILL_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case NO_EMPTY_BUFFERS: strcpy (e_str, "NO SPARE DATA BUFFERS."); break; case FILL_UNITS_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_DATA: NO MEMORY FOR CONVERTED UNITS PER BUFFER."); break; case FILL_UNITS_REALLOC: strcpy (e_str, "IR_ALLOC_FILL_DATA: NO MEMORY FOR EXPANSION OF CONVERTED UNITS PER BUFFER."); break; case FILL_SWP_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_DATA: NO MEMORY FOR CONVERTED SWEEP VALUES."); break; case FILL_SWP_REALLOC: strcpy (e_str, "IR_ALLOC_FILL_DATA: NO MEMORY FOR EXPANSION OF CONVERTED SWEEP VALUES."); break; case FILL_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_DATA: NO MEMORY FOR DATA BUFFERS."); break; case FILL_ARRAY_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_ARRAYS: NO MEMORY FOR FILL_DATA STRUCTURE."); break; case FILL_INFO_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_INFO: NO MEMORY FOR DATA BUFFER INFORMATION."); break; case PHI_DIFF_UNITS: strcpy (e_str, "IR_FILL_PHI_BINS: SENSORS DO NOT PROCESS THE SAME NUMBER OF DATA LEVELS."); break; case FILL_PHI_FIRST: strcpy (e_str, "IR_FILL_PHI_BINS: THE STARTING AZIMUTHAL ANGLE WAS NOT CONTAINED WITHIN ANY OF THE DEFINED PHI BINS."); break; case FILL_PHI_LAST: strcpy (e_str, "IR_FILL_PHI_BINS: THE ENDING AZIMUTHAL ANGLE WAS NOT CONTAINED WITHIN ANY OF THE DEFINED PHI BINS."); break; case CDIMEN_NOT_FOUND: strcpy (e_str, "COLLAPSE_DIMENSIONS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CDIMEN_COLLAPSE: strcpy (e_str, "COLLAPSE_DIMENSIONS : NO MEMORY HAS BEEN ALLOCATED FOR COLLAPSING DATA."); break; case CDIMEN_MANY_SCAN: strcpy (e_str, "COLLAPSE_DIMENSIONS: MORE THAN ONE SCAN RANGE WAS REQUESTED FOR THIS VIRTUAL INSTRUMENT."); break; case CHRG_PA_ERROR: strcpy (e_str, "COLLAPSE_DIMENSIONS : STRAIGHT AVERAGE AZIMUTHAL AVERAGING OPTION FOR THE CHARGE DIMENSION IS NOT A VALID AVERAGING METHOD."); break; case MASS_PA_ERROR: strcpy (e_str, "COLLAPSE_DIMENSIONS : STRAIGHT AVERAGE AZIMUTHAL AVERAGING OPTION FOR THE MASS DIMENSION IS NOT A VALID AVERAGING METHOD."); break; case COMPUTE_MOMENTS: strcpy (e_str, "COLLAPSE_DIMENSIONS: THE MOMENTS_COMPUTATION ROUTINE MUST BE CALLED FOR THE MOMENTS INTEGRATION AVERAGING METHOD."); break; case FILL_DISC_NOT_FOUND: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_DISC_BIN_MISSING: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DISCONTINUOUS_DATA ROUTINE."); break; case FILL_DISC_NO_PHI: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: THE FILL_DISCONTINUOUS_DATA ROUTINE DOES NOT HANDLE DATA WITH DIMENSIONS HIGHER THAN THETA."); break; case FILL_DISC_BASE_TIME_MISSING: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: THE ROUTINE SET_TIME_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DISCONTINUOUS_DATA ROUTINE."); break; case FILL_WITH_SWEEP_DISC: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: SWEEP_DISCONTINUOUS_DATA AND FILL_DISCONTINUOUS_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case FILL_DISC_CENTER_BAND_MISSING: strcpy (e_str, "FILL_DISCONTINUOUS_DATA: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DISCONTINUOUS_DATA ROUTINE."); break; case FILL_DISC_MALLOC: strcpy (e_str, "IR_ALLOC_FILL_DISCONTINUOUS: NO MEMORY FOR FILL_DISCONTINUOUS STRUCTURE."); break; case DISC_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_DISCONTINUOUS_DATA: NO MEMORY FOR DATA BUFFERS."); break; case DISC_TMP_MALLOC: strcpy (e_str, "IR_TRANSFER_DISC_DATA: NO MEMORY FOR TEMPORARY SCRATCH SPACE."); break; case FILL_MODE_ARRAY_MALLOC: strcpy (e_str, "IR_ALLOC_MODE_ARRAYS: NO MEMORY FOR FILL_MODE STRUCTURE."); break; case MODE_UNITS_MALLOC: strcpy (e_str, "IR_ALLOC_MODE_DATA: NO MEMORY FOR CONVERTED UNITS PER BUFFER."); break; case MODE_UNITS_REALLOC: strcpy (e_str, "IR_ALLOC_MODE_DATA: NO MEMORY FOR EXPANSION OF CONVERTED UNITS PER BUFFER."); break; case MODE_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_MODE_DATA: NO MEMORY FOR DATA BUFFERS."); break; case FILL_MODE_NOT_FOUND: strcpy (e_str, "FILL_MODE_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_MODE_FILE_OPEN: strcpy (e_str, "FILL_MODE_DATA: THE USER DID NOT REQUEST MODE DATA PROCESSING WHEN FILE_OPEN WAS CALLED."); break; case FILL_MODE_INFO_DUP: strcpy (e_str, "FILL_MODE_DATA: THE EX_INFO STRUCTURE FOR THE MODE DATA HAS NEVER BEEN ALLOCATED."); break; case MODES_NOT_REQUESTED: strcpy (e_str, "FILL_MODE_DATA: THE USER DID NOT CALL FILL_MODE_INFO FOR ANY MODE VALUES."); break; case FILL_MODE_BASE_TIME_MISSING: strcpy (e_str, "FILL_MODE_DATA: THE ROUTINE SET_TIME_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_MODE_DATA ROUTINE."); break; case FILL_WITH_SWEEP_MODE: strcpy (e_str, "FILL_MODE_DATA: SWEEP_MODE_DATA AND FILL_MODE_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case ALLOC_MODE_INFO_MALLOC: strcpy (e_str, "IR_ALLOC_MODE_INFO: NO MEMORY FOR DATA BUFFER INFORMATION."); break; case SWEEP_UNITS_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_DATA: NO MEMORY FOR CONVERTED UNITS."); break; case SWEEP_UNITS_REALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_DATA: NO MEMORY FOR EXPANSION OF CONVERTED UNITS."); break; case SWEEP_SWP_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_DATA: NO MEMORY FOR CONVERTED SWEEP VALUES."); break; case SWEEP_SWP_REALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_DATA: NO MEMORY FOR EXPANSION OF CONVERTED SWEEP VALUES."); break; case SWEEP_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_DATA: NO MEMORY FOR DATA BUFFER."); break; case SWEEP_INFO_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_INFO: NO MEMORY FOR DATA BUFFER INFORMATION."); break; case FILL_ENV_NOT_FOUND: strcpy (e_str, "FILL_DATA_ENVELOPE: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_ENV_SCALAR: strcpy (e_str, "FILL_DATA_ENVELOPE: THE DATA SOURCE SPECIFIED IS NON-SCALAR."); break; case FILL_ENV_BASE_TIME_MISSING: strcpy (e_str, "FILL_DATA_ENVELOPE: THE ROUTINE SET_TIME_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA_ENVELOPE ROUTINE."); break; case FILL_ENV_BIN_MISSING: strcpy (e_str, "FILL_DATA_ENVELOPE: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA_ENVELOPE ROUTINE."); break; case FILL_ENV_WITH_SWEEP: strcpy (e_str, "FILL_DATA_ENVELOPE: SWEEP_DATA AND FILL_DATA_ENVELOPE CANNOT BE CALLED IN CONJUNCTION."); break; case FILL_ENV_CENTER_BAND_MISSING: strcpy (e_str, "FILL_DATA_ENVELOPE: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE FILL_DATA_ENVELOPE ROUTINE."); break; case NEG_BIN_STAT: strcpy (e_str, "IR_ADD_PHI_MATRICES: THE RESULTANT PHI MATRIX HAS A NEGATIVE BIN STAT VALUE."); break; case FILL_SEN_NOT_FOUND: strcpy (e_str, "FILL_SENSOR_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_SEN_MALLOC: strcpy (e_str, "FILL_SENSOR_INFO: NO MEMORY FOR ARRAY OF FILL_SENSOR STRUCTURES."); break; case FILL_SEN_REALLOC: strcpy (e_str, "FILL_SENSOR_INFO: NO MEMORY FOR EXPANSION OF FILL_SENSOR STRUCTURES."); break; case FILL_SEN_BASE_MALLOC: strcpy (e_str, "FILL_SENSOR_INFO: NO MEMORY FOR ARRAY OF MIN_MAX_TBL_APP STRUCTURES."); break; case FILL_SEN_BASE_REALLOC: strcpy (e_str, "FILL_SENSOR_INFO: NO MEMORY FOR EXPANSION OF MIN_MAX_TBL_APP STRUCTURES."); break; case FILL_SEN_TBL_MALLOC: strcpy (e_str, "FILL_SENSOR_INFO: NO MEMORY FOR TABLE APPLICATION FLAGS."); break; case FILL_SEN_MODE_TYPE: strcpy (e_str, "FILL_SENSOR_INFO: MODE DATA IS NOT SUPPORTED BY THIS FUNCTION."); break; case FILL_THETA_NOT_FOUND: strcpy (e_str, "FILL_THETA_MATRIX: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILL_THETA_COLLAPSE: strcpy (e_str, "FILL_THETA_MATRIX : NO MEMORY HAS BEEN ALLOCATED FOR COLLAPSING DATA."); break; case THETA_DIFF_UNITS: strcpy (e_str, "FILL_THETA_MATRIX : SENSORS DO NOT PROCESS THE SAME NUMBER OF DATA LEVELS."); break; case RET_PHI_NOT_FOUND: strcpy (e_str, "RETURN_PHI_PTRS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CPTR_RET_PHI: strcpy (e_str, "RETURN_PHI_PTRS : NO MEMORY HAS BEEN ALLOCATED FOR COLLAPSING DATA."); break; case NO_RET_PHI: strcpy (e_str, "RETURN_PHI_PTRS : NO MEMORY HAS BEEN ALLOCATED FOR PHI PROCESSING."); break; case MODE_INFO_NOT_FOUND: strcpy (e_str, "FILL_MODE_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case MODE_INFO_MALLOC: strcpy (e_str, "FILL_MODE_INFO: NO MEMORY FOR ARRAY OF FILL_SENSOR STRUCTURES."); break; case MODE_INFO_REALLOC: strcpy (e_str, "FILL_MODE_INFO: NO MEMORY FOR EXPANSION OF FILL_SENSOR STRUCTURES."); break; case MODE_INFO_BASE_MALLOC: strcpy (e_str, "FILL_MODE_INFO: NO MEMORY FOR ARRAY OF MIN_MAX_TBL_APP STRUCTURES."); break; case MODE_INFO_BASE_REALLOC: strcpy (e_str, "FILL_MODE_INFO: NO MEMORY FOR EXPANSION OF MIN_MAX_TBL_APP STRUCTURES."); break; case MODE_INFO_TBL_MALLOC: strcpy (e_str, "FILL_MODE_INFO: NO MEMORY FOR TABLE APPLICATION FLAGS."); break; case MODE_INFO_NO_MODES: strcpy (e_str, "FILL_MODE_INFO: THERE ARE NO MODE VALUES DEFINED FOR THE DATA SET IN QUESTION."); break; case MODE_FILE_OPEN: strcpy (e_str, "FILL_MODE_INFO: THE USER DID NOT REQUEST MODE DATA PROCESSING WHEN FILE_OPEN WAS CALLED."); break; case MODE_INFO_DUP: strcpy (e_str, "FILL_MODE_INFO: THE EX_INFO STRUCTURE FOR THE MODE DATA HAS NEVER BEEN ALLOCATED."); break; case MODE_UNITS_IND_NOT_FOUND: strcpy (e_str, "MODE_UNITS_INDEX: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case MODE_UNITS_FILE_OPEN: strcpy (e_str, "MODE_UNITS_INDEX: THE USER DID NOT REQUEST MODE DATA PROCESSING WHEN FILE_OPEN WAS CALLED."); break; case MODE_UNITS_INFO_DUP: strcpy (e_str, "MODE_UNITS_INDEX: THE EX_INFO STRUCTURE FOR THE MODE DATA HAS NEVER BEEN ALLOCATED."); break; case MODE_UNITS_NO_MODE: strcpy (e_str, "MODE_UNITS_INDEX: REQUESTED MODE NOT FOUND AMONGST FILL INFORMATION."); break; case MODE_UNITS_NO_MATCH: strcpy (e_str, "MODE_UNITS_INDEX: REQUESTED DATA LEVEL NOT FOUND."); break; case RET_CENTER_NOT_FOUND: strcpy (e_str, "RETURN_CENTER_AND_BAND_PTRS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case RET_CBPTR_NO_SENSOR: strcpy (e_str, "RETURN_CENTER_AND_BAND_PTRS: THE SPECIFIED SENSOR IS NOT FLAGGED AS A SENSOR THAT IS BEING PROCESSED."); break; case RET_CBPTR_NOT_FOUND: strcpy (e_str, "RETURN_CENTER_AND_BAND_PTRS: THE BIN_INFO STRUCTURE HAS NEVER BEEN ALLOCATED."); break; case NPHI_NOT_FOUND: strcpy (e_str, "NUMBER_OF_PHI_BINS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case NPHI_NO_BINS: strcpy (e_str, "NUMBER_OF_PHI_BINS: NO MEMORY HAS BEEN ALLOCATED FOR THE PHI BINS."); break; case NBINS_NOT_FOUND: strcpy (e_str, "NUMBER_OF_DATA_BINS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case NBINS_NO_BINS: strcpy (e_str, "NUMBER_OF_DATA_BINS: THE BIN_INFO STRUCTURE HAS NEVER BEEN ALLOCATED."); break; case SET_VWIDTH_CENTER_MALLOC: strcpy (e_str, "IR_SET_VWIDTH_INFO: NO MEMORY FOR VARIABLE WIDTH CENTER TBLS/OPERS."); break; case SET_VWIDTH_BAND_MALLOC: strcpy (e_str, "IR_SET_VWIDTH_INFO: NO MEMORY FOR VARIABLE WIDTH BAND TBLS/OPERS."); break; case SET_VWIDTH_UPPER_BAND_MALLOC: strcpy (e_str, "IR_SET_VWIDTH_INFO: NO MEMORY FOR VARIABLE WIDTH UPPER BAND TBLS/OPERS."); break; case COLLAPSE_NOT_FOUND: strcpy (e_str, "SET_COLLAPSE_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case COLLAPSE_MALLOC: strcpy (e_str, "SET_COLLAPSE_INFO: NO MEMORY FOR COLLAPSE_DATA STRUCTURE."); break; case COLLAPSE_SEN_MALLOC: strcpy (e_str, "SET_COLLAPSE_INFO: NO MEMORY FOR SENSOR SPECIFIC ARRAYS."); break; case COLLAPSE_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_COLLAPSE_DATA: NO MEMORY FOR COLLAPSING DATA ARRAYS."); break; case COLLAPSE_DATA_ADDRESS: strcpy (e_str, "IR_ALLOC_COLLAPSE_DATA: NO MEMORY FOR ADDRESS POINTERS TO COLLAPSING DATA ARRAYS."); break; case THETA_CHK_MALLOC: strcpy (e_str, "IR_CALC_THETA_BINS: NO MEMORY FOR TEMPORARY ARRAY."); break; case THETA_BIN_MALLOC: strcpy (e_str, "IR_CALC_THETA_BINS: NO MEMORY FOR THETA ANGLE VALUES."); break; case ORDER_THETA_MALLOC: strcpy (e_str, "IR_ORDER_THETA_BINS: NO MEMORY FOR THETA ORDER INDEXES."); break; case SET_BIN_NOT_FOUND: strcpy (e_str, "SET_BIN_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SET_BIN_MALLOC: strcpy (e_str, "SET_BIN_INFO: NO MEMORY FOR BIN_INFO STRUCTURE."); break; case SET_BIN_INDEX_MALLOC: strcpy (e_str, "SET_BIN_INFO: NO MEMORY FOR INDEX VALUES FOR THE SENSORS."); break; case SET_BIN_BAD_FMT: strcpy (e_str, "SET_BIN_INFO: ZERO OR VARIABLE WIDTH SPACING CAN ONLY BE REQUESTED IN CONJUNCTION WITH FIXED SWEEP PROCESSING."); break; case SET_SCAN_NOT_FOUND: strcpy (e_str, "SET_SCAN_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SCAN_BIN_MISSING: strcpy (e_str, "SET_SCAN_INFO: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THIS ROUTINE."); break; case SET_SCAN_TBL_MALLOC: strcpy (e_str, "SET_SCAN_INFO: NO MEMORY FOR SWEEP STEP TABLE APPLICATION FLAGS."); break; case SCAN_INDEX_MALLOC: strcpy (e_str, "SET_SCAN_INFO: NO MEMORY FOR INDEX VALUES FOR THE SENSORS."); break; case SCAN_IDF_MANY_BYTES: strcpy (e_str, "SET_SCAN_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case SCAN_IDF_ELE_NOT_FOUND: strcpy (e_str, "SET_SCAN_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case SCAN_IDF_TBL_NUM: strcpy (e_str, "SET_SCAN_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case SCAN_IDF_CON_NUM: strcpy (e_str, "SET_SCAN_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case SCAN_IDF_NO_ENTRY: strcpy (e_str, "SET_SCAN_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case SWEEP_NOT_FOUND: strcpy (e_str, "SWEEP_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SWEEP_BIN_MISSING: strcpy (e_str, "SWEEP_DATA: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE SWEEP_DATA ROUTINE."); break; case SWEEP_WITH_FILL: strcpy (e_str, "SWEEP_DATA: SWEEP_DATA AND FILL_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case SWEEP_CENTER_BAND_MISSING: strcpy (e_str, "SWEEP_DATA: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE SWEEP_DATA ROUTINE."); break; case SWEEP_DISC_NOT_FOUND: strcpy (e_str, "SWEEP_DISCONTINUOUS_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SWEEP_DISC_BIN_MISSING: strcpy (e_str, "SWEEP_DISCONTINUOUS_DATA: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE SWEEP_DISCONTINUOUS_DATA ROUTINE."); break; case SWEEP_DISC_NO_PHI: strcpy (e_str, "SWEEP_DISCONTINUOUS_DATA: THE SWEEP_DISCONTINUOUS_DATA ROUTINE DOES NOT HANDLE DATA WITH DIMENSIONS HIGHER THAN THETA."); break; case SWEEP_DISC_WITH_FILL: strcpy (e_str, "SWEEP_DISCONTINUOUS_DATA: SWEEP_DISCONTINUOUS_DATA AND FILL_DISCONTINUOUS_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case SWEEP_DISC_CENTER_BAND_MISSING: strcpy (e_str, "SWEEP_DISCONTINUOUS_DATA: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE SWEEP_DISCONTINUOUS_DATA ROUTINE."); break; case SPIN_INFO_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_INFO: NO MEMORY FOR DATA BUFFER INFORMATION."); break; case SPIN_UNITS_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_DATA: NO MEMORY FOR CONVERTED UNITS."); break; case SPIN_UNITS_REALLOC: strcpy (e_str, "IR_ALLOC_SPIN_DATA: NO MEMORY FOR EXPANSION OF CONVERTED UNITS."); break; case SPIN_SWP_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_DATA: NO MEMORY FOR CONVERTED SWEEP VALUES."); break; case SPIN_SWP_REALLOC: strcpy (e_str, "IR_ALLOC_SPIN_DATA: NO MEMORY FOR EXPANSION OF CONVERTED SWEEP VALUES."); break; case SPIN_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_DATA: NO MEMORY FOR DATA BUFFERS."); break; case SPIN_DATA_PIX_NOT_FOUND: strcpy (e_str, "SPIN_DATA_PIXEL: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SPIN_DATA_PIX_WITH_FILL_SWEEP: strcpy (e_str, "SPIN_DATA_PIXEL: SPIN_DATA_PIXEL CANNOT BE CALLED IN CONJUNCTION WITH FILL_DATA OR SWEEP_DATA."); break; case SPIN_DATA_PIX_BIN_MISSING: strcpy (e_str, "SPIN_DATA_PIXEL: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE SPIN_DATA_PIXEL ROUTINE."); break; case SPIN_DATA_PIX_CENTER_BAND_MISSING: strcpy (e_str, "SPIN_DATA_PIXEL: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE SPIN_DATA_PIXEL ROUTINE."); break; case SPIN_DATA_PIX_NO_SPIN: ex = ginfo.expt; sprintf (e_str, "SPIN_DATA_PIXEL: %s DOES NOT SPIN BASED UPON DATA RECORD INFO.", ex->data_name); break; case SPIN_DATA_NOT_FOUND: strcpy (e_str, "SPIN_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SPIN_DATA_BIN_MISSING: strcpy (e_str, "SPIN_DATA: THE ROUTINE SET_BIN_INFO HAS NOT BEEN CALLED PRIOR TO CALLING THE SPIN_DATA ROUTINE."); break; case SPIN_DATA_WITH_FILL_SWEEP: strcpy (e_str, "SPIN_DATA: SPIN_DATA CANNOT BE CALLED IN CONJUNCTION WITH FILL_DATA OR SWEEP_DATA."); break; case SPIN_DATA_CENTER_BAND_MISSING: strcpy (e_str, "SPIN_DATA: THE ROUTINE CENTER_AND_BAND_VALUES HAS NOT BEEN CALLED PRIOR TO CALLING THE SPIN_DATA ROUTINE."); break; case SPIN_DATA_NO_SPIN: ex = ginfo.expt; sprintf (e_str, "SPIN_DATA: %s DOES NOT SPIN BASED UPON DATA RECORD INFO.", ex->data_name); break; case SWP_TIMES_TMP_MALLOC: strcpy (e_str, "IR_COMPUTE_SWEEP_TIMES: NO MEMORY TO HOLD SWEEP TIME COMPONENTS."); break; case UNITS_IND_NOT_FOUND: strcpy (e_str, "UNITS_INDEX: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case UNITS_NO_SENSOR: strcpy (e_str, "UNITS_INDEX: REQUESTED SENSOR NOT FOUND AMONGST FILL INFORMATION."); break; case UNITS_NO_MATCH: strcpy (e_str, "UNITS_INDEX: REQUESTED DATA LEVEL NOT FOUND."); break; case UNITS_IND_MODE_TYPE: strcpy (e_str, "UNITS_INDEX: MODE DATA IS NOT SUPPORTED BY THIS FUNCTION."); break; case SMODE_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_MODE_DATA: NO MEMORY FOR DATA BUFFERS."); break; case SMODE_UNITS_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_MODE_DATA: NO MEMORY FOR CONVERTED UNITS PER BUFFER."); break; case SMODE_UNITS_REALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_MODE_DATA: NO MEMORY FOR EXPANSION OF CONVERTED UNITS PER BUFFER."); break; case ALLOC_SMODE_INFO_MALLOC: strcpy (e_str, "IR_ALLOC_SWEEP_MODE_INFO: NO MEMORY FOR DATA BUFFER INFORMATION."); break; case SWEEP_MODES_NOT_REQUESTED: strcpy (e_str, "SWEEP_MODE_DATA: THE USER DID NOT CALL FILL_MODE_INFO FOR ANY MODE VALUES."); break; case SWEEP_MODE_NOT_FOUND: strcpy (e_str, "SWEEP_MODE_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SWEEP_MODE_FILE_OPEN: strcpy (e_str, "SWEEP_MODE_DATA: THE USER DID NOT REQUEST MODE DATA PROCESSING WHEN FILE_OPEN WAS CALLED."); break; case SWEEP_MODE_INFO_DUP: strcpy (e_str, "SWEEP_MODE_DATA: THE EX_INFO STRUCTURE FOR THE MODE DATA HAS NEVER BEEN ALLOCATED."); break; case SWEEP_MODE_WITH_FILL: strcpy (e_str, "SWEEP_MODE_DATA: SWEEP_MODE_DATA AND FILL_MODE_DATA CANNOT BE CALLED IN CONJUNCTION."); break; case GET_FPTR_NOT_FOUND: strcpy (e_str, "GET_FILL_DATA_POINTER: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case TRANS_3D_BINNED_MALLOC: strcpy (e_str, "IR_TRANSFER_TO_3D_BINNED: NO MEMORY FOR NORMALIZATION FACTORS"); break; /* case TIME_OFF_DIFFER: strcpy (e_str, "FILL_DATA: ALL SENSORS MUST HAVE THE SAME TIME OFFSET VALUES IN THE VIDF."); break; */ } }