void DictionarySuite_PopulateDictWithTestValues( Dictionary* dict, DictionarySuite_TestDictData* testDD ) {
Index ii;
for ( ii=0; ii< testDD->testEntriesCount; ii++ ) {
Dictionary_Add( dict, testDD->testKeys[ii],\
Dictionary_Entry_Value_Copy( testDD->testValues[ii], True ) );
}
}
void stgImportToolbox( Dictionary* dictionary, char* toolboxName ) {
Dictionary_Entry_Value* dev = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"import" );
if( !dev ) {
dev = Dictionary_Entry_Value_NewList();
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"import", dev );
}
Dictionary_Entry_Value_AddElement( dev, Dictionary_Entry_Value_FromString( toolboxName ) );
}
Bool Geothermal_Init( int* argc, char** argv[] ) {
/*
* This init function tells StGermain of all the component types, etc this module contributes.
* Because it can be linked at compile time or linked in by a toolbox at runtime, we need to make
* sure it isn't run twice (compiled in and loaded through a toolbox.
*/
if( !ToolboxesManager_IsInitialised( stgToolboxesManager, "Geothermal" ) ) {
int tmp;
char* directory;
Geothermal_Base_Init(argc, argv);
/* DO NOT CHANGE OR REMOVE */
Journal_Printf( Journal_Register( DebugStream_Type, (Name)"Context" ), "In: %s\n", __func__ );
tmp = Stream_GetPrintingRank( Journal_Register( InfoStream_Type, (Name)"Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, (Name)"Context" ), 0 );
/* DO NOT CHANGE OR REMOVE */
Journal_Printf(
Journal_Register( InfoStream_Type, (Name)"Context" ),
"Geothermal (Bleeding Edge Geodynamics framework) Revision %s. Copyright (C) 2005 Monash University.\n",
VERSION );
/* Add repo indentity info in the repo dictionary. */
Dictionary_Add( versionDict, "Geothermal", Dictionary_Entry_Value_FromString( VERSION ) );
Dictionary_Add( branchDict, "Geothermal", Dictionary_Entry_Value_FromString( BRANCH ) );
Dictionary_Add( pathDict, "Geothermal", Dictionary_Entry_Value_FromString( PATH ) );
Stream_Flush( Journal_Register( InfoStream_Type, (Name)"Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, (Name)"Context" ), tmp );
/* Add the Geothermal path to the global xml path dictionary */
directory = Memory_Alloc_Array( char, 200, "xmlDirectory" ) ;
sprintf(directory, "%s%s", LIB_DIR, "/StGermain" );
XML_IO_Handler_AddDirectory( "Geothermal", directory );
Memory_Free(directory);
/* Add the plugin path to the global plugin list */
ModulesManager_AddDirectory( "Geothermal", LIB_DIR );
return True;
}
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 );
}
}
void DictionarySuite_TestMerge( DictionarySuiteData* data ) {
Dictionary_Entry_Value* testStruct2=NULL;
Dictionary_Entry_Value* testGeomStruct2=NULL;
Dictionary_Entry_Value* mergedStruct=NULL;
Dictionary_Entry_Value* expectedMergedStruct=NULL;
testStruct2 = Dictionary_Entry_Value_NewStruct( );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"height", Dictionary_Entry_Value_FromDouble( data->testDD->testStruct->height ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"anisotropic", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"new_person", Dictionary_Entry_Value_FromString( "Luke" ) );
testGeomStruct2 = Dictionary_Entry_Value_NewStruct( );
Dictionary_Entry_Value_AddMember( testStruct2, (Dictionary_Entry_Key)"geom", testGeomStruct2 );
Dictionary_Entry_Value_AddMember( testGeomStruct2, (Dictionary_Entry_Key)"startx", Dictionary_Entry_Value_FromUnsignedInt( data->testDD->testStruct->geom.startx ) );
Dictionary_Entry_Value_AddMember( testGeomStruct2, (Dictionary_Entry_Key)"startz", Dictionary_Entry_Value_FromUnsignedInt( 222 ) );
/* Testing Merge_Append */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
/* Do a copy of the DEV during merge, since we don't want it being deleted */
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Append );
/* OK: since this was an append, we expect _two_ entries called "test_struct",
* one preceding the other, one with the orig data, one with new data */
pcu_check_true( (data->testDD->testEntriesCount+1) == data->dict->count );
pcu_check_true( Dictionary_Entry_Value_Compare( data->testDD->testValues[8], Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" ) ) );
pcu_check_true( Dictionary_Entry_Value_Compare( testStruct2, data->dict->entryPtr[9]->value ) );
Dictionary_Empty( data->dict );
/* Testing Merge_Merge */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
/* The nicest way for this test I think is to manually build a merged struct
* to compare against */
expectedMergedStruct = Dictionary_Entry_Value_Copy( data->testDD->testValues[8], True );
Dictionary_Set( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"anisotropic", Dictionary_Entry_Value_FromBool( False ) );
Dictionary_Add( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"new_person", Dictionary_Entry_Value_FromString( "Luke" ) );
Dictionary_Set( (Dictionary_Get( expectedMergedStruct->as.typeStruct, (Dictionary_Entry_Key)"geom" ) )->as.typeStruct, "startz", Dictionary_Entry_Value_FromUnsignedInt( 222 ) );
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Merge );
/* This time, the new struct should be merged into the existing one */
pcu_check_true( data->testDD->testEntriesCount == data->dict->count );
mergedStruct = Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" );
pcu_check_true( Dictionary_Entry_Value_Compare( mergedStruct, expectedMergedStruct ) );
Dictionary_Empty( data->dict );
Dictionary_Entry_Value_Delete( expectedMergedStruct );
/* Testing Merge_Replace */
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
Dictionary_AddMerge( data->dict, "test_struct", Dictionary_Entry_Value_Copy( testStruct2, True ), Dictionary_MergeType_Replace );
pcu_check_true( data->testDD->testEntriesCount == data->dict->count );
pcu_check_true( Dictionary_Entry_Value_Compare( testStruct2, Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" ) ) );
Dictionary_Empty( data->dict );
Dictionary_Entry_Value_Delete( testStruct2 );
}
PyObject* Dictionary_Python_AddString( PyObject* self, PyObject* args ) {
PyObject* pyDictionary;
Dictionary* dictionary;
char* name;
char* value;
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "Oss:", &pyDictionary, &name, &value ) ) {
return NULL;
}
dictionary = (Dictionary*)( PyCObject_AsVoidPtr( pyDictionary ) );
/* Run function */
Dictionary_Add( dictionary, name, Dictionary_Entry_Value_FromString( value ) );
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
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
BMI_Initialize (const char *config_file, BMI_Model ** handle)
{
BMI_Model *self;
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
char* filename;
if (!handle)
return BMI_FAILURE;
self = malloc( sizeof(BMI_Model) );
/* Initialise MPI, get world info */
MPI_Init( NULL, NULL ); /* MPI_Init( &argc, &argv ); */
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
/* Hardwire the process to watch to 0.
Note that it doesn't have to be 0 when multiple processrs are used. */
procToWatch = 0;
#if 0
if( argc >= 3 ) {
procToWatch = atoi( argv[2] );
}
else {
procToWatch = 0;
}
#endif
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
/* if (!Snac_Init( &argc, &argv )) { */
if (!Snac_Init( NULL, NULL )) {
fprintf(stderr, "Error initialising StGermain, exiting.\n" );
exit(EXIT_FAILURE);
}
/* Snac's init message */
{
int tmp = Stream_GetPrintingRank( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), 0 );
Journal_Printf( /* DO NOT CHANGE OR REMOVE */
Journal_Register( InfoStream_Type, "Context" ),
"Snac. Copyright (C) 2003-2005 Caltech, VPAC & University of Texas.\n" );
Stream_Flush( Journal_Register( InfoStream_Type, "Context" ) );
Stream_SetPrintingRank( Journal_Register( InfoStream_Type, "Context" ), tmp );
}
/* Ensures copyright info always come first in output */
MPI_Barrier( CommWorld );
/* Create the dictionary, and some fixed values */
/* Hardwirred to the one-processor scenario for now. */
self->dictionary = Dictionary_New();
Dictionary_Add( self->dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( 0 ) );
Dictionary_Add( self->dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
/* Read input */
self->ioHandler = XML_IO_Handler_New();
filename = strdup( config_file );
if ( False == IO_Handler_ReadAllFromFile( self->ioHandler, filename, self->dictionary ) )
{
fprintf( stderr, "Error: Snac couldn't find specified input file %s. Exiting.\n", filename );
exit( EXIT_FAILURE );
}
Journal_ReadFromDictionary( self->dictionary );
free( filename );
/* This is the handle to the SNAC's model data. */
self->snacContext = Snac_Context_New( 0.0f, 0.0f, sizeof(Snac_Node), sizeof(Snac_Element), CommWorld, self->dictionary );
if( rank == procToWatch ) Dictionary_PrintConcise( self->dictionary, self->snacContext->verbose );
/* Construction phase -----------------------------------------------------------------------------------------------*/
Stg_Component_Construct( self->snacContext, 0 /* dummy */, &(self->snacContext), True );
/* Building phase ---------------------------------------------------------------------------------------------------*/
Stg_Component_Build( self->snacContext, 0 /* dummy */, False );
/* Initialisaton phase ----------------------------------------------------------------------------------------------*/
Stg_Component_Initialise( self->snacContext, 0 /* dummy */, False );
if( rank == procToWatch ) Context_PrintConcise( self->snacContext, self->snacContext->verbose );
/* pass the pointer to Snac_Context to handle */
*handle = self;
return BMI_SUCCESS;
}
int main(int argc, char **argv)
{
MPI_Comm CommWorld;
XML_IO_Handler *io_handler = XML_IO_Handler_New();
int rank, procCount, procToWatch;
Dictionary *dictionary;
EmbeddedSurface *surface;
MeshTopology *rmt, *imt;
MeshGeometry *rmg, *img;
MeshDecomp *rmd, *imd;
MeshLayout *rml, *isl;
ExtensionManager_Register *extensionMgr_Register;
Mesh *mesh;
Element_GlobalIndex intersectCnt, *intersect;
Index i;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &procCount );
MPI_Comm_rank( CommWorld, &rank );
Base_Init( &argc, &argv );
DiscretisationGeometry_Init( &argc, &argv );
DiscretisationShape_Init( &argc, &argv );
DiscretisationMesh_Init( &argc, &argv );
DiscretisationUtils_Init( &argc, &argv );
MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */
if( argc >= 2 )
procToWatch = atoi( argv[1] );
else
procToWatch = 0;
if( rank == procToWatch ) printf( "Watching rank: %i\n", rank );
dictionary = Dictionary_New();
Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 2 ) );
Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 2 ) );
Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) );
Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 0 ) );
IO_Handler_ReadAllFromFile(io_handler, "data/surface.xml", dictionary);
rmt = (MeshTopology *)HexaMeshTopology_New(dictionary);
rmg = (MeshGeometry *)HexaMeshGeometry_New(dictionary);
rmd = (MeshDecomp *)HexaMeshDecomp_New(dictionary, MPI_COMM_WORLD, (HexaMeshTopology *)rmt);
rml = MeshLayout_New(dictionary, rmt, rmg, rmd);
imt = (MeshTopology *)TriSurfTopology_New(dictionary, "imElements");
img = (MeshGeometry *)TriSurfGeometry_New(dictionary, "imNodes");
imd = (MeshDecomp *)IrregularMeshDecomp_New1(dictionary, MPI_COMM_WORLD, imt, img, rml);
isl = MeshLayout_New(dictionary, imt, img, imd);
extensionMgr_Register = ExtensionManager_Register_New( );
mesh = Mesh_New( isl, sizeof(Node), sizeof(Element), extensionMgr_Register, dictionary );
Mesh_Build( mesh );
Mesh_Initialise(mesh);
surface = EmbeddedSurface_New(mesh);
if (procToWatch == rank)
{
intersect = Memory_Alloc_Array( Element_GlobalIndex, isl->decomp->elementGlobalCount(isl->decomp), "intersect" );
intersectCnt = EmbeddedSurface_BuildIntersection(surface, intersect);
printf("Intersects: %u\n", intersectCnt);
for (i = 0; i < intersectCnt; i++)
printf("\tinstersect[%u]: %u\n", i, intersect[i]);
printf("\n");
if (intersect) Memory_Free(intersect);
for (i = 0; i < isl->decomp->nodeGlobalCount(isl->decomp); i++)
{
Coord point;
point[0] = ((TriSurfGeometry *)img)->node[i][0] + 1.0;
point[1] = ((TriSurfGeometry *)img)->node[i][1];
point[2] = ((TriSurfGeometry *)img)->node[i][2];
printf("Distance to point {%.3f, %.3f, %.3f}: ", point[0], point[1], point[2]);
printf("%.3f\n", EmbeddedSurface_DistanceToPoint(surface, point));
}
}
Stg_Class_Delete(surface);
Stg_Class_Delete(isl);
Stg_Class_Delete(imd);
Stg_Class_Delete(img);
Stg_Class_Delete(imt);
Stg_Class_Delete(rml);
Stg_Class_Delete(rmd);
Stg_Class_Delete(rmg);
Stg_Class_Delete(rmt);
DiscretisationUtils_Finalise();
DiscretisationMesh_Finalise();
DiscretisationShape_Finalise();
DiscretisationGeometry_Finalise();
Base_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
MPI_Comm CommWorld;
int rank;
int 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 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 */
}
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;
}
/* 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 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;
}
