気象関連ソフトウェア¶

// ECMWF APIクライアントの実装例
interface ECMWFGribData {
  date: string;
  time: string;
  step: string;
  levtype: string;
  param: string;
  area?: number[]; // North/West/South/East
  grid?: number[]; // lat/lon resolution
}

class ECMWFClient {
  private readonly baseUrl = 'https://api.ecmwf.int/v1';
  private apiKey: string;

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async retrieveForecast(request: ECMWFGribData): Promise<ArrayBuffer> {
    const response = await fetch(`${this.baseUrl}/services/mars/requests`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        class: 'od',
        type: 'fc',
        stream: 'oper',
        ...request
      })
    });

    if (!response.ok) {
      throw new Error(`ECMWF API error: ${response.statusText}`);
    }

    return response.arrayBuffer();
  }

  // アンサンブル予報データの取得
  async getEnsembleForecast(
    parameter: string,
    date: Date,
    area: [number, number, number, number] // N/W/S/E
  ): Promise<EnsembleForecast> {
    const ensembleMembers: ForecastData[] = [];

    // 51メンバーのアンサンブル予報を取得
    for (let member = 0; member <= 50; member++) {
      const gribData = await this.retrieveForecast({
        date: date.toISOString().split('T')[0],
        time: '00',
        step: '24/to/240/by/24',
        levtype: 'sfc',
        param: parameter,
        area,
        grid: [0.1, 0.1], // 0.1度格子
        number: member.toString()
      });

      ensembleMembers.push(await this.parseGribData(gribData));
    }

    return this.calculateEnsembleStatistics(ensembleMembers);
  }

  private async parseGribData(gribBuffer: ArrayBuffer): Promise<ForecastData> {
    // GRIB2データの解析
    const decoder = new GribDecoder();
    return decoder.decode(gribBuffer);
  }

  // アンサンブル統計の計算
  private calculateEnsembleStatistics(members: ForecastData[]): EnsembleForecast {
    const gridPoints = members[0].values.length;
    const mean = new Float32Array(gridPoints);
    const std = new Float32Array(gridPoints);
    const probability = new Float32Array(gridPoints);

    // 各格子点での統計計算
    for (let i = 0; i < gridPoints; i++) {
      const values = members.map(m => m.values[i]);

      // 平均
      mean[i] = values.reduce((sum, v) => sum + v, 0) / values.length;

      // 標準偏差
      const variance = values.reduce((sum, v) => sum + Math.pow(v - mean[i], 2), 0) / values.length;
      std[i] = Math.sqrt(variance);

      // 閾値を超える確率（例：降水1mm以上）
      probability[i] = values.filter(v => v >= 1.0).length / values.length;
    }

    return {
      ensembleMean: mean,
      ensembleSpread: std,
      probability,
      members: members.length
    };
  }
}

interface ForecastData {
  values: Float32Array;
  metadata: {
    parameter: string;
    level: number;
    validTime: Date;
    grid: { lat: number[], lon: number[] };
  };
}

interface EnsembleForecast {
  ensembleMean: Float32Array;
  ensembleSpread: Float32Array;
  probability: Float32Array;
  members: number;
}

// 台風進路予測システム
class TyphoonTrackForecast {
  private models: Map<string, WeatherModel> = new Map();

  constructor() {
    this.models.set('ECMWF', new ECMWFModel());
    this.models.set('GFS', new GFSModel());
    this.models.set('JMA', new JMAModel());
  }

  // 複数モデルによる台風進路予測
  async predictTyphoonTrack(
    typhoonId: string,
    currentPosition: { lat: number; lon: number },
    forecastHours: number = 120
  ): Promise<TyphoonForecast[]> {
    const forecasts: TyphoonForecast[] = [];

    for (const [modelName, model] of this.models) {
      try {
        const trackForecast = await model.getTyphoonTrack(
          typhoonId,
          currentPosition,
          forecastHours
        );

        forecasts.push({
          model: modelName,
          track: trackForecast,
          confidence: this.calculateConfidence(trackForecast),
          lastUpdate: new Date()
        });
      } catch (error) {
        console.error(`Failed to get forecast from ${modelName}:`, error);
      }
    }

    return this.generateConsensusTrack(forecasts);
  }

  // コンセンサス進路の生成
  private generateConsensusTrack(forecasts: TyphoonForecast[]): TyphoonForecast[] {
    if (forecasts.length === 0) return [];

    const forecastHours = forecasts[0].track.length;
    const consensusTrack: TyphoonTrackPoint[] = [];

    // 各予報時刻でのコンセンサス計算
    for (let i = 0; i < forecastHours; i++) {
      const positions = forecasts.map(f => f.track[i]).filter(p => p);

      if (positions.length > 0) {
        const avgLat = positions.reduce((sum, p) => sum + p.latitude, 0) / positions.length;
        const avgLon = positions.reduce((sum, p) => sum + p.longitude, 0) / positions.length;
        const avgPressure = positions.reduce((sum, p) => sum + p.centralPressure, 0) / positions.length;

        consensusTrack.push({
          time: positions[0].time,
          latitude: avgLat,
          longitude: avgLon,
          centralPressure: avgPressure,
          maxWindSpeed: Math.max(...positions.map(p => p.maxWindSpeed)),
          uncertainty: this.calculatePositionUncertainty(positions)
        });
      }
    }

    return [{
      model: 'CONSENSUS',
      track: consensusTrack,
      confidence: this.calculateEnsembleConfidence(forecasts),
      lastUpdate: new Date()
    }];
  }

  private calculatePositionUncertainty(positions: TyphoonTrackPoint[]): number {
    if (positions.length < 2) return 0;

    // 標準偏差を計算（km単位）
    const avgLat = positions.reduce((sum, p) => sum + p.latitude, 0) / positions.length;
    const avgLon = positions.reduce((sum, p) => sum + p.longitude, 0) / positions.length;

    const distances = positions.map(p => 
      this.calculateDistance(avgLat, avgLon, p.latitude, p.longitude)
    );

    const variance = distances.reduce((sum, d) => sum + d * d, 0) / distances.length;
    return Math.sqrt(variance);
  }

  private calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    const R = 6371; // 地球の半径 (km)
    const dLat = (lat2 - lat1) * Math.PI / 180;
    const dLon = (lon2 - lon1) * Math.PI / 180;
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
              Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
              Math.sin(dLon/2) * Math.sin(dLon/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return R * c;
  }
}

interface TyphoonTrackPoint {
  time: Date;
  latitude: number;
  longitude: number;
  centralPressure: number; // hPa
  maxWindSpeed: number; // m/s
  uncertainty?: number; // km
}

interface TyphoonForecast {
  model: string;
  track: TyphoonTrackPoint[];
  confidence: number;
  lastUpdate: Date;
}

// WRF設定ファイルの生成と実行管理
interface WRFNamelist {
  timeDomain: {
    startYear: number;
    startMonth: number;
    startDay: number;
    startHour: number;
    endYear: number;
    endMonth: number;
    endDay: number;
    endHour: number;
    intervalSeconds: number;
  };
  domains: WRFDomain[];
  physics: WRFPhysics;
  dynamics: WRFDynamics;
}

interface WRFDomain {
  id: number;
  parentId: number;
  parentRatio: number;
  iParentStart: number;
  jParentStart: number;
  eWE: number; // x方向の格子数
  eSN: number; // y方向の格子数
  eVert: number; // 鉛直方向の格子数
  dx: number; // x方向の格子間隔 (m)
  dy: number; // y方向の格子間隔 (m)
  mapProj: string; // 地図投影法
  refLat: number;
  refLon: number;
  truelat1: number;
  truelat2: number;
  standLon: number;
}

interface WRFPhysics {
  microphysics: number; // 雲物理過程
  convection: number; // 積雲対流パラメタリゼーション
  pbl: number; // 境界層スキーム
  surface: number; // 地表面スキーム
  radiation: {
    longwave: number;
    shortwave: number;
  };
}

interface WRFDynamics {
  timeStep: number; // 積分時間間隔
  epssm: number; // 数値安定化フィルター強度
  nonHydrostatic: boolean; // 非静力学近似
  moistAdv: number; // 水蒸気移流スキーム
}

class WRFModelManager {
  private configPath: string;
  private workingDirectory: string;
  private isRunning: boolean = false;

  constructor(workingDir: string) {
    this.workingDirectory = workingDir;
    this.configPath = `${workingDir}/namelist.wps`;
  }

  // WPS（前処理）の設定生成
  generateWPSNamelist(domain: WRFDomain, startDate: Date, endDate: Date): string {
    const namelistContent = `
&share
wrf_core = 'ARW',
max_dom = 1,
start_date = '${this.formatDate(startDate)}',
end_date = '${this.formatDate(endDate)}',
interval_seconds = 21600,
io_form_geogrid = 2,
/

&geogrid
parent_id = 1,
parent_grid_ratio = 1,
i_parent_start = 1,
j_parent_start = 1,
e_we = ${domain.eWE},
e_sn = ${domain.eSN},
dx = ${domain.dx},
dy = ${domain.dy},
map_proj = '${domain.mapProj}',
ref_lat = ${domain.refLat},
ref_lon = ${domain.refLon},
truelat1 = ${domain.truelat1},
truelat2 = ${domain.truelat2},
stand_lon = ${domain.standLon},
geog_data_path = '/path/to/geog/'
/

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

&metgrid
fg_name = 'FILE',
io_form_metgrid = 2,
/
    `.trim();

    return namelistContent;
  }

  // WRF本体の設定生成（詳細な物理過程設定）
  generateWRFNamelist(config: WRFNamelist): string {
    const startDate = new Date(
      config.timeDomain.startYear,
      config.timeDomain.startMonth - 1,
      config.timeDomain.startDay,
      config.timeDomain.startHour
    );
    const endDate = new Date(
      config.timeDomain.endYear,
      config.timeDomain.endMonth - 1,
      config.timeDomain.endDay,
      config.timeDomain.endHour
    );

    const runHours = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60));

    const namelistContent = `
&time_control
run_days = 0,
run_hours = ${runHours},
run_minutes = 0,
run_seconds = 0,
start_year = ${config.timeDomain.startYear},
start_month = ${config.timeDomain.startMonth},
start_day = ${config.timeDomain.startDay},
start_hour = ${config.timeDomain.startHour},
start_minute = 0,
start_second = 0,
end_year = ${config.timeDomain.endYear},
end_month = ${config.timeDomain.endMonth},
end_day = ${config.timeDomain.endDay},
end_hour = ${config.timeDomain.endHour},
end_minute = 0,
end_second = 0,
interval_seconds = ${config.timeDomain.intervalSeconds},
input_from_file = .true.,
history_interval = 60,
frames_per_outfile = 1,
restart = .false.,
restart_interval = 5000,
io_form_history = 2,
io_form_restart = 2,
io_form_input = 2,
io_form_boundary = 2,
debug_level = 0,
/

&domains
time_step = ${config.dynamics.timeStep},
time_step_fract_num = 0,
time_step_fract_den = 1,
max_dom = ${config.domains.length},
e_we = ${config.domains.map(d => d.eWE).join(', ')},
e_sn = ${config.domains.map(d => d.eSN).join(', ')},
e_vert = ${config.domains.map(d => d.eVert).join(', ')},
p_top_requested = 5000,
num_metgrid_levels = 40,
num_metgrid_soil_levels = 4,
dx = ${config.domains.map(d => d.dx).join(', ')},
dy = ${config.domains.map(d => d.dy).join(', ')},
grid_id = ${config.domains.map(d => d.id).join(', ')},
parent_id = ${config.domains.map(d => d.parentId).join(', ')},
i_parent_start = ${config.domains.map(d => d.iParentStart).join(', ')},
j_parent_start = ${config.domains.map(d => d.jParentStart).join(', ')},
parent_grid_ratio = ${config.domains.map(d => d.parentRatio).join(', ')},
parent_time_step_ratio = ${config.domains.map(d => d.parentRatio).join(', ')},
feedback = 1,
smooth_option = 0,
/

&physics
mp_physics = ${config.physics.microphysics},
ra_lw_physics = ${config.physics.radiation.longwave},
ra_sw_physics = ${config.physics.radiation.shortwave},
radt = 30,
sf_sfclay_physics = 1,
sf_surface_physics = ${config.physics.surface},
bl_pbl_physics = ${config.physics.pbl},
bldt = 0,
cu_physics = ${config.physics.convection},
cudt = 5,
isfflx = 1,
ifsnow = 1,
icloud = 1,
surface_input_source = 1,
num_soil_layers = 4,
sf_urban_physics = 0,
/

&fdda
/

&dynamics
w_damping = 0,
diff_opt = 1,
km_opt = 4,
diff_6th_opt = 0,
diff_6th_factor = 0.12,
base_temp = 290.,
damp_opt = 0,
zdamp = 5000.,
dampcoef = 0.2,
khdif = 0,
kvdif = 0,
non_hydrostatic = ${config.dynamics.nonHydrostatic ? '.true.' : '.false.'},
moist_adv_opt = ${config.dynamics.moistAdv},
scalar_adv_opt = 1,
/

&bdy_control
spec_bdy_width = 5,
spec_zone = 1,
relax_zone = 4,
specified = .true.,
nested = .false.,
/

&grib2
/

&namelist_quilt
nio_tasks_per_group = 0,
nio_groups = 1,
/
    `.trim();

    return namelistContent;
  }

  // WRF実行の管理
  async runWRF(namelist: WRFNamelist): Promise<WRFRunResult> {
    if (this.isRunning) {
      throw new Error('WRF is already running');
    }

    this.isRunning = true;

    try {
      // 設定ファイル出力
      await this.writeNamelistFile(namelist);

      // 前処理実行（WPS）
      await this.executeCommand('geogrid.exe');
      await this.executeCommand('ungrib.exe');
      await this.executeCommand('metgrid.exe');

      // 初期化・境界条件生成
      await this.executeCommand('real.exe');

      // WRF本体実行
      const startTime = Date.now();
      await this.executeCommand('wrf.exe');
      const endTime = Date.now();

      // 結果ファイルの確認
      const outputFiles = await this.checkOutputFiles();

      return {
        success: true,
        executionTimeMs: endTime - startTime,
        outputFiles,
        logFiles: await this.getLogFiles()
      };

    } catch (error) {
      return {
        success: false,
        error: error.message,
        logFiles: await this.getLogFiles()
      };
    } finally {
      this.isRunning = false;
    }
  }

  // 結果データの解析
  async analyzeResults(outputFile: string): Promise<WRFAnalysisResult> {
    // NetCDFファイルの読み込み
    const netcdfData = await this.readNetCDF(outputFile);

    // 基本統計量の計算
    const precipitation = netcdfData.variables['RAINC'].add(netcdfData.variables['RAINNC']);
    const temperature = netcdfData.variables['T2'].subtract(273.15); // K → ℃
    const windU = netcdfData.variables['U10'];
    const windV = netcdfData.variables['V10'];

    // 最大・最小値の計算
    const maxPrecip = precipitation.max();
    const minTemp = temperature.min();
    const maxTemp = temperature.max();
    const maxWind = windU.pow(2).add(windV.pow(2)).sqrt().max();

    // 予報検証指標の計算
    const verification = await this.calculateVerificationScores(netcdfData);

    return {
      timeRange: {
        start: netcdfData.dimensions.Time.start,
        end: netcdfData.dimensions.Time.end
      },
      statistics: {
        precipitation: {
          max: maxPrecip,
          total: precipitation.sum(),
          mean: precipitation.mean()
        },
        temperature: {
          min: minTemp,
          max: maxTemp,
          mean: temperature.mean()
        },
        wind: {
          max: maxWind,
          mean: windU.pow(2).add(windV.pow(2)).sqrt().mean()
        }
      },
      verification,
      gridInfo: {
        dimensions: netcdfData.dimensions,
        resolution: {
          dx: netcdfData.globalAttributes.DX,
          dy: netcdfData.globalAttributes.DY
        }
      }
    };
  }

  private formatDate(date: Date): string {
    return date.toISOString().replace(/[-:]/g, '').split('.')[0];
  }

  private async executeCommand(command: string): Promise<void> {
    return new Promise((resolve, reject) => {
      const { exec } = require('child_process');
      const process = exec(
        command,
        { cwd: this.workingDirectory },
        (error, stdout, stderr) => {
          if (error) {
            reject(new Error(`Command failed: ${error.message}`));
          } else {
            resolve();
          }
        }
      );

      // リアルタイム進捗監視
      process.stdout.on('data', (data) => {
        console.log(`[${command}] ${data}`);
      });

      process.stderr.on('data', (data) => {
        console.error(`[${command}] ERROR: ${data}`);
      });
    });
  }
}

interface WRFRunResult {
  success: boolean;
  executionTimeMs?: number;
  outputFiles?: string[];
  logFiles?: string[];
  error?: string;
}

interface WRFAnalysisResult {
  timeRange: {
    start: Date;
    end: Date;
  };
  statistics: {
    precipitation: {
      max: number;
      total: number;
      mean: number;
    };
    temperature: {
      min: number;
      max: number;
      mean: number;
    };
    wind: {
      max: number;
      mean: number;
    };
  };
  verification: VerificationScores;
  gridInfo: {
    dimensions: any;
    resolution: {
      dx: number;
      dy: number;
    };
  };
}

interface VerificationScores {
  bias: number;
  rmse: number;
  correlation: number;
  threat: number; // Threat Score
  ets: number; // Equitable Threat Score
}

// 気象レーダーデータ処理システム
interface RadarScan {
  elevation: number; // 仰角
  azimuth: number[]; // 方位角配列
  range: number[]; // 距離配列
  reflectivity: number[][]; // 反射強度 (dBZ)
  velocity: number[][]; // ドップラー速度 (m/s)
  spectrumWidth: number[][]; // スペクトル幅
  timestamp: Date;
  radarId: string;
}

interface RadarVolume {
  scans: RadarScan[];
  radarLocation: {
    latitude: number;
    longitude: number;
    altitude: number;
  };
  volumeTimestamp: Date;
}

class WeatherRadarProcessor {
  private readonly REFLECTIVITY_THRESHOLD = 15; // dBZ
  private readonly VELOCITY_THRESHOLD = 15; // m/s

  // レーダーボリュームデータの処理
  processRadarVolume(volume: RadarVolume): RadarProducts {
    const products: RadarProducts = {
      ppi: this.generatePPI(volume.scans),
      cappi: this.generateCAPPI(volume.scans),
      precipitation: this.estimatePrecipitation(volume.scans),
      windShear: this.detectWindShear(volume.scans),
      mesocyclone: this.detectMesocyclone(volume.scans),
      tornado: this.detectTornadoVortexSignature(volume.scans)
    };

    return products;
  }

  // PPI（Plan Position Indicator）生成
  private generatePPI(scans: RadarScan[]): PPIProduct[] {
    return scans.map(scan => ({
      elevation: scan.elevation,
      timestamp: scan.timestamp,
      reflectivityField: this.interpolateRadialData(
        scan.azimuth,
        scan.range,
        scan.reflectivity
      ),
      velocityField: this.interpolateRadialData(
        scan.azimuth,
        scan.range,
        scan.velocity
      )
    }));
  }

  // CAPPI（Constant Altitude PPI）生成
  private generateCAPPI(scans: RadarScan[]): CAPPIProduct[] {
    const altitudes = [1000, 2000, 3000, 5000]; // 高度 (m)
    const cappiProducts: CAPPIProduct[] = [];

    for (const altitude of altitudes) {
      const cappiData = this.extractConstantAltitude(scans, altitude);
      cappiProducts.push({
        altitude,
        reflectivityField: cappiData.reflectivity,
        velocityField: cappiData.velocity,
        coverage: cappiData.coverage
      });
    }

    return cappiProducts;
  }

  // 定量的降水量推定
  private estimatePrecipitation(scans: RadarScan[]): PrecipitationProduct {
    const surfaceScan = scans.find(s => s.elevation === 0.5) || scans[0];
    const rainRate = this.reflectivityToRainRate(surfaceScan.reflectivity);

    // 雨粒粒径分布補正
    const correctedRainRate = this.correctDropSizeDistribution(rainRate);

    // 地形クラッター除去
    const filteredRainRate = this.removeGroundClutter(correctedRainRate, surfaceScan);

    return {
      instantaneousRainRate: filteredRainRate,
      accumulatedPrecipitation: this.calculateAccumulation(filteredRainRate),
      qualityIndex: this.calculateQualityIndex(surfaceScan),
      timestamp: surfaceScan.timestamp
    };
  }

  // Z-R関係式による降水量推定
  private reflectivityToRainRate(reflectivity: number[][]): number[][] {
    return reflectivity.map(row =>
      row.map(z => {
        if (z < this.REFLECTIVITY_THRESHOLD) return 0;
        // Z = aR^b (a=200, b=1.6)
        const linearZ = Math.pow(10, z / 10);
        return Math.pow(linearZ / 200, 1 / 1.6);
      })
    );
  }

  // 風のシアー検出（ダウンバースト検出）
  private detectWindShear(scans: RadarScan[]): WindShearProduct[] {
    const products: WindShearProduct[] = [];

    for (const scan of scans) {
      const windShearAreas = this.identifyDivergenceConvergence(scan);

      for (const area of windShearAreas) {
        const shearValue = this.calculateWindShearMagnitude(area);

        if (shearValue > 20) { // 20 m/s のシアー
          products.push({
            location: area.center,
            intensity: shearValue,
            type: area.type, // 'convergence' | 'divergence'
            areaKm2: area.areaKm2,
            confidence: this.calculateShearConfidence(area),
            elevation: scan.elevation,
            timestamp: scan.timestamp
          });
        }
      }
    }

    return products;
  }

  // メソサイクロン検出
  private detectMesocyclone(scans: RadarScan[]): MesocycloneProduct[] {
    const products: MesocycloneProduct[] = [];

    for (const scan of scans) {
      const vortexCandidates = this.findVortexSignatures(scan);

      for (const candidate of vortexCandidates) {
        const rotationalVelocity = this.calculateRotationalVelocity(candidate);
        const shear = this.calculateRadialShear(candidate);

        // メソサイクロン判定基準
        if (rotationalVelocity > 15 && shear > 10e-3) {
          products.push({
            location: candidate.center,
            rotationalVelocity,
            shear,
            diameter: candidate.diameterKm,
            depth: this.calculateVerticalExtent(scans, candidate),
            strength: this.categorizeMesocyclone(rotationalVelocity, shear),
            elevation: scan.elevation,
            timestamp: scan.timestamp
          });
        }
      }
    }

    return products;
  }

  // 竜巻渦シグネチャ（TVS）検出
  private detectTornadoVortexSignature(scans: RadarScan[]): TornadoProduct[] {
    const products: TornadoProduct[] = [];

    for (const scan of scans) {
      if (scan.elevation > 1.0) continue; // 低仰角のみ

      const tvsSignatures = this.findTVSSignatures(scan);

      for (const signature of tvsSignatures) {
        const deltaV = this.calculateVelocityDifference(signature);
        const distance = this.calculateSignatureDistance(signature);

        // TVS判定基準（δV > 30 m/s, 距離 < 2km）
        if (deltaV > 30 && distance < 2) {
          products.push({
            location: signature.center,
            velocityDifference: deltaV,
            distance,
            rotationalVelocity: deltaV / 2,
            lowLevelConvergence: this.checkConvergence(signature),
            associatedMesocyclone: this.findAssociatedMesocyclone(signature, products),
            probability: this.calculateTornadoProbability(deltaV, distance),
            timestamp: scan.timestamp
          });
        }
      }
    }

    return products;
  }

  // リアルタイムアラート生成
  generateRealTimeAlerts(products: RadarProducts): WeatherAlert[] {
    const alerts: WeatherAlert[] = [];

    // 大雨アラート
    const heavyRain = products.precipitation.instantaneousRainRate.flat()
      .find(rate => rate > 50); // 50mm/h以上
    if (heavyRain) {
      alerts.push({
        type: 'HEAVY_RAINFALL',
        severity: 'HIGH',
        message: `Heavy rainfall detected: ${heavyRain.toFixed(1)}mm/h`,
        validUntil: new Date(Date.now() + 30 * 60 * 1000) // 30分有効
      });
    }

    // 竜巻アラート
    if (products.tornado.length > 0) {
      const tornado = products.tornado[0];
      alerts.push({
        type: 'TORNADO_WARNING',
        severity: 'CRITICAL',
        message: `Tornado signature detected at ${tornado.location.latitude.toFixed(3)}, ${tornado.location.longitude.toFixed(3)}`,
        validUntil: new Date(Date.now() + 15 * 60 * 1000) // 15分有効
      });
    }

    // ダウンバーストアラート
    const strongWindShear = products.windShear.find(ws => ws.intensity > 30);
    if (strongWindShear) {
      alerts.push({
        type: 'DOWNBURST_WARNING',
        severity: 'HIGH',
        message: `Strong wind shear detected: ${strongWindShear.intensity.toFixed(1)}m/s`,
        validUntil: new Date(Date.now() + 20 * 60 * 1000) // 20分有効
      });
    }

    return alerts;
  }
}

interface RadarProducts {
  ppi: PPIProduct[];
  cappi: CAPPIProduct[];
  precipitation: PrecipitationProduct;
  windShear: WindShearProduct[];
  mesocyclone: MesocycloneProduct[];
  tornado: TornadoProduct[];
}

interface PrecipitationProduct {
  instantaneousRainRate: number[][];
  accumulatedPrecipitation: number[][];
  qualityIndex: number[][];
  timestamp: Date;
}

interface WindShearProduct {
  location: { latitude: number; longitude: number };
  intensity: number; // m/s
  type: 'convergence' | 'divergence';
  areaKm2: number;
  confidence: number;
  elevation: number;
  timestamp: Date;
}

interface MesocycloneProduct {
  location: { latitude: number; longitude: number };
  rotationalVelocity: number; // m/s
  shear: number; // s^-1
  diameter: number; // km
  depth: number; // km
  strength: 'WEAK' | 'MODERATE' | 'STRONG';
  elevation: number;
  timestamp: Date;
}

interface TornadoProduct {
  location: { latitude: number; longitude: number };
  velocityDifference: number; // m/s
  distance: number; // km
  rotationalVelocity: number; // m/s
  lowLevelConvergence: boolean;
  associatedMesocyclone?: MesocycloneProduct;
  probability: number; // 0-1
  timestamp: Date;
}

interface WeatherAlert {
  type: 'HEAVY_RAINFALL' | 'TORNADO_WARNING' | 'DOWNBURST_WARNING';
  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  message: string;
  validUntil: Date;
}

// 気象警報システムの実装
interface WeatherWarning {
  id: string;
  type: WarningType;
  level: WarningLevel;
  targetArea: GeographicArea;
  phenomenon: WeatherPhenomenon;
  criteria: WarningCriteria;
  validPeriod: {
    start: Date;
    end: Date;
  };
  issuedAt: Date;
  updatedAt?: Date;
  cancelledAt?: Date;
  message: string;
  supplement?: string;
}

enum WarningType {
  SPECIAL_WARNING = 'special_warning',
  WARNING = 'warning',
  ADVISORY = 'advisory',
  FORECAST = 'forecast'
}

enum WarningLevel {
  EMERGENCY = 5,  // 特別警報
  SEVERE = 4,     // 警報
  MODERATE = 3,   // 注意報
  MINOR = 2,      // 予報
  INFO = 1        // 情報
}

enum WeatherPhenomenon {
  HEAVY_RAIN = 'heavy_rain',
  HEAVY_SNOW = 'heavy_snow',
  STRONG_WIND = 'strong_wind',
  STORM_SURGE = 'storm_surge',
  HIGH_WAVES = 'high_waves',
  THUNDERSTORM = 'thunderstorm',
  TORNADO = 'tornado',
  FLOODING = 'flooding',
  LANDSLIDE = 'landslide'
}

class WeatherWarningSystem {
  private forecastModels: Map<string, ForecastModel> = new Map();
  private observationNetwork: ObservationNetwork;
  private warningCriteria: Map<string, WarningCriteriaSet> = new Map();
  private activeWarnings: Map<string, WeatherWarning> = new Map();

  constructor() {
    this.setupWarningCriteria();
    this.observationNetwork = new ObservationNetwork();
  }

  // 警報発表基準の設定
  private setupWarningCriteria(): void {
    // 大雨警報基準（例：東京都）
    this.warningCriteria.set('tokyo_heavy_rain', {
      phenomenon: WeatherPhenomenon.HEAVY_RAIN,
      warning: {
        rainfall1h: 50,    // 1時間50mm以上
        rainfall3h: 100,   // 3時間100mm以上
        soilMoisture: 85   // 土壌雨量指数85以上
      },
      advisory: {
        rainfall1h: 30,    // 1時間30mm以上
        rainfall3h: 60,    // 3時間60mm以上
        soilMoisture: 60   // 土壌雨量指数60以上
      },
      specialWarning: {
        rainfall24h: 500,  // 24時間500mm以上
        probabilisticIndex: 0.9 // 確率的指標0.9以上
      }
    });

    // 暴風警報基準
    this.warningCriteria.set('strong_wind', {
      phenomenon: WeatherPhenomenon.STRONG_WIND,
      warning: {
        maxWindSpeed: 25,     // 最大風速25m/s以上
        maxGustSpeed: 35      // 最大瞬間風速35m/s以上
      },
      advisory: {
        maxWindSpeed: 15,     // 最大風速15m/s以上
        maxGustSpeed: 25      // 最大瞬間風速25m/s以上
      }
    });
  }

  // リアルタイム警報判定
  async evaluateWarnings(): Promise<WeatherWarning[]> {
    const newWarnings: WeatherWarning[] = [];

    // 最新の予報データを取得
    const forecast = await this.getLatestForecast();
    const observations = await this.observationNetwork.getLatestObservations();

    // 各地域・現象について判定
    for (const region of this.getTargetRegions()) {
      for (const phenomenon of Object.values(WeatherPhenomenon)) {
        const criteriaKey = `${region.code}_${phenomenon}`;
        const criteria = this.warningCriteria.get(criteriaKey);

        if (!criteria) continue;

        const evaluation = await this.evaluatePhenomenon(
          region,
          phenomenon,
          criteria,
          forecast,
          observations
        );

        if (evaluation.shouldIssue) {
          const warning = this.createWarning(region, phenomenon, evaluation);
          newWarnings.push(warning);
        }
      }
    }

    return this.updateWarnings(newWarnings);
  }

  // 現象評価
  private async evaluatePhenomenon(
    region: Region,
    phenomenon: WeatherPhenomenon,
    criteria: WarningCriteriaSet,
    forecast: ForecastData,
    observations: ObservationData[]
  ): Promise<WarningEvaluation> {
    let level = WarningLevel.INFO;
    let shouldIssue = false;
    let confidence = 0;

    switch (phenomenon) {
      case WeatherPhenomenon.HEAVY_RAIN:
        const rainEval = this.evaluateRainfall(region, criteria, forecast, observations);
        level = rainEval.level;
        shouldIssue = rainEval.shouldIssue;
        confidence = rainEval.confidence;
        break;

      case WeatherPhenomenon.STRONG_WIND:
        const windEval = this.evaluateWind(region, criteria, forecast, observations);
        level = windEval.level;
        shouldIssue = windEval.shouldIssue;
        confidence = windEval.confidence;
        break;

      // その他の現象...
    }

    return {
      phenomenon,
      level,
      shouldIssue,
      confidence,
      expectedDuration: this.calculateExpectedDuration(phenomenon, forecast),
      peakTime: this.identifyPeakTime(phenomenon, forecast)
    };
  }

  // 降水評価
  private evaluateRainfall(
    region: Region,
    criteria: WarningCriteriaSet,
    forecast: ForecastData,
    observations: ObservationData[]
  ): RainfallEvaluation {

    // 観測による現在状況
    const currentRain1h = this.getMaxRainfallInRegion(observations, region, 1);
    const currentRain3h = this.getMaxRainfallInRegion(observations, region, 3);

    // 予報による将来予測
    const forecast1h = this.getForecastMaxRainfall(forecast, region, 1);
    const forecast3h = this.getForecastMaxRainfall(forecast, region, 3);
    const forecast24h = this.getForecastMaxRainfall(forecast, region, 24);

    // 土壌雨量指数の計算
    const soilMoistureIndex = this.calculateSoilMoistureIndex(region, observations, forecast);

    // 判定
    let level = WarningLevel.INFO;
    let shouldIssue = false;

    // 特別警報判定
    if (forecast24h >= criteria.specialWarning?.rainfall24h || 
        soilMoistureIndex >= criteria.specialWarning?.soilMoisture) {
      level = WarningLevel.EMERGENCY;
      shouldIssue = true;
    }
    // 警報判定
    else if (Math.max(currentRain1h, forecast1h) >= criteria.warning.rainfall1h || 
            Math.max(currentRain3h, forecast3h) >= criteria.warning.rainfall3h ||
            soilMoistureIndex >= criteria.warning.soilMoisture) {
      level = WarningLevel.SEVERE;
      shouldIssue = true;
    }
    // 注意報判定
    else if (Math.max(currentRain1h, forecast1h) >= criteria.advisory.rainfall1h || 
            Math.max(currentRain3h, forecast3h) >= criteria.advisory.rainfall3h ||
            soilMoistureIndex >= criteria.advisory.soilMoisture) {
      level = WarningLevel.MODERATE;
      shouldIssue = true;
    }

    // 信頼度計算
    const confidence = this.calculateRainfallConfidence(
      forecast, observations, region, level
    );

    return { level, shouldIssue, confidence };
  }

  // 土壌雨量指数の計算
  private calculateSoilMoistureIndex(
    region: Region,
    observations: ObservationData[],
    forecast: ForecastData
  ): number {
    // 過去の降水量から土壌雨量指数を計算
    const pastRainfall = this.getRegionalRainfall(observations, region, 72); // 過去72時間
    const futureRainfall = this.getForecastTotalRainfall(forecast, region, 24); // 今後24時間

    // タンクモデルによる土壌水分計算
    const tankModel = new TankModel({
      initialWater: this.getInitialSoilMoisture(region),
      parameters: this.getTankParameters(region)
    });

    // 過去の降水を入力
    for (const rain of pastRainfall) {
      tankModel.input(rain.amount, rain.timestamp);
    }

    // 将来の降水を入力（予測）
    for (const rain of futureRainfall) {
      tankModel.input(rain.amount, rain.timestamp);
    }

    return tankModel.getSoilMoistureIndex();
  }

  // 警報の更新・配信
  private updateWarnings(newWarnings: WeatherWarning[]): WeatherWarning[] {
    const updatedWarnings: WeatherWarning[] = [];

    for (const warning of newWarnings) {
      const existingWarningId = this.findExistingWarning(warning);

      if (existingWarningId) {
        // 既存警報の更新
        const existing = this.activeWarnings.get(existingWarningId);
        if (this.hasSignificantChange(existing, warning)) {
          const updated = this.updateExistingWarning(existing, warning);
          this.activeWarnings.set(existingWarningId, updated);
          updatedWarnings.push(updated);
        }
      } else {
        // 新規警報発表
        warning.id = this.generateWarningId();
        this.activeWarnings.set(warning.id, warning);
        updatedWarnings.push(warning);
      }
    }

    // 解除チェック
    const cancelledWarnings = this.checkForCancellations();
    updatedWarnings.push(...cancelledWarnings);

    // 配信実行
    this.distributeWarnings(updatedWarnings);

    return updatedWarnings;
  }

  // 多言語対応メッセージ生成
  generateWarningMessage(warning: WeatherWarning, language: string = 'ja'): string {
    const templates = {
      ja: {
        heavy_rain_warning: '{areaName}に大雨警報が発表されました。{validPeriod}にかけて、1時間に{maxRainfall}ミリの激しい雨が降る見込みです。土砂災害や低い土地の浸水、河川の増水に警戒してください。',
        heavy_rain_special: '{areaName}に大雨特別警報が発表されました。これまでに経験したことのないような大雨となっており、重大な危険が差し迫っています。直ちに命を守る行動をとってください。',
        strong_wind_warning: '{areaName}に暴風警報が発表されました。{validPeriod}にかけて、最大風速{maxWind}メートルの暴風が吹く見込みです。外出は避け、安全な場所に留まってください。'
      },
      en: {
        heavy_rain_warning: 'Heavy rainfall warning issued for {areaName}. Expect intense rainfall of {maxRainfall}mm per hour until {validPeriod}. Be alert for landslides, flooding in low-lying areas, and rising river levels.',
        heavy_rain_special: 'Special heavy rainfall warning issued for {areaName}. Unprecedented heavy rainfall is occurring, posing grave danger. Take immediate action to protect life.',
        strong_wind_warning: 'Strong wind warning issued for {areaName}. Expect maximum wind speeds of {maxWind} m/s until {validPeriod}. Avoid going outside and stay in a safe location.'
      }
    };

    const template = templates[language]?.[warning.phenomenon + '_' + (warning.level === WarningLevel.EMERGENCY ? 'special' : 'warning')];

    if (!template) return warning.message;

    return template
      .replace('{areaName}', warning.targetArea.name)
      .replace('{validPeriod}', this.formatDateTime(warning.validPeriod.end))
      .replace('{maxRainfall}', warning.criteria?.maxRainfall?.toString() || '')
      .replace('{maxWind}', warning.criteria?.maxWind?.toString() || '');
  }

  // CAP（Common Alerting Protocol）形式での配信
  generateCAPMessage(warning: WeatherWarning): string {
    const capMessage = `<?xml version="1.0" encoding="UTF-8"?>
<alert xmlns="urn:oasis:names:tc:emergency:cap:1.2">
  <identifier>${warning.id}</identifier>
  <sender>jma@met.gov.jp</sender>
  <sent>${warning.issuedAt.toISOString()}</sent>
  <status>Actual</status>
  <msgType>${warning.updatedAt ? 'Update' : 'Alert'}</msgType>
  <scope>Public</scope>

  <info>
    <language>ja-JP</language>
    <category>Met</category>
    <event>${this.phenomenonToEventType(warning.phenomenon)}</event>
    <urgency>${this.levelToUrgency(warning.level)}</urgency>
    <severity>${this.levelToSeverity(warning.level)}</severity>
    <certainty>Observed</certainty>
    <effective>${warning.validPeriod.start.toISOString()}</effective>
    <expires>${warning.validPeriod.end.toISOString()}</expires>
    <senderName>Japan Meteorological Agency</senderName>
    <headline>${warning.message}</headline>
    <description>${warning.supplement || warning.message}</description>

    <area>
      <areaDesc>${warning.targetArea.name}</areaDesc>
      <geocode>
        <valueName>JMA_CODE</valueName>
        <value>${warning.targetArea.code}</value>
      </geocode>
    </area>
  </info>
</alert>`;

    return capMessage;
  }

  // リアルタイム配信システム
  private distributeWarnings(warnings: WeatherWarning[]): void {
    for (const warning of warnings) {
      // CAP形式メッセージ生成
      const capMessage = this.generateCAPMessage(warning);

      // 各配信チャネルに送信
      Promise.all([
        this.sendToJMASystem(capMessage),
        this.sendToLocalGovernments(warning),
        this.sendToMediaOutlets(warning),
        this.sendToMobileCarriers(warning),
        this.sendToWebServices(warning)
      ]).catch(error => {
        console.error('Warning distribution error:', error);
        // 配信失敗時の代替手段実行
        this.handleDistributionFailure(warning, error);
      });

      // ログ記録
      this.logWarningDistribution(warning);
    }
  }
}

interface WarningCriteriaSet {
  phenomenon: WeatherPhenomenon;
  warning: {
    rainfall1h?: number;
    rainfall3h?: number;
    soilMoisture?: number;
    maxWindSpeed?: number;
    maxGustSpeed?: number;
  };
  advisory: {
    rainfall1h?: number;
    rainfall3h?: number;
    soilMoisture?: number;
    maxWindSpeed?: number;
    maxGustSpeed?: number;
  };
  specialWarning?: {
    rainfall24h?: number;
    probabilisticIndex?: number;
    soilMoisture?: number;
  };
}

interface WarningEvaluation {
  phenomenon: WeatherPhenomenon;
  level: WarningLevel;
  shouldIssue: boolean;
  confidence: number;
  expectedDuration: number; // hours
  peakTime: Date;
}

interface RainfallEvaluation {
  level: WarningLevel;
  shouldIssue: boolean;
  confidence: number;
}

// タンクモデル（土壌雨量指数計算用）
class TankModel {
  private tanks: Array<{ capacity: number; drainRate: number; water: number }>;
  private parameters: any;

  constructor(config: { initialWater: number; parameters: any }) {
    this.parameters = config.parameters;
    this.tanks = [
      { capacity: 100, drainRate: 0.1, water: config.initialWater * 0.6 },
      { capacity: 50, drainRate: 0.05, water: config.initialWater * 0.3 },
      { capacity: 25, drainRate: 0.02, water: config.initialWater * 0.1 }
    ];
  }

  input(rainfall: number, timestamp: Date): void {
    let remainingRainfall = rainfall;

    // 上位タンクから順に水を入れる
    for (let i = 0; i < this.tanks.length; i++) {
      const tank = this.tanks[i];
      const canAdd = Math.min(remainingRainfall, tank.capacity - tank.water);
      tank.water += canAdd;
      remainingRainfall -= canAdd;

      // 次のタンクに流れる量を計算
      if (i < this.tanks.length - 1 && tank.water > tank.capacity * 0.8) {
        const overflow = (tank.water - tank.capacity * 0.8) * 0.5;
        tank.water -= overflow;
        remainingRainfall += overflow;
      }
    }

    // 蒸発・浸透による減少
    for (const tank of this.tanks) {
      tank.water *= (1 - tank.drainRate);
    }
  }

  getSoilMoistureIndex(): number {
    // 各タンクの水位を重み付け合計
    const totalWater = this.tanks.reduce((sum, tank, index) => {
      const weight = [0.5, 0.3, 0.2][index];
      return sum + tank.water * weight;
    }, 0);

    return Math.min(totalWater, 100); // 最大値100で正規化
  }
}