WRF-ARW Modeling System

https://github.com/wrf-model/wrf
Admin
WRF-ARW is an open-source atmospheric modeling system for weather research and forecasting...
Tokens:87,818
Snippets:555
Trust Score:7.2
Update:8 months ago
Show doc for...
Tokens:
Raw
### Setup WRF Model Namelist README File (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_b_wave/CMakeLists.txt

Copies the README.namelist file from the run directory to the specified destination path. This makes the namelist documentation available in the installed test directory.

```cmake
wrf_setup_files( 
                FILES     ${PROJECT_SOURCE_DIR}/run/README.namelist
                DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                )
```

--------------------------------

### Setup WRF Model Targets with Symlinks (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_b_wave/CMakeLists.txt

Sets up build targets for 'ideal' and 'wrf' with symbolic links. The targets are placed in a destination path derived from the installation prefix and the folder name.

```cmake
wrf_setup_targets(
                  TARGETS   ideal wrf
                  DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                  USE_SYMLINKS
                  )
```

--------------------------------

### Setup WRF Model Runtime Files for Installation (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_quarter_ss/CMakeLists.txt

This CMake function installs essential runtime data files for the WRF model to a specified destination path. These files are necessary for the model to run correctly after installation.

```cmake
wrf_setup_files( 
                FILES
                  ${PROJECT_SOURCE_DIR}/run/README.namelist
                  ${PROJECT_SOURCE_DIR}/run/bulkdens.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/bulkradii.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/capacity.asc
                  ${PROJECT_SOURCE_DIR}/run/coeff_p.asc
                  ${PROJECT_SOURCE_DIR}/run/coeff_q.asc
                  ${PROJECT_SOURCE_DIR}/run/constants.asc
                  ${PROJECT_SOURCE_DIR}/run/kernels.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/kernels_z.asc
                  ${PROJECT_SOURCE_DIR}/run/masses.asc
                  ${PROJECT_SOURCE_DIR}/run/termvels.asc
                DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                )
```

--------------------------------

### Setup WRF Data Files for Installation (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_convrad/CMakeLists.txt

Installs essential WRF data files, such as namelist README, land use tables, and radiation data, to a designated destination path. This ensures the model has the necessary data to run.

```cmake
wrf_setup_files( 
                FILES
                  ${PROJECT_SOURCE_DIR}/run/README.namelist
                  ${PROJECT_SOURCE_DIR}/run/LANDUSE.TBL
                  ${PROJECT_SOURCE_DIR}/run/RRTMG_LW_DATA
                  ${PROJECT_SOURCE_DIR}/run/RRTMG_SW_DATA
                  ${PROJECT_SOURCE_DIR}/run/ozone.formatted
                  ${PROJECT_SOURCE_DIR}/run/ozone_lat.formatted
                  ${PROJECT_SOURCE_DIR}/run/ozone_plev.formatted
                DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                )
```

--------------------------------

### Setup WRF Configuration Files (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_scm_xy/CMakeLists.txt

Configures and installs essential WRF model configuration files to a specified destination path. This ensures that necessary tables and data files are available for model execution.

```cmake
wrf_setup_files( 
                FILES
                  ${PROJECT_SOURCE_DIR}/run/README.namelist
                  ${PROJECT_SOURCE_DIR}/run/GENPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/LANDUSE.TBL
                  ${PROJECT_SOURCE_DIR}/run/SOILPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/VEGPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/RRTM_DATA
                DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                )
```

--------------------------------

### Install WRF Executables and Files using CMake

Source: https://github.com/wrf-model/wrf/blob/master/test/em_real/CMakeLists.txt

This snippet demonstrates how to use CMake to install WRF executable targets and various data/parameter files. It defines installation directories, excludes specific files from installation, and sets up symbolic links for executables. Dependencies include CMake and custom WRF macros.

```cmake
get_filename_component( FOLDER_DEST ${CMAKE_CURRENT_SOURCE_DIR} NAME )

install(
        DIRECTORY   ${CMAKE_CURRENT_SOURCE_DIR}
        DESTINATION ${CMAKE_INSTALL_PREFIX}/test/
        PATTERN CMakeLists.txt EXCLUDE
        PATTERN .gitignore     EXCLUDE
        )
wrf_setup_targets(
                  TARGETS         real tc ndown wrf
                  DEST_PATH       ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                  USE_SYMLINKS
                  )

wrf_setup_files( 
                FILES
                  ${PROJECT_SOURCE_DIR}/run/README.namelist
                  ${PROJECT_SOURCE_DIR}/run/README.physics_files
                  ${PROJECT_SOURCE_DIR}/run/README.physics_files

                  ${PROJECT_SOURCE_DIR}/run/ETAMPNEW_DATA
                  ${PROJECT_SOURCE_DIR}/run/ETAMPNEW_DATA.expanded_rain
                  ${PROJECT_SOURCE_DIR}/run/RRTM_DATA
                  ${PROJECT_SOURCE_DIR}/run/RRTMG_LW_DATA
                  ${PROJECT_SOURCE_DIR}/run/RRTMG_SW_DATA
                  ${PROJECT_SOURCE_DIR}/run/CAM_ABS_DATA
                  ${PROJECT_SOURCE_DIR}/run/CAM_AEROPT_DATA
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.RCP4.5
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.RCP6
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.RCP8.5
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.A1B
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.A2
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP119
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP126
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP245
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP370
                  ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP585
                  ${PROJECT_SOURCE_DIR}/run/CLM_ALB_ICE_DFS_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_ALB_ICE_DRC_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_ASM_ICE_DFS_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_ASM_ICE_DRC_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_DRDSDT0_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_EXT_ICE_DFS_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_EXT_ICE_DRC_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_KAPPA_DATA
                  ${PROJECT_SOURCE_DIR}/run/CLM_TAU_DATA
                  ${PROJECT_SOURCE_DIR}/run/ozone.formatted
                  ${PROJECT_SOURCE_DIR}/run/ozone_lat.formatted
                  ${PROJECT_SOURCE_DIR}/run/ozone_plev.formatted
                  ${PROJECT_SOURCE_DIR}/run/aerosol.formatted
                  ${PROJECT_SOURCE_DIR}/run/aerosol_lat.formatted
                  ${PROJECT_SOURCE_DIR}/run/aerosol_lon.formatted
                  ${PROJECT_SOURCE_DIR}/run/aerosol_plev.formatted
                  ${PROJECT_SOURCE_DIR}/run/eclipse_besselian_elements.dat
                  ${PROJECT_SOURCE_DIR}/run/capacity.asc
                  ${PROJECT_SOURCE_DIR}/run/coeff_p.asc
                  ${PROJECT_SOURCE_DIR}/run/coeff_q.asc
                  ${PROJECT_SOURCE_DIR}/run/constants.asc
                  ${PROJECT_SOURCE_DIR}/run/masses.asc
                  ${PROJECT_SOURCE_DIR}/run/termvels.asc
                  ${PROJECT_SOURCE_DIR}/run/kernels.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/kernels_z.asc
                  ${PROJECT_SOURCE_DIR}/run/bulkdens.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/bulkradii.asc_s_0_03_0_9
                  ${PROJECT_SOURCE_DIR}/run/CCN_ACTIVATE.BIN
                  ${PROJECT_SOURCE_DIR}/run/p3_lookupTable_1.dat-v5.4_2momI
                  ${PROJECT_SOURCE_DIR}/run/p3_lookupTable_1.dat-v5.4_3momI
                  ${PROJECT_SOURCE_DIR}/run/p3_lookupTable_2.dat-v5.3
                  ${PROJECT_SOURCE_DIR}/run/HLC.TBL
                  ${PROJECT_SOURCE_DIR}/run/wind-turbine-1.tbl
                  ${PROJECT_SOURCE_DIR}/run/ishmael-gamma-tab.bin
                  ${PROJECT_SOURCE_DIR}/run/ishmael-qi-qc.bin
                  ${PROJECT_SOURCE_DIR}/run/ishmael-qi-qr.bin
                  ${PROJECT_SOURCE_DIR}/run/BROADBAND_CLOUD_GODDARD.bin
                  ${PROJECT_SOURCE_DIR}/run/STOCHPERT.TBL
                  
                  ${PROJECT_SOURCE_DIR}/run/GENPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/LANDUSE.TBL
                  ${PROJECT_SOURCE_DIR}/run/SOILPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/URBPARM.TBL
                  ${PROJECT_SOURCE_DIR}/run/URBPARM_LCZ.TBL
                  ${PROJECT_SOURCE_DIR}/run/VEGPARM.TBL
                  ${PROJECT_SOURCE_DIR}/phys/noahmp/parameters/MPTABLE.TBL
                  ${PROJECT_SOURCE_DIR}/run/tr49t67
                  )

```

--------------------------------

### Setup WRF Data Files

Source: https://github.com/wrf-model/wrf/blob/master/test/em_real/CMakeLists.txt

This CMake function is used to set up various data files for the WRF model. It copies files from the project source directory to a destination path within the installation prefix. The function handles GRIB map files and atmospheric data files.

```cmake
wrf_setup_file_new_name(
                        FILE      ${PROJECT_SOURCE_DIR}/run/tr49t85
                        DEST_PATH ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                        )

wrf_setup_file_new_name(
                        FILE      ${PROJECT_SOURCE_DIR}/run/tr67t85
                        DEST_PATH ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                        )

wrf_setup_file_new_name(
                        FILE      ${PROJECT_SOURCE_DIR}/run/gribmap.txt
                        DEST_PATH ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                        )

wrf_setup_file_new_name(
                        FILE      ${PROJECT_SOURCE_DIR}/run/grib2map.tbl
                        DEST_PATH ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                        )
```

--------------------------------

### Setup WRF Files

Source: https://github.com/wrf-model/wrf/blob/master/main/CMakeLists.txt

Installs specified WRF model files to a destination path. It takes a list of files and a destination directory as input. This is crucial for ensuring the model has necessary parameter and run-time files.

```cmake
wrf_setup_files(
                FILES
                  ${PROJECT_SOURCE_DIR}/phys/noahmp/parameters/MPTABLE.TBL
                DEST_PATH
                  ${CMAKE_INSTALL_PREFIX}/run/
                )
```

--------------------------------

### Install WRF Model Directories and Exclude Files (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_b_wave/CMakeLists.txt

Installs the current source directory to the destination path, excluding specific files like CMakeLists.txt and .gitignore. This ensures only necessary model files are deployed.

```cmake
get_filename_component( FOLDER_DEST ${CMAKE_CURRENT_SOURCE_DIR} NAME )

install(
        DIRECTORY   ${CMAKE_CURRENT_SOURCE_DIR}
        DESTINATION ${CMAKE_INSTALL_PREFIX}/test/
        PATTERN CMakeLists.txt EXCLUDE
        PATTERN .gitignore     EXCLUDE
        )
```

--------------------------------

### Install WRF Model Directories and Files

Source: https://github.com/wrf-model/wrf/blob/master/test/em_squall2d_x/CMakeLists.txt

Installs the current source directory to the destination path, excluding specific files like CMakeLists.txt and .gitignore. It also sets up symbolic links for WRF targets and installs README files.

```cmake
get_filename_component( FOLDER_DEST ${CMAKE_CURRENT_SOURCE_DIR} NAME )

install(
        DIRECTORY   ${CMAKE_CURRENT_SOURCE_DIR}
        DESTINATION ${CMAKE_INSTALL_PREFIX}/test/
        PATTERN CMakeLists.txt EXCLUDE
        PATTERN .gitignore     EXCLUDE
        )
wrf_setup_targets(
                  TARGETS   ideal wrf
                  DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                  USE_SYMLINKS
                  )

wrf_setup_files( 
                FILES     ${PROJECT_SOURCE_DIR}/run/README.namelist
                DEST_PATH  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}
                )
```

--------------------------------

### Setup WRF CAMtr Volume Mixing Ratio File

Source: https://github.com/wrf-model/wrf/blob/master/test/em_real/CMakeLists.txt

This CMake function sets up a specific atmospheric data file, 'CAMtr_volume_mixing_ratio.SSP245', for the WRF model. It renames the file to 'CAMtr_volume_mixing_ratio' in the installation directory and supports the use of symbolic links.

```cmake
wrf_setup_file_new_name(
                        FILE      ${PROJECT_SOURCE_DIR}/run/CAMtr_volume_mixing_ratio.SSP245
                        NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/CAMtr_volume_mixing_ratio
                        USE_SYMLINKS
                        )
```

--------------------------------

### List Git Variables

Source: https://github.com/wrf-model/wrf/wiki/Useful-Git-Commands

Lists all git variables for the current repository, providing insights into configuration, origin, and user details. This command is useful for understanding the repository's setup and user-specific settings.

```bash
git var -l
```

--------------------------------

### Installing WRF Include Files (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/frame/CMakeLists.txt

This CMake `install` command specifies that the header files listed in `WRF_INCLUDE_FILES` should be installed. They will be placed in the `include/${FOLDER_COMPILE_TARGET}` directory relative to the installation prefix.

```cmake
install (
        FILES       ${WRF_INCLUDE_FILES}
        DESTINATION include/${FOLDER_COMPILE_TARGET}
        )
```

--------------------------------

### Count Total WRF Builds

Source: https://github.com/wrf-model/wrf/wiki/Automated-Jenkins-Testing

This `grep` command counts the total number of builds attempted by filtering for lines starting with ' START' and excluding lines with 'CLEAN START'. The `-a` option ensures binary files are treated as text.

```bash
grep -a " START" * | grep -av "CLEAN START" | wc -l
```

--------------------------------

### Install WRF Executable (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/tools/CMakeLists.txt

This CMake snippet defines the installation rules for the compiled WRF executable and its associated libraries. It specifies the destination directories for runtime binaries, archives, and libraries.

```cmake
install(
        TARGETS ${FOLDER_COMPILE_TARGET}
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )
```

--------------------------------

### Configure and Build WRF-Hydro Coupling

Source: https://context7.com/wrf-model/wrf/llms.txt

Enables WRF-Hydro coupling by setting environment variables, configuring, compiling WRF, and copying necessary WRF-Hydro files to the run directory. Requires WRF and WRF-Hydro installations.

```bash
# Set environment variables before configure
setenv WRF_HYDRO 1
setenv HYDRO_D 1           # Enable diagnostic output
setenv NETCDF_INC "$NETCDF/include"
setenv NETCDF_LIB "$NETCDF/lib"

# Configure and compile
./configure
./compile em_real

# Copy WRF-Hydro namelist and parameter files to run directory
cp hydro/Run/hydro.namelist test/em_real/
cp hydro/Run/*.TBL test/em_real/

# Edit hydro.namelist for your domain
cat hydro/Run/hydro.namelist
# Key settings:
#   HRLDAS_SETUP_FILE = path to high-res domain files
#   GEO_STATIC_FLNM = path to geo_em file
#   RESTART_FILE = path to restart file (for spinup)

```

--------------------------------

### Set WRF Include Files and Install Headers (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/external/ioapi_share/CMakeLists.txt

This snippet configures the WRF build process using CMake. It defines a list of header files to be included and specifies their installation destination. The `get_filename_component` command extracts the target folder name, and `set` defines the include files. The `install` command then places these files into the correct directory structure.

```cmake
get_filename_component( FOLDER_COMPILE_TARGET ${CMAKE_CURRENT_SOURCE_DIR} NAME)
set( 
    WRF_INCLUDE_FILES
    wrf_io_flags.h
    wrf_status_codes.h
    )

install( 
        FILES       ${WRF_INCLUDE_FILES}
        DESTINATION include/external/${FOLDER_COMPILE_TARGET}
        )
```

--------------------------------

### Configure WRF Domains and Nesting (Fortran)

Source: https://context7.com/wrf-model/wrf/llms.txt

Defines the domain configuration for WRF simulations, including grid dimensions, spacing, vertical levels, and nesting parameters. This setup is crucial for defining the simulation area and resolution, as well as how nested domains interact with parent domains.

```fortran
&domains
 ! Time step (seconds) - recommend 6*dx(km) for stability
 time_step                           = 180,    ! 30km domain
 time_step_fract_num                 = 0,
 time_step_fract_den                 = 1,

 ! Number of domains
 max_dom                             = 2,

 ! Grid dimensions (staggered)
 e_we                                = 150, 451,   ! West-East
 e_sn                                = 130, 361,   ! South-North
 e_vert                              = 45,  45,    ! Vertical levels

 ! Grid spacing (meters)
 dx                                  = 30000, 10000,
 dy                                  = 30000, 10000,

 ! Vertical coordinate
 p_top_requested                     = 5000,       ! Model top (Pa)

 ! Vertical level distribution (auto_levels_opt=2)
 auto_levels_opt                     = 2,
 dzbot                               = 50.,        ! Bottom layer thickness (m)
 dzstretch_s                         = 1.3,        ! Surface stretch factor
 dzstretch_u                         = 1.1,        ! Upper stretch factor
 max_dz                              = 1000.,      ! Max layer thickness (m)

 ! Nesting parameters
 grid_id                             = 1,     2,
 parent_id                           = 0,     1,
 i_parent_start                      = 1,     50,
 j_parent_start                      = 1,     40,
 parent_grid_ratio                   = 1,     3,
 parent_time_step_ratio              = 1,     3,
 feedback                            = 1,          ! Nest-to-parent feedback
 smooth_option                       = 2,          ! Smoothing for feedback

 ! Input data levels
 num_metgrid_levels                  = 34,
 num_metgrid_soil_levels             = 4,
/
```

--------------------------------

### Configure WRF Environment Variables (Bash)

Source: https://github.com/wrf-model/wrf/blob/master/doc/README.cygwin.md

Sets essential environment variables required by WRF to locate necessary libraries and configurations. This includes paths for NetCDF, HDF5, and optionally Jasper, as well as flags for large file support.

```bash
export NETCDF=/usr
export NETCDF4=1
export HDF5=/usr
# Optional: export JASPER=/usr JASPERLIB=/usr/lib JASPERINC=/usr/include
# Optional: export WRFIO_NCD_NO_LARGE_FILE_SUPPORT=0 NETCDF_classic=0
```

--------------------------------

### WRF Namelist: Initial Run Configuration

Source: https://github.com/wrf-model/wrf/wiki/How-to-Check-Bit-for-Bit-Results-with-Restart-Capability

Configures the `&time_control` section in `namelist.input` for an initial WRF model run. This setup ensures the model runs for 1 hour and generates restart files at 30-minute intervals. The `history_interval` is set to 60 minutes, and `restart_interval` to 30 minutes.

```fortran
&time_control
 run_days                       = 0,
 run_hours                      = 1,
 run_minutes                    = 0,
 start_year                     = 2017, 2017,
 start_month                    = 02,   02,
 start_day                      = 01,   01,
 start_hour                     = 00,   00,
 start_minutes                  = 00,   00,
 end_year                       = 2017, 2017,
 end_month                      = 02,   02,
 end_day                        = 01,   01,
 end_hour                       = 01,   01,
 history_interval               = 60,   60,
 frames_per_outfile.            = 1,    1,
 restart                        = .false.,
 restart_interval               = 30,

```

--------------------------------

### Inspect and Analyze WRF Output with Command-Line and Python

Source: https://context7.com/wrf-model/wrf/llms.txt

This snippet demonstrates how to inspect WRF output files using `ncdump` to view metadata and `ncks` to extract specific variables. It also includes a Python example using the `wrf-python` library to open WRF output files, extract variables with proper destaggering, and interpolate data to specific pressure levels.

```bash
# View WRF output with ncdump
ncdump -h wrfout_d01_2019-09-04_12:00:00

# Extract specific variables
ncks -v T2,PSFC,U10,V10 wrfout_d01_2019-09-04_12:00:00 subset.nc

# Convert to GrADS format using ARWpost (separate package)
# or use wrf-python for analysis:

# Python analysis example
python << 'EOF'
from netCDF4 import Dataset
import wrf

# Open WRF output
ncfile = Dataset("wrfout_d01_2019-09-04_12:00:00")

# Extract variables with proper destaggering
t2 = wrf.getvar(ncfile, "T2")           # 2m temperature
slp = wrf.getvar(ncfile, "slp")         # Sea level pressure
ua = wrf.getvar(ncfile, "ua")           # U-wind destaggered
va = wrf.getvar(ncfile, "va")           # V-wind destaggered
dbz = wrf.getvar(ncfile, "dbz")         # Reflectivity

# Interpolate to pressure levels
p_levels = [850, 700, 500, 300]
ht_850 = wrf.interplevel(wrf.getvar(ncfile, "z"),
                         wrf.getvar(ncfile, "pressure"), 850)
EOF

```

--------------------------------

### Navigate to WRF Output Directory

Source: https://github.com/wrf-model/wrf/wiki/Automated-Jenkins-Testing

After decompressing the output archive, this command navigates the user into the newly created `output_testcase` directory, where the analysis files are located.

```bash
cd output_testcase
```

--------------------------------

### List WRF Output Files

Source: https://github.com/wrf-model/wrf/wiki/Automated-Jenkins-Testing

This command lists the contents of the `output_testcase` directory, displaying file details such as permissions, owner, size, and modification date. It helps in understanding the available output files.

```bash
ls -ls
```

--------------------------------

### Configure WRF Build with configure Script

Source: https://context7.com/wrf-model/wrf/llms.txt

The `configure` script interactively sets up the WRF build environment. It requires setting the NetCDF library path and optionally enables WRF-Hydro or chemistry. Users select compilers (GNU, Intel, PGI) and parallelism options (serial, OpenMP, MPI, hybrid).

```bash
# Set NetCDF library path (required)
setenv NETCDF /usr/local/netcdf-pgi

# Optional: Enable WRF-Hydro coupling
setenv WRF_HYDRO 1

# Optional: Enable chemistry
setenv WRF_CHEM 1

# Run configure and select compiler/parallelism options
./configure

# Output: Select from numbered options like:
#   1. GNU (gfortran/gcc)
#   2. Intel (ifort/icc)
#   3. PGI (pgf90/pgcc)
# Then select: serial, smpar (OpenMP), dmpar (MPI), or dm+sm (hybrid)
```

--------------------------------

### Setup WRF Double Precision Data Files (Conditional)

Source: https://github.com/wrf-model/wrf/blob/master/test/em_real/CMakeLists.txt

This CMake code block conditionally sets up double-precision data files for the WRF model if the 'USE_DOUBLE' variable is true. It renames various atmospheric and radiative transfer model data files to their standard names in the installation directory.

```cmake
if ( ${USE_DOUBLE} )
  
  wrf_setup_file_new_name(
                          FILE      ${PROJECT_SOURCE_DIR}/run/ETAMPNEW_DATA_DBL
                          NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/ETAMPNEW_DATA
                          )
  wrf_setup_file_new_name(
                          FILE      ${PROJECT_SOURCE_DIR}/run/ETAMPNEW_DATA.expanded_rain_DBL
                          NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/ETAMPNEW_DATA.expanded_rain
                          )
  wrf_setup_file_new_name(
                          FILE      ${PROJECT_SOURCE_DIR}/run/RRTM_DATA_DBL
                          NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/RRTM_DATA
                          )
  wrf_setup_file_new_name(
                          FILE      ${PROJECT_SOURCE_DIR}/run/RRTMG_LW_DATA_DBL
                          NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/RRTMG_LW_DATA
                          )
  wrf_setup_file_new_name(
                          FILE      ${PROJECT_SOURCE_DIR}/run/RRTMG_SW_DATA_DBL
                          NEW_NAME  ${CMAKE_INSTALL_PREFIX}/test/${FOLDER_DEST}/RRTMG_SW_DATA
                          )
endif()
```

--------------------------------

### Real-Data Case Workflow for WRF Simulation

Source: https://context7.com/wrf-model/wrf/llms.txt

This outlines the typical workflow for running a WRF simulation with real meteorological data. It involves preparing input data using the WPS (WRF Preprocessing System) and then setting up the run directory by linking or copying the generated met_em files.

```bash
# 1. Prepare input data using WPS (WRF Preprocessing System)
# This produces met_em.d01.*

# 2. Navigate to run directory
cd test/em_real

# 3. Link or copy met_em files from WPS
ln -sf /path/to/wps/met_em.d01.* .
```

--------------------------------

### Install WRF Core Target (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/CMakeLists.txt

Installs the WRF core target to specified runtime, archive, and library destinations. This ensures that the compiled core components are placed correctly in the installation directory structure.

```cmake
set( CONFIG_INSTALL_DIRECTORY lib/cmake/${PROJECT_NAME} )
install(
        TARGETS ${PROJECT_NAME}_Core
        EXPORT ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )
```

--------------------------------

### Configure WRF Build with CMake (configure_new)

Source: https://context7.com/wrf-model/wrf/llms.txt

The `configure_new` script utilizes CMake for a more flexible build configuration. It can be run interactively or with advanced options to preselect compilers, skip prompts, specify build/install directories, and pass options directly to CMake.

```bash
# Basic configuration - follows interactive prompts
./configure_new

# Advanced: Preselect GNU compiler, skip prompts, specify options directly
./configure_new -p GNU -x -- -DWRF_CORE=ARW -DWRF_NESTING=BASIC -DWRF_CASE=EM_REAL

# Use alternate build and install directories
./configure_new -d _buildCustom -i /opt/wrf/install

# Configuration options:
#   -p <pattern>   Preselect stanza by description (e.g., "GNU", "Intel")
#   -x             Skip interactive prompts
#   -d <dir>       Alternate build directory (default: _build/)
#   -i <dir>       Alternate install directory (default: $PWD/install)
#   -- <cmake>     Pass options directly to CMake
```

--------------------------------

### Create WRF Executable

Source: https://github.com/wrf-model/wrf/blob/master/chem/KPP/kpp/kpp-2.1/CMakeLists.txt

This snippet creates the main executable target named 'kpp'. It lists all the source files required for the executable, including those generated by FLEX and BISON, along with various C source files.

```cmake
add_executable(
                kpp
                ${FLEX_kpp_lex_OUTPUTS}
                ${BISON_kpp_tab_OUTPUTS}
                src/scanner.c
                src/scanutil.c
                src/kpp.c
                src/gen.c
                src/code.c
                src/code_c.c
                src/code_f77.c
                src/code_f90.c
                src/code_matlab.c
                src/debug.c
                )
```

--------------------------------

### Generate and Install WRF Package Config Files (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/CMakeLists.txt

Generates and installs the main package configuration file (`Config.cmake`) and its version file (`ConfigVersion.cmake`) for the WRF project. These files are crucial for CMake's package management system to locate and use the installed WRF build.

```cmake
configure_package_config_file(
                              ${PROJECT_SOURCE_DIR}/cmake/template/${EXPORT_NAME}Config.cmake.in
                              ${CMAKE_BINARY_DIR}/${EXPORT_NAME}Config.cmake
                              INSTALL_DESTINATION ${CONFIG_INSTALL_DIRECTORY}
                              )

write_basic_package_version_file(
                                  ${CMAKE_BINARY_DIR}/${EXPORT_NAME}ConfigVersion.cmake
                                  VERSION ${PROJECT_VERSION}
                                  #!TODO Check if this is the type of versioning support we want to use
                                  COMPATIBILITY SameMinorVersion
                                  )

install(
        FILES
          ${CMAKE_BINARY_DIR}/${EXPORT_NAME}Config.cmake
          ${CMAKE_BINARY_DIR}/${EXPORT_NAME}ConfigVersion.cmake
        DESTINATION ${CONFIG_INSTALL_DIRECTORY}
        )
```

--------------------------------

### Run KPP Model to Generate Fortran Files (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/chem/KPP/CMakeLists.txt

This CMake script snippet configures a custom command to execute the KPP model for a given mechanism. It sets the KPP home directory, defines a working directory for the mechanism, copies mechanism files, and then invokes the KPP executable. The output includes generated Fortran source files for parameters, precision, Jacobian, and integrator. Dependencies are managed to ensure KPP is built before its generated files are used.

```cmake
set( KPP_HOME ${CMAKE_CURRENT_SOURCE_DIR}/kpp/kpp-2.1 )

set( KPP_WORKING_DIR ${CMAKE_CURRENT_BINARY_DIR}/mechanisms/${MECH} )
file( COPY ${CMAKE_CURRENT_SOURCE_DIR}/mechanisms/${MECH}/ DESTINATION ${KPP_WORKING_DIR} )
set(
    ${MECH}_KPP_SOURCES
    ${KPP_WORKING_DIR}/${MECH}_Parameters.f90
    ${KPP_WORKING_DIR}/${MECH}_Precision.f90
    ${KPP_WORKING_DIR}/${MECH}_JacobianSP.f90
    ${KPP_WORKING_DIR}/${MECH}_Jacobian.f90
    ${KPP_WORKING_DIR}/${MECH}_Update_Rconst.f90
    )
set(
    ${MECH}_KPP_SOURCES_INTEGRATOR
    ${KPP_WORKING_DIR}/${MECH}_Integrator.f90
    )

add_custom_command(
                    OUTPUT
                      ${${MECH}_KPP_SOURCES}
                      ${${MECH}_KPP_SOURCES_INTEGRATOR}
                    COMMAND ${CMAKE_COMMAND} -E env KPP_HOME=${KPP_HOME} $<TARGET_FILE:kpp> ${MECH}.kpp > ${CMAKE_BINARY_DIR}/kpp_${MECH}.log 2>&1
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_Integrator.f90     ${KPP_WORKING_DIR}/${MECH}_Integrator.f90
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_Parameters.f90     ${KPP_WORKING_DIR}/${MECH}_Parameters.f90
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_Precision.f90      ${KPP_WORKING_DIR}/${MECH}_Precision.f90
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_JacobianSP.f90     ${KPP_WORKING_DIR}/${MECH}_JacobianSP.f90
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_Jacobian.f90       ${KPP_WORKING_DIR}/${MECH}_Jacobian.f90
                    COMMAND ${CMAKE_COMMAND} -E compare_files ${KPP_WORKING_DIR}/${MECH}_Update_Rconst.f90  ${KPP_WORKING_DIR}/${MECH}_Update_Rconst.f90
                    WORKING_DIRECTORY ${KPP_WORKING_DIR}
                    DEPENDS kpp
                    )
add_custom_target(
                    ${MECH}_kpp
                    COMMENT "[KPP] Generating kpp files for ${MECH}"
                    DEPENDS
                      ${${MECH}_KPP_SOURCES}
                      ${${MECH}_KPP_SOURCES_INTEGRATOR}
                    )

add_dependencies( ${PROJECT_NAME}_Core ${MECH}_kpp )
target_sources( ${PROJECT_NAME}_Core PRIVATE ${${MECH}_KPP_SOURCES} )
```

--------------------------------

### Install WRF Target (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/external/fftpack/fftpack5/CMakeLists.txt

This CMake code defines the installation rules for the WRF target library. It specifies the export name for targets and sets the destination directories for runtime, archive, and library files.

```cmake
install(
        TARGETS ${FOLDER_COMPILE_TARGET}
        EXPORT  ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )

```

--------------------------------

### Install WRF Targets using CMake

Source: https://github.com/wrf-model/wrf/blob/master/external/io_netcdf/CMakeLists.txt

Defines the installation rules for the built WRF targets. It specifies the destination directories for runtime files, archives, and libraries, ensuring proper deployment of the compiled model components.

```cmake
install(
        TARGETS ${FOLDER_COMPILE_TARGET} ${DIFFWRF_TARGET}
        EXPORT  ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/ 
        ARCHIVE DESTINATION lib/ 
        LIBRARY DESTINATION lib/ 
        )
```

--------------------------------

### Install WRF Helper CMake Modules (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/CMakeLists.txt

Installs helper CMake files and scripts into the `share` directory, categorized under a 'helpers' component. This makes utility CMake scripts available for use in other projects that depend on this WRF build.

```cmake
# Install some helper files for anyone using this build as part of their code
install(
        DIRECTORY
          # Trailing / is important
          ${PROJECT_SOURCE_DIR}/cmake/modules/
        COMPONENT       helpers
        DESTINATION     share
        FILES_MATCHING
          PATTERN       "*.cmake"
        )
install(
        FILES
          ${PROJECT_SOURCE_DIR}/cmake/confcheck.cmake
          ${PROJECT_SOURCE_DIR}/cmake/gitinfo.cmake
          ${PROJECT_SOURCE_DIR}/cmake/printOption.cmake
          ${PROJECT_SOURCE_DIR}/cmake/wrf_get_version.cmake
        COMPONENT     helpers
        DESTINATION   share
        )
```

--------------------------------

### Configure Build Options and Subdirectories in CMake

Source: https://github.com/wrf-model/wrf/blob/master/hydro/CMakeLists.txt

This snippet shows how to set compile options and definitions, and include sub-projects using CMake. It conditionally adds definitions and subdirectories based on the WRF_HYDRO_NUDGING variable.

```cmake
add_compile_options( "${PROJECT_COMPILE_OPTIONS}" )
add_compile_definitions( "${PROJECT_COMPILE_DEFINITIONS}" )
set(CMAKE_Fortran_MODULE_DIRECTORY ${PROJECT_BINARY_DIR}/hydro/mods)
add_definitions(-DMPP_LAND)
if (WRF_HYDRO_NUDGING STREQUAL "1")
        add_definitions(-DWRF_HYDRO_NUDGING=1)
endif()

# build the various sup-projects
add_subdirectory("MPP")
add_subdirectory("utils")
add_subdirectory("IO")
add_subdirectory("OrchestratorLayer")
add_subdirectory("Debug_Utilities")
add_subdirectory("Routing/Overland")
add_subdirectory("Routing/Subsurface")
add_subdirectory("Routing/Reservoirs")
add_subdirectory("Data_Rec")
add_subdirectory("Routing")
add_subdirectory("HYDRO_drv")
add_subdirectory("CPL/WRF_cpl")

if (WRF_HYDRO_NUDGING STREQUAL "1")
        add_subdirectory("nudging")
        add_dependencies(hydro_routing hydro_nudging)
        add_dependencies(hydro_driver hydro_nudging)
endif()
```

--------------------------------

### Install WRF Library Targets with CMake

Source: https://github.com/wrf-model/wrf/blob/master/external/io_adios2/CMakeLists.txt

This snippet defines the installation rules for the WRF library targets using CMake. It specifies the destinations for runtime binaries, archives, and libraries, ensuring proper deployment of the built components.

```cmake
install(
        TARGETS ${FOLDER_COMPILE_TARGET}
        EXPORT  ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )
```

--------------------------------

### Recompiling Cygwin Packages with cygport (Bash)

Source: https://github.com/wrf-model/wrf/blob/master/doc/README.cygwin.md

Provides commands to recompile Cygwin packages using cygport, typically for resolving compilation issues related to library versions. It involves editing the .cygport file, then running cygport commands to build and install the package.

```bash
cygport ${package}.cygport download prep compile test install package
# If errors occur, fix them and re-run:
cygport ${package}.cygport compile test install package
```

--------------------------------

### Create and Switch Git Branches

Source: https://github.com/wrf-model/wrf/wiki/Making-a-change-in-multiple-commits

Demonstrates how to create a new Git branch for development and switch to it. This is a fundamental step for isolating changes and maintaining a clean project history. It assumes you have a local clone of the repository.

```bash
/Users/kavulich/WRFDA_REGTEST/WORKDIR/WRF/var/da/da_main>git checkout master
Switched to branch 'master'
Your branch is up-to-date with 'origin/master'.
/Users/kavulich/WRFDA_REGTEST/WORKDIR/WRF/var/da/da_main>git branch typo_fixes
/Users/kavulich/WRFDA_REGTEST/WORKDIR/WRF/var/da/da_main>git checkout typo_fixes
Switched to branch 'typo_fixes'
```

--------------------------------

### Extracting Recompiled Package Files (Bash)

Source: https://github.com/wrf-model/wrf/blob/master/doc/README.cygwin.md

A bash script to extract tar.xz archives of a recompiled package from the /usr/src directory. This is part of the manual process after recompiling a Cygwin package.

```bash
cd /
for name in /usr/src/${package}-${version}*/${package}-${version}*/dist/**.tar.xz;
do
    tar xaf ${name}
done
```

--------------------------------

### HDF5 Variable Info Inquiry (Not Implemented)

Source: https://github.com/wrf-model/wrf/blob/master/external/io_phdf5/INSTALL.htm

This snippet indicates that the function to get variable information for HDF5 format is not implemented in this version of the WRF model. It shows a placeholder write statement.

```Fortran
#ifdef HDF5
CASE ( IO_HDF5 )
write(*,*) "NOT IMPLEMENT at HDF5"
! CALL ext_hdf5_get_var_info ( Hndl , VarName , NDim , &
```

--------------------------------

### Set WRF Target Properties (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/external/io_pio/CMakeLists.txt

This CMake snippet configures properties for the WRF target library, specifically setting the Fortran module directory for installation and exporting these properties. It relies on `CMAKE_INSTALL_PREFIX` and `FOLDER_COMPILE_TARGET` variables.

```cmake
set_target_properties( 
                      ${FOLDER_COMPILE_TARGET} 
                        PROPERTIES
                          Fortran_MODULE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/${FOLDER_COMPILE_TARGET}
                          EXPORT_PROPERTIES        Fortran_MODULE_DIRECTORY
                      )
```

--------------------------------

### Compile WRF Executables with compile Script

Source: https://context7.com/wrf-model/wrf/llms.txt

The `compile` script builds WRF executables for various test cases and applications. It supports building for real-data cases (`em_real`), idealized test cases, WRFDA, and WRF-Plus. Parallel compilation and large file support can be enabled.

```bash
# List available compile targets
./compile

# Build for real-data cases (most common)
# Creates: main/wrf.exe, main/real.exe, main/ndown.exe, main/tc.exe
./compile em_real

# Build for idealized test cases
# Creates: main/wrf.exe, main/ideal.exe
./compile em_quarter_ss    # Quarter-circle supercell
./compile em_b_wave        # Baroclinic wave
./compile em_les           # Large-eddy simulation
./compile em_squall2d_x    # 2D squall line
./compile em_hill2d_x      # 2D flow over hill
./compile em_grav2d_x      # 2D gravity current
./compile em_heldsuarez    # Global Held-Suarez test
./compile em_tropical_cyclone  # Idealized tropical cyclone
./compile em_convrad       # Convective-radiative equilibrium
./compile em_scm_xy        # Single column model

# Build WRFDA (data assimilation)
./configure wrfda
./compile all_wrfvar

# Build WRF-Plus (adjoint/tangent linear model for 4DVAR)
./compile wrfplus

# Parallel compilation (use multiple processors)
setenv J "-j 8"
./compile em_real

# Enable large file support for output > 2GB (default since V3.9)
setenv WRFIO_NCD_LARGE_FILE_SUPPORT 1
./compile em_real
```

--------------------------------

### Define and Execute KPP Registry Generation (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/chem/KPP/util/wkc/CMakeLists.txt

This CMake code defines a custom command to generate registry files and interface sources for the KPP mechanism. It creates necessary directories, executes the registry generation command with expanded definitions, and includes commands to compare generated files and touch an output file. Dependencies include the folder compile target and registry file.

```cmake
get_directory_property( DIR_DEFS DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS )
wrf_expand_definitions( 
                        RESULT_VAR  REGISTRY_DEFS
                        DEFINITIONS ${DIR_DEFS}
                        )

add_custom_command(
                    OUTPUT
                      gen_${FOLDER_COMPILE_TARGET}
                      ${CMAKE_BINARY_DIR}/chem/kpp_mechanism_driver.F
                      ${KPP_INTERFACE_SOURCES}
                    WORKING_DIRECTORY
                      ${CMAKE_BINARY_DIR}
                    # Replicate what exists in project directory for registry
                    COMMAND
                      ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/Registry
                    COMMAND
                      ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/inc
                    COMMAND
                      ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/frame
                    COMMAND
                      $<TARGET_FILE:${FOLDER_COMPILE_TARGET}> ${REGISTRY_DEFS} ${REGISTRY_FILE} > ${CMAKE_BINARY_DIR}/${FOLDER_COMPILE_TARGET}.log 2>&1
                    ${KPP_INTERFACE_SOURCES_CMD_CHECK}
                    COMMAND
                      ${CMAKE_COMMAND} -E compare_files ${CMAKE_BINARY_DIR}/chem/kpp_mechanism_driver.F ${CMAKE_BINARY_DIR}/chem/kpp_mechanism_driver.F
                    COMMAND 
                      ${CMAKE_COMMAND} -E touch gen_${FOLDER_COMPILE_TARGET}
                    DEPENDS
                      ${FOLDER_COMPILE_TARGET}
                    )
```

--------------------------------

### Define and Build WRF Static Library with CMake

Source: https://github.com/wrf-model/wrf/blob/master/external/io_grib1/WGRIB/CMakeLists.txt

This CMake code defines a static library named after the current directory and compiles a list of C source files into it. It then configures the installation paths for the library artifacts.

```cmake
get_filename_component( FOLDER_COMPILE_TARGET ${CMAKE_CURRENT_SOURCE_DIR} NAME)

add_library(
            ${FOLDER_COMPILE_TARGET}
              STATIC
              )

target_sources(
                ${FOLDER_COMPILE_TARGET}
                PRIVATE
                  # wgrib_main.c # Driver
                  seekgrib.c
                  ibm2flt.c
                  readgrib.c
                  intpower.c
                  cnames.c
                  BDSunpk.c
                  flt2ieee.c
                  wrtieee.c
                  levels.c
                  PDStimes.c
                  missing.c
                  nceptable_reanal.c
                  nceptable_opn.c
                  ensemble.c
                  ombtable.c
                  ec_ext.c
                  gribtable.c
                  gds_grid.c
                  PDS_date.c
                  ectable_128.c
                  ectable_129.c
                  ectable_130.c
                  ectable_131.c
                  ectable_140.c
                  ectable_150.c
                  ectable_151.c
                  ectable_160.c
                  ectable_170.c
                  ectable_180.c
                  nceptab_129.c
                  dwdtable_002.c
                  dwdtable_201.c
                  dwdtable_202.c
                  dwdtable_203.c
                  cptectable_254.c
                  nceptab_130.c
                  nceptab_131.c
                  )

install(
        TARGETS ${FOLDER_COMPILE_TARGET}
        EXPORT  ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )
```

--------------------------------

### Show Commit Details and Diff

Source: https://github.com/wrf-model/wrf/wiki/Useful-Git-Commands

Displays the log message, author, date, and the text difference (diff) for a specified commit hash. This command is crucial for understanding the changes introduced by a particular commit and its context.

```bash
git show e005cab
```

--------------------------------

### Generate Dynamic Fortran Sources with wrf_c_preproc_fortran

Source: https://github.com/wrf-model/wrf/blob/master/frame/CMakeLists.txt

This snippet demonstrates the use of `wrf_c_preproc_fortran` to dynamically generate Fortran source files. It iterates to create `nl_set_n` and `nl_get_n` targets, processing `nl_access_routines.F` with specific include paths, definitions, and dependencies on `registry_code`. The generated files are placed in a pre-processing output directory.

```cmake
set( nl_dyn_source )
foreach( n RANGE 0 7 )
  
  wrf_c_preproc_fortran( 
                        TARGET_NAME     nl_set_${n}
                        OUTPUT_DIR      ${CMAKE_CURRENT_BINARY_DIR}/preproc/
                        EXTENSION       ".f90"
                        PREFIX          "nl_set_${n}_"
                        INCLUDES        ${CMAKE_CURRENT_SOURCE_DIR}
                                        ${CMAKE_BINARY_DIR}/inc
                        DEPENDENCIES    registry_code
                        DEFINITIONS     ${PROJECT_COMPILE_DEFINITIONS} NNN=${n} NL_set_ROUTINES
                        SOURCES         nl_access_routines.F
                        )
  wrf_c_preproc_fortran( 
                      TARGET_NAME     nl_get_${n}
                      OUTPUT_DIR      ${CMAKE_CURRENT_BINARY_DIR}/preproc/
                      EXTENSION       ".f90"
                      PREFIX          "nl_get_${n}_"
                      INCLUDES        ${CMAKE_CURRENT_SOURCE_DIR}
                                      ${CMAKE_BINARY_DIR}/inc
                      DEPENDENCIES    registry_code
                      DEFINITIONS     ${PROJECT_COMPILE_DEFINITIONS} NNN=${n} NL_get_ROUTINES
                      SOURCES         nl_access_routines.F
                      )

  add_dependencies( ${PROJECT_NAME}_Core nl_get_${n} nl_set_${n} )

  list(
        APPEND
        nl_dyn_source
        ${CMAKE_CURRENT_BINARY_DIR}/preproc/nl_set_${n}_nl_access_routines.f90
        ${CMAKE_CURRENT_BINARY_DIR}/preproc/nl_get_${n}_nl_access_routines.f90
        )

endforeach()
```

--------------------------------

### Export WRF Package Configuration (CMake)

Source: https://github.com/wrf-model/wrf/blob/master/CMakeLists.txt

Exports the CMake targets for the WRF package, creating configuration files (`.cmake`) that allow other projects to find and use the WRF build. This includes installing the target export file with a specified namespace.

```cmake
# Install to namespace
install(
        EXPORT      ${EXPORT_NAME}Targets
        DESTINATION ${CONFIG_INSTALL_DIRECTORY}
        FILE        ${EXPORT_NAME}Targets.cmake
        NAMESPACE   ${EXPORT_NAME}::
        )
```

--------------------------------

### Decompress WRF Output Archive

Source: https://github.com/wrf-model/wrf/wiki/Automated-Jenkins-Testing

This snippet shows how to decompress the `wrf_output.zip` file using the `unzip` command. It is a prerequisite for accessing the individual test output files.

```bash
unzip wrf_output.zip
```
Tokens:
Raw