int main( int argc, char* argv[] ) { MPI_Comm CommWorld; int rank; int numProcessors; int procToWatch; /* Initialise MPI, get world info */ MPI_Init( &argc, &argv ); MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld ); MPI_Comm_size( CommWorld, &numProcessors ); MPI_Comm_rank( CommWorld, &rank ); BaseFoundation_Init( &argc, &argv ); BaseIO_Init( &argc, &argv ); if( argc >= 2 ) { procToWatch = atoi( argv[1] ); } else { procToWatch = 0; } if( rank == procToWatch ) { XML_IO_Handler* io_handler = XML_IO_Handler_New(); Dictionary* dictionary = Dictionary_New(); Dictionary_Index index; Stream* stream = Journal_Register( InfoStream_Type, XML_IO_Handler_Type ); /* use the base class functions */ printf( "\ntest of raw data file:\n" ); IO_Handler_ReadAllFromFile( io_handler, "data/rawdata.xml", dictionary ); printf( "\ndictionary now contains:\n" ); printf( "Dictionary:\n" ); printf( "\tsize: %u\n", dictionary->size ); printf( "\tdelta: %u\n", dictionary->delta ); printf( "\tcount: %u\n", dictionary->count ); printf( "\tentryPtr[0-%u]: {\n", dictionary->count ); for( index = 0; index < dictionary->count; index++ ) { printf( "\t\t" ); Dictionary_Entry_Print( dictionary->entryPtr[index], stream ); printf( "\n" ); } printf( "\t}\n" ); /* Dictionary_Entry_Value_SetEncoding( Dictionary_Get( dictionary, "boundary_conditions2" ), RawASCII ); */ IO_Handler_WriteAllToFile( io_handler, "data/newrawdata.xml", dictionary ); Stg_Class_Delete( io_handler ); Stg_Class_Delete( dictionary ); } BaseIO_Finalise(); BaseFoundation_Finalise(); /* Close off MPI */ MPI_Finalize(); return EXIT_SUCCESS; }
Stg_ComponentFactory* stgMainInitFromXML( char* xmlInputFilename, MPI_Comm communicator, void* _context ) { Dictionary* dictionary = NULL; Dictionary* sources = NULL; Bool result; XML_IO_Handler* ioHandler; Stg_ComponentFactory* cf; dictionary = Dictionary_New(); sources = Dictionary_New(); ioHandler = XML_IO_Handler_New(); result = IO_Handler_ReadAllFromFile( ioHandler, xmlInputFilename, dictionary, sources ); /* In case the user has put any journal configuration in the XML, read here. */ Journal_ReadFromDictionary( dictionary ); cf = stgMainConstruct( dictionary, sources, communicator, _context ); /* now dereference aliases */ DictionaryUtils_AliasDereferenceDictionary( dictionary ); /* * We don't need the XML IO handler again (however don't delete the dictionary as it's * 'owned' by the context from hereon. */ Stg_Class_Delete( ioHandler ); Stg_Class_Delete( sources ); return cf; }
PyObject* Dictionary_Python_LoadFromFile( PyObject* self, PyObject* args ) { PyObject* pyDictionary; Dictionary* dictionary; XML_IO_Handler* ioHandler; char* filename; /* Obtain arguements */ if( !PyArg_ParseTuple( args, "Os:", &pyDictionary, &filename ) ) { return NULL; } dictionary = (Dictionary*)( PyCObject_AsVoidPtr( pyDictionary ) ); /* Run function */ ioHandler = XML_IO_Handler_New(); IO_Handler_ReadAllFromFile( ioHandler, filename, dictionary ); Stg_Class_Delete( ioHandler ); /* Return */ Py_INCREF( Py_None ); return Py_None; }
int main(int argc, char **argv) { MPI_Comm CommWorld; XML_IO_Handler *io_handler = XML_IO_Handler_New(); int rank, procCount, procToWatch; Dictionary *dictionary; EmbeddedSurface *surface; MeshTopology *rmt, *imt; MeshGeometry *rmg, *img; MeshDecomp *rmd, *imd; MeshLayout *rml, *isl; ExtensionManager_Register *extensionMgr_Register; Mesh *mesh; Element_GlobalIndex intersectCnt, *intersect; Index i; /* Initialise MPI, get world info */ MPI_Init( &argc, &argv ); MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld ); MPI_Comm_size( CommWorld, &procCount ); MPI_Comm_rank( CommWorld, &rank ); Base_Init( &argc, &argv ); DiscretisationGeometry_Init( &argc, &argv ); DiscretisationShape_Init( &argc, &argv ); DiscretisationMesh_Init( &argc, &argv ); DiscretisationUtils_Init( &argc, &argv ); MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */ if( argc >= 2 ) procToWatch = atoi( argv[1] ); else procToWatch = 0; if( rank == procToWatch ) printf( "Watching rank: %i\n", rank ); dictionary = Dictionary_New(); Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) ); Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) ); Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 2 ) ); Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 2 ) ); Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 4 ) ); Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) ); Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( True ) ); Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) ); Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 0 ) ); IO_Handler_ReadAllFromFile(io_handler, "data/surface.xml", dictionary); rmt = (MeshTopology *)HexaMeshTopology_New(dictionary); rmg = (MeshGeometry *)HexaMeshGeometry_New(dictionary); rmd = (MeshDecomp *)HexaMeshDecomp_New(dictionary, MPI_COMM_WORLD, (HexaMeshTopology *)rmt); rml = MeshLayout_New(dictionary, rmt, rmg, rmd); imt = (MeshTopology *)TriSurfTopology_New(dictionary, "imElements"); img = (MeshGeometry *)TriSurfGeometry_New(dictionary, "imNodes"); imd = (MeshDecomp *)IrregularMeshDecomp_New1(dictionary, MPI_COMM_WORLD, imt, img, rml); isl = MeshLayout_New(dictionary, imt, img, imd); extensionMgr_Register = ExtensionManager_Register_New( ); mesh = Mesh_New( isl, sizeof(Node), sizeof(Element), extensionMgr_Register, dictionary ); Mesh_Build( mesh ); Mesh_Initialise(mesh); surface = EmbeddedSurface_New(mesh); if (procToWatch == rank) { intersect = Memory_Alloc_Array( Element_GlobalIndex, isl->decomp->elementGlobalCount(isl->decomp), "intersect" ); intersectCnt = EmbeddedSurface_BuildIntersection(surface, intersect); printf("Intersects: %u\n", intersectCnt); for (i = 0; i < intersectCnt; i++) printf("\tinstersect[%u]: %u\n", i, intersect[i]); printf("\n"); if (intersect) Memory_Free(intersect); for (i = 0; i < isl->decomp->nodeGlobalCount(isl->decomp); i++) { Coord point; point[0] = ((TriSurfGeometry *)img)->node[i][0] + 1.0; point[1] = ((TriSurfGeometry *)img)->node[i][1]; point[2] = ((TriSurfGeometry *)img)->node[i][2]; printf("Distance to point {%.3f, %.3f, %.3f}: ", point[0], point[1], point[2]); printf("%.3f\n", EmbeddedSurface_DistanceToPoint(surface, point)); } } Stg_Class_Delete(surface); Stg_Class_Delete(isl); Stg_Class_Delete(imd); Stg_Class_Delete(img); Stg_Class_Delete(imt); Stg_Class_Delete(rml); Stg_Class_Delete(rmd); Stg_Class_Delete(rmg); Stg_Class_Delete(rmt); DiscretisationUtils_Finalise(); DiscretisationMesh_Finalise(); DiscretisationShape_Finalise(); DiscretisationGeometry_Finalise(); Base_Finalise(); /* Close off MPI */ MPI_Finalize(); return 0; }
int main( int argc, char *argv[] ) { int rank; int procCount; int procToWatch; Stream* stream; /* Initialise MPI, get world info */ MPI_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &procCount ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); BaseFoundation_Init( &argc, &argv ); RegressionTest_Init( "Base/Automation/Stg_Component" ); BaseIO_Init( &argc, &argv ); BaseContainer_Init( &argc, &argv ); BaseAutomation_Init( &argc, &argv ); stream = Journal_Register( Info_Type, __FILE__ ); if( argc >= 2 ) { procToWatch = atoi( argv[1] ); } else { procToWatch = 0; } if( rank == procToWatch ) { Stg_ComponentMeta* metaTest; XML_IO_Handler* io; Dictionary* allDict; Dictionary* compDict; CompositeVC* vc; Journal_Printf( stream, "%s\n", Stg_Component_GetMetadata() ); metaTest = Stg_Component_CreateMeta( "blah", Variable_Type ); Stg_Class_Print( metaTest, stream ); Stg_Class_Delete( metaTest ); allDict = Dictionary_New(); io = XML_IO_Handler_New(); IO_Handler_ReadAllFromFile( io, "data/metatest.xml", allDict ); compDict = Dictionary_GetDictionary( allDict, "components" ); vc = CompositeVC_DefaultNew( "vc" ); metaTest = Stg_Component_Validate( vc, CompositeVC_Type, compDict ); Stg_Class_Print( metaTest, stream ); Stg_Class_Delete( metaTest ); Stg_Class_Delete( io ); Stg_Class_Delete( compDict ); } BaseAutomation_Finalise(); BaseContainer_Finalise(); BaseIO_Finalise(); RegressionTest_Finalise(); BaseFoundation_Finalise(); /* Close off MPI */ MPI_Finalize(); return 0; /* success */ }
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 ); }
/* 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; 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; /* Initialise MPI, get world info */ MPI_Init( &argc, &argv ); MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld ); MPI_Comm_size( CommWorld, &numProcessors ); MPI_Comm_rank( CommWorld, &rank ); BaseFoundation_Init( &argc, &argv ); BaseIO_Init( &argc, &argv ); if( argc >= 2 ) { procToWatch = atoi( argv[1] ); } else { procToWatch = 0; } if( rank == procToWatch ) { Stream* infoTest1; Stream* infoTest2; Stream* debugTest1; Stream* debugTest2; Stream* dumpTest1; Stream* dumpTest2; Stream* newTest1; Stream* newTest2; Stream* fileTest1; Stream* fileTest2; Stream* propTest1; Stream* propTest2; Dictionary* dictionary = Dictionary_New(); XML_IO_Handler* io_handler = XML_IO_Handler_New(); infoTest1 = Journal_Register( Info_Type, "test1" ); infoTest2 = Journal_Register( Info_Type, "test2" ); debugTest1 = Journal_Register( Debug_Type, "test1" ); debugTest2 = Journal_Register( Debug_Type, "test2" ); dumpTest1 = Journal_Register( Dump_Type, "test1" ); dumpTest2 = Journal_Register( Dump_Type, "test2" ); IO_Handler_ReadAllFromFile( io_handler, "data/journal.xml", dictionary ); Journal_ReadFromDictionary( dictionary ); newTest1 = Journal_Register( Info_Type, "test1.new1" ); newTest2 = Journal_Register( Info_Type, "test1.new2" ); Journal_Printf( infoTest1, "infoTest1\n" ); Journal_Printf( infoTest2, "infoTest2\n" ); Journal_Printf( debugTest1, "debugTest1\n" ); Journal_Printf( debugTest2, "debugTest2\n" ); Journal_Printf( dumpTest1, "dumpTest1\n" ); Journal_Printf( dumpTest2, "dumpTest2\n" ); Journal_PrintfL( newTest1, 3, "newTest1\n" ); Journal_PrintfL( newTest1, 4, "newTest1\n" ); Journal_Printf( newTest2, "newTest2\n" ); fileTest1 = Journal_Register( "newtype", "hello" ); fileTest2 = Journal_Register( "newtype", "other" ); Journal_Printf( fileTest1, "yay!" ); Journal_Printf( fileTest2, "double yay!" ); propTest1 = Journal_Register( Info_Type, "propertiestest1" ); propTest2 = Journal_Register( Info_Type, "propertiestest2" ); Print( propTest1, infoTest1 ); Print( propTest2, infoTest1 ); Stg_Class_Delete( io_handler ); Stg_Class_Delete( dictionary ); } BaseIO_Finalise(); BaseFoundation_Finalise(); /* Close off MPI */ MPI_Finalize(); return EXIT_SUCCESS; }
int 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; }