METplus

The umbrella layer that drives MET and its companion tools from human-editable config files.

METplus is the top of the ecosystem. It does not compute statistics itself — it is a suite of Python wrappers that drive the Model Evaluation Tools (MET) and the companion packages from plain-text .conf files. It handles time looping, file finding, environment variables, and chaining individual tools into reproducible, end-to-end use cases. If you want a verification workflow you can re-run and share, you start here.

What METplus is

The official documentation calls METplus Wrappers “a Python scripting infrastructure for the MET tools.” In plain terms: MET (the Model Evaluation Tools) contains the actual verification math — the algorithms that turn forecasts and observations into statistics. METplus is the layer that sits above MET and runs it for you. It is, in the project’s own words, “a suite of Python wrappers and ancillary scripts” that wrap and orchestrate MET.

Crucially, METplus performs no statistical computation of its own. Every number still comes out of MET (or a companion package). What METplus contributes is the plumbing: it reads your configuration, figures out which input files to use, sets up the environment MET expects, loops over the times and forecast leads you asked for, runs each tool in order, and hands one tool’s output to the next.

Mental model

Think of MET as a box of precise instruments and METplus as the lab technician who sets each instrument up, runs them in the right order over every case in your study, and writes everything down so the run is reproducible.

Who uses it, and where it sits

METplus serves “the research and operational communities” — described as universities, governments, the private sector, and operational modeling and prediction centers — and is a core part of verifying the Unified Forecast System. In a verification workflow it sits at the top: a user edits a config, runs METplus, and METplus drives everything below it.

Why it exists

The documentation is explicit about the problem METplus solves. Before METplus, “users who had more complex verifications that required the use of more than one MET tool were faced with setting up multiple MET config files and creating some automation scripts.” Every multi-step study turned into a pile of bespoke shell glue that was hard to reproduce and hard to share.

METplus replaces that hand-rolled automation with a single, configuration-driven framework. The payoff is three things you do not have to build yourself:

Reproducibility

A run is fully described by its .conf files. Hand the configs to a colleague and they get the same workflow — no undocumented shell steps.

Time looping

Declare a range of valid or initialization times and a set of forecast leads once; METplus iterates over every case for you.

Tool chaining

String several MET tools into one ordered sequence so the output of one step feeds the input of the next.

The design is deliberately modular. As the docs put it, “Wrappers can be run individually, or as a group of wrappers that represent a sequence of MET processes. New wrappers can readily be added to the METplus Wrappers package due to this modular design.”

Architecture & the time loop

The flow is the same every time. You edit a .conf file. You launch run_metplus.py. The wrapper layer reads your configuration, and for each case in your time loop it drives the appropriate MET tools and companion packages, producing output files, plots, and database loads.

Figure 1. A user-edited .conf file drives run_metplus.py, which runs the METplus wrapper layer. Inside a loop over initialization/valid times and forecast leads, the wrappers orchestrate the MET tools and companion packages, producing output files, plots, and database loads.

The companion packages named in the diagram each play a distinct role: METcalcpy (statistical calculations), METplotpy (plotting), and METdataio (data input/output and database loading). METplus calls into them where a workflow needs derived statistics, figures, or a database load.

The dashed box is the heart of the value proposition: the time loop. You describe a study once — a span of dates and a list of forecast lead times — and METplus walks through every combination, running the same sequence of tools on each case so the result is consistent and reproducible.

The config-driven model

You drive METplus by editing plain-text .conf files and then running one script. The documentation describes a hierarchy of configuration files: built-in defaults that ship with METplus, overlaid by the config(s) you supply on the command line. METplus merges them, so your file only needs to state what differs.

1. Choose what runs. A process list names the sequence of wrappers (and therefore MET tools) to execute, in order — this is the recipe for your workflow.
2. Choose how to loop. Set LOOP_BY to control how METplus marches through your data. The docs state: “LOOP_BY = VALID or REALTIME to have METplus proceed through the data based on Valid Time” and “LOOP_BY = INIT or RETRO to have METplus proceed through the data based on Initialization Time.”
3. Set the time span and leads. Give a begin time, end time, and increment for the loop, plus the forecast lead times to evaluate. METplus expands these into the full set of cases.
4. Run it. Launch run_metplus.py with your config(s). METplus does the file finding, sets the environment variables MET expects, runs the tools, and writes the output.

See exactly what ran

After a run, METplus writes out the fully merged configuration it actually used (the documentation references a metplus_final.conf file). That single file captures every default and override in effect — a precise, shareable record of the run.

Config variable names

Exact variable names beyond LOOP_BY evolve between releases and are too numerous to enumerate here. Always confirm the spelling of time and process variables against the configuration glossary for your installed version before relying on them.

Wrapper categories

Each MET tool (and several companion capabilities) has a corresponding METplus wrapper. They group into a handful of broad categories. The table below shows representative wrappers in each — names map onto the underlying MET tools they drive. Treat this as an orientation map, not the complete catalog.

Category	What it does	Representative wrappers
Reformatting	Prepare and convert inputs into MET-ready forms before statistics run.	PCPCombine, RegridDataPlane, PB2NC, ASCII2NC, GenVxMask
Statistics	The core verification: compare forecasts against observations or analyses.	GridStat, PointStat, EnsembleStat, MODE, GridDiag
Tropical cyclone	Track and intensity verification and genesis for TC applications.	TCPairs, TCStat, TCGen, ExtractTiles
Diagnostics	Derived fields and time/space diagnostics over a series of cases.	SeriesAnalysis, TCRMW
Plotting	Turn statistics and fields into figures.	TCMPRPlotter, PlotDataPlane, PlotPointObs, CyclonePlotter
User-script	An escape hatch to run your own script inside the METplus time loop.	UserScript

Ecosystem link

The statistics wrappers drive MET; the plotting and diagnostics wrappers often call into the companion packages. See METplotpy for plotting and METcalcpy for the calculations behind many diagnostics.

Deep dives

Three places to go next, depending on whether you want to understand the wrappers, see real examples, or get a workflow running.

The Python wrappers → How each wrapper maps onto a MET tool, what it configures, and how to compose them into a process list.

Use cases & how to run them → Ready-made, end-to-end examples that chain tools into a complete verification — and how to run one.

Install, configure, run → Setting up METplus and MET, writing your first .conf, and launching run_metplus.py.

Where it sits in the ecosystem

METplus is the umbrella. It sits above MET — driving the engine that does the verification math — and ties the companion repositories into coordinated workflows. The documentation lists the integrated repositories as MET, METplus, METdataio, METcalcpy, METplotpy, and METviewer.

The METplus ecosystem

METplus orchestrates and connects: MET (the verification engine it drives), METdataio (data input/output and database loading), METviewer and METexpress (database-backed visualization), and METcalcpy and METplotpy (calculations and plotting). Output and database loads from a METplus run are what those visualization tools read.

Start at the ecosystem overview for a map of how all the pieces relate, or jump straight into getting started to run your first workflow.

---

A derived, human-readable re-presentation — not official documentation. Sources: METplus User’s Guide — Overview · Getting Started