Geostationary SatelliteGridded DataProduct Guide

This reader is written specifically for the native DN grid. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.nio.file.Files;
import java.nio.file.Path;

public class ReadAmaterassDn {
    private record Grid(int nx, int ny) {}

    private static Grid gridFromName(String name) {
        String lower = name.toLowerCase();
        if (lower.contains(".ext.")) return new Grid(24000, 24000);
        if (lower.contains(".vis.")) return new Grid(12000, 12000);
        if (lower.contains(".sir.") || lower.contains(".tir.")) return new Grid(6000, 6000);
        throw new IllegalArgumentException("filename must contain .ext., .vis., .sir., or .tir.");
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) throw new IllegalArgumentException("usage: java ReadAmaterassDn FILE");
        Path path = Path.of(args[0]);
        Grid grid = gridFromName(path.getFileName().toString());
        long count = (long) grid.nx * grid.ny;
        long expectedBytes = count * 2L;
        if (Files.size(path) != expectedBytes)
            throw new IllegalArgumentException("unexpected file size: " + Files.size(path) + " bytes");

        int first = -1, minimum = 65535, maximum = 0;
        long missing = 0, valid = 0;
        try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(path)))) {
            for (long i = 0; i < count; i++) {
                int value;
                try { value = in.readUnsignedShort(); }
                catch (EOFException e) { throw new EOFException("unexpected end of file at value " + i); }
                if (i == 0) first = value;
                if (value == 65535) { missing++; continue; }
                valid++;
                minimum = Math.min(minimum, value);
                maximum = Math.max(maximum, value);
            }
            if (in.read() != -1) throw new IllegalArgumentException("file is larger than expected");
        }
        System.out.printf("grid  = %d x %d%n", grid.nx, grid.ny);
        System.out.printf("first = %d DN%nmissing = %d pixels (DN 65535)%n", first, missing);
        if (valid > 0) System.out.printf("valid min = %d DN%nvalid max = %d DN%n", minimum, maximum);
    }
}

javac ReadAmaterassDn.java
java ReadAmaterassDn 201907070300.vis.02.fld.geoss

This reader is written specifically for the native DN grid. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

static int grid_size(const char *name) {
    if (strstr(name, ".ext.")) return 24000;
    if (strstr(name, ".vis.")) return 12000;
    if (strstr(name, ".sir.") || strstr(name, ".tir.")) return 6000;
    fprintf(stderr, "filename must contain .ext., .vis., .sir., or .tir.\n");
    exit(EXIT_FAILURE);
}

int main(int argc, char **argv) {
    if (argc != 2) { fprintf(stderr, "usage: %s FILE\n", argv[0]); return EXIT_FAILURE; }
    int n = grid_size(argv[1]);
    uint64_t count = (uint64_t)n * (uint64_t)n, expected = count * 2u;
    struct stat info;
    if (stat(argv[1], &info) != 0) { perror(argv[1]); return EXIT_FAILURE; }
    if ((uint64_t)info.st_size != expected) {
        fprintf(stderr, "unexpected file size: %lld bytes\n", (long long)info.st_size);
        return EXIT_FAILURE;
    }

    FILE *fp = fopen(argv[1], "rb");
    if (!fp) { perror(argv[1]); return EXIT_FAILURE; }
    uint16_t first = 0, minimum = UINT16_MAX, maximum = 0;
    uint64_t missing = 0, valid = 0;
    for (uint64_t i = 0; i < count; i++) {
        uint8_t b[2];
        if (fread(b, 1, 2, fp) != 2) { fprintf(stderr, "unexpected end of file\n"); return EXIT_FAILURE; }
        uint16_t value = (uint16_t)(((uint16_t)b[0] << 8) | b[1]);
        if (i == 0) first = value;
        if (value == UINT16_MAX) { missing++; continue; }
        valid++;
        if (value < minimum) minimum = value;
        if (value > maximum) maximum = value;
    }
    fclose(fp);
    printf("grid  = %d x %d\nfirst = %u DN\nmissing = %llu pixels (DN 65535)\n",
           n, n, first, (unsigned long long)missing);
    if (valid > 0) printf("valid min = %u DN\nvalid max = %u DN\n", minimum, maximum);
    return EXIT_SUCCESS;
}

cc -O3 -std=c11 read_amaterass_dn.c -o read_dn
./read_dn 201907070300.vis.02.fld.geoss

This reader is written specifically for the native DN grid. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

program read_amaterass_dn
  use iso_fortran_env, only: int16, int32, int64
  implicit none
  character(len=1024) :: path
  integer :: nx, ny, unit, row, column, stat
  integer(int64) :: bytes, expected, missing, valid
  integer(int16), allocatable :: raw(:)
  integer(int32) :: value, first, minimum, maximum

  if (command_argument_count() /= 1) error stop 'usage: read_dn FILE'
  call get_command_argument(1, path)
  if (index(path, '.ext.') > 0) then
    nx=24000
  else if (index(path, '.vis.') > 0) then
    nx=12000
  else if (index(path, '.sir.') > 0 .or. index(path, '.tir.') > 0) then
    nx=6000
  else
    error stop 'filename must contain .ext., .vis., .sir., or .tir.'
  end if
  ny=nx
  inquire(file=trim(path), size=bytes)
  expected=int(nx,int64)*int(ny,int64)*2_int64
  if (bytes /= expected) error stop 'unexpected file size'

  allocate(raw(nx))
  open(newunit=unit,file=trim(path),access='stream',form='unformatted', &
       status='old',action='read',convert='big_endian')
  minimum=65535; maximum=0; first=-1; missing=0; valid=0
  do row=1,ny
    read(unit,iostat=stat) raw
    if (stat /= 0) error stop 'unexpected end of file'
    do column=1,nx
      value=iand(int(raw(column),int32),int(z'FFFF',int32))
      if (row == 1 .and. column == 1) first=value
      if (value == 65535) then
        missing=missing+1
        cycle
      end if
      valid=valid+1
      minimum=min(minimum,value); maximum=max(maximum,value)
    end do
  end do
  close(unit)
  print '(A,I0,A,I0)', 'grid  = ',nx,' x ',ny
  print '(A,I0,A)', 'first = ',first,' DN'
  print '(A,I0,A)', 'missing = ',missing,' pixels (DN 65535)'
  if (valid > 0) then
    print '(A,I0,A)', 'valid min = ',minimum,' DN'
    print '(A,I0,A)', 'valid max = ',maximum,' DN'
  end if
end program read_amaterass_dn

gfortran -O3 read_amaterass_dn.f90 -o read_dn
./read_dn 201907070300.vis.02.fld.geoss

This reader is written specifically for the native DN grid. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

from pathlib import Path
import sys
import numpy as np

def grid_size(name: str) -> int:
    name = name.lower()
    if ".ext." in name:
        return 24000
    if ".vis." in name:
        return 12000
    if ".sir." in name or ".tir." in name:
        return 6000
    raise ValueError("filename must contain .ext., .vis., .sir., or .tir.")

def main() -> None:
    if len(sys.argv) != 2:
        raise SystemExit(f"usage: {Path(sys.argv[0]).name} FILE")
    path = Path(sys.argv[1])
    n = grid_size(path.name)
    values = np.fromfile(path, dtype=">u2")
    if values.size != n * n:
        raise ValueError(f"unexpected value count: {values.size}")
    grid = values.reshape(n, n)
    valid = grid != 65535
    valid_values = grid[valid]
    print(f"grid  = {n} x {n}")
    print(f"first = {int(grid[0, 0])} DN")
    print(f"missing = {int((~valid).sum())} pixels (DN 65535)")
    if valid_values.size:
        print(f"valid min = {int(valid_values.min())} DN")
        print(f"valid max = {int(valid_values.max())} DN")

if __name__ == "__main__":
    main()

python3 read_amaterass_dn.py 201907070300.vis.02.fld.geoss

This reader is written specifically for the 4 km physical-quantity product. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.nio.file.Files;
import java.nio.file.Path;

public class ReadAmaterass4km {
    private static final int NX = 3000, NY = 3000;

    public static void main(String[] args) throws Exception {
        if (args.length != 1) throw new IllegalArgumentException("usage: java ReadAmaterass4km FILE");
        Path path = Path.of(args[0]);
        long count = (long) NX * NY, expectedBytes = count * 4L;
        if (Files.size(path) != expectedBytes)
            throw new IllegalArgumentException("unexpected file size: " + Files.size(path) + " bytes");

        float first = Float.NaN, minimum = Float.POSITIVE_INFINITY, maximum = Float.NEGATIVE_INFINITY;
        long finite = 0;
        try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(path)))) {
            for (long i = 0; i < count; i++) {
                float value;
                try { value = in.readFloat(); }
                catch (EOFException e) { throw new EOFException("unexpected end of file at value " + i); }
                if (i == 0) first = value;
                if (Float.isFinite(value)) {
                    finite++;
                    minimum = Math.min(minimum, value);
                    maximum = Math.max(maximum, value);
                }
            }
            if (in.read() != -1) throw new IllegalArgumentException("file is larger than expected");
        }
        System.out.printf("grid   = %d x %d%n", NX, NY);
        System.out.printf("first  = %.7g%nfinite = %d%nmin    = %.7g%nmax    = %.7g%n",
                          first, finite, minimum, maximum);
    }
}

javac ReadAmaterass4km.java
java ReadAmaterass4km 201907070300.vis.02.rfy.fld.4km.bin

This reader is written specifically for the 4 km physical-quantity product. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#define NX 3000
#define NY 3000

int main(int argc, char **argv) {
    if (argc != 2) { fprintf(stderr, "usage: %s FILE\n", argv[0]); return EXIT_FAILURE; }
    const uint64_t count = (uint64_t)NX * NY, expected = count * 4u;
    struct stat info;
    if (stat(argv[1], &info) != 0) { perror(argv[1]); return EXIT_FAILURE; }
    if ((uint64_t)info.st_size != expected) {
        fprintf(stderr, "unexpected file size: %lld bytes\n", (long long)info.st_size);
        return EXIT_FAILURE;
    }

    FILE *fp = fopen(argv[1], "rb");
    if (!fp) { perror(argv[1]); return EXIT_FAILURE; }
    float first = NAN, minimum = INFINITY, maximum = -INFINITY;
    uint64_t finite = 0;
    for (uint64_t i = 0; i < count; i++) {
        uint8_t b[4];
        if (fread(b, 1, 4, fp) != 4) { fprintf(stderr, "unexpected end of file\n"); return EXIT_FAILURE; }
        uint32_t bits = ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) |
                        ((uint32_t)b[2] << 8) | (uint32_t)b[3];
        float value;
        memcpy(&value, &bits, sizeof value);
        if (i == 0) first = value;
        if (isfinite(value)) {
            finite++;
            if (value < minimum) minimum = value;
            if (value > maximum) maximum = value;
        }
    }
    fclose(fp);
    printf("grid   = %d x %d\nfirst  = %.7g\nfinite = %llu\nmin    = %.7g\nmax    = %.7g\n",
           NX, NY, first, (unsigned long long)finite, minimum, maximum);
    return EXIT_SUCCESS;
}

cc -O3 -std=c11 read_amaterass_4km.c -o read_4km
./read_4km 201907070300.vis.02.rfy.fld.4km.bin

This reader is written specifically for the 4 km physical-quantity product. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

program read_amaterass_4km
  use iso_fortran_env, only: int64, real32
  use, intrinsic :: ieee_arithmetic, only: ieee_is_finite
  implicit none
  integer, parameter :: nx=3000, ny=3000
  character(len=1024) :: path
  integer :: unit, row, column, stat
  integer(int64) :: bytes, expected, finite
  real(real32), allocatable :: values(:)
  real(real32) :: value, first, minimum, maximum

  if (command_argument_count() /= 1) error stop 'usage: read_4km FILE'
  call get_command_argument(1, path)
  inquire(file=trim(path), size=bytes)
  expected=int(nx,int64)*int(ny,int64)*4_int64
  if (bytes /= expected) error stop 'unexpected file size'

  allocate(values(nx))
  open(newunit=unit,file=trim(path),access='stream',form='unformatted', &
       status='old',action='read',convert='big_endian')
  minimum=huge(minimum); maximum=-huge(maximum); finite=0; first=0.0_real32
  do row=1,ny
    read(unit,iostat=stat) values
    if (stat /= 0) error stop 'unexpected end of file'
    do column=1,nx
      value=values(column)
      if (row == 1 .and. column == 1) first=value
      if (ieee_is_finite(value)) then
        finite=finite+1; minimum=min(minimum,value); maximum=max(maximum,value)
      end if
    end do
  end do
  close(unit)
  print '(A,I0,A,I0)', 'grid   = ',nx,' x ',ny
  print '(A,ES14.6)', 'first  = ',first
  print '(A,I0)', 'finite = ',finite
  print '(A,ES14.6)', 'min    = ',minimum
  print '(A,ES14.6)', 'max    = ',maximum
end program read_amaterass_4km

gfortran -O3 read_amaterass_4km.f90 -o read_4km
./read_4km 201907070300.vis.02.rfy.fld.4km.bin

This reader is written specifically for the 4 km physical-quantity product. It reads a headerless, row-major, big-endian binary file and verifies the value count and file size.

from pathlib import Path
import sys
import numpy as np

NX, NY = 3000, 3000

def main() -> None:
    if len(sys.argv) != 2:
        raise SystemExit(f"usage: {Path(sys.argv[0]).name} FILE")
    path = Path(sys.argv[1])
    values = np.fromfile(path, dtype=">f4")
    if values.size != NX * NY:
        raise ValueError(f"unexpected value count: {values.size}")
    grid = values.reshape(NY, NX)
    finite = np.isfinite(grid)
    print(f"grid   = {NX} x {NY}")
    print(f"first  = {float(grid[0, 0]):.7g}")
    print(f"finite = {int(finite.sum())}")
    print(f"min    = {float(grid[finite].min()):.7g}")
    print(f"max    = {float(grid[finite].max()):.7g}")

if __name__ == "__main__":
    main()

python3 read_amaterass_4km.py 201907070300.vis.02.rfy.fld.4km.bin