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 _GALEDivergenceForce_AssignFromXML( void* forceTerm, Stg_ComponentFactory* cf, void* data ) {
GALEDivergenceForce* self = (GALEDivergenceForce*)forceTerm;
Dictionary* dict;
Stg_Shape* domainShape=NULL;
FeMesh* geometryMesh=NULL;
GALEStressBC_Entry force;
char *type;
/* Construct Parent */
_ForceTerm_AssignFromXML( self, cf, data );
dict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, self->name ) );
domainShape = Stg_ComponentFactory_ConstructByKey( cf, self->name, "DomainShape", Stg_Shape, True, data ) ;
type = Stg_ComponentFactory_GetString( cf, self->name, "force_type", "" );
if(!strcasecmp(type,"double") || !strcasecmp(type,"float"))
{
force.type = GALEStressBC_Double;
force.DoubleValue = Stg_ComponentFactory_GetDouble( cf, self->name, "force_value", 0.0 );
}
else if(!strcasecmp(type,"func"))
{
char *funcName = Stg_ComponentFactory_GetString( cf, self->name, "force_value", "" );
Index cfIndex;
cfIndex = ConditionFunction_Register_GetIndex
( condFunc_Register, funcName);
force.type = GALEStressBC_ConditionFunction;
if ( cfIndex == (unsigned)-1 ) {
Stream* errorStr = Journal_Register( Error_Type, self->type );
Journal_Printf( errorStr, "Error- in %s: While parsing "
"definition of GALEDivergenceForce, the cond. func. "
" \"%s\" - wasn't found in the c.f. register.\n",
__func__, funcName );
Journal_Printf( errorStr, "(Available functions in the C.F. register are: ");
ConditionFunction_Register_PrintNameOfEachFunc
( condFunc_Register, errorStr );
Journal_Printf( errorStr, ")\n");
assert(0);
}
force.CFIndex = cfIndex;
}
else if(strlen(type)==0)
{
Stream* errorStr = Journal_Register( Error_Type, self->type );
Journal_Printf( errorStr, "Error- in %s: While parsing "
"definition of GALEDivergenceForce, force_type is not specified.\nSupported types are \"double\" and \"function\".\n",
__func__);
assert(0);
}
else
{
Stream* errorStr = Journal_Register( Error_Type, self->type );
Journal_Printf( errorStr, "Error- in %s: While parsing "
"definition of GALEDivergenceForce, the type of condition \"%s\"\nis not supported. Supported types are \"double\" and \"function\".\n",
__func__, type );
assert(0);
}
geometryMesh=Stg_ComponentFactory_ConstructByKey( cf, self->name, "GeometryMesh", FeMesh, True, data ) ;
_GALEDivergenceForce_Init( self, domainShape, geometryMesh, force);
}
