void _ShellGeometry_Init(
ShellGeometry* self )
{
/* General and Virtual info should already be set */
/* ShellGeometry info */
self->isConstructed = True;
self->size[0] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeI",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->size[1] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeJ",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->size[2] = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_GetDefault( self->dictionary, "meshSizeK",
Dictionary_Entry_Value_FromUnsignedInt( 2 ) ) );
self->pointCount = self->size[0] * self->size[1] * self->size[2];
assert( self->pointCount );
self->min[0] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minTheta",
Dictionary_Entry_Value_FromDouble( 2.0 * M_PI / 3.0 ) ) );
self->min[1] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minPhi",
Dictionary_Entry_Value_FromDouble( 2.0 * M_PI / 3.0 ) ) );
self->min[2] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "minR",
Dictionary_Entry_Value_FromDouble( 0.5f ) ) );
self->max[0] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxTheta",
Dictionary_Entry_Value_FromDouble( M_PI / 3.0 ) ) );
self->max[1] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxPhi",
Dictionary_Entry_Value_FromDouble( M_PI / 3.0 ) ) );
self->max[2] = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( self->dictionary, "maxR",
Dictionary_Entry_Value_FromDouble( 1.0f ) ) );
}
void _TriGaussParticleLayout_AssignFromXML( void* triGaussParticleLayout, Stg_ComponentFactory* cf, void* data ){
TriGaussParticleLayout *self = (TriGaussParticleLayout*)triGaussParticleLayout;
unsigned int dim;
unsigned int particlesPerCell;
_PerCellParticleLayout_AssignFromXML( self, cf, data );
dim = Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault( cf->rootDict, "dim", Dictionary_Entry_Value_FromUnsignedInt( 3 ) ) );
particlesPerCell = Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault( cf->rootDict, "particlesPerCell", Dictionary_Entry_Value_FromUnsignedInt( 1 ) ) );
_TriGaussParticleLayout_Init( self, dim, particlesPerCell );
}
unsigned int Dictionary_Entry_Value_AsUnsignedInt( Dictionary_Entry_Value* self ) {
if( !self ) {
return 0;
}
switch( self->type ) {
case Dictionary_Entry_Value_Type_Struct:
/* Do nothing (later will print a warning) */
return 0;
case Dictionary_Entry_Value_Type_List:
/* returns the first element as an unsigned int */
if (self->as.typeList->first) {
return Dictionary_Entry_Value_AsUnsignedInt( self->as.typeList->first );
} else {
return 0;
}
case Dictionary_Entry_Value_Type_String:
return strtoul( self->as.typeString, 0, 0 );
case Dictionary_Entry_Value_Type_Double:
return (unsigned int)self->as.typeDouble;
case Dictionary_Entry_Value_Type_UnsignedInt:
return self->as.typeUnsignedInt;
case Dictionary_Entry_Value_Type_UnsignedLong:
return self->as.typeUnsignedLong;
case Dictionary_Entry_Value_Type_Bool:
return (unsigned int)self->as.typeBool;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type );
}
}
return 0;
}
unsigned int _Stg_ComponentFactory_GetUnsignedInt( void* cf, Name componentName, Dictionary_Entry_Key key, unsigned int defaultVal ) {
unsigned int retVal;
retVal = Dictionary_Entry_Value_AsUnsignedInt(
_Stg_ComponentFactory_GetNumericalValue( cf, componentName, key,
Dictionary_Entry_Value_FromUnsignedInt( defaultVal )));
/* TODO : Possible memory leak if defaultVal not added to the dictionary */
return retVal;
}
int Dictionary_GetUnsignedInt_WithDefault(
Dictionary* dictionary,
Dictionary_Entry_Key key,
const unsigned int defaultVal )
{
return Dictionary_Entry_Value_AsUnsignedInt(
Dictionary_GetDefault(
dictionary, key, Dictionary_Entry_Value_FromUnsignedInt( defaultVal ) ) );
}
Dictionary_Entry_Value* Dictionary_Entry_Value_FromStringTo( char* string, char type ) {
Dictionary_Entry_Value* retValue = Memory_Alloc( Dictionary_Entry_Value, "Return Value" );
/* need to create the value temporarily so it can be converted if necessary */
retValue->type = Dictionary_Entry_Value_Type_String;
if ( string ) {
retValue->as.typeString = ExpandEnvironmentVariables( string );
}
else {
retValue->as.typeString = string;
}
switch (type) {
case Dictionary_Entry_Value_Type_String:
Dictionary_Entry_Value_InitFromString( retValue, retValue->as.typeString );
break;
case Dictionary_Entry_Value_Type_Double:
Dictionary_Entry_Value_InitFromDouble( retValue, Dictionary_Entry_Value_AsDouble( retValue ) );
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
Dictionary_Entry_Value_InitFromUnsignedInt( retValue, Dictionary_Entry_Value_AsUnsignedInt( retValue ) );
break;
case Dictionary_Entry_Value_Type_Int:
Dictionary_Entry_Value_InitFromInt( retValue, Dictionary_Entry_Value_AsInt( retValue ) );
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
Dictionary_Entry_Value_InitFromUnsignedLong( retValue, Dictionary_Entry_Value_AsUnsignedLong( retValue ) );
break;
case Dictionary_Entry_Value_Type_Bool:
Dictionary_Entry_Value_InitFromBool( retValue, Dictionary_Entry_Value_AsBool( retValue ) );
break;
case Dictionary_Entry_Value_Type_Struct:
Dictionary_Entry_Value_InitNewStruct( retValue );
break;
case Dictionary_Entry_Value_Type_List:
Dictionary_Entry_Value_InitNewList( retValue );
break;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: type '%d' is invalid.\n", __func__, type );
}
}
return retValue;
}
void Dictionary_Entry_Value_SetFromStringKeepCurrentType( Dictionary_Entry_Value* self, char* string ) {
Dictionary_Entry_Value_Type currType = self->type;
Dictionary_Entry_Value_DeleteContents( self );
self->type = Dictionary_Entry_Value_Type_String;
self->as.typeString = string;
switch (currType) {
case Dictionary_Entry_Value_Type_String:
Dictionary_Entry_Value_SetValueString( self, string );
break;
case Dictionary_Entry_Value_Type_Double:
Dictionary_Entry_Value_SetValueDouble( self, Dictionary_Entry_Value_AsDouble( self ) );
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
Dictionary_Entry_Value_SetValueUnsignedInt( self, Dictionary_Entry_Value_AsUnsignedInt( self ) );
break;
case Dictionary_Entry_Value_Type_Int:
Dictionary_Entry_Value_SetValueInt( self, Dictionary_Entry_Value_AsInt( self ) );
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
Dictionary_Entry_Value_SetValueUnsignedLong( self, Dictionary_Entry_Value_AsUnsignedLong( self ) );
break;
case Dictionary_Entry_Value_Type_Bool:
Dictionary_Entry_Value_SetValueBool( self, Dictionary_Entry_Value_AsBool( self ) );
break;
case Dictionary_Entry_Value_Type_Struct:
Dictionary_Entry_Value_SetValueNewStruct( self );
break;
case Dictionary_Entry_Value_Type_List:
Dictionary_Entry_Value_SetValueNewList( self );
break;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type );
}
}
}
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 );
}
}
Bool Stg_ComponentFactory_TryUnsignedInt( void* cf, Name componentName, Dictionary_Entry_Key key, unsigned int* value ) {
Dictionary_Entry_Value* dict_value = _Stg_ComponentFactory_GetNumericalValue( cf, componentName, key, NULL);
if (!dict_value) return False;
*value = Dictionary_Entry_Value_AsUnsignedInt(dict_value);
return True;
}
void _MeshGenerator_AssignFromXML( void* meshGenerator, Stg_ComponentFactory* cf, void* data ) {
MeshGenerator* self = (MeshGenerator*)meshGenerator;
Dictionary* dict;
unsigned nDims;
Dictionary_Entry_Value* meshList;
Dictionary_Entry_Value *enabledDimsList, *enabledIncList;
Mesh* mesh;
Bool partitioned;
assert( self );
assert( cf );
/* Rip out the components structure as a dictionary. */
dict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, (Dictionary_Entry_Key)self->name ) );
/* Set the communicator to a default. */
partitioned = Stg_ComponentFactory_GetBool( cf, self->name, (Dictionary_Entry_Key)"partitioned", 1 );
if( partitioned ) {
MeshGenerator_SetMPIComm( self, MPI_COMM_WORLD );
}
else {
MeshGenerator_SetMPIComm( self, MPI_COMM_SELF );
}
self->context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", AbstractContext, False, data );
if( !self->context )
self->context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", AbstractContext, False, data );
/* Read the individual mesh if specified. */
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"mesh", Mesh, False, data );
if( mesh )
MeshGenerator_AddMesh( self, mesh );
/* Read the mesh list, if it's there. */
meshList = Dictionary_Get( dict, (Dictionary_Entry_Key)"meshes" );
if( meshList ) {
unsigned nMeshes;
char* name;
unsigned m_i;
nMeshes = Dictionary_Entry_Value_GetCount( meshList );
for( m_i = 0; m_i < nMeshes; m_i++ ) {
Mesh* mesh;
name = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( meshList, m_i ) );
mesh = Stg_ComponentFactory_ConstructByName( cf, (Name)name, Mesh, True, data );
MeshGenerator_AddMesh( self, mesh );
}
}
/* Read dimensions and state. */
nDims = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"dim", 2 );
nDims = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"dims", nDims );
MeshGenerator_SetDimSize( self, nDims );
enabledDimsList = Dictionary_Get( dict, (Dictionary_Entry_Key)"enabledDims" );
enabledIncList = Dictionary_Get( dict, (Dictionary_Entry_Key)"enabledIncidence" );
/* Clear dims/incidence flags */
unsigned d_i;
memset( self->enabledDims, 0, (nDims + 1) * sizeof(Bool) );
for( d_i = 0; d_i <= nDims; d_i++ )
memset( self->enabledInc[d_i], 0, (nDims + 1) * sizeof(Bool) );
if( enabledDimsList ) {
unsigned dim;
unsigned nEnabledDims;
nEnabledDims = Dictionary_Entry_Value_GetCount( enabledDimsList );
for( d_i = 0; d_i < nEnabledDims; d_i++ ) {
dim = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_Entry_Value_GetElement( enabledDimsList, d_i ) );
if (dim > nDims)
Journal_Printf(Mesh_Warning, "Warning - in %s: *** Skipping out of range dimension: %d\n", __func__, dim);
else
MeshGenerator_SetDimState( self, dim, True );
}
}
else
{
/* Default to all dimensions enabled */
for( d_i = 0; d_i < nDims + 1; d_i++ )
MeshGenerator_SetDimState( self, d_i, True );
}
if( enabledIncList ) {
unsigned nEnabledInc;
unsigned fromDim, toDim;
nEnabledInc = Dictionary_Entry_Value_GetCount( enabledIncList );
assert( nEnabledInc % 2 == 0 );
for( d_i = 0; d_i < nEnabledInc; d_i += 2 ) {
fromDim = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_Entry_Value_GetElement( enabledIncList, d_i ) );
toDim = Dictionary_Entry_Value_AsUnsignedInt( Dictionary_Entry_Value_GetElement( enabledIncList, d_i + 1 ) );
if (fromDim > nDims || toDim > nDims)
Journal_Printf( Mesh_Warning, "Warning - in %s: *** Skipping out of range incidence: %d to %d\n",
__func__ , fromDim, toDim);
else
MeshGenerator_SetIncidenceState( self, fromDim, toDim, True );
}
}
else
{
/* Default incidence setup 0->1,2,3 1->0,2 2->0,1 3->0,3 */
MeshGenerator_SetIncidenceState( self, 0, 0, True );
for( d_i = 1; d_i <= nDims; d_i ++ ) {
MeshGenerator_SetIncidenceState( self, 0, d_i, True );
MeshGenerator_SetIncidenceState( self, d_i, 0, True );
}
if (nDims == 2) {
MeshGenerator_SetIncidenceState( self, 1, 2, True );
MeshGenerator_SetIncidenceState( self, 2, 1, True );
MeshGenerator_SetIncidenceState( self, 2, 2, True );
}
if( nDims == 3 )
MeshGenerator_SetIncidenceState( self, 3, 3, True );
}
}
Bool Dictionary_Entry_Value_CompareFull( Dictionary_Entry_Value* self, Dictionary_Entry_Value* dev, Bool strictTypeCheck ) {
Bool retValue = True;
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
if ( strictTypeCheck ) {
if ( self->type != dev->type ) {
return False;
}
}
switch( self->type ) {
case Dictionary_Entry_Value_Type_String: {
/* Comparing as strings is tricky. When both are strings it's fine. If the dev to compare to is stored
* natively as a number, we should convert the first to a number also for comparison. Otherwise, you
* can get false Negatives when the entries are numerically the same, but use different notation
* (e.g. scientific vs decimal) */
switch( dev->type ) {
case Dictionary_Entry_Value_Type_String:
if ( 0 != strcmp( self->as.typeString, dev->as.typeString ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Double:
if ( dev->as.typeDouble != Dictionary_Entry_Value_AsDouble( self ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
if ( dev->as.typeUnsignedInt != Dictionary_Entry_Value_AsUnsignedInt( self ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Int:
if ( dev->as.typeInt != Dictionary_Entry_Value_AsInt( self ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
if ( dev->as.typeUnsignedLong != Dictionary_Entry_Value_AsUnsignedLong( self ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Bool:
if ( dev->as.typeBool != Dictionary_Entry_Value_AsBool( self ) )
case Dictionary_Entry_Value_Type_Struct:
case Dictionary_Entry_Value_Type_List:
retValue = False;
break;
default:
Journal_Firewall( False, errorStream, "In func %s: dev->type '%d' is invalid.\n", __func__, dev->type );
}
break;
}
case Dictionary_Entry_Value_Type_Double:
if ( self->as.typeDouble != Dictionary_Entry_Value_AsDouble( dev ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
if ( self->as.typeUnsignedInt != Dictionary_Entry_Value_AsUnsignedInt( dev ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Int:
if ( self->as.typeInt != Dictionary_Entry_Value_AsInt( dev ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
if ( self->as.typeUnsignedLong != Dictionary_Entry_Value_AsUnsignedLong( dev ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Bool:
if ( self->as.typeBool != Dictionary_Entry_Value_AsBool( dev ) )
retValue = False;
break;
case Dictionary_Entry_Value_Type_Struct:
if ( dev->type != Dictionary_Entry_Value_Type_Struct ) {
retValue = False;
break;
}
retValue = Dictionary_CompareAllEntriesFull( self->as.typeStruct, dev->as.typeStruct, strictTypeCheck );
break;
case Dictionary_Entry_Value_Type_List: {
Dictionary_Entry_Value* cur1 = NULL;
Dictionary_Entry_Value* cur2 = NULL;
if ( dev->type != Dictionary_Entry_Value_Type_List ) {
retValue = False;
break;
}
if ( self->as.typeList->count != dev->as.typeList->count ) {
retValue = False;
break;
}
cur1 = self->as.typeList->first;
cur2 = dev->as.typeList->first;
while ( cur1 ) {
retValue = Dictionary_Entry_Value_CompareFull( cur1, cur2, strictTypeCheck );
if ( retValue == False ) break;
cur1 = cur1->next;
cur2 = cur2->next;
}
break;
}
default:
Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type );
};
return retValue;
}
void _SnacRemesher_ConstructExtensions( void* _context, void* data ) {
Snac_Context* context = (Snac_Context*)_context;
SnacRemesher_Context* contextExt = ExtensionManager_Get(
context->extensionMgr,
context,
SnacRemesher_ContextHandle );
Mesh* mesh = context->mesh;
SnacRemesher_Mesh* meshExt = ExtensionManager_Get(
context->meshExtensionMgr,
mesh,
SnacRemesher_MeshHandle );
char* conditionStr;
Dictionary_Entry_Value* conditionCriterion;
Dictionary* meshDict;
Stream* error = Journal_Register( Error_Type, "Remesher" );
char tmpBuf[PATH_MAX];
Journal_Printf( context->debug, "In: %s\n", __func__ );
contextExt->debugIC = Journal_Register( Debug_Type, "Remesher-ICs" );
contextExt->debugCoords = Journal_Register( Debug_Type, "Remesher-Coords" );
contextExt->debugNodes = Journal_Register( Debug_Type, "Remesher-Nodes" );
contextExt->debugElements = Journal_Register( Debug_Type, "Remesher-Elements" );
contextExt->debugSync = Journal_Register( Debug_Type, "Remesher-Sync" );
/* Additional tables required over the nodeElementTbl already required by core Snac */
Mesh_ActivateNodeNeighbourTbl( mesh );
Mesh_ActivateElementNeighbourTbl( mesh );
/* Work out condition to remesh on */
if( !Dictionary_Get( context->dictionary, CONDITION_STR ) ) {
Journal_Printf(
error,
"Warning: No \"%s\" entry in dictionary... will default to \"%s\"\n",
CONDITION_STR,
OFF_STR );
}
conditionStr = Dictionary_Entry_Value_AsString(
Dictionary_GetDefault( context->dictionary, CONDITION_STR, Dictionary_Entry_Value_FromString( OFF_STR ) ) );
contextExt->OnTimeStep = 0;
contextExt->onMinLengthScale = 0;
if( !strcmp( conditionStr, OFF_STR ) ) {
contextExt->condition = SnacRemesher_Off;
Journal_Printf( context->snacInfo, "Remesher is off\n" );
}
else if( !strcmp( conditionStr, ONTIMESTEP_STR ) ) {
contextExt->condition = SnacRemesher_OnTimeStep;
conditionCriterion = Dictionary_Get( context->dictionary, TIMESTEPCRITERION_STR );
Journal_Printf( context->snacInfo, "Remesher is on... activated based on timeStep\n" );
if( conditionCriterion ) {
contextExt->OnTimeStep = Dictionary_Entry_Value_AsUnsignedInt( conditionCriterion );
}
else {
}
Journal_Printf( context->snacInfo, "Remeshing every %u timeSteps\n", contextExt->OnTimeStep );
}
else if( !strcmp( conditionStr, ONMINLENGTHSCALE_STR ) ) {
contextExt->condition = SnacRemesher_OnMinLengthScale;
conditionCriterion = Dictionary_Get( context->dictionary, LENGTHCRITERION_STR );
Journal_Printf( context->snacInfo, "Remesher is on... activated by minLengthScale\n" );
if( conditionCriterion ) {
contextExt->onMinLengthScale = Dictionary_Entry_Value_AsDouble( conditionCriterion );
}
else {
}
Journal_Printf( context->snacInfo, "Remesh when minLengthScale < %g\n", contextExt->onMinLengthScale );
}
else if( !strcmp( conditionStr, ONBOTHTIMESTEPLENGTH_STR ) ) {
contextExt->condition = SnacRemesher_OnBothTimeStepLength;
conditionCriterion = Dictionary_Get( context->dictionary, TIMESTEPCRITERION_STR );
Journal_Printf( context->snacInfo, "Remesher is on... activated by both timeStep and minLengthScale\n" );
if( conditionCriterion ) {
contextExt->OnTimeStep = Dictionary_Entry_Value_AsUnsignedInt( conditionCriterion );
conditionCriterion = Dictionary_Get( context->dictionary, LENGTHCRITERION_STR );
contextExt->onMinLengthScale = Dictionary_Entry_Value_AsDouble( conditionCriterion );
}
else {
}
Journal_Printf( context->snacInfo, "Remesh every %u timeSteps or wheen minLengthScale < %g\n", contextExt->OnTimeStep, contextExt->onMinLengthScale );
}
else {
contextExt->condition = SnacRemesher_Off;
Journal_Printf( context->snacInfo, "Remesher is defaulting to off\n" );
Journal_Printf( error, "Provided remesh condition \"%s\" unrecognised\n", conditionStr );
}
/* Work out the mesh type */
meshDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( context->dictionary, MESH_STR ) );
if( meshDict ) {
char* meshTypeStr;
if( !Dictionary_Get( meshDict, MESHTYPE_STR ) ) {
Journal_Printf(
error,
"Warning: No \"%s\" entry in \"%s\"... will default to \"%s\"\n",
MESHTYPE_STR,
MESH_STR,
CARTESIAN_STR );
}
meshTypeStr = Dictionary_Entry_Value_AsString(
Dictionary_GetDefault( meshDict, MESHTYPE_STR, Dictionary_Entry_Value_FromString( CARTESIAN_STR ) ) );
if( !strcmp( meshTypeStr, SPHERICAL_STR ) ) {
meshExt->meshType = SnacRemesher_Spherical;
Journal_Printf( context->snacInfo, "Remesher knows mesh as a spherical mesh\n" );
}
else if( !strcmp( meshTypeStr, CARTESIAN_STR ) ) {
meshExt->meshType = SnacRemesher_Cartesian;
Journal_Printf( context->snacInfo, "Remesher knows mesh as a cartesian mesh\n" );
}
else {
meshExt->meshType = SnacRemesher_Cartesian;
Journal_Printf( context->snacInfo, "Remesher assuming mesh as a cartesian mesh\n" );
Journal_Printf( error, "Provided mesh type \"%s\" unrecognised!\n", meshTypeStr );
}
}
else {
meshExt->meshType = SnacRemesher_Cartesian;
Journal_Printf( context->snacInfo, "Remesher assuming mesh as a cartesian mesh\n" );
Journal_Printf( error, "No \"%s\" entry in dictionary!\n", MESH_STR );
}
/* Decide whether to restore the bottom surface */
contextExt->bottomRestore = 0;
if( !strcmp( Dictionary_Entry_Value_AsString( Dictionary_GetDefault( context->dictionary, "bottomRestore", Dictionary_Entry_Value_FromString( OFF_STR ) ) ), ON_STR) )
contextExt->bottomRestore = 1;
/* Register these functions for use in VCs */
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacRemesher_TestCondFunc, "SnacRemesher_TestCondFunc" ) );
/* Register these functions for use in VCs */
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacRemesher_XFunc, "SnacRemesher_XFunc" ) );
/* Register these functions for use in VCs */
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacRemesher_YFunc, "SnacRemesher_YFunc" ) );
/* Obtain the keys for the our new entry points... having the keys saves doing a string compare at run time */
contextExt->recoverNodeK = EntryPoint_Register_GetHandle(
context->entryPoint_Register,
SnacRemesher_EP_RecoverNode );
contextExt->interpolateNodeK = EntryPoint_Register_GetHandle(
context->entryPoint_Register,
SnacRemesher_EP_InterpolateNode );
contextExt->interpolateElementK = EntryPoint_Register_GetHandle(
context->entryPoint_Register,
SnacRemesher_EP_InterpolateElement );
/* Prepare the dump file */
if( context->rank == 0) {
sprintf( tmpBuf, "%s/remeshInfo.%u", context->outputPath, context->rank );
if( (contextExt->remesherOut = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->remesherOut /* failed to open file for writing */ );
}
}
/* initialize remeshing counter */
contextExt->remeshingCount = 0;
}
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 );
}
}
