hfss_fld 0.1.0

Ansys HFSS `.fld` file parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

mod fld_file_loader;

pub use fld_file_loader::{DataCoordinates, DataDimensionality, FileData};

// pub fn load_b1_file(path_and_name: &str) -> FileData {
//     match FileData::load_file(path_and_name, 1) {
//         Ok(file_data) => file_data,
//         Err(msg) => panic!("Unable to read file! \n {}", msg),
//     }
// }

// pub fn load_complex_h_file(path_and_name: &str) -> FileData {
//     match FileData::load_file(path_and_name, 6) {
//         Ok(file_data) => file_data,
//         Err(msg) => panic!("Unable to read file! \n {}", msg),
//     }
// }

// pub fn load_complex_h_file_group(paths_and_names: &[&str]) -> Vec<FileData> {
//     paths_and_names
//         .iter()
//         .map(|pn| load_complex_h_file(&pn))
//         .collect()
// }

#[derive(Clone, Debug)]
pub struct B1Data {
    file_name: String,
    geo_keys: Vec<[i32; 3]>,
    b1_vals: Vec<f64>,
}

impl B1Data {
    pub fn from_file(path_and_name: &str) -> Self {
        let file_data = match FileData::load_file(path_and_name, 1) {
            Ok(fd) => fd,
            Err(msg) => panic!("{}", msg),
        };

        let file_name = file_data.file_name;
        let geo_keys = file_data
            .geo_points
            .iter()
            .map(|geo_floats| gen_geo_key(geo_floats))
            .collect();

        let b1_vals = file_data.fld_points.iter().flatten().copied().collect();

        Self {
            file_name,
            geo_keys,
            b1_vals,
        }
    }
}

#[derive(Clone, Debug)]
pub struct HDataGroup {
    file_names: Vec<String>,
    geo_keys: Vec<[i32; 3]>,
    ch_h_vals: Vec<Vec<[f64; 6]>>,
    num_points: usize,
}

impl HDataGroup {
    pub fn from_files(paths_and_names: &[&str], assert_geo_equality: bool) -> Self {
        let file_datas: Vec<FileData> = paths_and_names
            .iter()
            .map(|pn| match FileData::load_file(&pn, 6) {
                Ok(fd) => fd,
                Err(msg) => panic!("{}", msg),
            })
            .collect();

        let num_points = file_datas[0].num_points;
        for fd in file_datas.iter().skip(1) {
            assert_eq!(
                num_points, fd.num_points,
                "H files do not have the same number of points!"
            );
        }

        let file_names = file_datas.iter().map(|fd| fd.file_name.clone()).collect();
        let geo_keys: Vec<[i32; 3]> = file_datas[0]
            .geo_points
            .iter()
            .map(|geo_floats| gen_geo_key(geo_floats))
            .collect();

        if assert_geo_equality {
            for fd in file_datas.iter().skip(1) {
                for (key, geo_pt) in geo_keys.iter().zip(fd.geo_points.iter()) {
                    assert_eq!(
                        key,
                        &gen_geo_key(geo_pt),
                        "H files do not cover the same geometry!"
                    );
                }
            }
        }

        let ch_h_vals = file_datas
            .iter()
            .map(|fd| {
                fd.fld_points
                    .iter()
                    .map(|fld_pt| {
                        [
                            fld_pt[0], fld_pt[1], fld_pt[2], fld_pt[3], fld_pt[4], fld_pt[5],
                        ]
                    })
                    .collect()
            })
            .collect();

        Self {
            file_names,
            geo_keys,
            ch_h_vals,
            num_points,
        }
    }
}

fn gen_geo_key(geo_floats: &[f64; 3]) -> [i32; 3] {
    [
        (geo_floats[0] * 1000.0) as i32,
        (geo_floats[1] * 1000.0) as i32,
        (geo_floats[2] * 1000.0) as i32,
    ]
}