IOSS 2.0

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Ioss Namespace Reference

The main namespace for the Ioss library. More...

## Namespaces
| Init
| A special namespace for a class used to initialize Ioss.
| Private

## Classes
class | Asym_Tensor_01
class | Asym_Tensor_02
class | Asym_Tensor_03
struct | AxisAlignedBoundingBox
class | Beam2
class | Beam3
class | BlockDecompositionData
struct | BoundaryCondition
class | CommSet
class | CompositeVariableType
class | ConstructedVariableType
class | CoordinateFrame
class | DatabaseIO
| An input or output Database. More...
class | Decomposition
class | Edge2
class | Edge2D2
class | Edge2D3
class | Edge3
class | EdgeBlock
| A collection of element edges with the same topology. More...
class | EdgeSet
| A collection of element edges. More...
class | ElementBlock
| A collection of elements having the same topology. More...
class | ElementSet
| A collection of elements. More...
class | ElementTopology
| Represents an element topology. More...
class | ElementVariableType
class | EntityBlock
| Base class for all 'block'-type grouping entities, which means all members of the block are similar or have the same topology. More...
class | EntitySet
| Base class for all 'set'-type grouping entities, which means that members of the set are not necessarily similar, or do not necessarily have the same topology. More...
class | ETRegistry
class | Face
class | FaceBlock
| A collection of element faces with the same topology. More...
struct | FaceEqual
class | FaceGenerator
struct | FaceHash
class | FaceSet
| A collection of element faces. More...
class | Field
| Holds metadata for bulk data associated with a GroupingEntity. More...
class | FieldManager
| A collection of Ioss::Field objects. More...
class | FileInfo
| Return information about the specified file. More...
class | Full_Tensor_12
class | Full_Tensor_16
class | Full_Tensor_22
class | Full_Tensor_32
class | Full_Tensor_36
class | GetLongOption
| A database of program command line and environment variable options and methods for manipulating them. More...
class | GroupingEntity
| Base class for all 'grouping' entities. The following derived classes are typical: More...
class | Hex16
class | Hex20
class | Hex27
class | Hex8
class | Initializer
class | Invalid_Storage
class | IOFactory
| The main public user interface for creating Ioss::DatabaseIO objects. More...
class | Map
class | Matrix_22
class | Matrix_33
struct | MeshCopyOptions
class | NamedSuffixVariableType
class | Node
class | NodeBlock
| A collection of all nodes in the region. More...
class | NodeSet
| A collection of nodes. More...
class | NullEntity
class | ParallelUtils
class | Property
| A named value that has a known type. More...
class | PropertyManager
| A collection of Ioss::Property objects. More...
class | Pyramid13
class | Pyramid14
class | Pyramid18
class | Pyramid19
class | Pyramid5
class | Quad4
class | Quad6
class | Quad8
class | Quad9
class | Quaternion_2D
class | Quaternion_3D
class | Region
| A grouping entity that contains other grouping entities. More...
class | Registry
class | Scalar
class | SerializeIO
| Class `SerializeIO` is a sentry class which performs serialization for mesh database I/O. More...
class | SetDecompositionData
class | Shell4
class | Shell8
class | Shell9
class | ShellLine2D2
class | ShellLine2D3
class | SideBlock
| A collection of element sides having the same topology. More...
class | SideSet
| A collection of element sides. More...
class | Sphere
class | Spring2
class | Spring3
class | St_Beam2
class | St_Beam3
class | St_Edge2
class | St_Edge2D2
class | St_Edge2D3
class | St_Edge3
class | St_Hex16
class | St_Hex20
class | St_Hex27
class | St_Hex8
class | St_Node
class | St_Pyramid13
class | St_Pyramid14
class | St_Pyramid18
class | St_Pyramid19
class | St_Pyramid5
class | St_Quad4
class | St_Quad6
class | St_Quad8
class | St_Quad9
class | St_Shell4
class | St_Shell8
class | St_Shell9
class | St_ShellLine2D2
class | St_ShellLine2D3
class | St_Sphere
class | St_Spring2
class | St_Spring3
class | St_Super
class | St_Tet10
class | St_Tet11
class | St_Tet14
class | St_Tet15
class | St_Tet4
class | St_Tet7
class | St_Tet8
class | St_Tri3
class | St_Tri4
class | St_Tri4a
class | St_Tri6
class | St_Tri7
class | St_TriShell3
class | St_TriShell4
class | St_TriShell6
class | St_TriShell7
class | St_Unknown
class | St_Wedge12
class | St_Wedge15
class | St_Wedge16
class | St_Wedge18
class | St_Wedge20
class | St_Wedge21
class | St_Wedge6
class | StorageInitializer
class | StructuredBlock
| A structured zone – i,j,k. More...
struct | Suffix
class | Super
class | Sym_Tensor_10
class | Sym_Tensor_11
class | Sym_Tensor_13
class | Sym_Tensor_21
class | Sym_Tensor_31
class | Sym_Tensor_33
class | Tet10
class | Tet11
class | Tet14
class | Tet15
class | Tet4
class | Tet7
class | Tet8
class | Tracer
class | Transform
class | Tri3
class | Tri4
class | Tri4a
class | Tri6
class | Tri7
class | TriShell3
class | TriShell4
class | TriShell6
class | TriShell7
class | Unknown
class | Utils
class | VariableType
| A generic variable type. More...
class | Vector_2D
class | Vector_3D
class | Wedge12
class | Wedge15
class | Wedge16
class | Wedge18
class | Wedge20
class | Wedge21
class | Wedge6
struct | ZoneConnectivity

## Typedefs
using | CoordinateFrameContainer = std::vector< CoordinateFrame >
using | IntVector = std::vector< int >
using | Int64Vector = std::vector< int64_t >
using | NameList = std::vector< std::string >
using | IJK_t = std::array< int, 3 >
using | TopoContainer = std::vector< std::pair< const ElementTopology *, const ElementTopology * > >
using | ElementTopologyMap = std::map< std::string, ElementTopology *, std::less< std::string > >
using | ETM_VP = ElementTopologyMap::value_type
using | FaceUnorderedSet = tsl::robin_set< Face, FaceHash, FaceEqual >
using | FieldMapType = std::unordered_map< std::string, Field >
using | FieldValuePair = FieldMapType::value_type
using | IOFactoryValuePair = IOFactoryMap::value_type
using | IOFactoryMap = std::map< std::string, IOFactory *, std::less< std::string > >
using | MapContainer = std::vector< int64_t >
using | IdPair = std::pair< int64_t, int64_t >
using | ReverseMapContainer = std::vector< IdPair >
using | PropMapType = std::unordered_map< std::string, Property >
using | ValuePair = PropMapType::value_type
using | NodeBlockContainer = std::vector< NodeBlock * >
using | EdgeBlockContainer = std::vector< EdgeBlock * >
using | FaceBlockContainer = std::vector< FaceBlock * >
using | ElementBlockContainer = std::vector< ElementBlock * >
using | NodeSetContainer = std::vector< NodeSet * >
using | EdgeSetContainer = std::vector< EdgeSet * >
using | FaceSetContainer = std::vector< FaceSet * >
using | ElementSetContainer = std::vector< ElementSet * >
using | SideSetContainer = std::vector< SideSet * >
using | StructuredBlockContainer = std::vector< StructuredBlock * >
using | CommSetContainer = std::vector< CommSet * >
using | StateTimeContainer = std::vector< double >
using | AliasMap = std::map< std::string, std::string, std::less< std::string > >
using | SideBlockContainer = std::vector< SideBlock * >
using | VariableTypeMap = std::map< std::string, VariableType *, std::less< std::string > >
using | VTM_ValuePair = VariableTypeMap::value_type

## Enumerations
enum | DataSize { USE_INT32_API = 4, USE_INT64_API = 8 }
| The number of bytes used to store an integer type. More...
enum | DatabaseUsage { WRITE_RESTART = 1, READ_RESTART = 2, WRITE_RESULTS = 4, READ_MODEL = 8, WRITE_HISTORY, WRITE_HEARTBEAT }
| Specifies how an Ioss::DatabaseIO object will be used. More...
enum | IfDatabaseExistsBehavior { DB_OVERWRITE, DB_APPEND, DB_APPEND_GROUP, DB_ABORT, DB_ADD_SUFFIX, DB_ADD_SUFFIX_OVERWRITE }
enum | ElementShape { ElementShape::UNKNOWN, ElementShape::POINT, ElementShape::LINE, ElementShape::TRI, ElementShape::QUAD, ElementShape::TET, ElementShape::PYRAMID, ElementShape::WEDGE, ElementShape::HEX }
enum | EntityType { NODEBLOCK = 1, EDGEBLOCK = 2, FACEBLOCK = 4, ELEMENTBLOCK = 8, NODESET = 16, EDGESET = 32, FACESET = 64, ELEMENTSET = 128, SIDESET = 256, SURFACE = 256, COMMSET = 512, SIDEBLOCK = 1024, REGION = 2048, SUPERELEMENT = 4096, STRUCTUREDBLOCK = 8192, INVALID_TYPE = 16384 }
| The particular type of GroupingEntity. More...
enum | MeshType { MeshType::UNKNOWN, MeshType::STRUCTURED, MeshType::UNSTRUCTURED, MeshType::HYBRID }
| The mesh type – structured, unstructured, hybrid (future), or unknown. More...
enum | State { STATE_INVALID = -1, STATE_UNKNOWN, STATE_READONLY, STATE_CLOSED, STATE_DEFINE_MODEL, STATE_MODEL, STATE_DEFINE_TRANSIENT, STATE_TRANSIENT, STATE_LAST_ENTRY }
| Access states for a database. More...
enum | SurfaceSplitType { SPLIT_INVALID = -1, SPLIT_BY_TOPOLOGIES = 1, SPLIT_BY_ELEMENT_BLOCK = 2, SPLIT_BY_DONT_SPLIT = 3, SPLIT_LAST_ENTRY = 4 }
| Method used to split sidesets into homogenous blocks. More...

## Functions
bool | is_input_event (Ioss::DatabaseUsage db_usage)
template<typename INT >
void | qsort (std::vector< INT > &v)
std::ostream & | operator<< (std::ostream &os, const BoundaryCondition &bc)
SurfaceSplitType | int_to_surface_split (int split_int)
| Convert an integer code for the method used to split sidesets into homogenous blocks. More...
std::ostream & | operator<< (std::ostream &os, const ZoneConnectivity &zgc)
void | io_info_file_info (const Info::Interface &interface)
void | io_info_group_info (Info::Interface &interface)
void | io_info_set_db_properties (const Info::Interface &interface, Ioss::DatabaseIO *dbi)
void | io_info_file_info (const Info::Interface &interface, Ioss::Region &region)
std::vector< std::string > | tokenize (const std::string &str, const std::string &separators)

## Variables
constexpr int | entityTypeCount = 14

## Detailed Description

The main namespace for the Ioss library.

## Typedef Documentation

## ◆ AliasMap

using Ioss::AliasMap = typedef std::map<std::string, std::string, std::less<std::string> >

## ◆ CommSetContainer

using Ioss::CommSetContainer = typedef std::vector<CommSet *>

## ◆ CoordinateFrameContainer

typedef std::vector< CoordinateFrame > Ioss::CoordinateFrameContainer

## ◆ EdgeBlockContainer

using Ioss::EdgeBlockContainer = typedef std::vector<EdgeBlock *>

## ◆ EdgeSetContainer

using Ioss::EdgeSetContainer = typedef std::vector<EdgeSet *>

## ◆ ElementBlockContainer

using Ioss::ElementBlockContainer = typedef std::vector<ElementBlock *>

## ◆ ElementSetContainer

using Ioss::ElementSetContainer = typedef std::vector<ElementSet *>

## ◆ ElementTopologyMap

using Ioss::ElementTopologyMap = typedef std::map<std::string, ElementTopology *, std::less<std::string> >

## ◆ ETM_VP

using Ioss::ETM_VP = typedef ElementTopologyMap::value_type

## ◆ FaceBlockContainer

using Ioss::FaceBlockContainer = typedef std::vector<FaceBlock *>

## ◆ FaceSetContainer

using Ioss::FaceSetContainer = typedef std::vector<FaceSet *>

## ◆ FaceUnorderedSet

using Ioss::FaceUnorderedSet = typedef tsl::robin_set<Face, FaceHash, FaceEqual>

## ◆ FieldMapType

using Ioss::FieldMapType = typedef std::unordered_map<std::string, Field>

## ◆ FieldValuePair

using Ioss::FieldValuePair = typedef FieldMapType::value_type

## ◆ IdPair

using Ioss::IdPair = typedef std::pair<int64_t, int64_t>

## ◆ IJK_t

using Ioss::IJK_t = typedef std::array<int, 3>

## ◆ Int64Vector

using Ioss::Int64Vector = typedef std::vector<int64_t>

## ◆ IntVector

using Ioss::IntVector = typedef std::vector<int>

## ◆ IOFactoryMap

using Ioss::IOFactoryMap = typedef std::map<std::string, IOFactory *, std::less<std::string> >

## ◆ IOFactoryValuePair

using Ioss::IOFactoryValuePair = typedef IOFactoryMap::value_type

## ◆ MapContainer

using Ioss::MapContainer = typedef std::vector<int64_t>

## ◆ NameList

typedef std::vector< std::string > Ioss::NameList

## ◆ NodeBlockContainer

using Ioss::NodeBlockContainer = typedef std::vector<NodeBlock *>

## ◆ NodeSetContainer

using Ioss::NodeSetContainer = typedef std::vector<NodeSet *>

## ◆ PropMapType

using Ioss::PropMapType = typedef std::unordered_map<std::string, Property>

## ◆ ReverseMapContainer

using Ioss::ReverseMapContainer = typedef std::vector<IdPair>

## ◆ SideBlockContainer

using Ioss::SideBlockContainer = typedef std::vector<SideBlock *>

## ◆ SideSetContainer

using Ioss::SideSetContainer = typedef std::vector<SideSet *>

## ◆ StateTimeContainer

using Ioss::StateTimeContainer = typedef std::vector<double>

## ◆ StructuredBlockContainer

using Ioss::StructuredBlockContainer = typedef std::vector<StructuredBlock *>

## ◆ TopoContainer

using Ioss::TopoContainer = typedef std::vector<std::pair<const ElementTopology *, const ElementTopology *> >

## ◆ ValuePair

using Ioss::ValuePair = typedef PropMapType::value_type

## ◆ VariableTypeMap

using Ioss::VariableTypeMap = typedef std::map<std::string, VariableType *, std::less<std::string> >

## ◆ VTM_ValuePair

using Ioss::VTM_ValuePair = typedef VariableTypeMap::value_type

## Enumeration Type Documentation

## ◆ DatabaseUsage

enum Ioss::DatabaseUsage

Specifies how an Ioss::DatabaseIO object will be used.

Enumerator
WRITE_RESTART | The current state of the simulation, including model and field data will be written to this database.
READ_RESTART | A previous state of the simulation, including model and field data will be read from this database.
WRITE_RESULTS | Mesh-based results data, such as nodal displacements, will be written to this database.
READ_MODEL | Model data such as node coordinates, element connectivities will be read from this database.
WRITE_HISTORY | Global results data, such as total energy, will be written to this database.
WRITE_HEARTBEAT | Text-based results data for particular nodes, edges, faces, elements, or global variables at particular times will be written to this database.

## ◆ DataSize

enum Ioss::DataSize

The number of bytes used to store an integer type.

Enumerator
USE_INT32_API |
USE_INT64_API |

## ◆ ElementShape

enum Ioss::ElementShape
| strong

Enumerator
UNKNOWN |
POINT |
LINE |
TRI |
QUAD |
TET |
PYRAMID |
WEDGE |
HEX |

## ◆ EntityType

enum Ioss::EntityType

The particular type of GroupingEntity.

Enumerator
NODEBLOCK |
EDGEBLOCK |
FACEBLOCK |
ELEMENTBLOCK |
NODESET |
EDGESET |
FACESET |
ELEMENTSET |
SIDESET |
SURFACE |
COMMSET |
SIDEBLOCK |
REGION |
SUPERELEMENT |
STRUCTUREDBLOCK |
INVALID_TYPE |

## ◆ IfDatabaseExistsBehavior

enum Ioss::IfDatabaseExistsBehavior

Enumerator
DB_OVERWRITE |
DB_APPEND |
DB_APPEND_GROUP |
DB_ABORT |
DB_ADD_SUFFIX |
DB_ADD_SUFFIX_OVERWRITE |

## ◆ MeshType

enum Ioss::MeshType
| strong

The mesh type – structured, unstructured, hybrid (future), or unknown.

Enumerator
UNKNOWN |
STRUCTURED |
UNSTRUCTURED |
HYBRID |

## ◆ State

enum Ioss::State

Access states for a database.

All access states except STATE_INVALID, STATE_UNKNOWN, and STATE_READONLY are only for output databases.

Enumerator
STATE_INVALID | Error state if something goes wrong.
STATE_UNKNOWN | Typically used at the very beginning of the database's existence when the class has been created, but no reading or writing has occurred.
STATE_READONLY | An input database that is not in STATE_UNKNOWN is in this state, which means that it cannot be written to or changed.
STATE_CLOSED | The sates are not nested, so each state must end with a transition to this state prior to entering the next state.
STATE_DEFINE_MODEL | Defining the metadata, which defines the topology of the model (nontransient, geometry and topology).
STATE_MODEL | Outputting the bulk data (mesh_model_coordinates, ids, connectivity) relating to the model portion.
STATE_DEFINE_TRANSIENT | Defining the metadata relating to the transient data. For example, the element or nodal fields.
STATE_TRANSIENT | Outputting the transient bulk data.
STATE_LAST_ENTRY |

## ◆ SurfaceSplitType

enum Ioss::SurfaceSplitType

Method used to split sidesets into homogenous blocks.

Enumerator
SPLIT_INVALID |
SPLIT_BY_TOPOLOGIES |
SPLIT_BY_ELEMENT_BLOCK |
SPLIT_BY_DONT_SPLIT |
SPLIT_LAST_ENTRY |

## Function Documentation

## ◆ int_to_surface_split()

SurfaceSplitType Ioss::int_to_surface_split | ( | int | split_int | ) |
| inline

Convert an integer code for the method used to split sidesets into homogenous blocks.

Parameters

  [in] | split_int | The code.

Returns
  The corresponding SurfaceSplitType.

## ◆ io_info_file_info() [1/2]

void Ioss::io_info_file_info | ( | const Info::Interface & | interface | ) |

## ◆ io_info_file_info() [2/2]

void Ioss::io_info_file_info | ( | const Info::Interface & | interface,
|  | Ioss::Region & | region
| ) |  |

## ◆ io_info_group_info()

void Ioss::io_info_group_info | ( | Info::Interface & | interface | ) |

## ◆ io_info_set_db_properties()

void Ioss::io_info_set_db_properties | ( | const Info::Interface & | interface,
|  | Ioss::DatabaseIO * | dbi
| ) |  |

## ◆ is_input_event()

bool Ioss::is_input_event | ( | Ioss::DatabaseUsage | db_usage | ) |
| inline

## ◆ operator<<() [1/2]

std::ostream& Ioss::operator<< | ( | std::ostream & | os,
|  | const ZoneConnectivity & | zgc
| ) |  |

## ◆ operator<<() [2/2]

std::ostream& Ioss::operator<< | ( | std::ostream & | os,
|  | const BoundaryCondition & | bc
| ) |  |

## ◆ qsort()

template<typename INT >

void Ioss::qsort | ( | std::vector< INT > & | v | ) |

## ◆ tokenize()

TokenList Ioss::tokenize | ( | const std::string & | str,
|  | const std::string & | separators
| ) |  |

Take the 'str' argument and split it using the list of characters in separators as separators. Use tokens to return the result.

## Variable Documentation

## ◆ entityTypeCount

constexpr int Ioss::entityTypeCount = 14