Using geostationary satellite data,explore how solar radiation changes

#!/bin/sh
set -u
ok=1
check_cmd(){ label=$1; cmd=$2; if command -v "$cmd" >/dev/null 2>&1; then printf '%-16s OK\n' "$label"; else printf '%-16s NG\n' "$label"; ok=0; fi; }
check_cmd java java
check_cmd javac javac
if command -v wget1 >/dev/null 2>&1; then printf '%-16s OK\n' 'GNU Wget 1.x'; elif command -v wget >/dev/null 2>&1 && ! wget --version 2>&1 | grep -q 'Wget2'; then printf '%-16s OK\n' 'GNU Wget 1.x'; else printf '%-16s NG\n' 'GNU Wget 1.x'; ok=0; fi
check_cmd bzip2 bzip2
if date -u -d '2016-08-20 08:00 +0900' +%Y%m%d%H%M >/dev/null 2>&1; then printf '%-16s OK\n' 'GNU date'; else printf '%-16s NG\n' 'GNU date'; ok=0; fi
if command -v magick >/dev/null 2>&1 || command -v convert >/dev/null 2>&1; then printf '%-16s OK\n' 'ImageMagick'; else printf '%-16s NG\n' 'ImageMagick'; ok=0; fi
check_cmd Gnuplot gnuplot
if [ "$ok" -eq 1 ]; then echo 'SYSTEM READY'; exit 0; fi
echo 'SYSTEM NOT READY'; exit 1

#!/bin/sh
set -eu

select_wget() {
    if command -v wget1 >/dev/null 2>&1; then
        echo wget1
    elif command -v wget >/dev/null 2>&1 && ! wget --version 2>&1 | grep -q 'Wget2'; then
        echo wget
    else
        echo 'Error: GNU Wget 1.x (wget or wget1) is required.' >&2
        exit 1
    fi
}

EXPECTED=30262084
WGET=$(select_wget)
TOOLS=${AMATERASS_TOOLS_BASE:-ftp://amaterass.cr.chiba-u.ac.jp/quasi-realtime/himawari829/tools}
DEST=data/reference
mkdir -p "$DEST"
file_is_complete() { FILE=$1; [ -f "$FILE" ] || return 1; SIZE=$(wc -c < "$FILE" | tr -d ' '); [ "$SIZE" -eq "$EXPECTED" ]; }
DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=
cleanup_pending() { [ -n "$DECOMP_PID" ] || return 0; kill "$DECOMP_PID" 2>/dev/null || true; wait "$DECOMP_PID" 2>/dev/null || true; rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=; }
trap 'cleanup_pending' 0
trap 'cleanup_pending; exit 1' 1 2 15
finish_decompress() {
    [ -n "$DECOMP_PID" ] || return 0
    if ! wait "$DECOMP_PID"; then rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; echo "Decompression failed: $DECOMP_BZ2" >&2; DECOMP_PID=; return 1; fi
    if ! file_is_complete "$DEST/$DECOMP_NAME"; then SIZE=$(wc -c < "$DEST/$DECOMP_NAME" 2>/dev/null | tr -d ' ' || echo 0); rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; echo "Unexpected file size: $DEST/$DECOMP_NAME ($SIZE bytes)" >&2; DECOMP_PID=; return 1; fi
    rm -f "$DEST/$DECOMP_BZ2"
    DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=
}
for NAME in standard_2521x3001.lat.msm.1km.bin standard_2521x3001.lng.msm.1km.bin
do
    BZ2="$NAME.bz2"
    if file_is_complete "$DEST/$NAME"; then rm -f "$DEST/$BZ2"; echo "Already exists: $DEST/$NAME"; continue; fi
    if [ -e "$DEST/$NAME" ]; then SIZE=$(wc -c < "$DEST/$NAME" | tr -d ' '); echo "Removing incomplete file: $NAME ($SIZE bytes)"; rm -f "$DEST/$NAME"; fi
    (cd "$DEST" && "$WGET" -c "$TOOLS/$BZ2")
    finish_decompress || exit 1
    rm -f "$DEST/$NAME"
    (cd "$DEST" && bzip2 -d "$BZ2") &
    DECOMP_PID=$!; DECOMP_NAME=$NAME; DECOMP_BZ2=$BZ2
done
finish_decompress || exit 1
trap - 0 1 2 15
echo 'LAT/LNG ready.'

#!/bin/sh
set -eu

select_wget() {
    if command -v wget1 >/dev/null 2>&1; then
        echo wget1
    elif command -v wget >/dev/null 2>&1 && ! wget --version 2>&1 | grep -q 'Wget2'; then
        echo wget
    else
        echo 'Error: GNU Wget 1.x (wget or wget1) is required.' >&2
        exit 1
    fi
}

[ "$#" -eq 5 ] || { echo "Usage: $0 YYYY MM DD HH MN" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; HH=$4; MN=$5
case "$YYYY" in [0-9][0-9][0-9][0-9]) ;; *) echo 'YYYY must be four digits.' >&2; exit 1;; esac
case "$MM" in 0[1-9]|1[0-2]) ;; *) echo 'MM must be 01-12.' >&2; exit 1;; esac
case "$DD" in 0[1-9]|[12][0-9]|3[01]) ;; *) echo 'DD must be 01-31.' >&2; exit 1;; esac
case "$HH" in [01][0-9]|2[0-3]) ;; *) echo 'HH must be 00-23.' >&2; exit 1;; esac
case "$MN" in 00|10|20|30|40|50) ;; *) echo 'MN must be one of 00,10,20,30,40,50.' >&2; exit 1;; esac
DAY="${YYYY}${MM}${DD}"; TIME="${DAY}${HH}${MN}"; YYYYMM="${YYYY}${MM}"
EXPECTED=30262084
WGET=$(select_wget)
BASE=${AMATERASS_JP_BASE:-ftp://amaterass.cr.chiba-u.ac.jp/quasi-realtime/himawari829/archived/JP}
DEST=data/sample; DIR="$BASE/$YYYYMM/$DAY"; mkdir -p "$DEST"
file_is_complete() { FILE=$1; [ -f "$FILE" ] || return 1; SIZE=$(wc -c < "$FILE" | tr -d ' '); [ "$SIZE" -eq "$EXPECTED" ]; }
DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=
cleanup_pending() { [ -n "$DECOMP_PID" ] || return 0; kill "$DECOMP_PID" 2>/dev/null || true; wait "$DECOMP_PID" 2>/dev/null || true; rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=; }
trap 'cleanup_pending' 0
trap 'cleanup_pending; exit 1' 1 2 15
finish_decompress() {
    [ -n "$DECOMP_PID" ] || return 0
    if ! wait "$DECOMP_PID"; then rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; echo "Decompression failed: $DECOMP_BZ2" >&2; DECOMP_PID=; return 1; fi
    if ! file_is_complete "$DEST/$DECOMP_NAME"; then SIZE=$(wc -c < "$DEST/$DECOMP_NAME" 2>/dev/null | tr -d ' ' || echo 0); rm -f "$DEST/$DECOMP_NAME" "$DEST/$DECOMP_BZ2"; echo "Unexpected file size: $DEST/$DECOMP_NAME ($SIZE bytes)" >&2; DECOMP_PID=; return 1; fi
    rm -f "$DEST/$DECOMP_BZ2"; DECOMP_PID=; DECOMP_NAME=; DECOMP_BZ2=
}
for TYPE in dwn.sw.flx.sfc.msm.1km.bin grd.time.mjd.hms.msm.1km.bin
do
    NAME="$TIME.$TYPE"; BZ2="$NAME.bz2"
    if file_is_complete "$DEST/$NAME"; then rm -f "$DEST/$BZ2"; echo "Already exists: $DEST/$NAME"; continue; fi
    if [ -e "$DEST/$NAME" ]; then SIZE=$(wc -c < "$DEST/$NAME" | tr -d ' '); echo "Removing incomplete file: $NAME ($SIZE bytes)"; rm -f "$DEST/$NAME"; fi
    (cd "$DEST" && "$WGET" -c "$DIR/$BZ2")
    finish_decompress || exit 1
    rm -f "$DEST/$NAME"
    (cd "$DEST" && bzip2 -d "$BZ2") &
    DECOMP_PID=$!; DECOMP_NAME=$NAME; DECOMP_BZ2=$BZ2
done
finish_decompress || exit 1
trap - 0 1 2 15
echo "Sample solar/TIME ready: $TIME"

#!/bin/sh
set -eu

[ "$#" -eq 5 ] || { echo "Usage: $0 file max min color_div unit" >&2; exit 1; }
FILE=$1
MAX=$2
MIN=$3
DIV=$4
UNIT=$5
[ -f "$FILE" ] || { echo "Missing: $FILE" >&2; exit 1; }
[ -f tmap/tmap.class ] || { echo 'Tmap is not compiled. Run: cd tmap && javac *.java' >&2; exit 1; }

GRID="$FILE.grid.txt"
if [ -f "$GRID" ]; then
    getv() { sed -n "s/^$1=//p" "$GRID" | head -n 1; }
    WIDTH=$(getv width)
    HEIGHT=$(getv height)
    NORTH=$(getv north)
    LAT_SPAN=$(getv lat_span)
    WEST=$(getv west)
    LON_SPAN=$(getv lon_span)
    LAT_DIV=$(getv lat_div)
    LON_DIV=$(getv lon_div)
    : "${LAT_DIV:=6}" "${LON_DIV:=6}"
else
    SIZE=$(wc -c < "$FILE" | tr -d ' ')
    if [ "$SIZE" -ne 30262084 ]; then
        echo "No grid metadata for non-standard file: $FILE" >&2
        exit 1
    fi
    WIDTH=3001
    HEIGHT=2521
    NORTH=47.6
    LAT_SPAN=25.2
    LAT_DIV=5
    WEST=120
    LON_SPAN=30
    LON_DIV=6
fi

(
    cd tmap
    java tmap "../$FILE" "$MAX" "$MIN" "$DIV" "$UNIT" auto png \
      "$NORTH" "$LAT_SPAN" "$LAT_DIV" "$WEST" "$LON_SPAN" "$LON_DIV" \
      "$WIDTH" "$HEIGHT"
)

#!/bin/sh
set -eu
select_wget(){ if command -v wget1 >/dev/null 2>&1; then echo wget1; elif command -v wget >/dev/null 2>&1 && ! wget --version 2>&1 | grep -q 'Wget2'; then echo wget; else echo 'Error: GNU Wget 1.x (wget or wget1) is required.' >&2; exit 1; fi; }
[ "$#" -eq 7 ] || [ "$#" -eq 8 ] || { echo "Usage: $0 YYYY MM DD START_HH START_MN END_HH END_MN [DECOMP_JOBS]" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; START_HH=$4; START_MN=$5; END_HH=$6; END_MN=$7; JOBS=${8:-4}; DAY="${YYYY}${MM}${DD}"
case "$JOBS" in ''|*[!0-9]*) echo 'DECOMP_JOBS must be a positive integer.' >&2; exit 1;; esac
CHECK=$(date -u -d "${YYYY}-${MM}-${DD}" +%Y%m%d 2>/dev/null || true); [ "$CHECK" = "$DAY" ] || { echo 'Invalid calendar date.' >&2; exit 1; }
START=$(date -u -d "${YYYY}-${MM}-${DD} ${START_HH}:${START_MN} +0900" +%s); END=$(date -u -d "${YYYY}-${MM}-${DD} ${END_HH}:${END_MN} +0900" +%s); [ "$END" -ge "$START" ] || { echo 'End time must not be earlier than start time.' >&2; exit 1; }
EXPECTED=30262084; WGET=$(select_wget); BASE=${AMATERASS_JP_BASE:-ftp://amaterass.cr.chiba-u.ac.jp/quasi-realtime/himawari829/archived/JP}; DEST="data/animation/$DAY"; LIST="$DEST/timestamps.txt"; mkdir -p "$DEST"; : > "$LIST"
file_is_complete(){ FILE=$1; [ -f "$FILE" ] || return 1; SIZE=$(wc -c < "$FILE" | tr -d ' '); [ "$SIZE" -eq "$EXPECTED" ]; }
QUEUE=; RUNNING=0
cleanup_queue(){ for JOB in $QUEUE; do PID=${JOB%%|*}; REST=${JOB#*|}; NAME=${REST%%|*}; BZ2=${REST#*|}; kill "$PID" 2>/dev/null || true; wait "$PID" 2>/dev/null || true; rm -f "$DEST/$NAME" "$DEST/$BZ2"; done; QUEUE=; RUNNING=0; }
trap 'cleanup_queue' 0; trap 'cleanup_queue; exit 1' 1 2 15
finish_oldest(){ [ "$RUNNING" -gt 0 ] || return 0; set -- $QUEUE; JOB=$1; shift; QUEUE="$*"; PID=${JOB%%|*}; REST=${JOB#*|}; NAME=${REST%%|*}; BZ2=${REST#*|}; if ! wait "$PID"; then rm -f "$DEST/$NAME" "$DEST/$BZ2"; echo "Decompression failed: $BZ2" >&2; exit 1; fi; if ! file_is_complete "$DEST/$NAME"; then SIZE=$(wc -c < "$DEST/$NAME" 2>/dev/null | tr -d ' ' || echo 0); rm -f "$DEST/$NAME" "$DEST/$BZ2"; echo "Unexpected file size: $DEST/$NAME ($SIZE bytes)" >&2; exit 1; fi; rm -f "$DEST/$BZ2"; echo "Ready: $NAME"; RUNNING=$((RUNNING-1)); }
start_decompress(){ NAME=$1; BZ2=$2; rm -f "$DEST/$NAME"; (cd "$DEST" && bzip2 -d "$BZ2") & PID=$!; QUEUE="${QUEUE}${QUEUE:+ }${PID}|${NAME}|${BZ2}"; RUNNING=$((RUNNING+1)); [ "$RUNNING" -lt "$JOBS" ] || finish_oldest; }
T=$START; TOTAL=0
while [ "$T" -le "$END" ]; do
    TIME=$(date -u -d "@$T" +%Y%m%d%H%M); printf '%s\n' "$TIME" >> "$LIST"; TOTAL=$((TOTAL+1)); YYYYMM=$(printf '%s' "$TIME"|cut -c1-6); YYYYMMDD=$(printf '%s' "$TIME"|cut -c1-8); NAME="$TIME.dwn.sw.flx.sfc.msm.1km.bin"; BZ2="$NAME.bz2"
    if file_is_complete "$DEST/$NAME"; then rm -f "$DEST/$BZ2"; else if [ -e "$DEST/$NAME" ]; then SIZE=$(wc -c < "$DEST/$NAME"|tr -d ' '); echo "Removing incomplete file: $NAME ($SIZE bytes)"; rm -f "$DEST/$NAME"; fi; URL="$BASE/$YYYYMM/$YYYYMMDD/$BZ2"; if (cd "$DEST" && "$WGET" -q -c "$URL"); then start_decompress "$NAME" "$BZ2"; else rm -f "$DEST/$BZ2"; fi; fi
    T=$((T+600))
done
while [ "$RUNNING" -gt 0 ]; do finish_oldest; done
trap - 0 1 2 15
READY=$(while IFS= read -r TIME; do file_is_complete "$DEST/$TIME.dwn.sw.flx.sfc.msm.1km.bin" && echo 1; done < "$LIST" | wc -l | tr -d ' ')
[ "$READY" -gt 1 ] || { echo 'Not enough frames were downloaded.' >&2; exit 1; }
echo "Available frames: $READY / $TOTAL (max $JOBS decompression jobs)"; echo "Timestamp list: $LIST"

#!/bin/sh
set -eu

[ "$#" -eq 7 ] || { echo "Usage: $0 YYYY MM DD MAX MIN COLOR_DIV UNIT" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; MAX=$4; MIN=$5; DIV=$6; UNIT=$7
DAY="${YYYY}${MM}${DD}"
DEST="data/animation/$DAY"
LIST="$DEST/timestamps.txt"
[ -f "$LIST" ] || { echo "Missing: $LIST" >&2; exit 1; }
COUNT=0
while IFS= read -r TIME; do
    [ -n "$TIME" ] || continue
    FILE="$DEST/$TIME.dwn.sw.flx.sfc.msm.1km.bin"
    [ -f "$FILE" ] || continue
    ./draw_map.sh "$FILE" "$MAX" "$MIN" "$DIV" "$UNIT"
    COUNT=$((COUNT + 1))
done < "$LIST"
[ "$COUNT" -gt 1 ] || { echo 'Not enough frames to render.' >&2; exit 1; }
echo "PNG frames ready: $COUNT"

#!/bin/sh
set -eu

[ "$#" -eq 5 ] || { echo "Usage: $0 YYYY MM DD WIDTH DELAY" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; WIDTH=$4; DELAY=$5
DAY="${YYYY}${MM}${DD}"
DEST="data/animation/$DAY"
LIST="$DEST/timestamps.txt"
OUT="amaterass_${DAY}.gif"
[ -f "$LIST" ] || { echo "Missing: $LIST" >&2; exit 1; }
case "$WIDTH" in ''|*[!0-9]*) echo 'WIDTH must be a positive integer.' >&2; exit 1;; esac
case "$DELAY" in ''|*[!0-9]*) echo 'DELAY must be a non-negative integer.' >&2; exit 1;; esac
[ "$WIDTH" -gt 0 ] || { echo 'WIDTH must be greater than zero.' >&2; exit 1; }
set --
while IFS= read -r TIME; do
    [ -n "$TIME" ] || continue
    PNG="$DEST/$TIME.dwn.sw.flx.sfc.msm.1km.bin.png"
    [ -f "$PNG" ] || continue
    set -- "$@" "$PNG"
done < "$LIST"
[ "$#" -gt 1 ] || { echo 'Not enough PNG files for an animation.' >&2; exit 1; }
if command -v magick >/dev/null 2>&1; then
    magick -delay "$DELAY" -loop 0 "$@" -resize "${WIDTH}x" "$OUT"
elif command -v convert >/dev/null 2>&1; then
    convert -delay "$DELAY" -loop 0 "$@" -resize "${WIDTH}x" "$OUT"
else
    echo 'ImageMagick is required.' >&2
    exit 1
fi
echo "Created: $OUT ($# frames, ${WIDTH} px wide)"

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;
import java.util.*;

final class FloatGrid {
    static long floatCount(Path p) throws IOException {
        long size = Files.size(p);
        if ((size & 3L) != 0) throw new IOException("File size is not a multiple of 4: " + p);
        return size / 4L;
    }

    static void requireSameSize(Path... ps) throws IOException {
        long s = Files.size(ps[0]);
        for (Path p : ps) if (Files.size(p) != s) throw new IOException("Grid size mismatch: " + p);
    }

    static MappedByteBuffer map(Path p) throws IOException {
        try (FileChannel ch = FileChannel.open(p, StandardOpenOption.READ)) {
            MappedByteBuffer b = ch.map(FileChannel.MapMode.READ_ONLY, 0, ch.size());
            b.order(ByteOrder.BIG_ENDIAN);
            return b;
        }
    }

    static float readAt(Path p, long index) throws IOException {
        try (RandomAccessFile raf = new RandomAccessFile(p.toFile(), "r")) {
            raf.seek(index * 4L);
            return raf.readFloat();
        }
    }

    static void writeFloats(Path out, float[] data) throws IOException {
        Files.createDirectories(out.toAbsolutePath().getParent());
        try (DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(Files.newOutputStream(out)))) {
            for (float v : data) dos.writeFloat(v);
        }
    }

    static Path gridMetaPath(Path bin) {
        return Paths.get(bin.toString() + ".grid.txt");
    }

    static boolean hasGridMeta(Path bin) {
        return Files.isRegularFile(gridMetaPath(bin));
    }

    static Properties readGridMeta(Path bin) throws IOException {
        Path p = gridMetaPath(bin);
        Properties props = new Properties();
        try (Reader r = Files.newBufferedReader(p)) { props.load(r); }
        return props;
    }

    static void copyGridMeta(Path fromBin, Path toBin) throws IOException {
        Path from = gridMetaPath(fromBin);
        Path to = gridMetaPath(toBin);
        if (Files.isRegularFile(from)) {
            Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING);
        } else {
            Files.deleteIfExists(to);
        }
    }

    static boolean sameGridMeta(Path a, Path b) throws IOException {
        boolean ah = hasGridMeta(a);
        boolean bh = hasGridMeta(b);
        if (!ah && !bh) return true;
        if (ah != bh) return false;
        return readGridMeta(a).equals(readGridMeta(b));
    }
}

import java.nio.*;
import java.nio.file.*;
import java.time.*;
import java.time.format.*;

public class pixelinfo {
    public static void main(String[] args) throws Exception {
        if (args.length != 6) {
            System.err.println("Usage: pixelinfo solar lat lng time target_lat target_lon");
            System.exit(1);
        }
        Path solar = Paths.get(args[0]), latf = Paths.get(args[1]), lngf = Paths.get(args[2]), timef = Paths.get(args[3]);
        double targetLat = Double.parseDouble(args[4]);
        double targetLon = Double.parseDouble(args[5]);
        FloatGrid.requireSameSize(solar, latf, lngf, timef);
        long n = FloatGrid.floatCount(solar);
        if (n > Integer.MAX_VALUE) throw new IllegalArgumentException("Grid too large");

        MappedByteBuffer lat = FloatGrid.map(latf);
        MappedByteBuffer lng = FloatGrid.map(lngf);
        double best = Double.POSITIVE_INFINITY;
        int bestIndex = -1;
        float bestLat = Float.NaN, bestLon = Float.NaN;
        for (int i = 0; i < (int)n; i++) {
            float la = lat.getFloat(i * 4);
            float lo = lng.getFloat(i * 4);
            if (!Float.isFinite(la) || !Float.isFinite(lo)) continue;
            double dlat = la - targetLat;
            double dlon = (lo - targetLon) * Math.cos(Math.toRadians(targetLat));
            double d2 = dlat*dlat + dlon*dlon;
            if (d2 < best) { best = d2; bestIndex = i; bestLat = la; bestLon = lo; }
        }
        if (bestIndex < 0) throw new IllegalStateException("No valid coordinate found");

        float flux = FloatGrid.readAt(solar, bestIndex);
        float days = FloatGrid.readAt(timef, bestIndex);
        String name = solar.getFileName().toString();
        if (name.length() < 8) throw new IllegalArgumentException("Filename must begin with YYYYMMDD");
        LocalDate date = LocalDate.parse(name.substring(0,8), DateTimeFormatter.BASIC_ISO_DATE);
        long millis = Math.round(days * 86400.0 * 1000.0);
        Instant instant = date.atStartOfDay(ZoneOffset.UTC).toInstant().plusMillis(millis);
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS 'UTC'").withZone(ZoneOffset.UTC);

        int nx = 3001;
        int row = bestIndex / nx;
        int col = bestIndex % nx;
        System.out.printf("pixel       : row=%d column=%d (0-based)%n", row, col);
        System.out.printf("latitude    : %.6f deg%n", bestLat);
        System.out.printf("longitude   : %.6f deg%n", bestLon);
        System.out.printf("solar flux  : %.3f W/m^2%n", flux);
        System.out.printf("actual UTC  : %s%n", fmt.format(instant));
    }
}

#!/bin/sh
set -eu

select_wget() {
    if command -v wget1 >/dev/null 2>&1; then echo wget1
    elif command -v wget >/dev/null 2>&1 && ! wget --version 2>&1 | grep -q 'Wget2'; then echo wget
    else echo 'Error: GNU Wget 1.x (wget or wget1) is required.' >&2; exit 1
    fi
}
[ "$#" -eq 3 ] || [ "$#" -eq 4 ] || { echo "Usage: $0 YYYY MM DD [DECOMP_JOBS]" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; JOBS=${4:-4}
case "$JOBS" in ''|*[!0-9]*) echo 'DECOMP_JOBS must be a positive integer.' >&2; exit 1;; esac
[ "$JOBS" -ge 1 ] || { echo 'DECOMP_JOBS must be at least 1.' >&2; exit 1; }
DAY="${YYYY}${MM}${DD}"; YYYYMM="${YYYY}${MM}"; EXPECTED=30262084
WGET=$(select_wget); BASE=${AMATERASS_JP_BASE:-ftp://amaterass.cr.chiba-u.ac.jp/quasi-realtime/himawari829/archived/JP}; DEST="data/daily_raw/$DAY"
mkdir -p "$DEST"
file_is_complete(){ FILE=$1; [ -f "$FILE" ] || return 1; SIZE=$(wc -c < "$FILE" | tr -d ' '); [ "$SIZE" -eq "$EXPECTED" ]; }
QUEUE=; RUNNING=0
cleanup_queue(){ for JOB in $QUEUE; do PID=${JOB%%|*}; REST=${JOB#*|}; NAME=${REST%%|*}; BZ2=${REST#*|}; kill "$PID" 2>/dev/null || true; wait "$PID" 2>/dev/null || true; rm -f "$DEST/$NAME" "$DEST/$BZ2"; done; QUEUE=; RUNNING=0; }
trap 'cleanup_queue' 0
trap 'cleanup_queue; exit 1' 1 2 15
finish_oldest(){
    [ "$RUNNING" -gt 0 ] || return 0
    set -- $QUEUE; JOB=$1; shift; QUEUE="$*"
    PID=${JOB%%|*}; REST=${JOB#*|}; NAME=${REST%%|*}; BZ2=${REST#*|}
    if ! wait "$PID"; then rm -f "$DEST/$NAME" "$DEST/$BZ2"; echo "Decompression failed: $BZ2" >&2; exit 1; fi
    if ! file_is_complete "$DEST/$NAME"; then SIZE=$(wc -c < "$DEST/$NAME" 2>/dev/null | tr -d ' ' || echo 0); rm -f "$DEST/$NAME" "$DEST/$BZ2"; echo "Unexpected file size: $DEST/$NAME ($SIZE bytes)" >&2; exit 1; fi
    rm -f "$DEST/$BZ2"; echo "Ready: $NAME"; RUNNING=$((RUNNING-1))
}
start_decompress(){ NAME=$1; BZ2=$2; rm -f "$DEST/$NAME"; (cd "$DEST" && bzip2 -d "$BZ2") & PID=$!; QUEUE="${QUEUE}${QUEUE:+ }${PID}|${NAME}|${BZ2}"; RUNNING=$((RUNNING+1)); [ "$RUNNING" -lt "$JOBS" ] || finish_oldest; }
for HH in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23; do
  for MN in 00 10 20 30 40 50; do
    TIME="$DAY$HH$MN"; NAME="$TIME.dwn.sw.flx.sfc.msm.1km.bin"; BZ2="$NAME.bz2"
    if file_is_complete "$DEST/$NAME"; then rm -f "$DEST/$BZ2"; continue; fi
    if [ -e "$DEST/$NAME" ]; then SIZE=$(wc -c < "$DEST/$NAME" | tr -d ' '); echo "Removing incomplete file: $NAME ($SIZE bytes)"; rm -f "$DEST/$NAME"; fi
    URL="$BASE/$YYYYMM/$DAY/$BZ2"
    if (cd "$DEST" && "$WGET" -q -c "$URL"); then start_decompress "$NAME" "$BZ2"; else rm -f "$DEST/$BZ2"; fi
  done
done
while [ "$RUNNING" -gt 0 ]; do finish_oldest; done
trap - 0 1 2 15
COUNT=$(find "$DEST" -maxdepth 1 -type f -name "$DAY*.dwn.sw.flx.sfc.msm.1km.bin" -size 30262084c | wc -l | tr -d ' ')
[ "$COUNT" -gt 0 ] || { echo "No solar-radiation files were downloaded for $DAY. Check the date or network connection." >&2; exit 1; }
echo "Ready: $DAY ($COUNT files, max $JOBS decompression jobs)"

#!/bin/sh
set -eu
[ "$#" -eq 3 ] || { echo "Usage: $0 YYYY MM DD" >&2; exit 1; }
YYYY=$1; MM=$2; DD=$3; DAY="${YYYY}${MM}${DD}"; EXPECTED=30262084
SRC=analysis.msm1km/dailymean.java; CLS=analysis.msm1km/dailymean.class
[ -f "$SRC" ] || { echo 'Missing dailymean.java. Extract analysis_msm1km.tar.gz first.' >&2; exit 1; }
if [ ! -f "$CLS" ] || [ "$SRC" -nt "$CLS" ] || [ analysis.msm1km/FloatGrid.java -nt "$CLS" ]; then javac analysis.msm1km/*.java; fi
IN="data/daily_raw/$DAY"; OUT="data/daily/$DAY.dailymean.dwn.sw.flx.sfc.msm.1km.bin"; [ -d "$IN" ] || { echo "Missing: $IN" >&2; exit 1; }; mkdir -p data/daily; rm -f "$OUT"; java -cp analysis.msm1km dailymean "$IN" "$OUT"; SIZE=$(wc -c < "$OUT"|tr -d ' '); [ "$SIZE" -eq "$EXPECTED" ] || { rm -f "$OUT"; echo "Unexpected daily-mean size: $OUT ($SIZE bytes)" >&2; exit 1; }

import java.io.*;
import java.nio.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class dailymean {
    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            System.err.println("Usage: dailymean input_day_directory output.bin");
            System.exit(1);
        }
        Path dir = Paths.get(args[0]);
        Path out = Paths.get(args[1]);
        if (!Files.isDirectory(dir)) throw new IOException("Missing directory: " + dir);

        List<Path> all;
        try (Stream<Path> s = Files.list(dir)) {
            all = s.filter(p -> p.getFileName().toString().matches("\\d{12}\\.dwn\\.sw\\.flx\\.sfc\\.msm\\.1km\\.bin"))
                   .sorted().collect(Collectors.toList());
        }
        if (all.isEmpty()) throw new IOException("No 10-minute files in " + dir);
        long nLong = FloatGrid.floatCount(all.get(0));
        if (nLong > Integer.MAX_VALUE) throw new IOException("Grid too large");
        int n = (int)nLong;
        for (Path p : all) if (FloatGrid.floatCount(p) != nLong) throw new IOException("Size mismatch: " + p);

        float[] daily = new float[n];
        float[] hour = new float[n];
        for (int hh = 0; hh < 24; hh++) {
            final String hourKey = String.format("%02d", hh);
            List<Path> files = all.stream().filter(p -> {
                String x = p.getFileName().toString();
                return x.substring(8,10).equals(hourKey);
            }).collect(Collectors.toList());
            if (files.isEmpty()) {
                // AMATERASS solar-radiation files are not produced during fully dark hours.
                // For a 24-hour daily mean, those hours contribute 0 W/m^2.
                System.out.printf("hour %02d: 0 files -> 0 W/m^2%n", hh);
                continue;
            }
            Arrays.fill(hour, 0f);
            for (Path p : files) {
                MappedByteBuffer b = FloatGrid.map(p);
                for (int i=0;i<n;i++) hour[i] += b.getFloat(i*4);
            }
            float inv = 1.0f / files.size();
            for (int i=0;i<n;i++) daily[i] += hour[i] * inv;
            System.out.printf("hour %02d: %d files%n", hh, files.size());
        }
        for (int i=0;i<n;i++) daily[i] /= 24.0f;
        FloatGrid.writeFloats(out, daily);
        System.out.println("Created: " + out);
    }
}