MODE

MODE finds coherent features — blobs of rain, areas of cloud, regions of convection — in a forecast field and an observation field, then compares those features as whole objects: where they sit, how big they are, what shape they take, and how intense they are. That is much closer to how a human looks at a map and says “the forecast put the storm too far north and made it too small” than a cell-by-cell score ever could.

Why object-based verification

Traditional grid-to-grid verification compares the forecast and the observation at every grid point independently and tallies the agreement. That works, but it punishes a forecast harshly for small displacement errors: a perfectly shaped storm placed one grid box too far east can score as badly as no storm at all, because the hits and misses are counted point by point. This is sometimes called the “double penalty” problem — a feature in the wrong place is penalized once for being absent where it should be and again for being present where it should not.

MODE — the Method for Object-based Diagnostic Evaluation — takes a different view. It identifies coherent spatial structures (which it calls objects) in each field and compares them as objects. Instead of “did grid cell (i, j) match?” it asks “did the forecast produce a feature near the observed feature, of roughly the right size, shape, orientation, and intensity?” The MET documentation frames MODE as a way to provide diagnostic information that is more directly useful and meaningful than traditional scores, especially for high-resolution NWP output where small-scale detail is exactly what gets double-penalized.

It is used by verification specialists, operational forecasters, and researchers. Though it was originally built for precipitation, the method generalizes to any field with coherent spatial structure — clouds, convection, reflectivity, and similar.

Jargon, defined once

Object: a connected region of the field that exceeds a threshold after smoothing. Simple object: a single such region. Cluster object: one or more simple objects in one field grouped together because they collectively match something in the other field. Field: one gridded variable at one level (e.g. 1-hour accumulated precipitation).

The MODE pipeline

Conceptually MODE runs the same five stages on the forecast field and the observation field, then brings the two together. The diagram below traces a raw field through smoothing and thresholding into objects, then sets the forecast objects beside the observation objects and draws the matching link that the fuzzy-logic engine computes.

Figure 1. A raw, speckly field is smoothed with a convolution radius R and thresholded at T to produce objects. The same runs on the forecast and observation fields. The fuzzy-logic engine scores each cross-field pair; a high total interest (here 0.92) matches forecast object F1 to observation object O1, while O2 has no partner above the threshold and is reported as unmatched.

The rest of this page walks the five stages: identify objects, measure their attributes, optionally merge objects within a field, match objects across fields, and write the outputs.

1 · Identifying objects — convolution thresholding

MODE takes two gridded inputs: a forecast field and an observation field (typically a gridded analysis), each a single variable at a single level, on a common grid. It turns each raw field into objects through a three-stage process called convolution thresholding.

1. Convolve (smooth). The raw field f is convolved with a circular filter to produce a smoother field C. The one tunable control here is the convolution radius conv_radius (in grid squares). The filter height is set automatically so the filter integrates to one (π R² H = 1). Smoothing reduces noise and joins nearby high values into coherent blobs.
2. Threshold. The convolved field is compared against the convolution threshold conv_thresh to build a binary mask M: 1 inside objects, 0 outside. Each connected region of M = 1 is one object. You can supply an array of thresholds to explore several object definitions in one run.
3. Restore values. The original raw values are restored inside the masked regions to form the object field F = M · f, so intensity information is preserved within each object’s boundary even though the boundary itself was decided on the smoothed field.

The documentation is explicit that just two parameters — the radius of influence R and the threshold T — control the entire process of resolving objects from the raw field. They are not independent: a larger radius gives smoother fields and larger, fewer objects; a larger threshold keeps only stronger signal and yields fewer or smaller objects; a smaller radius resolves finer detail and finds more small objects. Optional preprocessing — censor_thresh with censor_val to standardize raw values, and vld_thresh to govern missing data within the convolution area — can be applied before object definition so that forecast and observation are made compatible.

Choosing radius and threshold

The radius and threshold define what counts as a feature for your application, so tune them together, not in isolation. Start from the scale of the phenomenon you care about: a larger conv_radius merges nearby cells into bigger blobs and suppresses noise, while a higher conv_thresh isolates only the strongest cores. If you get a fog of tiny objects, raise the radius or the threshold; if real features fragment or vanish, lower them. Because you can pass arrays of thresholds, it is common to run several combinations and inspect the PostScript summary before settling on one.

2 · Object attributes

Once objects exist, MODE measures them. There are two families of attributes: single-object attributes that describe one object on its own, and pairwise attributes that describe a forecast object relative to an observation object. The pairwise ones are what the matching engine later turns into interest.

Single-object attributes

Attribute	What it captures	Output column(s)
Area	Size of the object, as a count of grid squares.	AREA, AREA_THRESH
Centroid	Geometric center — a single point standing in for an extended object (first-order moments).	CENTROID_X/_Y, CENTROID_LAT/_LON
Axis angle	Orientation or tilt of the object (second-order moments).	AXIS_ANG
Length & width	Dimensions of a fitted rectangle aligned to the object’s axis angle.	LENGTH, WIDTH
Aspect ratio	Width divided by length — how elongated the object is.	ASPECT_RATIO
Curvature	Radius of curvature, from third-order moments.	CURVATURE, CURVATURE_X/_Y
Complexity	How non-convex (ragged) the shape is: object-vs-convex-hull area difference, scaled.	COMPLEXITY
Intensity percentiles	10th, 25th, 50th, 75th, 90th percentiles of raw values inside the object, plus a user-chosen percentile and the intensity sum.	INTENSITY_10/_25/_50/_75/_90, INTENSITY_NN, INTENSITY_SUM

Pairwise (forecast-vs-observation) attributes

Attribute	What it captures	Output column
Centroid distance	Vector distance between the two objects’ centroids — the displacement error.	CENTROID_DIST
Boundary distance	Minimum distance between the objects’ boundaries.	BOUNDARY_DIST
Convex hull distance	Minimum distance between the objects’ convex hulls.	CONVEX_HULL_DIST
Angle difference	Difference in axis angle (orientation mismatch).	ANGLE_DIFF
Aspect difference	Difference in aspect ratio.	ASPECT_DIFF
Area ratio	Forecast object area divided by observation object area.	AREA_RATIO
Intersection / union / symmetric difference	Overlap geometry: area inside both, area inside either, and area in exactly one.	INTERSECTION_AREA, UNION_AREA, SYMMETRIC_DIFF
Intersection over area	Intersection divided by the lesser of the two object areas — a normalized overlap.	INTERSECTION_OVER_AREA
Curvature / complexity ratios	Shape-comparison ratios between the paired objects.	CURVATURE_RATIO, COMPLEXITY_RATIO
Percentile intensity ratio	Ratio of a chosen intensity percentile between the objects.	PERCENTILE_INTENSITY_RATIO
Interest	The total interest value (0–1) — thresholded to decide a match.	INTEREST

3 · Merging objects within a field

Sometimes what is meteorologically “one feature” gets split into several objects by the thresholding step — a single storm complex broken into two blobs, say. Merging rejoins objects within a single field before they are matched across fields. MODE offers two mechanisms, selected with the merge_flag configuration entry:

Double thresholding (merge_flag = THRESH) — A second, lower threshold merge_thresh is applied alongside the main conv_thresh. Objects that are separate at the higher threshold but joined at the lower one are merged. The thresholds must be chosen so the lower-threshold objects fully contain the originally defined objects.

Fuzzy-engine merging (merge_flag = ENGINE) — The same interest machinery used for cross-field matching is turned inward: each object is compared against its neighbors in the same field, and objects whose interest exceeds the threshold are merged.

The merge_flag values are NONE (no merging), THRESH, ENGINE, and BOTH (apply both techniques).

4 · Matching & total interest

This is the heart of MODE. To decide whether a forecast object corresponds to an observation object, MODE runs a fuzzy-logic engine that blends the pairwise attributes into one number between 0 and 1: the total interest. The idea of fuzzy logic here is that “match” is not a hard yes/no on any single attribute — a pair can be a little too far apart but very similar in size and shape, and still be a good match overall.

How total interest is built

1. Map each attribute to an interest value. Every pairwise attribute is passed through an interest function (interest_function) — a piecewise-linear curve that returns a value from 0 to 1. For example, the default interest function for centroid distance is near 1 for small distances and falls toward 0 as the distance grows.
2. Weight it by confidence. A confidence map reflects how trustworthy the attribute is for this pair. Most default to 1.0; the axis-angle confidence varies with aspect ratio, because a nearly circular object has no well-defined orientation, so its angle should count for little.
3. Weight it by importance. Each attribute also has an empirical weight from the weight configuration block, expressing how much that attribute should matter relative to the others.
4. Combine. Total interest is the confidence- and weight-weighted average of the per-attribute interests — a single normalized score for the pair.

The attributes that feed the weight and interest_function blocks include centroid_dist, boundary_dist, convex_hull_dist, angle_diff, aspect_diff, area_ratio, int_area_ratio, curvature_ratio, complexity_ratio, and the intensity terms inten_perc_ratio / inten_perc_value.

Figure 2. Each pairwise attribute passes through its interest function to a value in 0–1, then attributes are blended by their weights wᵢ and confidences Cᵢ into one total interest. Pairs scoring above total_interest_thresh (default 0.7) are matched.

The match decision

The total interest is compared against total_interest_thresh (range 0–1, default 0.7). Object pairs scoring above it are matched; those below remain unmatched. A computational shortcut, max_centroid_dist, skips the full pairwise computation for objects whose centroids are so far apart that they have no chance of matching.

When matches are formed, MODE groups them into cluster objects: any set of one or more simple objects in one field that matches a set in the other field. Even a single forecast object matched to a single observation object is reported as a cluster pair. The match_flag entry controls how overlapping matches are merged across fields, with values NONE, MERGE_BOTH, MERGE_FCST, and NO_MERGE (where each object matches at most one object in the other field).

5 · Outputs

MODE writes its results in three formats — ASCII statistics, NetCDF object fields, and a PostScript summary plot — with generation controlled by the flags ct_stats_flag, nc_pairs_flag, and ps_plot_flag.

ASCII statistics

Object attribute statistics file — The main results file: one row per object and per object pair, all with the same column layout (unused columns filled). Object-identifier conventions distinguish simple forecast and observation objects (FNN, ONN), simple pairs (FNNN_ONNN), and merged cluster objects and pairs (CFNNN, CONNN, CFNNN_CONNN). Single-object attributes occupy one block of columns; pairwise attributes (including INTEREST) occupy another.

Contingency table statistics file (CTS) — A traditional-statistics companion comparing the raw, thresholded, and object fields. It reports contingency-table counts FY_OY, FY_ON, FN_OY, FN_ON and derived scores such as PODY (probability of detecting “yes” events), POFD (probability of false detection), FAR (false alarm ratio), CSI (critical success index), GSS (Gilbert skill score), and HSS (Heidke skill score). Disable with ct_stats_flag.

NetCDF object fields

A NetCDF file holds the gridded object information: raw fields (fcst_raw, obs_raw), restored values inside objects (fcst_obj_raw, obs_obj_raw), per-grid-point simple object indices (fcst_obj_id, obs_obj_id) and cluster indices (fcst_clus_id, obs_clus_id), plus boundary and convex-hull polylines. nc_pairs_flag selects which components are written.

PostScript summary plot

A multi-page PostScript file gives the visual story. The summary page shows thumbnail tiles of the raw forecast and observation fields, the matched/merged object fields, and the object-index fields. Matching colors across the forecast and observation tiles mark matched pairs, black outlines within a field mark merged objects, and royal-blue objects are unmatched. The page also lists the object-definition and matching/merging criteria and a sorted list of total-interest values for the simple object pairs. Later pages enlarge the fields, overlay forecast objects against observation outlines (and vice versa), and summarize cluster pairs.

Ecosystem links

MODE’s gridded and statistical output is plotted by METplotpy and can be explored interactively in METviewer. To summarize object statistics across many cases — building distributions of displacement, area ratio, and the like over a whole verification period — pass the object attribute files to MODE-Analysis (mode_analysis). To follow objects through time as 3D space-time features rather than snapshots, use MODE Time Domain (MTD / mode-td).

Running MODE

1. Prepare two gridded fields. A forecast field and an observation field for the same variable, level, and valid time, on a common grid (regrid first if they differ).
2. Set object definition. In the configuration, choose conv_radius and conv_thresh (optionally arrays) for each field, plus any censor_thresh/vld_thresh preprocessing.
3. Configure merging and matching. Pick merge_flag (and merge_thresh if double thresholding), set the attribute weight and interest_function blocks, and the total_interest_thresh and match_flag.
4. Run MODE and read the outputs. Inspect the PostScript summary to sanity-check object definition and matching, then use the ASCII attribute file (and CTS, NetCDF) for quantitative analysis downstream.

Derived guide — verify exact config names

Parameter names, defaults (such as the 0.7 interest threshold), and output column lists here summarize the MET User’s Guide for readability. Before relying on a specific configuration entry or column in production, confirm it against the official MODE documentation for your exact MET version, since details can change between releases.

Where MODE fits

MODE is one of MET’s spatial verification tools. It complements grid-to-grid tools like Grid-Stat by trading exact point matching for feature-level diagnosis, which is especially valuable for high-resolution forecasts. Its object statistics are the raw material for aggregation (MODE-Analysis), temporal extension (MTD), plotting (METplotpy), and interactive exploration (METviewer).

---

A derived, human-readable re-presentation — not official documentation. Sources: MET User’s Guide — MODE