void ElementCellLayoutSuite_Setup( ElementCellLayoutSuiteData* data ) { Journal_Enable_AllTypedStream( False ); /* MPI Initializations */ data->comm = MPI_COMM_WORLD; MPI_Comm_rank( data->comm, &data->rank ); MPI_Comm_size( data->comm, &data->nProcs ); data->nDims = 3; data->meshSize[0] = 2; data->meshSize[1] = 3; data->meshSize[2] = 2; data->minCrds[0] = 0.0; data->minCrds[1] = 0.0; data->minCrds[2] = 0.0; data->maxCrds[0] = 300.0; data->maxCrds[1] = 12.0; data->maxCrds[2] = 300.0; /* Init mesh */ data->extensionMgr_Register = ExtensionManager_Register_New(); data->mesh = ElementCellLayout_BuildMesh( data->nDims, data->meshSize, data->minCrds, data->maxCrds, data->extensionMgr_Register ); /* Configure the element-cell-layout */ data->elementCellLayout = ElementCellLayout_New( "elementCellLayout", NULL, data->mesh ); Stg_Component_Build( data->elementCellLayout, NULL, False ); Stg_Component_Initialise( data->elementCellLayout, NULL, False ); }
void SpaceFillerParticleLayoutSuite_TestSpaceFillerParticle( SpaceFillerParticleLayoutSuiteData* data ) { ExtensionManager_Register* extensionMgr_Register; SpaceFillerParticleLayout* particleLayout; ElementCellLayout* elementCellLayout; Mesh* mesh; Swarm* swarm; Stream* stream; unsigned nDims; unsigned meshSize[3]; double minCrds[3]; double maxCrds[3]; int procToWatch = data->nProcs > 1 ? 1 : 0; char expected_file[PCU_PATH_MAX]; if( data->rank == procToWatch ) { nDims = 3; meshSize[0] = 4; meshSize[1] = 2; meshSize[2] = 1; minCrds[0] = 0.0; minCrds[1] = 0.0; minCrds[2] = 0.0; maxCrds[0] = 400.0; maxCrds[1] = 200.0; maxCrds[2] = 100.0; extensionMgr_Register = ExtensionManager_Register_New(); mesh = SpaceFillerParticleLayoutSuite_BuildMesh( nDims, meshSize, minCrds, maxCrds, extensionMgr_Register ); elementCellLayout = ElementCellLayout_New( "spaceFillerParticlElementCellLayout", NULL, mesh ); particleLayout = SpaceFillerParticleLayout_New( "spaceFillerParticleLayout", NULL, GlobalCoordSystem, False, SpaceFillerParticleLayout_Invalid, 20, nDims ); swarm = Swarm_New( "testSpaceFIllerParticle", NULL, elementCellLayout, particleLayout, nDims, sizeof(Particle), extensionMgr_Register, NULL, data->comm, NULL ); Stg_Component_Build( swarm, 0, False ); Stg_Component_Initialise( swarm, 0, False ); Journal_Enable_AllTypedStream( True ); stream = Journal_Register( Info_Type, (Name)"TestSpaceFillerParticle" ); Stream_RedirectFile( stream, "spaceFillerParticle.dat" ); Swarm_PrintParticleCoords_ByCell( swarm, stream ); Journal_Enable_AllTypedStream( False ); pcu_filename_expected( "testSpaceFillerParticleLayoutOutput.expected", expected_file ); pcu_check_fileEq( "spaceFillerParticle.dat", expected_file ); remove( "spaceFillerParticle.dat" ); Stg_Class_Delete( extensionMgr_Register ); /*Stg_Component_Destroy( mesh, NULL, True );*/ Stg_Component_Destroy( elementCellLayout, NULL, True ); Stg_Component_Destroy( particleLayout, NULL, True ); Stg_Component_Destroy( swarm, NULL, True ); } }
void ParticleCoordsSuite_TestLineParticle( ParticleCoordsSuiteData* data ) { ExtensionManager_Register* extensionMgr_Register; Variable_Register* variable_Register; Swarm* swarm; Stream* stream; Dictionary* dictionary; DomainContext* context; int procToWatch = data->nProcs > 1 ? 1 : 0; char input_file[PCU_PATH_MAX]; char expected_file[PCU_PATH_MAX]; Stg_ComponentFactory* cf; if( data->rank == procToWatch ) { Journal_Enable_AllTypedStream( False ); /* Registers */ extensionMgr_Register = ExtensionManager_Register_New(); variable_Register = Variable_Register_New(); /* read in the xml input file */ pcu_filename_input( "testLineParticleLayout.xml", input_file ); cf = stgMainInitFromXML( input_file, data->comm, NULL ); stgMainBuildAndInitialise( cf ); context = (DomainContext*)LiveComponentRegister_Get( cf->LCRegister, (Name)"context" ); dictionary = context->dictionary; swarm = (Swarm* ) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"swarm" ); pcu_check_true( swarm ); Journal_Enable_AllTypedStream( True ); stream = Journal_Register( Info_Type, (Name)"LinearParticleStream" ); Stream_RedirectFile( stream, "linearParticle.dat" ); Swarm_PrintParticleCoords( swarm, stream ); Journal_Enable_AllTypedStream( False ); pcu_filename_expected( "testLineParticleLayoutOutput.expected", expected_file ); pcu_check_fileEq( "linearParticle.dat", expected_file ); /* Destroy stuff */ Stg_Class_Delete( extensionMgr_Register ); Stg_Class_Delete( variable_Register ); remove( "linearParticle.dat" ); } stgMainDestroy( cf ); }
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; 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 */ }
void WallVCSuite_TestWallVC( WallVCSuiteData* data ) { unsigned nDomains; unsigned nDims = 3; unsigned meshSize[3] = {3, 3, 3}; int procToWatch; double minCrds[3] = {0.0, 0.0, 0.0}; double maxCrds[3] = {1.0, 1.0, 1.0}; char* vcKey[] = {"WallVC_Front", "WallVC_Back", "WallVC_Left", "WallVC_Right", "WallVC_Top", "WallVC_Bottom"}; char* vcKeyName[] = {"WallVC_FrontName", "WallVC_BackName", "WallVC_LeftName", "WallVC_RightName", "WallVC_TopName", "WallVC_BottomName"}; char* varName[] = {"x", "y", "z", "vx", "vy", "vz", "temp"}; char input_file[PCU_PATH_MAX]; char expected_file[PCU_PATH_MAX]; Mesh* mesh; Variable_Register* variable_Register; ConditionFunction* quadCF; ConditionFunction* expCF; ConditionFunction_Register* conFunc_Register; ExtensionManager_Register* extensionMgr_Register; Dictionary* dictionary; Dictionary* sources; Stream* stream; XML_IO_Handler* io_handler; Variable* var[7]; double* array[7]; VariableCondition* vc; Index i; procToWatch = data->nProcs >=2 ? 1 : 0; io_handler = XML_IO_Handler_New(); stream = Journal_Register( Info_Type, (Name)"WallVCStream" ); Stream_RedirectFile( stream, "testWallVC.dat" ); dictionary = Dictionary_New(); sources = Dictionary_New(); Dictionary_Add( dictionary, (Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString("./output") ); /* Input file */ pcu_filename_input( "wallVC.xml", input_file ); IO_Handler_ReadAllFromFile( io_handler, input_file, dictionary, sources ); fflush( stdout ); extensionMgr_Register = ExtensionManager_Register_New(); /* Create a mesh. */ mesh = (Mesh*) WallVCSuite_buildMesh( nDims, meshSize, minCrds, maxCrds, extensionMgr_Register ); nDomains = Mesh_GetDomainSize( mesh, MT_VERTEX ); /* Create CF stuff */ quadCF = ConditionFunction_New( WallVCSuite_quadratic, (Name)"quadratic", NULL ); expCF = ConditionFunction_New( WallVCSuite_exponential, (Name)"exponential", NULL); conFunc_Register = ConditionFunction_Register_New( ); ConditionFunction_Register_Add(conFunc_Register, quadCF); ConditionFunction_Register_Add(conFunc_Register, expCF); /* Create variable register */ variable_Register = Variable_Register_New(); /* Create variables */ for (i = 0; i < 6; i++) { array[i] = Memory_Alloc_Array( double, nDomains, "array[i]" ); var[i] = Variable_NewScalar( varName[i], NULL, Variable_DataType_Double, (Index*)&nDomains, NULL, (void**)&array[i], 0 ); Variable_Register_Add(variable_Register, var[i]); } array[6] = Memory_Alloc_Array( double, nDomains * 5, "array[6]" ); var[6] = Variable_NewVector( varName[6], NULL, Variable_DataType_Double, 5, &nDomains, NULL, (void**)&array[6], 0 ); Variable_Register_Add(variable_Register, var[6]); Variable_Register_BuildAll(variable_Register); for (i = 0; i < 6; i++) { Index j, k; vc = (VariableCondition*) WallVC_New( vcKeyName[i], NULL, vcKey[i], variable_Register, conFunc_Register, dictionary, mesh ); Stg_Component_Build( vc, 0, False ); for (j = 0; j < 6; j++) memset(array[j], 0, sizeof(double)* nDomains ); memset(array[6], 0, sizeof(double)* nDomains * 5); VariableCondition_Apply(vc, NULL); if (data->rank == procToWatch) { Journal_Printf( stream,"Testing for %s\n", vcKey[i]); for (j = 0; j < 6; j++) { Journal_Printf( stream,"\nvar[%u]: %.2lf", j, array[j][0]); for (k = 1; k < nDomains; k++) Journal_Printf( stream,", %.2lf", array[j][k]); } Journal_Printf( stream,"\nvar[6]: %.2lf", array[6][0]); for (j = 1; j < nDomains*5; j++) Journal_Printf( stream,", %.2lf", array[6][j]); Journal_Printf( stream,"\n\n"); for (j = 0; j < 7; j++) { for (k = 0; k < nDomains; k++) Journal_Printf( stream,"%s ", VariableCondition_IsCondition(vc, k, j) ? "True " : "False"); Journal_Printf( stream,"\n"); } Journal_Printf( stream,"\n"); for (j = 0; j < 7; j++) { for (k = 0; k < nDomains; k++) { VariableCondition_ValueIndex valIndex; valIndex = VariableCondition_GetValueIndex(vc, k, j); if (valIndex != (unsigned)-1) Journal_Printf( stream,"%03u ", valIndex); else Journal_Printf( stream,"XXX "); } Journal_Printf( stream,"\n"); } Journal_Printf( stream,"\n"); } Stg_Class_Delete(vc); } if (data->rank == procToWatch) { pcu_filename_expected( "testWallVC.expected", expected_file ); pcu_check_fileEq( "testWallVC.dat", expected_file ); remove( "testWallVC.dat" ); } Stg_Class_Delete(variable_Register); for (i = 0; i < 7; i++) { Stg_Class_Delete(var[i]); if (array[i]) Memory_Free(array[i]); } Stg_Class_Delete(extensionMgr_Register); Stg_Class_Delete(io_handler); Stg_Class_Delete(conFunc_Register); Stg_Class_Delete(quadCF); Stg_Class_Delete(expCF); Stg_Class_Delete(dictionary); Stg_Class_Delete(sources); FreeObject( mesh ); }
int main(int argc, char *argv[]) { MPI_Comm CommWorld; int rank; int 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 */ }