void _ShellGeometry_Init(
ShellGeometry* self )
{
/* General and Virtual info should already be set */
/* ShellGeometry info */
self->isConstructed = True;
self->size[0] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeI",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->size[1] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeJ",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->size[2] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeK",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->pointCount = self->size[0] * self->size[1] * self->size[2];
assert( self->pointCount );
self->min[0] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minTheta",
Dictionary_Entry_Value_FromDouble( 2.0 * M_PI / 3.0 ) ) );
self->min[1] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minPhi",
Dictionary_Entry_Value_FromDouble( 2.0 * M_PI / 3.0 ) ) );
self->min[2] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minR",
Dictionary_Entry_Value_FromDouble( 0.5f ) ) );
self->max[0] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxTheta",
Dictionary_Entry_Value_FromDouble( M_PI / 3.0 ) ) );
self->max[1] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxPhi",
Dictionary_Entry_Value_FromDouble( M_PI / 3.0 ) ) );
self->max[2] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxR",
Dictionary_Entry_Value_FromDouble( 1.0f ) ) );
}
void _TriGaussParticleLayout_AssignFromXML( void* triGaussParticleLayout, Stg_ComponentFactory* cf, void* data ){
TriGaussParticleLayout *self = (TriGaussParticleLayout*)triGaussParticleLayout;
unsigned int dim;
unsigned int particlesPerCell;
_PerCellParticleLayout_AssignFromXML( self, cf, data );
dim = Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault( cf->rootDict, "dim", Dictionary_Entry_Value_FromUnsignedInt( 3 ) ) );
particlesPerCell = Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault( cf->rootDict, "particlesPerCell", Dictionary_Entry_Value_FromUnsignedInt( 1 ) ) );
_TriGaussParticleLayout_Init( self, dim, particlesPerCell );
}
void DictionarySuite_TestCreateValues( DictionarySuiteData* data ) {
Dictionary_Entry_Value* dev;
/* Don't use the pre-created test values. Want to do a very fundamental test here */
dev = Dictionary_Entry_Value_FromString( "hello" );
pcu_check_true( Dictionary_Entry_Value_Type_String == dev->type );
pcu_check_streq( "hello", dev->as.typeString );
Dictionary_Entry_Value_Delete( dev );
dev = Dictionary_Entry_Value_FromDouble( 45.567 );
pcu_check_true( Dictionary_Entry_Value_Type_Double == dev->type );
pcu_check_true( 45.567 == dev->as.typeDouble );
Dictionary_Entry_Value_Delete( dev );
dev = Dictionary_Entry_Value_FromUnsignedInt( 5 );
pcu_check_true( Dictionary_Entry_Value_Type_UnsignedInt == dev->type );
pcu_check_true( 5 == dev->as.typeUnsignedInt );
Dictionary_Entry_Value_Delete( dev );
dev = Dictionary_Entry_Value_FromInt( -5 );
pcu_check_true( Dictionary_Entry_Value_Type_Int == dev->type );
pcu_check_true( -5 == dev->as.typeInt );
Dictionary_Entry_Value_Delete( dev );
dev = Dictionary_Entry_Value_FromUnsignedLong( 52342423 );
pcu_check_true( Dictionary_Entry_Value_Type_UnsignedLong == dev->type );
pcu_check_true( 52342423 == dev->as.typeUnsignedLong );
Dictionary_Entry_Value_Delete( dev );
dev = Dictionary_Entry_Value_FromBool( True );
pcu_check_true( Dictionary_Entry_Value_Type_Bool == dev->type );
pcu_check_true( True == dev->as.typeBool );
Dictionary_Entry_Value_Delete( dev );
/* Since we know the DEV Struct is basically a Dictionary, won't test that one
* until after we've tested Dictionary_Add works */
}
unsigned int _Stg_ComponentFactory_GetUnsignedInt( void* cf, Name componentName, Dictionary_Entry_Key key, unsigned int defaultVal ) {
unsigned int retVal;
retVal = Dictionary_Entry_Value_AsUnsignedInt(
_Stg_ComponentFactory_GetNumericalValue( cf, componentName, key,
Dictionary_Entry_Value_FromUnsignedInt( defaultVal )));
/* TODO : Possible memory leak if defaultVal not added to the dictionary */
return retVal;
}
int Dictionary_GetUnsignedInt_WithDefault(
Dictionary* dictionary,
Dictionary_Entry_Key key,
const unsigned int defaultVal )
{
return Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault(
dictionary, key, Dictionary_Entry_Value_FromUnsignedInt( defaultVal ) ) );
}
void Dictionary_Entry_Value_AddElementWithSource( Dictionary_Entry_Value* self, Dictionary_Entry_Value* element,
Dictionary_Entry_Source source )
{
/* check type - convert to a list if not so... */
if (Dictionary_Entry_Value_Type_List != self->type) {
Dictionary_Entry_Value* copy;
switch (self->type) {
case Dictionary_Entry_Value_Type_String:
copy = Dictionary_Entry_Value_FromString( self->as.typeString );
break;
case Dictionary_Entry_Value_Type_Double:
copy = Dictionary_Entry_Value_FromDouble( self->as.typeDouble );
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
copy = Dictionary_Entry_Value_FromUnsignedInt( self->as.typeUnsignedInt );
break;
case Dictionary_Entry_Value_Type_Int:
copy = Dictionary_Entry_Value_FromInt( self->as.typeInt );
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
copy = Dictionary_Entry_Value_FromUnsignedLong( self->as.typeUnsignedLong );
break;
case Dictionary_Entry_Value_Type_Bool:
copy = Dictionary_Entry_Value_FromBool( self->as.typeBool );
break;
case Dictionary_Entry_Value_Type_Struct:
copy = Dictionary_Entry_Value_NewStruct();
copy->as.typeStruct = self->as.typeStruct;
break;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type );
}
}
Dictionary_Entry_Value_SetNewList( self );
Dictionary_Entry_Value_AddElementWithSource( self, copy, source );
}
if (!self->as.typeList->first) {
self->as.typeList->first = element;
} else {
self->as.typeList->last->next = element;
}
self->as.typeList->last = element;
self->as.typeList->count++;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int procCount;
Dictionary* dictionary;
Geometry* geometry;
ElementLayout* eLayout;
Topology* nTopology;
NodeLayout* nLayout;
HexaMD* meshDecomp;
Element_GlobalIndex e_I;
Index i;
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size(CommWorld, &procCount);
MPI_Comm_rank(CommWorld, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
geometry = (Geometry*)BlockGeometry_New( "blockGeometry", dictionary );
eLayout = (ElementLayout*)HexaEL_New( "HexaEL", 3, dictionary, geometry );
nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
meshDecomp = HexaMD_New( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout );
ElementLayout_Build( eLayout, meshDecomp );
printf( "Element corner indices:\n" );
for( e_I = 0; e_I < eLayout->elementCount; e_I++ ) {
Index* corners = Memory_Alloc_Array( Index, eLayout->elementCornerCount, "corners" );
eLayout->buildCornerIndices( eLayout, e_I, corners );
printf( "\tElement %u : { %u", e_I, corners[0] );
for( i = 1; i < eLayout->elementCornerCount; i++ )
printf( ", %u", corners[i] );
printf( " }\n" );
}
printf( "\n" );
printf( "Corner element indices:\n" );
for( i = 0; i < eLayout->cornerCount; i++ ) {
Element_GlobalIndex elementCnt = eLayout->cornerElementCount( eLayout, i );
Element_GlobalIndex* elements = Memory_Alloc_Array( Element_GlobalIndex, elementCnt, "elements" );
eLayout->buildCornerElements( eLayout, i, elements );
printf( "\tCorner %u : { %u", i, elements[0] );
for( e_I = 1; e_I < elementCnt; e_I++ )
printf( ", %u", elements[e_I] );
printf( " }\n" );
}
printf( "\n" );
printf( "Element with point:\n" );
for( i = 0; i < geometry->pointCount; i++ ) {
Coord point;
geometry->pointAt( geometry, i, point );
point[0] += 0.1;
point[1] += 0.1;
point[2] += 0.1;
printf( "\tPoint %u : %u\n", i, eLayout->elementWithPoint( eLayout, meshDecomp, point, NULL,
EXCLUSIVE_UPPER_BOUNDARY, 0, NULL ) );
}
printf( "\n" );
Stg_Class_Delete( dictionary );
Stg_Class_Delete( meshDecomp );
Stg_Class_Delete( nLayout );
Stg_Class_Delete( nTopology );
Stg_Class_Delete( eLayout );
Stg_Class_Delete( geometry );
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
Dictionary* dictionary;
AbstractContext* abstractContext;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
BaseFoundation_Init( &argc, &argv );
BaseIO_Init( &argc, &argv );
BaseContainer_Init( &argc, &argv );
BaseAutomation_Init( &argc, &argv );
BaseExtensibility_Init( &argc, &argv );
BaseContext_Init( &argc, &argv );
stream = Journal_Register (Info_Type, "myStream");
/* Redirect the error stream to stdout, so we can check warnings
appear correctly */
Stream_SetFileBranch( Journal_GetTypedStream( ErrorStream_Type ), stJournal->stdOut );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) Journal_Printf( (void*) stream, "Watching rank: %i\n", rank );
/* Read input */
dictionary = Dictionary_New();
dictionary->add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
dictionary->add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( numProcessors ) );
/* Build the context */
abstractContext = _AbstractContext_New(
sizeof(AbstractContext),
"TestContext",
MyDelete,
MyPrint,
NULL,
NULL,
NULL,
_AbstractContext_Build,
_AbstractContext_Initialise,
_AbstractContext_Execute,
_AbstractContext_Destroy,
"context",
True,
MySetDt,
0,
10,
CommWorld,
dictionary );
/* add hooks to existing entry points */
ContextEP_Append( abstractContext, AbstractContext_EP_Dt, MyDt );
if( rank == procToWatch ) {
Stream* stream = Journal_Register( InfoStream_Type, AbstractContext_Type );
Stg_Component_Build( abstractContext, 0 /* dummy */, False );
Stg_Component_Initialise( abstractContext, 0 /* dummy */, False );
Context_PrintConcise( abstractContext, stream );
Stg_Component_Execute( abstractContext, 0 /* dummy */, False );
Stg_Component_Destroy( abstractContext, 0 /* dummy */, False );
}
/* Stg_Class_Delete stuff */
Stg_Class_Delete( abstractContext );
Stg_Class_Delete( dictionary );
BaseContext_Finalise();
BaseExtensibility_Finalise();
BaseAutomation_Finalise();
BaseContainer_Finalise();
BaseIO_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main(int argc, char *argv[])
{
int rank;
int procCount;
int procToWatch;
Dictionary* dictionary;
MeshTopology* mt;
MeshGeometry* mg;
MeshDecomp* md;
MeshLayout* ml;
Coord point[8] = {{0.25, 0.25, 0.25}, {0.75, 0.25, 0.25}, {0.25, 0.75, 0.25}, {0.75, 0.75, 0.25},
{0.25, 0.25, 0.75}, {0.75, 0.25, 0.75}, {0.25, 0.75, 0.75}, {0.75, 0.75, 0.75}};
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &procCount);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 0 ) );
mt = (MeshTopology*)HexaMeshTopology_New(dictionary);
mg = (MeshGeometry*)HexaMeshGeometry_New(dictionary);
md = (MeshDecomp*)RegularMeshDecomp_New(dictionary, MPI_COMM_WORLD, mt);
ml = MeshLayout_New(mt, mg, md);
if (rank == procToWatch)
{
Element_GlobalIndex elt;
Index i;
Print(ml);
for (i = 0; i < 8; i++)
{
elt = MeshLayout_ElementWithPoint(ml, point[i]);
printf("Point: {%g, %g, %g} - element: ", point[i][0], point[i][1], point[i][2]);
if (elt < ml->decomp->nodeGlobalCount)
printf("%u\n", elt);
else
printf("X\n");
}
}
Stg_Class_Delete(ml);
Stg_Class_Delete(md);
Stg_Class_Delete(mg);
Stg_Class_Delete(mt);
Stg_Class_Delete(dictionary);
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main(int argc, char *argv[])
{
MPI_Comm CommWorld;
int rank;
int procCount;
int procToWatch;
Dictionary* dictionary;
ExtensionManager_Register* extensionMgr_Register;
Topology* nTopology;
ElementLayout* eLayout;
NodeLayout* nLayout;
MeshDecomp* decomp;
MeshLayout* ml;
Mesh* mesh;
Stream* stream;
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size(CommWorld, &procCount);
MPI_Comm_rank(CommWorld, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
stream = Journal_Register (Info_Type, "myStream");
procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary );
nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
decomp = (MeshDecomp*)HexaMD_New( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout );
ml = MeshLayout_New( "MeshLayout", eLayout, nLayout, decomp );
extensionMgr_Register = ExtensionManager_Register_New();
mesh = Mesh_New( "Mesh", ml, sizeof(Node), sizeof(Element), extensionMgr_Register, dictionary );
mesh->buildNodeLocalToGlobalMap = True;
mesh->buildNodeDomainToGlobalMap = True;
mesh->buildNodeGlobalToLocalMap = True;
mesh->buildNodeGlobalToDomainMap = True;
mesh->buildNodeNeighbourTbl = True;
mesh->buildNodeElementTbl = True;
mesh->buildElementLocalToGlobalMap = True;
mesh->buildElementDomainToGlobalMap = True;
mesh->buildElementGlobalToDomainMap = True;
mesh->buildElementGlobalToLocalMap = True;
mesh->buildElementNeighbourTbl = True;
mesh->buildElementNodeTbl = True;
Build( mesh, 0, False );
Initialise(mesh, 0, False );
if (rank == procToWatch)
{
Node_Index currElementNodesCount=0;
Node_Index* currElementNodes = NULL;
Element_Index element_dI = 0;
Node_Index refNode_eI = 0;
Node_Index node_Diagonal = 0;
Node_Index node_Diagonal_gI = 0;
// only use this while setting up the test
//Print(mesh, stream);
// Some tests involving RegularMeshUtils_GetDiagOppositeAcrossElementNodeIndex()
for (element_dI=0; element_dI < mesh->elementDomainCount; element_dI++) {
currElementNodes = mesh->elementNodeTbl[element_dI];
currElementNodesCount = mesh->elementNodeCountTbl[element_dI];
for (refNode_eI = 0; refNode_eI < currElementNodesCount; refNode_eI++ ) {
node_Diagonal = RegularMeshUtils_GetDiagOppositeAcrossElementNodeIndex(mesh, element_dI,
currElementNodes[refNode_eI]) ;
node_Diagonal_gI = Mesh_NodeMapDomainToGlobal( mesh, node_Diagonal );
//print message stating: Element #, curr node #, diag opp node #
printf("Element #: %d, Current Node #: %d, Diagonal Node #: %d, (%d) \n",
element_dI, currElementNodes[refNode_eI], node_Diagonal, node_Diagonal_gI);
}
}
}
Stg_Class_Delete(mesh);
Stg_Class_Delete(ml);
Stg_Class_Delete(decomp);
Stg_Class_Delete(nLayout);
Stg_Class_Delete(eLayout);
Stg_Class_Delete( nTopology );
Stg_Class_Delete(dictionary);
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
void DictionarySuite_SetupTestDictData( DictionarySuite_TestDictData* testDD ) {
Index ii=0;
Index iter=0;
Dictionary_Entry_Value* testStruct;
Dictionary_Entry_Value* testStruct2;
Dictionary_Entry_Value* testList;
testDD->testEntriesCount = 9;
testDD->testKeys = Memory_Alloc_Array_Unnamed( char*, testDD->testEntriesCount );
testDD->testValues = Memory_Alloc_Array_Unnamed( Dictionary_Entry_Value*,
testDD->testEntriesCount );
for ( ii=0; ii< testDD->testEntriesCount; ii++ ) {
testDD->testKeys[ii] = NULL;
testDD->testValues[ii] = NULL;
}
Stg_asprintf( &testDD->testString, "hello" );
Stg_asprintf( &testDD->testPlaceHolder, "test_double" );
testDD->testDouble=45.567;
testDD->testUint = 5;
testDD->testInt = -5;
testDD->testUnsignedlong = 52342423;
testDD->testBool = True;
iter = 0;
Stg_asprintf( &testDD->testKeys[iter], "test_cstring" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromString( testDD->testString );
Stg_asprintf( &testDD->testKeys[++iter], "test_double" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromDouble( testDD->testDouble );
Stg_asprintf( &testDD->testKeys[++iter], "test_uint" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromUnsignedInt( testDD->testUint );
Stg_asprintf( &testDD->testKeys[++iter], "test_int" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromInt( testDD->testInt );
Stg_asprintf( &testDD->testKeys[++iter], "test_unsignedlong" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromUnsignedLong( testDD->testUnsignedlong );
Stg_asprintf( &testDD->testKeys[++iter], "test_bool" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromUnsignedInt( testDD->testBool );
Stg_asprintf( &testDD->testKeys[++iter], "test_placeholder" );
testDD->testValues[iter] = Dictionary_Entry_Value_FromString( testDD->testPlaceHolder );
/* adding a list */
testDD->testListCount = 5;
testDD->testList = Memory_Alloc_Array_Unnamed( double, testDD->testListCount );
for (ii=0; ii<testDD->testListCount; ii++ ) {
testDD->testList[ii] = 10.0 * ii;
}
testList = Dictionary_Entry_Value_NewList();
Stg_asprintf( &testDD->testKeys[++iter], "test_list" );
testDD->testValues[iter] = testList;
for (ii=0; ii < testDD->testListCount; ii++ ) {
Dictionary_Entry_Value_AddElement( testList, Dictionary_Entry_Value_FromDouble(testDD->testList[ii]) );
}
/* Adding members to a struct */
testDD->testStruct = Memory_Alloc_Unnamed( TestStruct );
testDD->testStruct->height = 37;
testDD->testStruct->anisotropic = True;
Stg_asprintf( &testDD->testStruct->person, "Patrick" );
testDD->testStruct->geom.startx = 45;
testDD->testStruct->geom.starty = 60;
testDD->testStruct->geom.startz = 70;
testStruct = Dictionary_Entry_Value_NewStruct();
Stg_asprintf( &testDD->testKeys[++iter], "test_struct" );
testDD->testValues[iter] = testStruct;
Dictionary_Entry_Value_AddMember( testStruct, (Dictionary_Entry_Key)"height", Dictionary_Entry_Value_FromDouble( testDD->testStruct->height ) );
Dictionary_Entry_Value_AddMember( testStruct, (Dictionary_Entry_Key)"anisotropic", Dictionary_Entry_Value_FromBool( testDD->testStruct->anisotropic ) );
Dictionary_Entry_Value_AddMember( testStruct, (Dictionary_Entry_Key)"person", Dictionary_Entry_Value_FromString( testDD->testStruct->person ) );
/* Adding a 2nd struct within the first struct */
testStruct2 = Dictionary_Entry_Value_NewStruct( );
Dictionary_Entry_Value_AddMember( testStruct, (Dictionary_Entry_Key)"geom", testStruct2 );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"startx", Dictionary_Entry_Value_FromUnsignedInt( testDD->testStruct->geom.startx ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"starty", Dictionary_Entry_Value_FromUnsignedInt( testDD->testStruct->geom.starty ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"startz", Dictionary_Entry_Value_FromUnsignedInt( testDD->testStruct->geom.startz ) );
}
void DictionarySuite_TestMerge( DictionarySuiteData* data ) {
Dictionary_Entry_Value* testStruct2=NULL;
Dictionary_Entry_Value* testGeomStruct2=NULL;
Dictionary_Entry_Value* mergedStruct=NULL;
Dictionary_Entry_Value* expectedMergedStruct=NULL;
testStruct2 = Dictionary_Entry_Value_NewStruct( );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"height", Dictionary_Entry_Value_FromDouble( data->testDD->testStruct->height ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"anisotropic", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"new_person", Dictionary_Entry_Value_FromString( "Luke" ) );
testGeomStruct2 = Dictionary_Entry_Value_NewStruct( );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"geom", testGeomStruct2 );
Dictionary_Entry_Value_AddMember( testGeomStruct2, (Dictionary_Entry_Key)"startx", Dictionary_Entry_Value_FromUnsignedInt( data->testDD->testStruct->geom.startx ) );
Dictionary_Entry_Value_AddMember( testGeomStruct2, (Dictionary_Entry_Key)"startz", Dictionary_Entry_Value_FromUnsignedInt( 222 ) );
/* Testing Merge_Append */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
/* Do a copy of the DEV during merge, since we don't want it being deleted */
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Append );
/* OK: since this was an append, we expect _two_ entries called "test_struct",
* one preceding the other, one with the orig data, one with new data */
pcu_check_true( (data->testDD->testEntriesCount+1) == data->dict->count );
pcu_check_true( Dictionary_Entry_Value_Compare( data->testDD->testValues[8], Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" ) ) );
pcu_check_true( Dictionary_Entry_Value_Compare( testStruct2, data->dict->entryPtr[9]->value ) );
Dictionary_Empty( data->dict );
/* Testing Merge_Merge */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
/* The nicest way for this test I think is to manually build a merged struct
* to compare against */
expectedMergedStruct = Dictionary_Entry_Value_Copy( data->testDD->testValues[8], True );
Dictionary_Set( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"anisotropic", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"new_person", Dictionary_Entry_Value_FromString( "Luke" ) );
Dictionary_Set( (Dictionary_Get( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"geom" ) )->as.typeStruct, "startz", Dictionary_Entry_Value_FromUnsignedInt( 222 ) );
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Merge );
/* This time, the new struct should be merged into the existing one */
pcu_check_true( data->testDD->testEntriesCount == data->dict->count );
mergedStruct = Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" );
pcu_check_true( Dictionary_Entry_Value_Compare( mergedStruct, expectedMergedStruct ) );
Dictionary_Empty( data->dict );
Dictionary_Entry_Value_Delete( expectedMergedStruct );
/* Testing Merge_Replace */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Replace );
pcu_check_true( data->testDD->testEntriesCount == data->dict->count );
pcu_check_true( Dictionary_Entry_Value_Compare( testStruct2, Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" ) ) );
Dictionary_Empty( data->dict );
Dictionary_Entry_Value_Delete( testStruct2 );
}
double Stg_ComponentFactory_PluginGetUnsignedInt( void* cf, void *codelet, Dictionary_Entry_Key key, double defaultVal ) {
return Dictionary_Entry_Value_AsDouble(
_Stg_ComponentFactory_PluginGetNumericalValue( cf, codelet, key,
Dictionary_Entry_Value_FromUnsignedInt( defaultVal )));
}
int
BMI_Initialize (const char *config_file, BMI_Model ** handle)
{
BMI_Model *self;
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
char* filename;
if (!handle)
return BMI_FAILURE;
self = malloc( sizeof(BMI_Model) );
/* Initialise MPI, get world info */
MPI_Init( NULL, NULL ); /* MPI_Init( &argc, &argv ); */
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
/* Hardwire the process to watch to 0.
Note that it doesn't have to be 0 when multiple processrs are used. */
procToWatch = 0;
#if 0
if( argc >= 3 ) {
procToWatch = atoi( argv[2] );
}
else {
procToWatch = 0;
}
#endif
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
/* if (!Snac_Init( &argc, &argv )) { */
if (!Snac_Init( NULL, NULL )) {
fprintf(stderr, "Error initialising StGermain, exiting.\n" );
exit(EXIT_FAILURE);
}
/* Snac's init message */
{
int tmp = Stream_GetPrintingRank( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), 0 );
Journal_Printf( /* DO NOT CHANGE OR REMOVE */
Journal_Register( InfoStream_Type, "Context" ),
"Snac. Copyright (C) 2003-2005 Caltech, VPAC & University of Texas.\n" );
Stream_Flush( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), tmp );
}
/* Ensures copyright info always come first in output */
MPI_Barrier( CommWorld );
/* Create the dictionary, and some fixed values */
/* Hardwirred to the one-processor scenario for now. */
self->dictionary = Dictionary_New();
Dictionary_Add( self->dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( 0 ) );
Dictionary_Add( self->dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
/* Read input */
self->ioHandler = XML_IO_Handler_New();
filename = strdup( config_file );
if ( False == IO_Handler_ReadAllFromFile( self->ioHandler, filename, self->dictionary ) )
{
fprintf( stderr, "Error: Snac couldn't find specified input file %s. Exiting.\n", filename );
exit( EXIT_FAILURE );
}
Journal_ReadFromDictionary( self->dictionary );
free( filename );
/* This is the handle to the SNAC's model data. */
self->snacContext = Snac_Context_New( 0.0f, 0.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, self->dictionary );
if( rank == procToWatch ) Dictionary_PrintConcise( self->dictionary, self->snacContext->verbose );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( self->snacContext, 0 /* dummy */, &(self->snacContext), True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( self->snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( self->snacContext, 0 /* dummy */, False );
if( rank == procToWatch ) Context_PrintConcise( self->snacContext, self->snacContext->verbose );
/* pass the pointer to Snac_Context to handle */
*handle = self;
return BMI_SUCCESS;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int procCount;
Dictionary* dictionary;
Geometry* geometry;
ElementLayout* eLayout;
Topology* nTopology;
NodeLayout* nLayout;
HexaMD* meshDecomp;
Index i;
Processor_Index procToWatch;
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size(CommWorld, &procCount);
MPI_Comm_rank(CommWorld, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 13 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "maxX", Dictionary_Entry_Value_FromUnsignedInt( 6 ) );
Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
Dictionary_Add( dictionary, "isPeriodicI", Dictionary_Entry_Value_FromBool( True ) );
eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary );
nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
meshDecomp = HexaMD_New( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout );
ElementLayout_Build( eLayout, meshDecomp );
if (rank == procToWatch) {
printf( "Element with point:\n" );
}
geometry = eLayout->geometry;
for( i = 0; i < geometry->pointCount; i++ ) {
Coord point;
int excEl, incEl;
geometry->pointAt( geometry, i, point );
if (rank == procToWatch) {
printf( "\tNode %u (%0.2f,%0.2f,%0.2f):\n", i, point[0], point[1], point[2] );
excEl = eLayout->elementWithPoint( eLayout, meshDecomp, point, NULL,
EXCLUSIVE_UPPER_BOUNDARY, 0, NULL );
incEl = eLayout->elementWithPoint( eLayout, meshDecomp, point, NULL,
INCLUSIVE_UPPER_BOUNDARY, 0, NULL );
printf( "\t\tIncl %4u, Excl %4u\n", incEl, excEl );
}
point[0] += 0.1;
point[1] += 0.1;
point[2] += 0.1;
if (rank == procToWatch) {
printf( "\tTest point %u (%0.2f,%0.2f,%0.2f):\n", i, point[0], point[1], point[2] );
excEl = eLayout->elementWithPoint( eLayout, meshDecomp, point, NULL,
EXCLUSIVE_UPPER_BOUNDARY, 0, NULL );
incEl = eLayout->elementWithPoint( eLayout, meshDecomp, point, NULL,
INCLUSIVE_UPPER_BOUNDARY, 0, NULL );
printf( "\t\tIncl %4u, Excl %4u\n", incEl, excEl );
}
}
if (rank == procToWatch) {
printf( "\n" );
}
Stg_Class_Delete( dictionary );
Stg_Class_Delete( meshDecomp );
Stg_Class_Delete( nLayout );
Stg_Class_Delete( nTopology );
Stg_Class_Delete( eLayout );
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
Dictionary* dictionary;
Snac_Context* snacContext;
Element_LocalIndex elementIndex;
Node_LocalIndex nodeIndex;
double minLengthScale;
double speedOfSound;
Mass mass;
Mass inertialMass;
Force force;
Snac_Node* node;
Force balance;
Stream* stream;
Index elementNode_lI;
Coord *coord;
Index timeStep;
Dictionary_Entry_Value* pluginsList;
Dictionary_Entry_Value* velocityBCs;
Dictionary_Entry_Value* vcList;
Dictionary_Entry_Value* varStruct;
Dictionary_Entry_Value* eachVarList;
Dictionary_Entry_Value* vxStruct;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
Snac_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
stream = Journal_Register (InfoStream_Type, "myStream");
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
/* Read input */
dictionary = Dictionary_New();
dictionary->add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
dictionary->add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( numProcessors ) );
dictionary->add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
dictionary->add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
dictionary->add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 3 ) );
dictionary->add( dictionary, "minX", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "minY", Dictionary_Entry_Value_FromDouble( -1.0f ) );
dictionary->add( dictionary, "minZ", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxX", Dictionary_Entry_Value_FromDouble( 1.0f ) );
dictionary->add( dictionary, "maxY", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxZ", Dictionary_Entry_Value_FromDouble( 1.0f ) );
dictionary->add( dictionary, "gravity", Dictionary_Entry_Value_FromDouble( 0 ) );
dictionary->add( dictionary, "dtType", Dictionary_Entry_Value_FromString( "constant" ) );
dictionary->add( dictionary, "timeStep", Dictionary_Entry_Value_FromDouble( 1.0 ) );
dictionary->add( dictionary, "topo_kappa", Dictionary_Entry_Value_FromDouble( 0 ) );
dictionary->add( dictionary, "alpha", Dictionary_Entry_Value_FromDouble( 0 ) );
dictionary->add( dictionary, "forceCalcType", Dictionary_Entry_Value_FromString( "complete" ) );
pluginsList = Dictionary_Entry_Value_NewList();
Dictionary_Add( dictionary, "plugins", pluginsList );
velocityBCs = Dictionary_Entry_Value_NewStruct();
vcList = Dictionary_Entry_Value_NewList();
/* left wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vx" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.0 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "left" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* right wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vx" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.01 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "right" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* back wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vz" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.0 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "back" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* front wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vz" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.0 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "front" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* bottom wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vy" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.0 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "bottom" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* top wall */
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vy" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 0.0 ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "WallVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "wall", Dictionary_Entry_Value_FromString( "top" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
/* add to dictionary */
Dictionary_Entry_Value_AddMember( velocityBCs, "vcList", vcList );
Dictionary_Add( dictionary, "velocityBCs", velocityBCs );
/* Build the context */
snacContext = Snac_Context_New( 0.0f, 10.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, dictionary );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( snacContext, 0 /* dummy */, &snacContext, True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( snacContext, 0 /* dummy */, False );
/* Check the coordinates of the nodes. */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex ++ ) {
printf( "Element: %u, Coords: ", elementIndex );
for( elementNode_lI = 0; elementNode_lI < 8; elementNode_lI++ ) {
printf( "(%g %g %g) ",
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[2] );
}
printf( "\n" );
}
/* Check the velocity field. */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex ++ ) {
printf( "Element: %u, Vel: ",elementIndex );
for( elementNode_lI = 0; elementNode_lI < 8; elementNode_lI++ ) {
printf( "(%g %g %g) ",
Snac_Element_Node_P( snacContext, elementIndex, elementNode_lI )->velocity[0],
Snac_Element_Node_P( snacContext, elementIndex, elementNode_lI )->velocity[1],
Snac_Element_Node_P( snacContext, elementIndex, elementNode_lI )->velocity[2] );
}
printf( "\n" );
}
/* Check the coordinates of the nodes. */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex ++ ) {
printf( "Element: %u, Coords: ", elementIndex );
for( elementNode_lI = 0; elementNode_lI < 8; elementNode_lI++ ) {
printf( "(%g %g %g) ",
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, elementNode_lI )[2] );
}
printf( "\n" );
}
/* Loop until the static solution is reached. */
timeStep = 0;
while( timeStep < 10 ) {
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
double elementMinLengthScale;
Snac_UpdateElementMomentum( snacContext, elementIndex, &elementMinLengthScale );
if( elementMinLengthScale < minLengthScale ) {
minLengthScale = elementMinLengthScale;
}
}
/* Find the global minLengthScale, and then calculate the new dt and speed of sound, assuming frac=0.5,
* strain_inert=1.0e-5f & vbc_max=3.0e-10f */
{
double localMinLengthScale = minLengthScale;
MPI_Allreduce( &localMinLengthScale, &minLengthScale, 1, MPI_DOUBLE, MPI_MIN, CommWorld );
//snacContext->dt = minLengthScale * 0.5f * 1.0e-5f / 3.0e-10f;
speedOfSound = minLengthScale * 0.5f / snacContext->dt;
}
/* For each element, calculate strain-rate and then stress */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
Snac_StrainRate( (Context*)snacContext, elementIndex );
SnacTest_Stress( (Context*)snacContext, elementIndex );
}
for( nodeIndex = 0; nodeIndex < snacContext->mesh->nodeLocalCount; nodeIndex++ ) {
node = Snac_Node_At( snacContext, nodeIndex );
Snac_Force( snacContext, nodeIndex, speedOfSound, &mass, &inertialMass, &force, &balance );
Snac_UpdateNodeMomentum_PreProcess( snacContext, nodeIndex, inertialMass, force );
Snac_UpdateNodeMomentum( snacContext, nodeIndex, inertialMass, force );
}
timeStep++;
}
/* Check coordinates. */
for( nodeIndex = 0; nodeIndex < snacContext->mesh->nodeLocalCount; nodeIndex++ ) {
coord = Snac_NodeCoord_P( snacContext, nodeIndex );
printf( "Node %u : coord = %g %g %g\n", nodeIndex, (*coord)[0],(*coord)[1],(*coord)[2]);
}
/* Stg_Class_Delete stuff */
Stg_Class_Delete( snacContext );
Stg_Class_Delete( dictionary );
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main(int argc, char **argv)
{
MPI_Comm CommWorld;
XML_IO_Handler *io_handler = XML_IO_Handler_New();
int rank, procCount, procToWatch;
Dictionary *dictionary;
EmbeddedSurface *surface;
MeshTopology *rmt, *imt;
MeshGeometry *rmg, *img;
MeshDecomp *rmd, *imd;
MeshLayout *rml, *isl;
ExtensionManager_Register *extensionMgr_Register;
Mesh *mesh;
Element_GlobalIndex intersectCnt, *intersect;
Index i;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &procCount );
MPI_Comm_rank( CommWorld, &rank );
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
DiscretisationUtils_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
if( argc >= 2 )
procToWatch = atoi( argv[1] );
else
procToWatch = 0;
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 2 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 2 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 0 ) );
IO_Handler_ReadAllFromFile(io_handler, "data/surface.xml", dictionary);
rmt = (MeshTopology *)HexaMeshTopology_New(dictionary);
rmg = (MeshGeometry *)HexaMeshGeometry_New(dictionary);
rmd = (MeshDecomp *)HexaMeshDecomp_New(dictionary, MPI_COMM_WORLD, (HexaMeshTopology *)rmt);
rml = MeshLayout_New(dictionary, rmt, rmg, rmd);
imt = (MeshTopology *)TriSurfTopology_New(dictionary, "imElements");
img = (MeshGeometry *)TriSurfGeometry_New(dictionary, "imNodes");
imd = (MeshDecomp *)IrregularMeshDecomp_New1(dictionary, MPI_COMM_WORLD, imt, img, rml);
isl = MeshLayout_New(dictionary, imt, img, imd);
extensionMgr_Register = ExtensionManager_Register_New( );
mesh = Mesh_New( isl, sizeof(Node), sizeof(Element), extensionMgr_Register, dictionary );
Mesh_Build( mesh );
Mesh_Initialise(mesh);
surface = EmbeddedSurface_New(mesh);
if (procToWatch == rank)
{
intersect = Memory_Alloc_Array( Element_GlobalIndex, isl->decomp->elementGlobalCount(isl->decomp), "intersect" );
intersectCnt = EmbeddedSurface_BuildIntersection(surface, intersect);
printf("Intersects: %u\n", intersectCnt);
for (i = 0; i < intersectCnt; i++)
printf("\tinstersect[%u]: %u\n", i, intersect[i]);
printf("\n");
if (intersect) Memory_Free(intersect);
for (i = 0; i < isl->decomp->nodeGlobalCount(isl->decomp); i++)
{
Coord point;
point[0] = ((TriSurfGeometry *)img)->node[i][0] + 1.0;
point[1] = ((TriSurfGeometry *)img)->node[i][1];
point[2] = ((TriSurfGeometry *)img)->node[i][2];
printf("Distance to point {%.3f, %.3f, %.3f}: ", point[0], point[1], point[2]);
printf("%.3f\n", EmbeddedSurface_DistanceToPoint(surface, point));
}
}
Stg_Class_Delete(surface);
Stg_Class_Delete(isl);
Stg_Class_Delete(imd);
Stg_Class_Delete(img);
Stg_Class_Delete(imt);
Stg_Class_Delete(rml);
Stg_Class_Delete(rmd);
Stg_Class_Delete(rmg);
Stg_Class_Delete(rmt);
DiscretisationUtils_Finalise();
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
Dictionary* dictionary;
Snac_Context* snacContext;
Element_LocalIndex elementIndex;
Node_LocalIndex nodeIndex;
double minLengthScale;
double speedOfSound;
Mass mass;
Mass inertialMass;
Force force;
Force balance;
Stream* stream;
Dictionary_Entry_Value* nodeICs;
Dictionary_Entry_Value* vcList;
Dictionary_Entry_Value* varStruct;
Dictionary_Entry_Value* eachVarList;
Dictionary_Entry_Value* vxStruct;
Dictionary_Entry_Value* vyStruct;
Dictionary_Entry_Value* vzStruct;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
Snac_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
stream = Journal_Register (Info_Type, "myStream");
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
/* Read input */
dictionary = Dictionary_New();
dictionary->add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
dictionary->add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( numProcessors ) );
dictionary->add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "minX", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "minY", Dictionary_Entry_Value_FromDouble( -300.0f ) );
dictionary->add( dictionary, "minZ", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxX", Dictionary_Entry_Value_FromDouble( 300.0f ) );
dictionary->add( dictionary, "maxY", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxZ", Dictionary_Entry_Value_FromDouble( 300.0f ) );
nodeICs = Dictionary_Entry_Value_NewStruct();
vcList = Dictionary_Entry_Value_NewList();
varStruct = Dictionary_Entry_Value_NewStruct();
eachVarList = Dictionary_Entry_Value_NewList();
vxStruct = Dictionary_Entry_Value_NewStruct();
vyStruct = Dictionary_Entry_Value_NewStruct();
vzStruct = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( vxStruct, "name", Dictionary_Entry_Value_FromString( "vx" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vxStruct, "value", Dictionary_Entry_Value_FromDouble( 3.0e-10f ) );
Dictionary_Entry_Value_AddMember( vyStruct, "name", Dictionary_Entry_Value_FromString( "vy" ) );
Dictionary_Entry_Value_AddMember( vyStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vyStruct, "value", Dictionary_Entry_Value_FromDouble( 3.0e-10f ) );
Dictionary_Entry_Value_AddMember( vzStruct, "name", Dictionary_Entry_Value_FromString( "vz" ) );
Dictionary_Entry_Value_AddMember( vzStruct, "type", Dictionary_Entry_Value_FromString( "double" ) );
Dictionary_Entry_Value_AddMember( vzStruct, "value", Dictionary_Entry_Value_FromDouble( 6.0e-10f ) );
Dictionary_Entry_Value_AddElement( eachVarList, vxStruct );
Dictionary_Entry_Value_AddElement( eachVarList, vyStruct );
Dictionary_Entry_Value_AddElement( eachVarList, vzStruct );
Dictionary_Entry_Value_AddMember( varStruct, "type", Dictionary_Entry_Value_FromString( "AllNodesVC" ) );
Dictionary_Entry_Value_AddMember( varStruct, "variables", eachVarList );
Dictionary_Entry_Value_AddElement( vcList, varStruct );
Dictionary_Entry_Value_AddMember( nodeICs, "vcList", vcList );
Dictionary_Add( dictionary, "nodeICs", nodeICs );
/* Build the context */
snacContext = Snac_Context_New( 0.0f, 10.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, dictionary );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( snacContext, 0 /* dummy */, &snacContext, True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( snacContext, 0 /* dummy */, False );
/* Work out the first element's tetrahedra values, and print them. */
printf( "Element: 0, Coords: (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g) (%g %g %g) (%g %g %g) (%g %g %g)\n",
Snac_Element_NodeCoord( snacContext, 0, 0 )[0],
Snac_Element_NodeCoord( snacContext, 0, 0 )[1],
Snac_Element_NodeCoord( snacContext, 0, 0 )[2],
Snac_Element_NodeCoord( snacContext, 0, 1 )[0],
Snac_Element_NodeCoord( snacContext, 0, 1 )[1],
Snac_Element_NodeCoord( snacContext, 0, 1 )[2],
Snac_Element_NodeCoord( snacContext, 0, 3 )[0],
Snac_Element_NodeCoord( snacContext, 0, 3 )[1],
Snac_Element_NodeCoord( snacContext, 0, 3 )[2],
Snac_Element_NodeCoord( snacContext, 0, 2 )[0],
Snac_Element_NodeCoord( snacContext, 0, 2 )[1],
Snac_Element_NodeCoord( snacContext, 0, 2 )[2],
Snac_Element_NodeCoord( snacContext, 0, 4 )[0],
Snac_Element_NodeCoord( snacContext, 0, 4 )[1],
Snac_Element_NodeCoord( snacContext, 0, 4 )[2],
Snac_Element_NodeCoord( snacContext, 0, 5 )[0],
Snac_Element_NodeCoord( snacContext, 0, 5 )[1],
Snac_Element_NodeCoord( snacContext, 0, 5 )[2],
Snac_Element_NodeCoord( snacContext, 0, 7 )[0],
Snac_Element_NodeCoord( snacContext, 0, 7 )[1],
Snac_Element_NodeCoord( snacContext, 0, 7 )[2],
Snac_Element_NodeCoord( snacContext, 0, 6 )[0],
Snac_Element_NodeCoord( snacContext, 0, 6 )[1],
Snac_Element_NodeCoord( snacContext, 0, 6 )[2] );
printf( "Element: 0, Vel: (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g) (%g %g %g) (%g %g %g) (%g %g %g)\n",
Snac_Element_Node_P( snacContext, 0, 0 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 0 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 0 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 1 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 1 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 1 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 3 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 3 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 3 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 2 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 2 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 2 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 4 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 4 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 4 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 5 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 5 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 5 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 7 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 7 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 7 )->velocity[2],
Snac_Element_Node_P( snacContext, 0, 6 )->velocity[0],
Snac_Element_Node_P( snacContext, 0, 6 )->velocity[1],
Snac_Element_Node_P( snacContext, 0, 6 )->velocity[2] );
/* Snac_Material_Print( &snacContext->materialProperty[Snac_Element_At( snacContext, 0 )->material_I], stream ); */
/* Update all the elements, and in the process work out this processor's minLengthScale */
elementIndex = 0;
Snac_UpdateElementMomentum( (Context*)snacContext, elementIndex, &minLengthScale );
for( elementIndex = 1; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
double elementMinLengthScale;
Snac_UpdateElementMomentum( (Context*)snacContext, elementIndex, &elementMinLengthScale );
if( elementMinLengthScale < minLengthScale ) {
minLengthScale = elementMinLengthScale;
}
}
/* Find the global minLengthScale, and then calculate the new dt and speed of sound, assuming frac=0.5,
* strain_inert=1.0e-5f & vbc_max=3.0e-10f */
{
double localMinLengthScale = minLengthScale;
MPI_Allreduce( &localMinLengthScale, &minLengthScale, 1, MPI_DOUBLE, MPI_MIN, CommWorld );
snacContext->dt = minLengthScale * 0.5f * 1.0e-5f / 3.0e-10f;
speedOfSound = minLengthScale * 0.5f / snacContext->dt;
}
printf( "Global minLengthScale: %g\n", minLengthScale );
printf( "Dt: %g\n", snacContext->dt );
printf( "Speed of sound: %g\n", speedOfSound );
/* For each element, calculate strain-rate and then stress */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
Snac_StrainRate( (Context*)snacContext, elementIndex );
SnacTest_Stress( (Context*)snacContext, elementIndex );
}
/* For each node, calculate the mass, force, veloity and coordinates */
for( nodeIndex = 0; nodeIndex < snacContext->mesh->nodeLocalCount; nodeIndex++ ) {
Snac_Force( (Context*)snacContext, nodeIndex, speedOfSound, &mass, &inertialMass, &force, &balance );
Snac_UpdateNodeMomentum( (Context*)snacContext, nodeIndex, inertialMass, force );
}
/* For each element... just print out the info... too complicated to work out which ones have the same value */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
double elementMinLengthScale;
Tetrahedra_Index tetra_I;
Snac_UpdateElementMomentum( (Context*)snacContext, elementIndex, &elementMinLengthScale );
for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) {
printf( "Element: %u, tetrahedra: %u, strain: (%g %g %g) (%g %g %g)\n", elementIndex, tetra_I,
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[0][0],
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[1][1],
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[2][2],
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[0][1],
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[0][2],
Snac_Element_At( snacContext, elementIndex )->tetra[tetra_I].strain[1][2] );
}
}
/* Stg_Class_Delete stuff */
Stg_Class_Delete( snacContext );
Stg_Class_Delete( dictionary );
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
/* Main */
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
Dictionary* dictionary;
Dictionary* componentDict;
XML_IO_Handler* ioHandler;
char* filename;
Snac_Context* snacContext;
int tmp;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
if( argc >= 3 ) {
procToWatch = atoi( argv[2] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
if (!Snac_Init( &argc, &argv )) {
fprintf(stderr, "Error initialising StGermain, exiting.\n" );
exit(EXIT_FAILURE);
}
/* Snac's init message */
tmp = Stream_GetPrintingRank( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), 0 );
Journal_Printf( /* DO NOT CHANGE OR REMOVE */
Journal_Register( InfoStream_Type, "Context" ),
"Snac. Copyright (C) 2003-2005 Caltech, VPAC & University of Texas.\n" );
Stream_Flush( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), tmp );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
/* Create the dictionary, and some fixed values */
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( numProcessors ) );
/* Read input */
ioHandler = XML_IO_Handler_New();
if( argc >= 2 ) {
filename = strdup( argv[1] );
}
else {
filename = strdup( "input.xml" );
}
if ( False == IO_Handler_ReadAllFromFile( ioHandler, filename, dictionary ) )
{
fprintf( stderr, "Error: Snac couldn't find specified input file %s. Exiting.\n", filename );
exit( EXIT_FAILURE );
}
Journal_ReadFromDictionary( dictionary );
snacContext = Snac_Context_New( 0.0f, 0.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, dictionary );
if( rank == procToWatch ) Dictionary_PrintConcise( dictionary, snacContext->verbose );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( snacContext, 0 /* dummy */, &snacContext, True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( snacContext, 0 /* dummy */, False );
if( rank == procToWatch ) Context_PrintConcise( snacContext, snacContext->verbose );
/* Step the context solver */
Stg_Component_Execute( snacContext, 0 /* dummy */, False );
/* Stg_Class_Delete stuff */
Stg_Component_Destroy( snacContext, 0 /* dummy */, False );
Stg_Class_Delete( snacContext );
free( filename );
Stg_Class_Delete( ioHandler );
Stg_Class_Delete( dictionary );
/* Close off frameworks */
Snac_Finalise();
MPI_Finalize();
return 0; /* success */
}
Dictionary_Entry_Value* Dictionary_Entry_Value_Copy(
Dictionary_Entry_Value* self,
Bool deep )
{
Dictionary_Entry_Value* copy = NULL;
switch (self->type) {
case Dictionary_Entry_Value_Type_String:
copy = Dictionary_Entry_Value_FromString( self->as.typeString );
break;
case Dictionary_Entry_Value_Type_Double:
copy = Dictionary_Entry_Value_FromDouble( self->as.typeDouble );
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
copy = Dictionary_Entry_Value_FromUnsignedInt( self->as.typeUnsignedInt );
break;
case Dictionary_Entry_Value_Type_Int:
copy = Dictionary_Entry_Value_FromInt( self->as.typeInt );
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
copy = Dictionary_Entry_Value_FromUnsignedLong( self->as.typeUnsignedLong );
break;
case Dictionary_Entry_Value_Type_Bool:
copy = Dictionary_Entry_Value_FromBool( self->as.typeBool );
break;
case Dictionary_Entry_Value_Type_List:
if ( False == deep ) {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: Shallow copy operation of list DEV not supported.\n", __func__ );
}
else {
Dictionary_Entry_Value* cur = self->as.typeList->first;
Dictionary_Entry_Value* copiedEntry = NULL;
copy = Dictionary_Entry_Value_NewList();
while ( cur ) {
copiedEntry = Dictionary_Entry_Value_Copy( cur, True );
Dictionary_Entry_Value_AddElement( copy, copiedEntry );
cur = cur->next;
}
}
break;
case Dictionary_Entry_Value_Type_Struct:
if ( False == deep ) {
copy = Dictionary_Entry_Value_FromStruct( self->as.typeStruct );
}
else {
Dictionary* copiedDict;
copiedDict = (Dictionary*)Stg_Class_Copy( self->as.typeStruct,
NULL, True, NULL, NULL );
copy = Dictionary_Entry_Value_FromStruct( copiedDict );
}
break;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type );
}
}
return copy;
}
int main(int argc, char *argv[])
{
MPI_Comm CommWorld;
int rank;
int procCount;
int procToWatch;
Stream* stream;
Dictionary* dictionary;
XML_IO_Handler* io_handler;
Topology* nTopology;
ElementLayout* eLayout;
NodeLayout* nLayout;
MeshDecomp* decomp;
MeshLayout* layout;
Mesh* mesh;
Variable* var[7];
Variable_Register* variable_Register;
WallVC* vc;
ConditionFunction* quadCF;
ConditionFunction* expCF;
ConditionFunction_Register* conFunc_Register;
ExtensionManager_Register* extensionMgr_Register;
double* array[7];
char* vcKey[] = {"WallVC_Front", "WallVC_Back", "WallVC_Left", "WallVC_Right",
"WallVC_Top", "WallVC_Bottom"};
char* vcKeyName[] = {"WallVC_FrontName", "WallVC_BackName", "WallVC_LeftName", "WallVC_RightName",
"WallVC_TopName", "WallVC_BottomName"};
char* varName[] = {"x", "y", "z", "vx", "vy", "vz", "temp"};
Index i;
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size(CommWorld, &procCount);
MPI_Comm_rank(CommWorld, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
DiscretisationUtils_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
io_handler = XML_IO_Handler_New();
stream = Journal_Register (Info_Type, "myStream");
procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
dictionary = Dictionary_New();
IO_Handler_ReadAllFromFile(io_handler, "data/wallVC.xml", dictionary);
fflush(stdout);
MPI_Barrier(MPI_COMM_WORLD);
Dictionary_Add(dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt(rank));
Dictionary_Add(dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt(procCount));
Dictionary_Add(dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt(4));
Dictionary_Add(dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt(4));
Dictionary_Add(dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt(4));
Dictionary_Add(dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool(True));
extensionMgr_Register = ExtensionManager_Register_New();
nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary );
nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
decomp = (MeshDecomp*)HexaMD_New( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout );
layout = MeshLayout_New( "MeshLayout", eLayout, nLayout, decomp );
mesh = Mesh_New( "Mesh", layout, 0, 0, extensionMgr_Register, dictionary );
/* Create CF stuff */
quadCF = ConditionFunction_New(quadratic, "quadratic");
expCF = ConditionFunction_New(exponential, "exponential");
conFunc_Register = ConditionFunction_Register_New();
ConditionFunction_Register_Add(conFunc_Register, quadCF);
ConditionFunction_Register_Add(conFunc_Register, expCF);
/* Create variable register */
variable_Register = Variable_Register_New();
/* Create variables */
for (i = 0; i < 6; i++) {
array[i] = Memory_Alloc_Array( double, decomp->nodeLocalCount, "array[i]" );
var[i] = Variable_NewScalar( varName[i], Variable_DataType_Double, &decomp->nodeLocalCount, (void**)&array[i], 0 );
Variable_Register_Add(variable_Register, var[i]);
}
array[6] = Memory_Alloc_Array( double, decomp->nodeLocalCount * 5, "array[6]" );
var[6] = Variable_NewVector( varName[6], Variable_DataType_Double, 5, &decomp->nodeLocalCount, (void**)&array[6], 0 );
Variable_Register_Add(variable_Register, var[6]);
Variable_Register_BuildAll(variable_Register);
/* Create WallVC */
for (i = 0; i < 6; i++)
{
Index j, k;
vc = WallVC_New( vcKeyName[i], vcKey[i], variable_Register, conFunc_Register, dictionary, mesh );
Build( vc, 0, False );
for (j = 0; j < 6; j++)
memset(array[j], 0, sizeof(double)* decomp->nodeLocalCount );
memset(array[6], 0, sizeof(double)* decomp->nodeLocalCount * 5);
VariableCondition_Apply(vc, NULL);
if (rank == procToWatch)
{
printf("Testing for %s\n", vcKey[i]);
Print(vc, stream);
printf("\n");
for (j = 0; j < 6; j++)
{
printf("\nvar[%u]: %.2lf", j, array[j][0]);
for (k = 1; k < decomp->nodeLocalCount; k++)
printf(", %.2lf", array[j][k]);
}
printf("\nvar[6]: %.2lf", array[6][0]);
for (j = 1; j < decomp->nodeLocalCount*5; j++)
printf(", %.2lf", array[6][j]);
printf("\n\n");
for (j = 0; j < 7; j++)
{
for (k = 0; k < decomp->nodeLocalCount; k++)
printf("%s ", VariableCondition_IsCondition(vc, k, j) ? "True " : "False");
printf("\n");
}
printf("\n");
for (j = 0; j < 7; j++)
{
for (k = 0; k < decomp->nodeLocalCount; k++)
{
VariableCondition_ValueIndex valIndex;
valIndex = VariableCondition_GetValueIndex(vc, k, j);
if (valIndex != (unsigned)-1)
printf("%03u ", valIndex);
else
printf("XXX ");
}
printf("\n");
}
printf("\n");
}
Stg_Class_Delete(vc);
}
Stg_Class_Delete(variable_Register);
for (i = 0; i < 7; i++)
{
Stg_Class_Delete(var[i]);
if (array[i]) Memory_Free(array[i]);
}
Stg_Class_Delete(conFunc_Register);
Stg_Class_Delete(quadCF);
Stg_Class_Delete(expCF);
Stg_Class_Delete(layout);
Stg_Class_Delete(decomp);
Stg_Class_Delete(nLayout);
Stg_Class_Delete(eLayout);
Stg_Class_Delete( nTopology );
Stg_Class_Delete(dictionary);
DiscretisationUtils_Finalise();
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main(int argc, char *argv[])
{
MPI_Comm CommWorld;
int rank;
int procCount;
int procToWatch;
Dictionary* dictionary;
Topology* nTopology;
ElementLayout* eLayout;
NodeLayout* nLayout;
HexaMD* decompCorner;
HexaMD* decompBody;
Stream* stream;
Index decompDims;
XML_IO_Handler* ioHandler;
Dimension_Index dim_I;
/* Initialise MPI, get world info */
MPI_Init(&argc, &argv);
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size(CommWorld, &procCount);
MPI_Comm_rank(CommWorld, &rank);
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
Journal_Enable_TypedStream( DebugStream_Type, False );
stream = Journal_Register( DebugStream_Type, HexaMD_Type );
Stream_EnableBranch( stream, True );
Stream_SetLevelBranch( stream, 3 );
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 5 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 5 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 5 ) );
Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
/* Moved afterwards to allow command line to over-ride */
ioHandler = XML_IO_Handler_New();
IO_Handler_ReadAllFromCommandLine( ioHandler, argc, argv, dictionary );
decompDims = Dictionary_GetUnsignedInt_WithDefault( dictionary, "decompDims", 1 );
nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary );
nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
decompCorner = HexaMD_New_All( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout, decompDims );
if( rank == procToWatch ) {
printf( "Corner Node Layout\n" );
PrintDecompInfoOfHexaMD( decompCorner, rank );
printf( "\n" );
}
/* Do a run with body nodes */
Stg_Class_Delete( nLayout );
/* TODO: the following is a bit of a hack because of the weird way mesh size is defined by default in
the dictionary (assumes a corner mesh ) */
for ( dim_I = 0; dim_I < 3; dim_I++ ) {
if ( ((IJKTopology*)nTopology)->size[dim_I] > 1 ) {
((IJKTopology*)nTopology)->size[dim_I]--;
}
}
nLayout = (NodeLayout*)BodyNL_New( "BodyNL", dictionary, eLayout, nTopology );
decompBody = HexaMD_New_All( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout, decompDims );
if( rank == procToWatch ) {
Bool result;
printf( "Body Node Layout\n" );
//PrintDecompInfoOfHexaMD( decompBody, rank );
printf( "Checking body node decomp has same element decomp as corner node decomp:\n" );
result = CheckDecompItemsAreDecomposedIdentically( decompCorner, ELEMENT_ITEM_TYPE,
decompBody, ELEMENT_ITEM_TYPE, rank );
if ( result == True ) printf( "\tPassed.\n" );
else printf( "\tFailed.\n" );
printf( "Checking body node decomp has same node decomp as it's element decomp:\n" );
result = CheckDecompItemsAreDecomposedIdentically( decompBody, ELEMENT_ITEM_TYPE,
decompBody, NODE_ITEM_TYPE, rank );
if ( result == True ) printf( "\tPassed.\n" );
else printf( "\tFailed.\n" );
}
Stg_Class_Delete( decompBody );
Stg_Class_Delete( decompCorner );
Stg_Class_Delete( nLayout );
Stg_Class_Delete( eLayout );
Stg_Class_Delete( nTopology );
Stg_Class_Delete( dictionary );
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return EXIT_SUCCESS;
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
Dictionary* dictionary;
Snac_Context* snacContext;
Tetrahedra_Index tetraIndex;
Element_Index elementIndex;
double minLengthScale;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
Snac_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
/* Read input */
dictionary = Dictionary_New();
dictionary->add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
dictionary->add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( numProcessors ) );
dictionary->add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
dictionary->add( dictionary, "minX", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "minY", Dictionary_Entry_Value_FromDouble( -300.0f ) );
dictionary->add( dictionary, "minZ", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxX", Dictionary_Entry_Value_FromDouble( 300.0f ) );
dictionary->add( dictionary, "maxY", Dictionary_Entry_Value_FromDouble( 0.0f ) );
dictionary->add( dictionary, "maxZ", Dictionary_Entry_Value_FromDouble( 300.0f ) );
/* Build the context */
snacContext = Snac_Context_New( 0.0f, 10.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, dictionary );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( snacContext, 0 /* dummy */, &snacContext, True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( snacContext, 0 /* dummy */, False );
/* Work out the first element's tetrahedra values, and print them. */
printf( "Element: 0, Coords: (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g) (%g %g %g) (%g %g %g) (%g %g %g)\n",
Snac_Element_NodeCoord( snacContext, 0, 0 )[0],
Snac_Element_NodeCoord( snacContext, 0, 0 )[1],
Snac_Element_NodeCoord( snacContext, 0, 0 )[2],
Snac_Element_NodeCoord( snacContext, 0, 1 )[0],
Snac_Element_NodeCoord( snacContext, 0, 1 )[1],
Snac_Element_NodeCoord( snacContext, 0, 1 )[2],
Snac_Element_NodeCoord( snacContext, 0, 3 )[0],
Snac_Element_NodeCoord( snacContext, 0, 3 )[1],
Snac_Element_NodeCoord( snacContext, 0, 3 )[2],
Snac_Element_NodeCoord( snacContext, 0, 2 )[0],
Snac_Element_NodeCoord( snacContext, 0, 2 )[1],
Snac_Element_NodeCoord( snacContext, 0, 2 )[2],
Snac_Element_NodeCoord( snacContext, 0, 4 )[0],
Snac_Element_NodeCoord( snacContext, 0, 4 )[1],
Snac_Element_NodeCoord( snacContext, 0, 4 )[2],
Snac_Element_NodeCoord( snacContext, 0, 5 )[0],
Snac_Element_NodeCoord( snacContext, 0, 5 )[1],
Snac_Element_NodeCoord( snacContext, 0, 5 )[2],
Snac_Element_NodeCoord( snacContext, 0, 7 )[0],
Snac_Element_NodeCoord( snacContext, 0, 7 )[1],
Snac_Element_NodeCoord( snacContext, 0, 7 )[2],
Snac_Element_NodeCoord( snacContext, 0, 6 )[0],
Snac_Element_NodeCoord( snacContext, 0, 6 )[1],
Snac_Element_NodeCoord( snacContext, 0, 6 )[2] );
/* For each element, compare to the first element's */
for( elementIndex = 0; elementIndex < snacContext->mesh->elementLocalCount; elementIndex++ ) {
Bool error;
Snac_UpdateElementMomentum( (Context*)snacContext, elementIndex, &minLengthScale );
if( elementIndex == 0 ) {
for( tetraIndex = 0; tetraIndex < Tetrahedra_Count; tetraIndex++ ) {
Tetrahedra_Surface_Index faceIndex;
for( faceIndex = 0; faceIndex < Tetrahedra_Surface_Count; faceIndex++ ) {
printf( "Element: 0, Tetrahedra: %u, Face: %u, Normal: %g %g %g\n",
tetraIndex,
faceIndex,
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[0],
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[1],
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[2] );
}
}
}
else {
for( tetraIndex = 0, error = False; tetraIndex < Tetrahedra_Count; tetraIndex++ ) {
Tetrahedra_Surface_Index faceIndex;
for( faceIndex = 0; faceIndex < Tetrahedra_Surface_Count; faceIndex++ ) {
if( Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[0] !=
Snac_Element_At( snacContext, 0 )->tetra[tetraIndex].surface[faceIndex].normal[0] ||
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[1] !=
Snac_Element_At( snacContext, 0 )->tetra[tetraIndex].surface[faceIndex].normal[1] ||
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[2] !=
Snac_Element_At( snacContext, 0 )->tetra[tetraIndex].surface[faceIndex].normal[2] )
{
printf( "Element: %u, Tetrahedra: %u, Face %u, Area: %g %g %g\n",
elementIndex,
faceIndex,
tetraIndex,
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[0],
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[1],
Snac_Element_At( snacContext, elementIndex )->tetra[tetraIndex].surface[faceIndex].normal[2] );
error = True;
}
}
}
if( error ) {
printf( "Element: 0, Coords: (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g), (%g %g %g) (%g %g %g) (%g %g %g) (%g %g %g)\n",
Snac_Element_NodeCoord( snacContext, elementIndex, 0 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 0 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 0 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 1 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 1 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 1 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 2 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 2 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 2 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 3 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 3 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 3 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 4 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 4 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 4 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 5 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 5 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 5 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 6 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 6 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 6 )[2],
Snac_Element_NodeCoord( snacContext, elementIndex, 7 )[0],
Snac_Element_NodeCoord( snacContext, elementIndex, 7 )[1],
Snac_Element_NodeCoord( snacContext, elementIndex, 7 )[2] );
}
else {
printf( "Element %u: has same values as element 0.\n", elementIndex );
}
}
}
/* Stg_Class_Delete stuff */
Stg_Class_Delete( snacContext );
Stg_Class_Delete( dictionary );
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
