150 lines
4.2 KiB
Rust
150 lines
4.2 KiB
Rust
use femm_doc_heat::FemmDoc;
|
|
|
|
const FIXTURE: &str = r#"[Format] = 1
|
|
[Precision] = 1e-08
|
|
[MinAngle] = 30
|
|
[DoSmartMesh] = 1
|
|
[Depth] = 1
|
|
[LengthUnits] = millimeters
|
|
[ProblemType] = planar
|
|
[Coordinates] = cartesian
|
|
[PrevSoln] = ""
|
|
[dT] = 0.01
|
|
[Comment] = "heat-flow planar slab"
|
|
[PointProps] = 1
|
|
<BeginPoint>
|
|
<PointName> = "Tfix"
|
|
<Tp> = 300
|
|
<qp> = 0
|
|
<EndPoint>
|
|
[BdryProps] = 1
|
|
<BeginBdry>
|
|
<BdryName> = "ambient"
|
|
<BdryType> = 2
|
|
<Tset> = 0
|
|
<qs> = 0
|
|
<beta> = 0
|
|
<h> = 10
|
|
<Tinf> = 293
|
|
<EndBdry>
|
|
[BlockProps] = 2
|
|
<BeginBlock>
|
|
<BlockName> = "Air"
|
|
<Kx> = 0.026
|
|
<Ky> = 0.026
|
|
<Kt> = 1006
|
|
<qv> = 0
|
|
<EndBlock>
|
|
<BeginBlock>
|
|
<BlockName> = "Copper"
|
|
<Kx> = 401
|
|
<Ky> = 401
|
|
<Kt> = 385
|
|
<qv> = 0
|
|
<TKPoints> = 3
|
|
250 410
|
|
300 401
|
|
400 390
|
|
<EndBlock>
|
|
[ConductorProps] = 1
|
|
<BeginConductor>
|
|
<ConductorName> = "Heater"
|
|
<Tc> = 0
|
|
<qc> = 50
|
|
<ConductorType> = 0
|
|
<EndConductor>
|
|
[NumPoints] = 4
|
|
0 0 1 0 1
|
|
10 0 0 0 0
|
|
10 10 0 0 0
|
|
0 10 0 0 0
|
|
[NumSegments] = 4
|
|
0 1 -1 1 0 0 0
|
|
1 2 -1 1 0 0 0
|
|
2 3 -1 1 0 0 0
|
|
3 0 -1 1 0 0 0
|
|
[NumArcSegments] = 0
|
|
[NumHoles] = 0
|
|
[NumBlockLabels] = 1
|
|
5 5 2 0.1 0 0
|
|
"#;
|
|
|
|
#[test]
|
|
fn parses_fixture_geometry() {
|
|
let doc = FemmDoc::parse(FIXTURE).expect("parse");
|
|
assert_eq!(doc.dt, 0.01);
|
|
assert_eq!(doc.nodes.len(), 4);
|
|
assert_eq!(doc.segments.len(), 4);
|
|
assert_eq!(doc.arcs.len(), 0);
|
|
assert_eq!(doc.block_labels.len(), 1);
|
|
assert_eq!(doc.materials.len(), 2);
|
|
assert_eq!(doc.boundaries.len(), 1);
|
|
assert_eq!(doc.points.len(), 1);
|
|
assert_eq!(doc.conductors.len(), 1);
|
|
assert_eq!(doc.nodes[0].boundary_marker, "Tfix");
|
|
assert_eq!(doc.nodes[0].in_conductor, "Heater");
|
|
assert_eq!(doc.nodes[1].in_conductor, "<None>");
|
|
assert_eq!(doc.segments[0].boundary_marker, "ambient");
|
|
assert_eq!(doc.block_labels[0].block_type, "Copper");
|
|
assert_eq!(doc.materials[1].name, "Copper");
|
|
assert_eq!(doc.materials[1].tk_curve.len(), 3);
|
|
assert_eq!(doc.materials[1].tk_curve[1], (300.0, 401.0));
|
|
assert_eq!(doc.boundaries[0].h, 10.0);
|
|
assert_eq!(doc.boundaries[0].tinf, 293.0);
|
|
assert_eq!(doc.points[0].tp, 300.0);
|
|
assert_eq!(doc.conductors[0].qc, 50.0);
|
|
}
|
|
|
|
#[test]
|
|
fn round_trips_parse_write_parse() {
|
|
let a = FemmDoc::parse(FIXTURE).expect("parse a");
|
|
let text = a.write();
|
|
let b = FemmDoc::parse(&text).expect("parse b");
|
|
|
|
assert_eq!(a.dt, b.dt);
|
|
assert_eq!(a.precision, b.precision);
|
|
assert_eq!(a.depth, b.depth);
|
|
assert_eq!(a.nodes.len(), b.nodes.len());
|
|
assert_eq!(a.segments.len(), b.segments.len());
|
|
assert_eq!(a.materials.len(), b.materials.len());
|
|
assert_eq!(a.conductors.len(), b.conductors.len());
|
|
|
|
for (x, y) in a.nodes.iter().zip(b.nodes.iter()) {
|
|
assert!((x.x - y.x).abs() < 1e-12);
|
|
assert!((x.y - y.y).abs() < 1e-12);
|
|
assert_eq!(x.boundary_marker, y.boundary_marker);
|
|
assert_eq!(x.in_conductor, y.in_conductor);
|
|
}
|
|
for (x, y) in a.segments.iter().zip(b.segments.iter()) {
|
|
assert_eq!(x.n0, y.n0);
|
|
assert_eq!(x.n1, y.n1);
|
|
assert_eq!(x.boundary_marker, y.boundary_marker);
|
|
}
|
|
for (x, y) in a.materials.iter().zip(b.materials.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert!((x.kx - y.kx).abs() < 1e-12);
|
|
assert!((x.kt - y.kt).abs() < 1e-12);
|
|
assert_eq!(x.tk_curve.len(), y.tk_curve.len());
|
|
for ((t0, k0), (t1, k1)) in x.tk_curve.iter().zip(y.tk_curve.iter()) {
|
|
assert!((t0 - t1).abs() < 1e-12);
|
|
assert!((k0 - k1).abs() < 1e-12);
|
|
}
|
|
}
|
|
for (x, y) in a.boundaries.iter().zip(b.boundaries.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert!((x.h - y.h).abs() < 1e-12);
|
|
assert!((x.tinf - y.tinf).abs() < 1e-12);
|
|
}
|
|
for (x, y) in a.conductors.iter().zip(b.conductors.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert!((x.qc - y.qc).abs() < 1e-12);
|
|
assert_eq!(x.conductor_type, y.conductor_type);
|
|
}
|
|
assert_eq!(a.block_labels.len(), b.block_labels.len());
|
|
let la = &a.block_labels[0];
|
|
let lb = &b.block_labels[0];
|
|
assert!((la.x - lb.x).abs() < 1e-12);
|
|
assert_eq!(la.block_type, lb.block_type);
|
|
assert!((la.max_area - lb.max_area).abs() < 1e-10);
|
|
}
|