WRF Pre-Processing System

https://github.com/wrf-model/wps
Admin
The WRF Pre-Processing System (WPS) is a collection of Fortran and C programs that prepares...
Tokens:163,130
Snippets:1,110
Trust Score:7.2
Update:8 months ago
Show doc for...
Tokens:
Raw
### File Installation and Packaging Configuration (CMake)

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

This CMake snippet details the installation process for various project files and the generation of package configuration files. It includes installing a shell script, exporting targets, creating configuration files (Config.cmake and ConfigVersion.cmake), and installing helper CMake modules.

```cmake
wrf_setup_files( 
                FILES
                  ${PROJECT_SOURCE_DIR}/link_grib.csh
                DEST_PATH
                  ${CMAKE_INSTALL_PREFIX}/bin
                USE_SYMLINKS
                )

install(
        EXPORT      ${EXPORT_NAME}Targets
        DESTINATION lib/cmake/
        FILE        ${EXPORT_NAME}Targets.cmake
        NAMESPACE   ${EXPORT_NAME}::
        )

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

write_basic_package_version_file(
                                  ${CMAKE_BINARY_DIR}/${EXPORT_NAME}ConfigVersion.cmake
                                  VERSION ${PROJECT_VERSION}
                                  COMPATIBILITY SameMinorVersion
                                  )

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

install(
        DIRECTORY
          ${PROJECT_SOURCE_DIR}/cmake/modules/
        COMPONENT       helpers
        DESTINATION     share
        FILES_MATCHING  
          PATTERN       "*.cmake"
        )
```

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

### Build Example Binaries with zlib (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/CMakeLists.txt

This CMake code defines and builds example executable binaries ('example', 'minigzip', 'example64', 'minigzip64') that link against the zlib library. It includes conditional compilation for 64-bit support using the '_FILE_OFFSET_BITS=64' flag and sets up CMake tests for these executables.

```cmake
#============================================================================
# Example binaries
#============================================================================

add_executable(example test/example.c)
target_link_libraries(example zlib)
add_test(example example)

add_executable(minigzip test/minigzip.c)
target_link_libraries(minigzip zlib)

if(HAVE_OFF64_T)
    add_executable(example64 test/example.c)
    target_link_libraries(example64 zlib)
    set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
    add_test(example64 example64)

    add_executable(minigzip64 test/minigzip.c)
    target_link_libraries(minigzip64 zlib)
    set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
endif()
```

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

### Libpng I/O Setup and Signature Handling

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Covers setting up the input/output functions for libpng, including using the default `fwrite` and handling the PNG signature.

```APIDOC
## Libpng I/O Setup and Signature Handling

### Description
This section explains how to configure libpng for writing data to a file or stream, including using standard I/O functions and optionally skipping the PNG signature.

### Method
N/A (Code examples)

### Endpoint
N/A (Code examples)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
// Initialize standard I/O with a FILE pointer
png_init_io(png_ptr, fp); 

// If you have already written the signature or are embedding the PNG
// inform libpng not to write its own signature.
png_set_sig_bytes(png_ptr, 8); 
```

### Response
#### Success Response (200)
N/A (Code examples)

#### Response Example
N/A (Code examples)
```

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

### Install zlib Libraries and Headers (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/CMakeLists.txt

This CMake snippet defines the installation rules for the zlib library and its associated files. It specifies destinations for runtime binaries, archives, libraries, headers, man pages, and pkg-config files, conditional on not skipping installation.

```cmake
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
    install(TARGETS zlib zlibstatic
        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
endif()
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
endif()
```

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

### Install WRF WPS Files and Documentation (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/CMakeLists.txt

Installs various files including man pages and pkg-config files for the WRF WPS component. It sets a default man directory and installs man pages to `man3` and `man5`. It also installs `.pc` files and `*-config` scripts for pkg-config integration. This installation is controlled by `SKIP_INSTALL_FILES` and `SKIP_INSTALL_ALL` flags and includes platform checks.

```cmake
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL)
  # Install man pages
  if(NOT PNG_MAN_DIR)
    set(PNG_MAN_DIR "share/man")
  endif()
  install(FILES libpng.3 libpngpf.3 DESTINATION ${PNG_MAN_DIR}/man3)
  install(FILES png.5 DESTINATION ${PNG_MAN_DIR}/man5)
  # Install pkg-config files
  if(NOT CMAKE_HOST_WIN32 OR CYGWIN OR MINGW)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
            DESTINATION bin)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
            DESTINATION bin)
  endif()
endif()
```

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

### zlib deflate() and inflate() Usage Example in C

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/examples/zlib_how.html

This C code snippet demonstrates the core functionality of zlib for compressing and decompressing data from files. It utilizes deflateInit, deflate, deflateEnd, inflateInit, inflate, and inflateEnd. The example addresses buffer management and proper termination, with annotations explaining each step.

```c
/* zpipe.c: example of proper use of zlib's inflate() and deflate()
   Not copyrighted -- provided to the public domain
   Version 1.4  11 December 2005  Mark Adler */

/* Version history:
   1.0  30 Oct 2004  First version
   1.1   8 Nov 2004  Add void casting for unused return values
                     Use switch statement for inflate() return values
   1.2   9 Nov 2004  Add assertions to document zlib guarantees
   1.3   6 Apr 2005  Remove incorrect assertion in inf()
   1.4  11 Dec 2005  Add hack to avoid MSDOS end-of-line conversions
                     Avoid some compiler warnings for input and output buffers
 */

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "zlib.h"

#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
#  include <fcntl.h>
#  include <io.h>
#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#  define SET_BINARY_MODE(file) /* */
#endif

#define CHUNK 16384

/* Compress from file source to file dest until EOF on source. 
   infprintf() returns Z_OK on success, or another error code.
   Z_BUF_ERROR is returned if the output buffer is full.
*/
int def(FILE *source, FILE *dest, int level)
{
    int ret, flush;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    if (deflateInit(&strm, level) != Z_OK)
        return Z_ERRNO;

    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)deflateEnd(&strm);
            return Z_ERRNO;
        }
        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = in;

        /* run deflate() on input until output buffer not full, or
           next input is empty.  artificially deflate only when
           necessary, otherwise this is just a pass-through.
        */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = deflate(&strm, flush);
            assert(ret != Z_STREAM_ERROR);
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)deflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);

        /* done when inflate() has finished */
    } while (flush != Z_FINISH);

    /* clean up and return */
    (void)deflateEnd(&strm);
    return Z_OK;
}

/* Decompress from file source to file dest until stream ends or EOF. 
   infprintf() returns Z_OK on success, or another error code upon
   entry.  Z_DATA_ERROR is returned for the first chunk that is
   invalids.  Z_MEM_ERROR is for memory allocation failure. 
   Z_BUF_ERROR is for when no progress is made.
*/
int inf(FILE *source, FILE *dest)
{
    int ret;

    unsigned have;
    z_stream strm, *next;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

    /* next input and output buffers */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    if (inflateInit(&strm) != Z_OK)
        return Z_ERRNO;

    /* decompress until deflate stream ends or end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)inflateEnd(&strm);
            return Z_ERRNO;
        }
        if (strm.avail_in == 0)
            break;

        strm.next_in = in;

        /* run inflate() on input until output buffer not full, or
           next input is empty. */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = inflate(&strm, Z_NO_FLUSH);
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */

            switch (ret) {
            case Z_NEED_DICT:
                ret = Z_DATA_ERROR;
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void)inflateEnd(&strm);
                return ret;
            }

            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)inflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);
    } while (ret != Z_STREAM_END);

    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
}

/* example of using by read/write callbacks */
int main(int argc, char **argv)
{
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];
    unsigned have;
    FILE *source, *dest;
    int ret, flush;

    /* keep C off stdin */
    SET_BINARY_MODE(stdin);
    SET_BINARY_MODE(stdout);

    /* do compression */
    if (argc != 3) {
        fprintf(stderr, "usage: %s <in> <out>\n", argv[0]);
        return Z_DATA_ERROR;
    }
    source = fopen(argv[1], "rb");
    if (source == NULL) {
        perror("fopen");
        return Z_DATA_ERROR;
    }
    dest = fopen(argv[2], "wb");
    if (dest == NULL) {
        fclose(source);
        perror("fopen");
        return Z_DATA_ERROR;
    }

    if (def(source, dest, Z_DEFAULT_COMPRESSION) != Z_OK) {
        fprintf(stderr, "Zlib compression failed\n");
        fclose(source);
        fclose(dest);
        return Z_DATA_ERROR;
    }
    fclose(source);
    fclose(dest);

    /* do decompression */
    source = fopen(argv[2], "rb");
    if (source == NULL) {
        perror("fopen");
        return Z_DATA_ERROR;
    }
    dest = fopen(argv[2]+".out", "wb");
    if (dest == NULL) {
        fclose(source);
        perror("fopen");
        return Z_DATA_ERROR;
    }

    if (inf(source, dest) != Z_OK) {
        fprintf(stderr, "Zlib decompression failed\n");
        fclose(source);
        fclose(dest);
        return Z_DATA_ERROR;
    }
    fclose(source);
    fclose(dest);

    return Z_OK;
}

```

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

### Install WRF WPS Programs (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/CMakeLists.txt

Installs the WRF WPS programs, typically executables, to the bin directory. This installation is governed by the `SKIP_INSTALL_PROGRAMS` and `SKIP_INSTALL_ALL` flags.

```cmake
if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL)
  install(TARGETS ${PNG_BIN_TARGETS}
          RUNTIME DESTINATION bin)
endif()
```

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

### Initialize Output Buffer for Deflate (C)

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/examples/zlib_how.html

Sets up the output buffer for the zlib deflate function. It specifies the available output space and the pointer to the output buffer.

```c
strm.avail_out = CHUNK;
strm.next_out = out;
```

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

### Install Targets (CMake)

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

This CMake command defines the installation rules for the built targets. It specifies the runtime, archive, and library destinations for the executables and libraries when the project is installed.

```cmake
# Add these to the export targets
install(
        TARGETS ungrib g1print g2print pgu
        EXPORT ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/ 
        ARCHIVE DESTINATION lib/ 
        LIBRARY DESTINATION lib/ 
        )
```

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

### Detecting libpng with Autoconf (Shell)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

This example shows how to use the autoconf tool to check for the presence of the libpng library in a C project. It specifically looks for the `png_get_io_ptr` function, which has been available since libpng version 0.88.

```shell
AC_CHECK_LIB(png, png_get_io_ptr, ...)
```

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

### Configuring libpng with CPPFLAGS

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Illustrates how to configure libpng during the build process by defining preprocessor macros via CPPFLAGS. This example shows how to disable floating-point arithmetic in favor of fixed-point, which can be useful for systems without fast floating-point support.

```bash
CPPFLAGS=-DPNG_NO_FLOATING_ARITHMETIC
```

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

### Install WRF WPS Libraries (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/CMakeLists.txt

Installs the WRF WPS libraries, including handling shared and static library variants. It creates symlinks for different library suffixes and installs them to the appropriate destination directory. This script is conditional on `SKIP_INSTALL_LIBRARIES` and `SKIP_INSTALL_ALL` flags.

```cmake
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
  install(TARGETS ${PNG_LIB_TARGETS}
          EXPORT libpng
          RUNTIME DESTINATION bin
          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
          FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})

  if(PNG_SHARED)
    # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
    if(CYGWIN OR MINGW)
      create_symlink(libpng${CMAKE_IMPORT_LIBRARY_SUFFIX} TARGET png)
      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
              DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif()

    if(NOT WIN32)
      create_symlink(libpng${CMAKE_SHARED_LIBRARY_SUFFIX} TARGET png)
      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
              DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif()
  endif()

  if(PNG_STATIC)
    if(NOT WIN32 OR CYGWIN OR MINGW)
      create_symlink(libpng${CMAKE_STATIC_LIBRARY_SUFFIX} TARGET png_static)
      install(FILES $<TARGET_LINKER_FILE_DIR:png_static>/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
              DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif()
  endif()
endif()
```

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

### Install Metgrid Executable (CMake)

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

This CMake install command specifies where the built Metgrid executable and its associated libraries should be placed after the build process is complete. It defines the runtime, archive, and library destinations within the installation prefix, making the executable accessible in the `bin` directory and libraries in the `lib` directory.

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

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

### Install Library Targets

Source: https://github.com/wrf-model/wps/blob/master/ungrib/src/ngl/g2/CMakeLists.txt

Configures the installation of the compiled library targets. It specifies the destinations for runtime executables, archives, and shared libraries based on the build configuration.

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

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

### PNG Alpha Mode Configuration

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

This section provides examples of how to configure alpha channel handling using `png_set_alpha_mode` for various scenarios, including sRGB, Mac gamma, linear gamma, and optimized compositing.

```APIDOC
## `png_set_alpha_mode` Examples

### Description
Examples demonstrating the usage of `png_set_alpha_mode` to control how alpha channels are handled, including gamma correction and alpha pre-multiplication.

### Method
Function Call

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```c
// Example 1: PNG standard alpha mode with sRGB gamma
png_set_alpha_mode(png_ptr, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);

// Example 2: PNG standard alpha mode with Mac gamma
png_set_alpha_mode(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_MAC);

// Example 3: Standard linear alpha mode with linear gamma
png_set_alpha_mode(png_ptr, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);

// Example 4: Standard alpha mode with sRGB gamma and 16-bit expansion
png_set_expand_16(png_ptr);
png_set_alpha_mode(png_ptr, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);

// Example 5: Optimized alpha mode with sRGB gamma
png_set_alpha_mode(png_ptr, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
```

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A

### Notes
- `PNG_ALPHA_PNG`: Standard PNG alpha handling, not pre-multiplied.
- `PNG_ALPHA_STANDARD`: Porter/Duff compositing standard, often used for linear math.
- `PNG_ALPHA_ASSOCIATED` and `PNG_ALPHA_PREMULTIPLIED`: Aliases for `PNG_ALPHA_STANDARD`.
- `PNG_ALPHA_OPTIMIZED`: For compositing onto a matching output, avoids expansion.
- `PNG_ALPHA_BROKEN`: Alpha channel is gamma encoded; use only if necessary due to software/hardware bugs.
- `screen_gamma`: The gamma correction value for the output display.
- `png_set_expand_16()`: Expands components to 16 bits for more precision, use with `PNG_ALPHA_STANDARD` for accurate scaling and processing.
```

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

### Get Pixel Placement Information for De-interlacing (libpng)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

As of libpng 1.5, these macros provide information needed to de-interlace an image manually. They help determine the starting column and row, as well as the pixel spacing for each pass, facilitating the arrangement of sub-image pixels onto a rectangular grid in the output image.

```c
png_uint_32 x = PNG_PASS_START_COL(pass);
png_uint_32 y = PNG_PASS_START_ROW(pass);
png_uint_32 xStep = 1U << PNG_PASS_COL_SHIFT(pass);
```

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

### Install WRF WPS Executables (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/CMakeLists.txt

Installs the WRF WPS executables, specifically the `libpng-config` and `PNGLIB_NAME-config` scripts. These are installed to the bin directory and are subject to platform checks for Windows, Cygwin, and MinGW. Installation is controlled by `SKIP_INSTALL_EXECUTABLES` and `SKIP_INSTALL_ALL` flags.

```cmake
if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL)
  if(NOT WIN32 OR CYGWIN OR MINGW)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config DESTINATION bin)
  endif()
endif()
```

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

### Complete WPS Workflow Example - Bash Script

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

An end-to-end bash script demonstrating the complete WPS workflow for processing GFS data for a hurricane simulation case. It includes steps for cleaning, configuring namelist, running geogrid, ungrib, and metgrid, along with verification steps.

```bash
#!/bin/bash
# Complete WPS workflow for Hurricane Dorian case

# Set environment
export WRF_DIR=/path/to/WRF
export WPS_GEOG=/path/to/WPS_GEOG
export NETCDF=/path/to/netcdf

# 1. Clean previous runs
rm -f geo_em.d*.nc met_em.d*.nc FILE:* GRIBFILE.* Vtable

# 2. Configure namelist.wps for the case
cat > namelist.wps << 'EOF'
&share
 wrf_core = 'ARW',
 max_dom = 2,
 start_date = '2019-09-04_12:00:00','2019-09-04_12:00:00',
 end_date   = '2019-09-06_00:00:00','2019-09-04_12:00:00',
 interval_seconds = 10800
/

&geogrid
 parent_id         =   1,   1,
 parent_grid_ratio =   1,   3,
 i_parent_start    =   1,  53,
 j_parent_start    =   1,  25,
 e_we              = 150, 220,
 e_sn              = 130, 214,
 geog_data_res     = 'default','default',
 dx = 15000,
 dy = 15000,
 map_proj = 'lambert',
 ref_lat   =  33.00,
 ref_lon   = -79.00,
 truelat1  =  30.0,
 truelat2  =  60.0,
 stand_lon = -79.0,
 geog_data_path = '/path/to/WPS_GEOG/'
/

&ungrib
 out_format = 'WPS',
 prefix = 'FILE',
/

&metgrid
 fg_name = 'FILE'
/
EOF

# 3. Run geogrid
ln -sf geogrid/GEOGRID.TBL.ARW geogrid/GEOGRID.TBL
./geogrid.exe
if [ $? -ne 0 ]; then echo "geogrid failed"; exit 1; fi

# Verify output
ls -la geo_em.d*.nc

# 4. Run ungrib
ln -sf ungrib/Variable_Tables/Vtable.GFS Vtable
./link_grib.csh /data/gfs/gfs.t12z.pgrb2.0p25.f*
./ungrib.exe >& ungrib.out
if [ $? -ne 0 ]; then echo "ungrib failed"; exit 1; fi

# Verify intermediate files
ls -la FILE:*

# 5. Run metgrid
ln -sf metgrid/METGRID.TBL.ARW metgrid/METGRID.TBL
./metgrid.exe
if [ $? -ne 0 ]; then echo "metgrid failed"; exit 1; fi

# Verify final output
ls -la met_em.d*.nc

echo "WPS completed successfully!"
echo "Output files ready for WRF real.exe:"
ls met_em.d*.nc

# 6. Move output to WRF run directory
# cp met_em.d*.nc $WRF_DIR/run/

```

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

### Install WRF WPS Library

Source: https://github.com/wrf-model/wps/blob/master/ungrib/src/ngl/w3/CMakeLists.txt

This CMake snippet defines the installation rules for the compiled WRF WPS library. It specifies the target library name and the export name for CMake's install export system. The library is installed into 'bin/', 'lib/', and 'lib/' directories for runtime, archive, and library files respectively.

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

```

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

### Install WRF WPS Headers (CMake)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/CMakeLists.txt

Installs the public header files for the WRF WPS component. The headers are copied to the include directory and a subdirectory named after the PNG library. This installation is controlled by `SKIP_INSTALL_HEADERS` and `SKIP_INSTALL_ALL` flags.

```cmake
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL)
  install(FILES ${libpng_public_hdrs} DESTINATION include)
  install(FILES ${libpng_public_hdrs} DESTINATION include/${PNGLIB_NAME})
endif()
```

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

### Simplified PNG Image Reading with libpng

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Demonstrates the steps to read a PNG file using libpng's simplified API. This involves declaring a 'png_image' structure, calling initialization and reading functions, setting the desired format, allocating buffers, and finally finishing the read operation.

```c
png_image image;

// Initialize image structure
image.version = PNG_IMAGE_VERSION;
image.opaque = NULL;

// Begin reading the PNG file
png_image_begin_read_from_file(&image, "input.png");

// Set the desired in-memory format
image.format = PNG_FORMAT_RGBA; // Example format

// Allocate buffer for image data
png_bytep buffer = malloc(png_image_get_expected_size(&image, 1, NULL));

// Read the image data
png_image_finish_read(&image, NULL, buffer, 0, NULL);

// Use the image data in 'buffer'

// Free the buffer when done
free(buffer);
```

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

### Initialize PNG Image Read from File

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Opens a PNG file and reads its header to initialize a png_image structure for reading. Requires a valid file path.

```c
int png_image_begin_read_from_file( png_imagep image,
  const char *file_name)
{
  // Implementation details for reading from a file
  return 0; // Success
}
```

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

### Main routine for zpipe command-line utility

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/examples/zlib_how.html

The main() function implements the 'zpipe' command-line utility. It handles command-line arguments to determine whether to compress (default) or decompress (-d). It sets stdin and stdout to binary mode and calls the appropriate compression or decompression function, reporting errors using zerr().

```c
/* compress or decompress from stdin to stdout */
int main(int argc, char **argv)
{
    int ret;

    /* avoid end-of-line conversions */
    SET_BINARY_MODE(stdin);
    SET_BINARY_MODE(stdout);

    /* do compression if no arguments */
    if (argc == 1) {
        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }

    /* do decompression if -d specified */
    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
        ret = inf(stdin, stdout);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }

    /* otherwise, report usage */
    else {
        fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
        return 1;
    }
}
```

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

### PNG Write Structure Initialization

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Demonstrates the process of allocating and initializing libpng write structures (png_structp and png_infop) for writing PNG files.

```APIDOC
## PNG Write Structure Initialization

### Description
This section covers the initialization of `png_structp` and `png_infop`, which are essential for writing PNG files using libpng. It also touches upon custom memory allocation.

### Method
N/A (Code examples)

### Endpoint
N/A (Code examples)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
// Standard initialization
png_structp png_ptr = png_create_write_struct(
    PNG_LIBPNG_VER_STRING, 
    (png_voidp)user_error_ptr,
    user_error_fn, 
    user_warning_fn
);

if (!png_ptr) return ERROR;

png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
    png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
    return ERROR;
}

// Initialization with custom memory allocation
png_structp png_ptr_custom = png_create_write_struct_2(
    PNG_LIBPNG_VER_STRING,
    (png_voidp)user_error_ptr,
    user_error_fn,
    user_warning_fn,
    (png_voidp)user_mem_ptr,
    user_malloc_fn,
    user_free_fn
);
```

### Response
#### Success Response (200)
N/A (Code examples)

#### Response Example
N/A (Code examples)
```

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

### Configure geogrid.exe Domain with Bash

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

Shell commands and configuration steps for the geogrid.exe program in WPS. This involves setting up the domain in namelist.wps and linking the appropriate GEOGRID.TBL file for static data interpolation.

```bash
# 1. Configure domain in namelist.wps (&share and &geogrid sections)

# 2. Link appropriate GEOGRID.TBL for your application
ls -l geogrid/GEOGRID.TBL*
# Available tables:
#   GEOGRID.TBL.ARW         - Standard ARW configuration
#   GEOGRID.TBL.ARW.noahmp  - NoahMP land surface model
#   GEOGRID.TBL.ARW_CHEM    - WRF-Chem chemistry
#   GEOGRID.TBL.ARW_LCZ     - Local Climate Zones (urban)

```

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

### Build WPS with Bash

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

Configures and compiles the WRF Pre-Processing System (WPS) using bash scripts. Supports standard builds, parallel execution (MPI), GRIB2 support, and optional components like plotting utilities. Includes commands for cleaning build artifacts.

```bash
# Standard build with GRIB2 support
./configure
# Select appropriate option for your compiler and architecture
# Example: Option 3 for gfortran serial with GRIB2

./compile

# Alternative: Build without WRF dependency (limited functionality)
./configure --nowrf
./compile

# Build GRIB2 libraries from source if not installed system-wide
./configure --build-grib2-libs
./compile

# CMake-based build (alternative)
./configure_new
./compile_new

# Build optional plotting utilities (requires NCAR Graphics)
./compile plotfmt
./compile plotgrids

# Clean build artifacts
./clean
./cleanCMake.sh
```

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

### Install geogrid Executable (CMake)

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

Defines installation rules for the 'geogrid' executable. It specifies the destination directories for the runtime binary, static library, and shared library based on the build type and export configuration.

```cmake
# Add these to the export targets
install(
        TARGETS geogrid
        EXPORT ${EXPORT_NAME}Targets
        RUNTIME DESTINATION bin/
        ARCHIVE DESTINATION lib/
        LIBRARY DESTINATION lib/
        )
```

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

### Apply Common Properties and Install Targets (CMake)

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

This CMake code iterates through all defined utility targets ('ALL_UTIL_TARGETS' and 'util_common'). For each target, it sets Fortran module directory and format properties. It also links non-library targets to 'util_common' and installs all targets to their respective binary, archive, and library destinations.

```cmake
foreach( TARGET ${ALL_UTIL_TARGETS} util_common )

  set_target_properties (
                        ${TARGET}
                        PROPERTIES
                          Fortran_MODULE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/modules/util/
                          Fortran_FORMAT           FREE
                        )

  if ( NOT "${TARGET}" STREQUAL util_common )
    target_link_libraries(
                          ${TARGET}
                          PRIVATE
                            util_common
                          )
  endif()

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

endforeach()
```

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

### Customizing I/O Functions

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Libpng allows users to set custom input/output functions at runtime using `png_set_read_fn` and `png_set_write_fn`.

```APIDOC
## Customizing I/O Functions

### Description
Libpng provides mechanisms to replace its default input/output handling with custom functions at runtime. This is achieved by calling `png_set_read_fn` for reading and `png_set_write_fn` for writing.

### `png_set_write_fn`

#### Description
Sets a custom write function for libpng.

#### Method
`void png_set_write_fn(png_structp write_ptr, voidp write_io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)`

#### Parameters
*   `write_ptr` (png_structp) - Pointer to the libpng structure.
*   `write_io_ptr` (voidp) - A pointer to user data that will be passed to the custom write function.
*   `write_data_fn` (png_rw_ptr) - Pointer to the custom function that handles writing data.
*   `output_flush_fn` (png_flush_ptr) - Pointer to the custom function that handles flushing output buffers.

### Notes on I/O Customization
*   The `png_struct` stores the `FILE*` which is initialized via `png_init_io()`. To change the I/O method, use `png_set_read_fn()` and `png_set_write_fn()` instead of `png_init_io()`.
*   The `png_get_io_ptr()` function can retrieve the user-provided `voidp` pointer that was passed to `png_set_read_fn` or `png_set_write_fn`.
```

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

### Symbol Prefixing (libpng 1.6.0+)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Starting with libpng-1.6.0, you can configure libpng to prefix all exported symbols using the `PNG_PREFIX` macro.

```APIDOC
## Symbol Prefixing

### Description
Libpng version 1.6.0 and later allows you to configure the library to prefix all exported symbols. This is useful for avoiding symbol collisions in larger projects or when linking multiple versions of libpng.

### Method
Compile-time configuration using a preprocessor macro.

### Endpoint
N/A (Compile-time option)

### Parameters
#### Preprocessor Macros
- **PNG_PREFIX** (macro) - Define this macro during compilation to enable symbol prefixing. You can optionally provide a prefix string, e.g., `PNG_PREFIX=my_libpng_`.

### Request Example
```bash
# Example compilation command with symbol prefixing
CFLAGS="-DPNG_PREFIX=my_png_" make
```

### Response
N/A (Compile-time effect)

### Notes
- If `PNG_PREFIX` is defined without a value, a default prefix (if any) might be used, or it might just enable the feature.
- Consult the libpng build documentation for the exact syntax and behavior of `PNG_PREFIX`.
```

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

### Writing a PNG File with the Simplified API

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

This section outlines the steps required to write a PNG file using the simplified libpng API. It involves initializing a `png_image` structure, setting image properties, and calling the appropriate write function.

```APIDOC
## Writing a PNG File with the Simplified API

### Description
Follow these steps to write a PNG file using the simplified API:

1. Declare a `png_image` structure on the stack and initialize it to all zeros using `memset()`.
2. Set the members of the `png_image` structure to describe the image, ensuring the `format` member reflects the image sample format.
3. Call the appropriate `png_image_write...` function, passing a pointer to the `png_image` structure and, if necessary, the color-map.

### Method
N/A (Procedural Steps)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Public Function Declaration

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Example of declaring a public function (PNGAPI) with the return type and decorations on a separate line preceding the function name.

```c
/* This is a public function that is visible to
 * application programmers. It does thus-and-so.
 */
void PNGAPI
png_exported_function(png_ptr, png_info, foo)
{
   body;
}
```

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

### Initialize Progressive PNG Reader in C

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

This C code fragment demonstrates the initialization of libpng's progressive reader. It involves creating the PNG read and info structures, setting up jump buffers for error handling, and registering callback functions for progressive reading events.

```c
png_structp png_ptr;
png_infop info_ptr;

/*  An example code fragment of how you would
    initialize the progressive reader in your
    application. */
int
initialize_png_reader()
{
   png_ptr = png_create_read_struct
       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
        user_error_fn, user_warning_fn);

   if (!png_ptr)
       return ERROR;

   info_ptr = png_create_info_struct(png_ptr);

   if (!info_ptr)
   {
      png_destroy_read_struct(&png_ptr,
         (png_infopp)NULL, (png_infopp)NULL);
      return ERROR;
   }

   if (setjmp(png_jmpbuf(png_ptr)))
   {
      png_destroy_read_struct(&png_ptr, &info_ptr,
         (png_infopp)NULL);
      return ERROR;
   }

   /* This one's new.  You can provide functions
      to be called when the header info is valid,
      when each row is completed, and when the image
      is finished.  If you aren't using all functions,
      you can specify NULL parameters.  Even when all
      three functions are NULL, you need to call
      png_set_progressive_read_fn().  You can use
      any struct as the user_ptr (cast to a void pointer
      for the function call), and retrieve the pointer
      from inside the callbacks using the function

         png_get_progressive_ptr(png_ptr);

      which will return a void pointer, which you have
      to cast appropriately.
    */
   png_set_progressive_read_fn(png_ptr, (void *)user_ptr,
       info_callback, row_callback, end_callback);

   return 0;
}
```

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

### Initialize Libpng Structures in C

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Preferred methods for creating and initializing libpng structures, offering better version checking and custom error handling compared to older functions. These functions isolate structure sizes from the application.

```c
png_create_read_struct(...)
png_create_write_struct(...)
png_create_info_struct(...)
```

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

### Get PNG Palette Information

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Extracts the color palette and the number of entries in the palette from a PNG file. The palette is returned as an array of png_color structures.

```c
png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
```

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

### Get PNG Signature

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Retrieves the PNG signature from the file. The data is stored at the offset corresponding to how much of the signature might have already been read by the application.

```c
signature = png_get_signature(png_ptr, info_ptr);
```

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

### Initialize PNG Info Structure

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Allocates and initializes the PNG info structure, which holds metadata about the PNG image. If allocation fails, it's necessary to clean up the previously created read structure.

```c
png_infop info_ptr = png_create_info_struct(png_ptr);

    if (!info_ptr)
    {
       png_destroy_read_struct(&png_ptr,
           (png_infopp)NULL, (png_infopp)NULL);
       return ERROR;
    }
```

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

### Looping Until Output Buffer is Full (C)

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/examples/zlib_how.html

This do-while loop continues calling deflate() until it can no longer fill the provided output buffer, indicating that all input has been processed. It also asserts that all input has been consumed.

```c
} while (strm.avail_out == 0);
assert(strm.avail_in == 0);     /* all input will be used */
```

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

### Hexadecimal Constants for Bitmasks

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Example of using hexadecimal format for integer constants that serve as bitmasks, ensuring an even number of lower-case hex digits and unsigned type.

```c
0x00U, 0xffU, 0x0100U, 0xffffUL
```

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

### Initialize Zlib Deflate State

Source: https://github.com/wrf-model/wps/blob/master/external/zlib-1.2.11/examples/zlib_how.html

Initializes the zlib state for compression using deflateInit(). It sets up memory allocation routines and checks for successful initialization and version compatibility. The compression level can be set from -1 (default) to 9.

```c
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
ret = deflateInit(&strm, level);
if (ret != Z_OK)
    return ret;
```

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

### Get PNG Palette Histogram (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Retrieves the histogram of palette entries from a PNG file's hIST chunk. The histogram provides the frequency of each color in the palette.

```c
png_get_hIST(png_ptr, info_ptr, &hist);
```

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

### Get PNG Last Modification Time (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Retrieves the last modification time of the PNG image from its tIME chunk. This provides a timestamp indicating when the image was last saved.

```c
png_get_tIME(png_ptr, info_ptr, &mod_time);
```

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

### Initialize PNG I/O with File Pointer

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Configures libpng to read PNG data from a given FILE pointer. The file must be opened in binary mode. This function uses the default C fread() function.

```c
png_init_io(png_ptr, fp);
```

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

### Typecasted NULL Definitions (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Example of typecasted NULL definitions, such as `png_voidp_NULL`, which were used in libpng. These provide explicit type casting for NULL pointers, enhancing code clarity and safety.

```c
#define png_voidp_NULL (png_voidp)NULL
```

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

### libpng Configuration

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Details how libpng's features can be configured using C preprocessor directives, allowing for customized builds and portability.

```APIDOC
## libpng Configuration

### Description
libpng's functionality can be configured using C preprocessor directives of the form `#ifdef PNG_feature_SUPPORTED`. These directives protect function declarations and usage, allowing the library to be built with or without specific features. Application programs should check these feature macros for maximum portability.

### Configuration Files
- **`pnglibconf.h`**: Since libpng 1.5.0, feature macros set during the build are recorded in this file, which is always included by `png.h`.
- **`scripts/pnglibconf.h.prebuilt`**: A pre-built configuration file often copied to `pnglibconf.h` by build systems, supporting only the default configuration.
- **`pngusr.h`**: Can be used to provide custom feature macro settings when `PNG_USER_CONFIG` is defined.

### Customizing Configuration

1.  **Command Line Definitions (CPPFLAGS)**:
    For minor changes, define feature macros on the command line. For example, to use fixed-point arithmetic instead of floating-point:
    ```bash
    CPPFLAGS=-DPNG_NO_FLOATING_ARITHMETIC
    ```
    Verify that `pnglibconf.h` reflects the change.

2.  **`PNG_USER_CONFIG` and `pngusr.h`**:
    For more extensive changes, define `PNG_USER_CONFIG` and list feature macro settings in `pngusr.h`.

3.  **`DFA_XTRA` Makefile Variable**:
    Alternatively, set `DFA_XTRA` to a file containing configuration options in 'option' format.

4.  **Rebuilding `pnglibconf.h`**:
    `pnglibconf.h` can be rebuilt from `scripts/pnglibconf.dfa` using `awk` or by manual editing (copying `scripts/pnglibconf.h.prebuilt` and modifying it).
```

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

### Get PNG Gamma Information

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Retrieves the file gamma information, which indicates the gamma at which the image was written. Both floating-point (file_gamma) and fixed-point (int_file_gamma, 100,000 times the gamma) values are available.

```c
png_get_gAMA(png_ptr, info_ptr, &file_gamma);
png_get_gAMA_fixed(png_ptr, info_ptr, &int_file_gamma);
```

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

### Initialize and Write PNG Image to stdio FILE*

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Initializes a png_image structure and writes the image data to a standard C FILE pointer. The `convert_to_8bit` flag dictates the output format. Row stride and colormap are also provided.

```c
int png_image_write_to_stdio(png_imagep image,
   FILE *file,
   int convert_to_8_bit,
   const void *buffer,
   png_int_32 row_stride,
   const void *colormap);
```

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

### Get Libpng Compile-Time Version Macro (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Checks the version of the png.h header file used during application compilation. This is defined as a preprocessor macro, allowing for compile-time checks of the libpng version.

```c
#define PNG_LIBPNG_VER  10007  // Example for version 1.0.7
png_uint_32 application_vn = PNG_LIBPNG_VER;
```

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

### Get PNG Exif Data (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Extracts Exif profile data from a PNG file. This function retrieves the number of Exif entries and a pointer to the array containing the Exif profile data.

```c
png_get_eXIf_1(png_ptr, info_ptr, &num_exif, &exif);
```

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

### Set PNG Compression Strategy (C)

Source: https://github.com/wrf-model/wps/blob/master/external/libpng-1.6.37/libpng-manual.txt

Allows setting the compression strategy for zlib. This is an advanced option and not recommended for general use, as incorrect settings can lead to invalid PNG files. Consult zlib.h for details on available strategies.

```c
#include <zlib.h>

// Assuming png_ptr is a valid png_structp pointer
int strategy = Z_DEFAULT_STRATEGY; // Example strategy
png_set_compression_strategy(png_ptr, strategy);
```
Tokens:
Raw