Description of the Fidesys Case File Format (.fc)

"header": {...},

// File header.

"blocks": [...],

// List of block data.

"coordinate_systems": [...],

// List of data on coordinate systems.

"mesh": {...},

// Mesh data.

"materials": [...],

// List of material data.

"property_tables": [...],

// List of property tables.

// (analogous to Real Constants in Ansys).

"loads":[...],

// List of loads.

"restraints":[...],

// List of restraints.

"contact_constraints": [...],

// Contact list.

"coupling_constraints": [...],

// List of connections.

"periodic_constraints": [...],

// List of periodicals.

"receivers": [...],

// List of receivers.

"initial_sets": [...],

// List of initial conditions.

"sets": {...},

// Sets of nodes and sides.

"settings": {...},

// General settings.

"description": <String>,

// File Description.

"version": <unsigned short int>,

// Format version.

"types": {...},

// Type settings.

"binary": <bool>

// Binary or text format.

"char": <int>,

// sizeof (char)

"short_int": <int>,

// sizeof (short int)

"int": <int>,

// sizeof (int)

"double": <int>,

// sizeof (double)

"id": <int>,

// Block ID.

"cs_id": <int>,

// Block coordinate system ID.

"material":

// Step-by-step instructions for this block

// (optional parameter,

//  if the material ID does not change during calculation).

{

"ids": [int],

// List of material IDs.

"steps": [int]

// Step numbers.

},

"material_id": <int>,

// Block material ID.

"property_id": <int>,

// Block property ID.

"steps": [int]

// Calculation steps. Optional.

},

{...}

// The next element has the structure described above.

"id": <unsigned short int>,

// Coordinate system ID. Greater than zero.

// ID=1 should be the global Cartesian coordinate system.

"type":  <string>,

// Coordinate system type. Options: "cartesian",

// "cylindrical", "spherical".

"name":  <string>,

// SC name.

"origin": [double]

// SC start coordinates.

// The entire array is encoded as a string in Base64.

"dir1": [double]

// Direction vector end coordinates.

// along the direction 1.

// The entire array is encoded as a string in Base64.

"dir2": [double]

// Coordinates of the end of the direction vector

// along direction 2.

// The entire array is encoded as a string in Base64.

},

{...}

// The next element with the structure described above.

"nodes_count": <unsigned int>,

// Number of nodes.

// Must match the length of the nids array.

"nids": [int],

// Array of node IDs.

// The entire array is encoded as a single string in Base64.

"nodes": [double],

// Array of node coordinates in the form

// [x1 y1 z1 x2 y2 z2 etc.].

// In Base64, the entire array is encoded as a single string.

"elems_count": <unsigned int>,

// The number of elements must match

// the length of the elemids array.

"elemids": [int],

// Array of element IDs. Base64 encodes the entire array as a single string.

// the array is encoded as a single string.

"elem_types": [unsigned char],

// Array of element types. Encoded in Base64.

// The entire array as a single string.

"elem_blocks": [int],

// Array of block IDs to which the element belongs.

// The entire array is encoded in Base64 as a single string.

"elem_orders": [int],

// Array of SEM element orders (ignored

// for FEM), from 3 to 9.  The entire array is encoded in Base64.

// array as a single string.

"elem_parent_ids": [int],

// Array of geometry IDs to which the geometry belongs.

// element. In Base64, the entire array is encoded as

// one line.

"elems": [unsigned int],

// An array of node ID arrays that make up

// an element. Different size for each element.

// The entire array is encoded in Base64 as

// a single line.

// Material Structure

{

"id": <int>,

// Material ID.

"name":  <string>,

// Material Name.

"elasticity": [...],

// Elasticity and viscoelasticity.

"common": [...],

// General properties.

"thermal": [...]

// Thermal properties.

"geomechanic": [...],

// Geomechanics.

"plasticity": [...],

// Plasticity.

"hardening": [...],

// Hardening.

"creep": [...],

// Creep.

"preload": [...],

// Preload.

"strength": [...],

// Strength.

},

{...}

// Next item in the list.

{

"constants": [double],

// Array of arrays of group property values.

// Each element is encoded in Base64.

// (constant or array) of the main array.

//  Formulas are written as a string without encoding.

"const_types": [ [unsigned short int] ],

// Array of arrays of dependency types

//  of each property in the group. For multidimensional

//  table dependencies for one property

// There can be multiple TABULAR_*  dependencies.

"const_dep": [double],

// Array of arrays of table arguments

//  dependencies. Empty string for constant and formula.

// In Base64, each element of the main array

// is encoded separately.

"const_dep_size": [int],

// Array of table dependency dimensions

//  of each property (number of table rows).

// Equal to 0 for constants and formulas.

"const_names": [int]

// Names of group property constants.

"type": [int],

// Property type.

}

16 = E_T,

17 = E_L,

18 = PR_T,

19 = PR_TL,

20 = G_TL,

21 = G12,

22 = G23,

23 = G13,

24 = PRXY,

25 = PRYZ,

26 = PRXZ,

82 = C_1111,

83 = C_1112,

84 = C_1113,

85 = C_1122,

86 = C_1123,

87 = C_1133,

88 = C_1212,

89 = C_1213,

90 = C_1222,

91 = C_1223,

92 = C_1233,

93 = C_1313,

94 = C_1322,

95 = C_1323,

96 = C_1333,

97 = C_2222,

98 = C_2223,

99 = C_2233,

100 = C_2323,

101 = C_2333,

102 = C_3333

5 = COEF_THERMAL_CONDUCTIVITY_XX,

9 = COEF_THERMAL_CONDUCTIVITY_YY,

13 = COEF_THERMAL_CONDUCTIVITY_ZZ,

14 = COEF_LIN_EXPANSION_X,

15 = COEF_LIN_EXPANSION_Y,

16 = COEF_LIN_EXPANSION_Z,

17 = COEF_THERMAL_CONDUCTIVITY_T,

18 = COEF_THERMAL_CONDUCTIVITY_L,

19 = COEF_LIN_EXPANSION_T,

20 = COEF_LIN_EXPANSION_L

6 = PERMEABILITY_XX,

7 = PERMEABILITY_XY,

8 = PERMEABILITY_XZ,

9 = PERMEABILITY_YX,

10 = PERMEABILITY_YY,

11 = PERMEABILITY_YZ,

12 = PERMEABILITY_ZX,

13 = PERMEABILITY_ZY,

14 = PERMEABILITY_ZZ,

21 = BIOT_ALPHA_X,

22 = BIOT_ALPHA_Y,

23 = BIOT_ALPHA_Z

15 = PERMEABILITY_T,

16 = PERMEABILITY_TT,

17 = PERMEABILITY_TL,

18 = PERMEABILITY_L,

24 = BIOT_ALPHA_T,

25 = BIOT_ALPHA_L

0 = STRESS_XX,

1 = STRESS_YY,

2 = STRESS_ZZ,

3 = STRESS_XY,

4 = STRESS_YZ,

5 = STRESS_XZ,

6 = STRAIN_XX,

7 = STRAIN_YY,

8 = STRAIN_ZZ,

9 = STRAIN_XY,

10 = STRAIN_YZ,

11 = STRAIN_XZ,

12 = PSI_XX,

13 = PSI_YY,

14 = PSI_ZZ,

15 = PSI_XY,

16 = PSI_YZ,

17 = PSI_XZ,

18 = PSI_YX,

19 = PSI_ZY,

20 = PSI_ZX,

21 = GRADIENT_XX,

22 = GRADIENT_YY,

23 = GRADIENT_ZZ,

24 = GRADIENT_XY,

25 = GRADIENT_YZ,

26 = GRADIENT_XZ,

27 = GRADIENT_YX,

28 = GRADIENT_ZY,

29 = GRADIENT_ZX,

30 = PLASTIC_STRAIN_XX,

31 = PLASTIC_STRAIN_YY,

32 = PLASTIC_STRAIN_ZZ,

33 = PLASTIC_STRAIN_XY,

34 = PLASTIC_STRAIN_YZ,

35 = PLASTIC_STRAIN_XZ,

36 = FINGER_STRAIN_XX,

37 = FINGER_STRAIN_YY,

38 = FINGER_STRAIN_ZZ,

39 = FINGER_STRAIN_XY,

40 = FINGER_STRAIN_YZ,

41 = FINGER_STRAIN_XZ,

42 = PLASTIC_STRAIN_MISES,

43 = THERMAL_STRESS_XX,

44 = THERMAL_STRESS_YY,

45 = THERMAL_STRESS_ZZ,

46 = THERMAL_STRESS_XY,

47 = THERMAL_STRESS_YZ,

48 = THERMAL_STRESS_XZ

"id": <unsigned short int>,

// Property table number.

"name": <string>,

// Property table description.

"type": <int>,

// Property table type.

"direction_normal": <bool>

// Defines the layer direction for the SHELL type.

// True - along the normal,

// False - against the normal.

"thickness_change": <bool>

// Determines whether to include the change

// by shell thickness in SEM.

"properties": {...}

// Properties.

"layers":

// Shell layer properties. For the SHELL type.

{

"properties":

[

{

"angle" : <double>,

// Layer rotation angle relative to

// the element's local coordinate system.

"material_id" : <int>,

// Layer material ID.

"t" : <double>

// Layer thickness.

},

{...}

// Next layer properties.

]

}

},

{...}

// Next properties table.

"e": <double>

// Eccentricity of the given geometry relative to the midsurface.

// Varies from 0 (lower surface),

// to 1 (upper surface).

"mass": <double>,

// Mass. Mutually exclusive property with a set

// properties mass_x, mass_y, mass_z .

"mass_x": <double>,

// Mass distribution along the X-axis.

"mass_y": <double>,

// Mass distribution along the Y-axis.

"mass_z": <double>,

// Mass distribution along the Z-axis.

"mass_inertia": <double>,

// Moment of inertia.

// Mutually exclusive property with a set of properties

// mass_inertia_x, mass_inertia_y, mass_inertia_z.

"mass_inertia_x" : <double>,

// Moment of inertia around the X-axis.

"mass_inertia_y" : <double>,

// Moment of inertia about the Y- axis.

"mass_inertia_z" : <double>

// Moment of inertia about the Z- axis.

"spring_type": <string>,

// Spring type. Options:

// "linear_spring",

// "combined_spring".

// Linear_spring properties:

"stiffness": <double>,

// Tensile stiffness.

"spring_constant_damping": <double>,

// Constant damping coefficient.

"spring_linear_damping": <double>,

// Linear damping coefficient.

"spring_mass": <double>,

// Mass.

"stiffness_torsional": <double>,

// Torsional stiffness.

"spring_constant_damping_torsional" : <double>,

// Torsional damping coefficient.

"spring_linear_damping_torsional" : <double>,

// Linear damping coefficient

// torsional damping coefficient.

"spring_inertia" : <double>,

// Moment of inertia.

// Properties of combined_spring:

"k1": <double>,

// Stiffness of spring 1.

"k2": <double>,

// Stiffness of spring 2.

"gap": <double>,

// Gap.

"limit_sliding_force": <double>,

// Limit sliding force.

"damping": <double>,

// Constant damping coefficient.

"mass": <double>,

// Spring mass.

"mass_distribution": <double>,

// Mass distribution between nodes.

// Options:

// -1 - distribution to node 0;

// 1 - distribution to node 1;

// 0 - uniform distribution  

// between nodes 0 and 1.

"section_type": <int>,

// Beam section type.

"angle": <double>,

// Section rotation angle.

"ey": <double>,

// Eccentricity along the local Y-axis.

"ez": <double>,

// Eccentricity along the local Z-axis.

"mesh_quality" : <double>,

// Section mesh quality for 3D display.

"warping_dof": <double>,

// Including an additional degree of freedom.

// for section torsion.

"area": <double>,

// Cross-sectional area.

"Ip": <double>,

// Moment of inertia relative to the x-axis.

"Iy": <double>,

// Moment of inertia relative to the y-axis.

"Iyz": <double>,

// Centrifugal moment of inertia.

"Iz": <double>,

// Moment of inertia relative to the z-axis.

"It": <double>,

// Geometric torsional rigidity.

"Iw": <double>,

// Moment of inertia Iw.

"max_y": <double>,

// Maximum Y coordinate

// from the signed center of mass.

"max_z": <double>,

// Maximum Z coordinate

// from the signed center of mass.

"shear_coefficient_yy": <double>,

// YY shear coefficient.

"shear_coefficient_zz": <double>,

// ZZ shear coefficient.

"shear_coefficient_zy": <double>,

// ZY shear coefficient.

"shear_center_y": <double>,

// Y coordinate of the bending center.

"shear_center_z": <double>,

// Z coordinate of the bending center.

"B":  <double>,

// Width

"H":  <double>,

// Height

"a ":  <double>,

// Major axis  

"b ":  <double>,

// Minor axis  

"B1": <double>,

// Bottom Width

"B2": <double>,

// Top Width

"H": <double>,

// Height

"c2": <double>,

// Top Thickness

"c1": <double>,

// Bottom Thickness

"d": <double>

// Thickness

"D1 ": <double>,

// Outer Diameter

"D2": <double>,

// Inner Diameter

"e": <double>,

// Offset

"H": <double>,

// Height (H)

"B2": <double>,

// Top Width (B2)

"B1": <double>,

// Bottom Width (B1)

"c2": <double>,

// Top Thickness (c2)

"c1": <double>,

// Bottom Thickness (c1)

"d": <double>

// Thickness (d)

"H": <double>,

// Height (H)

"B": <double>,

// Bottom Width (B)

"d": <double>,

// Top Thickness (d)

"c1": <double>,

// Bottom Thickness (c1)

"H": <double>,

// Height (H)

"B2": <double>,

// Top Width (B2)

"B1": <double>,

// Bottom Width (B1)

"c2": <double>,

// Top Thickness (c2)

"c1": <double>,

// Bottom thickness (c1)

"d": <double>

// Thickness (d)

"H": <double>,

// Height (H)

"B": <double>,

// Bottom Width (B)

"d": <double>,

// Top Thickness (d)

"c1": <double>,

// Bottom Thickness (c1)

"H": <double>,

// Height (H)

"B": <double>,

// Width (B)

"d1": <double>,

// Left Width (d1)

"d2": <double>,

// Right Width (d2)

"c2": <double>,

// Upper Thickness (c2)

"c1": <double>

// Lower Thickness (c1)

"H": <double>,

// Height (H)

"B3": <double>,

// Top Width (B3)

"B1": <double>,

// Bottom Left Width (B1)

"B2": <double>,

// Bottom Right Width (B2)

"d1": <double>,

// Left Thickness (d1)

"d2": <double>

// Right Thickness (d2)

"c3": <double>,

// Top Thickness (c3)

"c1": <double>,

// Bottom Left Thickness (c1)

"c2": <double>

// Bottom right thickness (c2)

"d1 ": <double>,

// Outer Diameter

"d2": <double>,

// Inner Diameter

"p1": <double>,

// External Pressure

"p2": <double>,

// Internal Pressure

0 = RECTANGLE,

// Rectangle

1 = ELLIPSE,

// Ellipse

2 = I_BEAM,

// I-Beam

3 = CIRCLE_WITH_A_CUT,

// Circle with a

4 = POINT,

// Manual section parameter adjustment

5 = C_BEAM,

// Channel

6 = L_BEAM,

// Angle

7 = Z_BEAM,

// Z-section

8 = T_BEAM,

// T-beam

9 = RECTANGLE_WITH_A_CUT,

// Hollow rectangle

10 = HAT_BEAM,

// Trough profile

12 = PIPE

// Pipe

"nodesets":

// Node sets.

[

{

"id": <int>,

// Node set number.

"name": <string>,

// Node set name.

"apply_to": [<int>],

// Array of node IDs. Encoded in Base64.

// on one line.

"apply_to_size": <int>,

// Number of nodes in the set.

}

],

"sidesets":

// Sets of sides.

[

{

"id": <int>,

// Side set number.

"name": <string>,

// Side set name.

"apply_to": [ [int, int] ],

// 2-dimensional array of arrays,

// containing [element id, number

// faces/edges]. Encoded in Base64.

// array of arrays as a single string.

"apply_to_size": <int>

// Number of sides of elements in the set.

}

]

"id": <int>,

// Load ID.

"name": string,

// Load description.

"type": <int>,

// Load type.

"data": [double],

// Array of arrays of load component values.

// Each element is encoded in Base64.

// (constant or array) of the main array.

// Formulas are written as a string without encoding.

// Empty string for the inactive load component.

apply_to_size: <int>,

// Number of entitys to

// The load is applied.

apply_to: [int]",

// Array of entitys to which the load is applied.

// Encoded in Base64 by one line.

// The entity type (node, side, element) depends

// on the load type. Can have a string   value.

//  "all" if applied to all entitys.

"dep_var_num": [double]

// Array of table dependency dimensions

// each load component (number of lines

// tables).  In Base64, every element of the main

// The array is encoded separately.

// Equal to 0 for constant and formula.

"dep_var_size": [int],

// Array of table dependency dimensions

//  each load component (number of rows

//  tables).  Equal to 0 for constant and formula.

"dependency_type": [int | string],

// Array of arrays of dependency types for each

// load components. For multidimensional

// table dependencies for one component

// there may be multiple TABULAR_* dependencies.

//  The array component is equal to the empty string for

// an inactive load component.

// Face loads

1 = FaceDeadStress,

// Face stress. 1 component in data.

3 = FaceTrackingStress,

// Face tracking stress.

// 1 component in data.

11 = FaceHeatFlux,

// Face heat flux.

// 1 component in data.

13 = FaceConvection,

// Edge convection.

// 2 components in data:

// ambient temperature,

// heat transfer coefficient.

15 = FaceRadiation,

// Facet radiation. 2 components in data:

// ambient temperature,

// radiation.

19 = FaceAbsorbingBC,

// Face absorbing BC.

// No components in data.

21 = ShellHeatfluxTopBottom,

// Heat flux top and bottom.

// 2 components in data:

// Heat flux top and heat flux bottom.

22 = ShellHeatfluxTop,

// Heat flux top. 1 component in data.

23 = ShellHeatfluxBottom,

// Heat flux bottom. 1 component in data.

24 = ShellConvectionTopBottom,

// Convection top and bottom. 4 components in data:

// ambient temperature above,

// heat transfer coefficient from above,

// ambient temperature from below,

// heat transfer coefficient from below.

25 = ShellConvectionTop,

// Convection top. 2 components in data:

// ambient temperature above,

// heat transfer coefficient from above.

26 = ShellConvectionBottom,

// Convection low. 2 components in data:

// ambient temperature below,

// heat transfer coefficient from below.

35 = FaceDistributedForce,

// Distributed force on the edge.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

36 = ​​FaceEquivalentForce,

// Equivalent force on the face.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

37 = FaceTrackingDistributedForce,

// Distributed tracking force on the face.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

38 = FaceTrackingEquivalentForce,

// Equivalent force on the face.

// 6 components in the data:

// Force along X, Y, Z, moment along X, Y, Z.

39 = FaceFluidFlux,

// Fluid flow through the face.

// 1 component in the data.

// Edge loads

2 = SegmentDeadStress,  

// Edge stress. 1 component in data.

4 = SegmentTrackingStress,

// Edge tracking stress.

// 1 component in data.

12 = SegmentHeatFlux,

// Heat flux at the fin.

// 1 component in data.

14 = SegmentConvection,

// Convective heat transfer at the fin.

// 2 components in data:

// ambient temperature,

// heat transfer coefficient.

16 = SegmentRadiation,

// Radiation on the edge. 2 components in data:

// ambient temperature,

// radiation.

20 = SegmentAbsorbingBC,

// Absorbing GU on the edge.

// There are no components in data.

31 = SegmentDistributedForce,

// Distributed force on the edge.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

32 = SegmentEquivalentForce,

// Equivalent force on the edge.

// 6 components in data:

// force along X, Y, Z, moment along X, Y, Z.

33 = SegmentTrackingDistributedForce,

// Distributed tracking force on the edge.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

34 = SegmentTrackingEquivalentForce,

// Equivalent tracking force on the edge.

// 6 components in data:

// Force along X, Y, Z, moment along X, Y, Z.

40 = SegmentFluidFlux,

// Fluid flow through the rib.

// 1 component in data.

// Node loads

5 = NodeForce,

// The nodal force. 6 component in data:

// force in X, Y, Z, moment in X, Y, Z.

18 = HeatSource,

// A nodal heat source.

// 1 component in data.

28 = NodeHeatFlux,

// Nodal heat flow.

// 1 component in data.

29 = NodeConvection,

// Nodal convection. 2 components in data:

// ambient temperature,

// heat transfer coefficient.

30 = NodeRadiation,

// Nodal radiation. 2 components in data:

// ambient temperature,

// radiation.

41 = NodeFluidFlux,

// The flow of liquid through the node.

// 1 component in data.

43 = FluidSource,

// A nodal source of fluid.

// 1 component in data.

// Element loads

17 = VolumeHeatSource,

// Volumetric heat source.

// 1 component in data.

42 = VolumeFluidSource,

// Volumetric liquid source.

// 1 component in data.

44 = VolumeGravityMassForce

// Gravity. 3 components in data:

// by X, Y, Z.

{

"id": <int>,

// Pin number.

"name": <string>,

// Description of pinning.

"flag": [int],

// An array of pinning types for each

// direction.

"data": [double | string]

// An array of arrays of GU component values.

// Each element is encoded in Base64

// (constant or array) of the main

// arrays, formulas are written as a string

// without encoding. Empty line for

// inactive GU component.

"apply_to":[int] | <string>,

// An array of entitys to which the GU is applied.

// It is encoded in Base64 with a single line.

// Entity type (node, side, element)

// depends on the GU used.

// It can have the string value "all",

// if applied to all entitys.

"apply_to_size": <unsigned int>,

// The number of entitys to which

// pinning is applied.

"dep_var_num": [double]

// Array of tabular dimensions

// dependencies of each GU component

// (number of rows in the table).

// In Base64, each element is basic

// arrays are encoded separately.

// Is equal to 0 for the constant and formula.

"dep_var_size": [int],

// Array of tabular dimensions

// dependencies of each GU component

// (number of rows in the table).

// Is equal to 0 for the constant and formula.

"dependency_type": [int | string],

// Array of dependency types

// for each component of the GU. With multidimensional

// tabular dependencies of one

// There may be several components

// TABULAR_* dependencies. Component

// the array is equal to an empty string for

// inactive GU component.

"step" : [int]

// The steps where the GU is active.

},

{...}

// The next GU.

0 = EmptyRestraint,

// There is no restraints. Used in arrays

// along with the rest of the options.

1 = Displacement,

// GU for moving and rotating nodes.

// The length of the array is 6.

// Example. "flag": [1, 0, 0, 0, 1, 0].

2 = Velocity,

// GU for velosity and turning speeds for nodes.

// The length of the array is 6.

3 = Temperature,

// Temperature GU for nodes.

// The length of the array is 1.

// Example. "flag": [3].

4 = TemperatureTop,

// Temperature on the upper surface. For nodes

// shell elements.

// It is used together with the TemperatureBottom.

// The length of the array is 2.

// Example. "flag": [4, 5].

5 = TemperatureBottom,

// Temperature on the lower surface. For nodes

// shell elements.

// It is used together with TemperatureTop.

// The length of the array is 2.

6 = TemperatureMiddle,

// Temperature for nodes on the median surface

// the shell element.

// It can be applied independently or

// together with the temperatureradient.

// The length of the array is 1 or 2.

// Example 1. "flag": [6].

// Example 2. "flag": [6, 7].

7 = TemperatureGradient,

// Temperature gradient for nodes

// the shell element.

// It can be applied independently or

// along with the TemperatureMiddle.

// The length of the array is 1 or 2.

// Example 1. "flag": [7].

9 = Acceleration,

// Acceleration and angular acceleration guidelines for nodes.

// The length of the array is 6.

// Example. "flag": [9, 0, 9, 0, 0, 0].

10 = PorePressure,

// Pore pressure GU for nodes.

// The length of the array is 1.

// Example. "flag": [10].

12 = DirectionDisplacement,

// GU in the direction of movement.

// It is applied to the faces of the elements.

// The length of the array is 1.

13 = DirectionVelocity,

// GO in the direction of velocity.

// It is applied to the faces of the elements.

// The length of the array is 1.

14 = DirectionAcceleration,

// GO in the acceleration direction.

// It is applied to the faces of the elements.

// The length of the array is 1.

15 = VolumeAngularVelocity,

// Angular velocity GU. Applies to the elements.

// The length of the array is 3.

// Example. "flag": [15, 15, 0].

{

"id": <int>,

// The number of the initial conditions (IC).

"name": <string>,

// The name of the IC.

"type": <int>,

// Type IC.

"flag": [int],

// An array of flags indicating for which

// initial conditions are set for the parameters :

// 0 - not specified, 1 - yes.

// The size of the array is 6 for data types.

// Displacement and Velocity,

// equal to 3 for the angularVelocity type, equal to 1 for

// of the Temperature and PorePressure types.

"apply_to":[int] | <string>,

// An array of node numbers to which NU is applied.

// It is encoded in Base64 as a single string.

// Can be replaced with the string "all" if IC

// applies to all nodes of the model.

"apply_to_size": <int>,

// The number of nodes to which the NU is applied.

"dep_var_size": [int]

// Array of dimensions of the tabular dependency

// for each component (number of rows in the table).

// Is equal to 0 for the constant and formula.

"dep_var_num": [double]

// Array of table dependency arguments

// (by columns if there are more than 1 dependencies).

// It is encoded in Base64 with a single line.

// Is equal to an empty string """ for a constant

// and formulas.

"data": [[double]|<string>]

// An array of arrays of NU component values.

// Each element is encoded in Base64 (constant

// or an array) of the main array, formulas

// written as a string without encoding.

// Empty string for inactive GU component.

"dependency_type": [int]

// The type of dependence of the component of the initial conditions.

// See const_types in the materials section.

}

{

"detection_tolerance": <double>,

// The accuracy of the tangential contact search.

"friction": <double>,

// Coefficient of friction. Used for

// contacts of the "general" type.

"id": <int>,

// The contact's number.

"ignore_overlap": <bool>,

// Ignores the initial overlap.

// It is used for contact type "general".

"name": <string>,

// The contact's name.

"step": [int],

// The steps where the contact is active.

"master_size": <int>,

// The number of nodes of the main entity.

"master": "[int, int]",

// Array of [element id, side id] pairs

// the main entity.

// It is encoded in Base64 as a single string.

"slave_size": <int>,

// The number of nodes of the side entity.

"slave": "[elem_id, face_id]",

// Array of [element id, side id] pairs

// a side entity.

// It is encoded in Base64 as a single string.

"type": <string>,

// The type of contact. Options: "general",

// "tied", "tied_normal", "tied_tangent".

"method": <string>,

// The method of setting the contact.

// Options: "auto", "penalty", "mpc".

"tolerance": <double>,

// The accuracy of the contact search is "general",

// "tied", "tied_normal".

"offset": <double>,

// Offset. It is used for contact types.

"preload": <double>,

// Preload. Used for contact

// of the "tied_tangent" type.

"normal_stiffness":<double>,

// Normal contact stiffness.

// It is used for the "penalty" method.

"tangent_stiffness": <double>,

// Tangential contact stiffness.

// It is used for the "penalty" method.

"search_radius": <double>,

// The radius of the contact surface search.

"max_overlap": <double>,

// Maximum penetration.

}

{

"id": <int>,

// Contact number.

"name": <string>,

// The name of the connection.

"cs": <int>,

// The CC in which the relationship is set.

"step": [int],

// The steps where the connection is active.

"master": [int],

// An array of nodes of the main entity.

//It is encoded in a single string in Base64.

"master_size": <int>,

// The number of nodes of the main entity.

"slave": [int],

// An array of nodes of a side entity.

// It is encoded in a single string in Base64.

"slave_size": <int>,

// The number of nodes of the side entity.

"type": <int>,

// The type of connection.

"dofs": [int],

// An array of degrees of freedom. There are always 6 components,

// the included degrees of freedom are 1,

// the rest are 0.

// For ELASTICITY type connections.

"stiffness": [double],

// Stiffness of the bond. Used for types

// ELASTICITY or DIRECTION links.

"direction": [double]

// Direction.

"master_dofs": [int],

// An array of degrees of freedom of the master entity.

// There are always 6 components, degrees included

// freedoms are 1, others are 0.

// For relations of the INTERPOLATION type.

"slave_dofs": [int],

// An array of degrees of freedom of a slave entity.

// There are always 6 components, degrees included

// freedoms are 1, others are 0.

// For relations of the INTERPOLATION type.

"distance_weighting": <bool>

// Includes calculation of the weighting coefficients of the connection

// depending on the distance between the entities.

// For relations of the INTERPOLATION type.

"factor": <int>

// Multiplier for link weights of type

// INTERPOLATION.

}

0 = ELASTICITY,

// Communication by movement/rotation

1 = TEMPERATURE,

// Temperature connection

2 = DISTANCE,

// Communication by Distance (RBE2)

3 = PORE_PRESSURE,

// Pore pressure connection

4 = DIRECTION,

// Communication by direction

5 = INTERPOLATION

// Interpolation coupling (RBE3)

{

id: <int>,

// GU number.

name: <string>,

// The name of the GU.

cs: <int>,

// The coordinate system in which the GU is applied.

step: [int],

// The steps where the GU is active.

master_size: <int>,

// The number of sides belonging to the master entity.

master: [int, int],

// An array of sides of the master entity, represented as

// pairs of [element id, face/edge id].

// In Base64, it is encoded with a single string.

slave_size: <int>,

// The number of sides belonging to the slave entity.

slave: [int, int],

// An array of sides of a slave entity, represented by

// as pairs of [element id, face/edge id].

// In Base64, it is encoded with a single string.

type: <int>,

// The type of periodic GU.

sectors: <int>

// The number of sectors.

}

{

id: <int>,

// The receiver set number.

name: <string>,

// The name of the receiver set.

apply_to: [<int>],

// Id of nodes that are receivers in the set.

apply_to_size: <int>,

// The number of receivers in the set.

type: <int>,

// The type of receiver set.

dofs: [<int>],

// Degrees of freedom to be deduced.

// Required parameter for all types of sets,

// except PRESSURE.

output_step: <int>

// Save the results every output_step steps.

},

{...}

// The next set of receivers.

{

"type": <string>,

// The type of calculation.

// Options: "static", "dynamic",

// "eigenfrequencies", "buckling",

// "spectrum", "harmonic", "effectiveprops".

"dimensions":<string>,

// The dimension of the problem. Options: "2D", "3D".

"plane_state": <string>,

// Types of calculations for the "2D" dimension.

// Options: "p-stress", "p-strain",

// "axisym_x", "axisym_y".

"permission_write": <bool>,

// Allow writing to hard disk if

// insufficient RAM.

"periodic_bc": <bool>,

// Periodic GU for calculation

// effective properties.

"finite_deformations": <bool>,

// Enable finite deformations.

"elasticity": <bool>,

// Turn on the elasticity.

"plasticity": <bool>,

// Enable plasticity.

"heat_transfer": <bool>,

// Turn on the heat transfer conductivity.

"porefluid_transfer" : <bool>,

// Turn on porefluid transfer  conduction.

"slm" : <bool>,

// Enable additive manufacturing.

"incompressibility": <bool>,

// Enable incompressibility.

"preload": <bool>,

// The preloaded model.

"lumpmass": <bool>,

// Use a lumped one

// the diagonal mass matrix.

"radiation_among_surfaces" : <bool>,

// Turn on the radiant heat exchange.

"linear_solver": {...},

// Linear solver settings.

"nonlinear_solver": {...},

// Settings of the nonlinear solver.

"damping": {...},

// Damping settings.

"thermal_gap_settings": {...},

// Termal gap solver settings.

"eigen_solver": {...},

// Settings of the natural eigen solver.

dynamics: {...},

// Dynamic calculation settings.

"statics" : {...},

// Static calculation settings.

"harmonic": {...},

// Harmonic calculation settings.

"output": {...},

// Data output settings.

"test_opts": {...}

// Settings of the debug version of the kernel.

}

{

"method": <string>,

// The SLOUGH solution method. Options: "auto",

"direct", "iterative".

iter_opts:

// Iterative solver settings.

{

"epsilon": <double>,

// Epsilon accuracy.

"stopping_criteria": <double>,

// Absolute accuracy.

"max_iterations": <int>,

// The maximum number of iterations.

"preconditioner": <string>

// Choosing a preconditioner.

// Options: "auto", "no", "diagonal",

// "ilu0", "ilu2", "ilut".

}

"on_fail": <bool>,

// Use other methods in case of error.

// Only for the "auto" method.

"use_uzawa": <string>,

// Use the Uzawa method.

// Options: "auto", "yes", "no".

"uzawa_max_iterations": <int>,

// Maximum number of iterations

// The Uzawa method.

"uzawa_rel_precision": <double>

// The relative accuracy of the Uzawa method.

}

{

"arc_method": <bool>,

// Enable the bordering arcs method.

"line_search": <bool>,

// Enable linear search.

"max_iterations": <int>,

// The maximum number of iterations.

"min_load_steps": <int>,

// The minimum number of loading steps.

"max_load_steps": <int>,

// The maximum number of loading steps.

"tolerance": <double>,

// Tolerance.

"target_iter": <int>

// The target number of iterations.

}

{

number: <int> | <string>,

// The number of natural frequencies.

// If you need to print everything

// in the range, then the parameter

// becomes a string with the value "all".

target: <double> | [double],

// The target frequency value or

// frequency range

// (2 values in the array).

solver: <string>,

// The solution method. Options:

// "auto", "krylovschur",

// "arnoldi", "lanczos", "gd", "jd".

spectr_trans:

// Spectral settings

// transformations.

{

"name": <string>,

// Name of the spectral

// transformations.

// Options: "auto", "shift",

// "shift_invert", "general_cayley".

"shift_value": <double>,

// Shift value for methods

// "shift", "shift_invert" or"general_cayley".

"anti_shift_value": <double>

// Reverse shift value

// for the general_cayley method.

},

linear_solver:

// Linear solver settings for the midrange.

{

solver: <string>,

// The SLOUGH solver. Options:

// "auto", "direct", "iterative".

method: <string>,

// The type of iterative solver.

// Options: "auto", "preonly",

// "cg", "gmres","richardson",

// "chebyshev", "bicg", "bcgs",

// "minres", "tfqmr", "cr", "gcr".

preconditioner:

// The type of preconditioner.

// Options: "auto", "lu",

// "none", "jacobi", "bjacobi",

// "sor", "ssor", "ilu", "asm".

iter_opts:

// Iterative settings

// the number solver.

{

linear_absolute_tolerance: <double>,

// Absolute tolerance.

linear_relative_tolerance: <double>,

// Relative tolerance.

linear_max_iterations: <int>,

// The maximum number of iterations.

linear_divergence_tolerance: <double>

// Acceptable deviation.

}

}

relative_tolerance: <float value>,

// Relative tolerance

// the number solver.

absolute_tolerance: float value,

// Absolute tolerance of the counter solver.

eps_max_iterations: <int value>,

// Maximum number of iterations

// the number solver.

evaluate_effective_mass: <bool value>,

// Calculate effective masses.

rotation_center: [double]

// An array of 3 values defining

//the point relative to which to count

// moments of inertia of the model

// when enabled

// evaluate_effective_mass.

}

{

"use" : <bool>,

// Use damping in the calculation.

"structural": <double>,

// The value of structural damping.

"mass_matrix": <double>,  

// The damping value of the mass matrix.

"stiffness_matrix": <double>,

// The damping value of the stiffness matrix.

"coriolis": <bool>,

// Consider the Coriolis effect.

}

{

"start_temp":  <double>,

// The initial temperature.

"end_temp": <double>,

// The end temperature.

"step_temp":  <double>,  

// The temperature step.

"scatangle_eps": <double>,

// The tolerance of the scattering angle.

"impact_eps":  <double>,

// The tolerance of the aiming parameter.

"velocity_eps":  <double>,

// Relative velocity tolerance.

}

{

"result_output_time": <double>,

// Output of results every

// result_output_time time interval.

// Mutually exclusive parameter with

//"result_output_iter" and "result_number".

"result_output_iter": <int>,

// Output of results every

// result_output_iter step.

"result_number": <int>,   

// The total number of output steps.

"steps_count": <int>

// The number of static steps.

}

{

method: <string>,

// The solution method. Options:

// "full_solution", "mod_superposition".

scheme: <string>,

// The scheme of the solution. Options:

// "explicit", "implicit".

max_time: <double>,

// The maximum decision time.

time_step: <double>,

// Time step.

steps_count: <int>,

// The number of time steps.

courant: <double>=0=1,

// The number of the Courant.

// Only for the explicit schema.

max_steps_count: <int>,

// Maximum number of steps.

// Only for the explicit schema.

newmark_gamma: <double>,

// A parameter of the Newmark scheme.

// Only for the implicit schema.

"result_output_time": <double>

// Output of results every

// result_output_time time interval.

// Mutually exclusive parameter with

// parameters "result_output_iter"

and result_number.

"result_output_iter": <int>,

// Output of results every

// result_output_iter step.

"result_number": <int>,

// The total number of output steps.

mod_count: <int>

// The number of modes in the superposition method.

},

{

"method":  <string>,  

// The solution method. The value is only

// "mod_superposition".

"frequency_step": <double>,

// The frequency step for the selected range.  

// A mutually exclusive parameter with "steps_count".

"steps_count": <int>

// The number of steps in the selected range.

}

{

"print_matrix_full": <bool>,   

// Output the full version of the matrix.   

"print_matrix_txt": <bool>,

// Output a text version of the matrix.

"print_matrix_bin": <bool>,  

// Output the binary version of the matrix.  

"print_matrix_ccs": <bool>,

// Output the ccs version of the matrix.  

"precision": <int>,

// Number of decimal places

// when the matrix is output.

"output_iteration_results": <bool>

// Output the result in iterations.

}

{

"energy": <bool>,

// Calculate kinetic energy

// and the strain energy.

"intermediate_results": <bool>,

// Output an intermediate result.

// Only for non-linear tasks.

"log": <bool>,

// Output Log.

"normal_force": <bool>,

// Calculate the reaction force of the support.

"record3d": <bool>,

// Record 3D view for girders/

// shell models.

"vtu": <bool>,

// Output VTU.

"full_periodic": <bool>,

// Output a complete model for

// periodic GU.

"material": <bool>,

// Display the properties of materials.

"model_properties": <bool>,

// Output model properties.

"without_smoothing": <bool>

// Turn off the results without smoothing .

}