Radx2Grid param

Radx2Grid reads data from Radx-supported format files in native. The output is written to Cartesian files in CF-compliant NetCDF.

OVERVIEW

Radx2Grid is a large application with many parameters available for controlling its operation.

This makes the use of the parameter file confusing to a new user.

Therefore, the parameters are separated into sections.

The more common sections are at the top of the file, and the less common parameters lower down in the file. Each section is preceded by a header starting and ending with a line of ======================== characters.

This HTML documentation has been auto-generated from the default parameter file and reformatted for display on the web

DEBUGGING

debug

Debug option.

If set, debug messages will be printed appropriately.

Type: enum

Options:

• DEBUG_OFF
• DEBUG_NORM
• DEBUG_VERBOSE
• DEBUG_EXTRA

debug = DEBUG_OFF;

DATA INPUT DIRECTORY and INPUT MODE

input_dir

Input directory for searching for files.

Files will be searched for in this directory. This is ignored if the

list of files is specified on the command line using the -f option.

Type: string

input_dir = ".";

mode

Operating mode.

In FILELIST mode, we move through the list of file names specified on

the command line.

In REALTIME mode, the program waits for a new input file to arrive in

'input_dir'.

In ARCHIVE mode, we move through the files in input_dir between the

start and end times set on the command line.

In ARCHIVE mode, input_dir must be one above the day-directory.

Type: enum

Options:

• FILELIST
• ARCHIVE
• REALTIME

mode = FILELIST;

max_realtime_data_age_secs

Maximum age of realtime data (secs).

REALTIME mode only. Only data files less old than this will be

processed.

Type: int

max_realtime_data_age_secs = 300;

start_time

Set the start time for ARCHIVE mode analysis.

Format is 'yyyy mm dd hh mm ss'.

Type: string

start_time = "2015 06 26 00 00 00";

end_time

Set the end time for ARCHIVE mode analysis.

Format is 'yyyy mm dd hh mm ss'.

Type: string

end_time = "2015 06 26 12 00 00";

DATA OUTPUT DIRECTORY AND FILE NAMES

output_dir

Output directory for writing files.

Files will be written to this directory.

Type: string

output_dir = ".";

output_format

Set the output format.

CF_NETCDF

CF-compliant NetCDF. See

http://cf-pcmdi.llnl.gov/documents/cf-conventions. ZEBRA_NETCDF: NetCDF format specifically for ZEBRA display. This forces a conversion to a LATLON projection. MDV: legacy MDV format.

Type: enum

Options:

• CF_NETCDF
• ZEBRA_NETCDF
• MDV
• CEDRIC

output_format = CF_NETCDF;

INTERPOLATION MODE

interp_mode

Mode for interpolation.

INTERP_MODE_CART

interpolate onto a regular 3-D Cartesian grid. This

is the most common option and is equivalent to the legacy SPRINT application.

INTERP_MODE_PPI

interpolate onto a regular 2-D Cartesian grid in

(x,y), preserving the original radar elevation angles for each sweep in the vertical. The result is a volume of Cartesian PPIs, with the (x,y) dimensions in km and the vertical dimension in degrees.

INTERP_MODE_POLAR

interpolate onto a regular azimuth grid,

preserving the elevation angles for each sweep. The azimuths are remapped onto a regular grid. The elevation angle attached to each vertical level is derived from the sweep information in the input file.

INTERP_MODE_CART_REORDER

interpolate onto a regular 3-D Cartesian

grid using the reorder strategy. This should only be used for MOVING platforms only. DO NOT USE this method for FIXED platform, use INTERP_MODE_CART instead.

INTERP_MODE_SAT

interpolate satellite-based lidar or radar data onto

a grid, with a specified swath width along the satellite track. The remapped data can then be visualized using a Cartesian data display, such as Jazz.

Type: enum

Options:

• INTERP_MODE_CART
• INTERP_MODE_PPI
• INTERP_MODE_POLAR
• INTERP_MODE_CART_REORDER
• INTERP_MODE_CART_SAT

interp_mode = INTERP_MODE_CART;

INTERPOLATION OPTIONS

use_nearest_neighbor

; Option to use nearest neighbor method instead of 3D linear

interpolation.

If true, use the values from the nearest point instead of

interpolating between the measured points that surround the grid point.

Type: boolean

use_nearest_neighbor = FALSE;

min_nvalid_for_interp

Minimum number of valid data points for theinterpolation.

The program performs an 8-point linear interpolation. This is the

number of valid data points, out of the possible 8, which must be present for interpolation to proceed. A high number will exclude marginal points. A low number will include marginal points.

Minimum val: 1 Maximum val: 8

Type: int

min_nvalid_for_interp = 3;

use_fixed_angle_for_interpolation

; Option to use the fixed sweep angle for determining position for

interpolation.

If false, we use the measured elevaiton and azimuth for each ray. If

true, we use the fixed angle instead of the elevation angle in PPI scan mode and the fixed angle instead of azimuth in RHI mode.

Type: boolean

use_fixed_angle_for_interpolation = FALSE;

use_fixed_angle_for_data_limits

; Option to use the fixed sweep angle for determining the angle limits

of the data.

If true, we use the scan strategy sweep fixed angle for determining

the angular limits to the data. If false, we use the actual measured angles. We need to find the data limits so that we can extend the interpolation by a fraction of the beam width beyond the angular limits. See also 'beam_width_fraction_for_data_limit_extension'.

Type: boolean

use_fixed_angle_for_data_limits = TRUE;

beam_width_fraction_for_data_limit_extension

; Fraction of the beam width used to extend the data beyond the

observed limits.

At the edges of the observed region, the interpolated data is

extended by an angle computed as beam_width * fraction. For extending below the lowest tilt and above the upper tilt, the vertical beam width is used. For extended to the left or right of sector limits, the horizontal beam width is used.

Type: double

beam_width_fraction_for_data_limit_extension = 0.5;

CARTESIAN GRID VERTICAL LEVELS

Set the vertical levels for the Cartesian grid.

This applies to INTERP_MODE_CART, INTERP_MODE_SAT and

INTERP_MODE_REORDER.

For INTERP_MODE_PPI and INTERP_MODE_POLAR, the vertical levels are

governed by the elevation angle for each sweep in the input volume.

You can either specify a grid with constant vertial spacing, or you

can provide an array of heights. The latter allows you to specify a grid with irregular vertical spacing.

grid_z_geom

Specifying regular vertical grid levels.

nz is the number of levels. dz is constant spacing of the Z levels, in km. minz is the lowest level, in km MSL.

NOTE: Applies if specify_individual_z_levels is false. Does not apply

to INTERP_MODE_PPI.

Type: struct

typedef struct {

int nz; double minz; double dz;

}

grid_z_geom = {

nz = 20,

minz = 0.5,

dz = 1

};

specify_individual_z_levels

Option to specify each Z level individually.

If true, you will fill out the z_level array to specify each Z level.

This allows you to set up a grid with unequal spacing in the vertical. If false, use grid_z_geom to specify Z levels at constant spacing.

Type: boolean

specify_individual_z_levels = FALSE;

z_level_array

Array of grid levels, in km MSL.

This applies if specify_individual_z_levels is true.

Type: double 1D array - variable length.

z_level_array = {

};

CARTESIAN GRID XY DETAILS

; Specify the grid details in (x,y). This will be a regular Cartesian

grid. The units for the grid paramters are in (km,km) for all projections except for PROJ_LATLON. For the LATLON projection, the units are in (deg,deg).

grid_xy_geom

Specify the grid parameters in x,y.

nx: the number of grid points in the X dimension. ny: the number of grid points in the Y dimension. minx: the X coordinate of the center of the SW grid cell. miny: the Y coordinate of the center of the SW grid cell. dx: the grid spacing in the X dimension. dy: the grid spacing in the Y dimension.

Units are in km, except for PROJ_LATLON, which has units in degrees.

Type: struct

typedef struct {

int nx; int ny; double minx; double miny; double dx; double dy;

}

grid_xy_geom = {

nx = 400,

ny = 400,

minx = -199.5,

miny = -199.5,

dx = 1,

dy = 1

};

center_grid_on_radar

Option to set the grid origin at the radar.

If true, the latitude and longitude of the grid origin will be set to

the radar location. If false, grid_origin_lat and grid_origin_lon will be used. This parameter is not applicable for moving platforms.

Type: boolean

center_grid_on_radar = TRUE;

CARTESIAN GRID PROJECTION

grid_projection

Projection details for the Cartesian grid..

PROJ_LATLON: regular lat/lon grid (Equidistant Cylindrical) PROJ_FLAT: Azimuthal Equidistant (Radar) PROJ_LAMBERT_CONF: Lambert Conformal Conic PROJ_LAMBERT_AZIM: Lambert Azimuthal Equal Area PROJ_MERCATOR: Mercator - EW orientation PROJ_TRANS_MERCATOR: Tranverse Mercator - NS orientation PROJ_POLAR_STEREO: Stereographic- polar aspect PROJ_OBLIQUE_STEREO: Stereographic - oblique aspect PROJ_ALBERS: Albers Equal Area Conic PROJ_VERT_PERSP: Vertical Perspective (satellite view).

Type: enum

Options:

• PROJ_LATLON
• PROJ_LAMBERT_CONF
• PROJ_MERCATOR
• PROJ_POLAR_STEREO
• PROJ_FLAT
• PROJ_OBLIQUE_STEREO
• PROJ_TRANS_MERCATOR
• PROJ_ALBERS
• PROJ_LAMBERT_AZIM
• PROJ_VERT_PERSP

grid_projection = PROJ_FLAT;

grid_rotation

Grid rotation.

This applies only to PROJ_FLAT projection.

Type: double

grid_rotation = 0;

grid_origin_lat

Grid origin latitude.

This applies to all projections except LATLON.

If 'center_grid_on_radar' is true, the radar location is used

instead.

Type: double

grid_origin_lat = 0;

grid_origin_lon

Grid origin longitude.

This applies to all projections except LATLON.

If 'center_grid_on_radar' is true, the radar location is used

instead.

Type: double

grid_origin_lon = 0;

auto_remap_flat_to_latlon

; Option to first interpolate to a PROJ_FLAT projection, and then

automatically remap to a latlon projection on output.

If TRUE, before writing the file, the app will choose a latlon grid

that matches the FLAT grid extent and rsolution, and automatically remap to a PROJ_LATLON projection.

Type: boolean

auto_remap_flat_to_latlon = FALSE;

grid_lat1

Grid reference latitude 1.

This applies to LAMBERT_CONF and ALBERS projections.

Type: double

grid_lat1 = 0;

grid_lat2

Grid reference latitude 2.

This applies to LAMBERT_CONF and ALBERS projections.

Type: double

grid_lat2 = 0;

grid_central_scale

Central scale for projections.

This applies to POLAR_STEREO, OBLIQUE_STEREO and TRANSVERSE_MERCATOR

projections.

Type: double

grid_central_scale = 1;

grid_tangent_lat

Tangent latitude (deg).

This applies to OBLIQUE_STEREO only.

Type: double

grid_tangent_lat = 0;

grid_tangent_lon

Tangent longitude (deg).

This applies to OBLIQUE_STEREO and POLAR_STEREO.

Type: double

grid_tangent_lon = 0;

grid_pole_is_north

Flag indicating stereogtraphic is over the NORTH pole.

This applies to POLAR_STEREO. If false, the projection is over the

south pole.

Type: boolean

grid_pole_is_north = TRUE;

grid_persp_radius

Radius of perspective point (km).

This applies to VERT_PERSP.

Type: double

grid_persp_radius = 35786;

grid_false_northing

False northing correction.

Occasionally, this is added to the Y coordinate so that all

coordinates are positive. Normally 0. As an alternative to false_northing and false_easting, you can set the offset_latitude and offset_longitude.

Type: double

grid_false_northing = 0;

grid_false_easting

False easting correction.

Occasionally, this is added to the X coordinate so that all

coordinates are positive. Normally 0.

Type: double

grid_false_easting = 0;

grid_set_offset_origin

; Do you want to specify an offset origin using lat/lon instead of

false_northing and false_easting?.

If true, set grid_offset_origin_latitude and

grid_offset_origin_longitude.

Type: boolean

grid_set_offset_origin = FALSE;

grid_offset_origin_latitude

Latitude of offset origin.

See grid_set_offset_origin.

Type: double

grid_offset_origin_latitude = 0;

grid_offset_origin_longitude

Longitude of offset origin.

See grid_set_offset_origin.

Type: double

grid_offset_origin_longitude = 0;

SPECIFYING THE FIELDS FOR INTERPOLATION

; By default, all fields in the input files will be interpolated. If

you want to select individual fields to be interpolated, specify them here.

select_fields

Option to select the fields for interpolation.

If FALSE, all fields will be processed.

Type: boolean

select_fields = FALSE;

selected_fields

Select the list of fields to be processed.

See 'select_fields'. You specify the list of field names to be

processed. In addition you need to set 'process_this_field' to TRUE or FALSE. This is provided as a convenience, so that you can select or deselect fields without having to change the list.

Type: struct

typedef struct {

string input_name; boolean process_this_field;

}

1D array - variable length.

selected_fields = {

input_name = "DBZ",

process_this_field = TRUE

input_name = "VEL",

process_this_field = TRUE

input_name = "WIDTH",

process_this_field = FALSE

};

TRANSFORMING FIELDS FOR INTERPOLATION

transform_fields_for_interpolation

; Option to perform a transform on specified fields prior to

interpolation.

If TRUE, the field you specify in this section will be transformed

prior to interpolation, and possibly back again afterwards.

Type: boolean

transform_fields_for_interpolation = FALSE;

transform_fields

Transform fields for interpolation.

NOTE

this is done immediately after the fields are read from the

file.

'input_name' refers to the name of the field read in, before any

renaming occurs. If 'output_name' is the same as 'input_name', the field is transformed in place. If 'output_name' differs from 'input_name', a copy of the field is made prior to interpolation, and this field copy is named 'output_name'.

NOTE

the transform occurs first, before any rename operations (see

next section). 'output_name' in transform_fields matches 'input_name' in 'rename_fields'.

TRANSFORM_DB_TO_LINEAR

transform the field from dB to linear units,

perform the interpolation, and write out the interpolated field in linear units.

TRANSFORM_DB_TO_LINEAR_AND_BACK

transform the field from dB units to

linear units, perform the interpolation, and then transform back to dB units before writing to the output file.

TRANSFORM_LINEAR_TO_DB

transform the field from linear units to dB

units, perform the interpolation, and write out the interpolated field in dB units.

TRANSFORM_LINEAR_TO_DB_AND_BACK

transform the field from linear

units to dB units, perform the interpolation, and then transform back to linear units before writing to the output file.

Type

struct

 ;; typedef struct {

string input_name; string output_name; string output_units; interp_transform_t transform;

Options:

• TRANSFORM_DB_TO_LINEAR
• TRANSFORM_DB_TO_LINEAR_AND_BACK
• TRANSFORM_LINEAR_TO_DB
• TRANSFORM_LINEAR_TO_DB_AND_BACK
• 1D array - variable length.

transform_fields = {

input_name = "DBZ",

output_name = "DBZ",

output_units = "dBZ",

transform = TRANSFORM_DB_TO_LINEAR_AND_BACK

};

OPTION TO SET FOLDING LIMITS ON SELECTED FIELDS

set_fold_limits

Option to set the folding limits for individual fields.

The limits are set prior to interpolation.

If TRUE, fold limits will be set for the specified fields. You should

do this for fields such as VELOCITY and PHIDP. Some CfRadial files already contain the fold limits as attributes on the field - for these fields you do not need to set fold limits, unless you wish to override what is in the file. You only need to specify the limits if the file does not already have these attributes. The field_folds parameter can be set to FALSE to override an attribute set in the data file.

Type: boolean

set_fold_limits = FALSE;

folded_fields

Use this to set the fold limits for a particular field.

If this is specified, the interpolation for this field will be

performed 'on the circle' so that folding is handled correctly. If use_global_nyquist is true, the fold limits are set to plus and minus the main nyquist velocity. If false, the fold limits specified here are used instead.

NOTE: 'input_name' for this step refers to the 'input_name' in

'select_fields' and 'output_name' in 'transform_fields'. This step is performed prior to renaming fields (see below).

Type: struct

typedef struct {

string input_name; boolean field_folds; boolean use_global_nyquist; double fold_limit_lower; double fold_limit_upper;

}

1D array - variable length.

folded_fields = {

input_name = "VEL",

field_folds = TRUE,

use_global_nyquist = TRUE,

fold_limit_lower = -25,

fold_limit_upper = 25

};

OPTION TO OVERRIDE THE NYQUIST VELOCITY

override_nyquist

Option to override nyquist velocity in incoming data.

If true, the nyquist_velocity parameter is used to specify the

nyquist. If false, the nyquist is computed from the incoming radar data stream. The nyquist is used for velocity interpolation, to ensure that folded values are treated correctlty.

Type: boolean

override_nyquist = FALSE;

nyquist_velocity

Specify nyquist velocity (m/s).

See 'override_nyquist'.

Type: double

nyquist_velocity = 25;

OPTION TO DESIGNATE SELECTED FIELDS AS DISCRETE IN NATURE

set_discrete_fields

Option to set 'is_discrete' flag for individual fields.

If TRUE, the specified fields will be treated as holding discrete

values, and the nearest neighbor method will be used instead of interpolation.

You should do this for fields such as PID (particle ID). In CfRadial

files there is an option to store this information as attributes on each field. You can override what is in the file, or add to it.

Type: boolean

set_discrete_fields = FALSE;

discrete_fields

Use this to set the 'is_discrete' flag on a field.

If this is specified, nearest neighbor will be used for this field.

You can use this to override the is_discrete flag on a field in the input file.

NOTE: 'input_name' for this step refers to the 'input_name' in

'select_fields' and 'output_name' in 'transform_fields'. This step is performed prior to renaming fields (see below).

Type: struct

typedef struct {

string input_name; boolean is_discrete;

}

1D array - variable length.

discrete_fields = {

input_name = "PID",

is_discrete = TRUE

};

OPTION TO RENAME FIELDS ON OUTPUT

rename_fields

Option to rename some or all of the fields when they are written out.

If FALSE, no fields will be renamed.

Type: boolean

rename_fields = FALSE;

renamed_fields

Specify the list of fields to be renamed.

Only applies if 'rename_fields' is TRUE.

The field name is changed from 'input_name' to 'output_name'.

NOTE: for transformed fields (see previous section), 'input_name' in

'renamed_fields' matches 'output_name' in 'transform_fields'. The transform occurs first, and then the fields are renamed.

Type: struct

typedef struct {

string input_name; string output_name;

}

1D array - variable length.

renamed_fields = {

input_name = "DBZ",

output_name = "DBZ_S"

input_name = "VEL",

output_name = "VEL_S"

input_name = "WIDTH",

output_name = "WIDTH_S"

};

OPTION TO ADD GEOMETRY AND TIME FIELDS

; These fields are computed from the geometry of the radar rays, and

then added as input fields in native radial coordinates.

output_angle_fields

Option to output angle fields.

Type: boolean

output_angle_fields = FALSE;

angle_fields

Specify the output names of the angle fields. If set to empty, that

field will not be created.

azimuth: the azimuth of the ray (deg) elevation: the elevation of the ray (deg) alpha: sin(az) * cos(el) beta: cos(az) * cos(el) gamma: sin(el).

Type: struct

typedef struct {

string azimuth_field_name; string elevation_field_name; string alpha_field_name; string beta_field_name; string gamma_field_name;

}

angle_fields = {

azimuth_field_name = "azimuth",

elevation_field_name = "elevation",

alpha_field_name = "alpha",

beta_field_name = "beta",

gamma_field_name = "gamma"

};

output_range_field

Option to add range field to the output.

This is the range, in km, from the radar to each gate.

Type: boolean

output_range_field = FALSE;

range_field_name

Name of range field, if written.

See 'output_range_field'.

Type: string

range_field_name = "range";

output_height_field

Option to add height field to the output.

This is the height, in km msl, of the center of each gate.

Type: boolean

output_height_field = FALSE;

height_field_name

Name of height field, if written.

See 'output_height_field'.

Type: string

height_field_name = "height";

output_coverage_field

Option to output a field indicating radar coverage.

This is a flag field, with a 1 indicating that the radar covers that

location, and a 0 indicating that is does not. See also 'coverage_field_name'. This field is always transformed using nearest neighbor.

Type: boolean

output_coverage_field = FALSE;

coverage_field_name

Name of coverage field, if written.

See 'output_coverage_field'.

Type: string

coverage_field_name = "Coverage";

output_time_field

Option to output a field of time since start of volume (secs).

If true, time time elapsed field is included in the output file. See

also 'time_field_name' and 'interp_time_field'.

Type: boolean

output_time_field = FALSE;

time_field_name

Name of time field, if written.

See 'output_time_field'.

Type: string

time_field_name = "time_elapsed";

interp_time_field

Option to perform interpolation on the time field.

If false, nearest neighbor will be used for the time field.

Type: boolean

interp_time_field = TRUE;

OPTION TO ADD DEBUG FIELDS

; The debug fields are added to the output Cartesian grid. These are

geometry fields, and can be used to ensure the interpolation is working as expected.

output_debug_fields

Option to add debug fields for checking the interpolation.

The test fields allow us to ensure that the interpolation is working

correctly.

The debug fields are:

nContrib - number of points used in interpolation gridAz: azimuth deg gridEl: elevation deg gridRange: range km llEl: lower left elevation deg llAz: lower left azimuth deg lrEl: lower right elevation deg lrAz: lower right azimuth deg ulEl: upper left elevation deg ulAz: upper left azimuth deg urEl: upper right elevation deg urAz: upper right azimuth deg.

Type: boolean

output_debug_fields = FALSE;

CENSORING OUTPUT FIELDS

; You have the option of censoring the output data fields - i.e.

setting the fields to missing values - at gates which meet certain criteria based on the values in the input fields.

If this is done correctly, it allows you to preserve the valid data

and discard the noise, thereby improving compression. This leads to smaller data files.

apply_censoring

Apply censoring based on field values and thresholds.

If TRUE, censoring will be performed. See 'censoring_fields' for

details on how the censoring will be applied.

Type: boolean

apply_censoring = FALSE;

censoring_fields

Fields to be used for censoring.

Specify the fields to be used to determine whether a gate should be

censored.

The name refers to the field name in the input files.

Valid field values lie in the range from min_valid_value to

max_valid_value, inclusively. If the value of a field at a gate lies within this range, it is considered valid.

Each specified field is examined at each gate, and is flagged as

valid if its value lies in the valid range.

These field flags are then combined as follows:

First, all of the LOGICAL_OR flags are combined, yielding a single

combined_or flag which is true if any of the LOGICAL_OR fields is true.

Next the combined_or flag is combined with all of the LOGICAL_AND

fields, yielding a true value only if the combined_or flag and the LOGICAL_AND fields are all true.

If this computed flag is true, then the data at the gate is regarded

as valid and is retained.

If the computed flag is false, the data at the gate is censored, and

all of the fields at the gate are set to missing.

Type

struct

 ;; typedef struct {

string name; double min_valid_value; double max_valid_value; logical_t combination_method;

Options:

• LOGICAL_AND
• LOGICAL_OR
• 1D array - variable length.

censoring_fields = {

name = "SNR",

min_valid_value = 0,

max_valid_value = 1000,

combination_method = LOGICAL_OR

name = "NCP",

min_valid_value = 0.15,

max_valid_value = 1000,

combination_method = LOGICAL_OR

};

censoring_min_valid_run

Minimum valid run of non-censored gates.

Only active if set to 2 or greater. A check is made to remove short

runs of noise. Looking along the radial, we compute the number of contiguous gates (a 'run') with uncensored data. For the gates in this run to be accepted the length of the run must exceed censoring_min_valid_run. If the number of gates in a run is less than this, then all gates in the run are censored.

Type: int

censoring_min_valid_run = 1;

SETTING THE PSEUDO EARTH RADIUS RATIO FOR HEIGHT COMPUTATIONS

override_standard_pseudo_earth_radius

; Option to override the standard 4/3 earth radius model for

refraction.

If true, the standard 4/3 earth radius will be overridden. The US NWS

NEXRAD system uses 1.21 instead of 1.333.

Type: boolean

override_standard_pseudo_earth_radius = FALSE;

pseudo_earth_radius_ratio

; Ratio for computing the pseudo earth radius for beam height

computations.

For standard refraction this is 4/3. For super refraction it will be

less than 4.3, and for sub-refraction it will be greater. NEXRAD uses 1.21.

Type: double

pseudo_earth_radius_ratio = 1.33333;

FILE READ OPTIONS

aggregate_sweep_files_on_read

Option to aggregate sweep files into a volume on read.

If true, and the input data is in sweeps rather than volumes (e.g.

DORADE), the sweep files from a volume will be aggregated into a volume.

Type: boolean

aggregate_sweep_files_on_read = FALSE;

ignore_idle_scan_mode_on_read

Option to ignore data taken in IDLE mode.

If true, on read will ignore files with an IDLE scan mode.

Type: boolean

ignore_idle_scan_mode_on_read = TRUE;

remove_rays_with_antenna_transitions

Option to remove rays taken while the antenna was in transition.

If true, rays with the transition flag set will not be used. The

transiton flag is set when the antenna is in transtion between one sweep and the next.

Type: boolean

remove_rays_with_antenna_transitions = FALSE;

transition_nrays_margin

Number of transition rays to include as a margin.

Sometimes the transition flag is turned on too early in a transition,

on not turned off quickly enough after a transition. If you set this to a number greater than 0, that number of rays will be included at each end of the transition, i.e. the transition will effectively be shorter at each end by this number of rays.

Type: int

transition_nrays_margin = 0;

remove_long_range_rays

Option to remove long range rays.

Applies to NEXRAD data. If true, data from the non-Doppler long-range

sweeps will be removed.

Type: boolean

remove_long_range_rays = TRUE;

remove_short_range_rays

Option to remove short range rays.

Applies to NEXRAD data. If true, data from the Doppler short-range

sweeps will be removed.

Type: boolean

remove_short_range_rays = FALSE;

trim_surveillance_sweeps_to_360deg

; Option to trip surveillance sweeps so that they only cover 360

degrees.

Some sweeps will have rays which cover more than a 360-degree

rotation. Often these include antenna transitions. If this is set to true, rays are trimmed off either end of the sweep to limit the coverage to 360 degrees. The median elevation angle is computed and the end ray which deviates from the median in elevation is trimmed first.

Type: boolean

trim_surveillance_sweeps_to_360deg = FALSE;

override_fixed_angle_with_mean_measured_angle

Option to override the fixed angle with the mean angle for a sweep.

If true, for each sweep the mean pointing angle is computed and then

this is used to override the fixed angle.

Type: boolean

override_fixed_angle_with_mean_measured_angle = FALSE;

reorder_sweeps_by_ascending_angle

Option to reorder sweeps by ascending angles.

If true, sweeps will be checked to see if they are in ascending angle

order. If not they are reordered. If the sweeps are reordered, this means that the rays times will no longer be monotonically increasing.

Type: boolean

reorder_sweeps_by_ascending_angle = FALSE;

compute_sweep_angles_from_vcp_tables

; Option to compute sweep angles using the VCP tables when reading

NEXRAD data.

If true, the VCP tables will be used to assign sweep angles. This is

useful if rounding angles to fit the VCP is desired. For NEXRAD data files that don't follow a known VCP and the VCP header is not included, set this to false.

Type: boolean

compute_sweep_angles_from_vcp_tables = FALSE;

OPTION TO CORRECT TIME

apply_time_offset

Option to apply an offset to the ray times.

If TRUE, this offset will be ADDED to the existing ray times. This is

useful, for example, for correcting time errors, or converting from local time to UTC.

Type: boolean

apply_time_offset = FALSE;

time_offset_secs

Time offset (secs).

See 'apply_time_offset'. This value will be ADDED to the existing ray

times.

Type: double

time_offset_secs = 0;

SETTING LIMITS ON THE VALID DATA

set_max_range

Option to set the max range for any ray.

Type: boolean

set_max_range = FALSE;

max_range_km

Specified maximim range - km.

Gates beyond this range are removed.

Type: double

max_range_km = 9999;

set_elevation_angle_limits

Option to set elevation angle limits.

Only use rays within the specified elevation angle limits.

Type: boolean

set_elevation_angle_limits = FALSE;

lower_elevation_angle_limit

Lower elevation angle limit (deg).

Type: double

lower_elevation_angle_limit = 0;

upper_elevation_angle_limit

Upper elevation angle limit (deg).

Type: double

upper_elevation_angle_limit = 90;

set_azimuth_angle_limits

Option to set azimuth angle limits.

Only use rays within the specified azimuth angle limits. This

essentially specifies a sector for valid data. Rays outside this sector are ignored.

Type: boolean

set_azimuth_angle_limits = FALSE;

lower_azimuth_angle_limit

Counter-clockwise azimuth angle limit (deg).

This is the azimuth limit at the lower (counter clockwise) end of the

sector. For azimuths to the west of north, use values between 180 and 360.

Type: double

lower_azimuth_angle_limit = 0;

upper_azimuth_angle_limit

Clockwise azimuth angle limit (deg).

This is the azimuth limit at the upper (clockwise) end of the sector.

Type: double

upper_azimuth_angle_limit = 360;

check_fixed_angle_error

Option to limit the fixed angle error to a specfied maximum value.

If true, we compute the error between the actual pointing angle and

the fixed angle for the sweep. If the error exceeds the specified limit, we reject the ray. For PPIs, we check th elevation angle against the fixed angle. For RHIs, we check the azimuth against the fixed angle.

Type: boolean

check_fixed_angle_error = FALSE;

max_fixed_angle_error

Maximum permissable error in the pointing angle (deg).

See 'check_fixed_angle'.

Type: double

max_fixed_angle_error = 2;

check_number_of_sweeps

Option to check that the file has a minimum number of sweeps.

See 'min_number_of_sweeps'.

Type: boolean

check_number_of_sweeps = FALSE;

min_number_of_sweeps

Minimum number of sweeps for valid file.

Applies if 'check_number_of_sweeps' is true. Only process files with

this number of sweeps, or more.

Type: double

min_number_of_sweeps = 1;

OPTION TO OVERRIDE VOLUME NUMBER, OR AUTOINCREMENT

override_volume_number

Option to override the volume number in the file.

Useful is there is no volume number in the data.

Type: boolean

override_volume_number = FALSE;

starting_volume_number

Volume number at startup.

Applies if 'override_volume_number' is true.

Type: int

starting_volume_number = 1;

autoincrement_volume_number

Option to automatically increment the volume number.

Starts at 'starting_volume_number' and increments from there.

Type: boolean

autoincrement_volume_number = FALSE;

OPTION TO OVERRIDE RADAR LOCATION

override_radar_location

Option to override the radar location.

If true, the location in this file will be used. If not, the location

in the time series data will be used.

Type: boolean

override_radar_location = FALSE;

radar_latitude_deg

Radar latitude (deg).

See override_radar_location.

Type: double

radar_latitude_deg = -999;

radar_longitude_deg

Radar longitude (deg).

See override_radar_location.

Type: double

radar_longitude_deg = -999;

radar_altitude_meters

Radar altitude (meters).

See override_radar_location.

Type: double

radar_altitude_meters = -999;

OPTION TO OVERRIDE INSTRUMENT AND/OR SITE NAME

override_instrument_name

Option to override the instrument name.

If true, the name provided will be used.

Type: boolean

override_instrument_name = FALSE;

instrument_name

Instrument name.

See override_instrument_name.

Type: string

instrument_name = "unknown";

override_site_name

Option to override the site name.

If true, the name provided will be used.

Type: boolean

override_site_name = FALSE;

site_name

Site name.

See override_site_name.

Type: string

site_name = "unknown";

OPTION TO OVERRIDE RADAR BEAM WIDTH

; The beam width is used to decide how far to extend the interpolated

data beyond the observed data. The data is extended below the lowest tilt and above the highest tilt, and in the case of sector scans it is extended slightly beyond the sector limits.

override_beam_width

Option to override radar beam width.

If TRUE, the program will use beam width specified in the

'beam_width_deg' parameter.

Type: boolean

override_beam_width = FALSE;

beam_width_deg_h

Horizontal beam width if override is set true (deg).

Used for extending the data to the left or right of sector limits, if

applicable. This is only used if 'override_beam_width' is set true. Otherwise the metadata in the input data stream is used.

Type: double

beam_width_deg_h = 1;

beam_width_deg_v

Vertical beam width if override is set true (deg).

Used for extending data above or below the observed region. This only

used if 'override_beam_width' is set true. Otherwise the metadata in the input data stream is used.

Type: double

beam_width_deg_v = 1;

OPTION TO OVERRIDE RADAR GATE GEOMETRY

; If the start range and/or gate spacing is not correct in the data,

you can override it using the parameters below.

override_gate_geometry

Option to override gate geometry.

If TRUE, the program will use the start range and gate spacing

specified here.

Type: boolean

override_gate_geometry = FALSE;

start_range_km

Start range (km).

Used for overriding the start range in the data.

Type: double

start_range_km = 0.125;

gate_spacing_km

Gate spacing (km).

Used for overriding the gate spacing in the data.

Type: double

gate_spacing_km = 0.25;

OPTION TO APPLY ANGLE CORRECTIONS

; This section allows you to correct the azimuth and/or elevation

angles for a known error.

azimuth_correction_deg

Add this value to the azimuth.

Normally only used for testing, but can be used if there is a

constant azimuth error in the data.

Type: double

azimuth_correction_deg = 0;

elevation_correction_deg

Add this value to the elevation.

Normally only used for testing, but can be used if there is a

constant elevation error in the data.

Type: double

elevation_correction_deg = 0;

CF NetCDF OUTPUT DETAILS

specify_output_filename

If true, the file will be named 'output_filename'.

If false, the file name will be computed from the data time.

Type: boolean

specify_output_filename = FALSE;

output_filename

Name of output file.

Applies only if specify_output_filename is true.

Type: string

output_filename = "ncfGrid.nc";

name_file_from_start_time

If true, name the output file using the start time.

If false, the end time is used, in the MDV tradition.

Type: boolean

name_file_from_start_time = FALSE;

netcdf_file_prefix

User-specified output file prefix, comes before date_time.

Type: string

netcdf_file_prefix = "ncf_";

netcdf_file_suffix

; User-specified output file suffix, comes after the date_time and

before the .nc which gets automatically added on.

Type: string

netcdf_file_suffix = "";

use_iso8601_filename_convention

; If true the output filename uses the prefix, followed by ISO 8601

timestamp convention.

eg. prefix.2008-05-22T14:00:00.nc.

Type: boolean

use_iso8601_filename_convention = FALSE;

NETCDF COMPRESSION

netcdf_compressed

Option to compress data fields on output.

Applies to CfRadial netCDF and Dorade.

Type: boolean

netcdf_compressed = TRUE;

netcdf_compression_level

Level of compression for output data.

Valid range is 1 through 9. 1 gives lowest compression, 9 highest. 4

is a good compromise between speed and compression efficiency. Only applies to NetCDF file format.

Minimum val: 1 Maximum val: 9

Type: int

netcdf_compression_level = 4;

NETCDF STYLE

netcdf_style

NetCDF style - if output_format is CFRADIAL.

netCDF classic format, netCDF 64-bit offset format, netCDF4 using

HDF5 format, netCDF4 using HDF5 format but only netCDF3 calls.

Type: enum

Options:

• CLASSIC
• NC64BIT
• NETCDF4_CLASSIC
• NETCDF4

netcdf_style = NETCDF4;

netcdf_include_latlon_arrays

If true latitude and longitude arrays of each grid point are output.

The CF convention requires that these arrays are present in the

netCDF file; however, the information is redundant since the lat and lon arrays could be constructed using the other projection and grid information required with a gridded data field.

Type: boolean

netcdf_include_latlon_arrays = TRUE;

netcdf_output_mdv_attributes

Option to output non-CF compliant MDV attributes.

If true, MDV attributes which are not CF compliant will be output.

This will facilitate the translation of the data back into MDV with the minimal loss of information.

Type: boolean

netcdf_output_mdv_attributes = FALSE;

netcdf_output_mdv_chunks

Option to output non-CF compliant MDV chunks.

If true, MDV chunks will be included as byte binary variables. This

will also write the radar parameters, e.g. location, gate spacing, etc. - to the global attributes.

Type: boolean

netcdf_output_mdv_chunks = FALSE;

ncf_title

Title string for netCDF file.

Type: string

ncf_title = "SPOL radar data";

ncf_institution

Institution string for netCDF file.

Type: string

ncf_institution = "EOL/NCAR";

ncf_references

References string for netCDF file.

Type: string

ncf_references = "";

ncf_source

Source string for netCDF file.

Type: string

ncf_source = "SPOL radar";

ncf_history

History string for netCDF file.

Type: string

ncf_history = "";

ncf_comment

Comment string for netCDF file.

Type: string

ncf_comment = "";

PROCESS CONTROL

instance

Program instance for process registration.

This application registers with procmap. This is the instance used

for registration.

Type: string

instance = "test";

register_with_procmap

Option to register this process with the process mapper (procmap).

If TRUE, every minute this process will register a heartbeat with

procmap. If the process hangs, it will be restared by the auto_restarter.

Type: boolean

register_with_procmap = FALSE;

procmap_register_interval

Interval for registering with procmap (secs).

The app will register with procmap at this interval, to update its

status. If it does not register within twice this interval, the auto_restart script will restart the app.

Type: int

procmap_register_interval = 60;

MEMORY HANDLING

free_memory_between_files

Option to free up memory between each new file.

If true, we free up as much memory as possible between handling the

files. If false, we reduse allocated memory to the extent possible.

Type: boolean

free_memory_between_files = TRUE;

THREADING FOR SPEED

use_multiple_threads

Option to use multiple compute threads to improve performance.

The read and write stages occur in the main thread, since netCDF is

not thread safe. The compute stage can be multi-threaded to improve performance.

Type: boolean

use_multiple_threads = TRUE;

n_compute_threads

The number of compute threads.

The moments computations are segmented in range, with each thread

computing a fraction of the number of gates. For maximum performance, n_threads should be set to the number of processors multiplied by 4. For further tuning, use top to maximize CPU usage while varying the number of threads.

Minimum val: 1

Type: int

n_compute_threads = 4;

INTERPOLATION FOR SATELLITE DATA

; Satellite interpolation uses the reorder params above, plus those in

this section.

sat_data_invert_in_range

Option to invert satellite data in range from the instrument.

Since satellite-based instruments look downwards, it is sometimes

necessary to invert the data, so that it sorts from the ground up.

Type: boolean

sat_data_invert_in_range = FALSE;

sat_data_set_range_geom_from_fields

Option to use the range geometry from the fields instead of the rays.

If true, the field geometry will be copied into the ray metadata.

Type: boolean

sat_data_set_range_geom_from_fields = FALSE;

OPTION TO WRITE SEARCH MATRIX FILES

; This is for debugging purposes only. The search matrix data will be

written to MDV files that can then be viewed in CIDD or JAZZ.

write_search_matrix_files

Option to write files containing data from the search matrix.

Applies to the 2D search matrices that are computed for

INTERP_MODE_CART.

Type: boolean

write_search_matrix_files = FALSE;

search_matrix_dir

Output directory for writing search matrix files.

See 'output_search_matrix'.

Type: string

search_matrix_dir = "./mdv/search_matrix";

OPTION TO IDENTIFY THE CONVECTIVE/STRATIFORM SPLIT

Applies only to INTERP_MODE_CART.

identify_convective_stratiform_split

Option to identify the convective / stratiform split.

Uses the standard deviation of reflectivity as a texture field for

each Cartesian plane. Low variability indicates stratiform conditions.

Type: boolean

identify_convective_stratiform_split = FALSE;

conv_strat_dbz_field_name

Name of reflectivity field in input data.

This is used for computing reflectivity texture.

Type: string

conv_strat_dbz_field_name = "DBZ";

conv_strat_texture_radius_km

Radius for texture analysis (km).

We determine the reflectivity 'texture' at a point by computing the

standard deviation of the square of the reflectivity, for all grid points within this radius of the central point. We then compute the square root of that sdev.

Type: double

conv_strat_texture_radius_km = 7;

conv_strat_texture_depth_km

Depth of region for computing texture (km).

We compute the reflectivity 'texture' considering all radar points

within a specified region, centered on the grid points. This is the depth of that region. It does not necessarily match the vertical grid spacing - it is likely that the depth will be greater than the grid vertical spacing, to allow for more points to be included in computing the texture. However, the depth should not exceed 2km or so, because the texture is intended to find layers (such as bright-band) in the observations.

Type: double

conv_strat_texture_depth_km = 1;

conv_strat_min_valid_fraction_for_texture

Minimum fraction of surroundingpoints for texture computations.

For a valid computation of texture, we require at least this fraction

of points around the central point to have reflectivity in excess of min_valid_dbz.

Type: double

conv_strat_min_valid_fraction_for_texture = 0.33;

conv_strat_min_valid_height

Min height used in analysis (km).

Only data at or above this altitude is used.

Type: double

conv_strat_min_valid_height = 0;

conv_strat_max_valid_height

Max height used in analysis (km).

Only data at or below this altitude is used.

Type: double

conv_strat_max_valid_height = 25;

conv_strat_min_valid_dbz

Minimum reflectivity threshold for this analysis (dBZ).

Reflectivity below this threshold is set to missing.

Type: double

conv_strat_min_valid_dbz = 10;

conv_strat_dbz_threshold_for_definite_convection

Reflectivity value that indicates definite convection.

If the reflectivity exceeds this value at a point, we assume

convection is definitely active at that point. To use this, we first compute the column maximum reflectivity. If the column max dbz at a point exceeds this threshold, then we flag that point as convective.

Type: double

conv_strat_dbz_threshold_for_definite_convection = 53;

conv_strat_convective_radius_km

Radius of convective influence (km).

Given definite convection at a point (see above), we set all points

within this radius to be convective.

Type: double

conv_strat_convective_radius_km = 5;

conv_strat_min_texture_for_convection

Minimum texture for convection at a point.

If the texture at a point exceeds this value, we set the convective

flag at this point. We then expand the convective influence around the point using convetive_radius_km.

Type: double

conv_strat_min_texture_for_convection = 15;

conv_strat_write_partition

Option to write out the convective/stratiform partition.

If true, the 2-D partition will be added to the output file.

Type: boolean

conv_strat_write_partition = FALSE;

conv_strat_write_debug_fields

Option to write out the intermediate fields for debug purposes.

If true, the intermdiate fields will be written to the output file.

Type: boolean

conv_strat_write_debug_fields = FALSE;

INTERPOLATION USING REORDER METHOD

; !!!!!! WARNING - IMPORTANT NOTE - this mode should only be used for

mobile platforms. Use INTERP_MODE_CART for all fixed platforms - it is much more robust and gives much better results !!!!!!!.

reorder_npoints_search

Number of points retrieved around each grid point.

We find this number of closest points, and then check that their

distance is less than the search radius.

Type: int

reorder_npoints_search = 24;

reorder_search_radius_km

; Radius searched around a grid cell for radar points that contribute

to theinterpolation.

We optionally scale this by range, so that the radius increases at

longer ranges where the rays are more widely spaced.

Type: double

reorder_search_radius_km = 5;

reorder_scale_search_radius_with_range

Option to scale search radius based on range from radar.

If true, we treat the specified search radius as a nominal value, and

adjust it based on the range of the grid point from the radar. See also reorder_nominal_range_for_search_radius.

Type: boolean

reorder_scale_search_radius_with_range = TRUE;

reorder_nominal_range_for_search_radius_km

Range at which the xy_margin is equal to the nominal value (km).

At ranges other than this, we scale the search radius linearly based

on range from the radar, provided reorder_scale_xy_margin_with_range is TRUE.

Type: double

reorder_nominal_range_for_search_radius_km = 60;

reorder_z_search_ratio

Ratio of search in Z dimension with respect to the XY dimensions.

If this is 1.0, the search space around a grid point is effectively a

sphere. If this value is less than 1, then the search space is flattened, i.e. we look farther out in the XY directions than in the Z direction. This has the effect of reducing the ringing effect seen in data with higher gradients in Z than XY. If the value is greater than 1, the reverse applies.

Type: double

reorder_z_search_ratio = 1;

reorder_bound_grid_point_vertically

; Option to interpolate only if there is valid data both above and

below the grid point.

This enforces boundedness in the vertical coordinate. Essentially it

prevents extrapolation above the upper sweep and below the lowest sweep.

Type: boolean

reorder_bound_grid_point_vertically = FALSE;

reorder_min_valid_wt_ratio

Min ratio of valid weights to total weights.

In deciding whether a grid point should be marked as valid or

missing, we compute the ratio of the sum of the weights of the valid points over the weights of all points. If the ratio falls below this parameter, the point it marked as missing.

Type: double

reorder_min_valid_wt_ratio = 0.5;

reorder_blocks_nrows

; Number of rows in which grid is divided for computations, in the x

direction.

Reorder uses a K-dimensional tree for finding the closest radar

points to a selected Cartesian point. A kd-tree search slows down non-linearly as the number of points in the tree increases. To keep the number of points to reasonable values, we divide the grid into blocks, using the specified number of rows and columns. The tree will contain points in the block, plus some surrounding points to avoid edge effects. For computational efficieny the blocks should be approximately square in shape, so set nrows and ncols accordingly.

Type: int

reorder_blocks_nrows = 8;

reorder_blocks_ncols

; Number of columns in which grid is divided for computations, in the y

direction.

See reorder_search_nrows.

Type: int

reorder_blocks_ncols = 8;

reorder_min_nvalid_for_interp

Minimum Number of points used in the reorder interpolation.

This will make sure the number of points used for least squares fit

is sufficiently large. If this is too small the least squares fit becomes unstable and results become bad.

Type: int

reorder_min_nvalid_for_interp = 8;

reorder_weighted_interpolation

; Do the original weighted average reorder interpolation if set to

TRUE, do the least squares reorder interpolation if FALSE.

Type: boolean

reorder_weighted_interpolation = FALSE;

OPTION TO SET BOUNDS ON SELECTED FIELDS

bound_fields

If FALSE, no fields will be bounded.

Option to set limits on the values of some or all of the fields.

The parameters are set BEFORE interpolation, but the bound limits are

applied AFTER interpolation.

This only applies if 'interp_mode' is set to

INTERP_MODE_CART_REORDER. It can be a useful option since the linear-least-squares solution used by the REORDER interpolation can have unstable solutions that that lead to very out-of-range output values. This can in turn reduce the resolution of the output data if it is stored as a scaled integer.

Type: boolean

bound_fields = FALSE;

bounded_fields

Specify the list of fields to be constrained within bounds.

Only applies if 'bound_fields' is TRUE. At points where the output

value is out of bounds, it is set to missing.

NOTE: 'input_name' for this step refers to the 'input_name' in

'select_fields' and 'output_name' in 'transform_fields'. Setting the bounds on each field is performed prior to renaming fields (see below).

Type: struct

typedef struct {

string input_name; double min_value; double max_value;

}

1D array - variable length.

bounded_fields = {

input_name = "DBZ",

min_value = -50,

max_value = 100

input_name = "VEL",

min_value = -50,

max_value = 50

};