void _Ppc_Switch_AssignFromXML( void* _self, Stg_ComponentFactory* cf, void* data ) {
Ppc_Switch* self = (Ppc_Switch*)_self;
Dictionary* theDictionary = NULL;
Dictionary_Entry_Value* caseEntry = NULL;
Dictionary_Entry_Value* tagList = NULL;
Index case_I;
char* ppcName;
/* Construct parent */
_Ppc_AssignFromXML( self, cf, data );
/* The dictionary */
theDictionary = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, (Dictionary_Entry_Key)self->name ) );
/* Read the properties list */
tagList = Dictionary_Get( theDictionary, (Dictionary_Entry_Key)"CaseList" );
assert( tagList );
self->caseCount = Dictionary_Entry_Value_GetCount( tagList );
self->caseList = Memory_Alloc_Array( Ppc_Switch_Case, self->caseCount, "Ppc_Switch_caseList" );
for( case_I = 0; case_I < self->caseCount; case_I++ ){
caseEntry = Dictionary_Entry_Value_GetElement( tagList, case_I );
/* get case value */
self->caseList[case_I].constant = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( caseEntry, (Dictionary_Entry_Key)"Case") );
/* get ppc associated with the case*/
ppcName = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetMember( caseEntry, (Dictionary_Entry_Key)"Value") );
self->caseList[case_I].valueTag = PpcManager_GetPpcByName( self->manager, cf, (Name)ppcName );
}
/* Init */
_Ppc_Switch_Init(
self,
Stg_ComponentFactory_GetString( cf, self->name, (Dictionary_Entry_Key)"Interpolate", "" ),
PpcManager_GetPpcFromDict( self->manager, cf, self->name, (Dictionary_Entry_Key)"Field", "" ) );
}
void DictionarySuite_TestGet( DictionarySuiteData* data ) {
Dictionary_Entry_Value* yValue;
Dictionary_Entry_Value* testStruct;
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
testStruct = Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" );
yValue = Dictionary_Entry_Value_GetMember( Dictionary_Entry_Value_GetMember(testStruct, (Dictionary_Entry_Key)"geom" ), "starty");
pcu_check_true( data->testDD->testStruct->geom.starty == Dictionary_Entry_Value_AsDouble( yValue ) );
}
void _ConvexHull_AssignFromXML( void* convexHull, Stg_ComponentFactory* cf, void* data ) {
ConvexHull* self = (ConvexHull*)convexHull;
Index vertexCount;
Index vertex_I;
Coord_List vertexList;
double* coord;
Dictionary_Entry_Value* optionSet;
Dictionary_Entry_Value* optionsList;
Dictionary* dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
Stream* stream = cf->infoStream;
_Stg_Shape_AssignFromXML( self, cf, data );
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"vertices" );
Journal_Firewall( optionsList != NULL,
Journal_Register( Error_Type, (Name)self->type ),
"In func %s: The list 'vertices' specifying the convexHull is NULL.\n", __func__);
vertexCount = Dictionary_Entry_Value_GetCount(optionsList);
Journal_Firewall( ( self->dim == 2 && vertexCount < 4 ) || ( self->dim == 3 && vertexCount < 5 ),
Journal_Register( Error_Type, (Name)self->type ),
"In func %s: Sorry, but we got lazy, you can only specify 3 (2D) or 4 (3D) points. "
"Please feel free to hassle developers for this feature.\n", __func__);
/* Allocate space */
vertexList = Memory_Alloc_Array( Coord , vertexCount, "Vertex Array" );
memset( vertexList, 0, vertexCount * sizeof(Coord) );
Stream_Indent( stream );
for ( vertex_I = 0 ; vertex_I < vertexCount ; vertex_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, vertex_I );
coord = vertexList[vertex_I];
/* Read Vertex */
coord[ I_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"x") );
coord[ J_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"y") );
coord[ K_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"z"));
optionSet = optionSet->next;
}
Stream_UnIndent( stream );
_ConvexHull_Init( self, vertexList, vertexCount);
}
void DictionarySuite_TestAddElement( DictionarySuiteData* data ) {
Dictionary_Entry_Value* yValue;
Dictionary_Entry_Value* testStruct;
Dictionary_Entry_Value* currValue;
double newVal = -45.0;
DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD );
/* turning the starty value into a list using add element */
testStruct = Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_struct" );
yValue = Dictionary_Entry_Value_GetMember( Dictionary_Entry_Value_GetMember(testStruct, (Dictionary_Entry_Key)"geom" ), "starty");
Dictionary_Entry_Value_AddElement( yValue, Dictionary_Entry_Value_FromDouble(newVal) );
pcu_check_true( Dictionary_Entry_Value_Type_List == yValue->type );
pcu_check_true( 2 == Dictionary_Entry_Value_GetCount( yValue ) );
currValue = Dictionary_Entry_Value_GetFirstElement( yValue );
pcu_check_le( fabs( data->testDD->testStruct->geom.starty - Dictionary_Entry_Value_AsDouble( currValue )), 0.01 );
currValue = currValue->next;
pcu_check_le( fabs( newVal - Dictionary_Entry_Value_AsDouble( currValue )), 0.01 );
}
/*----------------------------------------------------------------------------------------------------------
** Virtual functions
*/
void _LinearSpaceAdaptor_AssignFromXML( void* _self, Stg_ComponentFactory* cf, void* data ) {
LinearSpaceAdaptor* self = (LinearSpaceAdaptor*)_self;
Dictionary* dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
Dictionary_Entry_Value* optionsList = NULL;
Dictionary_Entry_Value* optionSet = NULL;
linearSpaceAdaptor_Segment* seg = NULL;
Index segmentCount;
Index segment_I;
AbstractContext* context;
assert( self );
assert( cf );
/* Call parent construct. */
_MeshAdaptor_AssignFromXML( self, cf, data );
context = (AbstractContext*)Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", AbstractContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", AbstractContext, True, data );
self->loadFromCheckPoint = context->loadFromCheckPoint;
if( self->loadFromCheckPoint )
return;
self->minX = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minX" ) );
self->maxX = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxX" ) );
self->minY = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minY" ) );
self->maxY = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxY" ) );
self->minZ = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minZ" ) );
self->maxZ = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxZ" ) );
/* Read mapping functions - X axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionX" );
if( optionsList ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsx = segmentCount;
self->tablex = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table x" );
memset( self->tablex, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0 ; segment_I < segmentCount ; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tablex[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsx = 0;
}
/* Read mapping functions - Y axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionY" );
if( optionsList ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsy = segmentCount;
self->tabley = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table y" );
memset( self->tabley, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0; segment_I < segmentCount; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tabley[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsy = 0;
}
/* Read mapping functions - Z axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionZ" );
if( optionsList && ((DomainContext*)context)->dim==3 ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsz = segmentCount;
self->tablez = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table z" );
memset( self->tablez, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0 ; segment_I < segmentCount ; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tablez[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsz = 0;
}
_LinearSpaceAdaptor_Init( self );
}
void _FrictionVC_ReadDictionary( void* variableCondition, void* dictionary ) {
FrictionVC* self = (FrictionVC*)variableCondition;
Dictionary_Entry_Value* vcDictVal;
Dictionary_Entry_Value _vcDictVal;
Dictionary_Entry_Value* varsVal;
FrictionVC_Entry_Index entry_I;
/* Find dictionary entry */
if (self->_dictionaryEntryName)
vcDictVal = Dictionary_Get(dictionary, self->_dictionaryEntryName);
else
{
vcDictVal = &_vcDictVal;
Dictionary_Entry_Value_InitFromStruct(vcDictVal, dictionary);
}
if (vcDictVal)
{
char* wallStr;
/* Obtain which wall */
wallStr = Dictionary_Entry_Value_AsString(Dictionary_Entry_Value_GetMember(vcDictVal, "wall" ));
if (!strcasecmp(wallStr, "back"))
self->_wall = FrictionVC_Wall_Back;
else if (!strcasecmp(wallStr, "left"))
self->_wall = FrictionVC_Wall_Left;
else if (!strcasecmp(wallStr, "bottom"))
self->_wall = FrictionVC_Wall_Bottom;
else if (!strcasecmp(wallStr, "right"))
self->_wall = FrictionVC_Wall_Right;
else if (!strcasecmp(wallStr, "top"))
self->_wall = FrictionVC_Wall_Top;
else if (!strcasecmp(wallStr, "front"))
self->_wall = FrictionVC_Wall_Front;
else {
assert( 0 );
self->_wall = FrictionVC_Wall_Size; /* invalid entry */
}
/* Obtain the variable entries */
self->_entryCount = 0;
self->_entryCount = Dictionary_Entry_Value_GetCount(Dictionary_Entry_Value_GetMember(vcDictVal, "variables"));
self->_entryTbl = Memory_Alloc_Array( FrictionVC_Entry, self->_entryCount, "FrictionVC->_entryTbl" );
varsVal = Dictionary_Entry_Value_GetMember(vcDictVal, "variables");
for (entry_I = 0; entry_I < self->_entryCount; entry_I++)
{
char* valType;
Dictionary_Entry_Value* valueEntry;
Dictionary_Entry_Value* varDictListVal;
varDictListVal = Dictionary_Entry_Value_GetElement(varsVal, entry_I);
valueEntry = Dictionary_Entry_Value_GetMember(varDictListVal, "value");
self->_entryTbl[entry_I].varName = Dictionary_Entry_Value_AsString(
Dictionary_Entry_Value_GetMember(varDictListVal, "name"));
valType = Dictionary_Entry_Value_AsString(Dictionary_Entry_Value_GetMember(varDictListVal, "type"));
if (0 == strcasecmp(valType, "func"))
{
char* funcName = Dictionary_Entry_Value_AsString(valueEntry);
Index cfIndex;
self->_entryTbl[entry_I].value.type = VC_ValueType_CFIndex;
cfIndex = ConditionFunction_Register_GetIndex( self->conFunc_Register, funcName);
if ( cfIndex == (unsigned)-1 ) {
Stream* errorStr = Journal_Register( Error_Type, self->type );
Journal_Printf( errorStr, "Error- in %s: While parsing "
"definition of wallVC \"%s\" (applies to wall \"%s\"), the cond. func. applied to "
"variable \"%s\" - \"%s\" - wasn't found in the c.f. register.\n",
__func__, self->_dictionaryEntryName, FrictionVC_WallEnumToStr[self->_wall],
self->_entryTbl[entry_I].varName, funcName );
Journal_Printf( errorStr, "(Available functions in the C.F. register are: ");
ConditionFunction_Register_PrintNameOfEachFunc( self->conFunc_Register, errorStr );
Journal_Printf( errorStr, ")\n");
assert(0);
}
self->_entryTbl[entry_I].value.as.typeCFIndex = cfIndex;
}
else if (0 == strcasecmp(valType, "array"))
{
Dictionary_Entry_Value* valueElement;
Index i;
self->_entryTbl[entry_I].value.type = VC_ValueType_DoubleArray;
self->_entryTbl[entry_I].value.as.typeArray.size = Dictionary_Entry_Value_GetCount(valueEntry);
self->_entryTbl[entry_I].value.as.typeArray.array = Memory_Alloc_Array( double,
self->_entryTbl[entry_I].value.as.typeArray.size, "FrictionVC->_entryTbl[].value.as.typeArray.array" );
for (i = 0; i < self->_entryTbl[entry_I].value.as.typeArray.size; i++)
{
valueElement = Dictionary_Entry_Value_GetElement(valueEntry, i);
self->_entryTbl[entry_I].value.as.typeArray.array[i] =
Dictionary_Entry_Value_AsDouble(valueElement);
}
}
else if( 0 == strcasecmp( valType, "double" ) || 0 == strcasecmp( valType, "d" ) ||
0 == strcasecmp( valType, "float" ) || 0 == strcasecmp( valType, "f" ) )
{
self->_entryTbl[entry_I].value.type = VC_ValueType_Double;
self->_entryTbl[entry_I].value.as.typeDouble = Dictionary_Entry_Value_AsDouble( valueEntry );
}
else if( 0 == strcasecmp( valType, "integer" ) || 0 == strcasecmp( valType, "int" ) || 0 == strcasecmp( valType, "i" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Int;
self->_entryTbl[entry_I].value.as.typeInt = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( 0 == strcasecmp( valType, "short" ) || 0 == strcasecmp( valType, "s" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Short;
self->_entryTbl[entry_I].value.as.typeShort = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( 0 == strcasecmp( valType, "char" ) || 0 == strcasecmp( valType, "c" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Char;
self->_entryTbl[entry_I].value.as.typeChar = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( 0 == strcasecmp( valType, "pointer" ) || 0 == strcasecmp( valType, "ptr" ) || 0 == strcasecmp( valType, "p" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Ptr;
self->_entryTbl[entry_I].value.as.typePtr = (void*) ( (ArithPointer)Dictionary_Entry_Value_AsUnsignedInt( valueEntry ));
}
else {
/* Assume double */
Journal_DPrintf(
Journal_Register( InfoStream_Type, "myStream" ),
"Type to variable on variable condition not given, assuming double\n" );
self->_entryTbl[entry_I].value.type = VC_ValueType_Double;
self->_entryTbl[entry_I].value.as.typeDouble = Dictionary_Entry_Value_AsDouble( valueEntry );
}
}
void _VariableAllVC_ReadDictionary( void* variableCondition, void* dictionary ) {
VariableAllVC* self = (VariableAllVC*)variableCondition;
Dictionary_Entry_Value* vcDictVal;
Dictionary_Entry_Value _vcDictVal;
Dictionary_Entry_Value* varsVal;
VariableAllVC_Entry_Index entry_I;
/* Find dictionary entry */
if (self->_dictionaryEntryName)
vcDictVal = Dictionary_Get( dictionary, self->_dictionaryEntryName );
else
{
vcDictVal = &_vcDictVal;
Dictionary_Entry_Value_InitFromStruct( vcDictVal, dictionary );
}
if (vcDictVal)
{
/* Obtain the variable entries */
self->_entryCount = Dictionary_Entry_Value_GetCount(Dictionary_Entry_Value_GetMember(vcDictVal, "variables"));
self->_entryTbl = Memory_Alloc_Array( VariableAllVC_Entry, self->_entryCount, "VariableAllVC->_entryTbl" );
varsVal = Dictionary_Entry_Value_GetMember(vcDictVal, "variables");
for (entry_I = 0; entry_I < self->_entryCount; entry_I++)
{
char* valType;
Dictionary_Entry_Value* valueEntry;
Dictionary_Entry_Value* varDictListVal;
varDictListVal = Dictionary_Entry_Value_GetElement(varsVal, entry_I);
valueEntry = Dictionary_Entry_Value_GetMember(varDictListVal, "value");
self->_entryTbl[entry_I].varName = Dictionary_Entry_Value_AsString(
Dictionary_Entry_Value_GetMember(varDictListVal, "name"));
valType = Dictionary_Entry_Value_AsString(Dictionary_Entry_Value_GetMember(varDictListVal, "type"));
if (!strcasecmp(valType, "func"))
{
char* funcName = Dictionary_Entry_Value_AsString(valueEntry);
self->_entryTbl[entry_I].value.type = VC_ValueType_CFIndex;
self->_entryTbl[entry_I].value.as.typeCFIndex = ConditionFunction_Register_GetIndex(
self->conFunc_Register, funcName);
}
else if (!strcasecmp(valType, "array"))
{
Dictionary_Entry_Value* valueElement;
Index i;
self->_entryTbl[entry_I].value.type = VC_ValueType_DoubleArray;
self->_entryTbl[entry_I].value.as.typeArray.size = Dictionary_Entry_Value_GetCount(valueEntry);
self->_entryTbl[entry_I].value.as.typeArray.array = Memory_Alloc_Array( double,
self->_entryTbl[entry_I].value.as.typeArray.size,"VariableAllVC->_entryTbl[].value.as.typeArray.array" );
for (i = 0; i < self->_entryTbl[entry_I].value.as.typeArray.size; i++)
{
valueElement = Dictionary_Entry_Value_GetElement(valueEntry, i);
self->_entryTbl[entry_I].value.as.typeArray.array[i] =
Dictionary_Entry_Value_AsDouble(valueElement);
}
}
else if( !strcasecmp( valType, "double" ) || !strcasecmp( valType, "d" ) || !strcasecmp( valType, "float" ) || !strcasecmp( valType, "f" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Double;
self->_entryTbl[entry_I].value.as.typeDouble = Dictionary_Entry_Value_AsDouble( valueEntry );
}
else if( !strcasecmp( valType, "integer" ) || !strcasecmp( valType, "int" ) || !strcasecmp( valType, "i" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Int;
self->_entryTbl[entry_I].value.as.typeInt = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( !strcasecmp( valType, "short" ) || !strcasecmp( valType, "s" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Short;
self->_entryTbl[entry_I].value.as.typeShort = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( !strcasecmp( valType, "char" ) || !strcasecmp( valType, "c" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Char;
self->_entryTbl[entry_I].value.as.typeChar = Dictionary_Entry_Value_AsUnsignedInt( valueEntry );
}
else if( !strcasecmp( valType, "pointer" ) || !strcasecmp( valType, "ptr" ) || !strcasecmp( valType, "p" ) ) {
self->_entryTbl[entry_I].value.type = VC_ValueType_Ptr;
self->_entryTbl[entry_I].value.as.typePtr = (void*) ( (ArithPointer) Dictionary_Entry_Value_AsUnsignedInt( valueEntry ));
}
else {
/* Assume double */
Journal_DPrintf( Journal_Register( InfoStream_Type, "myStream" ), "Type to variable on variable condition not given, assuming double\n" );
self->_entryTbl[entry_I].value.type = VC_ValueType_Double;
self->_entryTbl[entry_I].value.as.typeDouble = Dictionary_Entry_Value_AsDouble( valueEntry );
}
}