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; }