AMATERASS
Data Guide

HIMAWARI fld.4km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

/** AMATERASS HIMAWARI fld.4km reader. Arrays are intentionally one-based: the first pixel is [1][1]. */
public final class AmaterassPickup {
    private static final int NX = 3000;
    private static final int NY = 3000;
    private static final long EXPECTED_BYTES = (long) NX * NY * Float.BYTES;

    public static void main(String[] args) throws IOException {
        if (args.length != 6) {
            System.err.println("Usage: java -Xmx512m AmaterassPickup DATA.bin LAT.bin LNG.bin TIME.bin LATITUDE LONGITUDE");
            System.exit(1);
        }
        float[][] data = readGrid(Path.of(args[0]));
        float[][] lat = readGrid(Path.of(args[1]));
        float[][] lon = readGrid(Path.of(args[2]));
        float[][] time = readGrid(Path.of(args[3]));
        double targetLat = Double.parseDouble(args[4]);
        double targetLon = normalizeLon(Double.parseDouble(args[5]));
        Pixel p = nearest(lat, lon, targetLat, targetLon);
        System.out.printf("pixel      = [%d][%d]%n", p.row, p.column);
        System.out.printf("latitude   = %.6f deg%n", lat[p.row][p.column]);
        System.out.printf("longitude  = %.6f deg%n", lon[p.row][p.column]);
        System.out.printf("solar flux = %.3f W/m^2%n", data[p.row][p.column]);
        double elapsedSeconds = time[p.row][p.column] * 86400.0;
        System.out.printf("elapsed UTC seconds from filename date 00:00 = %.3f%n", elapsedSeconds);
    }

    private static float[][] readGrid(Path file) throws IOException {
        if (Files.size(file) != EXPECTED_BYTES) throw new IOException("Unexpected file size: " + file);
        float[][] grid = new float[NY + 1][NX + 1]; // index 0 is unused
        ByteBuffer bytes = ByteBuffer.allocateDirect(NX * Float.BYTES).order(ByteOrder.BIG_ENDIAN);
        try (FileChannel channel = FileChannel.open(file, StandardOpenOption.READ)) {
            for (int row = 1; row <= NY; row++) {
                bytes.clear();
                while (bytes.hasRemaining()) if (channel.read(bytes) < 0) throw new EOFException(file.toString());
                bytes.flip();
                FloatBuffer values = bytes.asFloatBuffer();
                values.get(grid[row], 1, NX);
            }
        }
        return grid;
    }

    private static Pixel nearest(float[][] lat, float[][] lon, double targetLat, double targetLon) {
        int bestRow = 1, bestColumn = 1;
        double best = Double.POSITIVE_INFINITY;
        for (int row = 1; row <= NY; row++) for (int column = 1; column <= NX; column++) {
            double dLat = lat[row][column] - targetLat;
            double dLon = Math.abs(normalizeLon(lon[row][column]) - targetLon);
            dLon = Math.min(dLon, 360.0 - dLon);
            double d2 = dLat * dLat + dLon * dLon;
            if (d2 < best) { best = d2; bestRow = row; bestColumn = column; }
        }
        return new Pixel(bestRow, bestColumn);
    }

    private static double normalizeLon(double lon) {
        double value = lon % 360.0;
        return value < 0.0 ? value + 360.0 : value;
    }

    private record Pixel(int row, int column) {}
}

METEOSAT-IODC fld.3km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

/** AMATERASS METEOSAT-IODC fld.3km reader. Arrays are intentionally one-based: the first pixel is [1][1]. */
public final class AmaterassPickupIodc {
    private static final int NX = 4000;
    private static final int NY = 4000;
    private static final long EXPECTED_BYTES = (long) NX * NY * Float.BYTES;

    public static void main(String[] args) throws IOException {
        if (args.length != 5) {
            System.err.println("Usage: java -Xmx512m AmaterassPickupIodc DATA.bin LAT.bin LNG.bin LATITUDE LONGITUDE");
            System.exit(1);
        }
        float[][] data = readGrid(Path.of(args[0]));
        float[][] lat = readGrid(Path.of(args[1]));
        float[][] lon = readGrid(Path.of(args[2]));
        double targetLat = Double.parseDouble(args[3]);
        double targetLon = normalizeLon(Double.parseDouble(args[4]));
        Pixel p = nearest(lat, lon, targetLat, targetLon);
        System.out.printf("pixel      = [%d][%d]%n", p.row, p.column);
        System.out.printf("latitude   = %.6f deg%n", lat[p.row][p.column]);
        System.out.printf("longitude  = %.6f deg%n", lon[p.row][p.column]);
        System.out.printf("solar flux = %.3f W/m^2%n", data[p.row][p.column]);
    }

    private static float[][] readGrid(Path file) throws IOException {
        if (Files.size(file) != EXPECTED_BYTES) throw new IOException("Unexpected file size: " + file);
        float[][] grid = new float[NY + 1][NX + 1]; // index 0 is unused
        ByteBuffer bytes = ByteBuffer.allocateDirect(NX * Float.BYTES).order(ByteOrder.BIG_ENDIAN);
        try (FileChannel channel = FileChannel.open(file, StandardOpenOption.READ)) {
            for (int row = 1; row <= NY; row++) {
                bytes.clear();
                while (bytes.hasRemaining()) if (channel.read(bytes) < 0) throw new EOFException(file.toString());
                bytes.flip();
                FloatBuffer values = bytes.asFloatBuffer();
                values.get(grid[row], 1, NX);
            }
        }
        return grid;
    }

    private static Pixel nearest(float[][] lat, float[][] lon, double targetLat, double targetLon) {
        int bestRow = 1, bestColumn = 1;
        double best = Double.POSITIVE_INFINITY;
        for (int row = 1; row <= NY; row++) for (int column = 1; column <= NX; column++) {
            double dLat = lat[row][column] - targetLat;
            double dLon = Math.abs(normalizeLon(lon[row][column]) - targetLon);
            dLon = Math.min(dLon, 360.0 - dLon);
            double d2 = dLat * dLat + dLon * dLon;
            if (d2 < best) { best = d2; bestRow = row; bestColumn = column; }
        }
        return new Pixel(bestRow, bestColumn);
    }

    private static double normalizeLon(double lon) {
        double value = lon % 360.0;
        return value < 0.0 ? value + 360.0 : value;
    }

    private record Pixel(int row, int column) {}
}

HIMAWARI fld.4km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define NX 3000
#define NY 3000
typedef float (*Grid)[NX + 1];

/* Index 0 is intentionally unused; the first pixel is grid[1][1]. */
static int little_endian(void) { const uint16_t x = 1; return *(const uint8_t *)&x; }
static float swap_float(float value) {
    union { float f; uint8_t b[4]; } in = { .f = value }, out;
    out.b[0]=in.b[3]; out.b[1]=in.b[2]; out.b[2]=in.b[1]; out.b[3]=in.b[0];
    return out.f;
}
static Grid read_grid(const char *name) {
    FILE *fp = fopen(name, "rb");
    Grid grid = calloc(NY + 1, sizeof *grid);
    if (!fp || !grid) { perror(name); exit(EXIT_FAILURE); }
    for (int row = 1; row <= NY; row++) {
        if (fread(&grid[row][1], sizeof(float), NX, fp) != NX) { fprintf(stderr, "Short file: %s\n", name); exit(EXIT_FAILURE); }
        if (little_endian()) for (int column = 1; column <= NX; column++) grid[row][column] = swap_float(grid[row][column]);
    }
    if (fgetc(fp) != EOF) { fprintf(stderr, "File is larger than expected: %s\n", name); exit(EXIT_FAILURE); }
    fclose(fp); return grid;
}
static double norm_lon(double x) { x = fmod(x, 360.0); return x < 0 ? x + 360.0 : x; }

int main(int argc, char **argv) {
    if (argc != 7) { fprintf(stderr, "Usage: %s DATA.bin LAT.bin LNG.bin TIME.bin LATITUDE LONGITUDE\n", argv[0]); return EXIT_FAILURE; }
    Grid data = read_grid(argv[1]);
    Grid lat  = read_grid(argv[2]);
    Grid lon  = read_grid(argv[3]);
    Grid time = read_grid(argv[4]);
    double target_lat = strtod(argv[5], NULL), target_lon = norm_lon(strtod(argv[6], NULL));
    int best_row = 1, best_column = 1; double best = HUGE_VAL;
    for (int row = 1; row <= NY; row++) for (int column = 1; column <= NX; column++) {
        double dlat = lat[row][column] - target_lat;
        double dlon = fabs(norm_lon(lon[row][column]) - target_lon); dlon = fmin(dlon, 360.0 - dlon);
        double d2 = dlat*dlat + dlon*dlon;
        if (d2 < best) { best=d2; best_row=row; best_column=column; }
    }
    int row=best_row, column=best_column;
    printf("pixel      = [%d][%d]\n", row, column);
    printf("latitude   = %.6f deg\n", lat[row][column]);
    printf("longitude  = %.6f deg\n", lon[row][column]);
    printf("solar flux = %.3f W/m^2\n", data[row][column]);
    printf("elapsed UTC seconds from filename date 00:00 = %.3f\n", (double)time[row][column] * 86400.0);
    free(data); free(lat); free(lon);     free(time);
    return EXIT_SUCCESS;
}

METEOSAT-IODC fld.3km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define NX 4000
#define NY 4000
typedef float (*Grid)[NX + 1];

/* Index 0 is intentionally unused; the first pixel is grid[1][1]. */
static int little_endian(void) { const uint16_t x = 1; return *(const uint8_t *)&x; }
static float swap_float(float value) {
    union { float f; uint8_t b[4]; } in = { .f = value }, out;
    out.b[0]=in.b[3]; out.b[1]=in.b[2]; out.b[2]=in.b[1]; out.b[3]=in.b[0];
    return out.f;
}
static Grid read_grid(const char *name) {
    FILE *fp = fopen(name, "rb");
    Grid grid = calloc(NY + 1, sizeof *grid);
    if (!fp || !grid) { perror(name); exit(EXIT_FAILURE); }
    for (int row = 1; row <= NY; row++) {
        if (fread(&grid[row][1], sizeof(float), NX, fp) != NX) { fprintf(stderr, "Short file: %s\n", name); exit(EXIT_FAILURE); }
        if (little_endian()) for (int column = 1; column <= NX; column++) grid[row][column] = swap_float(grid[row][column]);
    }
    if (fgetc(fp) != EOF) { fprintf(stderr, "File is larger than expected: %s\n", name); exit(EXIT_FAILURE); }
    fclose(fp); return grid;
}
static double norm_lon(double x) { x = fmod(x, 360.0); return x < 0 ? x + 360.0 : x; }

int main(int argc, char **argv) {
    if (argc != 6) { fprintf(stderr, "Usage: %s DATA.bin LAT.bin LNG.bin LATITUDE LONGITUDE\n", argv[0]); return EXIT_FAILURE; }
    Grid data = read_grid(argv[1]);
    Grid lat  = read_grid(argv[2]);
    Grid lon  = read_grid(argv[3]);
    double target_lat = strtod(argv[4], NULL), target_lon = norm_lon(strtod(argv[5], NULL));
    int best_row = 1, best_column = 1; double best = HUGE_VAL;
    for (int row = 1; row <= NY; row++) for (int column = 1; column <= NX; column++) {
        double dlat = lat[row][column] - target_lat;
        double dlon = fabs(norm_lon(lon[row][column]) - target_lon); dlon = fmin(dlon, 360.0 - dlon);
        double d2 = dlat*dlat + dlon*dlon;
        if (d2 < best) { best=d2; best_row=row; best_column=column; }
    }
    int row=best_row, column=best_column;
    printf("pixel      = [%d][%d]\n", row, column);
    printf("latitude   = %.6f deg\n", lat[row][column]);
    printf("longitude  = %.6f deg\n", lon[row][column]);
    printf("solar flux = %.3f W/m^2\n", data[row][column]);
    free(data); free(lat); free(lon);     return EXIT_SUCCESS;
}

HIMAWARI fld.4km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

program amaterass_pickup
  use iso_fortran_env, only: real32, real64, error_unit
  implicit none
  integer, parameter :: NX=3000, NY=3000
  real(real32), allocatable :: data(:,:), lat(:,:), lon(:,:), time
  character(len=1024) :: arg(6)
  integer :: i, row, col, best_row, best_col
  real(real64) :: target_lat, target_lon, dlat, dlon, d2, best

  ! Fortran arrays are naturally one-based; the first pixel is (1,1).
  if (command_argument_count() /= 6) error stop 'Invalid number of arguments'
  do i=1,6; call get_command_argument(i,arg(i)); end do
  allocate(data(NY,NX), lat(NY,NX), lon(NY,NX), time(NY,NX))
  call read_grid(trim(arg(1)), data)
  call read_grid(trim(arg(2)), lat)
  call read_grid(trim(arg(3)), lon)
  call read_grid(trim(arg(4)), time)
  read(arg(5),*) target_lat; read(arg(6),*) target_lon
  target_lon = modulo(target_lon,360.0_real64)
  best=huge(best); best_row=1; best_col=1
  do row=1,NY
    do col=1,NX
      dlat=real(lat(row,col),real64)-target_lat
      dlon=abs(modulo(real(lon(row,col),real64),360.0_real64)-target_lon); dlon=min(dlon,360.0_real64-dlon)
      d2=dlat*dlat+dlon*dlon
      if (d2<best) then; best=d2; best_row=row; best_col=col; end if
    end do
  end do
  print '(A,I0,A,I0,A)', 'pixel      = [',best_row,'][',best_col,']'
  print '(A,F12.6)', 'latitude   = ',lat(best_row,best_col)
  print '(A,F12.6)', 'longitude  = ',lon(best_row,best_col)
  print '(A,F12.3)', 'solar flux = ',data(best_row,best_col)
  print '(A,F12.3)', 'elapsed UTC seconds from filename date 00:00 = ', real(time(best_row,best_col),real64)*86400.0_real64
contains
  subroutine read_grid(name,grid)
    character(len=*),intent(in)::name
    real(real32),intent(out)::grid(NY,NX)
    real(real32)::row_values(NX)
    integer::u,r,stat
    open(newunit=u,file=name,access='stream',form='unformatted',status='old',action='read',convert='big_endian')
    do r=1,NY
      read(u,iostat=stat) row_values
      if(stat/=0) error stop 'Unexpected end of file'
      grid(r,1:NX)=row_values
    end do
    close(u)
  end subroutine
end program

METEOSAT-IODC fld.3km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

program amaterass_pickup_iodc
  use iso_fortran_env, only: real32, real64, error_unit
  implicit none
  integer, parameter :: NX=4000, NY=4000
  real(real32), allocatable :: data(:,:), lat(:,:), lon(:,:)
  character(len=1024) :: arg(5)
  integer :: i, row, col, best_row, best_col
  real(real64) :: target_lat, target_lon, dlat, dlon, d2, best

  ! Fortran arrays are naturally one-based; the first pixel is (1,1).
  if (command_argument_count() /= 5) error stop 'Invalid number of arguments'
  do i=1,5; call get_command_argument(i,arg(i)); end do
  allocate(data(NY,NX), lat(NY,NX), lon(NY,NX))
  call read_grid(trim(arg(1)), data)
  call read_grid(trim(arg(2)), lat)
  call read_grid(trim(arg(3)), lon)
  read(arg(4),*) target_lat; read(arg(5),*) target_lon
  target_lon = modulo(target_lon,360.0_real64)
  best=huge(best); best_row=1; best_col=1
  do row=1,NY
    do col=1,NX
      dlat=real(lat(row,col),real64)-target_lat
      dlon=abs(modulo(real(lon(row,col),real64),360.0_real64)-target_lon); dlon=min(dlon,360.0_real64-dlon)
      d2=dlat*dlat+dlon*dlon
      if (d2<best) then; best=d2; best_row=row; best_col=col; end if
    end do
  end do
  print '(A,I0,A,I0,A)', 'pixel      = [',best_row,'][',best_col,']'
  print '(A,F12.6)', 'latitude   = ',lat(best_row,best_col)
  print '(A,F12.6)', 'longitude  = ',lon(best_row,best_col)
  print '(A,F12.3)', 'solar flux = ',data(best_row,best_col)
contains
  subroutine read_grid(name,grid)
    character(len=*),intent(in)::name
    real(real32),intent(out)::grid(NY,NX)
    real(real32)::row_values(NX)
    integer::u,r,stat
    open(newunit=u,file=name,access='stream',form='unformatted',status='old',action='read',convert='big_endian')
    do r=1,NY
      read(u,iostat=stat) row_values
      if(stat/=0) error stop 'Unexpected end of file'
      grid(r,1:NX)=row_values
    end do
    close(u)
  end subroutine
end program

HIMAWARI fld.4km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

from pathlib import Path
import sys
import numpy as np

NX, NY = 3000, 3000

def read_grid(path: Path) -> np.ndarray:
    raw = np.fromfile(path, dtype=">f4")
    if raw.size != NX * NY:
        raise ValueError(f"unexpected size: {path} ({raw.size} values)")
    grid = np.empty((NY + 1, NX + 1), dtype=np.float32)
    grid[0, :] = np.nan; grid[:, 0] = np.nan
    grid[1:, 1:] = raw.reshape(NY, NX)
    return grid

def main() -> None:
    # Index 0 is intentionally unused; the first pixel is grid[1, 1].
    if len(sys.argv) != 7:
        raise SystemExit("invalid number of arguments")
    data = read_grid(Path(sys.argv[1]))
    lat = read_grid(Path(sys.argv[2]))
    lon = read_grid(Path(sys.argv[3]))
    time = read_grid(Path(sys.argv[4]))
    target_lat = float(sys.argv[5]); target_lon = float(sys.argv[6]) % 360.0
    dlat = lat[1:, 1:] - target_lat
    dlon = np.abs(np.mod(lon[1:, 1:], 360.0) - target_lon); dlon = np.minimum(dlon, 360.0 - dlon)
    flat = int(np.nanargmin(dlat*dlat + dlon*dlon))
    row0, col0 = np.unravel_index(flat, (NY, NX)); row, column = row0 + 1, col0 + 1
    print(f"pixel      = [{row}][{column}]")
    print(f"latitude   = {lat[row, column]:.6f} deg")
    print(f"longitude  = {lon[row, column]:.6f} deg")
    print(f"solar flux = {data[row, column]:.3f} W/m^2")
    print(f"elapsed UTC seconds from filename date 00:00 = {float(time[row, column]) * 86400.0:.3f}")

if __name__ == "__main__":
    main()

METEOSAT-IODC fld.3km specific The first pixel uses one-based indices, and data and coordinates are matched at identical indices.

from pathlib import Path
import sys
import numpy as np

NX, NY = 4000, 4000

def read_grid(path: Path) -> np.ndarray:
    raw = np.fromfile(path, dtype=">f4")
    if raw.size != NX * NY:
        raise ValueError(f"unexpected size: {path} ({raw.size} values)")
    grid = np.empty((NY + 1, NX + 1), dtype=np.float32)
    grid[0, :] = np.nan; grid[:, 0] = np.nan
    grid[1:, 1:] = raw.reshape(NY, NX)
    return grid

def main() -> None:
    # Index 0 is intentionally unused; the first pixel is grid[1, 1].
    if len(sys.argv) != 6:
        raise SystemExit("invalid number of arguments")
    data = read_grid(Path(sys.argv[1]))
    lat = read_grid(Path(sys.argv[2]))
    lon = read_grid(Path(sys.argv[3]))
    target_lat = float(sys.argv[4]); target_lon = float(sys.argv[5]) % 360.0
    dlat = lat[1:, 1:] - target_lat
    dlon = np.abs(np.mod(lon[1:, 1:], 360.0) - target_lon); dlon = np.minimum(dlon, 360.0 - dlon)
    flat = int(np.nanargmin(dlat*dlat + dlon*dlon))
    row0, col0 = np.unravel_index(flat, (NY, NX)); row, column = row0 + 1, col0 + 1
    print(f"pixel      = [{row}][{column}]")
    print(f"latitude   = {lat[row, column]:.6f} deg")
    print(f"longitude  = {lon[row, column]:.6f} deg")
    print(f"solar flux = {data[row, column]:.3f} W/m^2")

if __name__ == "__main__":
    main()