Make profile and plume consistent, and extract unified profiles and plumes in analysis

Author: Peter9192

apps/class-solid/src/components/Analysis.tsx

@@ -1,16 +1,15 @@
 import type { Config } from "@classmodel/class/config";
-import { calculatePlume, transposePlumeData } from "@classmodel/class/fire";
+import { FirePlume, calculatePlume, noPlume } from "@classmodel/class/fire";
 import {
-  type ClassTimeSeries,
   type OutputVariableKey,
-  getOutputAtTime,
   outputVariables,
 } from "@classmodel/class/output";
 import {
   type ClassProfile,
-  NoProfile,
   generateProfiles,
+  noProfile,
 } from "@classmodel/class/profiles";
+import type { ClassData } from "@classmodel/class/runner";
 import * as d3 from "d3";
 import { saveAs } from "file-saver";
 import { toBlob } from "html-to-image";
@@ -78,7 +77,7 @@ interface FlatExperiment {
   color: string;
   linestyle: string;
   config: Config;
-  output?: ClassTimeSeries;
+  output?: ClassData;
 }
 
 // Create a derived store for looping over all outputs:
@@ -119,7 +118,7 @@ const flatObservations: () => Observation[] = createMemo(() => {
 });
 
 const _allTimes = () =>
-  new Set(flatExperiments().flatMap((e) => e.output?.utcTime ?? []));
+  new Set(flatExperiments().flatMap((e) => e.output?.timeseries.utcTime ?? []));
 const uniqueTimes = () => [...new Set(_allTimes())].sort((a, b) => a - b);
 
 // TODO: could memoize all reactive elements here, would it make a difference?
@@ -133,11 +132,15 @@ export function TimeSeriesPlot({ analysis }: { analysis: TimeseriesAnalysis }) {
 
   const allX = () =>
     flatExperiments().flatMap((e) =>
-      e.output ? e.output[analysis.xVariable as OutputVariableKey] : [],
+      e.output
+        ? e.output.timeseries[analysis.xVariable as OutputVariableKey]
+        : [],
     );
   const allY = () =>
     flatExperiments().flatMap((e) =>
-      e.output ? e.output[analysis.yVariable as OutputVariableKey] : [],
+      e.output
+        ? e.output.timeseries[analysis.yVariable as OutputVariableKey]
+        : [],
     );
 
   const granularities: Record<string, number | undefined> = {
@@ -157,12 +160,12 @@ export function TimeSeriesPlot({ analysis }: { analysis: TimeseriesAnalysis }) {
         ...formatting,
         data:
           // Zip x[] and y[] into [x, y][]
-          output?.t.map((_, t) => ({
+          output?.timeseries.t.map((_, t) => ({
             x: output
-              ? output[analysis.xVariable as OutputVariableKey][t]
+              ? output.timeseries[analysis.xVariable as OutputVariableKey][t]
               : Number.NaN,
             y: output
-              ? output[analysis.yVariable as OutputVariableKey][t]
+              ? output.timeseries[analysis.yVariable as OutputVariableKey][t]
               : Number.NaN,
           })) || [],
       };
@@ -241,7 +244,7 @@ export function TimeSeriesPlot({ analysis }: { analysis: TimeseriesAnalysis }) {
 export function VerticalProfilePlot({
   analysis,
 }: { analysis: ProfilesAnalysis }) {
-  const variableOptions = {
+  const profileVariables = {
     "Potential temperature [K]": "theta",
     "Virtual potential temperature [K]": "thetav",
     "Specific humidity [kg/kg]": "qt",
@@ -255,11 +258,11 @@ export function VerticalProfilePlot({
     "Density [kg/m³]": "rho",
     "Relative humidity [%]": "rh",
   } as const satisfies Record<string, keyof ClassProfile>;
+  type PlumeVariable = "theta" | "qt" | "thetav" | "T" | "Td" | "rh" | "w";
 
   const classVariable = () =>
-    variableOptions[analysis.variable as keyof typeof variableOptions];
+    profileVariables[analysis.variable as keyof typeof profileVariables];
 
-  type PlumeVariable = "theta" | "qt" | "thetav" | "T" | "Td" | "rh" | "w";
   function isPlumeVariable(v: string): v is PlumeVariable {
     return ["theta", "qt", "thetav", "T", "Td", "rh", "w"].includes(v);
   }
@@ -269,57 +272,65 @@ export function VerticalProfilePlot({
   const observations = () =>
     flatObservations().map((o) => observationsForProfile(o, classVariable()));
 
+  function extractLines<T extends Record<string, number[]>>(
+    data: T,
+    xvar: keyof T,
+    yvar: keyof T,
+  ) {
+    const xs = data[xvar] ?? [];
+    const ys = data[yvar] ?? [];
+
+    const n = Math.min(xs.length, ys.length);
+
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = { x: xs[i], y: ys[i] };
+    }
+
+    return result;
+  }
+
   const profileData = () =>
     flatExperiments().map((e) => {
       const { config, output, ...formatting } = e;
-      const t = output?.utcTime.indexOf(uniqueTimes()[analysis.time]);
-      if (config.sw_ml && output && t !== undefined && t !== -1) {
-        const outputAtTime = getOutputAtTime(output, t);
-        return { ...formatting, data: generateProfiles(config, outputAtTime) };
-      }
-      return { ...formatting, data: NoProfile };
+
+      const targetTime = uniqueTimes()[analysis.time];
+      const t = output?.timeseries.utcTime.indexOf(targetTime);
+
+      const profile =
+        (t != null && t !== -1 && output?.profiles?.[t]) || noProfile;
+
+      return {
+        ...formatting,
+        data: extractLines(profile, classVariable(), "z"),
+      };
     });
 
   const firePlumes = () =>
-    flatExperiments().map((e, i) => {
+    flatExperiments().map((e) => {
       const { config, output, ...formatting } = e;
-      if (config.sw_fire && isPlumeVariable(classVariable())) {
-        const plume = transposePlumeData(
-          calculatePlume(config, profileData()[i].data),
-        );
-        return {
-          ...formatting,
-          linestyle: "4",
-          data: plume.z.map((z, i) => ({
-            x: plume[classVariable() as PlumeVariable][i],
-            y: z,
-          })),
-        };
-      }
-      return { ...formatting, data: [] };
-    });
 
-  // TODO: There should be a way that this isn't needed.
-  const profileDataForPlot = () =>
-    profileData().map(({ data, label, color, linestyle }) => ({
-      label,
-      color,
-      linestyle,
-      data: data.z.map((z, i) => ({
-        x: data[classVariable()][i],
-        y: z,
-      })),
-    })) as ChartData<Point>[];
+      const targetTime = uniqueTimes()[analysis.time];
+      const t = output?.timeseries.utcTime.indexOf(targetTime);
+
+      const plume = (t != null && t !== -1 && output?.plumes?.[t]) || noPlume;
 
+      return {
+        ...formatting,
+        linestyle: "4",
+        data: extractLines(plume, classVariable() as PlumeVariable, "z"),
+      };
+    });
+    
   const allX = () => [
     ...firePlumes().flatMap((p) => p.data.map((d) => d.x)),
     ...profileDataForPlot().flatMap((p) => p.data.map((d) => d.x)),
     ...observations().flatMap((obs) => obs.data.map((d) => d.x)),
   ];
   const allY = () => [
-    ...firePlumes().flatMap((p) => p.data.map((d) => d.y)),
-    ...profileDataForPlot().flatMap((p) => p.data.map((d) => d.y)),
-    ...observations().flatMap((obs) => obs.data.map((d) => d.y)),
+    ...firePlumes().flatMap((p) => p.data.map((d) => d.z)),
+    ...profileDataForPlot().flatMap((p) => p.data.map((d) => d.z)),
+    ...observations().flatMap((obs) => obs.data.map((d) => d.z)),
   ];
 
   const xLim = () => getNiceAxisLimits(allX(), 0);
@@ -385,7 +396,7 @@ export function VerticalProfilePlot({
         <Picker
           value={() => analysis.variable}
           setValue={(v) => changeVar(v)}
-          options={Object.keys(variableOptions)}
+          options={Object.keys(profileVariables)}
           label="variable: "
         />
         {TimeSlider(
@@ -482,7 +493,7 @@ export function ThermodynamicPlot({ analysis }: { analysis: SkewTAnalysis }) {
         const outputAtTime = getOutputAtTime(output, t);
         return { ...formatting, data: generateProfiles(config, outputAtTime) };
       }
-      return { ...formatting, data: NoProfile };
+      return { ...formatting, data: noProfile };
     });
 
   const firePlumes = () =>

packages/class/src/fire.ts

@@ -62,7 +62,25 @@ export interface Parcel {
   rh: number; // Relative humidity [%]
 }
 
-export type FirePlume = Parcel[];
+export type FirePlume = Record<keyof Parcel, number[]>;
+export const noPlume: FirePlume = {
+  z: [],
+  w: [],
+  thetal: [],
+  theta: [],
+  qt: [],
+  thetav: [],
+  qsat: [],
+  b: [],
+  m: [],
+  area: [],
+  e: [],
+  d: [],
+  T: [],
+  Td: [],
+  p: [],
+  rh: [],
+};
 
 /**
  * Initialize fire parcel with ambient conditions and fire properties
@@ -221,15 +239,13 @@ export function calculatePlume(
 
     plume.push(parcel);
   }
-  return plume;
+  return transposePlumeData(plume);
 }
 
 /**
  * Convert array of objects into object of arrays
  */
-export function transposePlumeData(
-  plume: Parcel[],
-): Record<keyof Parcel, number[]> {
+export function transposePlumeData(plume: Parcel[]): FirePlume {
   if (plume.length === 0) {
     return {} as Record<keyof Parcel, number[]>;
   }

packages/class/src/profiles.ts

@@ -18,7 +18,7 @@ const CONSTANTS = {
 /**
  * Atmospheric vertical profiles
  */
-export interface ClassProfile {
+export interface ClassProfile extends Record<string, number[]> {
   z: number[]; // Height levels (cell centers) [m]
   theta: number[]; // Potential temperature [K]
   thetav: number[]; // Virtual potential temperature [K]
@@ -34,7 +34,7 @@ export interface ClassProfile {
   rh: number[]; // Relative humidity [%]
 }
 
-export const NoProfile: ClassProfile = {
+export const noProfile: ClassProfile = {
   z: [],
   theta: [],
   thetav: [],

packages/class/src/runner.ts

@@ -17,7 +17,11 @@ import { parse } from "./validate.js";
 type ClassTimeSeries = Record<OutputVariableKey, number[]>;
 type ClassProfiles = ClassProfile[];
 type ClassFirePlumes = FirePlume[];
-export type ClassData = [ClassTimeSeries, ClassProfiles?, ClassFirePlumes?];
+export interface ClassData {
+  timeseries: ClassTimeSeries;
+  profiles?: ClassProfiles;
+  plumes?: ClassFirePlumes;
+}
 
 /**
  * Runs the CLASS model with the given configuration and frequency.
@@ -38,7 +42,7 @@ export function runClass(config: Config, freq = 600): ClassData {
       const value = model.getValue(key);
       if (value !== undefined) {
         output[key] = model.getValue(key);
-        timeSeries[key].push(value as number);
+        timeseries[key].push(value as number);
       }
 
       // Include profiles
@@ -49,18 +53,18 @@ export function runClass(config: Config, freq = 600): ClassData {
         // Include fireplumes
         if (config.sw_fire) {
           const plume = calculatePlume(config, profile);
-          firePlumes.push(plume);
+          plumes.push(plume);
         }
       }
     }
   };
 
   // Initialize output arrays
-  const timeSeries = Object.fromEntries(
+  const timeseries = Object.fromEntries(
     outputKeys.map((key) => [key, []]),
   ) as unknown as ClassTimeSeries;
   const profiles: ClassProfiles = [];
-  const firePlumes: ClassFirePlumes = [];
+  const plumes: ClassFirePlumes = [];
 
   // Initial time
   writeOutput();
@@ -77,9 +81,9 @@ export function runClass(config: Config, freq = 600): ClassData {
   // Construct ClassData
   if (config.sw_ml) {
     if (config.sw_fire) {
-      return [timeSeries, profiles, firePlumes];
+      return { timeseries, profiles, plumes };
     }
-    return [timeSeries, profiles];
+    return { timeseries, profiles };
   }
-  return [timeSeries];
+  return { timeseries };
 }