Introduction

The B2000++ system makes use of the MemCom data manager system, which has been specially devised for managing FE data.

A B2000++ database is a collection of files and directories stored under a common file directory with the file name suffix .b2m. B2000++ creates at least the following files under the model directory:

Content of a *B2000++* database directory
Name	Type	Description
`archives.mc`	Directory	The MemCom model database contains all data describing the model.
`log.mc`	Directory	Logging (debug) database created when the command-line `-l 'data of all in db'` is given to `b2000++`. Data emitted during the logging will be written to this database.
`log.txt`	File	B2000++ execution log text file. The amount of information depends on the command-line `-l 'info of xxx in cerr'` is given to `b2000++`. Data emitted during the logging will be written to this database.
`.index`	File	Text file containing meta-information.

The MemCom model database contains a collection of MemCom datasets accessed by name. The datasets give a complete description of a FE problem. While any dataset explicitly describes a detail of the FE model, the relation between the datasets is implicit, i.e. knowledge of the relations among the datasets and the hierarchy of the datasets is needed. Example: The dataset COOR. consists of an array containing a contiguous array of the x-, y-, and z-coordinates of the mesh nodes. COOR. enters in relation with many other datasets, such as ETAB. , the element descriptions. Evidently, ETAB. would not store the coordinates for all element mesh nodes, but it would contain the indices pointing to the respective coordinates of COOR. .

The Chapter Example Database explains the most important of these relations.

B2000++ Datasets

Datasets are arrays or tables of one or more dimensions containing typed data. The first dimension of a dataset is referred to as the row, and the second dimension the column or sub-division. There are two categories of datasets:

Locical or ‘positional’ arrays: They contain data of a single data type, which can be accessed by position. Examples: Arrays of floats, integers.
Composite or ‘non-positional’ data: They contain data in the form of dictionaries. Examples: MemCom relational tables, array tables, sparse tables.

Relational tables in the context of the MemCom data manager are collections of pairs Key - Values. Relational tables are accessed by name (or key). Thus, the position of the key within a table is irrelevant. The MemCom API offers functions for accessing relational tables and their content. Values are arrays containing a single numerical or character data type. Note that the number of elements in the array is limited by the table size. Being very convenient, the drawback of relational tables is that accessing data is very slow compared to positional tables, and the table size is limited.

All datasets contain an optional relational descriptor table associated to any dataset referred to as dataset descriptor. The descriptor usually contains a brief description of the nature and the purpose of the data contained in the data portion of the data set.

Dataset names

Dataset names are character strings. Within the context of B2000++ a dataset name is composed of one or more fields separated by dots, thus achieving a hierarchical classification of data while keeping a flat access technique. For describing B2000++ database objects the following naming convention has been defined:

field1.field2.field3.field4.field5.field6

Each field usually has the following meaning:

field1 is the generic name, such as COOR (coordinates), DISP (displacement and rotation solutions at the mesh nodes), ETAB (element description tables) etc.
field2 is the branch or subdomain number (1, 2, 3, …).
field3 is the computational cycle (time step, load step, etc.).
field4 is the computational sub-cycle of the time step or the load step.
field5 is the ‘load’ case.
field6 is the ‘load’ sub-case or mode.

Example 1: The mesh node coordinates are stored in one array COOR per subdomain:

  gname:     COOR
             |
 branch:     1-------2
             |       |
setname:     COOR.1  COOR.2

Example 2: The displacement and rotation solutions at the mesh nodes (‘DOF solutions’) are stored in one array DISP per subdomain, per case, and per cycle (not listed here):

  gname:     DISP
             |
 branch:     1---------------------------2
             |                           |
   case:     1-------------2             1-------------2
             |             |             |             |
setname:     DISP.1.0.0.1  DISP.1.0.0.2  DISP.2.0.0.2  DISP.2.0.0.2

The length of a field can be chosen arbitrarily, but the total length of a dataset name including the dots must not exceed 64 characters (limitation imposed by MemCom).

Dataset types

The dataset type defines the data type, both for representing data in memory and on the database. It also implies converting the data types from database format to the data format required by the current hardware. In the table below Type designates the database data type. The following data types are available:

MemCom C/C++ data types
Ident	Data type	Size (bits)	Description
I	mcInt32	32	Integer
J	mcInt64	64	‘Long’ integer
E	mcFloat32	32	Float
C	mcComplexFloat32	2 x 32	Complex float
F	mcFloat64	64	Double precision float
Z	mcComplexFloat64	2 x 64	Double precision complex float
K	char []	n * 8	Character array
$	mcRTable	n/a	Relational table (dictionary)
AT	None	n/a	Array table
U	unsigned char abc[n]	n * 8	Unspecified format, i.e. byte array

MemCom Fortran data types
Ident	Data type	Size (bits)	Description
I	mcf_i4 (integer*4)	32	Integer
J	mcf_i8 (integer*8)	64	‘Long’ integer
E	mcf_r4 (real*4)	32	Float
C	mcf_c4 (complex*4)	2 x 32	Complex float
F	mcf_r84 (real*8)	64	Double precision float
Z	mcf_c8 (complex*8)	2 x 64	Double precision complex float
K	character*n	n * 8	Character array
$	mcRTable	mcf_rtable	Relational table (dictionary)
AT	None	n/a	Array table
U	unsigned char abc[n]	n/a	Unspecified format, i.e. byte array

Another data type is the pointer array consisting of the array and the pointer vector that points to the beginning of each row of data within the array. In B2000++ pointer arrays consist of two datasets: The array containing the data, i.e. integers, reals, or doubles, and the integer pointer array.