Stg_ComponentFactory* stgMainInitFromXML( char* xmlInputFilename, MPI_Comm communicator, void* _context ) {
Dictionary* dictionary = NULL;
Dictionary* sources = NULL;
Bool result;
XML_IO_Handler* ioHandler;
Stg_ComponentFactory* cf;
dictionary = Dictionary_New();
sources = Dictionary_New();
ioHandler = XML_IO_Handler_New();
result = IO_Handler_ReadAllFromFile( ioHandler, xmlInputFilename, dictionary, sources );
/* In case the user has put any journal configuration in the XML, read here. */
Journal_ReadFromDictionary( dictionary );
cf = stgMainConstruct( dictionary, sources, communicator, _context );
/* now dereference aliases */
DictionaryUtils_AliasDereferenceDictionary( dictionary );
/*
* We don't need the XML IO handler again (however don't delete the dictionary as it's
* 'owned' by the context from hereon.
*/
Stg_Class_Delete( ioHandler );
Stg_Class_Delete( sources );
return cf;
}
void DictionaryCheckSuite_TestCheckKeys( DictionaryCheckSuiteData* data ) {
Dictionary* dictionary = Dictionary_New();
Dictionary* dictionary2 = Dictionary_New();
const char* testFilename1 = "testDictionaryCheck-1.txt";
const char* testFilename2 = "testDictionaryCheck-2.txt";
char expectedFilename[PCU_PATH_MAX];
const char* errMessage = "Component dictionary must have unique names\n";
Stream_RedirectFile( Journal_Register( Error_Type, (Name)"DictionaryCheck" ), testFilename1 );
Stream_SetPrintingRank( Journal_Register( Error_Type, (Name)"DictionaryCheck" ), 0 );
Stream_ClearCustomFormatters( Journal_Register( Error_Type, (Name)"DictionaryCheck") );
/* Create a set of Dictionary entries */
/* For dictionary */
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"test_dict_string", Dictionary_Entry_Value_FromString( "hello" ) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"test_dict_double", Dictionary_Entry_Value_FromDouble( 45.567 ) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"test_dict_string", Dictionary_Entry_Value_FromString( "goodbye" ) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"test_dict_string", Dictionary_Entry_Value_FromString( "hello" ) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"test_dict_string2", Dictionary_Entry_Value_FromString( "hello" ) );
CheckDictionaryKeys( dictionary, errMessage );
if ( data->rank==0 ) {
pcu_filename_expected( testFilename1, expectedFilename );
pcu_check_fileEq( testFilename1, expectedFilename );
remove( testFilename1 );
}
/* For dictionary2 */
Dictionary_Add( dictionary2, (Dictionary_Entry_Key)"test_dict_string", Dictionary_Entry_Value_FromString( "hello" ) );
Dictionary_Add( dictionary2, (Dictionary_Entry_Key)"test_dict_double", Dictionary_Entry_Value_FromDouble( 45.567 ) );
Dictionary_Add( dictionary2, (Dictionary_Entry_Key)"test_dict_stuff", Dictionary_Entry_Value_FromString( "hello") );
/* Call DictionaryCheck function */
Stream_RedirectFile(Journal_Register( Error_Type, (Name)"DictionaryCheck" ), testFilename2 );
CheckDictionaryKeys(dictionary2, errMessage);
/* This file expected to be empty */
if ( data->rank==0 ) {
pcu_filename_expected( testFilename2, expectedFilename );
pcu_check_fileEq( testFilename2, expectedFilename );
remove( testFilename2 );
}
Stg_Class_Delete( dictionary );
Stg_Class_Delete( dictionary2 );
if ( data->rank==0 ) {
remove( testFilename1 );
remove( testFilename2 );
}
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
/* 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 );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) {
XML_IO_Handler* io_handler = XML_IO_Handler_New();
Dictionary* dictionary = Dictionary_New();
Dictionary_Index index;
Stream* stream = Journal_Register( InfoStream_Type, XML_IO_Handler_Type );
/* use the base class functions */
printf( "\ntest of raw data file:\n" );
IO_Handler_ReadAllFromFile( io_handler, "data/rawdata.xml", dictionary );
printf( "\ndictionary now contains:\n" );
printf( "Dictionary:\n" );
printf( "\tsize: %u\n", dictionary->size );
printf( "\tdelta: %u\n", dictionary->delta );
printf( "\tcount: %u\n", dictionary->count );
printf( "\tentryPtr[0-%u]: {\n", dictionary->count );
for( index = 0; index < dictionary->count; index++ ) {
printf( "\t\t" );
Dictionary_Entry_Print( dictionary->entryPtr[index], stream );
printf( "\n" );
}
printf( "\t}\n" );
/* Dictionary_Entry_Value_SetEncoding( Dictionary_Get( dictionary, "boundary_conditions2" ), RawASCII ); */
IO_Handler_WriteAllToFile( io_handler, "data/newrawdata.xml", dictionary );
Stg_Class_Delete( io_handler );
Stg_Class_Delete( dictionary );
}
BaseIO_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return EXIT_SUCCESS;
}
int main( int argc, char* argv[] ) {
Dictionary* dictionary=NULL;
Dictionary* sources;
XML_IO_Handler* ioHandler;
Stream* msgs;
char* outputFilename = DEFAULT_OUTPUT_FILE;
int ii;
MPI_Init( &argc, &argv );
if( !StGermainBase_Init( &argc, &argv ) ) {
fprintf( stderr, "Error initialising StGermain, exiting.\n" );
exit( EXIT_FAILURE );
}
msgs = Journal_Register( Info_Type, "Messages" );
for( ii = 0; ii < argc; ++ii ) {
if( strstr( argv[ii], OUTPUT_FILE_FLAG ) == argv[ii] ) {
outputFilename = argv[ii] + strlen( OUTPUT_FILE_FLAG );
if( strlen( outputFilename ) < 1 ) {
Journal_Printf( msgs, "Invalid outputfile name: %s\n", outputFilename );
Journal_Printf( msgs, "Exiting...\n" );
StGermainBase_Finalise();
return 1;
}
argv[ii] = " "; /* remove it from the arg list */
}
}
dictionary = Dictionary_New();
sources = Dictionary_New();
/* Read input */
ioHandler = XML_IO_Handler_New();
IO_Handler_ReadAllFromCommandLine( ioHandler, argc, argv, dictionary, sources );
IO_Handler_WriteAllToFile( ioHandler, outputFilename, dictionary, sources );
Stg_Class_Delete( dictionary );
Stg_Class_Delete( sources );
Stg_Class_Delete( ioHandler );
StGermainBase_Finalise();
MPI_Finalize();
return 0; /* success */
}
int main( int argc, char* argv[] ) {
Dictionary* dictionary;
Stream* stream;
MPI_Init( &argc, &argv );
BaseFoundation_Init( &argc, &argv );
BaseIO_Init( &argc, &argv );
stream = Journal_Register (Info_Type, "myStream");
Stream_RedirectFile( stream, "dictionaryOutput.dat" );
dictionary = Dictionary_New();
Dictionary_ReadAllParamFromCommandLine( dictionary, argc, argv );
Print( dictionary, stream );
Stg_Class_Delete( dictionary );
BaseIO_Finalise();
BaseFoundation_Finalise();
MPI_Finalize();
return EXIT_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 */
}
void WallVCSuite_TestWallVC( WallVCSuiteData* data ) {
unsigned nDomains;
unsigned nDims = 3;
unsigned meshSize[3] = {3, 3, 3};
int procToWatch;
double minCrds[3] = {0.0, 0.0, 0.0};
double maxCrds[3] = {1.0, 1.0, 1.0};
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"};
char input_file[PCU_PATH_MAX];
char expected_file[PCU_PATH_MAX];
Mesh* mesh;
Variable_Register* variable_Register;
ConditionFunction* quadCF;
ConditionFunction* expCF;
ConditionFunction_Register* conFunc_Register;
ExtensionManager_Register* extensionMgr_Register;
Dictionary* dictionary;
Dictionary* sources;
Stream* stream;
XML_IO_Handler* io_handler;
Variable* var[7];
double* array[7];
VariableCondition* vc;
Index i;
procToWatch = data->nProcs >=2 ? 1 : 0;
io_handler = XML_IO_Handler_New();
stream = Journal_Register( Info_Type, (Name)"WallVCStream" );
Stream_RedirectFile( stream, "testWallVC.dat" );
dictionary = Dictionary_New();
sources = Dictionary_New();
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString("./output") );
/* Input file */
pcu_filename_input( "wallVC.xml", input_file );
IO_Handler_ReadAllFromFile( io_handler, input_file, dictionary, sources );
fflush( stdout );
extensionMgr_Register = ExtensionManager_Register_New();
/* Create a mesh. */
mesh = (Mesh*) WallVCSuite_buildMesh( nDims, meshSize, minCrds, maxCrds, extensionMgr_Register );
nDomains = Mesh_GetDomainSize( mesh, MT_VERTEX );
/* Create CF stuff */
quadCF = ConditionFunction_New( WallVCSuite_quadratic, (Name)"quadratic", NULL );
expCF = ConditionFunction_New( WallVCSuite_exponential, (Name)"exponential", NULL);
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, nDomains, "array[i]" );
var[i] = Variable_NewScalar( varName[i], NULL, Variable_DataType_Double, (Index*)&nDomains, NULL, (void**)&array[i], 0 );
Variable_Register_Add(variable_Register, var[i]);
}
array[6] = Memory_Alloc_Array( double, nDomains * 5, "array[6]" );
var[6] = Variable_NewVector( varName[6], NULL, Variable_DataType_Double, 5, &nDomains, NULL, (void**)&array[6], 0 );
Variable_Register_Add(variable_Register, var[6]);
Variable_Register_BuildAll(variable_Register);
for (i = 0; i < 6; i++) {
Index j, k;
vc = (VariableCondition*) WallVC_New( vcKeyName[i], NULL, vcKey[i], variable_Register, conFunc_Register, dictionary, mesh );
Stg_Component_Build( vc, 0, False );
for (j = 0; j < 6; j++)
memset(array[j], 0, sizeof(double)* nDomains );
memset(array[6], 0, sizeof(double)* nDomains * 5);
VariableCondition_Apply(vc, NULL);
if (data->rank == procToWatch) {
Journal_Printf( stream,"Testing for %s\n", vcKey[i]);
for (j = 0; j < 6; j++) {
Journal_Printf( stream,"\nvar[%u]: %.2lf", j, array[j][0]);
for (k = 1; k < nDomains; k++)
Journal_Printf( stream,", %.2lf", array[j][k]);
}
Journal_Printf( stream,"\nvar[6]: %.2lf", array[6][0]);
for (j = 1; j < nDomains*5; j++)
Journal_Printf( stream,", %.2lf", array[6][j]);
Journal_Printf( stream,"\n\n");
for (j = 0; j < 7; j++) {
for (k = 0; k < nDomains; k++)
Journal_Printf( stream,"%s ", VariableCondition_IsCondition(vc, k, j) ? "True " : "False");
Journal_Printf( stream,"\n");
} Journal_Printf( stream,"\n");
for (j = 0; j < 7; j++) {
for (k = 0; k < nDomains; k++) {
VariableCondition_ValueIndex valIndex;
valIndex = VariableCondition_GetValueIndex(vc, k, j);
if (valIndex != (unsigned)-1)
Journal_Printf( stream,"%03u ", valIndex);
else
Journal_Printf( stream,"XXX ");
} Journal_Printf( stream,"\n");
} Journal_Printf( stream,"\n");
}
Stg_Class_Delete(vc);
}
if (data->rank == procToWatch) {
pcu_filename_expected( "testWallVC.expected", expected_file );
pcu_check_fileEq( "testWallVC.dat", expected_file );
remove( "testWallVC.dat" );
}
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(extensionMgr_Register);
Stg_Class_Delete(io_handler);
Stg_Class_Delete(conFunc_Register);
Stg_Class_Delete(quadCF);
Stg_Class_Delete(expCF);
Stg_Class_Delete(dictionary);
Stg_Class_Delete(sources);
FreeObject( mesh );
}
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 */
}
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 */
}
/* TODO: Need to find a way to add different communicators for different contexts. */
Stg_ComponentFactory* stgMainConstruct( Dictionary* dictionary, Dictionary* sources, MPI_Comm communicator, void* _context ) {
Stg_ComponentFactory* cf;
Dictionary* componentDict;
Stg_Component* component;
AbstractContext* context=NULL;
unsigned component_I;
char* timeStamp;
time_t currTime;
struct tm* timeInfo;
int adjustedYear;
int adjustedMonth;
unsigned rank;
MPI_Comm_rank( communicator, &rank );
currTime = time( NULL );
timeInfo = localtime( &currTime );
/* See man localtime() for why to adjust these. */
adjustedYear = 1900 + timeInfo->tm_year;
adjustedMonth = 1 + timeInfo->tm_mon;
Stg_asprintf( &timeStamp, "%.4d.%.2d.%.2d-%.2d.%.2d.%.2d",
adjustedYear, adjustedMonth, timeInfo->tm_mday,
timeInfo->tm_hour, timeInfo->tm_min, timeInfo->tm_sec );
if( ( componentDict = Dictionary_Entry_Value_AsDictionary(
Dictionary_Get( dictionary, (Dictionary_Entry_Key)"components" ) ) ) == NULL )
componentDict = Dictionary_New();
CheckDictionaryKeys( componentDict, "Component dictionary must have unique names\n" );
/* lets go right ahead and delete the component register. */
/* this is mainly required for the pcu tests which pass through here a number of times
without calling StGermain_Finalise */
LiveComponentRegister_Delete();
cf = Stg_ComponentFactory_New( dictionary, componentDict );
if( _context ) {
context = (AbstractContext*)_context;
context->CF = cf;
context->dictionary = dictionary;
context->communicator = communicator;
context->timeStamp = timeStamp;
LiveComponentRegister_Add( cf->LCRegister, (Stg_Component*)context );
}
/* Instantion phase. */
Stg_ComponentFactory_CreateComponents( cf );
/*
* Assign the dictionary, componentFactory & the communicator for the contexts.
* TODO: if different contexts require different communicators,
* then StG. components will be required for these, and they should be passed in from the XML
* Also, this is a little hacky, as nothing is known about the other
* layers of StG or their associated contexts here.
*/
for( component_I = 0; component_I < LiveComponentRegister_GetCount( cf->LCRegister ); component_I++ ) {
component = LiveComponentRegister_At( cf->LCRegister, component_I );
if( Stg_CompareType( component, AbstractContext ) ) {
Journal_Firewall(
dictionary->count,
Journal_Register( Error_Type, "Error Stream" ),
"Error in %s: The dictionary is empty, "
"meaning no input parameters have been feed into your program. "
"Perhaps you've forgot to pass any input files ( or command-line arguments ) in.\n",
__func__ );
context = (AbstractContext*)component;
context->dictionary = dictionary;
context->CF = cf;
context->timeStamp = timeStamp;
//context->communicator = communicator;
}
}
/* generate the Flattened xml file last once Scaling has occured */
if( rank==0 ) stgGenerateFlattenedXML( dictionary, sources, timeStamp );
/* Construction phase. */
Stg_ComponentFactory_ConstructComponents( cf, NULL );
return cf;
}
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;
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[] ) {
int rank;
int procCount;
int procToWatch;
Stream* stream;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &procCount );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
BaseFoundation_Init( &argc, &argv );
RegressionTest_Init( "Base/Automation/Stg_Component" );
BaseIO_Init( &argc, &argv );
BaseContainer_Init( &argc, &argv );
BaseAutomation_Init( &argc, &argv );
stream = Journal_Register( Info_Type, __FILE__ );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) {
Stg_ComponentMeta* metaTest;
XML_IO_Handler* io;
Dictionary* allDict;
Dictionary* compDict;
CompositeVC* vc;
Journal_Printf( stream, "%s\n", Stg_Component_GetMetadata() );
metaTest = Stg_Component_CreateMeta( "blah", Variable_Type );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
allDict = Dictionary_New();
io = XML_IO_Handler_New();
IO_Handler_ReadAllFromFile( io, "data/metatest.xml", allDict );
compDict = Dictionary_GetDictionary( allDict, "components" );
vc = CompositeVC_DefaultNew( "vc" );
metaTest = Stg_Component_Validate( vc, CompositeVC_Type, compDict );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
Stg_Class_Delete( io );
Stg_Class_Delete( compDict );
}
BaseAutomation_Finalise();
BaseContainer_Finalise();
BaseIO_Finalise();
RegressionTest_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
/* 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 );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch )
{
Stream* infoTest1;
Stream* infoTest2;
Stream* debugTest1;
Stream* debugTest2;
Stream* dumpTest1;
Stream* dumpTest2;
Stream* newTest1;
Stream* newTest2;
Stream* fileTest1;
Stream* fileTest2;
Stream* propTest1;
Stream* propTest2;
Dictionary* dictionary = Dictionary_New();
XML_IO_Handler* io_handler = XML_IO_Handler_New();
infoTest1 = Journal_Register( Info_Type, "test1" );
infoTest2 = Journal_Register( Info_Type, "test2" );
debugTest1 = Journal_Register( Debug_Type, "test1" );
debugTest2 = Journal_Register( Debug_Type, "test2" );
dumpTest1 = Journal_Register( Dump_Type, "test1" );
dumpTest2 = Journal_Register( Dump_Type, "test2" );
IO_Handler_ReadAllFromFile( io_handler, "data/journal.xml", dictionary );
Journal_ReadFromDictionary( dictionary );
newTest1 = Journal_Register( Info_Type, "test1.new1" );
newTest2 = Journal_Register( Info_Type, "test1.new2" );
Journal_Printf( infoTest1, "infoTest1\n" );
Journal_Printf( infoTest2, "infoTest2\n" );
Journal_Printf( debugTest1, "debugTest1\n" );
Journal_Printf( debugTest2, "debugTest2\n" );
Journal_Printf( dumpTest1, "dumpTest1\n" );
Journal_Printf( dumpTest2, "dumpTest2\n" );
Journal_PrintfL( newTest1, 3, "newTest1\n" );
Journal_PrintfL( newTest1, 4, "newTest1\n" );
Journal_Printf( newTest2, "newTest2\n" );
fileTest1 = Journal_Register( "newtype", "hello" );
fileTest2 = Journal_Register( "newtype", "other" );
Journal_Printf( fileTest1, "yay!" );
Journal_Printf( fileTest2, "double yay!" );
propTest1 = Journal_Register( Info_Type, "propertiestest1" );
propTest2 = Journal_Register( Info_Type, "propertiestest2" );
Print( propTest1, infoTest1 );
Print( propTest2, infoTest1 );
Stg_Class_Delete( io_handler );
Stg_Class_Delete( dictionary );
}
BaseIO_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return EXIT_SUCCESS;
}
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 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 */
}
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 */
}
void TimeIntegrationSuite_TestDriver( TimeIntegrationSuiteData* data, char *_name, char *_DerivName0, char *_DerivName1, int _order ) {
Stg_ComponentFactory* cf;
Stream* stream;
Dictionary* dictionary;
TimeIntegrator* timeIntegrator;
TimeIntegrand* timeIntegrand;
TimeIntegrand* timeIntegrandList[2];
DomainContext* context;
Variable* variable;
Variable* variableList[2];
double* array;
double* array2;
Index size0 = 11;
Index size1 = 7;
Index array_I;
Index timestep = 0;
Index maxTimesteps = 10;
Bool simultaneous;
unsigned order;
double error = 0.0;
Name derivName;
double tolerance = 0.001;
Index integrand_I;
Index integrandCount = 2;
char expected_file[PCU_PATH_MAX];
dictionary = Dictionary_New();
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString("./output") );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"DerivName0", Dictionary_Entry_Value_FromString(_DerivName0) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"DerivName1", Dictionary_Entry_Value_FromString(_DerivName1) );
context = DomainContext_New( "context", 0, 0, MPI_COMM_WORLD, NULL );
cf = stgMainConstruct( dictionary, NULL, data->comm, context );
stgMainBuildAndInitialise( cf );
ContextEP_Append( context, AbstractContext_EP_Dt, TimeIntegrationSuite_GetDt );
/* Create Stuff */
order = _order;
simultaneous = False;
variableList[0] = Variable_NewVector( "testVariable", (AbstractContext*)context, Variable_DataType_Double, 2, &size0, NULL, (void**)&array, NULL );
variableList[1] = Variable_NewVector( "testVariable2", (AbstractContext*)context, Variable_DataType_Double, 2, &size1, NULL, (void**)&array2, NULL );
timeIntegrator = TimeIntegrator_New( "testTimeIntegrator", order, simultaneous, NULL, NULL );
timeIntegrator->context = context;
timeIntegrandList[0] = TimeIntegrand_New( "testTimeIntegrand0", context, timeIntegrator, variableList[0], 0, NULL, True );
timeIntegrandList[1] = TimeIntegrand_New( "testTimeIntegrand1", context, timeIntegrator, variableList[1], 0, NULL, True );
Journal_Enable_AllTypedStream( True );
stream = Journal_Register( Info_Type, (Name)"EulerStream" );
Stream_RedirectFile( stream, _name );
Stream_Enable( timeIntegrator->info, False );
derivName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"DerivName0" );
timeIntegrandList[0]->_calculateTimeDeriv = TimeIntegrationSuite_GetFunctionPtr( derivName );
Journal_Printf( stream, "DerivName0 - %s\n", derivName );
derivName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"DerivName1" );
timeIntegrandList[1]->_calculateTimeDeriv = TimeIntegrationSuite_GetFunctionPtr( derivName );
Journal_Printf( stream, "DerivName1 - %s\n", derivName );
/* Print Stuff to file */
Journal_PrintValue( stream, order );
Journal_PrintBool( stream, simultaneous );
/* Add stuff to EPs */
TimeIntegrator_AppendSetupEP( timeIntegrator, "start1", TimeIntegrationSuite_TestContextType, CURR_MODULE_NAME, context );
TimeIntegrator_AppendFinishEP( timeIntegrator, "finish1", TimeIntegrationSuite_TestVariableType, CURR_MODULE_NAME, variableList[0] );
TimeIntegrator_PrependSetupEP( timeIntegrator, "start0", TimeIntegrationSuite_TestVariableType, CURR_MODULE_NAME, variableList[0] );
TimeIntegrator_PrependFinishEP( timeIntegrator, "finish0", TimeIntegrationSuite_TestContextType, CURR_MODULE_NAME, context );
/* Build */
Stg_Component_Build( variableList[0], context, False );
Stg_Component_Build( variableList[1], context, False );
Stg_Component_Build( timeIntegrator, context, False );
Stg_Component_Build( timeIntegrandList[0], context, False );
Stg_Component_Build( timeIntegrandList[1], context, False );
array = Memory_Alloc_Array( double, 2 * size0, "name" );
array2 = Memory_Alloc_Array( double, 2 * size1, "name" );
/* Initialise */
memset( array, 0, sizeof(double) * 2 * size0 );
memset( array2, 0, sizeof(double) * 2 * size1 );
Stg_Component_Initialise( timeIntegrator, context, False );
Stg_Component_Initialise( variableList[0], context, False );
Stg_Component_Initialise( variableList[1], context, False );
Stg_Component_Initialise( timeIntegrandList[0], context, False );
Stg_Component_Initialise( timeIntegrandList[1], context, False );
for ( timestep = 0.0 ; timestep < maxTimesteps ; timestep ++ ) {
Journal_Printf( stream, "Step %u - Time = %.3g\n", timestep, context->currentTime );
Stg_Component_Execute( timeIntegrator, context, True );
context->currentTime += AbstractContext_Dt( context );
for ( integrand_I = 0 ; integrand_I < integrandCount ; integrand_I++ ) {
timeIntegrand = timeIntegrandList[ integrand_I ];
variable = variableList[ integrand_I ];
for ( array_I = 0 ; array_I < variable->arraySize ; array_I++ ) {
if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - 2.0 * array_I * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + array_I * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.5 * array_I * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 3 * array_I * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - array_I * context->currentTime * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + 0.5 * array_I * context->currentTime * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.25 * array_I * context->currentTime * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 1.5 * array_I * context->currentTime * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - 2.0 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0)/3.0));
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0 )/3.0));
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.5 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0)/3.0));
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 3.0 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0 )/3.0));
}
else
Journal_Firewall( 0 , Journal_Register( Error_Type, (Name)CURR_MODULE_NAME ), "Don't understand _calculateTimeDeriv = %p\n", timeIntegrand->_calculateTimeDeriv );
}
}
}
pcu_check_lt( error, tolerance );
if ( error < tolerance )
Journal_Printf( stream, "Passed\n" );
else
Journal_Printf( stream, "Failed - Error = %lf\n", error );
Journal_Enable_AllTypedStream( False );
if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationEulerOutput.expected", expected_file );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationRK2Output.expected", expected_file );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationRK4Output.expected", expected_file );
}
pcu_check_fileEq( _name, expected_file );
/* Destroy stuff */
Stream_CloseAndFreeFile( stream );
Memory_Free( array );
Memory_Free( array2 );
Stg_Class_Delete( variable );
_Stg_Component_Delete( timeIntegrator );
_Stg_Component_Delete( timeIntegrandList[0] );
_Stg_Component_Delete( timeIntegrandList[1] );
remove( _name );
}
int main( int argc, char* argv[] ) {
Stream* stream = NULL;
Dictionary* dictionary;
Dictionary_Entry_Value* tmpVal0;
Dictionary_Entry_Value* tmpVal1;
MPI_Init( &argc, &argv );
BaseFoundation_Init( &argc, &argv );
BaseIO_Init( &argc, &argv );
stream = Journal_Register (Info_Type, "myStream");
dictionary = Dictionary_New();
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "name", Dictionary_Entry_Value_FromString( "bill" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 1.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "bottom" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "top" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_Add( dictionary, "one", tmpVal0 );
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "new_name", Dictionary_Entry_Value_FromString( "frank" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 2.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "left" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "right" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_AddMerge( dictionary, "one", tmpVal0, Dictionary_MergeType_Append );
Print( dictionary, stream );
Stg_Class_Delete( dictionary );
dictionary = Dictionary_New();
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "name", Dictionary_Entry_Value_FromString( "bill" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 1.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "bottom" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "top" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_Add( dictionary, "one", tmpVal0 );
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "new_name", Dictionary_Entry_Value_FromString( "frank" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 2.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "left" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "right" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_AddMerge( dictionary, "one", tmpVal0, Dictionary_MergeType_Merge );
Print( dictionary, stream );
Stg_Class_Delete( dictionary );
dictionary = Dictionary_New();
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "name", Dictionary_Entry_Value_FromString( "bill" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 1.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "bottom" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "top" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_Add( dictionary, "one", tmpVal0 );
tmpVal0 = Dictionary_Entry_Value_NewStruct();
tmpVal1 = Dictionary_Entry_Value_NewStruct();
Dictionary_Entry_Value_AddMember( tmpVal1, "new_name", Dictionary_Entry_Value_FromString( "frank" ) );
Dictionary_Entry_Value_AddMember( tmpVal1, "value", Dictionary_Entry_Value_FromDouble( 2.0f ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "inside", tmpVal1 );
tmpVal1 = Dictionary_Entry_Value_NewList();
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "left" ) );
Dictionary_Entry_Value_AddElement( tmpVal1, Dictionary_Entry_Value_FromString( "right" ) );
Dictionary_Entry_Value_AddMember( tmpVal0, "list_one", tmpVal1 );
Dictionary_AddMerge( dictionary, "one", tmpVal0, Dictionary_MergeType_Replace );
Print( dictionary, stream );
Stg_Class_Delete( dictionary );
BaseIO_Finalise();
BaseFoundation_Finalise();
MPI_Finalize();
return EXIT_SUCCESS;
}
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;
}
void DictionarySuite_Setup( DictionarySuiteData* data ) {
data->dict = Dictionary_New();
data->testDD = Memory_Alloc_Unnamed( DictionarySuite_TestDictData );
DictionarySuite_SetupTestDictData( data->testDD );
}
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 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 */
}
PyObject* Dictionary_Python_New( PyObject* self, PyObject* args ) {
return PyCObject_FromVoidPtr( Dictionary_New(), 0 );
}
static void Dictionary_Entry_Value_SetValueNewStruct( Dictionary_Entry_Value* self ) {
Dictionary_Entry_Value_SetValueStruct( self, Dictionary_New() );
}
/* 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 */
}
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;
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( InfoStream_Type, "myStream" );
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();
/* 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_ReplaceAll( abstractContext, AbstractContext_EP_Build, MyBuild );
ContextEP_ReplaceAll( abstractContext, AbstractContext_EP_Initialise, MyInitialConditions );
ContextEP_ReplaceAll( abstractContext, AbstractContext_EP_Solve, MySolve );
ContextEP_ReplaceAll( abstractContext, AbstractContext_EP_Dt, MyDt );
if( rank == procToWatch ) {
Journal_Printf(
(void*)stream,
"abstractContext->entryPointList->_size: %lu\n",
abstractContext->entryPoint_Register->_size );
Journal_Printf(
(void*)stream,
"abstractContext->entryPointList->count: %u\n",
abstractContext->entryPoint_Register->count );
}
ContextEP_Append( abstractContext, AbstractContext_EP_Solve, MySolve2 );
ContextEP_ReplaceAll( abstractContext, AbstractContext_EP_Initialise, MyInitialConditions2 );
if( rank == procToWatch ) {
stream = Journal_Register( InfoStream_Type, AbstractContext_Type );
AbstractContext_PrintConcise( abstractContext, stream );
Journal_Printf(
(void*)stream,
"abstractContext->entryPointList->_size: %lu\n",
abstractContext->entryPoint_Register->_size );
Journal_Printf(
(void*)stream,
"abstractContext->entryPointList->count: %u\n",
abstractContext->entryPoint_Register->count );
}
/* Run the context */
if( rank == procToWatch ) {
Stg_Component_Build( abstractContext, 0 /* dummy */, False );
Stg_Component_Initialise( abstractContext, 0 /* dummy */, False );
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 */
}
