Graphics Editor @ New York Times
Public
Edited
Dec 20, 2022
Paused
2 forks
Comments locked
7 stars
waveVolume = (waveHeightFeet * waveLengthFeet / 2) * wallWidthFeet
seawaterMassPounds = kgM3TolbsF3(1025)
waveMassPounds = waveVolume * seawaterMassPounds
waveSpeedFPS = mphToFPS(stormVelMPH)
crashTime = waveLengthFeet / (waveSpeedFPS / 2)
waveLBSForce = waveSpeedFPS * waveMassPounds / crashTime
function waterLevelTimeCurve(isoStart, isoEnd) {
let scale = d3.scaleTime().domain([isoStart, isoEnd]).range([0, 1])
return function curve(t) {
let d = scale.invert(t); // get date from time value
let results = waterLevel.filter(x => fmtDt(x.datetime) === fmtDt(d)) // filter for exact match
// If we get a single result we have an exact match
if (results.length === 1) {
return results[0].waterLvlPct
}
// Otherwise grab all results insert our time
results = waterLevel.concat([{datetime: d}])
// Sort them and then find the index of the one we inserted
results = results.sort((a, b) => d3.ascending(a.datetime, b.datetime))
let idx = results.findIndex(x => fmtDt(x.datetime) === fmtDt(d))
// Return the average of the element before and after
return (results[idx - 1].waterLvlPct + results[idx + 1].waterLvlPct) / 2
}
}
periods = d3.range(.01, 1, .01).concat([1])
cumulativeForceLBS = {
let isoStart = d3.min(waterLevel.map(x => x.datetime));
let isoEnd = d3.max(waterLevel.map(x => x.datetime));
let curve = waterLevelTimeCurve(isoStart, isoEnd);
let momentumOfT = (t) => curve(t) * wallAreaForce;
let milliElapsed = (isoEnd.getTime() - isoStart.getTime())
let seconds = milliElapsed / 1000;
let stepTime = seconds / 100;
// Integrate!
return periods.reduce((a, t) => {
return momentumOfT(t) * (stepTime) + a
}, 0)
}
hydroAreaForce = seawaterMassPounds * 9.8 * ((wallHeightFeet * waterDepthFactor) / 2) * ((wallHeightFeet * waterDepthFactor) * wallWidthFeet2)
totalCumulativeForce = {
let isoStart = d3.min(waterLevel.map(x => x.datetime));
let isoEnd = d3.max(waterLevel.map(x => x.datetime));
let curve = waterLevelTimeCurve(isoStart, isoEnd);
let momentumOfT = (t) => curve(t) * wallAreaForce;
let hydroOfT = (t) => curve(t) * hydroAreaForce;
let milliElapsed = (isoEnd.getTime() - isoStart.getTime())
let seconds = milliElapsed / 1000;
let stepTime = seconds / 100;
return periods.reduce((a, t) => {
return momentumOfT(t) * (stepTime) + hydroOfT(t) * (stepTime) + a
}, 0)
}
scaled = numericalModelData.map(x => ({...x, "scaledAvgForce": x["avgForce"] * Math.pow(scaleFactor, 2)}))
timeStep = 1
steps = d3.range(0, 61, timeStep)
timeStepData = scaled.filter(x => steps.includes(x.flowTime))
scaledForceOfT = (t) => timeStepData.filter(x => x.flowTime === t)[0].scaledAvgForce
minuteForce = steps.reduce((a, t) => scaledForceOfT(t) * timeStep + a)
hourForce = minuteForce * 60
checkWallWidth = .328
checkWallHeight = scaleFactor * checkWallWidth
checkWaterDepth = scaleFactor * .196
checkHighWaterMark = checkWaterDepth + scaleFactor * 0.066
checkSurfaceArea = checkHighWaterMark * checkWallWidth
checkDragForce = 63.99 * Math.sqrt(32.17 * checkWaterDepth) * checkSurfaceArea
checkHydroForce = 63.99 * 32.17 * (checkWaterDepth/2) * (checkWaterDepth * checkWallWidth)
pctAtTime = (t) => scaled.filter(x => x.flowTime === t)[0].pct
dragForceAtT = (t) => checkDragForce * pctAtTime(t)
hydroForceAtT = (t) => checkHydroForce * pctAtTime(t)
checkMinForce = steps.reduce((a, t) => dragForceAtT(t) * timeStep + hydroForceAtT(t) * timeStep + a)
checkHourForce = checkMinForce * 60
veaForceLBS = veaStats.speedFPS * veaStats.weightLBS / (veaStats.armLengthFeet / (veaStats.speedFPS / 2))
numVeas = waveLBSForce / veaForceLBS
trainHourVelocityFPS = Math.sqrt(hourForce / (train.density * (train.widthFeet * train.heightFeet)))
trainMinuteVelocityFPS = Math.sqrt(minuteForce / (train.density * (train.widthFeet * train.heightFeet)))
function kgM3TolbsF3(v) {
return v / 16.018;
}
function mphToFPS(v) {
return v * 1.466;
}
function fpsToMPH(v) {
return v / 1.466;
}
function hoursBetween(d1, d2) {
// https://stackoverflow.com/questions/19225414/how-to-get-the-hours-difference-between-two-date-objects
return Math.abs(d1 - d2) / 36e5;
}
fmtFloat = d3.format(",.2f")
function roundDown(places) {
return function(v) {
return Math.floor(v / Math.pow(10, places)) * Math.pow(10, places)
}
}
waveMassPoundsRounded = d3.format(",")(roundDown(2)(waveMassPounds))
wavePoundForceRounded = d3.format(",")(roundDown(2)(waveLBSForce))
numVeasRounded = roundDown(0)(numVeas)
viewWaveHeightFeet = waveHeightFeet
viewWaveLengthFeet = waveLengthFeet
viewWallWidthFeet = wallWidthFeet
fmtDt = d3.timeFormat("%Y-%m-%dT%H:%M:%s")
fmtInt = d3.format(",d")
viewHourlyTrainSpeedMPH = fmtInt(fpsToMPH(trainHourVelocityFPS))
viewMinuteTrainSpeedMPH = fmtInt(fpsToMPH(trainMinuteVelocityFPS))
viewFEAwaveHeight = fmtInt(scaleFactor * 0.066)
viewFEAwaveLength = fmtInt(scaleFactor * 1.312)
viewHourForce = fmtInt(hourForce)
viewMinuteForce = fmtInt(minuteForce)
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
