10.2. EnSight Gold Casefile Format

10.2.1. EnSight Gold General Description

EnSight Gold data consists of the following files:

Case (required) (points to all other needed files including model geometry, variables, and possibly measured geometry and variables - as well as optionally a periodic match file, a structured boundary file, and a rigid body file).

EnSight makes no assumptions regarding the physical significance of the scalar, vector, 2nd order symmetric tensor, and complex variables. These files can be from any discipline. For example, the scalar file can include such things as pressure, temperature, and stress. The vector file can be velocity, displacement, or any other vector data, etc.

In addition, EnSight Gold format handles "undefined" as well as "partial" variable values. (See appropriate subsections later in this chapter for details).

All variable results for EnSight Gold format are contained in disk files - one variable per file. Additionally, if there are multiple time steps, there must either be a set of disk files for each time step (transient multiple-file format), or all time steps of a particular variable or geometry in one disk file each (transient single-file format).

Sources of EnSight Gold format data include the following:

Data that can be translated to conform to the EnSight Gold data format (including being written from EnSight itself using the Save Geometric Entities option under File → Save).
Data that originates from one of the translators supplied with the EnSight application

The EnSight Gold format supports an unstructured defined element set as shown in the figure on a following page. Unstructured data must be defined in this element set. Elements that do not conform to this set must either be subdivided or discarded.

The EnSight Gold format also supports the same structured block data format as EnSight6, which is very similar to the PLOT3D format.

Note: The standard order of nodes, for this format, is such that I's advance quickest, followed by J's, and then K's.

A given EnSight Gold model may have either unstructured data, structured data, or a mixture of both.

This format is somewhat similar to the EnSight6 format, but differs enough to allow for more efficient reading of the data. It is intended for 3D, binary, big data models.

Note: While an ASCII format is available, it is not intended for use with large models and is in fact subject to limitations such as integer lengths of 10 digits. Use the binary format if your model will exceed 10 digits for node or element numbers or labels.

Starting with version 7, EnSight writes out all model and variable files in EnSight Gold format. Therefore, it can be read by all subsequent EnSight licenses: standard, Enterprise (formerly Gold or HPC), and custom licenses.

10.2.2. ens_checker

A program is supplied with EnSight which attempts to verify the integrity of the format of EnSight 6 and EnSight Gold files. If you are producing EnSight formatted data, this program can be very helpful, especially in your development stage, in making sure that you are adhering to the published format. It makes no attempt to verify the validity of floating point values, such as coordinates, variable values, etc. This program takes a casefile as input. Thus, it will check the format of the casefile, and all associated geometry and variable files referenced in the casefile. See Use ens_checker.

10.2.3. Turbomachinery Initialization File Format

The Turbomachinery initialization file format is designed to store the settings for initializing a turbomachinery model. The file is based on the XML format.

The following tags are used to store information related to the entire dataset:

ENS_TURBO_ORIGIN: Three comma separated floats that represent the model origin in X, Y, Z coordinate space.
ENS_TURBO_AXIS: Three comma separated floats that reflect the axis of symmetry in X,Y,Z coordinate space.
ENS_COMPONENT_ORDER: String that contains the component names in order upstream to downstream. The component names are comma separated, with no spaces.

After these initial model specific tags, a section called partlist contains the details of the turbomachinery initialization for each part. The parts are marked by their part name via the tag name. For each part, the following tags are expected:

ENS_TURBO_STAGE: String composed of two comma separated elements. The name of the component the part belongs to, and its turbomachinery type in capitals. Possible turbomachinery types are: FLUID, INLET, OUTLET, HUB, SHROUD. If a part happens to be a turbomachinery part for two or more components, the strings for each component will be put together via a ; delimiter. For example, if a part is the OUTLET for component R1 and it is also the INLET for component S2, then its corresponding string will be ENS_TURBO_STAGE is: ‘R1,OUTLET;S2,INLET’.
ENS_SYMMETRY_COUNT: Integer that corresponds Number of instances on 360. The special value -1 marks that the model is a full 360 degrees model.

When restoring a .trb file for a Turbomachinery initialization, should EnSight not find a part whose name matches the partname in the file, that particular section of the file will simply be skipped.

Here is an example of a Turbomachinery initialization file for a model with two components: R1 and S1, origin corresponding to (0, 0, 0) and z axis as the rotation axis:

<TurboMachinery version="1.0">
<case>
<origin originpoint="ENS_TURBO_ORIGIN">
0.000000, 0.000000, 0.000000</origin>
<origin originpoint="ENS_TURBO_AXIS">
0.0,0.0,1.0</origin>
<origin originpoint="ENS_COMPONENT_ORDER">
R1,S1,</origin>
<parts partlist="">
<partname name="Passage Main 2">
<turbo turboinfo="ENS_TURBO_STAGE">
R1,FLUID</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
11</turbo>
</partname>
<partname name="Passage Main">
<turbo turboinfo="ENS_TURBO_STAGE">
S1,FLUID</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
15</turbo>
</partname>
<partname name="R1 Hub">
<turbo turboinfo="ENS_TURBO_STAGE">
R1,HUB</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
11</turbo>
</partname>
<partname name="R1 Shroud">
<turbo turboinfo="ENS_TURBO_STAGE">
R1,SHROUD</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
11</turbo>
</partname>
<partname name="R1 to S1 Side 1">
<turbo turboinfo="ENS_TURBO_STAGE">
R1,INLET</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
11</turbo>
</partname>
<partname name="S2 to R1 Side 2">
<turbo turboinfo="ENS_TURBO_STAGE">
R1,OUTLET</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
11</turbo>
</partname>
<partname name="R1 to S1 Side 2">
<turbo turboinfo="ENS_TURBO_STAGE">
S1,OUTLET</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
15</turbo>
</partname>
<partname name="S1 Hub">
<turbo turboinfo="ENS_TURBO_STAGE">
S1,HUB</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
15</turbo>
</partname>
<partname name="S1 Inlet">
<turbo turboinfo="ENS_TURBO_STAGE">
S1,INLET</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
15</turbo>
</partname>
<partname name="S1 Shroud">
<turbo turboinfo="ENS_TURBO_STAGE">
S1,SHROUD</turbo>
<turbo turboinfo="ENS_SYMMETRY_COUNT">
15</turbo>
</partname>
</parts>
</case>
</TurboMachinery>

10.2.4. Supported EnSight Gold Elements

The elements that are supported by the EnSight Gold format are:

Figure 10.1: Supported EnSight Gold Elements

10.2.5. EnSight Gold Case File Format

The Case file is an ASCII free format file that contains all the file and name information for accessing model (and measured) geometry, variable, and time information. It is comprised of five sections (FORMAT, GEOMETRY, VARIABLE, TIME, FILE) as described below:

Note: If the case file name contains spaces it should load fine in the browser, but from the command line it must be in quotes (for example, ensight -case "file name.case") or on linux or mac can also use the backslash character ("\") as follows: ensight -case file\ name.case).

All lines in the Case file are limited to 1024.

The titles of each section must be in all capital letters.

Anything preceded by a # denotes a comment and is ignored. Comments may append information lines or be placed on their own lines.

Information following ":" may be separated by white spaces or tabs.

Specifications encased in "[ ]" are optional, as indicated.

10.2.5.1. Format Section

This is a required section which specifies the type of data to be read.

Usage:

FORMAT 
type: ensight gold

10.2.5.2. Geometry Section

This is a required section which specifies the geometry information for the model (as well as measured geometry if present, periodic match file Periodic Matchfile Format if present, boundary file (see EnSight Boundary File Format) if present, rigid body file (see EnSight Rigid Body File Format) if present, and vector glyphs file (see Vector Glyph File Format) if present).

Usage

GEOMETRY 
 model:       [ts]       [fs]       filename       [change_coords_only [cstep]] 
                OR                            
 model:       [ts]       [fs]       filename       [changing_geometry_per_part] 
 measured:    [ts]       [fs]       filename       [change_coords_only] 
 match:                             filename       [add_ghosts] 
 boundary:                          filename 
 rigid_body:                        filename       [do_first] 
 Vector_glyphs:                     filename

where: ts = time set number as specified in TIME section. This is optional.

fs = corresponding file set number as specified in FILE section below.

Note: If you specify fs, then ts is no longer optional and must also be specified.

filename = The filename of the appropriate file.

→ Model or measured filenames for a static geometry case (or single file format), as well as match, boundary, and rigid_body filenames will not contain "*" wildcards.

→ Model or measured filenames for a changing geometry case (unless single file format) will contain "*" wildcards where each * represents one integer with a maximum of 10 of the "*" wildcards per filename.

Model filenames with for the structured block continuation option will contain "%" wildcards.

→ filenames with spaces in them need to be enclosed in quotes.

change_coords_only = The option to indicate that the changing geometry (as indicated by wildcards in the filename) is coords only. Otherwise, changing geometry connectivity will be assumed.

cstep = the zero-based time step which contains the connectivity - only used for change_coords_only option. This is an optional parameter. If all time steps have the connectivity, then this is not needed and can be omitted. But if used, the other time steps do not need to contain the connectivity - the parts need only contain the coordinates, which can save considerably on file size.

changing_geometry_per_part = Signals the reader that the part lines in the geometry files will have a manditory additional option The valid options are:

part no_change

part coord_change

part conn_change

add_ghosts = EnSight Case Gold allows the optional [add_ghosts] parameter after the filename which will produce ghost cells across the match file boundary which will provide continuity for variable calculations across the boundary, and for computational symmetry/mirroring, etc. Only use the add_ghosts option if you can afford the penalty of the additional ghost cells and you need the computational continuity that they provide.

do_first = If both periodic and rigid body data are present then the default is to do periodic first then to do rigid body transforms. The do_first, does rigid body transforms first, then periodic afterward.

Note: It is possible to use EnSight 5 measured data with a casefile. This is done by using the Measured: line in the GEOMETRY section without any of the optional portions, and with filename being an EnSight 5 measured results file (which typically has a .mea extension). Also, since such information is contained in the .mea file, do not use any measured variable lines in the VARIABLE section.

10.2.5.3. Variable Section

This is an optional section which specifies the files and names of the variables (for maximum number of variables, see EnSight Maximums ). Per_Case and Per_Part Constant variable values can also be set in this section.

Usage:

VARIABLE
constant per case:           [ts]      name const_value(s) 
constant per case file:      [ts]      name cv_filename
constant per part:           [ts]      name cpp_filename [cpp_index_filename]
scalar per node:             [ts] [fs] name filename
vector per node:             [ts] [fs] name filename
tensor symm per node:        [ts] [fs] name filename 
tensor asym per node:        [ts] [fs] name filename 
scalar per element:          [ts] [fs] name filename 
vector per element:          [ts] [fs] name filename 
tensor symm per element:     [ts] [fs] name filename 
tensor asym per element:     [ts] [fs] name filename 
scalar per measured node:    [ts] [fs] name filename 
vector per measured node:    [ts] [fs] name filename
complex scalar per node:     [ts] [fs] name Re_fn Im_fn freq 
complex vector per node:     [ts] [fs] name Re_fn Im_fn freq
complex scalar per element:  [ts] [fs] name Re_fn Im_fn freq 
complex vector per element:  [ts] [fs] name Re_fn Im_fn freq

where: ts = The corresponding time set number (or index) as specified in the TIME section below, Time Section. This is only required for transient constants and variables.

fs = The corresponding file set number (or index) as specified in the FILE section below, File Section.

Note: If you specify fs, then ts is no longer optional and must also be specified.

name = The variable (GUI) name (ex. Pressure, Velocity, etc.) If the variable name contains a space, it must be in quotes, and will be renamed in EnSight, replacing the spaces with an underscore.

const_value(s = The constant value. If constants change over time, then ns (see TIME section below, Time Section) constant values of ts.

cv_filename = The filename containing the per_case constant values, one value per time step.

cpp_filename = The filename containing the per_part constant values.

cpp_index_filename = The filename containing the offset indexes in the referenced cpp_filename.

filename = The filename of the variable file.

Note: Only transient filenames contain "*" wildcards where each * represents one integer with a maximum of 10 of the "*" wildcards per filename. If the filename contains a space, it must be in quotes.

Re_fn = The filename for the file containing the real values of the complex variable.

Im_fn = The filename for the file containing the imaginary values of the complex variable.

freq = The corresponding harmonic frequency of the complex variable. For complex variables where harmonic frequency is undefined, simply use the text string: UNDEFINED.

Note: As many variable description lines as needed may be used.

Variable descriptions have the following restrictions:

The maximum variable name length is documented at the beginning of this chapter.
Duplicate variable descriptions are not allowed.
Leading and trailing white space will be eliminated.
Variable descriptions must not start with a numeric digit.
Variable descriptions must not contain any of the following reserved:
' '
'!'
'@'
'#'
'$'
'^'
'('
')'
'['
']'
'*'
'/'
'+'
'-'
','
'.'
''
'\\'
'\''
'"'
'<'
'>'
'?'
'|'

Scalar or vector per measured node is necessary for EnSight Gold or EnSight 6 measured format data. For EnSight 5 format measured data, only the results file (typically suffix .mea) is necessary in the geometry section because the EnSight 5 results file describes the geometry and variable files.

10.2.5.4. Time Section

This is an optional section for steady state cases, but is required for transient cases. It contains time set information. Shown below is information for one time set. Multiple time sets (up to 16) may be specified for measured data as shown in Example 10.3: Case File Example 3. Time values can be one per line, all on one line, or any combination of values per line (with a maximum limitation of 1024 per line).

Usage:

TIME
[maximum time steps:   tm]
time set:              ts  [description]
number of steps:       ns 
filename start number: fs 
filename increment:    fi
time values:           time_1  time_2  .... time_ns
or
TIME
[maximum time steps:   tm]
time set:            ts  [description]
number of steps:     ns
filename numbers:    fn
time values:         time_1  time_2  .... time_ns
or
TIME
[maximum time steps:   tm]
time set:            ts  [description]
number of steps:     ns 
filename numbers file: fnfilename 
time values file:    tvfilename

where: tm = optional integer value, used only if the number of timesteps is to be increasing over time. This keyword and value represents the never-to-exceed, maximum number of timesteps (see the Advanced section of Load Transient Data ).

ts = timeset number. This is the number referenced in the GEOMETRY and VARIABLE sections.

description = optional timeset description which will be shown in user interface.

ns = number of transient steps

fs = the number to replace the "*" wildcards in the filenames, for the first step

fi = the increment to fs for subsequent steps

fn = a list of numbers or indices, to replace the "*" wildcards in the filenames.

fnfilename = name of file containing ns filename numbers (fn).

tvfilename = name of file containing the time values (time_1 ... time_ns free format one to a line or on multiple lines).

time values = one time value for each timestep in free format on one or multiple lines (with a maximum limit of 1024 per line).

10.2.5.5. File Section

This section is optional for expressing a transient case with single-file formats. This section contains single-file set information. This information specifies the number of time steps in each file of each data entity, i.e. each geometry and each variable (model and/or measured). Each data entity's corresponding file set might have multiple continuation files due to system file size limit, i.e. ~2 GB for -bit and ~4 TB for 64-bit architectures. Each file set corresponds to one and only one time set, but a time set may be referenced by many file sets. The following information may be specified in each file set. For file sets where all of the time set data exceeds the maximum file size limit of the system, both filename index and number of steps are repeated within the file set definition for each continuation file required. Otherwise filename index may be omitted if there is only one file. File set information is shown in Example 10.5: Case File Example 5.

Usage:

FILE
file set: fs
filename index: fi # Note: only used when data continues in other files
number of steps: ns

where: fs = file set number. This is the number referenced in the GEOMETRY and VARIABLE sections above.

ns = number of transient steps

fi = file index number in the file name (replaces "*" in the filenames)

10.2.5.6. Material Section

This is an optional section for material set information in the material interface part case. For more details see the description in the Material Interface Parts Feature Panel, or the MatSpecies calculator function in 4.3. Shown below is the format for one material set. (Note, currently only one material set is supported.) An example of this material set information is appended below as EnSight Gold Material Files Format.

Usage:

MATERIAL
material set number:         ms [description]
material id count:           nm
material id numbers:         matno_1  matno_2  ... matno_nm 
material id names:           matdesc_1 mat_2 ... mat_nm
# Either sparse file specifications:
material id per element      [ts] [fs] filename 
material mixed ids:          [ts] [fs] filename 
material mixed values:       [ts] [fs] filename
# optional species parameters with sparse file specifications only
species id count:ns
species id numbers:           spno_1 spno_2 … spno_ns
species id names:             spdesc_1 spdesc_2 … spdesc_ns 
species per material counts:  spm_1 spm_2… spm_nm
species per material lists:   matno_1_sp_1 matno_1_sp_2 … matno_1_sp_spm_1
                              matno_2_sp_1 matno_2_sp_2 … matno_2_sp_spm_2
                              …            
                              matno_nm_sp_1 matno_nm_sp2 … matno_nm_sp_spm_nm 
                              (Note: above concatenated lists do not have to be on 
                               separate lines.)
species element values:       [ts] [fs] sp_filename

# Or materials defined by per element scalar variables:

material scalars per element: desc_esv_1 desc_esv_2 ... desc_esv_nm

where:

ts = The corresponding time set number (or index) as specified in TIME section above. This is only required for transient materials.

fs = The corresponding file set number (or index) as specified in FILE section above. (Note, if you specify fs, then ts is no longer optional and must also be specified.

ms = Material set number. (Note, currently there is only one, and it must be a positive number.)

description = Optional material set description which will be reflected in the file names of exported material files.

nm = Number of materials for this set.

matno = Material number used in the material and mixed-material id files. There should be nm of these. Non-positive numbers are grouped as the "null material". See EnSight Gold Material Files Format

matdesc = GUI material description corresponding to the nm matno's.

filename = The filename of the appropriate material file.

Note: Only transient filenames contain "*" wildcards with a maximum of 10 * wildcard. The three required files are the material id per element, the mixed-material ids, and the mixed-material values files.

ns = Number of species for this set.

spno = Specie number used in the species per material lists: specification. There should be ns of these positive integers.

spdesc = GUI specie description corresponding to the ns spno's.

spm = Number of species per material number (matno). Enter 0 if no species exist for a material.

matno_#_sp = Specie id number (spno) list member for this material number id (matno). If no species for this material, then proceed to next material that has species.

sp_filename = The filename of the appropriate species element values: file. Note, only transient filenames contain "*" wildcards.

desc_esv = The description of each per element scalar variable to be a material. The description listed must match the description listed under the VARIABLE section for the per element scalar variable.

Note: Material and species descriptions are limited to 19 in the current release. Material and species descriptions and file names must not start with a numeric digit and must not contain any of the following reserved:

( [ + @ ! * $

) ] - # ^ / space

10.2.5.7. Block Continuation

This section is optional for grouping partitioned structured blocks together. The files containing blocks must conform to some restrictions in order for this to be possible. Namely, the blocks in the files must be a continuation (in one of the directions) from the blocks in the previous file. This purpose for this capability is to be able to read N number of files using M number of cluster nodes, where N > M. The filenames for the geometry and variables must contain “%” wildcards if this option is used.

Usage:

BLOCK_CONTINUATION

number of sets: ns

filename start number:fs

filename increment: fi

where:

ns = The number of contiguous partitioned structured files to use

fs = the number to replace the “%” wildcards in the geometry and variable filenames, for the first set

fi = the increment to fs for subsequent sets

Note: Block Continuation cannot be used simultaneously with Multiple Case Files.

10.2.5.8. Scripts Section

This is an optional section which specifies the name of a Python script file or an XML metadata file. The Python file is read when the dataset is loaded. The script file contents are transferred to the client where they are executed in the running client Python interpreter. The geometry pathname will be prepended to the Python script filename before it is read if a fully qualified pathname is not provided.

The XML metadata file is used internal to EnSight, for example, to assign material to the parts, or units to the variables or to put parts into folders in the part list, etc.

Usage:

SCRIPTS

python: filename.py

metadata: filename.xml

Note: An example showing the usage of the XML file is included with your EnSight install in the directory shown below. To take advantage of this XML data, simply set the environmental variable as follows and load the case file in this directory. Setting this environmental variable will extensively customize your EnSight user interface, in addition to making units available. Color by a variable to see the units appear in the legend, and right-click a column header, such as Name, in the variables window to Customize... the columns and show Units (see below).

set ENSIGHT_ANSYS_VERSION=24.2

cd $CEI/ensight242/other_data/ensight/guard_rail_xml/

10.2.5.9. Query Section

This is an optional section which specifies query data filenames(s) each containing xy data saved to the XY Plot Data Format using right-click on query(ies) (see Right Mouse Button Actions)) or using the command language curve: save xy_data filename. Each of the filename(s) must be located in the same directory as the case file (you cannot use any path to point to the query data file(s)).

Note: The server passes the filename(s) up to the client where the EnSight formatted XY data file(s) are read into EnSight queries. The client must have access to the location of this file.

Also, the EnSight XY format contains a query that does not dynamically update in time, that is, you cannot save a query along a line in a transient dataset and expect to replicate the dynamically updating line query from a EnSight XY data file.

Usage:

QUERY 
xy_data: filename.exy 
xy_data: filename2.exy 
etc.

Example 10.1: Case File Example 1

The following is a minimal EnSight Gold case file for a steady state model with some results.

Note: This (engold.case) file, as well as all of its referenced geometry and variable files (along with a couple of command files) can be found under your installation directory (path: $CEI/ensight242/data/user_manual). The EnSight Gold Geometry File Example and the Variable File Examples are the contents of these files.

FORMAT 
type: ensight gold 
GEOMETRY 
model: engold.geo 
VARIABLE 
constant per case:             Cden .8 
scalar per element:            Esca engold.Esca 
scalar per node:               Nsca engold.Nsca 
vector per element:            Evec engold.Evec 
vector per node:               Nvec engold.Nvec 
tensor symm per element:       Eten engold.Eten 
tensor symm per node:          Nten engold.Nten 
complex scalar per element:    Ecmp engold.Ecmp_r engold.Ecmp_i 2.
complex scalar per node:       Ncmp engold.Ncmp_r engold.Ncmp_i 4.

Example 10.2: Case File Example 2

The following is a Case file for a transient model. The connectivity of the geometry is also changing.

Note: There are a maximum of 10 of the * wildcard per filename. And there is a single EnSight XY query file. It is not currently possible to save and restore transient query files (my_query**.exy is not currently supported).

FORMAT
type: ensight gold

GEOMETRY
model:                 1                     exgold2.geo**

VARIABLE
scalar per node:       1     Stress          exgold2.scl**
vector per node:       1     Displacement    exgold2.dis**

TIME
time set: 1
number of steps: 3
filename start number: 0
filename increment: 1
time values: 1.0 2.0 3.0
QUERY
xy_data: my_query.exy

The following files would be needed for Example 2:

exgold2.geo00         exgold2.scl00       exgold2.dis00               
exgold2.geo01         exgold2.scl01       exgold2.dis01
exgold2.geo02         exgold2.scl02       exgold2.dis02
query.exy

Example 10.3: Case File Example 3

The following is a Case file for a transient model with measured data.

Note: There are a maximum of 10 wildcard "*" per filename.

This example has pressure given per element.

FORMAT
type:  ensight gold


GEOMETRY
model:               1              exgold3.geo*
measured:            2              exgold3.mgeo**


VARIABLE
constant per case:                     Gamma      1.4
constant per case:                1    Density    .9 .9 .7 .6 .6
scalar per element                1    Pressure         exgold3.pre*
vector per node:                  1    Velocity         exgold3.vel* 
scalar per measured node:         2    Temperature      exgold3.mtem** 
vector per measured node:         2    Velocity         exgold3.mvel**

TIME
time set:                  1
number of steps:           5
filename start number:     1
filename increment:        2
time values:               .1 .2 .3         # This example shows that time            
                           .4 .5            # values can be on multiple lines
time set:                  2
number of steps:           6
filename start number:     0
filename increment:        2
time values:
.05 .15 .25 .34 .45 .55

The following files would be needed for Example 3:

exgold3.geo1     exgold3.pre1     exgold3.vel1
exgold3.geo3     exgold3.pre3     exgold3.vel3
exgold3.geo5     exgold3.pre5     exgold3.vel5
exgold3.geo7     exgold3.pre7     exgold3.vel7
exgold3.geo9     exgold3.pre9     exgold3.vel9

exgold3.mgeo00   exgold3.mtem00   exgold3.mvel00
exgold3.mgeo02   exgold3.mtem02   exgold3.mvel02
exgold3.mgeo04   exgold3.mtem04   exgold3.mvel04
exgold3.mgeo06   exgold3.mtem06   exgold3.mvel06
exgold3.mgeo08   exgold3.mtem08   exgold3.mvel08
exgold3.mgeo10   exgold3.mtem10   exgold3.mvel10

Example 10.4: Case File Example 4

The following is two Case files for a simple static Block Continuation structured model containing 5 files (sets). The first uses the first two sets, the second uses the last three sets.

FORMAT
type:  ensight gold
GEOMETRY
model:                                            ex_bc_%.geo
VARIABLE
scalar per node:               temperature        ex_bc_%.scl
BLOCK_CONTINUATION
number of sets:                2
filename start number:         1
filename increment:            1
---------------------------------------------------
FORMAT
type:  ensight gold
GEOMETRY
model:                                            ex_bc_%.geo
VARIABLE
scalar per node:               temperature        ex_bc_%.scl
BLOCK_CONTINUATION
number of sets:                3
filename start number:         3
filename increment:            1

The following files would be needed for Example 4:

ex_bc_1.geo           ex_bc_1.scl      used by first case
ex_bc_2.geo           ex_bc_2.scl      used by first case
ex_bc_3.geo           ex_bc_3.scl      used by second case
ex_bc_4.geo           ex_bc_4.scl      used by second case
ex_bc_5.geo           ex_bc_5.scl      used by second case

Example 10.5: Case File Example 5

The following is Case File Example 3 expressed in transient single-file formats.

In this example, the transient data for the measured velocity data entity happens to be greater than the maximum file size limit. Therefore, the first four time steps fit and are contained in the first file, and the last two time steps are continued in a second file.

FORMAT
type: ensight gold

GEOMETRY
model:                1    1    exgold5.geo
measured:             2    2    exgold5.mgeo

VARIABLE
constant per case:                     Density          .5
scalar per element:          1    1    Pressure         exgold5.pre 
vector per node:             1    1    Velocity         exgold5.vel 
scalar per measured node:    2    2    Temperature      exgold5.mtem 
vector per measured node:    2    3    Velocity         exgold5.mvel*

TIME
time set:             1    Model
number of steps:      5
time values:          .1 .2 .3 .4 .5
time set:             2    Measured
number of steps:      6
time values:          .05 .15 .25 .34 .45 .55
FILE
file set:             1
number of steps:      5
file set:             2
number of steps:      6
file set:             3
filename index:       1
number of steps:      4
filename index:       2
number of steps:      2

The following files would be needed for Example 4:

exgold5.geo    exgold5.pre    exgold5.vel
exgold5.mgeo   exgold5.mtem   exgold5.mvel1    
                              exgold5.mvel2

Example 10.6: Case File Example 6

The following is a Case file for a transient model. The connectivity of the geometry is not changing, but the coordinates are. The connectivity is only present in step 1, but is not present in steps 0, 2, 3, 4, or 5).

FORMAT
type: ensight gold GEOMETRY
model:                       1    aaa_coords.geo**  change_coords_only  1 TIME
time set:                    1
number of steps:             6
filename start number:       0
filename increment:          1
time values:                 0.1 1.2 2.3 3.4 4.5 5.6

The following files would be needed for Example 6:

aaa_coords.geo00
aaa_coords.geo01   (contains the connectivity) aaa_coords.geo02
aaa_coords.geo03 
aaa_coords.geo04
aaa_coords.geo05

Example 10.7: Case File Example 7

The following is a Case file for a static geometry, transient variable model with four constant per part variables. See EnSight Gold Constant Per Part Variable Files section for a description of the contents of constant per part files. There are a number of variations possible.

Note: The temperature constant per part also uses an optional constant per part index file - which will make reading the constant per part file more efficient.

FORMAT
type: ensight gold GEOMETRY
model:               crash.geo
VARIABLE
scalar per node:  1  plastic crash.plastic_**
vector per node:  1 displacement  crash.displacement_** 
constant per part:  1 colornumber  crash.colornumber
constant per part:  1 temperature  crash.temperature  crash.temperature.index 
constant per part:  1 casenumber  crash.casenumber
constant per part:  1 time  crash.time
TIME
time set:                   1
number of steps:            11
filename start number:      1
filename increment:         2
time values:                0.0 0.0235 0.047 0.0705
                            0.094 0.1175 0.141 0.1645
                            0.188 0.2115 0.235

The following files would be needed for Case File Example 7 (which is in the data/guard_rail directory of the EnSight 2024 R2 distribution):

crash_with_cpp.case            crash.plastic_01
crash.casenumber               crash.plastic_03
crash.colornumber              crash.plastic_05
crash.displacement_01          crash.plastic_07
crash.displacement_03          crash.plastic_09
crash.displacement_05          crash.plastic_11
crash.displacement_07          crash.plastic_13
crash.displacement_09          crash.plastic_15
crash.displacement_11          crash.plastic_17
crash.displacement_13          crash.plastic_19
crash.displacement_15          crash.plastic_21
crash.displacement_17          crash.temperature
crash.displacement_19          crash.temperature.index
crash.displacement_21          crash.time 
crash.geo

Contents of Transient Single Files

Each file contains transient data that corresponds to the specified number of time steps. The data for each time step sequentially corresponds to the simulation time values (time values) found listed in the TIME section. In transient single-file format, the data for each time step essentially corresponds to a standard EnSight gold geometry or variable file (model or measured) as expressed in multiple file format. The data for each time step is enclosed between two wrapper records, i.e. preceded by a BEGIN TIME STEP record and followed by an END TIME STEP record. Time step data is not split between files. If there is not enough room to append the data from a time step to the file without exceeding the maximum file limit of a particular system, then a continuation file must be created for the time step data and any subsequent time step. Any type of user comments may be included before and/or after each transient step wrapper.

Note: If transient single file format is used, EnSight expects all files of a dataset to be specified in transient single file format. Thus, even static files must be enclosed between a BEGIN TIME STEP and an END TIME STEP wrapper. This includes the condition where you have transient variables with static geometry. The static geometry file must have the wrapper.

For binary geometry files, the first BEGIN TIME STEP wrapper must follow the <C Binary/Fortran Binary> line. Both BEGIN TIME STEP and END TIME STEP wrappers are written according to type (1) in binary. Namely: This is a write of 80 to the file:

in C: char buffer[80];
      strcpy(buffer,"BEGIN TIME STEP");
      fwrite(buffer,sizeof(char),80,file_ptr);

in FORTRAN: character*80
            buffer buffer = "BEGIN TIME STEP"

Efficient reading of each file (especially binary) is facilitated by appending each file with a file index. A file index contains appropriate information to access the file byte positions of each time step in the file. (EnSight automatically appends a file index to each file when exporting in transient single file format.) If used, the file index must follow the last END TIME STEP wrapper in each file.

File Index Usage:

ASCII+	Binary	Item	Description
`"%20lld\n"`	4-byte integer	n	Total number of data time steps in the file.
`"%20lld\n"`	8-byte integer	fb1	File byte loc for contents of 1st time step*
`"%20lld\n"`	8-byte integer	fb2	File byte loc for contents of 2nd time step*
. . .	. . .	. . .	. . .
`"%20lld\n"`	8-byte integer	fbn	File byte loc for contents of nth time step*
`"%20lld\n"`	4-byte integer	flag	Miscellaneous flag (= 0 for now)
`"%20lld\n"`	8-byte integer	fb of item n	File byte loc for Item n above
`"%s\n"`	1-byte char*80	"FILE_INDEX"	File index keyword

Each file byte location is the first byte that follows the "BEGIN TIME STEP" record.

+ For Windows it is now acceptable to use "%20lld\n" for Visual Studio 2005 onward. Under VS2003, use "20I64d\n".

Shown below are the contents of each of the above files, using the data files from Case File Example 3 for reference (without FILE_INDEX for simplicity).

Contents of file exgold4.geo_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.geo1
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.geo3
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.geo5
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.geo7
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.geo9
                                END TIME STEP
Contents of file exgold4.pre_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.pre1
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.pre3
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.pre5
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.pre7
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.pre9
                                END TIME STEP
Contents of file exgold4.vel_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.vel1
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.vel3
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.vel5
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.vel7
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.vel9
                                END TIME STEP
Contents of file exgold4.mgeo_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo00
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo02
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo04
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo06
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo08
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mgeo10
                                END TIME STEP
Contents of file exgold4.mtem_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem00
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem02
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem04
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem06
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem08
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mtem10
                                END TIME STEP
Contents of file exgold4.mvel1_1:
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel00
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel02
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel04
                                END TIME STEP
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel06
                                END TIME STEP
Contents of file exgold4.mvel2_1:
                                Comments can precede the beginning wrapper here.
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel08
                                END TIME STEP
                                Comments can go between time step wrappers here.
                                BEGIN TIME STEP
                                Contents of file exgold3.mvel10
                                END TIME STEP
                                Comments can follow the ending time step wrapper.

Comments can follow the ending time step wrapper.

Note: Each of these files could (and should for efficiency reasons) have the FILE_INDEX information following the last END TIMESTEP. See the previous discussion for its usage.

10.2.6. EnSight Gold Wild Card Name Specification

If multiple time steps are involved, the file names must conform to the EnSight wild-card specification. This specification is as follows:

File names must include numbers that are in ascending order from beginning to end.
Numbers in the files names must be zero filled if there is more than one significant digit.
Numbers can be anywhere in the file name.
When the file name is specified in the EnSight case file, you must replace the numbers in the file with an asterisk(*). The number of asterisks specified is the number of significant digits. The asterisk must occupy the same place as the numbers in the file names.

10.2.7. EnSight Gold Geometry File Format

The EnSight Gold format is part based for both unstructured and structured data. There is no global coordinate array that each part references, but instead - each part contains its own local coordinate array. Therefore, the node numbers in element connectivities refer to the coordinate array using their 1-based index and not a node id or label.

Note: This is different than the EnSight6 format which uses node id.

The EnSight Gold format consists of keywords followed by information. The following items are important when working with EnSight Gold geometry files:

Node ids are optional. In this format they are strictly labels and are not used in the connectivity definition. The element connectivities are based on the local implied node number of the coordinate array in each part, which is sequential starting at one. If you let EnSight assign node IDs, this implied internal numbering is used. If node IDs are set to off, they are numbered internally, however, you will not be able to display or query on them. If you have node IDs given in your data, you can have EnSight ignore them by specifying node id ignore. Using this option may reduce some of the memory taken up by the Client and Server, but display and query on the nodes will not be available.
Note: Prior to EnSight 7.4, node ids could only be specified for unstructured parts. This restriction has been removed and user specified node ids are now possible for structured parts.
Node ids are always 1-based.
Element ids are optional. If you specify element IDs, or you let EnSight assign them, you can show them on the screen. If they are set to off, you will not be able to show or query on them. If you have element IDs given in your data you can have EnSight ignore them by specifying element id ignore. Using this option will reduce some of the memory taken up by the Client and Server. This may or may not be a significant amount, and remember that display and query on the elements will not be available.
Element ids are always 1-based.
Note: Prior to EnSight 7.4, element ids could only be specified for unstructured parts. This restriction has been removed and user specified element ids are now possible for structured parts.
Model extents can be defined in the file so EnSight will not have to determine these while reading in data. If they are not included, EnSight will compute them, but will not actually do so until a dataset query is performed the first time.
The format of integers and real numbers must be followed (See the Geometry Example below).
ASCII Integers are written out using the following integer format:
- From C: 10d format
- From FORTRAN: i10 format
  Note: This size of integer format limits the number of nodes as well as node and element labels to 2³¹ (2 GB) per part which is the same as a 32-bit integer.
ASCII Real numbers are written out using the following floating-point format:
- From C: 12.5e format
- From FORTRAN: e12.5 format
The number of integers or reals per line must also be followed!
By default, a Part is processed to show the outside boundaries. This representation is loaded to the Client host system when the geometry file is read (unless other attributes have been set on the workstation, such as feature angle).
Coordinates for unstructured data must be defined within each part. This is normally done before any elements are defined within a part, but does not have to be. The different elements can be defined in any order (that is, you can define a hexa8 before a bar2).
Every part should have an entry in all the .geo files. A part that is empty should just be listed as having 0 coordinates, and the elemental section can be skipped, e.g. coordinates 0
Note: Note also that the entry in the variable file for this part should contain an entry even if the part has 0 elements and coordinates. (see C Binary Form below).
EnSight uses the part name as the unique designator. As such, a given part name referring to a specific part, must remain the same in all geometry files: a given part name must not change over time and it must not be changed between spatially decomposed files.
Note: The double quote ("), ASCII character 34, is a forbidden character for part names.

A Part containing structured data cannot contain any unstructured element types or more than one block. Each structured Part is limited to a single block (or some subset of that block). A structured block is indicated by following the Part description line with a block line. By default, a block will be curvilinear, non-iblanked, non-ghost, complete range. However, by supplying one or more of the following options on the block line, parallelepiped, rectilinear or uniform blocks can be specified, nodal iblanking for the block can be used, cells within the block can be flagged as ghosts (used for computations, but not displayed), subset ranges can be specified (useful for partitioned data). The options include:

Only one of these can be used on the block line
`curvilinear`	Indicates that coordinates of all ijk locations of the block will be specified (default)
`rectilinear`	Indicates that i,j,k delta vectors for a regular block with possible non-regular spacing will be specified
`parallelepiped`	Indicates rectilinear plus an origin and i,j,k directional unit vectors for the i,j,k delta vectors will be specified
`uniform`	Indicates that i,j,k delta values for a regular block with regular spacing will be specified
Any, none, or all of these can be used
`iblanked`	An `iblanked` block must contain an additional integer array of values at each node, traditionally called the iblank array. Valid iblank values for the EnSight Gold format are:
	0	for nodes which are exterior to the model, sometimes called blanked-out nodes
	1	for nodes which are interior to the model, thus in the free stream and to be used
	<0 or >1	for any kind of boundary nodes
	In EnSight's structured Part building dialog, the iblank option selected will control which portion of the structured block is created. Therefore, from the same structured block, the interior flow field part as well as a symmetry boundary part could be created. Note: By default EnSight does not do any partial cell iblank processing. Namely, only complete cells containing no exterior nodes are created. It is possible to obtain partial cell processing by issuing the `test:partial_cells_on` command in the Command Dialog before reading the file.
`with_ghost`	A block with ghosts must contain an additional integer array of flags for each cell. A flag value of zero indicates a non-ghost cell. A flag value of non-zero indicates a ghost cell.
`range`	A block with ranges will contain an extra line, following the ijk line, which gives min and max planes for each of the ijk directions. Thus, normally a 6 x 5 x 1 block part would start something like: part 1 description block 6 5 1 0.00000e+00 ... (The coordinate information for the 30 nodes of the block must follow.) But if only the top 6 x 3 x 1portion was to be represented in the file, you can use "range" like: part 1 description for top only block range 6 5 1 1 6 3 5 1 1 0.00000e+00 ... (The coordinate information for the 18 nodes of the top portion of the block must follow. Note: The ijk line following the block line contains the size of the original block - which is needed to properly deal with node and element numbering. The next line contains the imin, imax, jmin, jmax, kmin, kmax defining the subset ranges. The actual size of the block being defined is thus computed from these ranges: size_i = imax - imin + 1 size_j = jmax - jmin + 1 size_k = kmax - kmin + 1

Note: For structured data, the standard order of nodes is such that I's advance quickest, followed by J's, and then K's.

Maximum number of parts is 32769
Maximum number of variables is 10000
Maximum file name length is 1024
Maximum part name length is 79, but the GUI will only display 49
Maximum variable name length is 79, but the GUI will only display 49

Generic Format

Usage Notes:

In general an unstructured part can contain several different element types.

`element type` can be any of:
	`point`	`g_point`
	`bar2`	`g_bar2`
	`bar3`	`g_bar3`
	`tria3`	`g_tria3`
	`tria6`	`g_tria6`
	`quad4`	`g_quad4`
	`quad8`	`g_quad8`
	`tetra4`	`g_tetra4`
	`tetra10`	`g_tetra10`
	`pyramid5`	`g_pyramid5`
	`pyramid13`	`g_pyramid13`
	`penta6`	`g_penta6`
	`penta15`	`g_penta15`
	`hexa8`	`g_hexa8`
	`hexa20`	`g_hexa20`
	`nsided`	`g_nsided`
	`nfaced`	`g_nfaced`

# = a part number (maximum is 32769)

nn = total number of nodes in a part

ne = number of elements of a given type

np = number of nodes per element for a given element type

nf = number of faces per nfaced element

id_* = node or element id number

x_* = x component

y_* = y component

z_* = z component

n*_e* = node number for an element

f*_e* = face number for an nfaced element

ib_* = iblanking value

gf_e* = ghost flag for a structured cell

origin_* = origin x,y,z coordinate components for a parallelepiped block

dirI_* = I-directional unit vector x,y,z components of respective i-delta vector for a parallelepiped block

dirJ_* = J-directional unit vector x,y,z components of respective j-delta vector for a parallelepiped block

dirK_* = K-directional unit vector x,y,z components of respective k-delta vector for a parallelepiped block

[ ] contain optional portions

< > contain choices

` indicates the beginning of an unformatted sequential FORTRAN binary write`

’ indicates the end of an unformatted sequential FORTRAN binary write.

C Binary Form

C Binary                                                                80 chars
description line 1                                                      80 chars
description line 2                                                      80 chars
node id <off/given/assign/ignore>                                       80 chars
element id <off/given/assign/ignore>                                    80 chars
[extents                                                                80 chars
xmin xmax ymin ymax zmin zmax]                                          6 floats
part [conn_change/coord_change/no_change]                               80 chars
#                                                                       1 int
description line
# this must be consistent in all files                                  80 chars
coordinates                                                             80 chars
nn                                                                      1 int
[id_n1 id_n2 ... id_nn]                                                 nn ints
x_n1 x_n2 ... x_nn                                                      nn floats
y_n1 y_n2 ... y_nn                                                      nn floats
z_n1 z_n2 ... z_nn                                                      nn floats
element type                                                            80 chars
ne                                                                      1 int
[id_e1 id_e2 ... id_ne]                                                 ne ints
n1_e1 n2_e1 ... np_e1 n1_e2 n2_e2 ... np_e2
.
.
n1_ne n2_ne ... np_ne                                                   ne*np ints
element type                                                            80 chars
.
.
part [conn_change/coord_change/no_change]                               80 chars
.
.
part [conn_change/coord_change/no_change]                               80 chars
#                                                                       1 int
description line                                                        80 chars
# this must be consistent in all files                                   
block [iblanked] [with_ghost] [range]                                   80 chars 
i j k                                                                   3 ints
# nn = j*j*k, ne = (i-1)*(j-1)*(k-1)
# ne = (i-l)*(j-l)*(k-1)
[imin imax jmin jmax kmin kmax]                                         6 ints
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_n1 x_n2 ... x_nn                                                      nn floats
y_n1 y_n2 ... y_nn                                                      nn floats
z_n1 z_n2 ... z_nn                                                      nn floats
[ib_n1 ib_n2 ... ib_nn]                                                 nn ints
[ghost_flags]                                                           80 chars
[gf_e1 gf_e2 ... gf_ne]                                                 ne ints
[node_ids]                                                              80 chars
[id_n1 id_n2 ... id_nn]                                                 nn ints
[element_ids]                                                           80 chars
[id_e1 id_e2 ... id_ne]                                                 ne ints
part [conn_change/coord_change/no_change]                               80 chars
#                                                                       1 int
description line                                                        80 chars
# this must be consistent in all files                    
block rectilinear [iblanked] [with_ghost] [range]                       80 chars 
i j k                                                                   3 ints
# nn = j*j*k, ne = (i-1)*(j-1)*(k-1)
# ne = (i-l)*(j-l)*(k-1)
[imin imax jmin jmax kmin kmax]                                         6 ints
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_1 x_2 ... x_i                                                         i floats
y_1 y_2 ... y_j                                                         j floats
z_1 z_2 ... z_k                                                         k floats
[ib_n1 ib_n2 ... ib_nn]                                                 nn ints
[ghost_flags]                                                           80 chars
[gf_e1 gf_e2 ... gf_ne]                                                 ne ints
[node_ids]                                                              80 chars
[id_n1 id_n2 ... id_nn]                                                 nn ints
[element_ids]                                                           80 chars
[id_e1 id_e2 ... id_ne]                                                 ne ints
part [conn_change/coord_change/no_change]                               80 chars
#                                                                       1 int
description line                                                        80 chars
# this must be consistent in all files
i j k                                                                   3 ints
# nn = j*j*k, ne = (i-1)*(j-1)*(k-1)
# ne = (i-l)*(j-l)*(k-1)
[imin imax jmin jmax kmin kmax]                                         6 ints
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_origin y_origin z_origin                                               3 floats
x_delta y_delta z_delta                                                  3 floats
[ib_n1 ib_n2 ... ib_nn]                                                  nn ints
[ghost_flags]                                                            80 chars
[gf_e1 gf_e2 ... gf_ne]                                                  ne ints
[node_ids]                                                               80 chars
[id_n1 id_n2 ... id_nn]                                                  nn ints
[element_ids]                                                            80 chars
[id_e1 id_e2 ... id_ne]                                                  ne ints

part [conn_change/coord_change/no_change]                                80 chars 
#                                                                        1 int 
description line     # this must be consistent in all files              80 chars 
block parallelepiped [iblanked] [with_ghost] [range]                      80 chars 
i j k                    # nn = i‘*j*k,  ne = (i—l)*(j-l)*(k-1)          3 ints 
[imin imax jmin jmax kmin kmax)   # if range used:                        6 ints 
                nn = (imax-imin+l)*(jmax-jmin+l)*(kmax-kmin+l) 
                ne = [imax-imin)*(jmax-jmin)*(kmax-kmin) 
origin_x origin_y origin_z                                                3 floats 
dirI_x dirI_y dirI_z                                                      3 floats 
dirJ_x dirJ_y dirJ_z                                                      3 floats 
dirK_x dirK_y dirK_z                                                      3 floats 
x_l x_2 ... x_i                                                           i floats 
y_1 y_2 ... y_j                                                           j floats 
z_1 z_2 ... z_k                                                           k floats 
[ib_n1 ib_n2 ... ib_nn]                                                   nn ints 
[ghost_flags]                                                             80 chars 
[gf_e1 gf_e2 ... gf_ne]                                                   ne ints 
[node_ids]                                                                80 chars 
[id_n1 id_n2 ... id_nn]                                                   nn ints 
[element_ids]                                                             80 chars 
[id_el id_e2 ... id_ne]                                                   ne ints

Fortran Binary Form

‘Fortran Binary’                                                    80 chars
‘description line 1’                                                80 chars
‘description line 2’                                                80 chars
‘node id <off/given/assign/ignore>’                                 80 chars
‘element id <off/given/assign/ignore>’                              80 chars
[‘extents’                                                          80 chars
‘xmin xmax ymin ymax zmin zmax’]                                    6 floats
‘part [conn_change/coord_change/no_change]’                         80 chars
‘#’                                                                 1 int
‘description line’                                                  80 chars
# this must be consistent in all files              
‘coordinates’                                                       80 chars
‘nn’                                                                1 int
[‘id_n1 id_n2 ... id_nn’]                                           nn ints
‘x_n1 x_n2 ... x_nn’                                                nn floats
‘y_n1 y_n2 ... y_nn’                                                nn floats
‘z_n1 z_n2 ... z_nn’                                                nn floats
‘element type’                                                      80 chars
‘ne’                                                                1 int
[‘id_e1 id_e2 ... id_ne’]                                           ne ints
‘n1_e1 n2_e1 ... np_e1 n1_e2 n2_e2 ... np_e2
.
.
n1_ne n2_ne ... np_ne’                                                ne*np ints
‘element type’                                                      80 chars
.
.
‘part [conn_change/coord_change/no_change]’                         80 chars
.
.
‘part [conn_change/coord_change/no_change]’                         80 chars
‘#’                                                                 1 int
‘description line’                                                  80 chars
‘block [iblanked] [with_ghost] [range]’                             80 chars 
i j k                                                               3 ints
# nn = j*j*k, ne = (i-1)*(j-1)*(k-1)
[imin imax jmin jmax kmin kmax]                                     6 ints
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
‘x_n1 x_n2 ... x_nn’                                                 nn floats
‘y_n1 y_n2 ... y_nn’                                                 nn floats
‘z_n1 z_n2 ... z_nn‘                                                 nn floats
[‘ib_n1 ib_n2 ... ib_nn’]                                            nn ints
[‘ghost_flags’]                                                      80 chars
[‘gf_e1 gf_e2 ... gf_ne’]                                            ne ints
[‘node_ids’]                                                         80 chars
[‘id_n1 id_n2 ... id_nn’]                                            nn ints
[‘element_ids’]                                                      80 chars
[‘id_e1 id_e2 ... id_ne’]                                            ne ints
‘part [conn_change/coord_change/no_change]’                          80 chars
‘#’                                                                  1 int
‘description line’                                                   80 chars
# this must be consistent in all files            
‘block rectilinear [iblanked] [with_ghost] [range]’                  80 chars 
‘i j k’                                                              3 ints
# nn = i‘*j*k, 
# ne = (i—l)*(j-l)*(k-1)
[‘imin imax jmin jmax kmin kmax’]                                    6 ints
# if range used:
# nn = (imax-imin+l)*(jmax-jmin+l)*(kmax-kmin+l)
# ne = (imax-imin)*(jmax-jmin)*(kmax-kmin)
‘x_1 x_2 ... x_i’                                                    i floats
‘y_1 y_2 ... y_j’                                                    j floats
‘z_1 z_2 ... z_k’                                                    k floats
[‘ib_n1 ib_n2 ... ib_nn’]                                            nn ints
[‘ghost_flags’]                                                      80 chars
[‘gf_e1 gf_e2 ... gf_ne’]                                            ne ints
[‘node_ids’]                                                         80 chars
[‘id_n1 id_n2 ... id_nn’]                                            nn ints
[‘element_ids’]                                                      80 chars
[‘id_e1 id_e2 ... id_ne’]                                            ne ints
‘part [conn_change/coord_change/no_change]’                          80 chars
‘#’                                                                  1 int
‘description line’                                                   80 chars
# this must be consistent in all files              
‘block uniform [iblanked] [with_ghost] [range]’                      80 chars 
‘i j k’                                                              3 ints
# nn = i‘*j*k, 
# ne = (i—l)*(j-l)*(k-1)
[‘imin imax jmin jmax kmin kmax’]                                    6 ints
# if range used:
# nn = (imax-imin+l)*(jmax-jmin+l)*(kmax-kmin+l)
# ne = (imax-imin)*(jmax-jmin)*(kmax-kmin)
‘x_origin y_origin z_origin                                             3 floats
x_delta y_delta z_delta’                                                3 floats
[‘ib_n1 ib_n2 ... ib_nn’]                                             nn ints
[‘ghost_flags’]                                                       80 chars
[‘gf_e1 gf_e2 ... gf_ne’]                                             ne ints
[‘node_ids’]                                                          80 chars
[‘id_n1 id_n2 ... id_nn’]                                             nn ints
[‘element_ids’]                                                       80 chars
[‘id_e1 id_e2 ... id_ne’]                                             ne ints
‘part [conn_change/coord_change/no_change]’                                                         80 chars 
#                                                                                                   1 int 
‘description line’  # this must be consistent in all files                                          80 chars 
‘block parallelepiped [iblanked] [with_ghost] [range]’                                               80 chars 
‘i j k’                    # nn = i‘*j*k,  ne = (i—l)*(j-l)*(k-1)                                   3 ints 
[‘imin imax jmin jmax kmin kmax’]    # if range used:                                               6 ints 
                                nn = (imax-imin+l)*(jmax-jmin+l)*(kmax-kmin+l) 
                                ne = [imax-imin)*(jmax-jmin)*(kmax-kmin) 
‘origin_x origin_y origin_z                                                                         3 floats 
dirI_x dirI_y dirI_z                                                                                3 floats 
dirJ_x dirJ_y dirJ_z                                                                                3 floats 
dirK_x dirK_y dirK_z’                                                                               3 floats 
‘x_l x_2 ... x_i’                                                                                   i floats 
‘y_1 y_2 ... y_j’                                                                                   j floats 
‘z_1 z_2 ... zk’                                                                                    k floats 
[‘ib_n1 ib_n2 ... ib_nn’]                                                                           nn ints 
[‘ghost_flags’]                                                                                     80 chars 
[‘gf_e1 gf_e2 ... gf_ne’]                                                                           ne ints 
[‘node_ids’]                                                                                        80 chars 
[‘id_n1 id_n2 ... id_nn’]                                                                           nn ints 
[‘element_ids’]                                                                                     80 chars 
[‘id_el id_e2 ... id_ne’]                                                                           ne ints

ASCII Form

description line 1                                                            A (max of 79 typ)
description line 2                                                            A
node id <off/given/assign/ignore>                                             A
element id <off/given/assign/ignore>                                          A

[extents                                                                      A
xmin xmax                                                                     2E12.5
ymin ymax                                                                     2E12.5
zmin zmax]                                                                    2E12.5
part [conn_change/coord_change/no_change]                                     A
#                                                                             I10
description line                                                              A
# this must be consistent in all files                                                              
coordinates                                                                   A
nn                                                                            I10
[id_n1                                                                        I10   1/line (nn)
id_n2
.
.
id_nn]
x_n1                                                                          E12.5  1/line (nn)
x_n2
.
.
x_nn
y_n1                                                                          E12.5  1/line (nn)
y_n2
.
.
y_nn
z_n1                                                                          E12.5  1/line (nn)
z_n2
.
.
z_nn
element type                                                                  A
ne                                                                            I10
[id_e1                                                                        I10   1/line (ne)
id_e2
.
.
id_ne]
n1_e1 n2_e1 ... np_e1                                                         I10   np/line
n1_e2 n2_e2 ... np_e2                                                                 (ne lines)
.
.
n1_ne n2_ne ... np_ne
element type                                                                  A
.
.
part [conn_change/coord_change/no_change]                                     A
.
.
part [conn_change/coord_change/no_change]                                     A
#                                                                             I10
description line                                                              A
# this must be consistent in all files                         
block [iblanked] [with_ghost] [range]                                         A
i j k                                                                         3I10
# nn = i*j*k, 
# ne = (i-1)*(j-1)*(k-1)
[imin imax jmin jmax kmin kmax]                                               6I10
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_n1                                                                          E12.5  1/line (nn)
x_n2
.
.
x_nn
y_n1                                                                          E12.5  1/line (nn)
y_n2
.
.
y_nn
z_n1                                                                          E12.5  1/line (nn)
z_n2
.
.
z_nn
[ib_n1                                                                        I10   1/line (nn)
ib_n2
.
.
ib_nn]
[ghost_flags]                                                                 80 chars
[gf_e1                                                                        10   1/line (ne)
gf_e2
.
.
gf_ne]
[node_ids]                                                                    80 chars
[id_n1                                                                        I10   1/line (nn)
id_n2
.
.
id_nn]
[element_ids]                                                                 80 chars
[id_e1                                                                        I10   1/line (ne)
id_e2
.
.
id_ne]
part [conn_change/coord_change/no_change]                                     A
#                                                                             I10
description line                                                              A
# this must be consistent in all files                       
block rectilinear [iblanked] [with_ghost] [range]                             A
i j k                                                                         3I10
# nn = i*j*k, 
# ne = (i-1)*(j-1)*(k-1)
[imin imax jmin jmax kmin kmax]                                               6I10
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_1                                                                           E12.5  1/line (i)
x_2
.
.
x_i
y_1                                                                            E12.5  1/line (j)
y_2
.
.
y_j
z_1                                                                            E12.5  1/line (k)
z_2
.
.
z_k
[ib_n1                                                                         I10   1/line (nn)
ib_n2
.
.
ib_nn]
[ghost_flags]                                                                  80 chars
[gf_e1                                                                         I10   1/line (ne)
gf_e2
.
.
gf_ne]
[node_ids]                                                                     80 chars
[id_n1                                                                         I10   1/line (nn)
id_n2
.
.
id_nn]
[element_ids]                                                                  80 chars
[id_e1                                                                         I10   1/line (ne)
id_e2
.
.
id_ne]
part [conn_change/coord_change/no_change]                                      A
#                                                                              I10
description line                                                               A
# this must be consistent in all files                       
block uniform [iblanked] [with_ghost] [range]                                  A
i j k                                                                          3I10
# nn = i*j*k, 
# ne = (i-1)*(j-1)*(k-1)
[imin imax jmin jmax kmin kmax]                                                6I10
# nn = (imax-imin+1)*(jmax-jmin+1)*(kmax-kmin+1)
# ne = (imax-imin)*(jmax*jmin)*(kmax-kmin)
x_origin                                                                       E12/5
y_origin                                                                       E12/5
z_origin                                                                       E12/5
x_delta                                                                        E12.5
y_delta                                                                        E12.5
z_delta                                                                        E12.5
[ib_n1                                                                         I10   1/line (nn)
ib_n2
.
.
ib_nn]
[ghost_flags]                                                                  80 chars
[gf_e1                                                                         I10   1/line (ne)
gf_e2
.
.
gf_ne]
[node_ids]                                                                     80 chars
[id_n1                                                                         I10   1/line (nn)
id_n2
.
.
id_nn]
[element_ids]                                                                   80 chars
[id_e1                                                                          I10   1/line (ne)
id_e2
.
.
id_ne]
part [conn_change/coord_chanqe/no_change]                                       A 
#                                                                               I10 
description line                   # this must be consistent in all files       A 
block parallelepiped [iblanked] [with_qhost] [range]                             A 
i j k                             #  nn = i*j*k,  
                                     ne = (i-1)*(j-1)*(k-1)                     3 I10 
[imin imax jmin jmax kmin kmax]         # if range used:                        6 I10 
                        nn = (imax-imin+l)*(jmax-jmin-l)*(kmax-kmin+l) 
                        ne = (imax-inin)*(jmax-jmin)*(kmax-kmin) 
origin_x                                                                        I10  1/line  (3) 
origin_x 
origin_x 
dirI_x                                                                          I10  1/line  (3) 
dirI_y 
dirI_z 
dirJ_x                                                                          I10  1/line  (3) 
dirJ_y 
dirJ_z 
dirK_x                                                                          I10  1/line  (3) 
dirK_y 
dirK_z 
x_1                                                                             E12.5 l/line (i) 
x_2 
… 
x_i 
y_1                                                                             E12.5 1/line (j) 
y_2 
… 
y_j 
z_1                                                                             E12.5 1/line (k) 
z_2 
… 
z_k 
[ib_n1                                                                          I10 1/line (nn) 
1b_n2 
… 
ib_nn] 
[ghost_flags]                                                                   80 chars 
[gf_e1                                                                          I10 1/line (ne) 
gf_e2 
… 
gf_ne) 
[node_ids                                                                     ] 80 chars 
[id_n1)                                                                         I10 1/line (nn 
id_n2 
… 
id_nn] 
[element_ids]                                                                   80 chars 
[id_el                                                                          I10 l/line (ne) 
id_e2 
id_ne]

Notes:

If node id is given or ignore, the [id] section must be there for each part.
If element id is given or ignore, the [id] section must be there for each element type of each part
If iblanked is there, the [ib] section must be there for the block.
x, y, and z coordinates are mandatory, even if a 2D problem.
If block rectilinear or parallelepiped, then the x, y, z coordinates change to the x, y, and z delta vectors.
If block uniform, then the x, y, z coordinates change to the x, y, z coordinates of the origin and the x, y, and z delta values.
If block range, the ijk min/max range line must follow the ijk line. And the number of nodes and elements is based on the ranges. The ijk line indicates the size of the original block.
If with_ghost is on the block line, then the ghost_flag section must be there
Ids are just labels, the coordinate (or element) order is implied.
The minimum needed for unstructured empty parts is the three lines (with a given part name consistently unchanging in all .geo files over time and/or spatially decomposed):
```
part 
         # (use the actual part number)
description 
# this must be consistent in all files
```

The minimum needed for structured empty parts is the five lines:

part 
         # (use the actual part number)
description
# this must be consistent in all files
Block 
         0         0         0

Element blocks for nsided elements contain an additional section - the number of nodes in each element. See below.
If the GEOMETRY, model: section contains the changing_geometry_per_part keyword, then the part keyword must be followed by one of the following keywords in the geometry file: conn_change/coord_change/no_change. This is useful when one or a few parts are changing connectivity (such as particle parts) and others are static. Only the parts that are truly changing connectivity will be updated by the reader on time change, avoiding unnecessary duplicate reads of static geometry, and speeding up the reading process.

part conn_change/coord_change/no_change 
         # (use the actual part number)
description
# this must be consistent in all files

C Binary form of element block, if nsided:

nsided                                            80 chars
ne                                                1 int
[id_n1 id_n2 ... id_ne]                           ne ints
np1 np2 ... npne         This data is needed      ne ints e1_n1 e1_n2 ... e1_np1
e2_n1 e2_n2 ... e2_np2
.
.
ne_n1 ne_n2 ... ne_npne                     np1+np2+...+npne ints

Fortran Binary form of element block, if nsided:

‘nsided’                                          80 chars
‘ne’                                              1 int
[‘id_n1 id_n2 ... id_ne’]                         ne ints
‘np1 np2 ... npne’       This data is needed      ne ints ‘e1_n1 e1_n2 ... e1_np1
e2_n1 e2_n2 ... e2_np2
.
.
ne_n1 ne_n2 ... ne_npne’                   np1+np2+...+npne ints

Ascii form of element block, if nsided:

nsided                                                                A
ne                                                                    I10
[id_n1                                                                I10   1/line (ne)
id_n2
.
id_ne]
np1                  This data is needed                            I10   1/line (ne)
np2                    .
.                    .
npne                   .
e1_n1 e1_n2 ... e1_np1                                                 I10   np*/line
e2_n1 e2_n2 ... e2_np2                                                 (ne lines)
.
ne_n1 ne_n2 ... ne_npne

Element blocks for nfaced elements are more involved since they are described by their nsided faces. Thus, there is the optional section for ids (id_e*), a section for the number of faces per element (nf_e*), a section for number of nodes per face per element (np(f*_e*)), and a section for the connectivity of each nsided face of each element (n*(f*_e*)). See below.

C Binary form of element block, if nfaced:

nfaced                                                                80 chars
ne                                                                    1 int
[id_e1 id_e2 ... id_ne]                                               ne ints
nf_e1 nf_e2 ... nf_ne                                                 ne ints
np(f1_e1) np(f2_e1) ... np(nf_e1) 
np(f1_e2) np(f2_e2) ... np(nf_e2)
.
.
np(f1_ne) np(f2_ne) ... np(nf_ne)                         nf_e1+nf_e2+...+nf_ne ints 
n1(f1_e1) n2(f1_e1) ... n(np(f1_e1))
n1(f2_e1) n2(f2_e1) ... n(np(f2_e1))
.
n1(nf_e1) n2(nf_e1) ... n(np(nf_e1))
n1(f1_e2) n2(f1_e2) ... n(np(f1_e2))

n1(f2_e2) n2(f2_e2) ... n(np(f2_e2))
.
n1(nf_e2) n2(nf_e2) ... n(np(nf_e2))
.
.
n1(f1_ne) n2(f1_ne) ... n(np(f1_ne))
n1(f2_ne) n2(f2_ne) ... n(np(f2_ne))
.
n1(nf_ne) n2(nf_ne) ... n(np(nf_ne))
np(f1_e1)+np(f2_e1)+...+np(nf_ne) ints

Fortran Binary form of element block, if nfaced:

‘nfaced’                                              80 chars
‘ne’                                                  1 int
[‘id_e1 id_e2 ... id_ne’]                             ne ints
‘nf_e1 nf_e2 ... nf_ne’                               ne ints
‘np(f1_e1) np(f2_e1) ... np(nf_e1) 
np(f1_e2) np(f2_e2) ... np(nf_e2)
.
.
np(f1_ne) np(f2_ne) ... np(nf_ne)’              nf_e1+nf_e2+...+nf_ne ints 
‘n1(f1_e1) n2(f1_e1)...n(np(f1_e1))
n1(f2_e1) n2(f2_e1) ... n(np(f2_e1))
.
n1(nf_e1) n2(nf_e1) ... n(np(nf_e1))
n1(f1_e2) n2(f1_e2) ... n(np(f1_e2))
n1(f2_e2) n2(f2_e2) ... n(np(f2_e2))
.
n1(nf_e2) n2(nf_e2) ... n(np(nf_e2))
.
.
n1(f1_ne) n2(f1_ne) ... n(np(f1_ne))
n1(f2_ne) n2(f2_ne) ... n(np(f2_ne))
.
n1(nf_ne) n2(nf_ne) ... n(np(nf_ne))’       np(f1_e1)+np(f2_e1)+...+np(nf_ne) ints

Ascii form of element block, if nfaced:

nfaced                                            A
ne                                                I10
[id_e1                                            I10   1/line
id_e2                                                  (ne lines)
.
id_ne]
nf_e1                                             I10   1/line
nf_e2                                                  (ne lines)
.
nf_ne
np(f1_e1)                                          I10   1/line
np(f2_e1)                                    (nf_e1+nf_e2+...+nf_ne lines)
.
np(nf_e1) np(f1_e2) np(f2_e2)
.
np(nf_e2)
.
.
np(f1_ne) np(f2_ne)
.
np(nf_ne)
n1(f1_e1) n2(f1_e1) ... n(np(f1_e1))                    I10  np*/line 
n1(f2_e1) n2(f2_e1) ... n(np(f2_e1))               (nf_e1+nf_e2+...+nf_ne lines)
.
n1(nf_e1) n2(nf_e1) ... n(np(nf_e1))
n1(f1_e2) n2(f1_e2) ... n(np(f1_e2))
n1(f2_e2) n2(f2_e2) ... n(np(f2_e2)).
.
n1(nf_e2) n2(nf_e2) ... n(np(nf_e2))
.
.
n1(f1_ne) n2(f1_ne) ... n(np(f1_ne))
n1(f2_ne) n2(f2_ne) ... n(np(f2_ne))
.
n1(nf_ne) n2(nf_ne) ... n(np(nf_ne))

EnSight Gold Geometry File Example

The following is an example of an ASCII EnSight Gold geometry file: This is the same example model as given in the EnSight6 geometry file section (only in Gold format) with 11 defined unstructured nodes from which 2 unstructured parts are defined, and a 2x3x2 structured part as depicted in the above diagram.

Note: The example file below (engold.geo) and all example variable files in the gold section (also prefixed with engold) may be found under your EnSight installation directory (path: $CEI/ensight242/data/user_manual).

Important: The appended # comment lines are for your reference only, and are not valid format lines within a geometry file as appended below. Do not put these # comments in your file.

This is the lst description line of the EnSight Gold geometry example 
This is the 2nd description line of the EnSight Gold geometry example 
node id given
element id given 
extents
 0.00000e+00 6.00000e+00
 0.00000e+00 3.00000e+00
 0.00000e+00 2.00000e+00
part
         1
2D uns-element	# unchanging description line for part 1
coordinates
        10		# nn		Do NOT put these # comments in your file!!
        15		# node ids
        20
        40
        22
        44
        55
        60
        61
        62
        63
 4.00000e+00		# x components
 5.00000e+00
 6.00000e+00
 5.00000e+00
 6.00000e+00
 6.00000e+00
 5.00000e+00
 6.00000e+00
 6.00000e+00
 5.00000e+00
 0.00000e+00		# y components
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00		# z components
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
tria3			# element type
         2		# ne
       102		# element ids
       103
         1         2         4
         4         5         6
hexa8
         1
       104
         2         3         5         4         7         8          9        10
part
         2
1D Line-elements	# (unchanging, consistent description line for part 2)
coordinates
         2
        15
        31
 4.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
bar2
         1
       101
         2         1
part
         3
3D struct-part	# (unchanging, consistent description line for part 3)
block iblanked
         2         3         2
 0.OO000e+00		# i components
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00		# j components
 0.00000e+00
 1.00000e+00
 1.00000e+00
 3.00000e+00
 3.000000+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 3.00000e+00
 3.00000e+00
 0.00000e+00		# k components
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
         1		# iblanking
         1
         1
         1
         1
         1
         1
         1
         1
         1
         1
         1

Simple Example Using Nsided/Nfaced Elements

The following is an example of an ASCII EnSight Gold geometry file with nsided and nfaced data. It is a non-realistic, simple model which is intended only to illustrate the format. Two nsided elements and three nfaced elements are used, even though the model could have been represented with a single nsided and single nfaced element.

Note: The appended # comment lines are for your reference only, and are not valid format lines within a geometry file as appended below. Do not put these # comments in your file.

simple example for nsided/nfaced element types in EnSight Gold Format node id given
element id given extents
-2.00000e+00 4.00000e+00 
0.00000e+00 3.50000e+00
-2.00000e+00 4.00000e+00
part
         1
barn
coordinates
        18              # nn          Do NOT put these # comments in your file!!
        10              # node ids
        20
        30
        40
        50
        60
        70
        80
        90
       100
       110
       120
       130
       140
       150
       160
       170
       180
 0.00000e+00             # x components 
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 0.00000e+00
 2.00000e+00
 4.00000e+00
 4.00000e+00
-2.00000e+00
-2.00000e+00
 0.00000e+00              # y components
 0.00000e+00
 2.00000e+00
 2.00000e+00
 0.00000e+00
 0.00000e+00
 2.00000e+00
 2.00000e+00
 3.50000e+00
 3.50000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00                # z components
 0.00000e+00
 0.00000e+00
 0.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 1.00000e+00
 1.00000e+00
 1.50000e+00
 1.50000e+00
 0.50000e+00
 0.50000e+00
-2.00000e+00
 4.00000e+00
 4.00000e+00
-2.00000e+00
nsided
         2                                                         # 2 nsided elements
       101                                                         # element ids
       202
         4                                                         # 4 nodes in first element
         8                                                         # 8 nodes in second element
         2         15        18         1                          # connectivity of element 1
         1         18        17         16        15         2         6         5                    # connectivity of element 2
nfaced
         3                                                             # 3 nfaced polyhedra elements
      1001                                                                 # element ids
      1002
      1003
         5                                                 # number of faces in element 1
         5                                                 # number of faces in element 2
         7                                                 # number of faces in element 3
         3                                                 # number of nodes in face 1 of element 1
         3                                        #                face 2 of element 1
         4                                        #                face 3 of element 1
         4                                        #                face 4 of element 1
         4                                        #                face 5 of element 1
         3                                        # number of nodes in face 1 of element 2
         3                                        #                face 2 of element 2
         4                                        #                face 3 of element 2
         4                                        #                face 4 of element 2
         4                                        #                face 5 of element 2
         5                                        # number of nodes in face 1 of element 3
         5                                        #                face 2 of element 3
         4                                        #                face 3 of element 3
         4                                        #                face 4 of element 3
         4                                        #                face 5 of element 3
         4                                        #                face 6 of element 3
         4                                        #                face 7 of element 3
         5         6         8                    # connectivity of face 1 of element 1
         2         1         4                    #              face 2 of element 1
         6         2         4         8          #              face 3 of element 1
         8         4         1         5          #              face 4 of element 1
         1         2         6         5          #              face 5 of element 1
         5         8         7                    # connectivity of face 1 of element 2
         1         3         4                    #              face 2 of element 2
         7         8         4         3          #              face 3 of element 2
         7         3         1         5             #              face 4 of element 2
         5         1         4         8              #              face 5 of element 2
         8         4        14        10        12    # connectivity of face 1 of element 3
         7        11         9        13         3    #              face 2 of element 3
         7         8        12        11              #              face 3 of element 3
         11       12        10         9              #              face 4 of element 3
         9        10        14        13              #              face 5 of element 3
         13       14         4         3              #              face 6 of element 3
         7         3         4         8              #              face 7 of element 3

Important: It is important to know that the execution time and memory use for nsided or nfaced elements is significantly increased. It is not advisable to simply use the nsided/nfaced representations for all elements, even those that could be represented with the simple basic elements. EnSight has no problem with different element types begin used within a part.

If, for example, you have a model with triangles, quads and some nsided elements. You will be far ahead to represent them in the EnSight data format as triangles, quads and the few nsided. Do not represent them all as nsided.

Simple Examples Using Ghost Cells

The following two ASCII EnSight Gold geometry file examples show use of ghost cells in unstructured and structured models. First the geometry file for the total model, composed of four parts, is given without any ghost cells. Then, two of four separate geometry files - each containing just one of the original parts (and appropriate ghost cells) will be given. This is supposed to simulate a decomposed model, such as you might provide for EnSight's Server-of-Servers.

Note: For unstructured models, ghost cells are simply a new element type. For structured models, ghost cells are an iblank-like flag.

Unstructured model

Total Unstructured Model Geometry File

EnSight Model Geometry File
EnSight 7.1.0 node id given element id given 
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part
         1
bottom left coordinates
         9
         1
         2
         3    
         6
         7
         8
         11
         12
         13
 0.00000e+00
 1.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
         9
         10
         13
         14
         15
 2.00000e+00
 3.00000e+00
 4.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 1.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         4        
         3
         4
         7
         8
         1     2     5     4
         2     3     6     5
         4     5     8     7
         5     6     9     8
part        
         3
top left
coordinates
         9
         11
         12
         13
         16
         17
         18
         21
         22
         23
 0.00000e+00
 1.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 4.00000e+00

 1.00000e+00
 1.00000e+00
 1.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4        
         4
         1
         2    
         5
         6
         1         2         5         4
         2         3         6         5
         4         5         8         7    
         5         6         9         8

part
         2
bottom right 
coordinates
         9
         3
         4
         5
         8
 4.00000e+00
 4.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         4
         9
         10
         13
         14
         1     2     5     4
         2     3     6     5
         4     5     8     7
         5     6     9     8
part
         4
top right
coordinates
         9
         13
         14
         15
         18
         19
         20
         23    
         24
         25
 2.00000e+00
 3.00000e+00
 4.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 4.00000e+00
 4.00000e+00
 4.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         4
         11
         12
         15
         16
         1     2     5     4
         2     3     6     5
         4     5     8     7
         5     6     9     8

Portion with Part 1 Containing Ghost Cells (Other Parts Are Empty)

EnSight Model Geometry File
part 1 portion
node id given
element id given
extents
 0.00000e+00 4.00000e+00    0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part
         1
bottom left
coordinates
        16
         1
         2
         3
         4
         6
         7
         8
         9
        11
        12
        13
        14
        16
        17
        18
        19
 0.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 0.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 1.00000e+00
 1.00000e+00
 2.00000e+00

 2.00000e+00
 2.00000e+00
 2.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         4
         1
         2
         5
         6
         1         2         6         5
         2         3         7         6
         5         6        10         9
         6         7        11        10
g_quad4
         5
         1
         1
         1
         1
         1
         3         4         8         7
         7         8        12        11
         9        10        14        13
        10        11        15        14
        11        12        16        15
part                            /* Empty part */
         2
bottom right
part                            /* Empty part */
         3
top left
part                            /* Empty part */
         4
top right

Portion with Part 2 Containing Ghost Cells (Other Parts Are Empty)

EnSight Model Geometry File
part 2 portion
node id given
element id given
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part                       /* Empty part */
         1
bottom left
part
         2
bottom right
coordinates
        16
         2
         3
         4
         5
         7
         8
         9
        10
        12
        13
        14
        15
        17
        18
        19
        20
 1.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 1.00000e+00

 1.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 2.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         4
         3
         4
         7
         8
         2         3         7         6
         3         4         8         7
         6         7        11        10
         7         8        12        11
g_quad4
         5
         1
         1
         1
         1
         1
         1         2         6         5
         5         6        10         9
         9        10        14        13
        10        11        15        14
        11        12        16        15
part                            /* Empty part */
         3
top left
part                            /* Empty part */
         4
top right

Structured Model

(Using essentially the same model, but in structured format):

EnSight Model Geometry File
Total Structured Model
node id assign
element id assign 
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part
         1
left bottom
block uniform range
         5         5         1
         1         3         1         3         1         1
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
part
         2
bottom right
block uniform range      
         5         5         1
         3         5         1         3         1         1
 2.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
part
         3
top left
block uniform range      
         5         5         1
         1         3         3         5         1         1
 0.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
part
         4
top right
block uniform range
         5         5         1
         3         5         3         5         1         1
 2.00000e+00
 2.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00

Portion with Part 1 Containing Ghost Cells (Other Parts Are Empty)

EnSight Model Geometry File
part 1 portion only
node id assign
element id assign
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part
         1
left bottom
block uniform range with_ghost
         4         4         1
         1         4         1         4         1         1
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
ghost_flags
         0
         0
         1
         0
         0
         1
         1
         1
         1
Part                 /* Empty Part */
         2
right bottom
block
         0         0         0
part                 /* Empty Part */
         3
left top
block
         0         0         0
part                 /* Empty Part */
         4
right top
block
         0         0         0

Portion with Part 2 Containing Ghost Cells (Other Parts Are Empty)

EnSight Model Geometry File
part 2 portion only
node id assign
element id assign
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 4.00000e+00
 0.00000e+00 0.00000e+00
part
         1
left bottom
block
         0         0         0
part
         2
right bottom
block uniform range with_ghost
         4         4         1
         2         5         1         4         1         1
 1.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
ghost_flags
         1
         0
         0
         1
         0
         0
         1
         1
         1
part                 /* Empty Part */
         3
left top
block
         0         0        0
part                 /* Empty Part */
         4
right top
block
         0         0         0

Note: For both the unstructured and the structured model above, only the first two files (parts 1 and 2) are given. The portion files for parts 3 and 4 are not given, but would be similar to those for parts 1 and 2.

Example with part 2 containing ghost cells (other parts are empty

10.2.8. Partial Example of Per-Part Connectivity Usage

sample.case
===========
FORMAT
type:                   ensight gold
GEOMETRY
model:                  1 sample.geo****  changing_geometry_per_part
TIME
time set:               1
number of steps:        4
filename start number:  0
filename increment:     1
time values:
 1.00000000e+00
 2.00000000e+00
 3.00000000e+00
 4.00000000e+00
sample.geo0000
==============
EnSight Model Geometry File
EnSight 2024 R2
node id assign
element id assign
extents
 0.00000e+00 4.00000e+00
 0.00000e+00 1.00000e+00
 0.00000e+00 0.00000e+00
part no_change
         1
square 1
coordinates
         4
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         1
         1         2         3         4
part coord_change
         2
square 2
coordinates
         4
 1.00000e+00
 2.00000e+00
 2.00000e+00
 1.00000e+00
 0.00000e+00
 0.00000e+00
 1.00000e+00
 1.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
quad4
         1
         1         2         3         4
part conn_change
         3
...

10.2.9. EnSight Gold Variable File Format

EnSight Gold variable files can either be per_node or per_element. They cannot be both. However, an EnSight model can have some variables which are per_node and others which are per_element.

10.2.10. EnSight Gold Per_Node Variable File Format

EnSight Gold variable files for per_node variables contain values for each unstructured node and for each structured node. First comes a single description line. Second comes a part line. Third comes a line containing the part number. Fourth comes a coordinates line or a block line. If a coordinates line, the value for each unstructured node of the part follows. If it is a scalar file, there is one value per node, while for vector files there are three values per node (output in the same component order as the coordinates, namely, all x components, then all y components, then all z components). If it is a block line, the value(s) for each structured node follows. The values for each node of the structured block are output in the same IJK order as the coordinates. (The number of nodes in the part are obtained from the corresponding EnSight Gold geometry file)

Note: If the geometry of given part is empty, nothing for that part needs to be in the variable file.

C Binary Form

SCALAR FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
coordinates                                       80 chars
s_n1 s_n2 ... s_nn                                nn floats
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = i*j*k                 80 chars
s_n1 s_n2 ... s_nn                                nn floats

VECTOR FILE:

description line 1                                   80 chars
part                                                 80 chars
#                                                    1 int
coordinates                                          80 chars
vx_n1 vx_n2 ... vx_nn                                nn floats
vy_n1 vy_n2 ... vy_nn                                nn floats
vz_n1 vz_n2 ... vz_nn                                nn floats
part                                                 80 chars
.
.
part                                                 80 chars
#                                                    1 int
block                # nn = i*j*k                    80 chars
vx_n1 vx_n2 ... vx_nn                                nn floats
vy_n1 vy_n2 ... vy_nn                                nn floats
vz_n1 vz_n2 ... vz_nn                                nn floats

TENSOR FILE:

description line 1                                    80 chars
part                                                  80 chars
#                                                     1 int
coordinates                                           80 chars
v11_n1 v11_n2 ... v11_nn                              nn floats
v22_n1 v22_n2 ... v22_nn                              nn floats
v33_n1 v33_n2 ... v33_nn                              nn floats
v12_n1 v12_n2 ... v12_nn                              nn floats
v13_n1 v13_n2 ... v13_nn                              nn floats
v23_n1 v23_n2 ... v23_nn                              nn floats
part                                                  80 chars
.
.
part                                                  80 chars
#                                                     1 int
block                    # nn = i*j*k                 80 chars
v11_n1 v11_n2 ... v11_nn                              nn floats
v22_n1 v22_n2 ... v22_nn                              nn floats
v33_n1 v33_n2 ... v33_nn                              nn floats
v12_n1 v12_n2 ... v12_nn                              nn floats
v13_n1 v13_n2 ... v13_nn                              nn floats
v23_n1 v23_n2 ... v23_nn                              nn floats

TENSOR9 FILE:

description line 1                                    80 chars
part                                                  80 chars
#                                                     1 int
coordinates                                           80 chars
v11_n1 v11_n2 ... v11_nn                              nn floats
v12_n1 v12_n2 ... v12_nn                              nn floats
v13_n1 v13_n2 ... v13_nn                              nn floats
v21_n1 v21_n2 ... v21_nn                              nn floats
v22_n1 v22_n2 ... v22_nn                              nn floats
v23_n1 v23_n2 ... v23_nn                              nn floats
v31_n1 v31_n2 ... v31_nn                              nn floats
v_n1 v_n2 ... v_nn                                    nn floats
v33_n1 v33_n2 ... v33_nn                              nn floats
part                                                  80 chars
.
.
part                                                  80 chars
#                                                     1 int
block                    # nn = i*j*k                 80 chars
v11_n1 v11_n2 ... v11_nn                              nn floats
v12_n1 v12_n2 ... v12_nn                              nn floats
v13_n1 v13_n2 ... v13_nn                              nn floats
v21_n1 v21_n2 ... v21_nn                              nn floats
v22_n1 v22_n2 ... v22_nn                              nn floats
v23_n1 v23_n2 ... v23_nn                              nn floats
v21_n1 v21_n2 ... v21_nn                              nn floats
v22_n1 v22_n2 ... v22_nn                              nn floats
v23_n1 v23_n2 ... v23_nn                              nn floats

COMPLEX SCALAR FILES (Real and/or Imaginary):

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
coordinates                                       80 chars
s_n1 s_n2 ... s_nn                                nn floats
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = i*j*k                 80 chars
s_n1 s_n2 ... s_nn                                nn floats

COMPLEX VECTOR FILES (Real and/or Imaginary):

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
coordinates                                       80 chars
vx_n1 vx_n2 ... vx_nn                             nn floats
vy_n1 vy_n2 ... vy_nn                             nn floats
vz_n1 vz_n2 ... vz_nn                             nn floats
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = i*j*k                 80 chars
vx_n1 vx_n2 ... vx_nn                             nn floats
vy_n1 vy_n2 ... vy_nn                             nn floats
vz_n1 vz_n2 ... vz_nn                             nn floats

Fortran Binary Form

SCALAR FILE:

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘coordinates’                                     80 chars
‘s_n1 s_n2 ... s_nn’                              nn floats
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’                # nn = i*j*k               80 chars
‘s_n1 s_n2 ... s_nn’                              nn floats

VECTOR FILE:

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘coordinates’                                     80 chars
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’                # nn = i*j*k               80 chars
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats

TENSOR FILE:

‘description line 1‘                                 80 chars
‘part’                                               80 chars
‘#’                                                  1 int
‘coordinates‘                                        80 chars
‘v11_n1 v11_n2 ... v11_nn’                           nn floats
‘v22_n1 v22_n2 ... v22_nn’                           nn floats
‘v33_n1 v33_n2 ... v33_nn’                           nn floats
‘v12_n1 v12_n2 ... v12_nn’                           nn floats
‘v13_n1 v13_n2 ... v13_nn’                           nn floats
‘v23_n1 v23_n2 ... v23_nn’                           nn floats
‘part’                                               80 chars
.
.
‘part’                                               80 chars
‘#’                                                  1 int
‘block’                # nn = i*j*k                  80 chars
‘v11_n1 v11_n2 ... v11_nn’                           nn floats
‘v22_n1 v22_n2 ... v22_nn’                           nn floats
‘v33_n1 v33_n2 ... v33_nn’                           nn floats
‘v12_n1 v12_n2 ... v12_nn’                           nn floats
‘v13_n1 v13_n2 ... v13_nn’                           nn floats
‘v23_n1 v23_n2 ... v23_nn’                           nn floats

TENSOR9 FILE:

‘description line 1‘                                  80 chars
‘part’                                                80 chars
‘#’                                                   1 int
‘coordinates‘                                         80 chars
‘v11_n1 v11_n2 ... v11_nn’                            nn floats
‘v12_n1 v12_n2 ... v12_nn’                            nn floats
‘v13_n1 v13_n2 ... v13_nn’                            nn floats
‘v21_n1 v21_n2 ... v21_nn’                            nn floats
‘v22_n1 v22_n2 ... v22_nn’                            nn floats
‘v23_n1 v23_n2 ... v23_nn’                            nn floats
‘v31_n1 v31_n2 ... v31_nn’                            nn floats
‘v_n1 v_n2 ... v_nn’                                  nn floats
‘v33_n1 v33_n2 ... v33_nn’                            nn floats
‘part’                                                80 chars
.
.
‘part’                                                80 chars
‘#’                                                   1 int
‘block’                # nn = i*j*k                   80 chars
‘v11_n1 v11_n2 ... v11_nn’                            nn floats
‘v12_n1 v12_n2 ... v12_nn’                            nn floats
‘v13_n1 v13_n2 ... v13_nn’                            nn floats
‘v21_n1 v21_n2 ... v21_nn’                            nn floats
‘v22_n1 v22_n2 ... v22_nn’                            nn floats
‘v23_n1 v23_n2 ... v23_nn’                            nn floats
‘v31_n1 v31_n2 ... v31_nn’                            nn floats
‘v_n1 v_n2 ... v_nn’                                  nn floats
‘v33_n1 v33_n2 ... v33_nn’                            nn floats

COMPLEX SCALAR FILES (Real and/or Imaginary):

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘coordinates’                                     80 chars
‘s_n1 s_n2 ... s_nn’                              nn floats
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’                # nn = i*j*k               80 chars
‘s_n1 s_n2 ... s_nn’                              nn floats

COMPLEX VECTOR FILES (Real and/or Imaginary):

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘coordinates’                                     80 chars
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’                # nn = i*j*k               80 chars
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats

ASCII Form

SCALAR FILE:

description line 1                                A (max of 79 typ)
part                                              A
#                                                 I10
coordinates                                       A
s_n1                                              E12.5  1/line (nn)
s_n2
.
.
s_nn
part                                              A
.
.
part                                              A
#                                                 I10
block                  # nn = i*j*k               A
s_n1                                              E12.5  1/line (nn)
s_n2
.
.
s_nn

VECTOR FILE:

description line 1                    A (max of 79 typ)
part                                              A
#                                                 I10
coordinates                                       A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn
part                                              A
.
.
part                                              A
#                                                 I10
block                  # nn = i*j*k               A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn

TENSOR FILE:

description line 1                   A (max of 79 typ)
part                                              A
#                                                 I10
coordinates                                       A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn
part                                              A
.
.
part                                              A
#                                                 I10
block                  # nn = i*j*k               A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn

TENSOR9 FILE:

description line 1                                A (max of 79 typ)
part                                              A
#                                                 I10
coordinates                                       A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v21_n1                                            E12.5  1/line (nn)
v21_n2
.
.
v21_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn
v31_n1                                            E12.5  1/line (nn)
v31_n2
.
.
v31_nn
v_n1                                              E12.5  1/line (nn)
v_n2
.
.
v_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn
part                                              A
.
.
part                                              A
#                                                 I10
block                  # nn = i*j*k               A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v21_n1                                            E12.5  1/line (nn)
v21_n2
.
.
v21_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn
v31_n1                                            E12.5  1/line (nn)
v31_n2
.
.
v31_nn
v_n1                                              E12.5  1/line (nn)
v_n2
.
.
v_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn

COMPLEX SCALAR FILES (Real and/or Imaginary):

description line 1                               A (max of 79 typ)
part                                             A
#                                                I10
coordinates                                      A
s_n1                                             E12.5  1/line (nn)
s_n2
.
.
s_nn
part                                             A
part                                             A
#                                                I10
block                  # nn = i*j*k              A
s_n1                                             E12.5  1/line (nn)
s_n2
.
.
s_nn

COMPLEX VECTOR FILES (Real and/or Imaginary):

description line 1                                A (max of 79 typ)
part                                              A
#                                                 I10
coordinates                                       A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn
part                                              A
.
.
part                                              A
#                                                 I10
block                  # nn = i*j*k               A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn

The following variable file examples reflect scalar, vector, tensor, and complex variable values per node for the previously defined EnSight6 Gold Geometry File Example with 11 defined unstructured nodes and a 2x3x2 structured Part (Part number 3). The values are summarized in the following table.

Note: These are the same values as listed in the EnSight6 per_node variable file section. Subsequently, the following example files contain the same data as the example files given in the EnSight6 section - only they are listed in gold format. (No asymmetric tensor example data given)

						`Complex Scalar`
	`Node`	`Node`	`Scalar`	`Vector`	`Tensor (2nd order symm.)`	`Real`	`Imaginary`
	`Index`	`Id`	`Value`	`Values`	`Values`	`Value`	`Value`
Unstructured
	1	15	(1.)	(1.1, 1.2, 1.3)	(1.1, 1.2, 1.3, 1.4, 1.5, 1.6)	(1.1)	(1.2)
	2	31	(2.)	(2.1, 2.2, 2.3)	(2.1, 2.2, 2.3, 2.4, 2.5, 2.6)	(2.1)	(2.2)
	3	20	(3.)	(3.1, 3.2, 3.3)	(3.1, 3.2, 3.3, 3.4, 3.5, 3.6)	(3.1)	(3.2)
	4	40	(4.)	(4.1, 4.2, 4.3)	(4.1, 4.2, 4.3, 4.4, 4.5, 4.6)	(4.1)	(4.2)
	5	22	(5.)	(5.1, 5.2, 5.3)	(5.1, 5.2, 5.3, 5.4, 5.5, 5.6)	(5.1)	(5.2)
	6	44	(6.)	(6.1, 6.2, 6.3)	(6.1, 6.2, 6.3, 6.4, 6.5, 6.6)	(6.1)	(6.2)
	7	55	(7.)	(7.1, 7.2, 7.3)	(7.1, 7.2, 7.3, 7.4, 7.5, 7.6)	(7.1)	(7.2)
	8	60	(8.)	(8.1, 8.2, 8.3)	(8.1, 8.2, 8.3, 8.4, 8.5, 8.60	(8.1)	(8.2)
	9	61	(9.)	(9.1, 9.2, 9.3)	(9.1, 9.2, 9.3, 9.4, 9.5, 9.6)	(9.1)	(9.2)
	10	62	(10.)	(10.1,10.2,10.3)	(10.1,10.2, 10.3,10.4, 10.5,10.6)	(10.1)	(10.2)
	11	63	(11.)	(11.1,11.2,11.3)	(11.1,11.2, 11.3,11.4, 11.5,11.6)	(11.1)	(11.2)
Structured
	1	1	(1.)	(1.1, 1.2, 1.3)	(1.1, 1.2, 1.3, 1.4, 1.5, 1.6)	(1.1)	(1.2)
	2	2	(2.)	(2.1, 2.2, 2.3)	(2.1, 2.2, 2.3, 2.4, 2.5, 2.6)	(2.1)	(2.2)
	3	3	(3.)	(3.1, 3.2, 3.3)	(3.1, 3.2, 3.3, 3.4, 3.5, 3.6)	(3.1)	(3.2)
	4	4	(4.)	(4.1, 4.2, 4.3)	(4.1, 4.2, 4.3, 4.4, 4.5, 4.6)	(4.1)	(4.2)
	5	5	(5.)	(5.1, 5.2, 5.3)	(5.1, 5.2, 5.3, 5.4, 5.5, 5.6)	(5.1)	(5.2)
	6	6	(6.)	(6.1, 6.2, 6.3)	(6.1, 6.2, 6.3, 6.4, 6.5, 6.6)	(6.1)	(6.2)
	7	7	(7.)	(7.1, 7.2, 7.3)	(7.1, 7.2, 7.3, 7.4, 7.5, 7.6)	(7.1)	(7.2)
	8	8	(8.)	(8.1, 8.2, 8.3)	(8.1, 8.2, 8.3, 8.4, 8.5, 8.6)	(8.1)	(8.2)
	9	9	(9.)	(9.1, 9.2, 9.3)	(9.1, 9.2, 9.3, 9.4, 9.5, 9.6)	(9.1)	(9.2)
	10	10	(10.)	(10.1,10.2,10.3)	(10.1,10.2, 10.3,10.4, 10.5,10.6)	(10.1)	(10.2)
	11	11	(11.)	(11.1,11.2,11.3)	(11.1,11.2, 11.3,11.4, 11.5,11.6)	(11.1)	(11.2)
	12	12	(12.)	(12.1,12.2,12.3)	(12.1,12.2, 12.3,12.4, 12.5,12.6)	(12.1)	(12.2)

Example 10.8: Per_node (Scalar) Variable Example 1

This shows an ASCII scalar file (engold.Nsca) for the gold geometry example.

Per_node scalar values for the EnSight Gold geometry example
part
        
        1
coordinates 
 1.00000E+00
 3.00000E+00
 4.00000E+00
 5.00000E+00
 6.00000E+00
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
part
        2
coordinates 
 1.00000E+00
 2.00000E+00
part
        3
block
 1.00000E+00
 2.00000E+00
 3.00000E+00
 4.00000E+00
 5.00000E+00
 6.00000E+00
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
 1.20000E+01

Example 10.9: Per_node (Vector) Variable Example 2

This example shows an ASCII vector file (engold.Nvec) for the gold geometry example.

Per_node vector values for the EnSight Gold geometry example

Per_node vector values for the EnSight Gold geometry example
part

1
coordinates 
 1.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
 1.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
 1.30000E+00
 3.30000E+00
 4.30000E+00
 5.30000E+00
 6.30000E+00
 7.30000E+00
 8.30000E+00
 9.30000E+00
 1.03000E+01
 1.13000E+01
part                
        2
coordinates 
 1.10000E+00
 2.10000E+00
 1.20000E+00
 2.20000E+00
 1.30000E+00
 2.30000E+00
part
        3
block
 1.10000E+00
 2.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
 1.21000E+01
 1.20000E+00
 2.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
 1.22000E+01
 1.30000E+00
 2.30000E+00
 3.30000E+00
 4.30000E+00
 5.30000E+00
 6.30000E+00
 7.30000E+00
 8.30000E+00
 9.30000E+00
 1.03000E+01
 1.13000E+01
 1.23000E+01

Example 10.10: Per_node (Tensor) Variable Example 3

This example shows an ASCII 2nd order symmetric tensor file (engold.Nten) for the gold geometry example.

Per_node symmetric tensor values for the EnSight Gold geometry example
part
        1
coordinates 
 1.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
 1.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
 1.30000E+00
 3.30000E+00
 4.30000E+00
 5.30000E+00
 6.30000E+00
 7.30000E+00
 8.30000E+00
 9.30000E+00
 1.03000E+01
 1.13000E+01
 1.40000E+00
 3.40000E+00
 4.40000E+00
 5.40000E+00
 6.40000E+00
 7.40000E+00
 8.40000E+00
 9.40000E+00
 1.04000E+01
 1.14000E+01
 1.50000E+00
 3.50000E+00
 4.50000E+00
 5.50000E+00
 6.50000E+00
 7.50000E+00
 8.50000E+00
 9.50000E+00
 1.05000E+01
 1.15000E+01
 1.60000E+00
 3.60000E+00
 4.60000E+00
 5.60000E+00
 6.60000E+00
 7.60000E+00
 8.60000E+00
 9.60000E+00
 1.06000E+01
 1.16000E+01
part
        2
coordinates
 1.10000E+00
 2.10000E+00
 1.20000E+00
 2.20000E+00
 1.30000E+00
 2.30000E+00
 1.40000E+00
 2.40000E+00
 1.50000E+00
 2.50000E+00
 1.60000E+00
 2.60000E+00
part
        3
block
 1.10000E+00
 2.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
 1.21000E+01
 1.20000E+00
 2.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
 1.22000E+01
 1.30000E+00
 2.30000E+00
 3.30000E+00
 4.30000E+00
 5.30000E+00
 6.30000E+00
 7.30000E+00
 8.30000E+00
 9.30000E+00
 1.03000E+01
 1.13000E+01
 1.23000E+01
 1.40000E+00
 2.40000E+00
 3.40000E+00
 4.40000E+00
 5.40000E+00
 6.40000E+00
 7.40000E+00
 8.40000E+00
 9.40000E+00
 1.04000E+01
 1.14000E+01
 1.24000E+01
 1.50000E+00
 2.50000E+00
 3.50000E+00
 4.50000E+00
 5.50000E+00
 6.50000E+00
 7.50000E+00
 8.50000E+00
 9.50000E+00
 1.05000E+01
 1.15000E+01
 1.25000E+01
 1.60000E+00
 2.60000E+00
 3.60000E+00
 4.60000E+00
 5.60000E+00
 6.60000E+00
 7.60000E+00
 8.60000E+00
 9.60000E+00
 1.06000E+01
 1.16000E+01
 1.26000E+01

Example 10.11: Per_node (Complex) Variable Example 4

This example shows ASCII complex real (engold.Ncmp_r) and imaginary (engold.Ncmp_i) scalar files for the gold geometry example. (The same methodology would apply for complex real and imaginary vector files.)

Real scalar File:

Per_node complex real scalar values for the EnSight Gold geometry example
part
        1
coordinates
 1.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
part
        2
coordinates
 1.10000E+00
 2.10000E+00
part        
        3
block
 1.10000E+00
 2.10000E+00
 3.10000E+00
 4.10000E+00
 5.10000E+00
 6.10000E+00
 7.10000E+00
 8.10000E+00
 9.10000E+00
 1.01000E+01
 1.11000E+01
 1.21000E+01

Imaginary scalar File:

Per_node complex imaginary scalar values for the EnSight Gold geometry example
part
        1
coordinates
 1.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
part
        2
coordinates
 1.20000E+00
 2.20000E+00
part
        3
block
 1.20000E+00
 2.20000E+00
 3.20000E+00
 4.20000E+00
 5.20000E+00
 6.20000E+00
 7.20000E+00
 8.20000E+00
 9.20000E+00
 1.02000E+01
 1.12000E+01
 1.22000E+01

10.2.11. EnSight Gold Per_Element Variable File Format

EnSight Gold variable files for per_element variables contain values for each element of designated types of designated Parts. First comes a single description line. Second comes a Part line. Third comes a line containing the part number. Fourth comes an element type line and then comes the value for each element of that type and part. If it is a scalar variable, there is one value per element, while for vector variables there are three values per element. (The number of elements of the given type are obtained from the corresponding EnSight Gold geometry file.)

Note: If the geometry of given part is empty, nothing for that part needs to be in the variable file.

C Binary Form

SCALAR FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
element type                                      80 chars
s_e1 s_e2 ... s_ne                                ne floats
element type                                      80 chars
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = (i-1)*(j-1)*(k-1)     80 chars 
s_n1 s_n2 ... s_nn                                nn floats

VECTOR FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
element type                                      80 chars
vx_e1 vx_e2 ... vx_ne                             ne floats
vy_e1 vy_e2 ... vy_ne                             ne floats
vz_e1 vz_e2 ... vz_ne                             ne floats
element type                                      80 chars
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = (i-1)*(j-1)*(k-1)     80 chars 
vx_n1 vx_n2 ... vx_nn                             nn floats
vy_n1 vy_n2 ... vy_nn                             nn floats
vz_n1 vz_n2 ... vz_nn                             nn floats

TENSOR FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
element type                                      80 chars
v11_e1 v11_e2 ... v11_ne                          ne floats
v22_e1 v22_e2 ... v22_ne                          ne floats
v33_e1 v33_e2 ... v33_ne                          ne floats
v12_e1 v12_e2 ... v12_ne                          ne floats
v13_e1 v13_e2 ... v13_ne                          ne floats
v23_e1 v23_e2 ... v23_ne                          ne floats
element type                                      80 chars
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = (i-1)*(j-1)*(k-1)     80 chars 
v11_n1 v11_n2 ... v11_nn                          nn floats
v22_n1 v22_n2 ... v22_nn                          nn floats
v33_n1 v33_n2 ... v33_nn                          nn floats
v12_n1 v12_n2 ... v12_nn                          nn floats
v13_n1 v13_n2 ... v13_nn                          nn floats
v23_n1 v23_n2 ... v23_nn                          nn floats

TENSOR9 FILE:

description line 1                                    80 chars
part                                                  80 chars
#                                                     1 int
element type                                          80 chars
v11_e1 v11_e2 ... v11_ne                              ne floats
v12_e1 v12_e2 ... v12_ne                              ne floats
v13_e1 v13_e2 ... v13_ne                              ne floats
v21_e1 v21_e2 ... v21_ne                              ne floats
v22_e1 v22_e2 ... v22_ne                              ne floats
v23_e1 v23_e2 ... v23_ne                              ne floats
v31_e1 v31_e2 ... v31_ne                              ne floats
v_e1 v_e2 ... v_ne                                    ne floats
v33_e1 v33_e2 ... v33_ne                              ne floats
element type                                          80 chars

COMPLEX SCALAR FILES (Real and/or Imaginary):

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
element type                                      80 chars
s_e1 s_e2 ... s_ne                                ne floats
element type                                      80 chars
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = (i-1)*(j-1)*(k-1)     80 chars 
s_n1 s_n2 ... s_nn                                nn floats

COMPLEX VECTOR FILES (Real and/or Imaginary):

description line 1                                 80 chars
part                                               80 chars
#                                                  1 int
element type                                       80 chars
vx_e1 vx_e2 ... vx_ne                              ne floats
vy_e1 vy_e2 ... vy_ne                              ne floats
vz_e1 vz_e2 ... vz_ne                              ne floats
element type                                       80 chars
.
.
part                                               80 chars
.
.
part                                              80 chars
#                                                 1 int
block                # nn = (i-1)*(j-1)*(k-1)     80 chars 
vx_n1 vx_n2 ... vx_nn                             nn floats
vy_n1 vy_n2 ... vy_nn                             nn floats
vz_n1 vz_n2 ... vz_nn                             nn floats

Fortran Binary Form

SCALAR FILE:

‘description line 1’                               80 chars
‘part’                                             80 chars
‘#’                                                1 int
‘element type’                                     80 chars
‘s_e1 s_e2 ... s_ne’                               ne floats
‘element type’                                     80 chars
.
.
‘part’                                             80 chars
.
.
‘part’                                             80 chars
‘#’                                                1 int
‘block’              # nn = (i-1)*(j-1)*(k-1)      80 chars 
‘s_n1 s_n2 ... s_nn’                               nn floats

VECTOR FILE:

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘element type‘                                    80 chars
‘vx_e1 vx_e2 ... vx_ne’                           ne floats
‘vy_e1 vy_e2 ... vy_ne’                           ne floats
‘vz_e1 vz_e2 ... vz_ne’                           ne floats
‘element type’                                    80 chars
.
.
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’              # nn = (i-1)*(j-1)*(k-1)     80 chars 
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats

TENSOR FILE:

‘description line 1’                               80 chars
‘part’                                             80 chars
‘#’                                                1 int
‘element type‘                                     80 chars
‘v11_e1 v11_e2 ... v11_ne’                         ne floats
‘v22_e1 v22_e2 ... v22_ne’                         ne floats
‘v33_e1 v33_e2 ... v33_ne’                         ne floats
‘v12_e1 v12_e2 ... v12_ne’                         ne floats
‘v13_e1 v13_e2 ... v13_ne’                         ne floats
‘v23_e1 v23_e2 ... v23_ne’                         ne floats
‘element type’                                     80 chars
.
.
‘part’                                             80 chars
.
.
‘part’                                             80 chars
‘#’                                                1 int
‘block’              # nn = (i-1)*(j-1)*(k-1)      80 chars 
‘v11_n1 v11_n2 ... v11_nn’                         nn floats
‘v22_n1 v22_n2 ... v22_nn’                         nn floats
‘v33_n1 v33_n2 ... v33_nn’                         nn floats
‘v12_n1 v12_n2 ... v12_nn’                         nn floats
‘v13_n1 v13_n2 ... v13_nn’                         nn floats
‘v23_n1 v23_n2 ... v23_nn’                         nn floats

TENSOR9 FILE:

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘element type‘                                    80 chars
‘v11_e1 v11_e2 ... v11_ne’                        ne floats
‘v12_e1 v12_e2 ... v12_ne’                        ne floats
‘v13_e1 v13_e2 ... v13_ne’                        ne floats
‘v21_e1 v21_e2 ... v21_ne’                        ne floats
‘v22_e1 v22_e2 ... v22_ne’                        ne floats
‘v23_e1 v23_e2 ... v23_ne’                        ne floats
‘v31_e1 v31_e2 ... v31_ne’                        ne floats
‘v_e1 v_e2 ... v_ne’                              ne floats
‘v33_e1 v33_e2 ... v33_ne’                        ne floats
‘element type’                                    80 chars
.
.
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’              # nn = (i-1)*(j-1)*(k-1)     80 chars 
‘v11_n1 v11_n2 ... v11_nn’                        nn floats
‘v12_n1 v12_n2 ... v12_nn’                        nn floats
‘v13_n1 v13_n2 ... v13_nn’                        nn floats
‘v21_n1 v21_n2 ... v21_nn’                        nn floats
‘v22_n1 v22_n2 ... v22_nn’                        nn floats
‘v23_n1 v23_n2 ... v23_nn’                        nn floats
‘v31_n1 v31_n2 ... v31_nn’                        nn floats
‘v_n1 v_n2 ... v_nn’                              nn floats
‘v33_n1 v33_n2 ... v33_nn’                        nn floats

COMPLEX SCALAR FILES (Real and/or Imaginary):

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘element type’                                    80 chars
‘s_e1 s_e2 ... s_ne’                              ne floats
‘element type’                                    80 chars
.
.
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’         # nn = (i-1)*(j-1)*(k-1)          80 chars
s_n1 s_n2 ... s_nn’                               nn floats

COMPLEX VECTOR FILES (Real and/or Imaginary):

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘element type‘                                    80 chars
‘vx_e1 vx_e2 ... vx_ne’                           ne floats
‘vy_e1 vy_e2 ... vy_ne’                           ne floats
‘vz_e1 vz_e2 ... vz_ne’                           ne floats
‘element type’                                    80 chars
.
.
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’              # nn = (i-1)*(j-1)*(k-1)     80 chars 
‘vx_n1 vx_n2 ... vx_nn’                           nn floats
‘vy_n1 vy_n2 ... vy_nn’                           nn floats
‘vz_n1 vz_n2 ... vz_nn’                           nn floats

ASCII Form

SCALAR FILE:

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
element type                                      A
s_e1                                              12.5  1/line (ne)
s_e2
.
.
s_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block               # nn = (i-1)*(j-1)*(k-1)      A
s_n1                                              E12.5  1/line (nn)
s_n2
.
.
s_nn

VECTOR FILE:

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
element type                                      A
vx_e1                                             E12.5  1/line (ne)
vx_e2
.
.
vx_ne
vy_e1                                             E12.5  1/line (ne)
vy_e2
.
.
vy_ne
vz_e1                                             E12.5  1/line (ne)
vz_e2
.
.
vz_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block                # nn = (i-1)*(j-1)*(k-1)     A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn

TENSOR FILE:

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
element type                                      A
v11_e1                                            E12.5  1/line (ne)
v11_e2
.
.
v11_ne
v22_e1                                            E12.5  1/line (ne)
v22_e2
.
.
v22_ne
v33_e1                                            E12.5  1/line (ne)
v33_e2
.
.
v33_ne
v12_e1                                            E12.5  1/line (ne)
v12_e2
.
.
v12_ne
v13_e1                                            E12.5  1/line (ne)
v13_e2
.
.
v13_ne
v23_e1                                            E12.5  1/line (ne)
v23_e2
.
.
v23_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block                # nn = (i-1)*(j-1)*(k-1)     A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn

TENSOR9 FILE:

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
element type                                      A
v11_e1                                            E12.5  1/line (ne)
v11_e2
.
.
v11_ne
v12_e1                                            E12.5  1/line (ne)
v12_e2
.
.
v12_ne
v13_e1                                            E12.5  1/line (ne)
v13_e2
.
.
v13_ne
v21_e1                                            E12.5  1/line (ne)
v21_e2
.
.
v21_ne
v22_e1                                            E12.5  1/line (ne)
v22_e2
.
.
v22_ne
v23_e1                                            E12.5  1/line (ne)
v23_e2
.
.
v23_ne
v31_e1                                            E12.5  1/line (ne)
v31_e2
.
.
v31_ne
v_e1                                              E12.5  1/line (ne)
v_e2
.
.
v_ne
v33_e1                                            E12.5  1/line (ne)
v33_e2
.
.
v33_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block                # nn = (i-1)*(j-1)*(k-1)     A
v11_n1                                            E12.5  1/line (nn)
v11_n2
.
.
v11_nn
v12_n1                                            E12.5  1/line (nn)
v12_n2
.
.
v12_nn
v13_n1                                            E12.5  1/line (nn)
v13_n2
.
.
v13_nn
v21_n1                                            E12.5  1/line (nn)
v21_n2
.
.
v21_nn
v22_n1                                            E12.5  1/line (nn)
v22_n2
.
.
v22_nn
v23_n1                                            E12.5  1/line (nn)
v23_n2
.
.
v23_nn
v31_n1                                            E12.5  1/line (nn)
v31_n2
.
.
v31_nn
v_n1                                              E12.5  1/line (nn)
v_n2
.
.
v_nn
v33_n1                                            E12.5  1/line (nn)
v33_n2
.
.
v33_nn

COMPLEX SCALAR FILES (Real and/or Imaginary):

description line 1                                 A (max of 80 typ)
part                                               A
#                                                  I10
element type                                       A
s_e1                                               12.5  1/line (ne)
s_e2
.
.
s_ne
element type                                       A  
.
.
part                                               A
.
.
part                                               A
#                                                  I10
block               # nn = (i-1)*(j-1)*(k-1)       A
s_n1                                               E12.5  1/line (nn)
s_n2
.
.
s_nn

COMPLEX VECTOR FILES (Real and/or Imaginary):

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
element type                                      A
vx_e1                                             E12.5  1/line (ne)
vx_e2
.
.
vx_ne
vy_e1                                             E12.5  1/line (ne)
vy_e2
.
.
vy_ne
vz_e1                                             E12.5  1/line (ne)
vz_e2
.
.
vz_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block                # nn = (i-1)*(j-1)*(k-1)     A
vx_n1                                             E12.5  1/line (nn)
vx_n2
.
.
vx_nn
vy_n1                                             E12.5  1/line (nn)
vy_n2
.
.
vy_nn
vz_n1                                             E12.5  1/line (nn)
vz_n2
.
.
vz_nn

The following variable file examples reflect scalar, vector, tensor, and complex variable values per element for the previously defined EnSight Gold Geometry File Example with 11 defined unstructured nodes and a 2x3x2 structured Part (Part number 3). The values are summarized in the following table

Note: These are the same values as listed in the EnSight6 per_element variable file section. Subsequently, the following example files contain the same data as the example files in the EnSight6 section - only they are listed in gold format. (No asymmetric tensor example data given)

						Complex Scalar
	Element	Element	Scalar	Vector	Tensor (2nd order symm.)	Real	Imaginary
	Index	Id	Value	Values	Values	Value	Value
Unstructured
bar2
	1	101	(1.)	(1.1, 1.2, 1.3)	(1.1, 1.2, 1.3, 1.4, 1.5, 1.6)	(1.1)	(1.2)
tria3
	1	102	(2.)	(2.1, 2.2, 2.3)	(2.1, 2.2, 2.3, 2.4, 2.5, 2.6)	(2.1)	(2.2)
	2	103	(3.)	(3.1, 3.2, 3.3)	(3.1, 3.2, 3.3, 3.4, 3.5, 3.6)	(3.1)	(3.2)
hexa8
	1	104	(4.)	(4.1, 4.2, 4.3)	(4.1, 4.2, 4.3, 4.4, 4.5, 4.6)	(4.1)	(4.2)
Structured
block	1	1	(5.)	(5.1, 5.2, 5.3)	(5.1, 5.2, 5.3, 5.4, 5.5, 5.6)	(5.1)	(5.2)

Example 10.12: Per_element (Scalar) Variable Example 1

This example shows an ASCII scalar file (engold.Esca) for the gold geometry example.

Per_elem scalar values for the EnSight Gold geometry example
part
        1
tria3
 2.00000E+00
 3.00000E+00
hexa8 
 4.00000E+00
part
        2
bar2
 1.00000E+00
part
        3
block
 5.00000E+00
 6.00000E+00

Example 10.13: Per_element (Vector) Variable Example 2

This example shows an ASCII vector file (engold.Evec) for the gold geometry example.

Per_elem vector values for the EnSight Gold geometry example
part
        1
tria3
 2.10000E+00
 3.10000E+00
 2.20000E+00
 3.20000E+00
 2.30000E+00
 3.30000E+00
hexa8
 4.10000E+00
 4.20000E+00
 4.30000E+00
part
        2
bar2
 1.10000E+00
 1.20000E+00
 1.30000E+00
part
        3
block
 5.10000E+00
 6.10000E+00
 5.20000E+00
 6.20000E+00
 5.30000E+00
 6.30000E+00

Example 10.14: Per_element (Tensor) Variable Example 3

Per_elem symmetric tensor values for the EnSight Gold geometry example
part
        1
tria3
 2.10000E+00
 3.10000E+00 
 2.20000E+00
 3.20000E+00
 2.30000E+00
 3.30000E+00
 2.40000E+00
 3.40000E+00
 2.50000E+00
 3.50000E+00
 2.60000E+00
 3.60000E+00
hexa8
 4.10000E+00
 4.20000E+00
 4.30000E+00
 4.40000E+00
 4.50000E+00
 4.60000E+00
part
        2
bar2
 1.10000E+00
 1.20000E+00
 1.30000E+00
 1.40000E+00
 1.50000E+00
 1.60000E+00
part
        3
block
 5.10000E+00
 6.10000E+00
 5.20000E+00
 6.20000E+00
 5.30000E+00
 6.30000E+00
 5.40000E+00
 6.40000E+00
 5.50000E+00
 6.50000E+00
 5.60000E+00
 6.60000E+00

Example 10.15: Per_element (Complex) Variable Example 4

This example shows ASCII complex real (engold.Ecmp_r) and imaginary (engold.Ecmp_i) scalar files for the gold geometry example. (The same methodology would apply for complex real and imaginary vector files.)

Real scalar File:

Per_elem complex real scalar values for the EnSight Gold geometry example
part
        1
tria3
 2.10000E+00
 3.10000E+00
hexa8
 4.10000E+00
part
        2
bar2
 1.10000E+00
part
        3
block
 5.10000E+00
 6.10000E+00

Imaginary scalar File:

Per_elem complex imaginary scalar values for the EnSight Gold geometry example
part
        1
tria3
 2.20000E+00
 3.20000E+00
hexa8
 4.20000E+00
part
        2
bar2
 1.20000E+00
part
        3
block
 5.20000E+00
 6.20000E+00

10.2.12. EnSight Gold Undefined Variable Values Format

Undefined variable values are allowed in EnSight Gold scalar, vector, tensor and complex variable file formats. Undefined values are specified on a per section basis (i.e. coordinates, element_type, or block) in each EnSight Gold variable file. EnSight first parses any undefined keyword undef that may follow the sectional keyword (i.e. coordinates undef, element_type undef, or block undef) on its line. This indicates that the next floating point value is the undefined value used in that section. EnSight reads this undefined value, reads all subsequent variable values for that section; and then converts any undefined (file section) values to an internal undefined value (currently -1.2345e-10) recognized computationally by EnSight

Note: The internal, or computational, undefined value can be changed by the user via the test: change_undef_value command before any data is read. EnSight's undefined capability is for variables only - not for geometry! Also, in determining internally whether a vector or tensor variable is undefined at a node or element, the first component is all that is examined. You cannot have some components defined and others undefined.

The following per_node and per_element ASCII scalar files contain examples of undefined values. For your comparison, these two files are the files engold.Nsca and engold.Esca written with some undefined values specified. Note that the undefined values per section need not be the same value; rather, it may be any value - usually outside the interval range of the variable. The same methodology applies to vector, tensor, and complex files.

C Binary Form: (Per_node)

SCALAR FILE:

description line 1                                80 chars
part                                              80 chars
#                                                  1 int
coordinates undef                                 80 chars
undef_value                                        1 float
s_n1 s_n2 ... s_nn                                nn floats
part                                              80 chars
.
.
part                                              80 chars
#                                                  1 int
block undef                # nn = i*j*k           80 chars
undef_value                                        1 float
s_n1 s_n2 ... s_nn                                nn floats

Fortran Binary Form: (Per_node)

SCALAR FILE:

‘description line 1’                               80 chars
‘part’                                             80 chars
‘#’                                                 1 int
‘coordinates undef’                                80 chars
‘undef_value’                                       1 float
‘s_n1 s_n2 ... s_nn’                               nn floats
‘part’                                             80 chars
.
.
‘part’                                             80 chars
‘#’                                                 1 int
‘block undef’                # nn = i*j*k          80 chars
‘undef_value’                                       1 float
‘s_n1 s_n2 ... s_nn’                               nn floats

ASCII Form: (Per_node)

SCALAR FILE:

description line 1                                 A (max of 79 typ)
part                                               A
#                                                  I10
coordinates undef                                  A
undef_value                                        E12.5
s_n1                                               E12.5  1/line (nn)
s_n2
.
.
s_nn
part                                               A
 .
 .
part                                               A
#                                                  I10
block undef                  # nn = i*j*k          A
undef_value                                        E12.5
s_n1                                               E12.5  1/line (nn)
s_n2
.
.
s_nn

Undefined per_node (Scalar) Variable Example: This example shows undefined data in an ASCII scalar file (engold.Nsca_u) for the gold geometry example.

Per_node undefined scalar values for the EnSight Gold geometry example
part
        1
coordinates undef
-1.00000E+04
-1.00000E+04
 3.00000E+00
 4.00000E+00
 5.00000E+00
 6.00000E+00
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
part
        2
coordinates
 1.00000E+00
 2.00000E+00
part
        3
block undef
-1.23450E-10
 1.00000E+00
 2.00000E+00
 3.00000E+00
 4.00000E+00
 5.00000E+00
-1.23450E-10
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
 1.20000E+01

C Binary Form (Per_element)

SCALAR FILE:

description line 1                                 80 chars
part                                               80 chars
#                                                   1 int
element type undef                                 80 chars
undef_value                                         1 float
s_e1 s_e2 ... s_ne                                 ne floats
element type undef                                 80 chars
undef_value                                         1 float
.
 .
part                                               80 chars
 .
 .
part                                               80 chars
#                                                   1 int
block undef          # nn = (i-1)*(j-1)*(k-1) 80 chars
undef_value                                         1 float
s_n1 s_n2 ... s_nn                                 nn floats

Fortran Binary Form (Per_element)

SCALAR FILE:

‘description line 1’                               80 chars
‘part’                                             80 chars
‘#’                                                 1 int
‘element type undef’                               80 chars
‘undef_value’                                       1 float
‘s_e1 s_e2 ... s_ne’                               ne floats
‘element type undef’                               80 chars
‘undef_value’                                       1 float
.
 .
‘part’                                              80 chars
 .
 .
‘part’                                              80 chars
‘#’                                                  1 int
‘block undef’         # nn = (i-1)*(j-1)*(k-1)      80 chars
‘undef_value’                                        1 float
‘s_n1 s_n2 ... s_nn’                                nn floats

ASCII Form (Per_element)

SCALAR FILE:

description line 1                                  A (max of 80 typ)
part                                                A
#                                                   I10
element type undef                                  A
undef_value                                         E12.5
s_e1                                                E12.5  1/line (ne)
s_e2
 .
 .
s_ne
element type undef                                  A
undef_value                                         E12.5
 .
 .
part                                                A
 .
 .
part                                                A
#                                                   I10
block undef         # nn = (i-1)*(j-1)*(k-1)        A undef_value                               
         E12.5
s_n1                                                E12.5  1/line (nn)
s_n2
 .
.
 s_nn

Undefined per_element (Scalar) Variable Example: This example shows undefined data in an ASCII scalar file (engold.Esca_u) for the gold geometry example.

Per_elem undefined scalar values for the EnSight Gold geometry example
part
        1
tria3 undef
-1.00000E+02
 2.00000E+00
-1.00000E+02
hexa8
 4.00000E+00
part
        2
bar2
 1.00000E+00
part
        3
block undef
-1.23450E-10
-1.23450E-10
 6.00000E+00

10.2.13. EnSight Gold Partial Variable Values Format

Partial variable values are allowed in EnSight Gold scalar, vector, tensor and complex variable file formats. Partial values are specified on a "per section" basis (i.e. coordinates, element_type, or block) in each EnSight Gold variable file. EnSight first parses any partial keyword "partial" that may follow the sectional keyword (i.e. coordinates partial, element_type partial, or block partial) on its line. This indicates that the next integer value is the number of partial values defined in that section. EnSight reads the number of defined partial values, next reads this number of integer partial indices, and finally reads all corresponding partial variable values for that section. Afterwords, any variable value not specified in the list of partial indices is assigned the internal undefined (see previous section) value. Values interpolated between time steps must be defined for both time steps; otherwise, they are undefined.

The following per_node and per_element ASCII scalar files contain examples of partial values. For your comparison, these two files are the files engold.Nsca and engold.Esca written with some partial values specified. The same methodology applies to vector, tensor, and complex files.

C Binary Form (Per_node)

SCALAR FILE:

description line 1                                  80 chars
part                                                80 chars
#                                                    1 int
coordinates partial                                 80 chars
nn                                                   1 int
i_n1 i_n2 ... i_nn                                  nn  ints
s_n1 s_n2 ... s_nn                                  nn floats
part                                                80 chars
.
.
part                                                80 chars
#                                                    1 int
block partial                # nn = i*j*k           80 chars
nn                                                   1 int
i_n1 i_n2 ... i_nn                                  nn  ints
s_n1 s_n2 ... s_nn                                  nn floats

Fortran Binary Form (Per_node)

SCALAR FILE:

‘description line 1’                                80 chars
‘part’                                              80 chars
‘#’                                                  1 int
‘coordinates partial’                               80 chars
‘nn’                                                 1 int
‘i_n1 i_n2 ... i_nn’                                nn ints
‘s_n1 s_n2 ... s_nn’                                nn floats
‘part’                                              80 chars
 .
‘part’                                              80 chars
‘#’                                                  1 int
‘block partial’                # nn = i*j*k         80 chars
‘nn’                                     1 int
‘i_n1 i_n2  ...  i_nn’                              nn ints
‘s_n1 s_n2 ... s_nn’                                nn floats

ASCII Form (Per_node)

SCALAR FILE:

description line 1                                  A (max of 79 typ)
part                                                A
#                                                   I10
coordinates partial                                 A
nn                                                  I10
i_n1                                                I10  1/line (nn)
i_n2
 .
 .
i_nn
s_n1                                                E12.5  1/line (nn)
s_n2
 .
 .
s_nn
part                                                A
 .
 .
part                                                A
#                                                   I10
block partial              # nn = i*j*k             A
nn                                                  I10
i_n1                                                I10  1/line (nn)
i_n2
 .
 .
i_nn
s_n1                                                E12.5  1/line (nn)
s_n2
 .
 .
s_nn

Partial per_node (Scalar) Variable Example: This example shows partial data in an ASCII scalar file (engold.Nsca_p) for the gold geometry example.

Per_node partial scalar values for the EnSight Gold geometry example
part
        1
coordinates partial
        9
        2
        3
        4
        5
        6
        7
        8
        9
        10
 3.00000E+00
 4.00000E+00
 5.00000E+00
 6.00000E+00
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
part
        2
coordinates
 1.00000E+00
 2.00000E+00
part
        3
block
 1.00000E+00
 2.00000E+00
 3.00000E+00
 4.00000E+00
 5.00000E+00
 6.00000E+00
 7.00000E+00
 8.00000E+00
 9.00000E+00
 1.00000E+01
 1.10000E+01
 1.20000E+01

C Binary Form (Per_element)

SCALAR FILE:

description line 1                                  80 chars
part                                                80 chars
#                                                    1 int
element type partial                                80 chars
ne                                                   1 int
i_n1 i_n2 ... i_ne                                  ne ints
s_e1 s_e2 ... s_ne                                  ne floats
element type partial                                80 chars
ne                                                   1 int
i_n1 i_n2 ... i_ne                                  ne ints
.
.
part                                                80 chars
.
.
part                                                80 chars
#                                                    1 int
block partial           # me= (i-1)*(j-1)*(k-1)     80 chars me                                 
     1 int
i_n1 i_n2 ... i_me                                  me ints
s_n1 s_n2 ... s_me                                  me floats

Fortran Binary Form (Per_element)

SCALAR FILE:

‘description line 1’                                80 chars
‘part’                                              80 chars
‘#’                                                  1 int
‘element type partial’                              80 chars
‘ne’                                                 1 int
‘i_n1 i_n2 ... i_ne’                                ne ints
‘s_e1 s_e2 ... s_ne’                                ne floats
‘element type partial’                              80 chars
‘ne’                                                 1 int
‘i_n1 i_n2 ... i_ne’                                ne ints
.
.
‘part’                                              80 chars
.
.
‘part’                                              80 chars
‘#’                                                  1 int
‘block partial’         # me = (i-1)*(j-1)*(k-1)    80 chars ‘me’                               
      1 int
‘i_n1 i_n2 ... i_me’                                me ints
‘s_n1 s_n2 ... s_me’                                me floats

ASCII Form (Per_element)

SCALAR FILE:

description line 1                                  A (max of 80 typ)
part                                                A
#                                                   I10
element type partial                                A
ne                                                  I10
i_n1                                                I10  1/line  (ne)
i_n2
 .
 .
i_ne
s_e1                                                E12.5  1/line (ne)
s_e2
 .
 .
s_ne
element type partial                                A
ne                                                  I10
i_n1                                                I10  1/line  (ne)
i_n2
 .
 .
i_ne
 .
 .
part                                                A
 .
 .
part                                                A
#                                                   I10
block partial        # me = (i-1)*(j-1)*(k-1)       A me                                        
       I10
i_n1                                                I10  1/line  (me)
i_n2
 .
 .
i_me
s_n1                                                E12.5  1/line (me)
s_n2
 .
 .
s_me

Partial per_element (Scalar) Variable Example: This example shows partial data in an ASCII scalar file (engold.Esca_p) for the gold geometry example.

Per_elem partial scalar values for the EnSight Gold geometry example
part
        1
tria3 partial
        1
        1
 2.00000E+00
hexa8
 4.00000E+00
part
        2
bar2
 1.00000E+00
part
        3
block partial
        1
        2
 6.00000E+00

10.2.14. EnSight Gold Constant Per Part Variable Files

This section contains descriptions of the two EnSight Gold constant per part variable files; i.e. constant per part file containing the values of the constant for the different parts, which can vary over time or not - and the optional constant per part index file containing the offset index for each time step in the constant per part file. Sample files for the guard_rail dataset included in the EnSight distribution are appended for an example (use crash_with_cpp.case in place of crash.case).

EnSight constant per part file(s) are referenced on a variable line in the VARIABLE section of an EnSight Case Gold casefile, like:

VARIABLE
constant per part: [ts] name cpp_filename [cpp_index_filename]

10.2.15. Constant Per Part File

This ASCII file contains the values of the constant for listed parts, and affected timesteps. The value can stay the same or vary over time. Some parts may be assigned the constant value, while others are not. The layout of the file is as follows:

ENSIGHT_CPP_VERSION 1.0                  This must always be the first line 
                                         obviously the version number could 
                                         change in the future.

TSTEP -1                                 -1 = apply to all time steps
Nparts                                   -1 = apply to all parts
[part list]                              list of part ids to apply constant to, 
                                         required if Nparts is not -1
                                         Note: measured part is indicated with 
                                         part id 0
constant per part value                  the constant value

-- OR --

TSTEP 0
Nparts 
[part list]
constant per part value 
Nparts
[part list]
constant per part value
... 
TSTEP 1
Nparts 
[part list]
constant per part value
...
TSTEP N-1
Nparts 
[part list]
constant per part value

where: Nparts =	(int) number of parts which will be assigned the specified constant value. A value of -1 indicates that it applies to all parts (which will include the measured part if it exists).
[part list] =	(int) list of parts assigned the specified constant value. This must consist of space or comma delimited part numbers (or part number ranges, which is two part numbers separated by a dash). The part numbers are the part ids used in the geometry file. The part list will be absent if Nparts is set to -1 The part list can, and often must be on multiple lines. The maximum character length of any given line is 1024. A few samples of part lists (these will accomplish the same thing), are:
	17,1,2,3,4,15,29,30,31,32,33,34,35
	17 1 2 3 4 15 29 30 31 32 33 34 35
	17,1-4,15,29,30-35
	17 1-4 15 29-35
	If you have a measured part, and want to include it in a part list, use the number 0
constant per part value =	(float) single scalar value assigned to all listed or implied parts.
TSTEP # =	Keyword tag pertaining to the respective time set's time step. A value of -1 indicates that the following Nparts, [part list] sections will apply at all times - and thus will be the only TSTEP line in the file.

Note: Any lines within the constant per part file which have a "#" in the first column, will be treated as comments and ignored.

10.2.16. Constant Per Part Index File

This separate and optional ASCII file contains the offset values to each TSTEP line in the constant per part file. It exists to be able to more efficiently process the constant per part file, by being able to jump directly to each time step, without having to parse one's way down. For large constant per part files - containing many timesteps and many parts, the use of such a file should be considered. For smaller file sizes, little is to be gained by its use.

Note: If one uses an index file, then one should avoid editing the constant per part file, as it will invalidate the index values and have to resort to the slower parsing method.

The file format consists simply of the version string on the first line, and one line per timestep in the model. On each of those lines, in a fixed width of 16, is placed the byte offset to the beginning of each TSTEP line in the constant per part file. A sample for a 4 timestep model might look like:

ENSIGHT_CPPI_VERSION 1.0
        12
        246
        340
        434

Sample constant per part files: For the guard_rail model included in the EnSight Distribution, which is made up 15 parts and 11 timesteps. This example will add four constant per part variables. Each illustrates different effects that are possible.

First, note the additional lines in the ensight casefile (which for this sample is entitled crash_with_cpp.case) are:

FORMAT
type: ensight gold GEOMETRY
model:                   crash.geo
VARIABLE
scalar per node:          1  plastic crash.plastic_**
vector per node:          1 displacement  crash.displacement_** 
constant per part:        1 colornumber crash.colornumber
constant per part:        1 temperature  crash.temperature  crash.temperature.index 
constant per part:        1 casenumber  crash.casenumber
constant per part:        1 time  crash.time
TIME
time set:                      1
number of steps:               11
filename start number:         1
filename increment:            2
time values:                   0.0 0.0235 0.047 0.0705
                               0.094 0.1175 0.141 0.1645        
                               0.188 0.2115 0.235

Contents of the crash.colornumber file assign different values (0.0 through 5.0) to different parts, which will stay constant for all time steps:

ENSIGHT_CPP_VERSION 1.0
# apply to all time
TSTEP -1
# engine, tires, bumpers, mounts
4
1,2,10,12
0.0
# wheels, floor, guardrail
3
3,7,15
1.0
# lights
1
4
2.0
# front and read body, hood
3
5,6,11
3.0
# windshields, windows
2
8,9
4.0
# guardrail supports
2
13, 14,
5.0

Contents of the crash.casenumber file assign the value of 1.0 to all model and measured parts for all time:

ENSIGHT_CPP_VERSION 1.0
# apply to all time steps
TSTEP -1
# apply to all parts
-1
1.0

Contents of crash.time assigns a changing time value, for the 11 time steps, to all parts:

ENSIGHT_CPP_VERSION 1.0
TSTEP 0
# apply to all parts
-1
0.0
TSTEP 1
-1
0.0235
TSTEP 2
-1
0.047
TSTEP 3
-1
0.0705
TSTEP 4
-1
0.094
TSTEP 5
-1
0.1175
TSTEP 6
-1
0.141
TSTEP 7
-1
0.1645
TSTEP 8
-1
0.188
TSTEP 9
-1
0.2115
TSTEP 10
-1
0.235

Contents of crash.temperature assigns transient temperature values to different parts:

ENSIGHT_CPP_VERSION 1.0
TSTEP 0
4
1,2,10,12
0.0
3
3,7,15
1.0
1
4
2.0
3
5,6,11
3.0
2
8,9
4.0
2
13,14
5.0
TSTEP 1
4
1,2,10,12
0.1
3
3,7,15
1.1
1
4
2.1
3
5,6,11
3.1
2
8,9
4.1
2
13,14
5.1
TSTEP 2
4
1,2,10,12
0.2
3
3,7,15
1.2
1
4
2.2
3
5,6,11
3.2
2
8,9
4.2
2
13,14
5.2

TSTEP 3
4
1,2,10,12
0.3
3
3,7,15
1.3
1
4
2.3
3
5,6,11
3.3
2
8,9
4.3
2
13,14
5.3
TSTEP 4
4
1,2,10,12
0.4
3
3,7,15
1.4
1
4
2.4
3
5,6,11
3.4
2
8,9
4.4
2
13,14
5.4
TSTEP 5
4
1,2,10,12
0.5
3
3,7,15
1.5
1
4
2.5
3
5,6,11
3.5
2
8,9
4.5
2
13,14
5.5

TSTEP 6
4
1,2,10,12
0.6
3
3,7,15
1.6
1
4
2.6
3
5,6,11
3.4
2
8,9
4.4
2
13,14
5.4
TSTEP 7
4
1,2,10,12
0.7
3
3,7,15
1.7
1
4
2.7
3
5,6,11
3.3
2
8,9
4.3
2
13,14
5.3
TSTEP 8
4
1,2,10,12
0.8
3
3,7,15
1.8
1
4
2.8
3
5,6,11
3.2
2
8,9
4.2
2
13,14
5.2

TSTEP 9
4
1,2,10,12
0.9
3
3,7,15
1.9
1
4
2.9
3
5,6,11
3.1
2
8,9
4.1
2
13,14
5.1
TSTEP 10
4
1,2,10,12
0.95
3
3,7,15
1.95
1
4
2.95
3
5,6,11
3.05
2
8,9
4.05
2
13,14
5.05

Contents of crash.temperature.index file are:

Note: They are simply the byte offset to each TSTEP in the above file, with said offsets residing in a fixed16 character field.

ENSIGHT_CPPI_VERSION 1.0
        24
        258
        352
        446
        540
        634
        728
        822
        916
        1010
        1104

10.2.17. EnSight Gold Measured/Particle File Format

Changes

Measured/Particle file formats for both geometry and variables have remained unchanged since EnSight 5. The only change is the contents of EnSight 5 results file (.mea suffix) containing geometry and variable filenames and time values are now entered directly into the EnSight Gold Case file.

While the format of a Measured/Particle geometry file is exactly the same as the EnSight 5& 6 geometry file, it is repeated below for convenience:

Line 1
This line is a description line.
Line 2
Indicates that this file contains particle coordinates. The words particle coordinates should be entered on this line without the quotes.
Line 3
Specifies the number of Particles.
Line 4 through the end of the file.
Each line contains the ID and the X, Y, and Z coordinates of each Particle. The format of this line is integer real real real written out in the following format:

From C: %8d%12.5e%12.5e%12.5e format

From FORTRAN: i8, 3e12.5 format

A generic measured/Particle geometry file is as follows:

A description line
particle coordinates
#_of_Particles
id xcoord ycoord zcoord
id xcoord ycoord zcoord
id xcoord ycoord zcoord
 .
 .
 .

Measured Geometry Example

The following illustrates a measured/Particle file with seven points:

This is a simple measured geometry file
particle coordinates
          7
          101 0.00000E+00 0.00000E+00 0.00000E+00
          102 1.00000E+00 0.00000E+00 0.00000E+00
          103 1.00000E+00 1.00000E+00 0.00000E+00
          104 0.00000E+00 1.00000E+00 0.00000E+00
          205 5.00000E-01 0.00000E+00 2.00000E+00
          206 5.00000E-01 1.00000E+00 2.00000E+00
          307 0.00000E+00 0.00000E+00-1.50000E+00

Measured Variable Files

Measured variable files have remained unchanged since EnSight 5.

The particle variable file is also the same as EnSight6 case per_node variable files.

Note: They are NOT the same as the EnSight gold per_node variable files. EnSight6 Per_Node Variable File Format

10.2.18. EnSight Gold Material Files Format

This section contains descriptions of the three EnSight Gold material files; i.e. material id file, mixed-material id file, and mixed-material values file. A simple example dataset is also appended for quick reference.

All three EnSight Gold material files correlate to and follow the same syntax of the other EnSight Gold file formats.

10.2.19. Material Id File

The material id file follows the same syntax as the per_element variable files, except that its values are integers for each element of designated types of designated parts. First comes a single description line. Second comes a Part line. Third comes a line containing the part number. Fourth comes an element type line

Note: This is the only material file that has an element type line. And then comes the corresponding integer value for each element of that type and part (and so on for each part.

The integer value is either positive or negative. A positive integer is the material number/id for the entire element. A negative integer indicates that this element is composed of multiple, or mixed, materials. The absolute value of this negative number is a relative (1-bias) index into the mixed ids file that points to the mixed material data for each element under its part (see example below).

10.2.20. Mixed (Material) Ids File

The mixed-material id file also contains integer values, and follows EnSight Gold syntax with exceptions as noted below. First comes a single description line. Second comes a Part line. Third comes a line containing the part number. Fourth comes a mixed ids keyword line. Fifth comes the size of the total mixed id array for all the mixed elements of this part. Next comes the mixed id element data for each of the elements with mixed materials for this part (and so on for each part).

The mixed id data for each of the mixed elements has the following order of syntax. First comes the number of mixed materials. Second comes a list of material ids that comprise that element. Next comes a negative number whose absolute value is a relative (1-bias) index into the mixed values file that points to the group of mixed-material fraction values that correspond to each listed material of that element under its part (see example below).

10.2.21. Mixed (Material) Values File

The mixed-material values file contains float values, and also follows EnSight Gold syntax with exceptions as noted below. First comes a single description line. Second comes a Part line. Third comes a line containing the part number. Fourth comes a mixed elements keyword line. Fifth comes the size of the total mixed values array for all the mixed elements of this part. Next comes the mixed material fraction values whose order corresponds to the order of the material ids listed for that element in the mixed ids file.

10.2.22. Species (Element) Values File

This is the same as the Mixed (Material) Values file except replace mixed values with species values and mixval with spval.

10.2.23. Materials via Per Element Scalar Variables

Materials defined by per element scalar variables are specified in the case file under the MATERIAL section. The per element scalar files are the same format as defined under the variable files subsection for scalar variable per element.

C Binary Form

MATERIAL ID FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
element type                                      80 chars
matid_e1 matid_e2 ... matid_ne                    ne ints
element type                                      80 chars
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
block     # nbe = (i-1)*(j-1)*(k-1)               80 chars
matid_e1 matid_e2 ... matid_nbe                   nbe ints

MIXED IDS FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
mixed ids                                         80 chars
ni                                                1 int
mixid_1 mixid_2 ... mixid_ni                      ni ints
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
mixed ids                                         80 chars
ni                                                1 int
mixid_1 mixid_2 ... mixid_ni                      ni ints

MIXED VALUES FILE:

description line 1                                80 chars
part                                              80 chars
#                                                 1 int
mixed values                                      80 chars
nf                                                1 int
mixval_1 mixval_2 ... mixval_nf                   nf floats
.
.
part                                              80 chars
.
.
part                                              80 chars
#                                                 1 int
mixed values                                      80 chars
nf                                                1 int
mixval_1 mixval_2 ... mixval_nf                   nf floats

SPECIES VALUES FILE:

same as Mixed Values File above except...
replace “mixed values” with “species values”
and “mixval” with “spval”

MATERIALS VIA PER ELEMENT SCALAR VARIABLES:

same as under EnSight Gold Per-Element Variable File Format

Fortran Binary Form

MATERIAL ID FILE:

‘description line 1’                              80 chars
‘part’                                            80 chars
‘#’                                               1 int
‘element type’                                    80 chars
‘matid_e1 matid_e2 ... matid_ne’                  ne ints
‘element type’                                    80 chars
.
.
‘part’                                            80 chars
.
.
‘part’                                            80 chars
‘#’                                               1 int
‘block’   # nbe = (i-1)*(j-1)*(k-1)               80 chars
‘matid_e1 matid_e2 ... matid_nbe’                 nbe ints

MIXED IDS FILE:

‘description line 1’                               80 chars
‘part’                                             80 chars
‘#’                                                1 int
‘mixed ids’                                        80 chars
‘ni’                                               1 int
‘mixid_1 mixid_2 ... mixid_ni’                     ni ints
.
.
‘part’                                             80 chars
.
.
‘part’                                             80 chars
‘#’                                                1 int
‘mixed ids’                                        80 chars
‘ni’                                               1 int
‘mixid_1 mixid_2 ... mixid_ni’                     ni ints

MIXED VALUES FILE:

‘description line 1’                                80 chars
‘part’                                              80 chars
‘#’                                                 1 int
‘mixed values’                                      80 chars
‘nf’                                                1 int
‘mixval_1 mixval_2 ... mixval_nf’                   nf floats
.
.
‘part’                                              80 chars
.
.
‘part’                                              80 chars
 ‘#’                                                 1 int
‘mixed values’                                      80 chars
‘nf’                                                1 int
‘mixval_1 mixval_2 ... mixval_nf’                   nf floats

SPECIES VALUES FILE:

same as Mixed Values File above except...
replace “mixed values” with “species values”
and “mixval” with “spval”

MATERIALS VIA PER ELEMENT SCALAR VARIABLES:

same as under EnSight Gold Per-Element Variable File Format

ASCII Form

MATERIAL ID FILE:

description line 1                                A (max of 79 typ)
part                                              A
#                                                 I10
element type                                      A
matid_e1                                          I10 1/line (ne)
matid_e2
...
matid_ne
element type                                      A
.
.
part                                              A
.
.
part                                              A
#                                                 I10
block     # nbe = (i-1)*(j-1)*(k-1)               A
matid_e1                                          I10 1/line (nbe)
matid_e2
matid_nbe

MIXED IDS FILE:

description line 1                                A (max of 79 typ)
part                                              A
#                                                 I10
mixed ids                                         A
ni                                                I10
mixid_1                                           I10 1/line (ni)
mixid_2
...
mixid_ni . .
part                                              A
.
.
part                                              A
#                                                 I10
mixed ids                                         A
ni                                                I10
mixid_1                                           I10 1/line (ni)
mixid_2
mixid_ni

MIXED VALUES FILE:

description line 1                                A (max of 80 typ)
part                                              A
#                                                 I10
mixed values                                      A
nf                                                I10
mixval_1                                          E12.5 1/line (nf)
mixval_2
...
mixval_nf
.
.
part                                              A
.
.
part                                              A
#                                                 I10
mixed values                                      A
nf                                                I10
mixval_1                                          E12.5 1/line (nf)
mixval_2
mixval_nf

SPECIES VALUES FILE:

same as Mixed Vaues File above except...
replace “mixed values” with “species values”
and “mixval” with “spval”

MATERIALS VIA PER ELEMENT SCALAR VARIABLES:

same as under EnSight Gold Per-Element Variable File Format

10.2.24. Example Material Dataset (Without Species)

The following example dataset of ASCII EnSight Gold geometry and material files show the definition of material fractions for an unstructured model.

Figure 10.2: Geometry for Example Material Dataset/Materials for Example Material Dataset

Case file

# Sample Case File for 2D Material Dataset
# Created: 03Apr03:mel

# FORMAT
type:  ensight gold
GEOMETRY
model:                    zmat2d.geo
VARIABLE
scalar per node:          scalar zmat2d.sca
MATERIAL
material set number:      1 Mat1 
material id count:        2
material id numbers:      3 6
material id names:        matl_3 mat1_6  #Air H2O 
material id per element:  zmat2d.mati
material mixed ids:       zmat2d.mixi 
material mixed values:    zmat2d.mixv
#        y
#
#        ^
#        |  Case Material ids = {3,6}
#
#   6.   7-----------8-----------9
#        |          /|\          |
#        |         / | \         |
#        |    e2  /  |  \ e3     |
#        |       /   |   \       |
#        |      /    |    \      |
#        |    q0     |    q1     |
#        |    /      |      \    |
#        |  {.5,.5}  |  {.5,.5}  |
#        |  /        |        \  |
#        | /         |         \ |
#        |/          |          \|
#   3.   4-----------5-----------6
#        |\          |          /|
#        | \ {0.,1.} |         / |
#        |  \        |    e4  /  |
#        |   \   t1  |       /   |
#        |    \      |      /    |
#        |  e0 \ e1  |    q2     |
#        |      \    |    /      |
#        |  t0   \   |  {.5,.5}  |
#        |        \  |  /        |
#        | {1.,0.} \ | /         |
#        |          \|/          |
#   0.   1-----------2-----------3 -> x
#
         0.          3.          6.

Geometry File (zmat2d.geo)

Geometry file
Example 2D Material Dataset 
node id given
element id given 
part
         1
2d-mesh
coordinates
         9
         1
         2
         3
         4
         5
         6
         7
         8
         9
 0.00000e+00
 3.00000e+00
 6.00000e+00
 0.00000e+00
 3.00000e+00
 6.00000e+00
 0.00000e+00
 3.00000e+00
 6.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 3.00000e+00
 3.00000e+00
 3.00000e+00
 6.00000e+00
 6.00000e+00
 6.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
 0.00000e+00
tria3
         2
         0
         1
         1 2 4
         2 5 4
quad4
         3
         2
         3
         4
         4 5 8 7
         8 5 6 9
         2 3 6 5

Scalar File (zmat2d.sca)

Scalar File
part
         1
coordinates
 0.00000e+00
 1.00000e+00
 2.00000e+00
 1.00000e+00
 2.00000e+00
 3.00000e+00
 2.00000e+00
 3.00000e+00
 4.00000e+00

10.2.25. Example Material Dataset (With Species)

Same as previous Material Dataset example except:

-append species information to MATERIAL section in case file, and

-add species element values file

(see example below).

Case file

Note: The following relationships are significant in the above case file.

material id numbers:              3      6
material id names:                Air    H20 
species per material counts:      3      2
                                ----^--- --^--
species per material lists:     12 13 14 11 13
                                 N  O Ar  H  O

where:

Case material ids (w/species) = {3,6} = {Air, H20} = {Air{ N, O, Ar), H20( H, O}}

Note: Typical values " {Air(.78,.21.01), H20(.33,.67)}

M
a
t S
e p Species Element Values File (zmat2d.spv)
r e Species Element Values File
i c part
a i 1 0-bias Element Element by type in
l e species values Index Label the connectivity list
=== === 20 ===== ======= =====================
Air N  0.78000e+00 <---------------0 <---- e0 = t0 = 1st Triangle
"   O  0.21000e+00                 1
"   Ar 0.01000e+00                 2
H2O H  0.33000e+00 <---------------3 <---- e1 = t1 = 2nd Triangle
"   O  0.67000e+00                 4
Air N  0.78100e+00 <---------------5 <---- e2 = q0 = 1st Quad
"   O  0.20900e+00                 6
"   Ar 0.01000e+00                 6
H2O H  0.33300e+00                 8
"   O  0.66700e+00                 9
Air N  0.78010e+00 <---------------10 <---- e3 = q1 = 2nd Quad
"   O  0.20990e+00                 11
"   Ar 0.01000e+00                 12
H2O H  0.33330e+00                 13
"   O  0.66670e+00                 14
Air N  0.78001e+00 <-------------  15 <---- e4 = q2 = 3rd Quad
"   O  0.20999e+00                 16
"   Ar 0.01000e+00                 17
H2O H  0.33333e+00                 18
"   O  0.66667e+00                 19

Note: The above species element values are accessed via part-element connectivity (zmat2d.geo) and material element data (zmat2d.mati and zmat2d.mixi) as illustrated above.

For more information on species, see Species, located in Material Interface Parts, MATERIAL Section under EnSight Gold Casefile Format, and MatSpecies function under 4.3 Variable Creation.

10.2.26. Example Material Dataset With Materials Defined By Per Element Scalar Variables

Note: Species are not supported under this format.

The following example dataset of ASCII EnSight Gold geometry and material files show the definition of material fractions for an unstructured model.

Figure 10.3: Geometry for Example Material Dataset Figure/Materials for Example Material Dataset

Case file

# Sample Case File for 2D Material Dataset w/materials via per element scalars
# Created: 07Feb20:mel
# FORMAT
type:                     ensight gold
GEOMETRY
model:                    zmat2d.geo
VARIABLE
scalar per node:          scalarN zmat2d.sca 
scalar per element:       scal_E3 zmat2d.se3 
scalar per element:       scal_E6 zmat2d.se6

MATERIAL
material set number:      1 Mat1 
material id count:        2
material id numbers:      3 6
material id names:        matl_3 mat1_6  #Air H2O 
material scalars per element:  scal_E3 scal_E6
#        y
#
#        ^
#        |  Case Material ids = {3,6}
#
#   6.   7-----------8-----------9
#        |          /|\          |
#        |         / | \         |
#        |    e2  /  |  \ e3     |
#        |       /   |   \       |
#        |      /    |    \      |
#        |    q0     |    q1     |
#        |    /      |      \    |
#        |  {.5,.5}  |  {.5,.5}  |
#        |  /        |        \  |
#        | /         |         \ |
#        |/          |          \|
#   3.   4-----------5-----------6
#        |\          |          /|
#        | \ {0.,1.} |         / |
#        |  \        |    e4  /  |
#        |   \   t1  |       /   |
#        |    \      |      /    |
#        |  e0 \ e1  |    q2     |
#        |      \    |    /      |
#        |  t0   \   |  {.5,.5}  |
#        |        \  |  /        |
#        | {1.,0.} \ | /         |
#        |          \|/          |
#   0.   1-----------2-----------3 -> x
#
#        0.          3.          6.

zmat2d.geo and zmat2d.sca are the same as in the Material Dataset (without species) example above.

zmat2d.se3 file contents:

zmat2d.se6 file contents: