rossby 0.0.3

A blazingly fast, in-memory, NetCDF-to-API server
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

use std::error::Error;
use std::path::Path;

use netcdf::types::{FloatType, NcVariableType};

fn main() -> Result<(), Box<dyn Error>> {
    // Path to the NetCDF file
    let file_path = Path::new("tests/fixtures/2m_temperature_1982_5.625deg.nc");

    println!("Inspecting NetCDF file: {}", file_path.display());

    // Open the NetCDF file
    let file = netcdf::open(file_path)?;

    // Print file information
    println!("\n=== FILE INFORMATION ===");

    // Print dimensions
    println!("\nDimensions:");
    for dim in file.dimensions() {
        println!(
            "  {} = {} {}",
            dim.name(),
            dim.len(),
            if dim.is_unlimited() {
                "(unlimited)"
            } else {
                ""
            }
        );
    }

    // Print variables
    println!("\nVariables:");
    for var in file.variables() {
        print!("  {} ({:?})", var.name(), var.vartype());

        // Print dimensions for this variable
        print!(" [");
        for (i, dim) in var.dimensions().iter().enumerate() {
            if i > 0 {
                print!(", ");
            }
            print!("{} = {}", dim.name(), dim.len());
        }
        println!("]");

        // Print attributes for this variable
        for attr in var.attributes() {
            print!("    {}: ", attr.name());
            match attr.value() {
                Ok(val) => println!("{:?}", val),
                Err(e) => println!("Error reading value: {}", e),
            }
        }
    }

    // Print global attributes
    println!("\nGlobal Attributes:");
    for attr in file.attributes() {
        print!("  {}: ", attr.name());
        match attr.value() {
            Ok(val) => println!("{:?}", val),
            Err(e) => println!("Error reading value: {}", e),
        }
    }

    // Print information about the first data values
    println!("\nSample Data Values:");
    for var in file.variables() {
        println!("  {} ({:?}):", var.name(), var.vartype());

        match var.name().as_str() {
            "longitude" | "latitude" | "time" => {
                // For coordinate variables, try to print all values
                match var.vartype() {
                    NcVariableType::Float(FloatType::F32) => {
                        println!("    Trying to read as f32...");
                        match var.get_values::<f32, _>(&[] as &[netcdf::Extent]) {
                            Ok(vals) => println!("    Values: {:?}", vals),
                            Err(e) => println!("    Error reading values: {}", e),
                        }
                    }
                    NcVariableType::Float(FloatType::F64) => {
                        println!("    Trying to read as f64...");
                        match var.get_values::<f64, _>(&[] as &[netcdf::Extent]) {
                            Ok(vals) => println!("    Values: {:?}", vals),
                            Err(e) => println!("    Error reading values: {}", e),
                        }
                    }
                    _ => println!("    Skipping unsupported type"),
                }
            }
            _ => {
                // For data variables, try to read just a few values
                match var.vartype() {
                    NcVariableType::Float(FloatType::F32) => {
                        println!("    Trying to read first value as f32...");
                        // Try to read just the first value
                        let indices = vec![0; var.dimensions().len()];
                        let mut index_array = [0; 10]; // Most NetCDF files won't have more than 10 dimensions
                        index_array[..var.dimensions().len()]
                            .copy_from_slice(&indices[..var.dimensions().len()]);

                        match var.get_value::<f32, _>(&index_array[..var.dimensions().len()]) {
                            Ok(val) => println!("    First value: {}", val),
                            Err(e) => println!("    Error reading first value: {}", e),
                        }
                    }
                    NcVariableType::Float(FloatType::F64) => {
                        println!("    Trying to read first value as f64...");
                        // Try to read just the first value
                        let indices = vec![0; var.dimensions().len()];
                        let mut index_array = [0; 10]; // Most NetCDF files won't have more than 10 dimensions
                        index_array[..var.dimensions().len()]
                            .copy_from_slice(&indices[..var.dimensions().len()]);

                        match var.get_value::<f64, _>(&index_array[..var.dimensions().len()]) {
                            Ok(val) => println!("    First value: {}", val),
                            Err(e) => println!("    Error reading first value: {}", e),
                        }
                    }
                    _ => println!("    Skipping unsupported type"),
                }
            }
        }
    }

    Ok(())
}