674 lines
20 KiB
Rust
674 lines
20 KiB
Rust
use crate::geom::{Meters, Region, Torus, WorldRegion};
|
|
use crate::real::{Real as _, ToFloat as _};
|
|
use crate::cross::vec::Vec3;
|
|
use crate::sim::AbstractSim;
|
|
use serde::{Serialize, Deserialize};
|
|
|
|
pub trait AbstractMeasurement<S>: Send + Sync {
|
|
fn eval(&self, state: &S) -> String;
|
|
fn key_value(&self, state: &S) -> Vec<Measurement>;
|
|
}
|
|
|
|
pub fn as_dyn_measurements<S, M: AbstractMeasurement<S>>(meas: &[M]) -> Vec<&dyn AbstractMeasurement<S>> {
|
|
meas.into_iter().map(|m| m as &dyn AbstractMeasurement<S>).collect()
|
|
}
|
|
|
|
|
|
/// combine several measurements
|
|
pub fn eval_multiple_kv<S>(state: &S, meas: &[&dyn AbstractMeasurement<S>]) -> Vec<Measurement>
|
|
meas.into_iter().flat_map(|m| m.key_value(state).into_iter()).collect()
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
|
|
pub enum MeasurementValue {
|
|
Field(Vec3<f32>),
|
|
Float(f32),
|
|
Int(u64),
|
|
Dim(Vec3u),
|
|
}
|
|
|
|
impl From<Vec3<f32>> for MeasurementValue {
|
|
fn from(v: Vec3<f32>) -> Self {
|
|
Self::Field(v)
|
|
}
|
|
}
|
|
impl From<f32> for MeasurementValue {
|
|
fn from(v: f32) -> Self {
|
|
Self::Float(v)
|
|
}
|
|
}
|
|
impl From<u64> for MeasurementValue {
|
|
fn from(v: u64) -> Self {
|
|
Self::Int(v)
|
|
}
|
|
}
|
|
impl From<Vec3u> for MeasurementValue {
|
|
fn from(v: Vec3u) -> Self {
|
|
Self::Dim(v)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
|
|
pub struct Measurement {
|
|
name: String,
|
|
value: MeasurementValue,
|
|
/// e.g. "A" for Amps
|
|
unit: String,
|
|
}
|
|
|
|
impl Measurement {
|
|
fn new<T: Into<MeasurementValue>>(name: &str, value: T, unit: &str) -> Self {
|
|
Self {
|
|
name.to_owned(),
|
|
value: value.into(),
|
|
unit: unit.to_owned(),
|
|
}
|
|
}
|
|
fn new_unitless<T: Into<MeasurementValue>>(name: &str, value: T) -> Self {
|
|
Self::new(name, value, "")
|
|
}
|
|
}
|
|
|
|
enum SiScale {
|
|
Pico,
|
|
Nano,
|
|
Micro,
|
|
Milli,
|
|
Unit,
|
|
Kilo,
|
|
Mega,
|
|
Giga,
|
|
Terra,
|
|
}
|
|
|
|
impl SiScale {
|
|
fn for_value(v: f32) -> Self {
|
|
use SiScale::*;
|
|
match v {
|
|
v if v < 1e-12 => Unit,
|
|
v if v < 1e-9 => Pico,
|
|
v if v < 1e-6 => Nano,
|
|
v if v < 1e-3 => Micro,
|
|
v if v < 1e0 => Milli,
|
|
v if v < 1e3 => Unit,
|
|
v if v < 1e6 => Kilo,
|
|
v if v < 1e9 => Mega,
|
|
v if v < 1e12 => Giga,
|
|
v if v < 1e15 => Terra,
|
|
_ => Unit
|
|
}
|
|
}
|
|
|
|
/// return the numerical scale of this prefix.
|
|
/// e.g. `scale(&Pico) -> 1e-12
|
|
fn scale(&self) -> f32 {
|
|
use SiScale::*;
|
|
match *self {
|
|
Pico => 1e-12,
|
|
Nano => 1e-9,
|
|
Micro => 1e-6,
|
|
Milli => 1e-3,
|
|
Unit => 1.0,
|
|
Kilo => 1e3,
|
|
Mega => 1e6,
|
|
Giga => 1e9,
|
|
Terra => 1e12,
|
|
}
|
|
}
|
|
|
|
/// return the short string for this scale.
|
|
/// e.g. `shortcode(Pico) -> "p"`
|
|
fn shortcode(&self) -> &'static str {
|
|
use SiScale::*;
|
|
match *self {
|
|
Pico => "p",
|
|
Nano => "n",
|
|
Micro => "u",
|
|
Milli => "m",
|
|
Unit => "",
|
|
Kilo => "k",
|
|
Mega => "M",
|
|
Giga => "G",
|
|
Terra => "T",
|
|
}
|
|
}
|
|
|
|
/// format `v`, with the provided unit.
|
|
/// e.g. `format_short(1234, "A") -> "1.23 kA"
|
|
fn format_short(v: f32, unit: &str) -> String {
|
|
let si = SiScale::for_value(v);
|
|
let scaled = si.scale() * v;
|
|
format!("{:.2} {}{}", scaled, si.shortcode(), unit)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Time;
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Time {
|
|
fn eval(&self, state: &S) -> String {
|
|
format!("{} (step {})", SiScale::format_short(state.time(), "s"), state.step_no())
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement>
|
|
vec![
|
|
Measurement::new_unitless("step", state.step_no()),
|
|
Measurement::new("time", state.time(), "s"),
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Meta;
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Meta {
|
|
fn eval(&self, state: &S) -> String {
|
|
format!("{}x{}x{} feat: {:.1e}m", state.width(), state.height(), state.depth(), state.feature_size())
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
vec![
|
|
Measurement::new_unitless("dim", state.dim()),
|
|
Measurement::new("feature_size", state.feature_size(), "m"),
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Volume {
|
|
name: String,
|
|
region: Box<dyn Region>,
|
|
}
|
|
|
|
impl Volume {
|
|
pub fn new<R: Region + 'static>(name: &str, r: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(r)
|
|
}
|
|
}
|
|
/// Returns the volume of the region, in units of um^3
|
|
fn data<S: AbstractSim>(&self, state: &S) -> f32 {
|
|
let feat_um = state.feature_size() as f64 * 1e6;
|
|
|
|
(state.volume_of_region(&*self.region) as f64 * feat_um * feat_um * feat_um) as f32
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Volume {
|
|
fn eval(&self, state: &S) -> String {
|
|
format!("Vol({}): {:.2e} um^3",
|
|
self.name,
|
|
self.data(state),
|
|
)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
vec![
|
|
Measurement::new(&format!("Vol({})", self.name), self.data(), "um^3"),
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Current {
|
|
name: String,
|
|
region: Box<dyn Region>,
|
|
}
|
|
|
|
impl Current {
|
|
pub fn new<R: Region + 'static>(name: &str, r: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(r)
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> (f32, Vec3<f32>) {
|
|
let FieldSample(volume, current_mag, current_vec) = state.map_sum_over_enumerated(&*self.region, |coord: Meters, _cell| {
|
|
let current = state.current(coord);
|
|
FieldSample(1, current.mag().cast(), current.cast())
|
|
});
|
|
let mean_current_mag = current_mag.to_f32() / (f32::from_primitive(volume));
|
|
let mean_current_vec = current_vec.cast::<f32>() / (f32::from_primitive(volume));
|
|
(mean_current_mag, mean_current_vec.cast())
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct FieldSample(u32, f64, Vec3<f64>);
|
|
|
|
impl std::iter::Sum for FieldSample {
|
|
fn sum<I>(iter: I) -> Self
|
|
where I: Iterator<Item = Self>
|
|
{
|
|
let mut s = FieldSample::default();
|
|
for FieldSample(a, b, c) in iter {
|
|
s = FieldSample(s.0 + a, s.1 + b, s.2 + c);
|
|
}
|
|
s
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct FieldSamples<T>(T);
|
|
|
|
impl std::iter::Sum for FieldSamples<[FieldSample; 2]> {
|
|
fn sum<I>(iter: I) -> Self
|
|
where I: Iterator<Item = Self>
|
|
{
|
|
let mut s = Self::default();
|
|
for p in iter {
|
|
s.0[0] = FieldSample(s.0[0].0 + p.0[0].0, s.0[0].1 + p.0[0].1, s.0[0].2 + p.0[0].2);
|
|
s.0[1] = FieldSample(s.0[1].0 + p.0[1].0, s.0[1].1 + p.0[1].1, s.0[1].2 + p.0[1].2);
|
|
}
|
|
s
|
|
}
|
|
}
|
|
|
|
impl std::iter::Sum for FieldSamples<[FieldSample; 3]> {
|
|
fn sum<I>(iter: I) -> Self
|
|
where I: Iterator<Item = Self>
|
|
{
|
|
let mut s = Self::default();
|
|
for p in iter {
|
|
s.0[0] = FieldSample(s.0[0].0 + p.0[0].0, s.0[0].1 + p.0[0].1, s.0[0].2 + p.0[0].2);
|
|
s.0[1] = FieldSample(s.0[1].0 + p.0[1].0, s.0[1].1 + p.0[1].1, s.0[1].2 + p.0[1].2);
|
|
s.0[2] = FieldSample(s.0[2].0 + p.0[2].0, s.0[2].1 + p.0[2].1, s.0[2].2 + p.0[2].2);
|
|
}
|
|
s
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Current {
|
|
fn eval(&self, state: &S) -> String {
|
|
let (mean_current_mag, mean_current_vec) = self.data(state);
|
|
format!("I/cell({}): {:.2e} {:.2e}",
|
|
self.name,
|
|
mean_current_mag,
|
|
mean_current_vec)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let (mean_current_mag, mean_current_vec) = self.data(state);
|
|
vec![
|
|
Measurement::new(
|
|
&format!("Imag/cell({})", self.name),
|
|
mean_current_mag,
|
|
"A",
|
|
),
|
|
Measurement::new(
|
|
&format!("/cell({})", self.name),
|
|
mean_current_vec,
|
|
"A",
|
|
),
|
|
]
|
|
}
|
|
}
|
|
|
|
/// Measures the current directed around a closed loop
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct CurrentLoop {
|
|
name: String,
|
|
region: Torus
|
|
}
|
|
|
|
impl CurrentLoop {
|
|
pub fn new(name: &str, r: Torus) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: r,
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> f32 {
|
|
let FieldSample(volume, directed_current, _current_vec) = state.map_sum_over_enumerated(&self.region, |coord: Meters, _cell| {
|
|
let normal = self.region.axis();
|
|
let to_coord = *coord - *self.region.center();
|
|
let tangent = normal.cross(to_coord).norm();
|
|
let current = state.current(coord);
|
|
let directed_current = current.dot(tangent.cast());
|
|
FieldSample(1, directed_current.cast(), current.cast())
|
|
});
|
|
let mean_directed_current = directed_current.cast::<f32>() / f32::from_primitive(volume);
|
|
let cross_section = self.region.cross_section() / (state.feature_size() * state.feature_size());
|
|
let cross_sectional_current = mean_directed_current * cross_section;
|
|
cross_sectional_current
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for CurrentLoop {
|
|
fn eval(&self, state: &S) -> String {
|
|
let cross_sectional_current = self.data(state);
|
|
format!("I({}): {:.2e}", self.name, cross_sectional_current)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let cross_sectional_current = self.data(state);
|
|
vec![
|
|
Measurement::new(
|
|
&format!("I({})", self.name),
|
|
cross_sectional_current,
|
|
"A"
|
|
),
|
|
]
|
|
}
|
|
}
|
|
|
|
|
|
/// Measures the M, B field directed around a closed loop
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct MagneticLoop {
|
|
name: String,
|
|
region: Torus
|
|
}
|
|
|
|
impl MagneticLoop {
|
|
pub fn new(name: &str, r: Torus) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: r,
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> (f32, f32, f32) {
|
|
let FieldSamples([
|
|
FieldSample(volume, directed_m, _m_vec),
|
|
FieldSample(_, directed_b, _b_vec),
|
|
FieldSample(_, directed_h, _h_vec),
|
|
]) = state.map_sum_over_enumerated(&self.region, |coord: Meters, cell|
|
|
{
|
|
let normal = self.region.axis();
|
|
let to_coord = *coord - *self.region.center();
|
|
let tangent = normal.cross(to_coord).norm();
|
|
|
|
let m = cell.m();
|
|
let directed_m = m.dot(tangent.cast());
|
|
let b = cell.b();
|
|
let directed_b = b.dot(tangent.cast());
|
|
let h = cell.h();
|
|
let directed_h = h.dot(tangent.cast());
|
|
FieldSamples([
|
|
FieldSample(1, directed_m.cast(), m.cast()),
|
|
FieldSample(1, directed_b.cast(), b.cast()),
|
|
FieldSample(1, directed_h.cast(), h.cast()),
|
|
])
|
|
});
|
|
// let cross_section = self.region.cross_section() / (state.feature_size() * state.feature_size());
|
|
let mean_directed_m = directed_m.cast::<f32>() / f32::from_primitive(volume);
|
|
// let cross_sectional_m = mean_directed_m * cross_section;
|
|
let mean_directed_b = directed_b.cast::<f32>() / f32::from_primitive(volume);
|
|
// let cross_sectional_b = mean_directed_b * cross_section;
|
|
let mean_directed_h = directed_h.cast::<f32>() / f32::from_primitive(volume);
|
|
// let cross_sectional_h = mean_directed_h * cross_section;
|
|
// format!(
|
|
// "M({}): {:.2e}; B({}): {:.2e}; H({}): {:.2e}",
|
|
// self.name, cross_sectional_m,
|
|
// self.name, cross_sectional_b,
|
|
// self.name, cross_sectional_h,
|
|
// )
|
|
(mean_directed_m, mean_directed_b, mean_directed_h)
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for MagneticLoop {
|
|
fn eval(&self, state: &S) -> String {
|
|
let (mean_directed_m, mean_directed_b, mean_directed_h) = self.data(state);
|
|
format!(
|
|
"M({}): {:.2e}; B({}): {:.2e}; H({}): {:.2e}",
|
|
self.name, mean_directed_m,
|
|
self.name, mean_directed_b,
|
|
self.name, mean_directed_h,
|
|
)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let (mean_directed_m, mean_directed_b, mean_directed_h) = self.data(state);
|
|
vec![
|
|
Measurement::new_unitless(&format!("M({})", self.name), mean_directed_current_m),
|
|
Beasurement::new_unitless(&format!("B({})", self.name), mean_directed_current_b),
|
|
Beasurement::new_unitless(&format!("H({})", self.name), mean_directed_current_h),
|
|
]
|
|
}
|
|
}
|
|
|
|
/// mean M over a region
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct MagneticFlux {
|
|
name: String,
|
|
region: Box<dyn Region>,
|
|
}
|
|
|
|
impl MagneticFlux {
|
|
pub fn new<R: Region + 'static>(name: &str, r: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(r)
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> Vec3<f32> {
|
|
let FieldSample(volume, _directed_mag, mag_vec) = state.map_sum_over(&*self.region, |cell| {
|
|
let b = cell.b();
|
|
let mag = b.mag();
|
|
FieldSample(1, mag.cast(), b.cast())
|
|
});
|
|
let mean_mag = mag_vec.cast() / f32::from_primitive(volume);
|
|
mean_mag
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for MagneticFlux {
|
|
fn eval(&self, state: &S) -> String {
|
|
let mean_mag = self.data(state);
|
|
format!("Bavg({}): {:.2e}", self.name, mean_mag)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let mean_mag = self.data(state);
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("Bavg({})", self.name),
|
|
mean_mag,
|
|
)
|
|
]
|
|
}
|
|
}
|
|
|
|
/// mean B over a region
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Magnetization {
|
|
name: String,
|
|
region: Box<dyn Region>,
|
|
}
|
|
|
|
impl Magnetization {
|
|
pub fn new<R: Region + 'static>(name: &str, r: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(r)
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> Vec3<f32> {
|
|
let FieldSample(volume, _directed_mag, mag_vec) = state.map_sum_over(&*self.region, |cell| {
|
|
let m = cell.m();
|
|
let mag = m.mag();
|
|
FieldSample(1, mag.cast(), m.cast())
|
|
});
|
|
let mean_mag = mag_vec.cast() / f32::from_primitive(volume);
|
|
mean_mag
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Magnetization {
|
|
fn eval(&self, state: &S) -> String {
|
|
let mean_mag = self.data(state);
|
|
format!("Mavg({}): {:.2e}", self.name, mean_mag)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let mean_mag = self.data(state);
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("Mavg({})", self.name), mean_mag
|
|
),
|
|
]
|
|
}
|
|
}
|
|
|
|
fn loc(v: Meters) -> String {
|
|
format!("{:.0} um", *v * f32::from_primitive(1_000_000))
|
|
}
|
|
|
|
/// M
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct MagnetizationAt(pub Meters);
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for MagnetizationAt {
|
|
fn eval(&self, state: &S) -> String {
|
|
let m = state.sample(self.0).m();
|
|
format!("M{}: {:.2e}", loc(self.0), m)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let m = state.sample(self.0).m();
|
|
vec![
|
|
Measurement::new_unitless(&format!("M{}", loc(self.0)), m)
|
|
]
|
|
}
|
|
}
|
|
|
|
/// B
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct MagneticFluxAt(pub Meters);
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for MagneticFluxAt {
|
|
fn eval(&self, state: &S) -> String {
|
|
let b = state.sample(self.0).b();
|
|
format!("B{}: {:.2e}", loc(self.0), b)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let b = state.sample(self.0).b();
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("B{}", loc(self.0)), b
|
|
)
|
|
]
|
|
}
|
|
}
|
|
|
|
/// H
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct MagneticStrengthAt(pub Meters);
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for MagneticStrengthAt {
|
|
fn eval(&self, state: &S) -> String {
|
|
let h = state.sample(self.0).h();
|
|
format!("H{}: {:.2e}", loc(self.0), h)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let h = state.sample(self.0).h();
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("H{}", loc(self.0)), h
|
|
)
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct ElectricField(pub Meters);
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for ElectricField {
|
|
fn eval(&self, state: &S) -> String {
|
|
let e = state.sample(self.0).e();
|
|
format!("E{}: {}", loc(self.0), e)
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let e = state.sample(self.0).e();
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("E{}", loc(self.0)), e
|
|
)
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Energy {
|
|
name: String,
|
|
region: Box<dyn Region>,
|
|
}
|
|
|
|
impl Energy {
|
|
pub fn world() -> Self {
|
|
Self::new("World", WorldRegion)
|
|
}
|
|
pub fn new<R: Region + 'static>(name: &str, region: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(region),
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> f32 {
|
|
// Potential energy stored in a E/M field:
|
|
// https://en.wikipedia.org/wiki/Magnetic_energy
|
|
// https://en.wikipedia.org/wiki/Electric_potential_energy#Energy_stored_in_an_electrostatic_field_distribution
|
|
// TODO: consider the M field? https://en.wikipedia.org/wiki/Potential_energy#Magnetic_potential_energy
|
|
// U(B) = 1/2 \int H . B dV
|
|
// U(E) = 1/2 \int E . D dV
|
|
#[allow(non_snake_case)]
|
|
let dV = state.feature_volume();
|
|
let e = f64::from_primitive(0.5 * dV) * state.map_sum_over(&*self.region, |cell| {
|
|
// E . D = E . (E + P) = E.E since we don't model polarization fields
|
|
cell.h().dot(cell.b()).to_f64() + cell.e().mag_sq().to_f64()
|
|
});
|
|
e.cast()
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Energy {
|
|
fn eval(&self, state: &S) -> String {
|
|
let e = self.data(state);
|
|
format!("U({}): {}", self.name, SiScale::format_short(e, "J"))
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let e = self.data(state);
|
|
vec![
|
|
Measurement::new_unitless(
|
|
&format!("U({})", self.name), e
|
|
)
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Power {
|
|
name: String,
|
|
region: Box<dyn Region>
|
|
}
|
|
|
|
impl Power {
|
|
pub fn world() -> Self {
|
|
Self::new("World", WorldRegion)
|
|
}
|
|
pub fn new<R: Region + 'static>(name: &str, region: R) -> Self {
|
|
Self {
|
|
name: name.into(),
|
|
region: Box::new(region),
|
|
}
|
|
}
|
|
fn data<S: AbstractSim>(&self, state: &S) -> f32 {
|
|
// Power is P = IV = A*J*V = L^2*J.(LE) = L^3 J.E
|
|
// where L is feature size.
|
|
#[allow(non_snake_case)]
|
|
let dV = state.feature_volume();
|
|
let power = f64::from_primitive(dV) * state.map_sum_over(&*self.region, |cell| {
|
|
cell.current_density().dot(cell.e()).to_f64()
|
|
});
|
|
power.cast()
|
|
}
|
|
}
|
|
|
|
impl<S: AbstractSim> AbstractMeasurement<S> for Power {
|
|
fn eval(&self, state: &S) -> String {
|
|
let power = self.data(state);
|
|
format!("P({}): {}", self.name, SiScale::format_short(power, "W"))
|
|
}
|
|
fn key_value(&self, state: &S) -> Vec<Measurement> {
|
|
let power = self.data(state);
|
|
vec![
|
|
Measurement::new(
|
|
&format!("P({})", self.name), power, "W"
|
|
)
|
|
]
|
|
}
|
|
}
|