/**C*
 *
 * Vaisala software source code file
 *
 * Copyright (c) Vaisala Oyj 1991, 1993, 1995, 1996, 1997, 1998, 1999, 2000,
 * 2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013.
 * All rights reserved.
 *
 **C*/

/** @file
 *
 * Structures to Hold User-Adjustable Set-Up Information
 *
 * $URL: https://subversion.vaisala.com/svn/repos/sigmet/wr_iris_rda/tags/release8.13.6/base/include/setup.h $
 *
 * $Id: setup.h 30291 2014-10-27 09:07:18Z rke $
 *
 */

#ifndef SIGMET_SETUP_H
#define SIGMET_SETUP_H 1

#ifdef __cplusplus
extern "C" {
#endif

#if 0
} /* Fix auto-indenter bug */
#endif

/* Structures defining information about devices.  The device type and unit
 * number are defined for all devices; optional unioned data is available
 * for those devices that need it.
 */

#define WINDOW_MAX_WIDTH  (1500)
#define WINDOW_MAX_HEIGHT (1100)

#define WINDOW_MIN_WIDTH  (240)
#define WINDOW_MIN_HEIGHT (240)

#define ARCHIVE_TAPE (1)
#define ARCHIVE_MO   (2)
#define ARCHIVE_LDA  (3)
#define ARCHIVE_DVD  (4)
/* Types of file systems to create on the modisk */
#define ARCHIVE_MO_HPHFS  (0)
#define ARCHIVE_MO_HPVXFS (1)

struct tape_device               /* Definitions for Tape device */
{
    char  sdevice[24];             /* Device file */
} ;
struct mo_device                 /* Definitions for MO device */
{
    char  sMountPoint[24];         /* Mount point */
    char  sdevice[24];             /* Device file */
    char  sdevice_raw[24];         /* Raw device file */
    uint8_t iFsType;               /* File system type for HP platforms */
    char  pad73x3[3] ;
} ;
struct lda_device                /* Definitions for LDA device */
{
    char  sDirectory[DIRECTORY_SIZE]; /* Directory to use */
    char  pad_end[3];
} ;

struct dvd_device                /* Definitions for DVD device */
{
    char  sMountPoint[24];         /* Mount point */
    char  sdevice[24];             /* Device file */
    uint32_t iBufSize;             /* iBufSize in MB before writing to DVD */
} ;

union archive_specific_info {    /* union, size 92 bytes each */
    struct tape_device Tape;
    struct mo_device   Mo;
    struct lda_device  Lda;
    struct dvd_device  Dvd;
} ;

/* archive_device structure is 96 bytes long */
struct archive_device            /* Definitions for ARCHIVE device */
{
    uint8_t isub_type ;            /* Type of archive */
    char  pad1x3[3] ;
    union archive_specific_info asi;
} ;

struct printer_device {          /* Definitions for PRINTER device */
    int16_t iwidth ;               /* Width of image */
    int16_t iheight ;              /* Height of image */
    uint8_t iPaperSize;            /* Size of paper, choices in printer_lib.h */
    char  pad5x3[3];
    char  squeue[24];
} ;

#define MAX_LOOP_COUNT  (300)
#define MAX_VISUAL_DEPTH (24)
struct window_device {           /* Definitions for WINDOW device */
    int16_t iwidth ;               /* Initial size of window */
    int16_t iheight ;
    int16_t ixpos;                 /* Initial position of window */
    int16_t iypos;
    int16_t imoviecnt ;            /* Allocation for movie frames */
#define WINDOW_TOOLS_OFF (0)
#define WINDOW_TOOLS_ON  (1)
    uint8_t iToolState ;
    char  pad11x1 ;
    char  sdisplay[24] ;
} ;

#define SIG_HOSTNAME_SIZE  (48)
struct network_device          /* Definitions for NETWORK device */
{ 
    int16_t iwidth ;      
    int16_t iheight ;              /* Default size of TIFF image */
#define NET_FILE_IRIS       (1)
#define NET_FILE_NORDRAD    (2)
#define NET_FILE_TIFF       (3)
#define NET_FILE_NONE       (5)         /*File is not copied */
#define NET_FILE_HEADER     (6)         /*Just IRIS header is copied */
#define NET_FILE_GIF        (7)            
#define NET_FILE_BMP        (8)            
#define NET_FILE_PS         (9)
#define NET_FILE_JPEG       (10)
#define NET_FILE_PNG        (11)
#define NET_FILE_PIPE       (12)
#define NET_FILE_TIFF_FLOAT (13)
#define NET_FILE_MAXIMUM    (13)   /*Maximum value for network file formats*/
    uint8_t ifile_format;          /* Format of file data */

#define NET_NAME_NATIVE   (1)        /* Native naming conventions */
#define NET_NAME_8P3      (2)        /* <12 char node.NNN format */
#define NET_NAME_DEFAULT  (3)        /* nodeYYMMDDHHMMSS.PPPNNNN format */
#define NET_NAME_METPS    (4)        /* Hong Kong METPS 8 char XXYMDHMS format*/
#define NET_NAME_ORIGINAL (5)        /* Original filename */
#define NET_NAME_IIA      (6)        /* Korea IIA propriatory format */
#define NET_NAME_COUNT    (6)        /* Number of different file name formats */
    uint8_t iname_format;          /* Format of file name */
#define NET_COMPRESS_NONE     (0)
#define NET_COMPRESS_COMPRESS (1)
#define NET_COMPRESS_GZIP     (2)
#define NET_COMPRESS_TIFFPACK (3)    /* TIFF PACKBITS compression */
#define NET_COMPRESS_MAXVALUE (3)    /* Maximum value allowed here */
    uint8_t iCompress;             /* Compression format */

/*#define NET_NOTIFY_DECNET  (1)*/   /*Use DECNET handshaking */
#define NET_NOTIFY_NONE    (2)       /*Use no handshaking */
#define NET_NOTIFY_NORDRAD (3)       /*File goes to NORDRAD using StoreProduct*/
#define NET_NOTIFY_TCPIP   (4)       /*Use TCP/IP socket, AF_INET */
#define NET_NOTIFY_RENAME  (5)       /*Use file renaming so receiver gets a full file */
#define NET_NOTIFY_UNIX    (6)       /*Use TCP/IP socket, AF_UNIX */
    uint8_t inotify_scheme;        /* Notification scheme */
    uint32_t itcpip_port;          /* Port number if TCP/IP notification */
    char  snode_name[SIG_HOSTNAME_SIZE]; /* Remote host name. */
#define NET_COPY_NONE    (0)         /*Do not copy file*/
#define NET_COPY_COPY    (1)         /*Use software copying*/
#define NET_COPY_RCP     (2)         /*Use rcp shell command*/
#define NET_COPY_SCRIPT  (3)         /*Use script program*/
#define NET_COPY_SCP     (4)         /*Use scp shell command  */
    uint8_t icopy_scheme;
    char  sdirectory[DIRECTORY_SIZE]; /* Directory to copy to */
    /* Same options as input command line syntax */
    uint8_t iCommandLineSyntax;    /* Type of pipe command line arguments */
    char  pad_143;
    char  sPipeName[16];           /* Name of convert pipe to envoke */
    char  sScriptName[16];         /* Name of copy script to envoke */
    char  sUserName[16];           /* User name on remote system */
    char  sPassword[16];           /* Password on remote system */
} ;

union device_specific_info {     /* Overall union, size 96 bytes each */
    struct  window_device window ;
    struct network_device network;
    struct archive_device archive;
    struct printer_device printer;
} ;

struct device_def
{
    uint8_t idev_type;
#define IDEVTYPE_MINVALUE  (2)
#define IDEVTYPE_PRINTER   (2)
#define IDEVTYPE_WINDOW    (3)
#define IDEVTYPE_UNUSED    (4)
#define IDEVTYPE_ARCHIVE   (6)
#define IDEVTYPE_NETWORK   (7)
#define IDEVTYPE_MAXVALUE  (7)

    char ipad1x1;
/*  int8_t iunit_num; */
#define MAX_ARCHIVE_LIMIT (24)       /* Upper bound */
    uint16_t iskip_time;           /* In seconds */
    char  salias[16];

    union device_specific_info dsi ;
};


/* ======================================================================
 *                          ANT Server Setup Structure
 * ======================================================================
 * This structure is provided to hold information about a particular signal
 * processor.   This is the structure that is passed to the Client 
 *
 */
struct serv_ant_manual_setup
{
    uint32_t bElevationFull;   /*Antenna can scan continuously in elevation.*/
    int32_t ielmin;            /* Signed number to make setup_limits work */
    BIN4  ielmax;              /* Unsigned number to make setup_limits work*/
};

struct misc_setup
{
    char sVersion[8] ;             /* IRIS version when saved */

    /* A certain fraction of the total available space for INGEST
     * and PRODUCT files can be used for "kept" files, i.e., files
     * that will not be deleted.  The percentage of total used for
     * kept is given in the following variables.  Note: additional
     * variables for RAW partition below.
     */
    int32_t ikbytes_ingest;        /* Max total # bytes for INGEST files */
    int16_t ikept_ingest_percent;

    int16_t ikept_product_percent;
    int32_t ifkbytes_product;      /* Max # kilobytes for PRODUCT files */

    int32_t itrunc;                /* Truncation height (cm above radar) */

    int16_t ingest_data_mode;      /* INGEST's supply of data */
#define DMODE_DSP    (0)             /* Use the DSP's */
#define DMODE_FAKE   (1)             /* Generate fake data */

    /* IEXT_HEADER tells which version number of extended header is to
     * be recorded.  Valid version numbers are 0,1,...  A negative value
     * means that no extended headers are to be recorded.
     */
    int16_t iext_header;

    /* Amount by which RHI's are to speed up at high angles.
     */
    float relspeedup;

    /* Default Z/R relationship numbers
     */
    double fzr_const;
    double fzr_exp;

    /* Maximum number of bytes that will be held in the mapio
     * read-only-file cache for the product generator. 
     */
    uint32_t iprod_cache_size ;

    /* Make a status product each time a task starts
     */
    uint8_t lStatusEachTask ;

    /* Record using GMT, otherwise use the local time on the computer */
    uint8_t lRecordGmt;

    /* Between continuous scan PPI's, allow the antenna to free-run
     * if the next scan will begin within this many seconds.
     */
    int16_t iant_coast_secs;

    /* The maximum time difference for APO of warning type in seconds.
     */
    int32_t iMaxWarnDiff;

    /* The maximum time difference for APO of track type in seconds.
     */
    int32_t iMaxTrackDiff;

    /* The maximum time difference for APO of all products not 
     * explicitly defined in other variables.
     */
    int32_t iMaxDefaultDiff;

    /* The timeout time in seconds before we abort a network transfer.
     */
    int32_t iNetworkSendTimeout;

    /* Maximum number of times to queue up a single product
     */
    uint16_t imax_send_queue;

    /* In automatic mode, switch the transmitter on this many
     * seconds before the task is scheduled to run.
     */
    int16_t irad_warm_time;

    /* Speak when text product arrives over the network */
    uint8_t lsay_text_product;
    uint8_t lsay_mode_change;      /* Speak when a mode change happens */
    uint8_t lsay_fatal_errors;     /* Speak when a fatal error happens */
    uint8_t lsay_bite_faults;      /* Speak when a BITE fault is reported */

    /* When INGEST is positioning the antenna, the servo is deemed
     * successful only if the velocity is less than the following
     * values in degrees/second.
     */
    float faz_ok_vel, fel_ok_vel;

    /* Likewise, if successful positioning is not achieved in a
     * time commensurate with a minimum level of performance (i.e.,
     * average velocity), then INGEST will not wait forever.  These
     * minimum performance velocities are in degrees per second.
     */
    float faz_morbid_speed, fel_morbid_speed;

    /* Time in seconds to wait between status products.
     */
    uint32_t istatus_product_gen;

    /* Time in seconds after a status product arrives before the site is
     * considered broken.
     */
    uint32_t istatus_product_timeout;

    /* Additional file information for separate RAW product directory
     */
    uint32_t ifkbytes_product_raw; /* Max # kilobytes for RAW products */
    uint16_t ikept_product_raw_percent ;

    /* Ingest angles are offset from zero by half a cpi */
    uint8_t lIngestAnglesEdged;

    /* Optimize tasks for continuous output */
    uint8_t lIngestContinuousOutput;

    /* Change pulse width in anticipation of an INGEST task that
     * will run in the future.
     */
    uint8_t lpw_advance_change ;

    /* Time is sourced by the RVP8, else IRIS */
    uint8_t lIngestTimeSourceRvp8;

    /* Allow INGEST noise samples. */
    uint8_t lnoise_enabled ;

    /* Force ingest to take noise samples each time the pulse width
     * changes */
    uint8_t lnoise_at_pw_change;

    /* INGEST can optionally move the antenna before taking noise
     * samples.  The following deg*10 values are the desired noise
     * position.  -1 indicates a "dont care" on that axis.
     */
    int16_t inoise_az, inoise_el;
    /* Take noise sample at start of vol scan if last one is older than
     * this many seconds.
     */
    int16_t inoise_time;

    /* Number of times to retry when there is an error in the noise sample.
     */
    int16_t iNoiseRetrys;

    /* Time to wait in ms after a bad noise sample before retrying.
     */
    int16_t iNoiseRetryWait;

    /* Switch off xmit if there is more than this many seconds free.
     */
    int16_t irad_off_time;

    /* Minimum gradient in 1/100 of a dB/km above the melting layer.
     * Positive means getting weaker as it goes up.
     */
    int16_t iMinVerticalGradient;
    /* Gradient below the melting layer */
    int16_t iLowVerticalGradient;
    /* Thickness of melting layer in km */
    float fMeltingThickness;
    /* Intensity of melting layer in dB */
    float fMeltingIntensity;
    /* Wind speed in m/s */
    float fWindSpeed;
    /* Wind direction in degrees */
    float fWindDirection;

    /* How to signal the centroids, only AVERAGE and MAXIMUM choices are
     * valid, See product.h for values.
     */
    uint16_t icentroid_label;

    /* Minimum time (hundredths of seconds) to wait between sweeps
     */
    uint16_t iaz_sweep_wait ;
    uint16_t iel_sweep_wait ;

    /* Maximum number of status products we are willing to have
     */
    uint16_t istatus_product_quota ;

    /* Tolerable (binary) angle error before going ahead with a scan
     */
    int16_t iaz_ok_err;
    int16_t iel_ok_err;

    /* Set to non-zero if we wish continuous scans to go counter clockwise.
     */
    uint8_t lcon_clockwise;

    /* Type of angle synching used by IRIS.  Set to one of the ANGSYN_???
     * values defined in dsp_lib.
     */
    int8_t isyn_mode;

    /* When DSP is used, angle information will be obtained in one
     * of the following ways:
     */
#define ANG_SRC_TAG_BIN16   (1)      /* 16-bit binary angles on TAG lines */
#define ANG_SRC_RCP         (3)      /* Angles from antenna controller */
    int8_t iIngestAngleSource;

    uint8_t lWindSpeedValid;       /* Wind speed is valid */

    /* Set to non-zero if we wish to allow ingest to set the time
     * automatically.
     */
    uint8_t lauto_time_set;
    /* Apply Zc Beam blockage correction in reingest */
    uint8_t lBeamBlockReingest;

    /* Priorities for IRIS.  These are broken out with greater detail
     * (May 94) to allow better tuning on different platforms.
     */
#define MIN_PRIORITY (-20)
#define MAX_PRIORITY  (20) 

    int16_t ipri_ingest, ipri_ingfio ;
    int16_t ipri_product  ;
    int16_t ipri_reingest ;
    int16_t ipri_network  ;
    int16_t ipri_output   ;
    int16_t ipri_archive  ;
    int16_t ipri_server   ;
    int16_t ipri_watchdog ;
    char  ipad176x2[2];

    /* Allow RCP mode control
     */
    uint16_t lrcp_mode_control;

    /* Relative priorities of products -- these are used by the product
     * generator to help decide the order of running products.  Check
     * that the array is dimensioned properly.  It must be a multiple
     * of 4 and not less than the number of products.
     */
#define NUM_DEFINED_PRIORITIES 40
#if defined(NUM_DEFINED_PRODUCTS) && (NUM_DEFINED_PRIORITIES < NUM_DEFINED_PRODUCTS)
#error Please manually maintain the dimension of iprod_priorities[]
#endif
    uint8_t iprod_priorities[ NUM_DEFINED_PRIORITIES ] ;

    /* The following flag is set TRUE if the WATCHDOG process
     * should automatically restart processes that terminate due to
     * a fatal internal error.
     */
    uint16_t lrestart_fatal ;

    /* TRUE iff the product generator should make products from
     * incomplete INGEST volume scans (i.e., those that were halted
     * before completing fully).
     */
    uint16_t luse_partial_ingest ;

    /* TRUE iff "R2" algorithms are to be used to estimate SNR and
     * spectral width when INGEST configures the DSP.
     */
    uint16_t lr2_processing ;

    /* When a product that contains a warning is received by the
     * network, a signal and beep will be produced if the data time
     * is within the following number of seconds of the current
     * time.  Zero means do not signal incoming warnings.
     */
    int16_t ircv_beep_time ;

    uint8_t bEnableWebDisplayOptions;
    char ipad229x3[3];

    /* Allow alternate polarization features in product generation
     */
    uint8_t lprod_alt_pol ;

    /* Whether INGEST runs in Active or Passive mode.
     */
    uint8_t iIngestActPsv ;        /* Ingest Active/Passive mode */
#define INGESTACTPSV_ACTIVE  0       /*   Active only */
#define INGESTACTPSV_PASSIVE 1       /*   Passive only */
#define INGESTACTPSV_BOTH    2       /*   Both are allowed */

    int16_t ipri_input;            /* Priority used for input processes */

    /* Maximum number of product files allowed on a single archive
     */
    uint32_t imax_archive_products ;

    /* Maximum number of product files allowed in the disk inventory
     */
    uint32_t imax_disk_products;

#define PRODUCT_FILES_CUSHION (0x00000080)
#define PRODUCT_FILES_MAX     (0x00030d40)
#define PRODUCT_FILES_SEARCH  (0x00020000) /* Larger than 1/2 of sum above */

    /* Maximum number of product configuration names in the disk inventory
     */
    uint32_t imax_disk_product_cfg_names;
  
#define PRODUCT_CFG_MAX     (0x00002710) /* 10000 decimal */
#define PRODUCT_CFG_SEARCH  (0x00002000) /* Larger than 1/2 of above */

    /* Extra space allowed in product inventory for slow deleting.
     */
    /* INGEST Clutter map control variables
     */
    /* Data dBZ must exceed clutter ray by this much */
    float fcmap_dbzover ;
    BIN2  icmap_eltol ;            /* EL angle tolerance in matching rays */
    uint8_t lcmap_usevel ;         /* Use velocity criteria in masking */
    uint8_t lclutter_map_reingest; /*Apply clutter map in ReIngest*/
    char ipad256x3[3];

    /* Control for attenuation correction */
    /* Enable Zc Z-based attenuation correction in ReINGEST */
    uint8_t lAttnReingest;
    float fAttnConstant;
    float fAttnExponent;
    float fAttnMaxZ;
    float fAttnMaxCorrection;

    /* INGEST data simulator control variables.
     */
    /* Strength of clutter in simulation (0=none) */
    float fIngSimClutterStrength;
    int16_t ingsim_lat ;      /* Lat/Lon of simulation point.  Note int16_t */
    int16_t ingsim_lon ;      /*  rather than BIN2 for signed setup_limits(). */

    int16_t ingsim_timeoffset ;    /* Virtual simulation time offset (seconds) */

    uint8_t ingsim_flags ;         /* Simulation control flags */
#define INGSIM_RADAR       0         /* Simulation is at the radar (else above Lat/Lon) */
#define INGSIM_SHEARLINE   1         /* Simulate shearline */
#define INGSIM_FALLSPEED   2         /* Simulate particle fallspeeds */
#define INGSIM_WINDFIELD   3         /* Simulate overall wind field */
#define INGSIM_RANDOMIZED  4         /* Probabilistic (non-deterministic) features */

    int8_t ingsim_u0 ;             /* Horizontal winds at origin, 5 * m/sec */
    int8_t ingsim_v0 ;

    uint8_t ingsim_wamp ;          /* VertVel sine amplitude, 100 * m/sec */
    uint8_t ingsim_whgt ;          /* VertVel period height, 10 * km */

    uint8_t ingsim_def ;           /* Deformation, 10 * m/sec/100km */

    uint16_t iNetworkWait;         /* Wait time for products to arrive */

    /* Allow Socket mode control
     */
    uint16_t lsocket_mode_control;

    /* VVP unfolding corrections for INGEST and ReINGEST
     */
    float fvvpunf_maxsep_km ;      /* Maximum VVP site separation (km) */
    uint16_t ivvpunf_maxage_sec ;  /* Maximum age of "UNFOLD" VVP (seconds) */
    uint8_t lvvpunf_reingest ;     /* Enable velocity unfolding in ReINGEST */
    uint8_t lMeltHeightValid;      /* Melting levels are valid */

    /* Fallspeed corrections for INGEST and ReINGEST
     */
    float ffallspd_vtz_coef[2];    /* Vt-Z coefficients below/above melting layer */
    float ffallspd_vtz_exp[2];     /* Vt-Z exponents below/above melting layer */
    int8_t ifallspd_melts[12];     /* Melting heights for each month in km*10 (above MSL) */
    uint8_t lfallspd_reingest;     /* Enable fall speed correction in ReINGEST */

    /* Use gradient to correct data in CAPPI and XSECT.
     */
    uint8_t lApplyGradient;

    /* When INGEST powers up, it can optionally reset the antenna and
     * signal processor.
     */
    uint8_t lIngestResetsDsp ;
    uint8_t lIngestResetsRcp ;

    /* The maximum time difference for APO of fcast type in seconds.
     */
    int32_t iMaxFcastDiff;

    /* Reference height for making products (meters above MSL).
     */
    int16_t iReferenceHeight;

    uint16_t iRainGageWait;        /* Wait time for RainGage data to arrive */

    /* Configuration for window alerts
     */
    uint8_t iWindowAlertStyle;
#define WINDOW_ALERT_DISABLED   (0)
#define WINDOW_ALERT_X_AND_TEXT (1)
#define WINDOW_ALERT_X_ONLY     (2)
#define WINDOW_ALERT_TEXT_ONLY  (3)
    uint8_t lWindowAlertOnFault;
    uint8_t iWindowFaultScheme;
#define WINDOW_FAULT_ONE (0)
#define WINDOW_FAULT_ALL (1)
    uint8_t lWindowAlertOnStale;

    /* Time delay in seconds until the image is flagged as stale
     */
    uint16_t iWindowStaleTime;

    char ipad350x2[2];

    /* Further information that is used for INGEST Active/Passive modes,
     * sometimes as clues for what to do.
     */
    char  sPassiveSiteCode[4];     /* Site code supplying status product */
    uint8_t iPassiveType;          /* Type of passive mode to run */
#define PASSIVE_TYPE_MULTIPLE   (0)  /* Select from multiple continuous scans */
#define PASSIVE_TYPE_SINGLE     (1)  /* Single task scheduled at a time */
#define PASSIVE_TYPE_STATUS     (2)  /* Slaved to a status product */
#define PASSIVE_TYPE_TSPLAYBACK (3)  /* Time Series playback */
    uint8_t lPassiveTrigRate ;     /* Use external trigger rate */
    uint8_t lTargetDetReingest;    /* Enable target detection correction in ReINGEST */
    uint8_t lStatusModeChange;     /* Change modes based on a status product */
    char  sStatusSiteCode[4];      /* Site code for status product to switch on */

    uint8_t lLabelBottomSline;     /* Label the SLINE display at bottom */
    uint8_t lLabelBottomTdwr;      /* Label the TDWR display at bottom */
    uint8_t lLabelBottomTrack;     /* Label the TRACK display at bottom */
    uint8_t lLabelBottomWarn;      /* Label the WARN display at bottom */
    uint8_t bLabelBottomCatch;     /* Label the CATCH display at bottom */
    char  ipad369x3[3];

    float fAzVelocityTolerance;    /* Azimuth velocity tolerance */
    float fElVelocityTolerance;    /* Elevation velocity tolerance */

    /* Time before signalling product overload (seconds) */
    uint16_t iProductBusyTime;
    /* Enable hydrometeor classification in ReINGEST */
    uint8_t lHydroClassReingest;

    /* Enable Zc (and ZDRc) DP-based attenuation correction in ReINGEST */
    uint8_t lZcDpAttnReingest;

    float   fVcStorm_maxsep_km;    /* Maximum FCAST site separation (km) */
    uint16_t iVcStorm_maxage_sec;  /* Maximum age of FCAST (seconds) */
    /* Enable Vc Storm Relative Velocity in ReIngest */
    uint8_t  lVcStormRelativeReingest;
    char     ipad_end[1];
} ;

struct rtdisp_channel_setup
{
    char sXmtName[20];             /* Name of the transmitter program */
    char sBroadcastAddress[20];    /* RTD Broadcast address in string form */
    uint32_t iPortNum;             /* Port number for RTD broadcast */

    uint8_t iXmtDataSet;           /* Type of data to be sent */
#define RTD_XMT_DATA_ZVW       (0)
#define RTD_XMT_DATA_SINGLEPOL (1)
#define RTD_XMT_DATA_DUALPOL   (2)
#define RTD_XMT_DATA_MAX_VALUE (2)
    char  ipad25x3[3];
};

#define RTD_CHANNEL_COUNT (16)

struct rtdisp_setup
{
    char sVersion[8];              /* IRIS version when saved */

    /* Indicates who should be sourcing the display.  Previously
     * was a logical flag
     * */
    /* No display generated */
#define RTD_ENABLE_OFF  (0)
    /* Display sourced an application program like IRIS/Ingest */
#define RTD_ENABLE_APP  (1)
    /* Display sourced directly by the signal processor */
#define RTD_ENABLE_RVP  (2)
    uint8_t lEnabled;             
    char ipad9x3[3];

    /* The maximum number of range bins that will be sent over the network.
     * Network constraints may lower the actual transmission.
     */
    int16_t irtd_max_bins;
    int16_t iPriority;             /* RTD transmitter priority */

    uint32_t iChannelCount;        /* Number of channels to include */

    struct rtdisp_channel_setup Channel[RTD_CHANNEL_COUNT];
};

/* --------------------------------------------------
 * The following protected region structures appear in some of the IRIS
 * data file formats, and therefore must not be changed.
 */

/* Structure defining a protected region for the warning product.
 * Each region is a rectangle having adjustable size, location,
 * and orientation.
 */
#define ONE_PROT_REGION_SIZE (32)
struct one_protected_region     /* !!! DO NOT CHANGE SIZE !!! */
{
    int32_t ixcenter;              /* Center of region (cm from radar) */
    int32_t iycenter;
    int32_t ixsize;                /* Size of region, before rotation */
    int32_t iysize;
    /* Orientation binary angle (-45 to +45 degrees) */
    uint16_t iangle;
    char  ipad18x2[2];
    /* Space padded name of region, first char space means unused */
    char  sname[12];
};

#define IMAX_PROT_REGIONS (32)
#define PROTECT_SETUP_SIZE (1024)
struct protect_setup             /* !!! DO NOT CHANGE SIZE !!! */
{
    struct one_protected_region protected_regions[IMAX_PROT_REGIONS];
};

/* --------------------------------------------------
 * Define the list of corridors.
 */
struct one_corridor
{
    char sCorridor[16];
};
struct corridor_list
{
    int32_t iCount;
    struct one_corridor List[IMAX_PROT_REGIONS];
};

#define STRUCT_DEVICE_SETUP_DEFINED 1
//idevcount    In Setup Menu. Output->Number of output devices
//imaxdevcount In Setup Menu. General->Maximum number of output devices
struct device_setup
{
    char sVersion[8] ;             /* IRIS version when saved */
    int32_t idevcount;             /* Current number of devices defined */
    int32_t imaxdevcount;          /* Max number of devices defined */
    struct device_def def[MAX_OUT_DEVICES];
};


struct one_input_setup           /* Definitions for input device */
{ 
    char  sName[16];               /* Name of input device */
    char  sDirectory[48];          /* Directory to search */
    char  sPipeName[16];           /* Name of pipe to envoke */
#define COMMAND_LINE_PIPE  (0)
#define COMMAND_LINE_PATHS (1)
    uint8_t iCommandLineSyntax;    /* Type of command line arguments */
    /* Choices are:
     * NET_NOTIFY_NONE for polling,
     * NET_NOTIFY_TCPIP for tcpip socket */
    uint8_t iNotifyScheme;         /* Notification scheme */
    uint16_t iSocketPort;          /* Port number if tcpip socket notification*/
} ;

struct input_setup
{
    char sVersion[8] ;             /* IRIS version when saved */
    uint32_t iInputCount;
    struct one_input_setup Def[MAX_INPUT_DEVICES];
};

/*
 * ======================================================================
 *                           SITES Information
 * ======================================================================
 * This structure is provided to hold information about the site.
 */
//#define MAX_SITES (31)
#define MAX_SITES (128)
struct site_list
{
    char site_name16[20];          /* IRIS sitename, null terminated */
    char site_name3[4];            /* IRIS site code, null terminated */
    uint8_t lChecked;
    char pad_25x3[3];
};

struct site_setup
{
    char sVersion[8] ;             /* IRIS version when saved */

    /* Flag indicating whether the operating system can perform mapped I/O
     */
    uint8_t lmmap_okay ;
    char  pad1x3[3] ;

    /* Site number for link indentifier
     */
    int32_t isite_number;

    /* The maximum number of IRIS clients allowed
     */
#define MAX_IRIS_CLIENTS    (30)
    int32_t imax_clients;

    struct site_list sites[MAX_SITES];
} ;

/* Site dependent setup information, for example the license number
 */
struct license_setup
{
    char sVersion[8] ;             /* IRIS version when saved */

    /* License structures for enabling/forbiding various features
     */
#define MAX_LICENSE_COUNT (6)
    char sLicenses[MAX_LICENSE_COUNT][60];

    char sSitename[16];            /* Name of current site, space padded */
    char sSiteCode[8];             /* Short code for the current site, null terminated */
    char sPassword[16];            /* Password for window operator privilege */
    char sHardwareName[16];        /* Name of hardware site, space padded */
    /* What style of IRIS we will have.
     */
    uint16_t iris_style;
#define STYLE_RADAR      (0)       /* full function IRIS */
#define STYLE_ANALYSIS   (2) 

    char pad_end[2] ;
};


/* Accumulate lots of setup information here, don't worry about which
 * files they are stored in.
 */
#define STRUCT_IRIS_SETUP_DEFINED 1
struct iris_setup
{
    struct misc_setup    misc;
    struct protect_setup protect;
    struct device_setup  device;
    struct site_setup    Site;
    struct input_setup   Input;
};

/* ======================================================================
 * Color Definition Structures
 */

#define SPECIAL_MAP_MAX (17)     /* Maximum number of special colors in map */
struct special_colors            /* Color values for all the special colors */
{
    struct color_def background;
    struct color_def legend;
    struct color_def overlay1;
    struct color_def drop_shadow;

    struct color_def overlay2;
    struct color_def overlay3;
    struct color_def overlay_txt_back;
    struct color_def underlay1;
    struct color_def underlay2;
    struct color_def underlay3;
    struct color_def centroid;
    struct color_def blink;
    struct color_def track;
    struct color_def track_highlight;
    struct color_def Shearline;
    struct color_def WindBarbs;
    struct color_def RangeRings;
};

struct color_def_pair
{
    struct color_def upper;
    struct color_def lower;
    uint16_t  ipair_flags;
    /* The color pair is either a solid color, or a continous gradient */
    /* Color pair is gradient, continuously between */
#define COLOR_PAIR_GRADIENT     (0x0001)
    /* The color pair is either divided or connected to the color above */
#define COLOR_PAIR_CONNECTED    (0x0002)
    uint16_t  ipad_end;
};

#define COLOR_SET_COLOR_COUNT (16)
struct colorset_setup
{
    char sname[20];
    /* RGB values for each */
    struct color_def_pair colors[COLOR_SET_COLOR_COUNT];
};

#define COLOR_SET_NAME_COUNT (8)
#define COLOR_SET_COUNT COLOR_SET_NAME_COUNT /* Old name for this */
#define COLOR_MAP_COLOR_COUNT (32)   /* Maximum number of colors in map */
#define COLOR_MAP_MAX COLOR_MAP_COLOR_COUNT  /* Old name for this */
#define COLOR_MAP_ZOOM (2)
#define COLOR_MAP_BASE (COLOR_SPECIAL_COUNT)
#define COLOR_CELL_COUNT (COLOR_MAP_BASE+(COLOR_MAP_ZOOM*COLOR_MAP_COLOR_COUNT))
struct colormap_setup {
    struct special_colors special; /* Special colors for display */
    struct colorset_setup set[COLOR_SET_NAME_COUNT]; /* Color number tables */
};

struct setup_scale_def           /* Color scale definition structure */
{
    char sname[20];
    uint16_t ilevel_seams[16];
    uint32_t iflags;
#define SCALE_DEFAULT          (0x0000)
#define SCALE_TOP_SATURATE     (0x0001)
#define SCALE_BOTTOM_SATURATE  (0x0002)
#define SCALE_RAINRATE_IN_HOUR (0x1000)
#define SCALE_RAIN_INCHES      (0x1000)
#define SCALE_HEIGHT_KFT       (0x2000)  /* Only partly implemented */
    uint8_t iset_number;           /*Which color set to use, origin 1*/
  
    uint8_t inum_levels;           /*Number of levels to use*/
    char  pad58x2[2];
};

#define COLOR_SCALE_COUNT (32)
struct one_dtype_scales
{
    struct setup_scale_def scales[COLOR_SCALE_COUNT];
};

struct class_label_table
{
    int32_t iValue;
    char  sLabel[8];
};

#define COLOR_HCLASS_LABEL_SIZE (30)
struct class_label_setup
{
    int32_t iLabelCount;           /* Number of remapped names */
    struct class_label_table Table[COLOR_HCLASS_LABEL_SIZE];
};

/* ===================
 * This is what is contained in the color setup file.
 */
struct color_setup
{
    char sVersion[8] ;             /* IRIS version when saved */
    struct colormap_setup colormap;
    struct one_dtype_scales dtype[SETUP_DTYPE_COUNT];
    struct class_label_setup ClassLabels;
};

/* ======================================================================
 *                          DSP Setup Structure
 * ======================================================================
 * This structure is provided to hold information about a particular signal
 * processor. 
 */
struct customTrig {              /* Custom trigger period sequence */
    int32_t iNumPeriods ;          /* Number of periods defined */
    int32_t iPeriods[MAXTRIGPERIODS];/* Trigger periods in nanoseconds */
} ;

struct dsp_losses_setup
{
    /* Transmitt loss from transmitter to antenna (1/10 of dB)
     */
    int16_t iXmtLossSingle;        /* XMT single channel */
    int16_t iXmtLossHAndV;         /* XMT simultanious */

    /* Receiver losses from antenna to receiver (1/10 of dB)
     */
    int16_t iRcvLoss;

    /* Losses between the test signal input point and the receiver (1/10
     * of dB)
     */
    int16_t iTestLoss;
};

struct dsp_manual_setup
{
    char sVersion[8] ;             /* IRIS version when saved */

    uint8_t ldsp_available ;       /* Flag indicates that system has a DSP */
    uint8_t itype ;                /* Type of DSP */

    uint8_t lCheckByteOrder ;      /* Check byte order on powerup */

    uint8_t interface;             /* Interface type */
    char  sdevice[40] ;            /* SOCKET: IP address */
    uint32_t iPortNumber;          /* Port number if socket interface */

    int16_t isync_fuzz;            /* Static sync mode fuzz angle */

    /* The number of pulswidths available on the radar
     */
    int16_t iwidcnt;

    /* The 4 pulswidths available in 1/100 of a microsecond.  Note that
     * if less than 4 are available, the remaining will be filled in
     * with one of the other pulsewidths.
     */
    int16_t ipwidths[4];

    /* This is an array containing the 4 bits to be output for each of
     * the four pulse widths available.
     */
    uint16_t ipwbits[4];

    /* The wavelength of the radar in 1/100 of a centimeter
     */
    int32_t iwavelength;
    /* Note that all PRFs below are in hertz.  This is the prf to use
     * during the calibration of the radar
     */
    int32_t idspprf;

    int32_t iminprf[4];            /* The minimum PRF available */
    int32_t imaxprf[4];            /* MAX PRFs for each of the pulsewidths */

    int32_t inoiseprf;             /* PRF at which to take the noise sample */

    /* Time in milliseconds to wait after turning off radiate before 
     * changing the pulse width.  If set to zero, then the feature is
     * disabled.  The radiate is turned back on as soon as the ipw_wait
     * time after pulse width change has elapsed.
     */
    int32_t iPwRadiateOffWait;

    /* Time in milliseconds to wait after changing the pulse width before
     * raising PRF
     */
    int32_t ipw_wait;

    /* Horizontal full beamwidth in 1/100 of a degrees
     */
    int16_t ihorizwidth;

    /* Vertical full beamwidth in 1/100 of a degree
     */
    int16_t ivertwidth;

    int32_t iantgain;              /* The antenna gain in 1/10 of dB */
    float fNoiseSourceENR;         /* The noise source ENR value */
    struct dsp_losses_setup Horiz;
    struct dsp_losses_setup Vert;

    int16_t idspagcode;            /* The desired AGC decay code */

    int16_t idspdualdelay;         /* The dual PRF stabilization delay */

    int16_t ildr_bias;             /* LDR bias in dB*100 */  
    int16_t izdr_bias;             /* ZDR bias in dB*16  */

    /* Type of transmitter and phase control
     */
    uint8_t iXmtTubeType;          /* Type of transmitter tube */
#define XMT_MAGNETRON (1)            /*   Magnetron */
#define XMT_KLYSTRON  (2)            /*   Klystron  */
#define XMT_TWT       (3)            /*   Travelling Wave Tube */

    uint8_t lXmtPhaseControl;      /* System has XMT phase control hardware */

    uint8_t lPolarAvailable;       /* Radar supports dual polarization */
    uint8_t iSinglePolarization;   /* Which polarization on signal pol radars */

    /* Time in milliseconds to wait after turning off radiate before 
     * changing the polarization.  If set to zero, then the feature is
     * disabled.  The radiate is turned back on as soon as the antenna 
     * notifies us that the new polarization is working, or the iMaxPolarWait
     * time has elapsed.
     */
    int32_t iPolarRadiateOffWait;
    /* Maximum polarization wait time after setting */
    int32_t iMaxPolarWait;

    /* Transmitter or receiver id, space terminated */
    char strid[40];

    uint8_t lDualReceiver;         /* System has dual receivers */

    uint8_t lPhidpAvailable ;      /* PHIDP is available from the DSP */
    uint8_t lRhohvAvailable ;      /* RHOHV is available from the DSP */
    uint8_t lHClassAvailable ;     /* HCLASS is available from the DSP */
    uint8_t lSqiAvailable ;        /* SQI is available from the DSP */
    uint8_t lSnrAvailable;         /* SNR is available from the DSP */
    
    uint8_t lLdrAvailable ;        /* LDR is available from the DSP */
    uint8_t lPhiAvailable ;        /* PHI is available from the DSP */
    uint8_t lRhoAvailable ;        /* RHO is available from the DSP */

    uint8_t lXmtHorizontalOnly;    /* Radar is capable of horizontal only transmitting */
    uint8_t lXmtVerticalOnly;      /* Radar is capable of vertical only transmitting */
    uint8_t lXmtAlternating;       /* Radar is capable of alternating transmitting */
    uint8_t lXmtSimultaneous;      /* Radar is capable of simultaneous transmitting */
    uint8_t iCalSignalType;        /* Type of calibration signal */
#define CAL_SIGNAL_NARROW (0)        /* Narrow band signal generator */
#define CAL_SIGNAL_BROAD  (1)        /* Broadband noise source */

    int32_t itpower[4] ;           /* Transmitted power in watts for each pulse width */

    int32_t iRangeMaskSpacing[4];  /* Range mask bin spacing in cm */

    uint8_t iwindow ;              /* Window to use for computing spectra */

    /* Flag indicating that the sign of velocities from the DSP should
     * be inverted.
     */
    uint8_t linvert_velocities;

    /* Flag indicating that the DSP uses digital gain control
     */
    uint8_t ldigital_gain ;

    /* Choice of 8-bit only (1), or both 8- and 16-bit (2) data from DSP
     */
    uint8_t iDataWidths ;
#define DSP_DATA_8ONLY  (1)
#define DSP_DATA_8AND16 (2)

    int32_t iaqclock ;             /* Acquisition clock frequency in Hz */

    /* Gas attenuation as 100000 * db/km
     */
    uint32_t iGasAtten ;

    /* Custom trigger periods
     */
    struct customTrig customTrig[CUSTOMTRIGS] ;

#define NUMPMODENAMES 4            /* Names of PMODE_USERn major modes */
    char sUserPModeNames[NUMPMODENAMES][16] ;

    /* Simulation parameters
     */
    uint32_t lSimClutterWidNorm;   /*Simulated clutter width is normalized, */
    float fSimClutterWidth ;       /*   else expressed in meters/sec */
} ;

/* --------------------------------------------------
 * Keep this here because it is used in ascope recording format.
 * Do not change.
 */
#define DSP_MANUAL_SIZE722 (400)
struct dsp_manual_setup722
{
    uint8_t ldsp_available ;
    uint8_t itype ;
    int16_t iwidcnt;
    int16_t ipwidths[4];
    uint16_t ipwbits[4];
    int32_t iwavelength;
    int16_t isync_fuzz;
    uint8_t interface;
    uint8_t lCheckByteOrder ;
    int32_t idspprf;
    int32_t iminprf[4];
    int32_t imaxprf[4];
    int32_t inoiseprf;
    int32_t ipw_wait;
    int16_t ihorizwidth;
    int16_t ivertwidth;
    int16_t iantgain;
    int16_t itrloss;
    int16_t irecloss;
    int16_t itestloss;
    char  ipad_84x2[2] ;
    int16_t idspagcode;
    int16_t idspdualdelay;
    int16_t iang_form;
    uint8_t lPolarAvailable;
    uint8_t lPolSimultaneous;
    char strid[40];
    int16_t izdr_bias;
    int32_t itpower[4] ;
    int32_t imask_res ;
    uint8_t iwindow ;
    uint8_t linvert_velocities;
    uint8_t ldigital_gain ;
    uint8_t idata_widths ;
    int32_t iaqclock ;
    char sdevice[40] ;
    uint8_t lPhidpAvailable ;
    uint8_t lRhohvAvailable ;
    uint8_t lSqiAvailable ;
    char ipad207x1;
    char sVersion[8];
    uint32_t iGasAtten ;
    char ipad220x180[180] ;
};

/* ======================================================================
 *                          DSP Server Setup Structure
 * ======================================================================
 * This structure is provided to hold information about a particular signal
 * processor.   This is the structure that is passed to the Client 
 *
 */
struct serv_dsp_manual_setup
{
    int32_t iwavelength;
    int32_t iwidcnt;
    int32_t ipwidths[4];
    int32_t ipwbits[4];
    /*  int32_t isync_fuzz; */
    int32_t idspprf;
    int32_t iminprf[4];
    int32_t imaxprf[4];
    int32_t inoiseprf;
    /*  int32_t idspagcode; */
    /*  int32_t idspdualdelay; */
    /*  int32_t iang_form; */
    int32_t lPolarAvailable;
    /* Radar is capable of vertical only transmitting */
    uint32_t lXmtVerticalOnly;
    /* Radar is capable of alternating transmitting */
    uint32_t lXmtAlternating;
    /* Radar is capable of simultaneous transmitting */
    uint32_t lXmtSimultaneous;
    char sUserPModeNames[NUMPMODENAMES][16] ;
    uint32_t iCustomTrigMask ;
    uint32_t linvert_velocities;
    int32_t itpower[4] ;
    uint32_t ldigital_gain ;
};

/* --------------------------------------------------------------------
 * This structure hold the numbers defining the reflectivity calibration
 * for one pulse width, one polarization.
 */
struct dsp_cal_pw
{
    /* The slope of the fit in dB/Machine number */
    float fRvp6Slope;
    /* The slope of the fit in dB/dB */
    float fRvp7Slope;

    /* The calibration offset in dBZ at 1 kilometer for each of the
     * pulse widths.
     */
    float fZCal;

    float fstd_dev;                /* Standard deviation of the fit */
    float fRvp6LogDc;
    /* Noise level, dBm for RVP7, A/D counts for RVP6 */
    float fNoiseLevel;
    float fRvp6LinRms;
    float fi0;                     /* I0 value from calibration */
    struct ymds_time time;         /* Local time calibration was done */
    uint32_t iflag;
#define ZCAL_OK   (0)
#define ZCAL_ZERO (1)
#define RANGE_CAL_OK (2)             /* Flag for dynamic range cal? */

    struct ymds_time SiggenTime;   /* Local time siggen calibration was done */
    char     sSiggenId[40];        /* siggen ID used in this calibration */

    float fMaximumLevelIf;         /* Saturation level, dBm */
    float fTransmitPowerW;         /* Transmit peak power used, in watts */
    /* The burst pulse power will be zero on a system which cannot
     * measure it*/
    float fBurstPulsePowerdBm;     /* Burst pulse peak power at cal time in dBm */
    float fBandWidthMHz;           /* Digital matched band width in MHz */
    float fRadarConstantdB;        /* Radar constant in dB */
//XZC    float fXmtLossSingle;          /* Loss in single channel transmit, used in fRadarConstant */
//XZC    float fXmtLossHAndV;           /* Loss in transmitting into H and V, needed for ZCal(H+V)  */

    /* The following fields are only applicable for dynamic range mode.  The
     * dynamic range is determined by finding the lowest and highest signal
     * generator setting which are considered usable.  This is defined as
     * follows:  The low limit is a signal which produces power 1 dB above
     * noise.  The high limit is a signal which produces power which has
     * rolled off from the ideal linear curve by 1 dB.  The IF limits are
     * simply  the measured signals which correspond to these.  This can
     * be used to plot the end points.
     */
    float fDynamicLimitsSiggen[2];
    float fDynamicLimitsIf[2];

};

/* --------------------------------------------------------------------
 * This structure hold the numbers defining the radar calibration
 */
#define DSP_CAL_PW_COUNT (4)
struct dsp_cal_polar
{
    struct dsp_cal_pw    PW[DSP_CAL_PW_COUNT];
};

#define STRUCT_DSP_CAL_DEFINED 1
struct dsp_cal
{
    struct dsp_cal_polar Horiz;
    struct dsp_cal_polar Vert;
};

#define STRUCT_DSP_REFL_CAL_DEFINED 1
struct dsp_refl_cal
{
    char             sVersion[8] ;            /* IRIS version when saved */
    struct ymds_time CurrentSiggenTime;       /* Local time */
    char             sCurrentSiggenId[40];
    struct dsp_cal   Reference;
    struct dsp_cal   Stored;
};

/* --------------------------------------------------------------------
 * This structure hold signal generator calibration results.  If no calibration
 * file is found, then time is set to zero, max value zero, factual set to
 * 1-to-1 mapping, and id set to "No siggen calibration file".
 */
#define DSP_SIGGEN_CAL_SIZE (568)

struct dsp_siggen_cal
{
    struct ymds_time siggen_time;  /* Local time siggen calibration was done*/
    char siggen_id[40];            /* Signal generator ID string */
    int32_t ical_max_value;        /* The maximum setting that was calibrated */

    /* The actual values for signal generator settings.
     * index 0 is for max value, index 1 for 1db less, ...
     */
    float factual[128];
};

/* --------------------------------------------------------------------
 * Structure to hold information for the various type of gain controls
 * that a DSP may have.  Both the analog (STC/ACG voltage) and the
 * digital (6-bit IAGC) calibrations appear here.
 */
#define IANALOG_GCAL_SIZE  ( 101)
#define IDIGITAL_GCAL_SIZE (  64)
struct dsp_gain_cal {
    /* dB vs. percent full scale volts */
    float fanalog_curve[IANALOG_GCAL_SIZE] ;
    /* Nominal and actual dB vs     */
    float fdigital_nominal_gain[IDIGITAL_GCAL_SIZE] ;
    /*   6-bit attenuator setting.  */
    float fdigital_actual_gain [IDIGITAL_GCAL_SIZE] ;
    /* usage flags for each setting */
    uint16_t idigital_flags[IDIGITAL_GCAL_SIZE] ;
};

/* --------------------------------------------------------------------
 * This structure holds the STC table.  This is the table of numbers to load
 * into the signal processor.  The exact format and size of this table is
 * dependent on the signal processor type, thus if the signal processor type
 * is changed.
 */
#define DSP_STC_TABLE_SIZE (16384)
struct dsp_stc_table
{
    uint16_t istctable[ DSP_STC_TABLE_SIZE/2 ];
};

/* --------------------------------------------------------------------
 * This structure holds the AGC calibration information.  In the analog
 * gain control case, this consists of a table of 256 values, and the two dB
 * values that led to the creation of that table.  In the digital gain
 * control case, the DSP signal power feedback constants are stored.
 */
#define DSP_AGC_TABLE_SIZE (256)
struct dsp_agc_cal
{
    uint16_t iagctable[DSP_AGC_TABLE_SIZE] ; /* Analog AGC map */
    float fsaturation ;            /* dBM level of saturation */
    float fmargin ;                /* saturation margin */

    float fiagc_hi ;               /* IAGC high dB limit */
    float fiagc_goal ;             /* IAGC feedback goal */
    float fiagc_low ;              /* IAGC low dB limit */
};


#ifdef __cplusplus
}
#endif
#endif /* #ifndef SIGMET_SETUP_H */
