Debian Codegraph @

packages/seacas/applications/zellij/Zellij.md

raw
1 # Zellij
2
3 Zellij is a "mesh concatenation" application for generating a mesh
4 consisting of a "lattice" containing one or more "unit cell" template
5 meshes. The lattice is a two-dimensional arrangement of the unit cell
6 template meshes.
7
8 The unit cell template meshes are placed by zellij into the specified
9 locations in the lattice and the nodes on the boundaries of the unit
10 cell meshes are united or coincident. Each unit cell mesh must have
11 the same exterior boundary meshes and coordinate extents on the X and
12 Y coordinate faces, but the Z faces are only required to have the same
13 coordinate extent; the Z face meshes are not required to be the same
14 among the different unit cells.
15
16 The lattice can be represented as a IxJ regular grid with each "cell"
17 in the grid or lattice containing one of the unit cell template
18 meshes.
19
20 [TOC]
21
22 ## Execution
23
24 Executing zellij with the `-help` option will result in output similar to the following:
25
26 ```
27 Zellij
28 (A code for tiling 1 or more template databases into a single output database.)
29 (Version: 1.4.1) Modified: 2021/03/16
30 Parallel Capability Not Enabled.
31
32 usage: zellij [options] -lattice <lattice_definition_file>
33 -lattice <$val> (Name of file to read lattice definition from. [required])
34 -output <$val> (Name of output file to create. Default is `zellij-out.e`)
35
36 -rcb (Use recursive coordinate bisection method to decompose the input mesh in a parallel run.)
37 -rib (Use recursive inertial bisection method to decompose the input mesh in a parallel run.)
38 -hsfc (Use hilbert space-filling curve method to decompose the input mesh in a parallel run. [default])
39 -linear (Use the linear method to decompose the input mesh in a parallel run.
40 Elements in order first n/p to proc 0, next to proc 1.)
41 -cyclic (Use the cyclic method to decompose the input mesh in a parallel run.
42 Elements handed out to id % proc_count)
43 -random (Use the random method to decompose the input mesh in a parallel run.
44 Elements assigned randomly to processors in a way that preserves balance
45 (do _not_ use for a real run))
46
47 -ranks <$val> (Number of ranks to decompose mesh across)
48 -start_rank <$val> (In partial output mode, start outputting decomposed files at this rank)
49 -rank_count <$val> (In partial output or subcycle modes, output this number of ranks)
50 -subcycle (Process cells in groups of '-rank_count'. Helps minimize open files,
51 but is faster than only having a single file open.)
52 -scale <$val> (Scale the output mesh coordinates by the specified value)
53 -minimize_open_files [$val] (Close files after accessing them to avoid issues with too many open files.
54 If argument is 'output' then close output, if 'unit' then close unit cells;
55 if 'all' or no argument close all.
56 Should not need to use this option unless you get an error message indicating this issue.)
57
58 -ignore_sidesets (Do not copy any sidesets in the unit cells to the output file.)
59 -generate_sidesets <$val> (Which surfaces on the output mesh should have sidesets generated,
60 Valid options are:
61 'x' or 'i' for surface on minimum X coordinate, default name = `min_i`
62 'y' or 'j' for surface on minimum Y coordinate, default name = `min_j`
63 'z' or 'k' for surface on minimum Z coordinate, default name = `min_k`
64 'X' or 'I' for surface on maximum X coordinate, default name = `max_i`
65 'Y' or 'J' for surface on maximum Y coordinate, default name = `max_j`
66 'Z' or 'K' for surface on maximum Z coordinate, default name = `max_k`
67 For example `xyXY` would generate sidesets on min/max X and Y surfaces.)
68 -sideset_names <$val> (Specify names for one or more of the generated sidesets.
69 Form is `axis:name,axis:name,...`
70 where 'axis' is one of 'ijkIJKxyzXYZ', and 'name' is the name of the sideset.
71 The default names are 'min_i', 'max_i', 'min_j', 'max_j', 'min_k', 'max_k'.
72 For example `x:left,X:right` would name the sideset on the min x face 'left' and the max X face 'right'.)
73
74 -netcdf3 (Output database will be a netcdf3 native classical netcdf file format (32-bit only))
75 -netcdf4 (Output database will be a netcdf4 hdf5-based file instead of the classical netcdf file format (default))
76 -netcdf5 (Output database will be a netcdf5 (CDF5) file instead of the classical netcdf file format)
77
78 -32-bit (True if forcing the use of 32-bit integers for the output file)
79 -64-bit (True if forcing the use of 64-bit integers for the output file (default))
80
81 -zlib (Use the Zlib / libz compression method if compression is enabled (default) [exodus only].)
82 -szip (Use SZip compression. [exodus only, enables netcdf-4])
83 -compress <$val> (Specify the hdf5 zlib compression level [0..9] or szip [even, 4..32] to be used on the output file.)
84
85 -separate_cells (Do not equivalence the nodes between adjacent unit cells.)
86 -repeat <$val> (Each lattice entry will be used the specified number of times as will
87 each row in the lattice (for debugging). `-repeat 2` would double the lattice.)
88 -skip <$val> (Skip the specified number of lattice entries and rows. For example, -skip 1
89 would read every other entry on the row and every other row. (for debugging))
90 -help (Print this summary and exit)
91 -version (Print version and exit)
92 -debug <$val> (debug level (values are or'd)
93 1 = Time stamp information.
94 2 = Memory information.
95 4 = Verbose Unit Cell information.
96 8 = Verbose output of Grid finalization calculations.
97 16 = Put exodus library into verbose mode.
98 32 = Verbose decomposition information.
99 64 = Verbose output database summary information.
100 128 = Verbose sideset generation information.)
101 -copyright (Show copyright and license data.)
102
103 Can also set options via ZELLIJ_OPTIONS environment variable.
104
105 ->->-> Send email to [email protected] for zellij support.<-<-<-
106 ```
107 The only required option is `-lattice` followed by the name of the file containing the lattice description. The other options are used to specify compression of the output file; the format of the output file; or to request additional debug output.
108
109 If the `-output <filename>` option is not specified, then the output mesh will be named `zellij-out.e`.
110
111 ## Lattice Description File Format
112 The format of the lattice description file is fairly simple, but is also very rigid. There are two sections of the file -- the _unit cell_ dictionary and the _lattice_ definition.
113
114 ### Unit Cell Dictionary
115 The unit cell dictionary defines the unit cell template meshes that will be placed in the lattice. The dictionary begins with a line containing `BEGIN_DICTIONARY` followed by one or more lines defining the unit cells and is then ended with a line containing `END_DICTIONARY`
116
117 The syntax of the lines defining the unit cells consists of two fields -- an arbitrary _key_ and the filename containing the Exodus file defining the mesh for this unit cell. The only restriction on the _key_ is that it must be unique in the dictionary. The filenames must specify the path (either absolute or relative to the current execution directory) to the Exodus file; it can optionally be delimited by double quotes (`"`). The filenames do not need to be unique, but it is more efficient in both memory and time if each unit cell template mesh is unique.
118
119 As an example, here is a valid dictionary definition:
120
121 ```
122 BEGIN_DICTIONARY
123 0001 "../zellij-example/xatom-1b.e"
124 0002 "../zellij-example/xatom-Y.e"
125 0003 "../zellij-example/xatom-X.e"
126 0004 "../zellij-example/xatom-2b.e"
127 END_DICTIONARY
128 ```
129 The unit cell dictionary must appear before the lattice definition in the lattice description file.
130
131 If an error is detected during the parsing of the unit cell dictionary, the code will output an error message and terminate. Errors can be incorrect syntax, missing unit cell template meshes, duplicate keys, or problems reading the mesh description from a unit cell template mesh. The unit cell template mesh file is accessed and partially read at the time that zellij parses the corresponding unit cell dictionary line.
132
133 ### Lattice Definition
134
135 The lattice definition specifies the size of the lattice and the distribution of the unit cell(s) within that lattice. The lattice definition must follow the unit cell dictionary in the lattice description file.
136
137 The first line of the lattice definition begins with the line `BEGIN_LATTICE {i} {j} 1` where `{i}` and `{j}` specify the size of the `IxJ` arrangement of unit cells. For example, the line `BEGIN_LATTICE 5 5 1` would define a lattice containing 25 unit cell instances arranged in a 5 by 5 regular grid.
138
139 The last line of the lattice definition is the line `END_LATTICE`. When that line is encountered, zellij will begin outputting the mesh.
140
141 Between the `BEGIN_LATTICE` and `END_LATTICE` are `{j}` lines with `{i}` entries per line. The entries are any of the _key_s that were specified in the unit cell dictionary.
142
143 As an example, here is a valid lattice definition using the keys of the example dictionary from the previous section:
144
145 ```
146 BEGIN_LATTICE 5 5 1
147 0001 0002 0003 0002 0001
148 0002 0003 0003 0003 0002
149 0003 0003 0004 0003 0003
150 0002 0003 0003 0003 0002
151 0001 0002 0003 0002 0001
152 END_LATTICE
153 ```
154
155 Although the lattice is typically symmetric and square, this is not a requirement and is not checked.
156
157 If an error is detected during the parsing of the _lattice_, the code will output an error message and terminate. Errors can include invalid keys, incorrect number of lattice definition lines, or incorrect number of keys on a definition line.
158
159 Note that zellij does not require that the unit cell keys be numeric; the following example shows a different method for specifying the same lattice definition file as the previous example:
160
161 ```
162 BEGIN_DICTIONARY
163 - "../zellij-example/xatom-1b.e"
164 | "../zellij-example/xatom-Y.e"
165 + "../zellij-example/xatom-X.e"
166 * "../zellij-example/xatom-2b.e"
167 END_DICTIONARY
168
169 BEGIN_LATTICE 5 5 1
170 - | + | -
171 | + + + |
172 + + * + +
173 | + + + |
174 - | + | -
175 END_LATTICE
176 ```
177
178 ## Unit Cell Template Mesh Requirements
179 Zellij requires that the boundary mesh (`X` and `Y` faces) of each of the unit cell templates be a _regular_ "structured" mesh. Basically this means that the faces of the mesh elements on the boundary are in a regular rectangular grid such that each mesh face is rectangular (90 degree corners) and that the boundary mesh on the minimum `X` face is the same as that on the maximum `X` face and similarly for the minimum `Y` face and the maximum `Y` face.
180
181 Additionally, the X faces on _all_ unit cells must match and the Y faces on _all_
182 unit cells must match both in structure and in coordinate extent. This requirement is verified during execution. The `Z` faces are less constrained with the only requirement being that the coordinate extents of all `Z` faces must be the same (which follows from the `X` and `Y` face requirement); the structure of the mesh on the `Z` faces is arbitrary.
183
184 The unit cell meshes can contain any number of element blocks; however, each element block _must_ contain hexahedral elements with 8-nodes per element. The element blocks do not need to be the same in each unit cell mesh, but if they do share the same element block `id`, then those elements will be combined into the same element block in the output mesh with the same `id`.
185
186 The output mesh will contain the union of all element blocks existing on the input mesh unit cells. For example, if:
187
188 * unit cell `0001` has element blocks `1 10 100`
189 * unit cell `0002` has element blocks `2 20 200`
190 * unit cell `0003` has element blocks `1 2 10 20`
191 * unit cell `0004` has element blocks `10 20 100 200`
192
193 The output mesh will have element blocks `1 2 10 20 100 200`
194
195 ## Sideset Handling
196 By default, zellij will replicate any sidesets that are defined on the
197 input unit cell meshes to the output mesh file. The sidesets will
198 have the same names and ids as the sidesets on the input unit cell
199 meshes. If you do not want the sidesets replicated, you can add the
200 command line option `-ignore_sidesets` and any sidesets on the input
201 unit cell meshes will be ignored.
202
203 Zellij can also generate new sidesets on the boundaries of the output
204 mesh via the command line option `-generate_sidesets <axes>` where
205 `axes` is one or more letters specifying the face of the output mesh
206 on which to generate a sideset. Valid letters are `xyzXYZ` or
207 `ijkIJK` which correspond to:
208
209 * `x` or `i` for surface on minimum X coordinate (default name = `min_i`)
210 * `y` or `j` for surface on minimum Y coordinate (default name = `min_j`)
211 * `z` or `k` for surface on minimum Z coordinate (default name = `min_k`)
212 * `X` or `I` for surface on maximum X coordinate (default name = `max_i`)
213 * `Y` or `J` for surface on maximum Y coordinate (default name = `max_j`)
214 * `Z` or `K` for surface on maximum Z coordinate (default name = `max_k`)
215
216 For example `-generate_sidesets xyXY` would generate sideset on the
217 surfaces corresponding to the minimum and maximum X and Y coordinates
218 on the output mesh.
219
220 By default, the generated sidesets will be named as shown in the list
221 above. The names can be changed with the `-sideset_names <arg>`
222 command line option. The syntax of `<arg>` is
223 `axis:name,axis:name,...` where `axis` is one of `ijkIJK` or `xyzXYZ`
224 and `name` is the name of the specified sideset. For example,
225 `-sideset_names x:left,X:right` would name the sidesets on the
226 minimum x and maximum X faces `left` and `right` respectively. There
227 will be an error if two or more sidesets have the same name.
228
229 ## Parallel Execution
230 Zellij can produce a mesh decomposed into a file-per-rank for use in a
231 parallel analysis application. Note that Zellij itself is run
232 serially. The main option that tells Zellij to produce the decomposed
233 files is `-ranks <number_of_ranks>`. If this is specified, then
234 Zellij will create `number_of_ranks` individual files each containing
235 a portion of the complete model. The files will have the information
236 needed by a parallel application to read the data and set up the
237 correct communication paths and identify the nodes that are shared
238 across processor boundaries.
239
240 The decomposition method can also be specified. This determines the
241 algorithm that is used to break the lattice into `number_of_ranks`
242 pieces each with approximately the same computational complexity. The
243 decomposition methods are:
244
245 * `-rcb` Use recursive coordinate bisection method to decompose the input mesh in a parallel run.
246 * `-rib` Use recursive inertial bisection method to decompose the input mesh in a parallel run.
247 * `-hsfc` Use hilbert space-filling curve method to decompose the input mesh in a parallel run.
248 * `-linear` Use the linear method to decompose the input mesh in a parallel run. Elements in order first `n/p` to proc 0, next to proc 1.
249 * `-cyclic` Use the cyclic method to decompose the input mesh in a parallel run. Elements handed out to `id % proc_count`.
250 * `-random` Use the random method to decompose the input mesh in a parallel run. Elements are assigned randomly to processors in a way that preserves balance (do _not_ use for a real run))
251
252 The `-hsfc` method is the default if no other decomposition method is
253 specified. Note that the decomposition occurs at the _grid_ level so
254 the elements of each grid cell will not be split across multiple ranks. The grid
255 cells are weighted by the number of elements in the cell which should
256 produce a balanced decomposition if there are unit cells of varying
257 element counts.
258
259 The `-linear`, `-cyclic`, and `-random` methods are typically used for
260 debugging and testing Zellij and should not be used in a production
261 run, especially the `-random` method.
262
263 ### Partial Parallel Output Mode
264 There is a _partial parallel output_ mode in which you can tell Zellij to only output a portion of the parallel decomposed files. This is selected with the `-start_rank <rank>` and `-rank_count <count>` options. In this case, Zellij will only output the ranks from `rank` up to `rank+count-1`. For example, if you run `zellij -ranks 10 -start_rank 5 -rank_count 3`, then zellij would output files for ranks 5, 6, and 7. This is somewhat inefficient since zellij will do many of the calculations for all ranks and only output the specified ranks; however, it does allow you to run multiple copies of zellij simultaneously. For example, you could run:
265
266 ```
267 zellij -ranks 16 --start_rank 0 --rank_count 4
268 zellij -ranks 16 --start_rank 4 --rank_count 4
269 zellij -ranks 16 --start_rank 8 --rank_count 4
270 zellij -ranks 16 --start_rank 12 --rank_count 4
271 ```
272
273 simultaneously and all 16 files should be output faster than running a single execution that wrote all of the files.
274
275 ### Parallel Capable Parallel Execution
276
277 If Zellij is compiled with parallel capability enabled (This is shown at the beginning of the `-help` output or the version
278 information output when zellij begins executing as `Parallel Capability Enabled`), then you can run Zellij in parallel using the
279 normal `mpiexec -np <#> zellij <normal zellij options>` command. In this case, there will be `#` copies of zellij running
280 simultaneously and each copy will divide up the output files and work among each process/copy.
281
282 For example, if you run `mpiexec -np 8 zellij -ranks 1024 -latice lattice.txt`, then there will be 8 copies of zellij running
283 and each will output `1024/8 = 128` output files.
284
285 ### Maximum Open File Complications
286
287 Most compute systems have a limit on the number of files that a program can have open simultaneously. For many systems, this
288 limit is 1024. The files that zellij deals with are (1) the unit cell meshes and (2) the per-rank output files, and (3) the
289 standard input, output, and error files. Because of this, it is somewhat easy for a zellij execution to exceed the open file
290 limit. Zellij attempts to handle this automatically using logic similar to:
291
292 * If the unit cell count exceeds the open file limit, then close each unit cell after each access before opening the next unit
293 cell mesh.
294
295 * If the number of `-ranks` that zellij is creating exceeds the open file count, then determine how many output files can be
296 open at one time (max_open = open file limit - 3 - number of unit cells open simultaneously) and run zellij in a `subcycle` mode
297 where it is only writing to `max_open` files at one time.
298
299 * If the `max_open` calculated in the above bullet is too small, then set the mode to only open a single unit cell mesh at a
300 time and redo the calculation.
301
302 * If all else fails, run with only a single unit cell file open and only a single output mesh rank file open.
303
304 If the above logic fails and Zellij is unable to run without exceeding the open file count, you can specify the behavior
305 manually using a combination of the `-minimize_open_files=<UNIT|OUTPUT|ALL>` option and the `-subcycle` and `-rank_count <#>`
306 options.
307
308 The options to `-minimize_open_files` are:
309
310 * `UNIT` - only have a single unit cell mesh open at one time; close before accessing another unit cell mesh.
311 * `OUTPUT` - only have a single output rank mesh file open at one time.
312 * `ALL` - both of the above options.
313
314 The `-subcycle` and `-rank_count <#>` options cause zellij to output `#` output files at a time and then cycle to the next `#`
315 output files until all files have been output. For example, `zellij -ranks 1024 -subcycle -rank_count 256` would do the
316 following:
317
318 * First cycle would output ranks 0 to 255,
319 * Second cycle would output ranks 256 to 511,
320 * Third cycle would output ranks 512 to 767,
321 * Fourth cycle would output ranks 768 to 1023.
322
323 In this mode, there will the `#` output files open simultaneously (unless
324 `-minimize_open_files=OUTPUT|ALL` was specified also). So the total number of open files will be `unit cell count + 3 + #` or
325 `1 + 3 + #` if `-minimize_open_files=UNIT` was specified.
326
327 ## Execution Complexity
328
329 Zellij is intended to produce extremely large meshes and is therefore very concerned with both memory efficiency and execution
330 time efficiency.
331
332 ### Memory Complexity
333
334 Zellij stores the following data:
335
336 * For each unit cell template mesh:
337 * metadata
338 * 64-bit Ids of nodes on each min_I, max_I, min_J, max_J face
339 * For each entry in the lattice definition:
340 * metadata (approximately 1KiByte)
341 * temporarily it will hold 64-bit Ids of nodes on the max_I and max_J faces. This will be deleted once the upper `I` and upper `J` "neighbor" entry has been processed (see below)
342 * For the lattice:
343 * vector containing the lattice definition.
344
345 The main memory use once the output file is being processed is the temporary storage containing the nodes on the `max_I` and `max_J` faces. The lattice is processed cell by cell. For an `II by JJ` sized grid, the cells are processed in the order `(1,1), (2,1), ... , (II, 1), (1,2), (2,2), ..., (II, JJ)`. The temporary storage on the `max_I` face is only needed until the next cell is processed. That is, for cell `(i,j)`, its `max_I` nodes will be used during the processing of cell `(i+1, j)` and then deleted.
346
347 The temporary storage on the `max_J` face is retained for a longer time. For cell `(i,j)`, the `max_J` storage is needed for cell `(i, j+1)` and then deleted.
348
349 For a grid of size `(II, JJ)`, there will at most be:
350
351 * 1 temporary vector of size `max_I` nodes
352 * `II` temporary vectors of size `max_J` nodes.
353
354 If you have a lattice that is rectangular (`II != JJ`), then it is more efficient for memory usage to make the `I` direction the smallest value if possible.
355
356 In addition to the above memory usage, zellij must also transfer the mesh coordinate data and element block connectivity data for each lattice entry to the output file. Zellij outputs the model using the following pseudo-code:
357
358 ```
359 for each j : J
360 for each i : I
361 read cell(i,j) x, y, and z local coordinates
362 map coordinates to offset in output mesh
363 eliminate nodes that join to an already output neighbor cell
364 write cell(i,j) x, y, and z global coordinates
365
366 for each j : J
367 for each i : I
368 for each element block in cell(i,j) mesh
369 read block connectivity
370 map local node ids to global node ids
371 write block connectivity
372 ```
373
374 The maximum memory use will be the size of storage needed for the `x` `y` and `z` coordinates of a unit cell mesh or the storage needed to hold the connectivity for a single unit cell element block.
375
376 Note that the memory requirements are proportional to the size of an individual unit cell mesh and not a function of the size of the output mesh. It is possible to create meshes which are much larger than the amount of memory present on the compute system running zellij.
377
378 The memory being used by zellij during execution will be output if the `--debug 2` argument is specified at execution time.
379
380 ### Execution Time Complexity
381
382 For a large model, the majority of the execution time is related to:
383
384 * Read/process/write element block connectivity
385 * Read/process/write nodal coordinates
386 * Categorize boundary nodes on each unit cell mesh
387
388 ### Efficiency at the NetCDF level
389 The Exodus format which is used for the unit cell template meshes and the output mesh uses the NetCDF library for on-disk storage. There are several variants of the NetCDF on-disk storage including the format: `netcdf3`, `netcdf4`, and `netcdf5` and the integer size (32-bit integers or 64-bit integers). Although these details are usually transparent to the user, they can affect the execution time especially when very large meshes are being processed.
390
391 #### Format
392 The `netcdf3` format is the original native NetCDF format. At the time the library was being developed, the `byte endianness` of data stored on disk was not standard among the computes in use at that time and the NetCDF developers had to pick an `endianness` for the data. They picked the XDR standard which stood for _eXternal Data Representation_ which was used for communicating between different computer systems. Regretfully, the representation used by XDR turned out to be opposite of the representation used by (almost?) all systems in use today, so each read and write of data in the `netcdf3` format results in a translation of the endianness. This translation is very fast, but is overhead that would not be needed if the on-disk format was the opposite representation. This representation is also used by the `netcdf5` format.
393
394 However, the NetCDF `netcdf4` format is based on using the HDF5 library to manage the underlying data format on disk and it can read and write data using the native endianness of the system on which the data is being read and written and therefore does not incur the cost of transforming the data's endianness.
395
396 #### Integer Size
397 By default, most current mesh generators will output a mesh using 32-bit integer data. This is sufficient to represent a mesh with up to approximately 2.1 billion nodes and elements.
398
399 If the input mesh and the output mesh have the same integer size, then there is no data conversion needed. The data will be read as `N`-bit integers, processed as `N`-bit integers, and written as `N`-bit integers. However, if the input mesh is `N`-bit integers and the output mesh is `M`-bit integers, then the NetCDF library will convert all integer data (element block connectivity typically) from `N` bits to `M` bits which for large meshes can incur an execution time overhead.
400
401 #### Compression
402 The NetCDF library supports compression of the output file. Typically, the `zlib` compression algorithm is used, but recently NetCDF begain supporting the `szip` compression and a few more algorithms are starting to be supported.
403
404 The benefit of the compression is that it can result in much smaller output (and input) mesh files; the disadvantage is that the default `zlib` compression algorithm is not very fast and can increase the execution time of zellij. The `szip` compression algorithm is faster with typically (but not always) slightly less compression, but it still will incur an overhead in execution time.
405
406 #### Recommendations
407 For minimal overhead, it is recommended that:
408
409 * Use the `netcdf4` format for all input and output meshes
410 * Use the same integer size for all input and output meshes
411 * The integer size of the output mesh can be specified using the `-32` or `-64` options.
412 * The `-64` option is the default.
413
414 It is most efficient if the format and integer size of the input mesh matches the output mesh. The format of the input meshes can be converted using the `io_shell` application with the `-netcdf4` and `-64` or `-32` options. The format and integer size of a mesh can be queried using the `exo_format` application.
415
416 For illustration, here is the execution time for several runs with different format and integer size. In all cases, the input and output mesh sizes are the same:
417
418 | input | output | integer input | integer output | execution time |
419 |:-------:|:-------:|:-------------:|:--------------:|:--------------:|
420 | netcdf3 | netcdf3 | 32 | 32 | 7.0 |
421 | netcdf3 | netcdf4 | 32 | 32 | 2.6 |
422 | netcdf3 | netcdf4 | 32 | 64 | 3.8 |
423 | netcdf4 | netcdf3 | 32 | 32 | 6.5 |
424 | netcdf4 | netcdf3 | 64 | 32 | 7.4 |
425 | netcdf4 | netcdf5 | 64 | 64 | 9.4 |
426 | netcdf4 | netcdf4 | 32 | 32 | 2.4 |
427 | netcdf4 | netcdf4 | 32 | 64 | 3.6 |
428 | netcdf4 | netcdf4 | 64 | 32 | 3.2 |
429 | netcdf4 | netcdf4 | 64 | 64 | 3.3 |
430
431 The fastest option is both input and output using 32-bit integers and the `netcdf4` format. Almost as fast is the case where the input format is `netcdf3` and the output `netcdf4`. The `64-bit` integer options with both input and output using `netcdf4` are slightly slower, but this is probably due to the doubling of the size of the integer data being read and written.
432
433 The output mesh in this case consisted of 37.3 million elements and 38.5 million nodes in a grid of 46 x 46 unit cells. There were 56 unit cell template meshes.