Skip to main content

C Interfaces for Participant Library

Provides C interfaces to the System Coupling participant library.

The C interface closely follows the C++ interface, and is implemented as a wrapper around the latter.

Enumeration types​

Enumeration type SyscLocation​

Definition: syscCommonTypes.h (line 26)

enum SyscLocation {
  SyscNode = 0,
  SyscElement = 1
}

Provide an enum for variable mesh locations.

Enumerator SyscNode​

Nodal data.

Enumerator SyscElement​

Data on elements.

Enumeration type SyscTensorType​

Definition: syscCommonTypes.h (line 32)

enum SyscTensorType {
  SyscScalar = 0,
  SyscVector = 1
}

Provide an enum for variable tensor type.

Enumerator SyscScalar​

Scalar

Enumerator SyscVector​

Vector

Enumeration type SyscTopology​

Definition: syscCommonTypes.h (line 38)

enum SyscTopology {
  SyscSurface = 2,
  SyscVolume = 3
}

Provide an enum for region topologies.

Enumerator SyscSurface​

Surface topology.

Enumerator SyscVolume​

Volume topology.

Enumeration type SyscRegionDiscretizationType​

Definition: syscCommonTypes.h (line 44)

enum SyscRegionDiscretizationType {
  SyscMeshRegion = 0,
  SyscPointCloudRegion = 1
}

Provide an enum for region mesh type.

Enumerator SyscMeshRegion​

Mesh region discretization.

Enumerator SyscPointCloudRegion​

Point cloud region discretization.

Enumeration type SyscInterfaceSide​

Definition: syscCommonTypes.h (line 50)

enum SyscInterfaceSide {
  SyscInterfaceSide_One = 1,
  SyscInterfaceSide_Two = 2
}

Provide enum for coupling interface side.

Enumerator SyscInterfaceSide_One​

Enumerator SyscInterfaceSide_Two​

Enumeration type SyscDimension​

Definition: syscCommonTypes.h (line 56)

enum SyscDimension {
  SyscD2 = 2,
  SyscD3 = 3
}

Provide enum for system coupling dimension.

Enumerator SyscD2​

Enumerator SyscD3​

Enumeration type SyscTimeIntegration​

Definition: syscCommonTypes.h (line 62)

enum SyscTimeIntegration {
  SyscImplicit = 0,
  SyscExplicit = 1
}

Provide an enum for time integration.

Enumerator SyscImplicit​

Enumerator SyscExplicit​

Enumeration type SyscQuantityType​

Definition: syscCommonTypes.h (line 91)

enum SyscQuantityType {
  SyscUnspecified = 0,
  SyscForce = 1,
  SyscIncrementalDisplacement = 2,
  SyscTemperature = 3,
  SyscHeatRate = 4,
  SyscHeatTransferCoefficient = 5,
  SyscConvectionReferenceTemperature = 6,
  SyscModeShape = 7,
  SyscElectricalConductivity = 8
}

Provide an enum for supported quantity types.

Quantity type provides information about the physical meaning of the variable. This can be useful for detecting validation errors during the coupled analysis setup. If the variable does not match any of the provided quantity types, quantity type can be set to unspecified.

Enumerator SyscUnspecified​

Enumerator SyscForce​

Enumerator SyscIncrementalDisplacement​

Enumerator SyscTemperature​

Enumerator SyscHeatRate​

Enumerator SyscHeatTransferCoefficient​

Enumerator SyscConvectionReferenceTemperature​

Enumerator SyscModeShape​

Enumerator SyscElectricalConductivity​

Enumeration type SyscDataType​

Definition: syscCommonTypes.h (line 103)

enum SyscDataType {
  SyscDataType_Real = 0,
  SyscDataType_Complex = 1
}

Enumerator SyscDataType_Real​

Enumerator SyscDataType_Complex​

Enumeration type SyscConvergenceStatus​

Definition: syscCommonTypes.h (line 109)

enum SyscConvergenceStatus {
  SyscDiverging = -1,
  SyscNotYetConverged = 0,
  SyscConverged = 1,
  SyscComplete = 2,
  SyscNotEvaluated = 3
}

Provide enum for participant's solver convergence status.

Enumerator SyscDiverging​

Enumerator SyscNotYetConverged​

Enumerator SyscConverged​

Enumerator SyscComplete​

Enumerator SyscNotEvaluated​

Enumeration type SyscAnalysisType​

Definition: syscCommonTypes.h (line 118)

enum SyscAnalysisType {
  SyscSteady = 0,
  SyscTransient = 1
}

Provide an enum for coupled analysis type.

Enumerator SyscSteady​

Steady analysis type.

Enumerator SyscTransient​

Transient (unsteady) analysis type.

Enumeration type SyscPrimitiveType​

Definition: syscCommonTypes.h (line 147)

enum SyscPrimitiveType {
  SyscFloat = 0,
  SyscDouble = 1,
  SyscInt32 = 2,
  SyscInt64 = 3,
  SyscUnsignedInt16 = 4,
  SyscUnsignedInt64 = 5
}

Provide an enum for supported primitive types.

Enumerator SyscFloat​

Single-precision floating point type.

Enumerator SyscDouble​

Double-precision floating point type.

Enumerator SyscInt32​

Signed 32-bit integer.

Enumerator SyscInt64​

Signed 64-bit integer.

Enumerator SyscUnsignedInt16​

Unsigned 16-bit integer.

Enumerator SyscUnsignedInt64​

Unsigned 64-bit integer.

Enumeration type SyscParticipantType​

Definition: syscCommonTypes.h (line 156)

enum SyscParticipantType {
  SyscDEFAULT = 0,
  SyscCFX = 1,
  SyscFLUENT = 2,
  SyscMAPDL = 3,
  SyscAEDT = 4,
  SyscFMU = 5,
  SyscFMU_PROXY = 6,
  SyscEXTERNALDATA = 7,
  SyscFORTE = 8,
  SyscDEFAULT_SRV = 9,
  SyscMECH_SRV = 10,
  SyscCFD_SRV = 11,
  SyscSCDT_SRV = 12,
  SyscTHERMAL_DESKTOP = 13,
  SyscLS_DYNA = 14,
  SyscROCKY = 15
}

Enumerator SyscDEFAULT​

Enumerator SyscCFX​

Enumerator SyscFLUENT​

Enumerator SyscMAPDL​

Enumerator SyscAEDT​

Enumerator SyscFMU​

Enumerator SyscFMU_PROXY​

Enumerator SyscEXTERNALDATA​

Enumerator SyscFORTE​

Enumerator SyscDEFAULT_SRV​

Enumerator SyscMECH_SRV​

Enumerator SyscCFD_SRV​

Enumerator SyscSCDT_SRV​

Enumerator SyscTHERMAL_DESKTOP​

Enumerator SyscLS_DYNA​

Enumerator SyscROCKY​

Enumeration type SyscElementTypes​

Definition: syscElementTypes.h (line 238)

enum SyscElementTypes {
  SyscTri3 = 5,
  SyscTri6 = 6,
  SyscQuad4 = 7,
  SyscQuad8 = 8,
  SyscTet4 = 9,
  SyscTet10 = 10,
  SyscHex8 = 11,
  SyscHex20 = 12,
  SyscWedge6 = 13,
  SyscWedge15 = 14,
  SyscPyramid5 = 15,
  SyscPyramid13 = 16,
  SyscPolygon = 18,
  SyscPolyhedron = 19
}

Provide an enum for element types.

Enumerator SyscTri3​

Trilateral element with corner nodes only.

Enumerator SyscTri6​

Trilateral element with corner and mid-side nodes.

Enumerator SyscQuad4​

Quadrilateral element with corner nodes only.

Enumerator SyscQuad8​

Quadrilateral element with corner and mid-side nodes.

Enumerator SyscTet4​

Tetrahedral element with corner nodes only.

Enumerator SyscTet10​

Tetrahedral element with corner and mid-side nodes.

Enumerator SyscHex8​

Hexahedral element with corner nodes only.

Enumerator SyscHex20​

Hexahedral element with corner and mid-side nodes.

Enumerator SyscWedge6​

Wedge element with corner nodes only.

Enumerator SyscWedge15​

Wedge element with corner and mid-side nodes.

Enumerator SyscPyramid5​

Pyramid element with corner nodes only.

Enumerator SyscPyramid13​

Pyramid element with corner and mid-side nodes.

Enumerator SyscPolygon​

Arbitrary polygon.

Enumerator SyscPolyhedron​

Arbitrary polyhedron.

Typedefs​

Typedef SyscSolutionControl​

Definition: syscCommonTypes.h (line 134)

typedef struct SyscSolutionControl SyscSolutionControl

Provide a structure containing solution control.

Return type: struct SyscSolutionControl

Typedef SyscOpaqueDataAccess​

Definition: syscCommonTypes.h (line 175)

typedef void* SyscOpaqueDataAccess

Declare an opaque pointer type.

Return type: void *

Typedef SyscSetupInfo​

Definition: syscCommonTypes.h (line 197)

typedef struct SyscSetupInfo SyscSetupInfo

Provide a structure for System Coupling setup information.

To create and/or initialize the SyscSetupInfo struct, it is highly recommended to use one of the functions with names starting with syscGetSetupInfo. These functions will initialize all members to the correct values and will help to avoid back-compatibility issues in the future. For example:

SyscSetupInfo setupInfo = syscGetSetupInfoA(SyscSteady);

Return type: struct SyscSetupInfo

Typedef SyscSetupFileInfo​

Definition: syscCommonTypes.h (line 297)

typedef struct SyscSetupFileInfo SyscSetupFileInfo

Provide a structure for writing System Coupling setup files.

To create and/or initialize the SyscSetupFileInfo struct, it is highly recommended to use syscGetSetupFileInfo function. This function will initialize all members to the correct values and will help to avoid back-compatibility issues in the future. For example:

SyscSetupFileInfo setupFileInfo = syscGetSetupFileInfo("setup.scp");

Return type: struct SyscSetupFileInfo

Typedef SyscResultsInfo​

Definition: syscCommonTypes.h (line 316)

typedef struct SyscResultsInfo SyscResultsInfo

Provide a structure for writing results files.

Return type: struct SyscResultsInfo

Typedef SyscCouplingInterface​

Definition: syscCouplingInterface.h (line 47)

typedef struct SyscCouplingInterface SyscCouplingInterface

Provide a struct for a coupling interface.

Coupling interface can be used to set up the transfers of data between different regions within the same participant solver. Interface contains two sides and each side can contain one or more regions. Data transfers are automatically defined: if a variable is defined as an output on all regions on one side of the interface and as an input on all regions on the opposide side of the interface, then it will be mapped from the former side to the latter side.

All regions on one side of the interface must have the same topology.

To create and/or initialize the SyscCouplingInterface struct, it is highly recommended to use the syscGetCouplingInterface function. This function will initialize all members to the correct values and will help to avoid back-compatibility issues in the future. For example:

SyscCouplingInterface reg = syscGetCouplingInterface("FSI");

Return type: struct SyscCouplingInterface

Typedef SyscDataTransfer​

Definition: syscDataTransfer.h (line 33)

typedef struct SyscDataTransfer SyscDataTransfer

Provide a struct for a data transfer.

Data transfer specifies the source and target variables for mapping.

Return type: struct SyscDataTransfer

Typedef SyscInputScalarDataAccess​

Definition: syscFunctionTypes.h (line 39)

typedef SyscInputScalarData(* SyscInputScalarDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to input scalar data.

Return type: SyscInputScalarData(*

Typedef SyscInputScalarDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 46)

typedef SyscInputScalarData(* SyscInputScalarDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to input scalar data with opaque pointer.

Return type: SyscInputScalarData(*

Typedef SyscInputScalarDataMultiZoneAccess​

Definition: syscFunctionTypes.h (line 54)

typedef SyscInputScalarData(* SyscInputScalarDataMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone input scalar data.

Return type: SyscInputScalarData(*

Typedef SyscInputVectorDataAccess​

Definition: syscFunctionTypes.h (line 63)

typedef SyscInputVectorData(* SyscInputVectorDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to input vector data.

Return type: SyscInputVectorData(*

Typedef SyscInputVectorDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 70)

typedef SyscInputVectorData(* SyscInputVectorDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to input vector data with opaque pointer.

Return type: SyscInputVectorData(*

Typedef SyscInputVectorDataMultiZoneAccess​

Definition: syscFunctionTypes.h (line 78)

typedef SyscInputVectorData(* SyscInputVectorDataMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone input vector data.

Return type: SyscInputVectorData(*

Typedef SyscOutputScalarDataAccess​

Definition: syscFunctionTypes.h (line 87)

typedef SyscOutputScalarData(* SyscOutputScalarDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to output scalar data.

Return type: SyscOutputScalarData(*

Typedef SyscOutputScalarDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 94)

typedef SyscOutputScalarData(* SyscOutputScalarDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to output scalar data with opaque pointer.

Return type: SyscOutputScalarData(*

Typedef SyscOutputScalarDataMultiZoneAccess​

Definition: syscFunctionTypes.h (line 102)

typedef SyscOutputScalarData(* SyscOutputScalarDataMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone output scalar data.

Return type: SyscOutputScalarData(*

Typedef SyscOutputVectorDataAccess​

Definition: syscFunctionTypes.h (line 111)

typedef SyscOutputVectorData(* SyscOutputVectorDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to output vector data.

Return type: SyscOutputVectorData(*

Typedef SyscOutputVectorDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 118)

typedef SyscOutputVectorData(* SyscOutputVectorDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to output vector data with opaque pointer.

Return type: SyscOutputVectorData(*

Typedef SyscOutputVectorDataMultiZoneAccess​

Definition: syscFunctionTypes.h (line 126)

typedef SyscOutputVectorData(* SyscOutputVectorDataMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone output vector data.

Return type: SyscOutputVectorData(*

Typedef SyscInputComplexScalarDataAccess​

Definition: syscFunctionTypes.h (line 135)

typedef SyscInputComplexScalarData(* SyscInputComplexScalarDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to input complex scalar data.

Return type: SyscInputComplexScalarData(*

Typedef SyscInputComplexScalarDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 142)

typedef SyscInputComplexScalarData(* SyscInputComplexScalarDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to input complex scalar data with opaque pointer.

Return type: SyscInputComplexScalarData(*

Typedef SyscInputComplexVectorDataAccess​

Definition: syscFunctionTypes.h (line 150)

typedef SyscInputComplexVectorData(* SyscInputComplexVectorDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to input complex vector data.

Return type: SyscInputComplexVectorData(*

Typedef SyscInputComplexVectorDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 157)

typedef SyscInputComplexVectorData(* SyscInputComplexVectorDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to input complex vector data with opaque pointer.

Return type: SyscInputComplexVectorData(*

Typedef SyscOutputComplexScalarDataAccess​

Definition: syscFunctionTypes.h (line 165)

typedef SyscOutputComplexScalarData(* SyscOutputComplexScalarDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to output complex scalar data.

Return type: SyscOutputComplexScalarData(*

Typedef SyscOutputComplexScalarDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 172)

typedef SyscOutputComplexScalarData(* SyscOutputComplexScalarDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to output complex scalar data with opaque pointer.

Return type: SyscOutputComplexScalarData(*

Typedef SyscOutputComplexVectorDataAccess​

Definition: syscFunctionTypes.h (line 180)

typedef SyscOutputComplexVectorData(* SyscOutputComplexVectorDataAccess) (const char *regionName, const char *variableName)

Provide function prototype for access to output complex vector data.

Return type: SyscOutputComplexVectorData(*

Typedef SyscOutputComplexVectorDataAccessWithPointer​

Definition: syscFunctionTypes.h (line 187)

typedef SyscOutputComplexVectorData(* SyscOutputComplexVectorDataAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, const char *variableName)

Provide function prototype for access to output complex vector data with opaque pointer.

Return type: SyscOutputComplexVectorData(*

Typedef SyscSurfMeshAccess​

Definition: syscFunctionTypes.h (line 195)

typedef SyscSurfaceMesh(* SyscSurfMeshAccess) (const char *regionName)

Provide function prototype for access to surface mesh.

Return type: SyscSurfaceMesh(*

Typedef SyscSurfaceMeshAccessWithPointer​

Definition: syscFunctionTypes.h (line 201)

typedef SyscSurfaceMesh(* SyscSurfaceMeshAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName)

Provide function prototype for access to surface mesh with opaque pointer.

Return type: SyscSurfaceMesh(*

Typedef SyscSurfaceMeshMultiZoneAccess​

Definition: syscFunctionTypes.h (line 206)

typedef SyscSurfaceMesh(* SyscSurfaceMeshMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone surface mesh.

Return type: SyscSurfaceMesh(*

Typedef SyscVolumeMeshAccess​

Definition: syscFunctionTypes.h (line 214)

typedef SyscVolumeMesh(* SyscVolumeMeshAccess) (const char *regionName)

Provide function prototype for access to volume mesh.

Return type: SyscVolumeMesh(*

Typedef SyscVolumeMeshAccessWithPointer​

Definition: syscFunctionTypes.h (line 220)

typedef SyscVolumeMesh(* SyscVolumeMeshAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName)

Provide function prototype for access to volume mesh with opaque pointer.

Return type: SyscVolumeMesh(*

Typedef SyscVolumeMeshMultiZoneAccess​

Definition: syscFunctionTypes.h (line 225)

typedef SyscVolumeMesh(* SyscVolumeMeshMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone volume mesh.

Return type: SyscVolumeMesh(*

Typedef SyscPointCloudAccess​

Definition: syscFunctionTypes.h (line 233)

typedef SyscPointCloud(* SyscPointCloudAccess) (const char *regionName)

Provide function prototype for access to point cloud.

Return type: SyscPointCloud(*

Typedef SyscPointCloudAccessWithPointer​

Definition: syscFunctionTypes.h (line 239)

typedef SyscPointCloud(* SyscPointCloudAccessWithPointer) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName)

Provide function prototype for access to point cloud with an opaque pointer.

Return type: SyscPointCloud(*

Typedef SyscPointCloudMultiZoneAccess​

Definition: syscFunctionTypes.h (line 244)

typedef SyscPointCloud(* SyscPointCloudMultiZoneAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName, uint16_t zoneIndex)

Provide function prototype for access to multi-zone point cloud.

Return type: SyscPointCloud(*

Typedef SyscZoneCountAccess​

Definition: syscFunctionTypes.h (line 252)

typedef uint16_t(* SyscZoneCountAccess) (SyscOpaqueDataAccess opaqueDataAccess, const char *regionName)

Provide function prototype for access to zone count.

Return type: uint16_t(*

Typedef SyscRestartPointCreation​

Definition: syscFunctionTypes.h (line 263)

typedef const char*(* SyscRestartPointCreation) ()

Provide function prototype for creating restart points.

This function may be called only during outputs update, and is expected to return a unique string identifier for a given restart point.

Return type: const char (

Typedef SyscParameter​

Definition: syscParameter.h (line 29)

typedef struct SyscParameter SyscParameter

Provide a struct for a System Coupling parameter.

Return type: struct SyscParameter

Typedef SyscRegion​

Definition: syscRegion.h (line 47)

typedef struct SyscRegion SyscRegion

Provide a struct for a System Coupling region.

Participant can declare which regions can be used in the coupled analysis. Each region can declare its input variables and output variables. Input variables represent physical quantities whose values the participant expects System Coupling to provide. Output variables represent physical quantities whose values System Coupling expects the participant to provide.

To create and/or initialize the SyscRegion struct, it is highly recommended to use one of the functions with names starting with syscGetRegion. These functions will initialize all members to the correct values and will help to avoid back-compatibility issues in the future. For example:

SyscRegion reg = syscGetRegionT("Wall", SyscSurface);

Return type: struct SyscRegion

Typedef SyscVariable​

Definition: syscVariable.h (line 45)

typedef struct SyscVariable SyscVariable

Provide a struct for a System Coupling variable.

To create and/or initialize the SyscVariable struct, it is highly recommended to use one of the functions with names starting with syscGetVariable. These functions will initialize all members to the correct values and will help to avoid back-compatibility issues in the future. For example:

SyscVariable var = syscGetVariableTE(
  "Temperature", SyscScalar, 0, SyscNode);

Return type: struct SyscVariable

Functions​

Function syscGetRealAttribute​

SyscRealAttribute syscGetRealAttribute(const char *name, double value, SyscDimensionality dimensionality)

Create a real-valued attribute.

Parameters:

  • name: - attribute name.
  • value: - attribute value.
  • dimensionality: - attribute dimensionality.

Parameters:

Return type: SyscRealAttribute

Function syscGetRealAttributeVDM​

SyscRealAttribute syscGetRealAttributeVDM(const char *name, double value, SyscDimensionality dimensionality, int modifiable)

Create a real-valued attribute.

Parameters:

  • name: - attribute name.
  • value: - attribute value.
  • dimensionality: - attribute dimensionality.
  • modifiable: - attribute is modifiable.

Parameters:

Return type: SyscRealAttribute

Function syscGetIntegerAttribute​

SyscIntegerAttribute syscGetIntegerAttribute(const char *name, long long int value)

Create an integer-valued attribute.

Parameters:

  • name: - attribute name.
  • value: - attribute value.

Parameters:

  • const char * name
  • long long int value

Return type: SyscIntegerAttribute

Function syscGetIntegerAttributeVM​

SyscIntegerAttribute syscGetIntegerAttributeVM(const char *name, long long int value, int modifiable)

Create an integer-valued attribute.

Parameters:

  • name: - attribute name.
  • value: - attribute value.
  • modifiable: - attribute is modifiable.

Parameters:

  • const char * name
  • long long int value
  • int modifiable

Return type: SyscIntegerAttribute

Function syscGetDimensionality​

SyscDimensionality syscGetDimensionality()

Get dimensionality.

Return type: SyscDimensionality

Function syscGetSyscError​

SyscError syscGetSyscError(int retcode, const char *message)

Provide a function to return SyscError struct.

Parameters:

  • int retcode
  • const char * message

Return type: SyscError

Function syscGetSetupInfo​

SyscSetupInfo syscGetSetupInfo()

Create a setup info struct.

Analysis type will be set to steady. Restarts supported flag will be set to false.

Return type: SyscSetupInfo

Function syscGetSetupInfoA​

SyscSetupInfo syscGetSetupInfoA(enum SyscAnalysisType analysisType)

Create a setup info struct.

Parameters:

  • analysisType: - analysis type.

Restarts supported flag will be set to false.

Parameters:

Return type: SyscSetupInfo

Function syscGetSetupInfoAR​

SyscSetupInfo syscGetSetupInfoAR(enum SyscAnalysisType analysisType, int restartsSupported)

Create a setup info struct.

Parameters:

  • analysisType: - analysis type.
  • restartsSupported: - flag indicating whether restarts are supported.

Parameters:

Return type: SyscSetupInfo

Function syscGetSetupInfoARD​

SyscSetupInfo syscGetSetupInfoARD(enum SyscAnalysisType analysisType, int restartsSupported, enum SyscDimension dimension)

Create a setup info struct.

Parameters:

  • analysisType: - analysis type.
  • restartsSupported: - flag indicating whether restarts are supported.
  • dimension: - dimension of the participant.

Parameters:

Return type: SyscSetupInfo

Function syscGetSetupInfoARDT​

SyscSetupInfo syscGetSetupInfoARDT(enum SyscAnalysisType analysisType, int restartsSupported, enum SyscDimension dimension, enum SyscTimeIntegration timeIntegration)

Create a setup info struct.

Parameters:

  • analysisType: - analysis type.
  • restartsSupported: - flag indicating whether restarts are supported.
  • dimension: - dimension of the participant.
  • timeIntegration: - Time integration method

Parameters:

Return type: SyscSetupInfo

Function syscGetSetupInfoARDTP​

SyscSetupInfo syscGetSetupInfoARDTP(enum SyscAnalysisType analysisType, int restartsSupported, enum SyscDimension dimension, enum SyscTimeIntegration timeIntegration, enum SyscParticipantType participantType)

Create a setup info struct.

Parameters:

  • analysisType: - analysis type.
  • restartsSupported: - flag indicating whether restarts are supported.
  • dimension: - dimension of the participant.
  • timeIntegration: - Time integration method
  • participantType: - Participant type

Parameters:

Return type: SyscSetupInfo

Function syscGetSetupFileInfo​

SyscSetupFileInfo syscGetSetupFileInfo(const char *setupFileName)

Provide a function to create SetupFileInfo struct.

Parameters:

  • setupFileName: Setup file name.

Restarts supported flag will be set to false.

Parameters:

  • const char * setupFileName

Return type: SyscSetupFileInfo

Function syscGetResultsInfo​

SyscResultsInfo syscGetResultsInfo(const char *baseFileName)

Provide a function to create SetupFileInfo struct.

Parameters:

  • baseFileName: - base results file name.

Parameters:

  • const char * baseFileName

Return type: SyscResultsInfo

Function syscGetCouplingInterface​

SyscCouplingInterface syscGetCouplingInterface(const char *name)

Create a coupling interface.

Parameters:

  • name: - Unique name for this interface. String length should not exceed SYSC_STRING_LENGTH.

Parameters:

  • const char * name

Return type: SyscCouplingInterface

Function syscAddSideOneRegion​

SyscError syscAddSideOneRegion(const SyscCouplingInterface couplingInterface, const SyscRegion region)

Add region to side one of the interface.

If this region has already been added to the interface on side one, then this call will have no effect.

If a different region with the same name has already been added to the interface on side one, then a runtime error will be thrown.

If a region with the same name has already been added to the interface on side two, then a runtime error will be thrown.

If the region name contains invalid characters, a runtime error will be thrown.

Parameters:

  • couplingInterface: Coupling interface to which the output variable is to be added.
  • region: Region to be added to side one of the interface.

Parameters:

Return type: SyscError

Function syscAddSideTwoRegion​

SyscError syscAddSideTwoRegion(const SyscCouplingInterface couplingInterface, const SyscRegion region)

Add region to side two of the interface.

If this region has already been added to the interface on side two, then this call will have no effect.

If a different region with the same name has already been added to the interface on side two, then a runtime error will be thrown.

If a region with the same name has already been added to the interface on side one, then a runtime error will be thrown.

If the region name contains invalid characters, a runtime error will be thrown.

Parameters:

  • couplingInterface: Coupling interface to which the output variable is to be added.
  • region: Region to be added to side two of the interface.

Parameters:

Return type: SyscError

Function syscAddDataTransfer​

SyscError syscAddDataTransfer(SyscCouplingInterface couplingInterface, SyscDataTransfer dataTransfer)

Add the data transfer to the coupling interface.

Parameters:

Return type: SyscError

Function syscCouplingInterfaceGetNumDataTransfers​

size_t syscCouplingInterfaceGetNumDataTransfers(SyscCouplingInterface couplingInterface)

Get number of data transfer for a given coupling interface.

Parameters:

Return type: size_t

Function syscCouplingInterfaceGetNumSideOneRegions​

size_t syscCouplingInterfaceGetNumSideOneRegions(SyscCouplingInterface couplingInterface)

Get number of side one regions for a given coupling interface.

Parameters:

Return type: size_t

Function syscCouplingInterfaceGetNumSideTwoRegions​

size_t syscCouplingInterfaceGetNumSideTwoRegions(SyscCouplingInterface couplingInterface)

Get number of side two regions for a given coupling interface.

Parameters:

Return type: size_t

Function syscCouplingInterfaceGetDataTransfer​

SyscDataTransfer syscCouplingInterfaceGetDataTransfer(SyscCouplingInterface couplingInterface, size_t index)

Get the data transfer at specified index for a given coupling interface.

Parameters:

Return type: SyscDataTransfer

Function syscCouplingInterfaceGetSideOneRegion​

SyscRegion syscCouplingInterfaceGetSideOneRegion(SyscCouplingInterface couplingInterface, size_t index)

Get the side one region at specified index for a given coupling interface.

Parameters:

Return type: SyscRegion

Function syscCouplingInterfaceGetSideTwoRegion​

SyscRegion syscCouplingInterfaceGetSideTwoRegion(SyscCouplingInterface couplingInterface, size_t index)

Get the side two region at specified index for a given coupling interface.

Parameters:

Return type: SyscRegion

Function syscGetDataTransfer​

SyscDataTransfer syscGetDataTransfer(SyscVariable sideOneVariable, SyscVariable sideTwoVariable, enum SyscInterfaceSide targetSide)

Create a data transfer using sideOneVariable and sideTwoVariable.

Parameters:

  • sideOneVariable: - side one variable.
  • sideTwoVariable: - side two variable.
  • targetSide: - target side.

Parameters:

Return type: SyscDataTransfer

Function syscGetDataTransferST​

SyscDataTransfer syscGetDataTransferST(SyscVariable sourceVariable, SyscVariable targetVariable, enum SyscInterfaceSide targetSide)

Create a data transfer using "source|target"Variable.

Parameters:

  • sourceVariable: - source variable.
  • targetVariable: - target variable.
  • targetSide: - target side.

Parameters:

Return type: SyscDataTransfer

Function syscGetInputComplexScalarData​

SyscInputComplexScalarData syscGetInputComplexScalarData()

Create an empty input copmlex scalar data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscInputComplexScalarData

Function syscGetInputComplexScalarDataSplitDouble​

SyscInputComplexScalarData syscGetInputComplexScalarDataSplitDouble(double *const dataReal, double *const dataImag, size_t dataSize)

Create a complex input scalar data access struct.

Parameters:

  • dataReal: - pointer to the double-precision real data component.
  • dataImag: - pointer to the double-precision imaginary data component.
  • dataSize: - data size.

Parameters:

  • double *const dataReal
  • double *const dataImag
  • size_t dataSize

Return type: SyscInputComplexScalarData

Function syscGetInputComplexScalarDataSplitFloat​

SyscInputComplexScalarData syscGetInputComplexScalarDataSplitFloat(float *const dataReal, float *const dataImag, size_t dataSize)

Create a complex input scalar data access struct.

Parameters:

  • dataReal: - pointer to the single-precision real data component.
  • dataImag: - pointer to the single-precision imaginary data component.
  • dataSize: - data size.

Parameters:

  • float *const dataReal
  • float *const dataImag
  • size_t dataSize

Return type: SyscInputComplexScalarData

Function syscGetInputComplexScalarDataCompactDouble​

SyscInputComplexScalarData syscGetInputComplexScalarDataCompactDouble(double *const data, size_t dataSize)

Create a complex input scalar data access struct.

Parameters:

  • data: - pointer to the double-precision data.
  • dataSize: - data size.

Parameters:

  • double *const data
  • size_t dataSize

Return type: SyscInputComplexScalarData

Function syscGetInputComplexScalarDataCompactFloat​

SyscInputComplexScalarData syscGetInputComplexScalarDataCompactFloat(float *const data, size_t dataSize)

Create a complex input scalar data access struct.

Parameters:

  • data: - pointer to the single-precision data.
  • dataSize: - data size.

Parameters:

  • float *const data
  • size_t dataSize

Return type: SyscInputComplexScalarData

Function syscGetInputComplexVectorData​

SyscInputComplexVectorData syscGetInputComplexVectorData()

Create an empty input complex vector data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexCompactVectorDataDouble​

SyscInputComplexVectorData syscGetInputCompactComplexCompactVectorDataDouble(double *const data, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data: - pointer to the double-precision complex data.
  • dataSize: - data size.

Parameters:

  • double *const data
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexCompactVectorDataFloat​

SyscInputComplexVectorData syscGetInputCompactComplexCompactVectorDataFloat(float *const data, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data: - pointer to the single-precision complex data.
  • dataSize: - data size.

Parameters:

  • float *const data
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputSplitComplexCompactVectorDataDouble​

SyscInputComplexVectorData syscGetInputSplitComplexCompactVectorDataDouble(double *const dataReal, double *const dataImag, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • dataReal: - pointer to the double-precision complex data (real components).
  • dataImag: - pointer to the double-precision complex data (imaginary components).
  • dataSize: - data size.

Parameters:

  • double *const dataReal
  • double *const dataImag
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputSplitComplexCompactVectorDataFloat​

SyscInputComplexVectorData syscGetInputSplitComplexCompactVectorDataFloat(float *const dataReal, float *const dataImag, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • dataReal: - pointer to the single-precision complex data (real components).
  • dataImag: - pointer to the single-precision complex data (imaginary components).
  • dataSize: - data size.

Parameters:

  • float *const dataReal
  • float *const dataImag
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexSplitVectorDataDouble​

SyscInputComplexVectorData syscGetInputCompactComplexSplitVectorDataDouble(double *const data1, double *const data2, double *const data3, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data1: - pointer to the double-precision complex data (first component).
  • data2: - pointer to the double-precision complex data (second component).
  • data3: - pointer to the double-precision complex data (third component).
  • dataSize: - data size.

Parameters:

  • double *const data1
  • double *const data2
  • double *const data3
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexSplitVectorDataFloat​

SyscInputComplexVectorData syscGetInputCompactComplexSplitVectorDataFloat(float *const data1, float *const data2, float *const data3, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data1: - pointer to the single-precision complex data (first component).
  • data2: - pointer to the single-precision complex data (second component).
  • data3: - pointer to the single-precision complex data (third component).
  • dataSize: - data size.

Parameters:

  • float *const data1
  • float *const data2
  • float *const data3
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputSplitComplexSplitVectorDataDouble​

SyscInputComplexVectorData syscGetInputSplitComplexSplitVectorDataDouble(double *const data1Real, double *const data1Imag, double *const data2Real, double *const data2Imag, double *const data3Real, double *const data3Imag, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data1Real: - pointer to the double-precision complex data (first real component).
  • data1Imag: - pointer to the double-precision complex data (first imagindary component).
  • data2Real: - pointer to the double-precision complex data (second real component).
  • data2Imag: - pointer to the double-precision complex data (second imagindary component).
  • data3Real: - pointer to the double-precision complex data (third real component).
  • data3Imag: - pointer to the double-precision complex data (third imagindary component).
  • dataSize: - data size.

Parameters:

  • double *const data1Real
  • double *const data1Imag
  • double *const data2Real
  • double *const data2Imag
  • double *const data3Real
  • double *const data3Imag
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputSplitComplexSplitVectorDataFloat​

SyscInputComplexVectorData syscGetInputSplitComplexSplitVectorDataFloat(float *const data1Real, float *const data1Imag, float *const data2Real, float *const data2Imag, float *const data3Real, float *const data3Imag, size_t dataSize)

Create a 3D complex input vector data access struct.

Parameters:

  • data1Real: - pointer to the single-precision complex data (first real component).
  • data1Imag: - pointer to the single-precision complex data (first imagindary component).
  • data2Real: - pointer to the single-precision complex data (second real component).
  • data2Imag: - pointer to the single-precision complex data (second imagindary component).
  • data3Real: - pointer to the single-precision complex data (third real component).
  • data3Imag: - pointer to the single-precision complex data (third imagindary component).
  • dataSize: - data size.

Parameters:

  • float *const data1Real
  • float *const data1Imag
  • float *const data2Real
  • float *const data2Imag
  • float *const data3Real
  • float *const data3Imag
  • size_t dataSize

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexCompactVectorDataDoubleDim​

SyscInputComplexVectorData syscGetInputCompactComplexCompactVectorDataDoubleDim(double *const data, size_t dataSize, enum SyscDimension dimension)

Create a complex input vector data access struct based on dimension.

Parameters:

  • data: - pointer to the double-precision complex data.
  • dataSize: - data size.
  • dimension: - dimension of complex vector data.

Parameters:

  • double *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscInputComplexVectorData

Function syscGetInputCompactComplexCompactVectorDataFloatDim​

SyscInputComplexVectorData syscGetInputCompactComplexCompactVectorDataFloatDim(float *const data, size_t dataSize, enum SyscDimension dimension)

Create a complex input vector data access struct based on dimension.

Parameters:

  • data: - pointer to the single-precision complex data.
  • dataSize: - data size.
  • dimension: - dimension of complex vector data.

Parameters:

Return type: SyscInputComplexVectorData

Function syscGetInputScalarData​

SyscInputScalarData syscGetInputScalarData()

Create an input scalar data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointer will be set to null.

Return type: SyscInputScalarData

Function syscGetInputScalarDataDouble​

SyscInputScalarData syscGetInputScalarDataDouble(double *const data, size_t dataSize)

Create an input scalar data access struct.

Parameters:

  • data: - pointer to the double-precision (64-bit) array of data.
  • dataSize: - number of elements in the array.

Parameters:

  • double *const data
  • size_t dataSize

Return type: SyscInputScalarData

Function syscGetInputScalarDataFloat​

SyscInputScalarData syscGetInputScalarDataFloat(float *const data, size_t dataSize)

Create an input scalar data access struct.

Parameters:

  • data: - pointer to the single-precision (32-bit) array of data.
  • dataSize: - number of elements in the array.

Parameters:

  • float *const data
  • size_t dataSize

Return type: SyscInputScalarData

Function syscGetInputVectorData​

SyscInputVectorData syscGetInputVectorData()

Create an input vector data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscInputVectorData

Function syscGetInputVectorDataCompactDouble​

SyscInputVectorData syscGetInputVectorDataCompactDouble(double *const data, size_t dataSize)

Create an 3D input vector data access struct with compact storage.

Parameters:

  • data: - pointer to the array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • double *const data
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetInputVectorDataCompactFloat​

SyscInputVectorData syscGetInputVectorDataCompactFloat(float *const data, size_t dataSize)

Create an 3D input vector data access struct with compact storage.

Parameters:

  • data: - pointer to the array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • float *const data
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetInputVectorDataSplitDouble​

SyscInputVectorData syscGetInputVectorDataSplitDouble(double *const data0, double *const data1, double *const data2, size_t dataSize)

Create an 3D input vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of double-precision data
  • data1: - pointer to the second array of double-precision data
  • data2: - pointer to the third array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • double *const data0
  • double *const data1
  • double *const data2
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetInputVectorDataSplitFloat​

SyscInputVectorData syscGetInputVectorDataSplitFloat(float *const data0, float *const data1, float *const data2, size_t dataSize)

Create an 3D input vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of single-precision data
  • data1: - pointer to the second array of single-precision data
  • data2: - pointer to the third array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • float *const data0
  • float *const data1
  • float *const data2
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetInputVectorDataCompactDoubleDim​

SyscInputVectorData syscGetInputVectorDataCompactDoubleDim(double *const data, size_t dataSize, enum SyscDimension dimension)

Create an input vector data access struct with compact storage based on dimension.

Parameters:

  • data: - pointer to the array of double-precision data
  • dataSize: - number of vectors.
  • dimension: - dimension of complex vector data.

Parameters:

  • double *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscInputVectorData

Function syscGetInputVectorDataCompactFloatDim​

SyscInputVectorData syscGetInputVectorDataCompactFloatDim(float *const data, size_t dataSize, enum SyscDimension dimension)

Create an input vector data access struct with compact storage based on dimension.

Parameters:

  • data: - pointer to the array of single-precision data
  • dataSize: - number of vectors.
  • dimension: - dimension of complex vector data.

Parameters:

Return type: SyscInputVectorData

Function syscGetInput2DVectorDataSplitDouble​

SyscInputVectorData syscGetInput2DVectorDataSplitDouble(double *const data0, double *const data1, size_t dataSize)

Create an 2D input vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of double-precision data
  • data1: - pointer to the second array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • double *const data0
  • double *const data1
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetInput2DVectorDataSplitFloat​

SyscInputVectorData syscGetInput2DVectorDataSplitFloat(float *const data0, float *const data1, size_t dataSize)

Create an 2D input vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of single-precision data
  • data1: - pointer to the second array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • float *const data0
  • float *const data1
  • size_t dataSize

Return type: SyscInputVectorData

Function syscGetNodeData​

SyscNodeData syscGetNodeData()

Create a mesh node data access struct.

Returns an empty mesh node data access struct. All member will be assigned default values.

Return type: SyscNodeData

Function syscGetNodeDataIC​

SyscNodeData syscGetNodeDataIC(SyscOutputIntegerData nodeIds, SyscOutputVectorData nodeCoords)

Create a mesh node data access struct, given node ids and node coords in same order.

Parameters:

Return type: SyscNodeData

Function syscGetNodeDataC​

SyscNodeData syscGetNodeDataC(SyscOutputVectorData nodeCoords)

Creates a mesh node data access struct, given node coordinates in ascending node ids order.

Parameters:

Return type: SyscNodeData

Function syscGetElementTypeDataEmpty​

SyscElementTypeData syscGetElementTypeDataEmpty()

Create an empty mesh element type data access struct.

Returns an empty mesh element type data access struct. All member will be assigned default values.

Return type: SyscElementTypeData

Function syscGetElementTypeData​

SyscElementTypeData syscGetElementTypeData(SyscOutputIntegerData elemTypes)

Create an mesh element type data access struct, given element types.

Parameters:

Return type: SyscElementTypeData

Function syscGetElementNodeCountDataEmpty​

SyscElementNodeCountData syscGetElementNodeCountDataEmpty()

Create an empty mesh element node count data access struct.

Returns an empty mesh element node count data access struct. All member will be assigned default values.

Return type: SyscElementNodeCountData

Function syscGetElementNodeCountData​

SyscElementNodeCountData syscGetElementNodeCountData(SyscOutputIntegerData elemNodeCount)

Create an mesh element node count data access struct, given element node counts.

Parameters:

Return type: SyscElementNodeCountData

Function syscGetElementNodeConnectivityDataEmpty​

SyscElementNodeConnectivityData syscGetElementNodeConnectivityDataEmpty()

Create an empty element-to-node connectivity data access struct.

Returns an empty element-to-node connectivity data access struct. All member will be assigned default values.

Return type: SyscElementNodeConnectivityData

Function syscGetElementNodeConnectivityData​

SyscElementNodeConnectivityData syscGetElementNodeConnectivityData(SyscOutputIntegerData elemNodeIds)

Create an element-to-node connectivity data access struct, given element node ids.

Parameters:

Return type: SyscElementNodeConnectivityData

Function syscGetFaceCellConnectivityDataEmpty​

SyscFaceCellConnectivityData syscGetFaceCellConnectivityDataEmpty()

Create empty face-to-cell connectivity.

Return type: SyscFaceCellConnectivityData

Function syscGetFaceCellConnectivityData​

SyscFaceCellConnectivityData syscGetFaceCellConnectivityData(SyscOutputIntegerData cell0Ids, SyscOutputIntegerData cell1Ids)

Create face-to-cell connectivity given cell0 and cell1 arrays.

Parameters:

Return type: SyscFaceCellConnectivityData

Function syscGetCellIdDataEmpty​

SyscCellIdData syscGetCellIdDataEmpty()

Create empty cell id data.

Return type: SyscCellIdData

Function syscGetCellIdData​

SyscCellIdData syscGetCellIdData(SyscOutputIntegerData cellIds)

Create cell id data given cell ids array.

Parameters:

Return type: SyscCellIdData

Function syscGetElementIdDataEmpty​

SyscElementIdData syscGetElementIdDataEmpty()

Create empty element id data.

Return type: SyscElementIdData

Function syscGetElementIdData​

SyscElementIdData syscGetElementIdData(SyscOutputIntegerData elementIds)

Create cell id data given cell ids array.

Parameters:

Return type: SyscElementIdData

Function syscGetFaceDataEmpty​

SyscFaceData syscGetFaceDataEmpty()

Create empty face data.

Return type: SyscFaceData

Function syscGetFaceDataITCNF​

SyscFaceData syscGetFaceDataITCNF(SyscElementIdData faceIds, SyscElementTypeData faceTypes, SyscElementNodeCountData faceNodeCounts, SyscElementNodeConnectivityData faceNodeConnectivity, SyscFaceCellConnectivityData faceCellConnectivity)

Create face data given face ids, types, node counts, node-to-face connectivity, face-to-cell connectivity.

Parameters:

Return type: SyscFaceData

Function syscGetFaceDataICNF​

SyscFaceData syscGetFaceDataICNF(SyscElementIdData faceIds, SyscElementNodeCountData faceNodeCounts, SyscElementNodeConnectivityData faceNodeConnectivity, SyscFaceCellConnectivityData faceCellConnectivity)

Create face data given face ids, types, node-to-face connectivity, face-to-cell connectivity.

Parameters:

Return type: SyscFaceData

Function syscGetFaceDataITN​

SyscFaceData syscGetFaceDataITN(SyscElementIdData faceIds, SyscElementTypeData faceTypes, SyscElementNodeConnectivityData faceNodeConnectivity)

Create face data given face ids, types, node-to-face connectivity, face-to-cell connectivity.

Parameters:

Return type: SyscFaceData

Function syscGetFaceDataCN​

SyscFaceData syscGetFaceDataCN(SyscElementNodeCountData faceNodeCounts, SyscElementNodeConnectivityData faceNodeConnectivity)

Create face data given face node counts, node-to-face connectivity.

Parameters:

Return type: SyscFaceData

Function syscGetCellDataEmpty​

SyscCellData syscGetCellDataEmpty()

Create empty cell data.

Return type: SyscCellData

Function syscGetCellDataITN​

SyscCellData syscGetCellDataITN(SyscElementIdData cellIds, SyscElementTypeData cellTypes, SyscElementNodeConnectivityData cellNodeConnectivity)

Create cell data given cell ids, types, cell-to-node connectivity.

Parameters:

Return type: SyscCellData

Function syscGetCellDataI​

SyscCellData syscGetCellDataI(SyscElementIdData cellIds)

Create cell data given cell ids.

Parameters:

Return type: SyscCellData

Function syscGetCellDataTN​

SyscCellData syscGetCellDataTN(SyscElementTypeData cellTypes, SyscElementNodeConnectivityData cellNodeConnectivity)

Create cell data given cell types, cell-to-node connectivity.

Parameters:

Return type: SyscCellData

Function syscGetOutputComplexScalarData​

SyscOutputComplexScalarData syscGetOutputComplexScalarData()

Create an empty output complex scalar data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscOutputComplexScalarData

Function syscGetOutputComplexScalarDataSplitDouble​

SyscOutputComplexScalarData syscGetOutputComplexScalarDataSplitDouble(const double *const dataReal, const double *const dataImag, size_t dataSize)

Create a complex output scalar data access struct.

Parameters:

  • dataReal: - pointer to the double-precision real data component.
  • dataImag: - pointer to the double-precision imaginary data component.
  • dataSize: - data size.

Parameters:

  • const double *const dataReal
  • const double *const dataImag
  • size_t dataSize

Return type: SyscOutputComplexScalarData

Function syscGetOutputComplexScalarDataSplitFloat​

SyscOutputComplexScalarData syscGetOutputComplexScalarDataSplitFloat(const float *const dataReal, const float *const dataImag, size_t dataSize)

Create a complex output scalar data access struct.

Parameters:

  • dataReal: - pointer to the single-precision real data component.
  • dataImag: - pointer to the single-precision imaginary data component.
  • dataSize: - data size.

Parameters:

  • const float *const dataReal
  • const float *const dataImag
  • size_t dataSize

Return type: SyscOutputComplexScalarData

Function syscGetOutputComplexScalarDataCompactDouble​

SyscOutputComplexScalarData syscGetOutputComplexScalarDataCompactDouble(const double *const data, size_t dataSize)

Create a complex output scalar data access struct.

Parameters:

  • data: - pointer to the double-precision data.
  • dataSize: - data size.

Parameters:

  • const double *const data
  • size_t dataSize

Return type: SyscOutputComplexScalarData

Function syscGetOutputComplexScalarDataCompactFloat​

SyscOutputComplexScalarData syscGetOutputComplexScalarDataCompactFloat(const float *const data, size_t dataSize)

Create a complex output scalar data access struct.

Parameters:

  • data: - pointer to the single-precision data.
  • dataSize: - data size.

Parameters:

  • const float *const data
  • size_t dataSize

Return type: SyscOutputComplexScalarData

Function syscGetOutputComplexVectorData​

SyscOutputComplexVectorData syscGetOutputComplexVectorData()

Create an empty output complex vector data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexCompactVectorDataDouble​

SyscOutputComplexVectorData syscGetOutputCompactComplexCompactVectorDataDouble(const double *const data, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data: - pointer to the double-precision complex data.
  • dataSize: - data size.

Parameters:

  • const double *const data
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexCompactVectorDataFloat​

SyscOutputComplexVectorData syscGetOutputCompactComplexCompactVectorDataFloat(const float *const data, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data: - pointer to the single-precision complex data.
  • dataSize: - data size.

Parameters:

  • const float *const data
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputSplitComplexCompactVectorDataDouble​

SyscOutputComplexVectorData syscGetOutputSplitComplexCompactVectorDataDouble(const double *const dataReal, const double *const dataImag, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • dataReal: - pointer to the double-precision complex data (real components).
  • dataImag: - pointer to the double-precision complex data (imaginary components).
  • dataSize: - data size.

Parameters:

  • const double *const dataReal
  • const double *const dataImag
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputSplitComplexCompactVectorDataFloat​

SyscOutputComplexVectorData syscGetOutputSplitComplexCompactVectorDataFloat(const float *const dataReal, const float *const dataImag, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • dataReal: - pointer to the single-precision complex data (real components).
  • dataImag: - pointer to the single-precision complex data (imaginary components).
  • dataSize: - data size.

Parameters:

  • const float *const dataReal
  • const float *const dataImag
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexSplitVectorDataDouble​

SyscOutputComplexVectorData syscGetOutputCompactComplexSplitVectorDataDouble(const double *const data1, const double *const data2, const double *const data3, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data1: - pointer to the double-precision complex data (first component).
  • data2: - pointer to the double-precision complex data (second component).
  • data3: - pointer to the double-precision complex data (third component).
  • dataSize: - data size.

Parameters:

  • const double *const data1
  • const double *const data2
  • const double *const data3
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexSplitVectorDataFloat​

SyscOutputComplexVectorData syscGetOutputCompactComplexSplitVectorDataFloat(const float *const data1, const float *const data2, const float *const data3, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data1: - pointer to the single-precision complex data (first component).
  • data2: - pointer to the single-precision complex data (second component).
  • data3: - pointer to the single-precision complex data (third component).
  • dataSize: - data size.

Parameters:

  • const float *const data1
  • const float *const data2
  • const float *const data3
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputSplitComplexSplitVectorDataDouble​

SyscOutputComplexVectorData syscGetOutputSplitComplexSplitVectorDataDouble(const double *const data1Real, const double *const data1Imag, const double *const data2Real, const double *const data2Imag, const double *const data3Real, const double *const data3Imag, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data1Real: - pointer to the double-precision complex data (first real component).
  • data1Imag: - pointer to the double-precision complex data (first imagindary component).
  • data2Real: - pointer to the double-precision complex data (second real component).
  • data2Imag: - pointer to the double-precision complex data (second imagindary component).
  • data3Real: - pointer to the double-precision complex data (third real component).
  • data3Imag: - pointer to the double-precision complex data (third imagindary component).
  • dataSize: - data size.

Parameters:

  • const double *const data1Real
  • const double *const data1Imag
  • const double *const data2Real
  • const double *const data2Imag
  • const double *const data3Real
  • const double *const data3Imag
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputSplitComplexSplitVectorDataFloat​

SyscOutputComplexVectorData syscGetOutputSplitComplexSplitVectorDataFloat(const float *const data1Real, const float *const data1Imag, const float *const data2Real, const float *const data2Imag, const float *const data3Real, const float *const data3Imag, size_t dataSize)

Create a 3D complex output vector data access struct.

Parameters:

  • data1Real: - pointer to the single-precision complex data (first real component).
  • data1Imag: - pointer to the single-precision complex data (first imagindary component).
  • data2Real: - pointer to the single-precision complex data (second real component).
  • data2Imag: - pointer to the single-precision complex data (second imagindary component).
  • data3Real: - pointer to the single-precision complex data (third real component).
  • data3Imag: - pointer to the single-precision complex data (third imagindary component).
  • dataSize: - data size.

Parameters:

  • const float *const data1Real
  • const float *const data1Imag
  • const float *const data2Real
  • const float *const data2Imag
  • const float *const data3Real
  • const float *const data3Imag
  • size_t dataSize

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexCompactVectorDataDoubleDim​

SyscOutputComplexVectorData syscGetOutputCompactComplexCompactVectorDataDoubleDim(const double *const data, size_t dataSize, enum SyscDimension dimension)

Create a complex output vector data access struct based on dimension.

Parameters:

  • data: - pointer to the double-precision complex data.
  • dataSize: - data size.
  • dimension: - dimension of complex vector data.

Parameters:

  • const double *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscOutputComplexVectorData

Function syscGetOutputCompactComplexCompactVectorDataFloatDim​

SyscOutputComplexVectorData syscGetOutputCompactComplexCompactVectorDataFloatDim(const float *const data, size_t dataSize, enum SyscDimension dimension)

Create a complex output vector data access struct based on dimension.

Parameters:

  • data: - pointer to the single-precision complex data.
  • dataSize: - data size.
  • dimension: - dimension of complex vector data.

Parameters:

  • const float *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscOutputComplexVectorData

Function syscGetOutputIntegerData​

SyscOutputIntegerData syscGetOutputIntegerData()

Create an output integer data access struct.

Primitive type will default to 64-bit signed integer. Data size will be set to zero. Data pointer will be set to null.

Return type: SyscOutputIntegerData

Function syscGetOutputIntegerDataInt32​

SyscOutputIntegerData syscGetOutputIntegerDataInt32(const int32_t *const data, size_t dataSize)

Create an output integer data access struct.

Parameters:

  • data: - pointer to the signed (32-bit) array of data.
  • dataSize: - number of elements in the array.

Parameters:

  • const int32_t *const data
  • size_t dataSize

Return type: SyscOutputIntegerData

Function syscGetOutputIntegerDataInt64​

SyscOutputIntegerData syscGetOutputIntegerDataInt64(const int64_t *const data, size_t dataSize)

Create an output integer data access struct.

Parameters:

  • data: - pointer to the 64-bit array of integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const int64_t *const data
  • size_t dataSize

Return type: SyscOutputIntegerData

Function syscGetOutputIntegerDataUInt16​

SyscOutputIntegerData syscGetOutputIntegerDataUInt16(const uint16_t *const data, size_t dataSize)

Create an output integer data access struct.

Parameters:

  • data: - pointer to the 16-bit array of unsigned integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const uint16_t *const data
  • size_t dataSize

Return type: SyscOutputIntegerData

Function syscGetOutputIntegerDataUInt64​

SyscOutputIntegerData syscGetOutputIntegerDataUInt64(const uint64_t *const data, size_t dataSize)

Create an output integer data access struct.

Parameters:

  • data: - pointer to the 64-bit array of unsigned integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const uint64_t *const data
  • size_t dataSize

Return type: SyscOutputIntegerData

Function syscGetOutputScalarData​

SyscOutputScalarData syscGetOutputScalarData()

Create an output scalar data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointer will be set to null.

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataDouble​

SyscOutputScalarData syscGetOutputScalarDataDouble(const double *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the double-precision (64-bit) array of data.
  • dataSize: - number of elements in the array.

Parameters:

  • const double *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataFloat​

SyscOutputScalarData syscGetOutputScalarDataFloat(const float *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the single-precision (32-bit) array of data.
  • dataSize: - number of elements in the array.

Parameters:

  • const float *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataInt32​

SyscOutputScalarData syscGetOutputScalarDataInt32(const int32_t *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the 32-bit array of integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const int32_t *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataInt64​

SyscOutputScalarData syscGetOutputScalarDataInt64(const int64_t *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the 64-bit array of integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const int64_t *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataUInt16​

SyscOutputScalarData syscGetOutputScalarDataUInt16(const uint16_t *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the 16-bit array of unsigned integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const uint16_t *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputScalarDataUInt64​

SyscOutputScalarData syscGetOutputScalarDataUInt64(const uint64_t *const data, size_t dataSize)

Create an output scalar data access struct.

Parameters:

  • data: - pointer to the 64-bit array of unsigned integer data.
  • dataSize: - number of elements in the array.

Parameters:

  • const uint64_t *const data
  • size_t dataSize

Return type: SyscOutputScalarData

Function syscGetOutputVectorData​

SyscOutputVectorData syscGetOutputVectorData()

Create an output vector data access struct.

Primitive type will default to double-precision. Data size will be set to zero. Data pointers will be set to null.

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataCompactDouble​

SyscOutputVectorData syscGetOutputVectorDataCompactDouble(const double *const data, size_t dataSize)

Create an 3D output vector data access struct with compact storage.

Parameters:

  • data: - pointer to the array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • const double *const data
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataCompactFloat​

SyscOutputVectorData syscGetOutputVectorDataCompactFloat(const float *const data, size_t dataSize)

Create an 3D output vector data access struct with compact storage.

Parameters:

  • data: - pointer to the array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • const float *const data
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataSplitDouble​

SyscOutputVectorData syscGetOutputVectorDataSplitDouble(const double *const data0, const double *const data1, const double *const data2, size_t dataSize)

Create an 3D output vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of double-precision data
  • data1: - pointer to the second array of double-precision data
  • data2: - pointer to the third array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • const double *const data0
  • const double *const data1
  • const double *const data2
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataSplitFloat​

SyscOutputVectorData syscGetOutputVectorDataSplitFloat(const float *const data0, const float *const data1, const float *const data2, size_t dataSize)

Create an 3D output vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of single-precision data
  • data1: - pointer to the second array of single-precision data
  • data2: - pointer to the third array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • const float *const data0
  • const float *const data1
  • const float *const data2
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataCompactDoubleDim​

SyscOutputVectorData syscGetOutputVectorDataCompactDoubleDim(const double *const data, size_t dataSize, enum SyscDimension dimension)

Create an output vector data access struct with compact storage based on dimension.

Parameters:

  • data: - pointer to the array of double-precision data
  • dataSize: - number of vectors.
  • dimension: - dimension of complex vector data.

Parameters:

  • const double *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscOutputVectorData

Function syscGetOutputVectorDataCompactFloatDim​

SyscOutputVectorData syscGetOutputVectorDataCompactFloatDim(const float *const data, size_t dataSize, enum SyscDimension dimension)

Create an output vector data access struct with compact storage based on dimension.

Parameters:

  • data: - pointer to the array of single-precision data
  • dataSize: - number of vectors.
  • dimension: - dimension of complex vector data.

Parameters:

  • const float *const data
  • size_t dataSize
  • enum SyscDimension dimension

Return type: SyscOutputVectorData

Function syscGetOutput2DVectorDataSplitDouble​

SyscOutputVectorData syscGetOutput2DVectorDataSplitDouble(const double *const data0, const double *const data1, size_t dataSize)

Create a 2D output vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of double-precision data
  • data1: - pointer to the second array of double-precision data
  • dataSize: - number of vectors.

Parameters:

  • const double *const data0
  • const double *const data1
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetOutput2DVectorDataSplitFloat​

SyscOutputVectorData syscGetOutput2DVectorDataSplitFloat(const float *const data0, const float *const data1, size_t dataSize)

Create an output vector data access struct with split storage.

Parameters:

  • data0: - pointer to the first array of single-precision data
  • data1: - pointer to the second array of single-precision data
  • dataSize: - number of vectors.

Parameters:

  • const float *const data0
  • const float *const data1
  • size_t dataSize

Return type: SyscOutputVectorData

Function syscGetParameter​

SyscParameter syscGetParameter(const char *name)

Create parameter to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this parameter. String length should not exceed SYSC_STRING_LENGTH.

Display name will default to the same as name.

Parameters:

  • const char * name

Return type: SyscParameter

Function syscGetParameterD​

SyscParameter syscGetParameterD(const char *name, const char *displayName)

Create parameter to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this parameter. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - parameter display name. String length should not exceed SYSC_STRING_LENGTH.

Parameters:

  • const char * name
  • const char * displayName

Return type: SyscParameter

Function syscGetPointCloudEmpty​

SyscPointCloud syscGetPointCloudEmpty()

Create a point cloud access struct.

Returns a struct representing empty point cloud. All member will be assigned default values.

Return type: SyscPointCloud

Function syscGetPointCloud​

SyscPointCloud syscGetPointCloud(SyscOutputIntegerData nodeIds, SyscOutputVectorData nodeCoords)

Create a point cloud access struct.

Parameters:

  • nodeIds: - output integer data access for node ids
  • nodeCoords: - output vector data access for node coordinates, provided in the same order as node ids

Parameters:

Return type: SyscPointCloud

Function syscGetRegion​

SyscRegion syscGetRegion(const char *name)

Create region to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this region. String length should not exceed SYSC_STRING_LENGTH.

Display name will default to the same as name.

Topology will default to surface.

Region mesh type will default to mesh.

Parameters:

  • const char * name

Return type: SyscRegion

Function syscGetRegionT​

SyscRegion syscGetRegionT(const char *name, enum SyscTopology topology)

Create region to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this region. String length should not exceed SYSC_STRING_LENGTH.
  • topology: - region topology.

Display name will default to the same as name.

Region mesh type will default to mesh.

Parameters:

Return type: SyscRegion

Function syscGetRegionDT​

SyscRegion syscGetRegionDT(const char *name, const char *displayName, enum SyscTopology topology)

Create region to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this region. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - region display name. String length should not exceed SYSC_STRING_LENGTH.
  • topology: - region topology.

Region mesh type will default to mesh.

Parameters:

  • const char * name
  • const char * displayName
  • enum SyscTopology topology

Return type: SyscRegion

Function syscGetRegionTM​

SyscRegion syscGetRegionTM(const char *name, enum SyscTopology topology, enum SyscRegionDiscretizationType regionDiscretizationType)

Create region to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this region. String length should not exceed SYSC_STRING_LENGTH.
  • topology: - region topology.
  • regionDiscretizationType: - region mesh type.

Display names will be same as name.

Parameters:

Return type: SyscRegion

Function syscGetRegionDTM​

SyscRegion syscGetRegionDTM(const char *name, const char *displayName, enum SyscTopology topology, enum SyscRegionDiscretizationType regionDiscretizationType)

Create region to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this region. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - region display name. String length should not exceed SYSC_STRING_LENGTH.
  • topology: - region topology.
  • regionDiscretizationType: - region mesh type.

Parameters:

Return type: SyscRegion

Function syscAddInputVariable​

SyscError syscAddInputVariable(const SyscRegion region, const SyscVariable variable)

Provide a function to add an input variable to the region.

If this variable has already been added to the region as an input variable, then this call will have no effect.

If a different variable with the same name has already been added to the region as an input variable, then an error will be returned.

If a variable with the same name has already been added to the region as an output variable, then an error will be returned.

If the variable name contains invalid characters, then an error will be returned.

If the region discretization type is point cloud, then the location of the variable added to this region is insignificant.

Parameters:

  • region: Region to which the input variable is to be added.
  • variable: Variable whose values are provided by System Coupling and consumed by the participant.

Parameters:

Return type: SyscError

Function syscAddOutputVariable​

SyscError syscAddOutputVariable(const SyscRegion region, const SyscVariable variable)

Provide a function to add an output variable to the region.

If this variable has already been added to the region as an output variable, then this call will have no effect.

If a different variable with the same name has already been added to the region as an output variable, then an error will be returned.

If a variable with the same name has already been added to the region as an input variable, then an error will be returned.

If the variable name contains invalid characters, then an error will be returned.

If the region discretization type is point cloud, then the location of the variable added to this region is insignificant.

Parameters:

  • region: Region to which the output variable is to be added.
  • variable: Variable whose values are consumed by System Coupling and provided by the participant.

Parameters:

Return type: SyscError

Function syscGetNumInputVariables​

size_t syscGetNumInputVariables(const SyscRegion region)

Provide a function to return the number of input variables.

Parameters:

  • region: - region

Returns:

Number of input variables for the region.

Parameters:

Return type: size_t

Function syscGetInputVariable​

SyscVariable syscGetInputVariable(const SyscRegion region, size_t index)

Return an input variable.

Parameters:

  • region: - region
  • index: - region index

Returns:

Variable at specified index.

Parameters:

Return type: SyscVariable

Function syscGetNumOutputVariables​

size_t syscGetNumOutputVariables(const SyscRegion region)

Provide a function to return the number of output variables.

Parameters:

  • region: - region

Returns:

Number of output variables for the region.

Parameters:

Return type: size_t

Function syscGetOutputVariable​

SyscVariable syscGetOutputVariable(const SyscRegion region, size_t index)

Return an output variable.

Parameters:

  • region: - region
  • index: - region index

Returns:

Variable at specified index.

Parameters:

Return type: SyscVariable

Function syscGetSurfaceMesh​

SyscSurfaceMesh syscGetSurfaceMesh()

Create a surface mesh access struct.

Returns a struct representing empty surface mesh. All member will be assigned default values.

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshNF​

SyscSurfaceMesh syscGetSurfaceMeshNF(SyscNodeData nodes, SyscFaceData faces)

Create a surface mesh access struct.

Parameters:

  • nodes: - node data
  • faces: - face data

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshNTCI​

SyscSurfaceMesh syscGetSurfaceMeshNTCI(SyscNodeData nodes, SyscElementTypeData elemTypes, SyscElementNodeCountData elemNodeCounts, SyscElementNodeConnectivityData elemNodeConnectivity)

Create a surface mesh access struct.

Both element types and element node counts are provided.

Parameters:

  • nodes: - mesh nodes
  • elemTypes: - element types
  • elemNodeCounts: - element node counts
  • elemNodeConnectivity: - element-to-node connectivity

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshNCI​

SyscSurfaceMesh syscGetSurfaceMeshNCI(SyscNodeData nodes, SyscElementNodeCountData elemNodeCounts, SyscElementNodeConnectivityData elemNodeConnectivity)

Create a surface mesh access struct.

Element node counts are provided, element types are deduced from element node counts.

Parameters:

  • nodes: - mesh nodes
  • elemNodeCounts: - element node counts
  • elemNodeConnectivity: - element-to-node connectivity

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshNCIF​

SyscSurfaceMesh syscGetSurfaceMeshNCIF(SyscNodeData nodes, SyscElementNodeCountData elemNodeCounts, SyscElementNodeConnectivityData elemNodeConnectivity, SyscFaceCellConnectivityData faceCellConnectivty)

Create a surface mesh access struct.

Element node counts are provided, element types are deduced from element node counts. Face-to-cell connectivity is provided as well.

Parameters:

  • nodes: - mesh nodes
  • elemNodeCounts: - element node counts
  • elemNodeConnectivity: - element-to-node connectivity
  • faceCellConnectivity: - face-to-cell connectivity

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshNTI​

SyscSurfaceMesh syscGetSurfaceMeshNTI(SyscNodeData nodes, SyscElementTypeData elemTypes, SyscElementNodeConnectivityData elemNodeConnectivity)

Create a surface mesh access struct.

Element types are provided, element node counts are deduced from element types.

Parameters:

  • nodes: - mesh nodes
  • elemTypes: - element types
  • elemNodeConnectivity: - element-to-node connectivity

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshA​

SyscSurfaceMesh syscGetSurfaceMeshA(SyscOutputScalarData nodeIds, SyscOutputVectorData nodeCoords, SyscOutputScalarData elemNodeCounts, SyscOutputScalarData elemNodeIds)

Create a surface mesh access struct.

Note: this function is deprecated. Use syscGetSurfaceMeshNCI instead.

Parameters:

  • nodeIds: - output scalar data access for node ids
  • nodeCoords: - output vector data access for node coordinates, provided in the same order as node ids
  • elemNodeCounts: - output scalar data access for element node counts
  • elemNodeIds: - output scalar data access for element node ids

Parameters:

Return type: SyscSurfaceMesh

Function syscGetSurfaceMeshB​

SyscSurfaceMesh syscGetSurfaceMeshB(SyscOutputVectorData nodeCoords, SyscOutputScalarData elemNodeCounts, SyscOutputScalarData elemNodeIds)

Create a surface mesh access struct.

Note: this function is deprecated. Use syscGetSurfaceMeshNCI instead.

Parameters:

  • nodeCoords: - output vector data access for node coordinates, provided in ascending node ids order
  • elemNodeCounts: - output scalar data access for element node counts
  • elemNodeIds: - output scalar data access for element node ids

Parameters:

Return type: SyscSurfaceMesh

Function syscStartStandaloneParallel​

SyscError syscStartStandaloneParallel(const size_t mpiCommunicator)

Provide a function to start standalone mode in parallel.

Parameters:

  • mpiCommunicator: MPI communicator cast to size_t.

This will initialize the participant library in standalone mode and will use the provided MPI communicator for all parallel communication.

Note that if the MPI communicator is MPI_COMM_WORLD, then it is not necessary to call this function.

Parameters:

  • const size_t mpiCommunicator

Return type: SyscError

Function syscConnect​

SyscError syscConnect(const char *scHost, const unsigned short scPort, const char *participantName, const char *buildInformation)

Provide a function to establish connection to System Coupling.

A participant must have obtained the host and port information from System Coupling prior to calling this function (e.g. via an input argument when participant application was started).

Parameters:

  • scHost: Name of the host on which System Coupling is running.
  • scPort: Port number on which System Coupling is listening for participant connections.
  • participantName: Name of this participant (e.g. "MAPDL-1").
  • buildInformation: Information about the build of this participant solver.

Returns:

SyscError Can be checked for any errors.

Parameters:

  • const char * scHost
  • const unsigned short scPort
  • const char * participantName
  • const char * buildInformation

Return type: SyscError

Function syscConnectParallel​

SyscError syscConnectParallel(const char *scHost, const unsigned short scPort, const char *participantName, const size_t communicator, const char *buildInformation)

Provide a function to establish connection to System Coupling in parallel.

This function is an alternative to syscConnect function. It works the same way as syscConnect, but it takes in one additional argument, which is the MPI communicator, cast as size_t.

Note that if the MPI communicator is MPI_COMM_WORLD, then it is not necessary to call this function and syscConnect() can be used instead.

Parameters:

  • const char * scHost
  • const unsigned short scPort
  • const char * participantName
  • const size_t communicator
  • const char * buildInformation

Return type: SyscError

Function syscConnectUseStruct​

SyscError syscConnectUseStruct(SyscParticipantInfo participantInfo)

Provide a function to establish connection to System Coupling in serial using a C structure.

Parameters:

  • participantInfo: A C structure containing the participant attributes

Returns:

SyscError

Parameters:

Return type: SyscError

Function syscConnectParallelUseStruct​

SyscError syscConnectParallelUseStruct(SyscParticipantInfo participantInfo, const size_t communicator)

Provide a function to establish connection to System Coupling in parallel using a C structure.

Parameters:

  • participantInfo: A C structure containing the participant attributes
  • communicator: A size_t flag signifying what mode to run in parallel with.

Returns:

SyscError

Parameters:

Return type: SyscError

Function syscAddRegion​

SyscError syscAddRegion(const SyscRegion region)

Provide a function to add a region that could be used in a coupled analysis.

If this region has already been added, then this call will have no effect.

If a different region with the same has already been added, then an error will be returned.

If the region name contains invalid characters, then a runtime error will be thrown.

Parameters:

Return type: SyscError

Function syscAddInputParameter​

SyscError syscAddInputParameter(const SyscParameter parameter)

Provide a method to add an input parameter that could be used in a coupled analysis.

If this parameter has already been added as an input solver parameter, then this call will have no effect.

If a different parameter with the same name has already been added as an input parameter, then a runtime error will be thrown.

If a parameter with the same name has already been added as an output parameter, then a runtime error will be thrown.

If the parameter name contains invalid characters, a runtime error will be thrown.

Parameters:

  • parameter: Parameter whose values are provided by System Coupling and consumed by the participant.

Parameters:

Return type: SyscError

Function syscAddOutputParameter​

SyscError syscAddOutputParameter(const SyscParameter parameter)

Provide a method to add an output parameter that could be used in a coupled analysis.

If this parameter has already been added as an output solver parameter, then this call will have no effect.

If a different parameter with the same name has already been added as an output parameter, then a runtime error will be thrown.

If a parameter with the same name has already been added as an input parameter, then a runtime error will be thrown.

If the parameter name contains invalid characters, a runtime error will be thrown.

Parameters:

  • parameter: Parameter whose values are provided by System Coupling and consumed by the participant.

Parameters:

Return type: SyscError

Function syscGetNumInputParameters​

size_t syscGetNumInputParameters()

Provide a method to get the number of input parameters.

Returns:

Number of input parameters.

Return type: size_t

Function syscGetNumOutputParameters​

size_t syscGetNumOutputParameters()

Provide a method to get the number of output parameters.

Returns:

Number of output parameters.

Return type: size_t

Function syscGetAddedInputParameter​

SyscParameter syscGetAddedInputParameter(size_t index)

Provide a function to return input parameter information.

Parameters:

  • index: - input parameter index

Returns:

Input parameter information at specified index.

Parameters:

  • size_t index

Return type: SyscParameter

Function syscGetAddedOutputParameter​

SyscParameter syscGetAddedOutputParameter(size_t index)

Provide a function to return input parameter information.

Parameters:

  • index: - input parameter index

Returns:

Output parameter information at specified index.

Parameters:

  • size_t index

Return type: SyscParameter

Function syscGetNumRealAttributes​

size_t syscGetNumRealAttributes()

Provide a function to get the number of real attributes.

Returns:

Number of real attributes.

Return type: size_t

Function syscGetNumIntegerAttributes​

size_t syscGetNumIntegerAttributes()

Provide a function to get the number of integer attributes.

Returns:

Number of integer attributes.

Return type: size_t

Function syscGetAddedRealAttribute​

SyscRealAttribute syscGetAddedRealAttribute(size_t index)

Provide a function to return real attribute information.

Parameters:

  • index: - real attribute index.

Returns:

Real attribute information at specified index.

Parameters:

  • size_t index

Return type: SyscRealAttribute

Function syscGetAddedIntegerAttribute​

SyscIntegerAttribute syscGetAddedIntegerAttribute(size_t index)

Provide a function to return integer attribute information.

Parameters:

  • index: - integer attribute index.

Returns:

Integer attribute information at specified index.

Parameters:

  • size_t index

Return type: SyscIntegerAttribute

Function syscAddRealAttribute​

SyscError syscAddRealAttribute(const SyscRealAttribute attribute)

Provide a method to add a real attribute that could be used in a coupled analysis.

If this attribute has already been added as a real attribute, then this call will have no effect.

If a different real attribute with the same name has already been added, then a runtime error will be thrown.

If a an attribute with the same name has already been added as an integer attribute, then a runtime error will be thrown.

If the attribute name contains invalid characters, a runtime error will be thrown.

Parameters:

  • attribute: Real attribute.

Parameters:

Return type: SyscError

Function syscAddIntegerAttribute​

SyscError syscAddIntegerAttribute(const SyscIntegerAttribute attribute)

Provide a method to add an integer attribute that could be used in a coupled analysis.

If this attribute has already been added as an integer attribute, then this call will have no effect.

If a different integer attribute with the same name has already been added, then a runtime error will be thrown.

If a an attribute with the same name has already been added as a real attribute, then a runtime error will be thrown.

If the attribute name contains invalid characters, a runtime error will be thrown.

Parameters:

  • attribute: Integer attribute.

Parameters:

Return type: SyscError

Function syscGetParameterValue​

double syscGetParameterValue(const char *parameterName, SyscError *errorCode)

Provide a function to get a Parameter value.

Parameters:

  • parameterName: - name of the parameter.
  • errorCode: - error status for the fuction.

Parameters:

  • const char * parameterName
  • SyscError * errorCode

Return type: double

Function syscSetParameterValue​

SyscError syscSetParameterValue(const char *parameterName, double value)

Provide a function to set a Parameter value.

Parameters:

  • parameterName: - name of the parameter.
  • value: - value of the parameter.

Parameters:

  • const char * parameterName
  • double value

Return type: SyscError

Function syscGetRealAttributeValue​

double syscGetRealAttributeValue(const char *attributeName, SyscError *errorCode)

Provide a function to get a RealAttribute value.

Parameters:

  • attributeName: - name of the attribute.
  • errorCode: - error status for the function.

Parameters:

  • const char * attributeName
  • SyscError * errorCode

Return type: double

Function syscGetIntegerAttributeValue​

int64_t syscGetIntegerAttributeValue(const char *attributeName, SyscError *errorCode)

Provide a function to get an IntegerAttribute value.

Parameters:

  • attributeName: - name of the attribute.
  • errorCode: - error status for the function.

Parameters:

  • const char * attributeName
  • SyscError * errorCode

Return type: int64_t

Function syscAddCouplingInterface​

SyscError syscAddCouplingInterface(const SyscCouplingInterface couplingInterface)

Provide a function to add a coupling interface.

If this coupling interface has already been added, then this call will have no effect.

If a different coupling interface with the same has already been added, then an error status will be returned.

If the coupling interface name contains invalid characters, then an error status will be returned.

See SyscCouplingInterface for more details.

Parameters:

Return type: SyscError

Function syscAddCouplingInterfaceA​

SyscError syscAddCouplingInterfaceA(const SyscCouplingInterface couplingInterface, int autoGenerateDataTransfers)

Provide a function to add a coupling interface.

If this coupling interface has already been added, then this call will have no effect.

If a different coupling interface with the same has already been added, then an error status will be returned.

If the coupling interface name contains invalid characters, then an error status will be returned.

See SyscCouplingInterface for more details.

Parameters:

Return type: SyscError

Function syscCompleteSetup​

SyscError syscCompleteSetup(const SyscSetupInfo setupInfo)

Provide a function to notify System Coupling that setup can be completed.

After this function is called, coupled analysis setup can no longer be updated, i.e. regions and variables cannot be changed.

Once the setup is complete, any subsequent call to complete the setup will have no effect.

Parameters:

  • setupInfo: - setup information.

Parameters:

Return type: SyscError

Function syscRegisterInputScalarDataAccess​

SyscError syscRegisterInputScalarDataAccess(SyscInputScalarDataAccess dataAccess)

Provide a function to register input scalar data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputScalarDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputScalarDataAccessWithPointer​

SyscError syscRegisterInputScalarDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscInputScalarDataAccessWithPointer dataAccess)

Provide a function to register input scalar data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscInputScalarDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputScalarDataMultiZoneAccess​

SyscError syscRegisterInputScalarDataMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscInputScalarDataMultiZoneAccess dataAccess)

Provide a function to register input scalar data multi-zone access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputScalarDataMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputVectorDataAccess​

SyscError syscRegisterInputVectorDataAccess(SyscInputVectorDataAccess dataAccess)

Provide a function to register input vector data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputVectorDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputVectorDataAccessWithPointer​

SyscError syscRegisterInputVectorDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscInputVectorDataAccessWithPointer dataAccess)

Provide a function to register input vector data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscInputVectorDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputVectorDataMultiZoneAccess​

SyscError syscRegisterInputVectorDataMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscInputVectorDataMultiZoneAccess dataAccess)

Provide a function to register input vector data multi-zone access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputVectorDataMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputScalarDataAccess​

SyscError syscRegisterOutputScalarDataAccess(SyscOutputScalarDataAccess dataAccess)

Provide a function to register output scalar data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputScalarDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputScalarDataAccessWithPointer​

SyscError syscRegisterOutputScalarDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputScalarDataAccessWithPointer dataAccess)

Provide a function to register output scalar data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscOutputScalarDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputScalarDataMultiZoneAccess​

SyscError syscRegisterOutputScalarDataMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputScalarDataMultiZoneAccess dataAccess)

Provide a function to register output scalar data multi-zone access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputScalarDataMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputVectorDataAccess​

SyscError syscRegisterOutputVectorDataAccess(SyscOutputVectorDataAccess dataAccess)

Provide a function to register output vector data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputVectorDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputVectorDataAccessWithPointer​

SyscError syscRegisterOutputVectorDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputVectorDataAccessWithPointer dataAccess)

Provide a function to register output vector data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscOutputVectorDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputVectorDataMultiZoneAccess​

SyscError syscRegisterOutputVectorDataMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputVectorDataMultiZoneAccess dataAccess)

Provide a function to register output vector data multi-zone access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputVectorDataMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputComplexScalarDataAccess​

SyscError syscRegisterInputComplexScalarDataAccess(SyscInputComplexScalarDataAccess dataAccess)

Provide a function to register input complex scalar data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputComplexScalarDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputComplexScalarDataAccessWithPointer​

SyscError syscRegisterInputComplexScalarDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscInputComplexScalarDataAccessWithPointer dataAccess)

Provide a function to register input complex scalar data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscInputComplexScalarDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputComplexVectorDataAccess​

SyscError syscRegisterInputComplexVectorDataAccess(SyscInputComplexVectorDataAccess dataAccess)

Provide a function to register input complex vector data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscInputComplexVectorDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterInputComplexVectorDataAccessWithPointer​

SyscError syscRegisterInputComplexVectorDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscInputComplexVectorDataAccessWithPointer dataAccess)

Provide a function to register input complex vector data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscInputComplexVectorDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputComplexScalarDataAccess​

SyscError syscRegisterOutputComplexScalarDataAccess(SyscOutputComplexScalarDataAccess dataAccess)

Provide a function to register output complex scalar data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputComplexScalarDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputComplexScalarDataAccessWithPointer​

SyscError syscRegisterOutputComplexScalarDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputComplexScalarDataAccessWithPointer dataAccess)

Provide a function to register output complex scalar data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscOutputComplexScalarDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputComplexVectorDataAccess​

SyscError syscRegisterOutputComplexVectorDataAccess(SyscOutputComplexVectorDataAccess dataAccess)

Provide a function to register output complex vector data access.

Parameters:

  • dataAccess: - a pointer to the function that conforms to SyscOutputComplexVectorDataAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterOutputComplexVectorDataAccessWithPointer​

SyscError syscRegisterOutputComplexVectorDataAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscOutputComplexVectorDataAccessWithPointer dataAccess)

Provide a function to register output complex vector data access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • dataAccess: - a pointer to the function that conforms to SyscOutputComplexVectorDataAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterSurfMeshAccess​

SyscError syscRegisterSurfMeshAccess(SyscSurfMeshAccess meshAccess)

Provide a function to register surface mesh access.

Parameters:

  • meshAccess: - a pointer to the function that conforms to SyscSurfMeshAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterSurfaceMeshAccessWithPointer​

SyscError syscRegisterSurfaceMeshAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscSurfaceMeshAccessWithPointer meshAccess)

Provide a function to register surface mesh access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • meshAccess: - a pointer to the function that conforms to SyscSurfaceMeshAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterSurfaceMeshMultiZoneAccess​

SyscError syscRegisterSurfaceMeshMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscSurfaceMeshMultiZoneAccess meshAccess)

Provide a function to register surface mesh multi-zone access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • meshAccess: - a pointer to the function that conforms to SyscSurfaceMeshMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterVolumeMeshAccess​

SyscError syscRegisterVolumeMeshAccess(SyscVolumeMeshAccess meshAccess)

Provide a function to register volume mesh access.

Parameters:

  • meshAccess: - a pointer to the function that conforms to SyscVolumeMeshAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterVolumeMeshAccessWithPointer​

SyscError syscRegisterVolumeMeshAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscVolumeMeshAccessWithPointer meshAccess)

Provide a function to register volume mesh access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • meshAccess: - a pointer to the function that conforms to SyscVolumeMeshAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterVolumeMeshMultiZoneAccess​

SyscError syscRegisterVolumeMeshMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscVolumeMeshMultiZoneAccess meshAccess)

Provide a function to register volume mesh multi-zone access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • meshAccess: - a pointer to the function that conforms to SyscVolumeMeshMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterPointCloudAccess​

SyscError syscRegisterPointCloudAccess(SyscPointCloudAccess pointCloudAccess)

Provide a function to register point cloud access.

Parameters:

  • pointCloudAccess: - a pointer to the function that conforms to SyscPointCloudAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterPointCloudAccessWithPointer​

SyscError syscRegisterPointCloudAccessWithPointer(SyscOpaqueDataAccess opaqueDataAccess, SyscPointCloudAccessWithPointer pointCloudAccess)

Provide a function to register point cloud access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • pointCloudAccess: - a pointer to the function that conforms to SyscPointCloudAccessWithPointer prototype.

Parameters:

Return type: SyscError

Function syscRegisterPointCloudMultiZoneAccess​

SyscError syscRegisterPointCloudMultiZoneAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscPointCloudMultiZoneAccess pointCloudAccess)

Provide a function to register point cloud multi-zone access.

Parameters:

  • opaqueDataAccess: - a pointer to an address in memory. This pointer will be passed into the callback function.
  • meshAccess: - a pointer to the function that conforms to SyscPointCloudMultiZoneAccess prototype.

Parameters:

Return type: SyscError

Function syscRegisterZoneCountAccess​

SyscError syscRegisterZoneCountAccess(SyscOpaqueDataAccess opaqueDataAccess, SyscZoneCountAccess zoneCountAccess)

Provide a function to register zone count access.

Parameters:

Return type: SyscError

Function syscRegisterRestartPointCreation​

SyscError syscRegisterRestartPointCreation(SyscRestartPointCreation restartPointCreation)

Provide a function to register restart point creation callback.

Parameters:

  • restartPointCreation: - a pointer to the function that conforms to SyscRestartPointCreation function prototype. See SyscRestartPointCreation for details.

Parameters:

Return type: SyscError

Function syscInitializeAnalysis​

SyscError syscInitializeAnalysis()

Provide a function to notify System Coupling that analysis initialization can be completed.

This function must be called after registering mesh and variable data access and prior to entering the coupled analysis loop.

If this function is called before the coupled analysis is complete, it will automatically complete the coupled analysis and assume steady analysis type.

Return type: SyscError

Function syscDoIteration​

int syscDoIteration()

Provide a function to check whether to do a coupling iteration.

This function returns 1 (true) if another coupling iteration is required, otherwise it returns 0 (false).

Return type: int

Function syscDoTimeStep​

int syscDoTimeStep()

Provide a function to check whether to do a coupling time step.

This function returns 1 (true) if another coupling time step is required, otherwise it returns 0 (false).

This function should be called to check if another coupling time step should be done. If the previous coupling time step is finished and another time step should be performed, then calling this function will tell System Coupling that the coupling participant is going to advance to the next time step (i.e. calling syscDoTimeStep() will cause syscDoIteration() to change from returning false to returning true, under the conditions described above).

This function only makes sense for transient analysis. It will always return false for steady analysis.

Return type: int

Function syscGetCurrentTimeStep​

SyscTimeStep syscGetCurrentTimeStep()

Provide a function to get current time step.

This function returns a time step struct, which contains time step number, start time, and time step size for the current coupling time step.

A default value (time step number 0, start time 0.0, time step size 0.0) is returned if this function is called outside the coupled analysis loop or if the analysis is steady.

Return type: SyscTimeStep

Function syscUpdateInputs​

SyscError syscUpdateInputs()

Provide a function to update the participants input variables.

Solution data for all input variables will be updated. Depending on the defined interfaces, data will be transferred from another coupling participant solver, or from the opposite side of the same-participant coupling interface.

When doing cosimulation, this function must be called from inside the coupled analysis loop. It tells System Coupling that the participant is about to begin its solver iterations. All input variable data will be up-to-date after returning from this function. If any local coupling interfaces are defined, all corresponding input variable data will also be updated.

When doing same-participant mapping only (without cosimulation), this function should be called whenever input data needs to be brought up-to-date.

Return type: SyscError

Function syscUpdateOutputs​

SyscError syscUpdateOutputs(const enum SyscConvergenceStatus convStatus)

Provide a function to update the participants output variables.

This function must be called from inside the coupled analysis loop. It tells System Coupling that the participant has finished performing its solver iterations.

Parameters:

Return type: SyscError

Function syscDisconnect​

SyscError syscDisconnect()

Provide a function to end the analysis and disconnect from System Coupling.

Return type: SyscError

Function syscFatalError​

void syscFatalError(const char *errorMessage)

Provide a function to notify System Coupling about a fatal error.

Parameters:

  • const char * errorMessage

Return type: void

Function syscNonFatalError​

void syscNonFatalError(const char *errorMessage)

Provide a function to notify System Coupling about a non fatal error.

Parameters:

  • const char * errorMessage

Return type: void

Function syscCheckSurfaceMeshValidity​

SyscError syscCheckSurfaceMeshValidity(SyscSurfaceMesh mesh)

Provide a function to perform simple mesh validity checks.

This function is provided as a testing and debugging tool and is not meant to be used in production workflows. System Coupling itself will not call this function for performance reasons.

The function will check the surface mesh for detectable problems. For example, it will check if array sizes are consistent, that elemNodeIds array only contains ids that are found in nodeIds array, etc. It is not an exhaustive validity check - the mesh can still have problems even if all checks passed.

Returns:

Return value is SyscError struct. If mesh checks passed, then retcode will be 0. If mesh checks failed, then retcode will be not 0 and message that contains information about about the particular issue.

Parameters:

Return type: SyscError

Function syscWriteSetupFile​

int syscWriteSetupFile(const SyscSetupFileInfo setupFileInfo)

Provide a function to write the setup file.

This function can be used to generate a System Coupling setup file, which contains participant's setup information. It should be called after calling syscCompleteCouplingSetup.

It takes SyscSetupFileInfo struct as input parameter.

It will return true (1) if the setup file was successfully written, and false (0) otherwise.

Parameters:

Return type: int

Function syscWriteResults​

SyscError syscWriteResults(const SyscResultsInfo resultsInfo)

Write results to a file.

Parameters:

Return type: SyscError

Function syscGetNumRegions​

size_t syscGetNumRegions()

Provide a function to return the number of added regions.

Returns:

Number of regions.

Return type: size_t

Function syscGetAddedRegion​

SyscRegion syscGetAddedRegion(size_t index)

Provide a function to return added region given the region index.

Parameters:

Returns:

Region at specified index.

Parameters:

  • size_t index

Return type: SyscRegion

Function syscGetSolutionControl​

SyscSolutionControl syscGetSolutionControl()

Get solution control.

Return type: SyscSolutionControl

Function syscGetNumCouplingInterfaces​

size_t syscGetNumCouplingInterfaces()

Provide a function to return the number of added coupling interfaces.

Returns:

Number of coupling interfaces.

Return type: size_t

Function syscGetAddedCouplingInterface​

SyscCouplingInterface syscGetAddedCouplingInterface(size_t index)

Parameters:

  • size_t index

Return type: SyscCouplingInterface

Function syscGetVariable​

SyscVariable syscGetVariable(const char *name)

Create variable to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this variable. String length should not exceed SYSC_STRING_LENGTH.

Display name will default to the same as name.

Tensor type will default to scalar.

Is extensive flag will default to false (to non-extensive).

Location will default to nodes.

Quantity type will default to unspecified.

Parameters:

  • const char * name

Return type: SyscVariable

Function syscGetVariableDTELQD​

SyscVariable syscGetVariableDTELQD(const char *name, const char *displayName, enum SyscTensorType tensorType, int isExtensive, enum SyscLocation location, enum SyscQuantityType quantityType, enum SyscDataType dataType)

Create variable to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this variable. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - variable display name. String length should not exceed SYSC_STRING_LENGTH.
  • tensorType: - variable tensor type.
  • isExtensive: - flag indicating if it's an extensive property.
  • location: - variable location (e.g element or node).
  • quantityType: - variable quantity type.
  • dataType: - variable data type.

Parameters:

Return type: SyscVariable

Function syscGetVariableTE​

SyscVariable syscGetVariableTE(const char *name, enum SyscTensorType tensorType, int isExtensive, enum SyscLocation location)

Create variable to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this variable. String length should not exceed SYSC_STRING_LENGTH.
  • tensorType: - variable tensor type.
  • isExtensive: - flag indicating if it's an extensive property.
  • location: - variable location (e.g element or node).

Display name will default to the same as name.

Quantity type will default to unspecified.

Parameters:

Return type: SyscVariable

Function syscGetVariableTEQ​

SyscVariable syscGetVariableTEQ(const char *name, const char *displayName, enum SyscTensorType tensorType, int isExtensive, enum SyscLocation location, enum SyscQuantityType quantityType)

Create variable to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this variable. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - variable display name. String length should not exceed SYSC_STRING_LENGTH.
  • tensorType: - variable tensor type.
  • isExtensive: - flag indicating if it's an extensive property.
  • location: - variable location (e.g element or node).
  • quantityType: - variable quantity type.

Parameters:

Return type: SyscVariable

Function syscGetVariableQ​

SyscVariable syscGetVariableQ(const char *name, const char *displayName, enum SyscLocation location, enum SyscQuantityType quantityType)

Create variable to be used in a coupled analysis.

Parameters:

  • name: - Unique name for this variable. String length should not exceed SYSC_STRING_LENGTH.
  • displayName: - variable display name. String length should not exceed SYSC_STRING_LENGTH.
  • location: - variable location (e.g element or node).
  • quantityType: - variable quantity type.

The variable tensor type and is extensive properties will be inferred from the quantity type, according to the following rules:

Quantity Type                     Tensor Type      Is Extensive
----------------------------------------------------------------
Force                             Vector           True
Incremental Displacement          Vector           False
Temperature                       Scalar           False
Heat Rate                         Scalar           True
Heat Transfer Coefficient         Scalar           False
Convection Reference Temperature  Scalar           False

If any other quantity type is specified, tensor type will be set to scalar and is extensive will be set to false.

Parameters:

Return type: SyscVariable

Function syscVariableAddRealAttribute​

SyscError syscVariableAddRealAttribute(SyscVariable variable, SyscRealAttribute attribute)

Add real-valued attribute to the variable.

Parameters:

Return type: SyscError

Function syscVariableAddIntegerAttribute​

SyscError syscVariableAddIntegerAttribute(SyscVariable variable, SyscIntegerAttribute attribute)

Add integer-valued attribute to the variable.

Parameters:

Return type: SyscError

Function syscVariableGetNumRealAttributes​

size_t syscVariableGetNumRealAttributes(SyscVariable variable)

Get number of real-valued attributes.

Parameters:

Return type: size_t

Function syscVariableGetNumIntegerAttributes​

size_t syscVariableGetNumIntegerAttributes(SyscVariable variable)

Get number of integer-valued attributes.

Parameters:

Return type: size_t

Function syscVariableGetRealAttribute​

SyscRealAttribute syscVariableGetRealAttribute(SyscVariable variable, size_t index)

Return the real-valued attribute at the given index.

Parameters:

Return type: SyscRealAttribute

Function syscVariableGetIntegerAttribute​

SyscIntegerAttribute syscVariableGetIntegerAttribute(SyscVariable variable, size_t index)

Return the integer-valued attribute at the given index.

Parameters:

Return type: SyscIntegerAttribute

Function syscGetVolumeMeshEmpty​

SyscVolumeMesh syscGetVolumeMeshEmpty()

Create an empty volume mesh access struct.

Returns a struct representing empty volume mesh. All member will be assigned default values.

Return type: SyscVolumeMesh

Function syscGetVolumeMeshNFC​

SyscVolumeMesh syscGetVolumeMeshNFC(SyscNodeData nodes, SyscFaceData faces, SyscCellData cells)

Create a volume mesh access struct.

Parameters:

  • nodes: - node data
  • faces: - face data
  • cells: - cell data

Parameters:

Return type: SyscVolumeMesh

Function syscGetVolumeMeshElementBased​

SyscVolumeMesh syscGetVolumeMeshElementBased(SyscNodeData nodes, SyscElementTypeData cellTypes, SyscElementNodeConnectivityData cellNodeConnectivity)

Create an element-based volume mesh access struct.

Parameters:

  • nodes: - node data
  • cellTypes: - cell types
  • cellNodeConnectivity: - cell-to-node connectivity

Parameters:

Return type: SyscVolumeMesh

Function syscGetVolumeMeshFaceBased​

SyscVolumeMesh syscGetVolumeMeshFaceBased(SyscNodeData nodes, SyscElementNodeCountData faceNodeCounts, SyscElementNodeConnectivityData faceNodeConnectivity, SyscFaceCellConnectivityData faceCellConnectivity, SyscCellIdData cellIds)

Create a face-based volume mesh access struct.

Parameters:

  • nodes: - node data
  • faceNodeCounts: - face node counts
  • faceNodeConnectivity: - face-to-node connectivity
  • faceCellConnectivity: - face-to-cell connectivity
  • cellIds: - cell ids

Parameters:

Return type: SyscVolumeMesh

Macros​

Macro SYSC_STRING_LENGTH​

#define SYSC_STRING_LENGTH 256

Define maximum string length.

Last updated on by rborsaru-ansys