void VariableSuite_Setup( VariableSuiteData* data ) { Particle tmpParticle; Name pNames[] = { "mass", "force", "info" }; SizeT pOffsets[] = { 0, 0, 0 }; /* Init later... */ Variable_DataType pDataTypes[] = { Variable_DataType_Int, Variable_DataType_Float, Variable_DataType_Pointer, }; Index pDtCounts[] = { 1, 3, 1 }; static SizeT pSize = sizeof(Particle); data->aSize[0] = 16; data->aSize[1] = 16; data->aSize[2] = 16; pOffsets[0] = (ArithPointer)&tmpParticle.mass - (ArithPointer)&tmpParticle; pOffsets[1] = (ArithPointer)&tmpParticle.force - (ArithPointer)&tmpParticle; pOffsets[2] = (ArithPointer)&tmpParticle.info - (ArithPointer)&tmpParticle; /* Construction phase --------------------------------------------------------------------------------------------*/ data->vr = Variable_Register_New(); Variable_NewScalar( "temperature", NULL, Variable_DataType_Double, &data->aSize[0], NULL, (void**)&data->temperature, data->vr ); Variable_NewVector( "velocity", NULL, Variable_DataType_Double, 3, &data->aSize[1], NULL, (void**)&data->velocity, data->vr, "vx", "vy", "vz" ); Variable_New( "particle", NULL, 3, pOffsets, pDataTypes, pDtCounts, pNames, &pSize, &data->aSize[2], NULL, (void**)&data->particle, data->vr ); /* Build phase ---------------------------------------------------------------------------------------------------*/ data->temperature = Memory_Alloc_Array( double, data->aSize[0], "temperature" ); data->velocity = Memory_Alloc_Array( VectorD, data->aSize[1], "velocity" ); data->particle = Memory_Alloc_Array( Particle, data->aSize[2], "array" ); Variable_Register_BuildAll( data->vr ); }
void Variable_RegisterSuite_TestAddGet( Variable_RegisterSuiteData* data ) { Variable* var[10]; #define ARRAY_SIZE 4 #define STRUCT_SIZE 4 double array[ARRAY_SIZE]; Index arraySize = ARRAY_SIZE; char* name[10] = {"testVar0", "testVar1", "testVar2", "testVar3", "testVar4", "testVar5", "testVar6", "testVar7", "testVar8", "testVar9"}; Index i; for (i = 0; i < 10; i++) { var[i] = Variable_NewVector( name[i], NULL, Variable_DataType_Double, 4, &arraySize, NULL, (void**)&array, 0 ); } for (i = 0; i < 10; i++) { Variable_Register_Add(data->reg, var[i]); } for (i = 0; i < 10; i++) { pcu_check_true( i == Variable_Register_GetIndex(data->reg, name[i])); } for (i = 0; i < 10; i++) { pcu_check_true( var[i] == Variable_Register_GetByName(data->reg, name[i])); } for (i = 0; i < 10; i++) { Stg_Class_Delete(var[i]); } }
void Mesh_GenerateVertices( void* mesh, unsigned nVerts, unsigned nDims ){ Mesh* self = (Mesh*)mesh; if (self->vertices) return; self->vertices = Memory_Alloc_Array( double, nDims*nVerts, "Mesh::verts" ); char* name; /* Create name for normal variable */ Stg_asprintf( &name, "%s-%s", self->name, "vertices" ); self->nverts = nVerts; self->verticesVariable = Variable_NewVector( name, NULL, Variable_DataType_Double, nDims, &self->nverts, NULL, (void**)&self->vertices, NULL, "vert_i", "vert_j", "vert_j" ); Stg_Component_Build(self->verticesVariable, NULL, False); Stg_Component_Initialise(self->verticesVariable, NULL, False); free(name); }
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 */ }
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 ); }
void LiveComponentRegisterSuite_TestGet( LiveComponentRegisterSuiteData* data ) { typedef float Triple[3]; float* array; Triple* structArray; Variable* var; Variable* vec; Variable* vecVar[3]; Variable* tempVar = NULL; Index length = 10; Variable_Register* reg; array = Memory_Alloc_Array( float, length, "test" ); structArray = Memory_Alloc_Array( Triple, length, "test" ); reg = Variable_Register_New(); var = Variable_NewScalar( "Scalar", NULL, Variable_DataType_Float, &length, NULL, (void**)&array, reg ); vec = Variable_NewVector( "Three", NULL, Variable_DataType_Float, 3, &length, NULL, (void**)&structArray, reg, "a", "b", "c" ); vecVar[0] = Variable_Register_GetByName( reg, "a" ); vecVar[1] = Variable_Register_GetByName( reg, "b" ); vecVar[2] = Variable_Register_GetByName( reg, "c" ); Variable_Register_BuildAll( reg ); LiveComponentRegister_Add( data->lcRegister, (Stg_Component*) var ); pcu_check_true( LiveComponentRegister_IfRegThenAdd( (Stg_Component*) vec ) ); LiveComponentRegister_Add( data->lcRegister, (Stg_Component*) vecVar[0] ); LiveComponentRegister_Add( data->lcRegister, (Stg_Component*) vecVar[1] ); LiveComponentRegister_Add( data->lcRegister, (Stg_Component*) vecVar[2] ); tempVar = (Variable*) LiveComponentRegister_Get( data->lcRegister, (Name)"Scalar" ); pcu_check_true( tempVar == var ); tempVar = (Variable* ) LiveComponentRegister_Get( LiveComponentRegister_GetLiveComponentRegister(), (Name)"Three" ); pcu_check_true( tempVar == vec ); tempVar = (Variable* ) LiveComponentRegister_Get( data->lcRegister, (Name)"a" ); pcu_check_true( tempVar == vecVar[0] ); tempVar = (Variable* ) LiveComponentRegister_Get( data->lcRegister, (Name)"b" ); pcu_check_true( tempVar == vecVar[1] ); tempVar = (Variable* ) LiveComponentRegister_Get( data->lcRegister, (Name)"c" ); pcu_check_true( tempVar == vecVar[2] ); }
void VariableSuite_TestVariable_Short( VariableSuiteData* data ) { typedef short Triple[3]; short* array; Triple* structArray; Index length = 10; /* List of values to test the variable with. * Values to test are hex 5's and a's because they are a series of 0101 and 1010 respectively so they test * each bit in memory to read/set. */ long int testValues[] = { 0x5555, 0xaaaa }; Index testValueCount = 2; Index test_I; long int testValue; Variable* var; Variable* vec; Variable* vecVar[3]; int i, j; array = Memory_Alloc_Array( short, length, "test" ); structArray = Memory_Alloc_Array( Triple, length, "test" ); var = Variable_NewScalar( "Short-Scalar", NULL, Variable_DataType_Short, &length, NULL, (void**)&array, data->vr ); vec = Variable_NewVector( "Short-Three", NULL, Variable_DataType_Short, 3, &length, NULL, (void**)&structArray, data->vr, "a", "b", "c" ); vecVar[0] = Variable_Register_GetByName( data->vr, "a" ); vecVar[1] = Variable_Register_GetByName( data->vr, "b" ); vecVar[2] = Variable_Register_GetByName( data->vr, "c" ); Variable_Register_BuildAll( data->vr ); for ( test_I = 0; test_I < testValueCount; ++test_I ) { testValue = testValues[test_I]; for ( i = 0; i < length; ++i ) { Variable_SetValueShort( var, i, testValue ); Variable_SetValueAtShort( vec, i, 0, testValue ); Variable_SetValueAtShort( vec, i, 1, testValue ); Variable_SetValueAtShort( vec, i, 2, testValue ); } for ( i = 0; i < length; ++i ) { pcu_check_true( Variable_GetValueShort( var, i ) == (short)(short)testValue ); pcu_check_true( Variable_GetValueShortAsChar( var, i ) == (char)(short)testValue ); pcu_check_true( Variable_GetValueShortAsInt( var, i ) == (int)(short)testValue ); pcu_check_true( Variable_GetValueShortAsFloat( var, i ) == (float)(short)testValue ); pcu_check_true( Variable_GetValueShortAsDouble( var, i ) == (double)(short)testValue ); } for ( i = 0; i < length; ++i ) { pcu_check_true( Variable_GetValueAtShort( vec, i, 0 ) == (short)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsChar( vec, i, 0 ) == (char)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsInt( vec, i, 0 ) == (int)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsFloat( vec, i, 0 ) == (float)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsDouble( vec, i, 0 ) == (double)(short)testValue ); pcu_check_true( Variable_GetPtrAtShort( vec, i, 0 ) == &structArray[i][0] ); pcu_check_true( Variable_GetValueAtShort( vec, i, 1 ) == (short)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsChar( vec, i, 1 ) == (char)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsInt( vec, i, 1 ) == (int)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsFloat( vec, i, 1 ) == (float)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsDouble( vec, i, 1 ) == (double)(short)testValue ); pcu_check_true( Variable_GetPtrAtShort( vec, i, 1 ) == &structArray[i][1] ); pcu_check_true( Variable_GetValueAtShort( vec, i, 2 ) == (short)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsChar( vec, i, 2 ) == (char)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsInt( vec, i, 2 ) == (int)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsFloat( vec, i, 2 ) == (float)(short)testValue ); pcu_check_true( Variable_GetValueAtShortAsDouble( vec, i, 2 ) == (double)(short)testValue ); pcu_check_true( Variable_GetPtrAtShort( vec, i, 2 ) == &structArray[i][2] ); } for ( i = 0; i < length; ++i ) { for ( j = 0; j < 3; ++j ) { pcu_check_true( Variable_GetStructPtr( vecVar[j], i ) == &structArray[i][j] ); } } } }
void VariableSuite_TestVariable_Float( VariableSuiteData* data ) { typedef float Triple[3]; float* array; Triple* structArray; Index length = 10; float testValues[] = { 123456789.0, 0.987654321 }; Index testValueCount = 2; Index test_I; float testValue; Variable* var; Variable* vec; Variable* vecVar[3]; int i, j; array = Memory_Alloc_Array( float, length, "test" ); structArray = Memory_Alloc_Array( Triple, length, "test" ); var = Variable_NewScalar( "Float-Scalar", NULL, Variable_DataType_Float, &length, NULL, (void**)&array, data->vr ); vec = Variable_NewVector( "Float-Three", NULL, Variable_DataType_Float, 3, &length, NULL, (void**)&structArray, data->vr, "a", "b", "c" ); vecVar[0] = Variable_Register_GetByName( data->vr, "a" ); vecVar[1] = Variable_Register_GetByName( data->vr, "b" ); vecVar[2] = Variable_Register_GetByName( data->vr, "c" ); Variable_Register_BuildAll( data->vr ); for ( test_I = 0; test_I < testValueCount; ++test_I ) { testValue = testValues[test_I]; for ( i = 0; i < length; ++i ) { Variable_SetValueFloat( var, i, testValue ); Variable_SetValueAtFloat( vec, i, 0, testValue ); Variable_SetValueAtFloat( vec, i, 1, testValue ); Variable_SetValueAtFloat( vec, i, 2, testValue ); } /* "~~~Scalar~~~\n" */ for ( i = 0; i < length; ++i ) { pcu_check_true( Variable_GetValueFloat( var, i ) == (float)(float)testValue ); pcu_check_true( Variable_GetValueFloatAsChar( var, i ) == (float)(char)testValue ); pcu_check_true( Variable_GetValueFloatAsShort( var, i ) == (float)(short)testValue ); pcu_check_true( Variable_GetValueFloatAsInt( var, i ) == (float)(int)testValue ); pcu_check_true( Variable_GetValueFloatAsDouble( var, i ) == (double)(float)testValue ); } /*~~~Vector~~~*/ for ( i = 0; i < length; ++i ) { pcu_check_true( Variable_GetValueAtFloat( vec, i, 0 ) == (float)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsChar( vec, i, 0 ) == (char)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsShort( vec, i, 0 ) == (short)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsInt( vec, i, 0 ) == (int)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsDouble( vec, i, 0 ) == (double)(float)testValue ); pcu_check_true( Variable_GetPtrAtFloat( vec, i, 0 ) == &structArray[i][0] ); pcu_check_true( Variable_GetValueAtFloat( vec, i, 1 ) == (float)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsChar( vec, i, 1 ) == (char)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsShort( vec, i, 1 ) == (short)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsInt( vec, i, 1 ) == (int)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsDouble( vec, i, 1 ) == (double)(float)testValue ); pcu_check_true( Variable_GetPtrAtFloat( vec, i, 1 ) == &structArray[i][1] ); pcu_check_true( Variable_GetValueAtFloat( vec, i, 2 ) == (float)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsChar( vec, i, 2 ) == (char)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsShort( vec, i, 2 ) == (short)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsInt( vec, i, 2 ) == (int)(float)testValue ); pcu_check_true( Variable_GetValueAtFloatAsDouble( vec, i, 2 ) == (double)(float)testValue ); pcu_check_true( Variable_GetPtrAtFloat( vec, i, 2 ) == &structArray[i][2] ); } /*~~~Vector: Sub-Variable~~~*/ for ( i = 0; i < length; ++i ) { for ( j = 0; j < 3; ++j ) { pcu_check_true( Variable_GetStructPtr( vecVar[j], i ) == &structArray[i][j] ); } } } }