int main(void){
ESMC_ArraySpec arrayspec; // ESMC_ArraySpec object
char name[80];
char failMsg[80];
int result = 0;
int rc = 0;
int localrc;
int rank = 2;
int rank_out=0;
ESMC_TypeKind typekind;
ESMC_TypeKind typekind_out;
typekind= ESMC_TYPEKIND_I4;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Create an arrayspec object -- cf
strcpy(name, "ArraySpecSet Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, rank, typekind);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Get the data values of an arrayspec object -- cf
strcpy(name, "ArraySpecGet Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecGet(arrayspec, &rank_out, &typekind_out);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
#ifdef ESMF_TESTEXHAUSTIVE
//EX_UTest
// Verify output of ESMC_ArraySpecGet: kind
strcpy(name, "ArraySpecGet: rank Unit test");
strcpy(failMsg, "Rank returned is wrong");
ESMC_Test((rank == rank_out), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//EX_UTest
// Verify output of ESMC_ArraySpecGet: typekind
strcpy(name, "ArraySpecGet: typekind Unit test");
strcpy(failMsg, "Typekind returned is wrong");
ESMC_Test((typekind == typekind_out), name, failMsg, &result, __FILE__, __LINE__, 0);
#endif
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
char name[80];
char failMsg[80];
int result = 0;
int rc;
ESMC_ArraySpec arrayspec;
int *minIndexValues, *maxIndexValues;
ESMC_InterfaceInt minIndex, maxIndex;
ESMC_DistGrid distgrid;
ESMC_Array array;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Set the arrayspec
strcpy(name, "ArraySpecSet");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, 2, ESMC_TYPEKIND_I4);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
minIndexValues = (int *)malloc(2*sizeof(int));
minIndexValues[0] = minIndexValues[1] = 1;
minIndex = ESMC_InterfaceIntCreate(minIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
maxIndexValues = (int *)malloc(2*sizeof(int));
maxIndexValues[0] = 5;
maxIndexValues[1] = 10;
maxIndex = ESMC_InterfaceIntCreate(maxIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create 5 x 10 ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
distgrid = ESMC_DistGridCreate(minIndex, maxIndex, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(minIndexValues);
rc = ESMC_InterfaceIntDestroy(&minIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(maxIndexValues);
rc = ESMC_InterfaceIntDestroy(&maxIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
array = ESMC_ArrayCreate(arrayspec, distgrid, "array1", &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Print ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayPrint(array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_DistGridDestroy(&distgrid);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayDestroy(&array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
ESMC_State myState; // ESMC_State object
const char* arrayName;
char name[80];
char failMsg[80];
int result = 0;
int rc = 0;
int localrc;
ESMC_ArraySpec arrayspec;
int *minIndexValues, *maxIndexValues;
ESMC_InterfaceInt minIndex, maxIndex;
ESMC_DistGrid distgrid;
ESMC_Array array;
ESMC_Array retrievedArray;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Create a state object -- cf
strcpy(name, "StateCreate Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
myState = ESMC_StateCreate("stateName",&rc);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__,0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Set the arrayspec
strcpy(name, "ArraySpecSet");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, 2, ESMC_TYPEKIND_I4);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
minIndexValues = (int *)malloc(2*sizeof(int));
minIndexValues[0] = minIndexValues[1] = 1;
minIndex = ESMC_InterfaceIntCreate(minIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
maxIndexValues = (int *)malloc(2*sizeof(int));
maxIndexValues[0] = 5;
maxIndexValues[1] = 10;
maxIndex = ESMC_InterfaceIntCreate(maxIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create 5 x 10 ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
distgrid = ESMC_DistGridCreate(minIndex, maxIndex, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(minIndexValues);
rc = ESMC_InterfaceIntDestroy(&minIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(maxIndexValues);
rc = ESMC_InterfaceIntDestroy(&maxIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
array = ESMC_ArrayCreate(arrayspec, distgrid, "array1", &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Retrieve the name of an ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
arrayName = ESMC_ArrayGetName(array,&rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Verify array object name retrieved");
strcpy(failMsg, "Did not retrieve array name correctly");
ESMC_Test(!strcmp(arrayName, "array1"), name, failMsg, &result, __FILE__,
__LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Print ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayPrint(array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Add an Array to a State object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateAddArray(myState,array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Get an array from a state, based on its name");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateGetArray(myState, "array1", &retrievedArray);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Compare array stored into and array retrieved from a state");
strcpy(failMsg, "Discrepancy on array pointers");
ESMC_Test((array.ptr==retrievedArray.ptr), name, failMsg, &result, __FILE__,
__LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_DistGridDestroy(&distgrid);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayDestroy(&array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Destroy a state object -- cf
strcpy(name, "StateDestroy Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateDestroy(&myState);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__,0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
void myInitInC(ESMC_GridComp gcomp, ESMC_State importState,
ESMC_State exportState, ESMC_Clock *clock, int *rc){
// Array variables
ESMC_Array retrievedArray;
double *ptr;
int i, j, ij;
// Mesh variables
ESMC_Mesh mesh;
int pdim=2;
int sdim=3;
int num_elem, num_node, conn_size;
int *nodeId, *nodeOwner;
double *nodeCoord;
int *elemId, *elemType, *elemConn;
// Field variables
ESMC_Field field;
ESMC_ArraySpec arrayspec;
int *gridToFieldMap, *ungriddedLBound, *ungriddedUBound;
ESMC_InterfaceInt i_gridToFieldMap, i_ungriddedLBound, i_ungriddedUBound;
// initialize return code
*rc = ESMF_SUCCESS;
printf("In myInitInC()\n");
// get Array from import State
*rc=ESMC_StateGetArray(importState, "array1", &retrievedArray);
if (*rc!=ESMF_SUCCESS) return; // bail out
// obtain access to Array data
ptr = (double *)ESMC_ArrayGetPtr(retrievedArray, 0, rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// test accesibility of Array data via print
printf("local ptr[0] = %g\n", ptr[0]);
printf("local ptr[1] = %g\n", ptr[1]);
// modify Array data
for (j=0; j<2; j++){
for (i=0; i<5; i++){
// interpret as 2D array with contiguous, column-major storage
ij= j*5 +i;
ptr[ij] = j;
}
}
// print a modified value
printf("local ptr[0] = %g\n", ptr[0]);
// Create a Mesh from VTK file
mesh = ESMC_MeshCreate(&pdim, &sdim, rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Read input files' header data
*rc = ESMC_MeshVTKHeader("data/testmesh", &num_elem, &num_node, &conn_size);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Allocate the arrays to describe Mesh
nodeId = (int *) malloc (num_node * sizeof (int));
nodeCoord = (double *) malloc (3*num_node * sizeof (double));
nodeOwner = (int *) malloc (num_node * sizeof (int));
elemId = (int *) malloc (num_elem * sizeof (int));
elemType = (int *) malloc (num_elem * sizeof (int));
elemConn = (int *) malloc (conn_size * sizeof (int));
// Read input files
*rc = ESMC_MeshVTKBody("data/testmesh", nodeId, nodeCoord, nodeOwner, elemId,
elemType, elemConn);
if (*rc!=ESMF_SUCCESS) return; // bail out
// VTKBody returns zero based elemConn, so make them 1 based
for (int i = 0; i < conn_size; i++){
elemConn[i] = elemConn[i]+1;
}
// Add node information to the mesh
*rc = ESMC_MeshAddNodes(mesh, &num_node, nodeId, nodeCoord, nodeOwner);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Add element information to the mesh
*rc = ESMC_MeshAddElements(mesh, &num_elem, elemId, elemType, elemConn);
if (*rc!=ESMF_SUCCESS) return; // bail out
// garbage collection of temporary variables used to create Mesh object
free(nodeId);
free(nodeCoord);
free(nodeOwner);
free(elemId);
free(elemType);
free(elemConn);
// Create a Field from Mesh
// Setup arrayspec
*rc = ESMC_ArraySpecSet(&arrayspec, 3, ESMC_TYPEKIND_I4);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Setup gridToFieldMap
gridToFieldMap = (int *)malloc(sizeof(int));
gridToFieldMap[0] = 1;
i_gridToFieldMap = ESMC_InterfaceIntCreate(gridToFieldMap, 1, rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Setup ungriddedLBound
ungriddedLBound = (int *)malloc(2*sizeof(int));
ungriddedLBound[0] = 1;
ungriddedLBound[1] = 1;
i_ungriddedLBound = ESMC_InterfaceIntCreate(ungriddedLBound, 2, rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Setup ungriddedUBound
ungriddedUBound = (int *)malloc(2*sizeof(int));
ungriddedUBound[0] = 2;
ungriddedUBound[1] = 3;
i_ungriddedUBound = ESMC_InterfaceIntCreate(ungriddedUBound, 2, rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Finally create Field
field = ESMC_FieldCreate(mesh, arrayspec, i_gridToFieldMap, i_ungriddedLBound,
i_ungriddedUBound, "Field from C", rc);
if (*rc!=ESMF_SUCCESS) return; // bail out
// Add Field to the export State
*rc = ESMC_StateAddField(exportState, field);
if (*rc!=ESMF_SUCCESS) return; // bail out
// garbage collection of temporary variables used to create Field object
*rc = ESMC_InterfaceIntDestroy(&i_gridToFieldMap);
if (*rc!=ESMF_SUCCESS) return; // bail out
free(gridToFieldMap);
*rc = ESMC_InterfaceIntDestroy(&i_ungriddedLBound);
if (*rc!=ESMF_SUCCESS) return; // bail out
free(ungriddedLBound);
*rc = ESMC_InterfaceIntDestroy(&i_ungriddedUBound);
if (*rc!=ESMF_SUCCESS) return; // bail out
free(ungriddedUBound);
}
