199 lines
5.9 KiB
Rust
199 lines
5.9 KiB
Rust
use femm_doc_curr::FemmDoc;
|
|
|
|
const FIXTURE: &str = r#"[Format] = 1
|
|
[Precision] = 1e-08
|
|
[Frequency] = 1000
|
|
[MinAngle] = 30
|
|
[DoSmartMesh] = 1
|
|
[Depth] = 1
|
|
[LengthUnits] = millimeters
|
|
[ProblemType] = planar
|
|
[Coordinates] = cartesian
|
|
[Comment] = "two-electrode current flow"
|
|
[PointProps] = 1
|
|
<BeginPoint>
|
|
<PointName> = "V=0"
|
|
<vpr> = 0.5
|
|
<vpi> = 0.25
|
|
<qpr> = 1.5
|
|
<qpi> = -0.75
|
|
<EndPoint>
|
|
[BdryProps] = 1
|
|
<BeginBdry>
|
|
<BdryName> = "outer"
|
|
<BdryType> = 2
|
|
<vsr> = 12
|
|
<vsi> = 3
|
|
<qsr> = 0.1
|
|
<qsi> = -0.2
|
|
<c0r> = 4
|
|
<c0i> = 5
|
|
<c1r> = 6
|
|
<c1i> = 7
|
|
<EndBdry>
|
|
[BlockProps] = 2
|
|
<BeginBlock>
|
|
<BlockName> = "Copper"
|
|
<ox> = 5.8e7
|
|
<oy> = 5.8e7
|
|
<ex> = 1
|
|
<ey> = 1
|
|
<ltx> = 0
|
|
<lty> = 0
|
|
<EndBlock>
|
|
<BeginBlock>
|
|
<BlockName> = "FR4"
|
|
<ox> = 0.01
|
|
<oy> = 0.02
|
|
<ex> = 4.3
|
|
<ey> = 4.5
|
|
<ltx> = 0.02
|
|
<lty> = 0.03
|
|
<EndBlock>
|
|
[ConductorProps] = 1
|
|
<BeginConductor>
|
|
<ConductorName> = "Pad"
|
|
<vcr> = 10
|
|
<vci> = 1
|
|
<qcr> = 0.5
|
|
<qci> = -0.5
|
|
<ConductorType> = 1
|
|
<EndConductor>
|
|
[NumPoints] = 4
|
|
0 0 1 0 0
|
|
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.frequency, 1000.0);
|
|
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, "V=0");
|
|
assert_eq!(doc.segments[0].boundary_marker, "outer");
|
|
assert_eq!(doc.block_labels[0].block_type, "FR4");
|
|
|
|
let p = &doc.points[0];
|
|
assert!((p.vp.re - 0.5).abs() < 1e-12);
|
|
assert!((p.vp.im - 0.25).abs() < 1e-12);
|
|
assert!((p.qp.re - 1.5).abs() < 1e-12);
|
|
assert!((p.qp.im + 0.75).abs() < 1e-12);
|
|
|
|
let b = &doc.boundaries[0];
|
|
assert_eq!(b.format, 2);
|
|
assert!((b.vs.re - 12.0).abs() < 1e-12);
|
|
assert!((b.vs.im - 3.0).abs() < 1e-12);
|
|
assert!((b.qs.re - 0.1).abs() < 1e-12);
|
|
assert!((b.qs.im + 0.2).abs() < 1e-12);
|
|
assert!((b.c0.re - 4.0).abs() < 1e-12);
|
|
assert!((b.c0.im - 5.0).abs() < 1e-12);
|
|
assert!((b.c1.re - 6.0).abs() < 1e-12);
|
|
assert!((b.c1.im - 7.0).abs() < 1e-12);
|
|
|
|
let m1 = &doc.materials[1];
|
|
assert_eq!(m1.name, "FR4");
|
|
assert!((m1.ox - 0.01).abs() < 1e-12);
|
|
assert!((m1.oy - 0.02).abs() < 1e-12);
|
|
assert!((m1.ex - 4.3).abs() < 1e-12);
|
|
assert!((m1.ey - 4.5).abs() < 1e-12);
|
|
assert!((m1.ltx - 0.02).abs() < 1e-12);
|
|
assert!((m1.lty - 0.03).abs() < 1e-12);
|
|
|
|
let c = &doc.conductors[0];
|
|
assert_eq!(c.name, "Pad");
|
|
assert_eq!(c.conductor_type, 1);
|
|
assert!((c.vc.re - 10.0).abs() < 1e-12);
|
|
assert!((c.vc.im - 1.0).abs() < 1e-12);
|
|
assert!((c.qc.re - 0.5).abs() < 1e-12);
|
|
assert!((c.qc.im + 0.5).abs() < 1e-12);
|
|
}
|
|
|
|
#[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.frequency, b.frequency);
|
|
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());
|
|
assert_eq!(a.boundaries.len(), b.boundaries.len());
|
|
assert_eq!(a.points.len(), b.points.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);
|
|
}
|
|
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.ox - y.ox).abs() < 1e-12);
|
|
assert!((x.oy - y.oy).abs() < 1e-12);
|
|
assert!((x.ex - y.ex).abs() < 1e-12);
|
|
assert!((x.ey - y.ey).abs() < 1e-12);
|
|
assert!((x.ltx - y.ltx).abs() < 1e-12);
|
|
assert!((x.lty - y.lty).abs() < 1e-12);
|
|
}
|
|
for (x, y) in a.points.iter().zip(b.points.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert!((x.vp.re - y.vp.re).abs() < 1e-12);
|
|
assert!((x.vp.im - y.vp.im).abs() < 1e-12);
|
|
assert!((x.qp.re - y.qp.re).abs() < 1e-12);
|
|
assert!((x.qp.im - y.qp.im).abs() < 1e-12);
|
|
}
|
|
for (x, y) in a.boundaries.iter().zip(b.boundaries.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert_eq!(x.format, y.format);
|
|
assert!((x.vs.re - y.vs.re).abs() < 1e-12);
|
|
assert!((x.vs.im - y.vs.im).abs() < 1e-12);
|
|
assert!((x.qs.re - y.qs.re).abs() < 1e-12);
|
|
assert!((x.qs.im - y.qs.im).abs() < 1e-12);
|
|
assert!((x.c0.re - y.c0.re).abs() < 1e-12);
|
|
assert!((x.c0.im - y.c0.im).abs() < 1e-12);
|
|
assert!((x.c1.re - y.c1.re).abs() < 1e-12);
|
|
assert!((x.c1.im - y.c1.im).abs() < 1e-12);
|
|
}
|
|
for (x, y) in a.conductors.iter().zip(b.conductors.iter()) {
|
|
assert_eq!(x.name, y.name);
|
|
assert_eq!(x.conductor_type, y.conductor_type);
|
|
assert!((x.vc.re - y.vc.re).abs() < 1e-12);
|
|
assert!((x.vc.im - y.vc.im).abs() < 1e-12);
|
|
assert!((x.qc.re - y.qc.re).abs() < 1e-12);
|
|
assert!((x.qc.im - y.qc.im).abs() < 1e-12);
|
|
}
|
|
|
|
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);
|
|
}
|