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;
}
int main( int argc, char* argv[] ) {
Dictionary* dictionary=NULL;
Dictionary* sources;
XML_IO_Handler* ioHandler;
Stream* msgs;
char* outputFilename = DEFAULT_OUTPUT_FILE;
int ii;
MPI_Init( &argc, &argv );
if( !StGermainBase_Init( &argc, &argv ) ) {
fprintf( stderr, "Error initialising StGermain, exiting.\n" );
exit( EXIT_FAILURE );
}
msgs = Journal_Register( Info_Type, "Messages" );
for( ii = 0; ii < argc; ++ii ) {
if( strstr( argv[ii], OUTPUT_FILE_FLAG ) == argv[ii] ) {
outputFilename = argv[ii] + strlen( OUTPUT_FILE_FLAG );
if( strlen( outputFilename ) < 1 ) {
Journal_Printf( msgs, "Invalid outputfile name: %s\n", outputFilename );
Journal_Printf( msgs, "Exiting...\n" );
StGermainBase_Finalise();
return 1;
}
argv[ii] = " "; /* remove it from the arg list */
}
}
dictionary = Dictionary_New();
sources = Dictionary_New();
/* Read input */
ioHandler = XML_IO_Handler_New();
IO_Handler_ReadAllFromCommandLine( ioHandler, argc, argv, dictionary, sources );
IO_Handler_WriteAllToFile( ioHandler, outputFilename, dictionary, sources );
Stg_Class_Delete( dictionary );
Stg_Class_Delete( sources );
Stg_Class_Delete( ioHandler );
StGermainBase_Finalise();
MPI_Finalize();
return 0; /* success */
}
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;
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;
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 );
}
void stgGenerateFlattenedXML( Dictionary* dictionary, Dictionary* sources, char* timeStamp ) {
XML_IO_Handler* ioHandler;
char* outputPath;
char* flatFilename;
char* flatFilenameStamped;
char* slimFilename;
Stream* s;
Bool isEnabled;
Bool ret;
Bool outputSlim;
s = Journal_Register( Info_Type, (Name)XML_IO_Handler_Type );
/* Avoid confusing messages from XML_IO_Handler. Turn it off temporarily. */
isEnabled = Stream_IsEnable( s );
Stream_EnableSelfOnly( s, False );
ioHandler = XML_IO_Handler_New();
if( sources == NULL )
ioHandler->writeSources = False;
outputPath = StG_Strdup( Dictionary_Entry_Value_AsString( Dictionary_GetDefault( dictionary,
(Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString( "./" ) ) ) );
outputSlim = Dictionary_Entry_Value_AsBool( Dictionary_GetDefault( dictionary,
(Dictionary_Entry_Key)"outputSlimmedXML", Dictionary_Entry_Value_FromBool( True ) ) );
if( ! Stg_DirectoryExists( outputPath ) ) {
if( Stg_FileExists( outputPath ) )
Journal_Firewall( 0, s, "outputPath '%s' is a file an not a directory! Exiting...\n", outputPath );
Journal_Printf( s, "outputPath '%s' does not exist, attempting to create...\n", outputPath );
ret = Stg_CreateDirectory( outputPath );
Journal_Firewall( ret, s, "Unable to create non-existing outputPath to '%s'\n", outputPath );
Journal_Printf( s, "outputPath '%s' successfully created!\n", outputPath );
}
/* Set file names. */
Stg_asprintf( &flatFilename, "%s/%s", outputPath, "input.xml" );
IO_Handler_WriteAllToFile( ioHandler, flatFilename, dictionary, sources );
/* Format; path/input-YYYY.MM.DD-HH.MM.SS.xml. */
if (timeStamp) {
Stg_asprintf( &flatFilenameStamped, "%s/%s-%s.%s",
outputPath, "input", timeStamp, "xml" );
IO_Handler_WriteAllToFile( ioHandler, flatFilenameStamped, dictionary, sources );
Memory_Free( flatFilenameStamped );
}
if( outputSlim && timeStamp ) {
ioHandler->writeSources = False;
Stg_asprintf( &slimFilename, "%s/%s-%s.%s",
outputPath, "input-basic", timeStamp, "xml" );
IO_Handler_WriteAllToFile( ioHandler, slimFilename, dictionary, NULL);
}
Stream_EnableSelfOnly( s, isEnabled );
Stg_Class_Delete( ioHandler );
Memory_Free( flatFilename );
}
/* 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;
}
