xdmf 0.2.0

Small library to write XDMF files for Paraview
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

//! This module contains the Attribute element, which defines values associated with the mesh.

use serde::{Deserialize, Serialize};

use super::data_item::DataItem;

/// The Attribute element defines values associated with the mesh.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct Attribute {
    #[serde(rename = "@Name")]
    #[doc(hidden)]
    pub name: String,

    #[serde(rename = "@AttributeType")]
    #[doc(hidden)]
    pub attribute_type: AttributeType,

    #[serde(rename = "@Center")]
    #[doc(hidden)]
    pub center: Center,

    #[serde(rename = "DataItem")]
    #[doc(hidden)]
    pub data_items: Vec<DataItem>,
}

/// Type of the data (scalar, vector, tensor, etc.)
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
pub enum AttributeType {
    #[default]
    #[doc(hidden)]
    Scalar,
    #[doc(hidden)]
    Vector,
    #[doc(hidden)]
    Tensor,
    #[doc(hidden)]
    Tensor6,
    #[doc(hidden)]
    Matrix,
}

/// Specifies where the attribute data is centered, e.g., on nodes or cells.
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
pub enum Center {
    #[default]
    #[doc(hidden)]
    Node,
    #[doc(hidden)]
    Edge,
    #[doc(hidden)]
    Face,
    #[doc(hidden)]
    Cell,
    #[doc(hidden)]
    Grid,
    #[doc(hidden)]
    Other,
}

#[cfg(test)]
mod tests {
    use quick_xml::se::to_string;

    use super::*;

    #[test]
    fn attribute_default() {
        let attribute = Attribute::default();
        assert_eq!(attribute.name, "");
        assert_eq!(attribute.attribute_type, AttributeType::Scalar);
        assert_eq!(attribute.center, Center::Node);
    }

    #[test]
    fn attribute_serialization() {
        let attribute = Attribute {
            name: String::from("Temperature"),
            attribute_type: AttributeType::Scalar,
            center: Center::Cell,
            data_items: vec![DataItem::default(), DataItem::default()],
        };

        pretty_assertions::assert_eq!(
            to_string(&attribute).unwrap(),
            "<Attribute Name=\"Temperature\" AttributeType=\"Scalar\" Center=\"Cell\">\
                <DataItem Dimensions=\"1\" NumberType=\"Float\" Format=\"XML\" Precision=\"4\"/>\
                <DataItem Dimensions=\"1\" NumberType=\"Float\" Format=\"XML\" Precision=\"4\"/>\
            </Attribute>"
        );
    }

    #[test]
    fn attribute_type_default() {
        assert_eq!(AttributeType::default(), AttributeType::Scalar);
    }

    #[test]
    fn center_default() {
        assert_eq!(Center::default(), Center::Node);
    }
}