void _RSGenerator_AssignFromXML( void* meshGenerator, Stg_ComponentFactory* cf, void* data )
{
RSGenerator* self = (RSGenerator*)meshGenerator;
FiniteElementContext* context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", FiniteElementContext, True, NULL );
Dictionary* dict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, (Dictionary_Entry_Key)self->name ) );
Dictionary_Entry_Value *minList, *maxList, *tmp;
char* rootKey;
unsigned d_i;
double maxVal;
_CartesianGenerator_AssignFromXML( meshGenerator, cf, data );
// mesh min/max coords are written to file from the mesh->min/maxGlobalCoord field. these differ from the min/max
// coords as defined in the RSGenerator->min/maxCrd (these are in r-theta-phi, not x-y-z), so if we're restarting
// we need to over-ride the coords from the hdf5 mesh file with those from the xml (assuming they don't differ
// between runs...
if( self->nDims > 2 ) {
if( context->loadFromCheckPoint ) {
minList = Dictionary_Get( dict, (Dictionary_Entry_Key)"minCoord" );
maxList = Dictionary_Get( dict, (Dictionary_Entry_Key)"maxCoord" );
if( minList && maxList ) {
assert( Dictionary_Entry_Value_GetCount( minList ) >= self->nDims );
assert( Dictionary_Entry_Value_GetCount( maxList ) >= self->nDims );
for( d_i = 0; d_i < self->nDims; d_i++ ) {
tmp = Dictionary_Entry_Value_GetElement( minList, d_i );
rootKey = Dictionary_Entry_Value_AsString( tmp );
if( !Stg_StringIsNumeric( (char*)rootKey ) )
tmp = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)rootKey );
self->crdMin[d_i] = Dictionary_Entry_Value_AsDouble( tmp );
tmp = Dictionary_Entry_Value_GetElement( maxList, d_i );
rootKey = Dictionary_Entry_Value_AsString( tmp );
if( !Stg_StringIsNumeric( (char*)rootKey ) )
tmp = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)rootKey );
self->crdMax[d_i] = Dictionary_Entry_Value_AsDouble( tmp );
/* test to ensure provided domain is valid */
maxVal = (abs(self->crdMax[d_i]) > abs(self->crdMin[d_i])) ? abs(self->crdMax[d_i]) : abs(self->crdMin[d_i]);
if( maxVal == 0 ) maxVal = 1; /* if maxVal is zero, then both numbers must be zero, set to one as next test will fail */
Journal_Firewall( ( ( (self->crdMax[d_i] - self->crdMin[d_i])/maxVal) > 1E-10 || d_i==J_AXIS), global_error_stream,
"\n\nError in %s for %s '%s'\n\n"
"Dimension of domain (min = %f, max = %f) for component number %u is not valid.\n\n",
__func__, self->type, self->name, self->crdMin[d_i], self->crdMax[d_i], d_i );
}
}
}
// phi = (pi/2, pi)
Journal_Firewall( !(fabs(self->crdMin[2] -self->crdMax[2])>=179.99 || self->crdMax[2] < self->crdMin[2]),
global_error_stream, "\nError in %s: Phi definition is wrong. Ensure minZ < maxZ & abs(minZ-maxZ)<180\n", __func__);
}
Journal_Firewall( self->nDims==3, global_error_stream,
"Error in %s: Must have 3 dimensions for component %s\n", __func__, self->name );
// check domain size is valid
Journal_Firewall( !(self->crdMin[0] <= 0 || self->crdMax[0] < self->crdMin[0]), global_error_stream,
"Error in %s: Radius definition is wrong. Ensure maxX > minX & minX > 0\n", __func__ );
Journal_Firewall(!( fabs(self->crdMin[1]-self->crdMax[1]) >= 179.99 || self->crdMax[1] < self->crdMin[1] ),
global_error_stream, "Error in %s: Theta definition is wrong. Ensure minY < maxY && abs(minY-maxY) < 180\n", __func__ );
}
void _Geothermal_DepthMap_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data ) {
Geothermal_DepthMap* self = (Geothermal_DepthMap*)component;
Dictionary* dictionary = Codelet_GetPluginDictionary( component, cf->rootDict );
Stream* errorStream = Journal_Register( ErrorStream_Type, Geothermal_DepthMap_Type );
Stream_SetPrintingRank( errorStream, 0 );
Journal_Printf( errorStream, "WARNING: \"DepthMap\" plugin is depricated, use \"FieldMap\" plugin instead" );
self->swarm = Stg_ComponentFactory_ConstructByName(
cf, Dictionary_GetString( dictionary, "Swarm" ), Swarm, True, data );
self->context = (AbstractContext*)Stg_ComponentFactory_ConstructByName(
cf, "context", UnderworldContext, True, data );
self->depth = Dictionary_GetDouble_WithDefault( dictionary, (Dictionary_Entry_Key)"DepthFromSurface", 0.0 );
self->outputPath = Dictionary_GetString_WithDefault( dictionary, (Dictionary_Entry_Key)"outputPath", "./output" );
self->outputAllNodes = Dictionary_GetBool_WithDefault( dictionary, (Dictionary_Entry_Key)"OutputAllNodes", False );
self->outputTopNodes = Dictionary_GetBool_WithDefault( dictionary, (Dictionary_Entry_Key)"OutputTopNodes", False );
self->gocadOutput = Dictionary_GetBool_WithDefault( dictionary, (Dictionary_Entry_Key)"GOCADOutput", True );
self->outputPath = Dictionary_Entry_Value_AsString( Dictionary_Get( dictionary, "outputPath" ) );
self->field = Stg_ComponentFactory_ConstructByName(
cf, Dictionary_GetString( dictionary, "Field" ), FeVariable, True, data );
ContextEP_Append( self->context, AbstractContext_EP_Dump, Geothermal_DepthMap_Dump );
}
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", "" ) );
}
char* Dictionary_GetString_WithDefault(
Dictionary* dictionary,
Dictionary_Entry_Key key,
const char* const defaultVal )
{
return Dictionary_Entry_Value_AsString(
Dictionary_GetDefault(
dictionary, key, Dictionary_Entry_Value_FromString( defaultVal ) ) );
}
void Dictionary_Entry_Value_Print( Dictionary_Entry_Value* self, Stream* stream ) {
Dictionary_Index index;
if( !self ) {
return;
}
switch( self->type ) {
case Dictionary_Entry_Value_Type_String:
Journal_Printf( stream, "\"%s\"", self->as.typeString );
return;
case Dictionary_Entry_Value_Type_Double:
Journal_Printf( stream, "%g", self->as.typeDouble );
return;
case Dictionary_Entry_Value_Type_UnsignedInt:
Journal_Printf( stream, "%u", self->as.typeUnsignedInt );
return;
case Dictionary_Entry_Value_Type_Int:
Journal_Printf( stream, "%d", self->as.typeInt );
return;
case Dictionary_Entry_Value_Type_UnsignedLong:
Journal_Printf( stream, "%ld", self->as.typeUnsignedLong );
return;
case Dictionary_Entry_Value_Type_Bool:
Journal_Printf( stream, "%s", Dictionary_Entry_Value_AsString( self ) );
return;
case Dictionary_Entry_Value_Type_List:
if (self->as.typeList->first) {
Dictionary_Entry_Value* cur = self->as.typeList->first;
Dictionary_Entry_Value_Print( cur, stream );
cur = cur->next;
while (cur) {
Journal_Printf( stream, ", " );
Dictionary_Entry_Value_Print( cur, stream );
cur = cur->next;
}
}
return;
case Dictionary_Entry_Value_Type_Struct:
Stream_Indent( stream );
for( index = 0; index < self->as.typeStruct->count; index++ ) {
Journal_Printf( stream, "\n");
Journal_Printf( stream, "%s: ", self->as.typeStruct->entryPtr[index]->key );
Dictionary_Entry_Value_Print( self->as.typeStruct->entryPtr[index]->value, stream );
}
Stream_UnIndent( stream );
return;
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 );
}
}
}
Dictionary_Entry_Value* _Dictionary_GetDouble_WithScopeDefault(
Dictionary* dictionary,
Dictionary_Entry_Key key,
Dictionary_Entry_Value* defaultVal )
{
Dictionary_Entry_Value *returnVal=NULL;
Bool usedDefault = False;
Stream* stream = Journal_Register( Info_Type, "Dictionary" );
returnVal = Dictionary_GetDefault( dictionary, key, defaultVal );
if( returnVal && returnVal->type == Dictionary_Entry_Value_Type_String ) {
Dictionary_Entry_Key rootDictKey = Dictionary_Entry_Value_AsString( returnVal );
Dictionary* rootDict = dictionary;
/* Check if the number really is a string or not */
if( Stg_StringIsNumeric( rootDictKey ) )
return returnVal;
Journal_PrintfL(
stream,
2,
"Key '%s' points to key '%s' in the root dictionary: ",
key,
rootDictKey );
/* Get Value from dictionary */
returnVal = Dictionary_Get( rootDict, rootDictKey );
if( !returnVal && defaultVal ) {
returnVal = Dictionary_GetDefault( rootDict, rootDictKey, defaultVal );
usedDefault = True;
}
/* Print Stuff */
if( usedDefault ) {
Journal_PrintfL( stream, 2, "Using default value = " );
if( Stream_IsPrintableLevel( stream, 2 ) )
Dictionary_Entry_Value_Print( returnVal, stream );
Journal_PrintfL( stream, 2, "\n" );
return returnVal;
}
else if( returnVal ) {
Journal_PrintfL( stream, 2, "Found - Value = " );
if( Stream_IsPrintableLevel( stream, 2 ) )
Dictionary_Entry_Value_Print( returnVal, stream );
Journal_PrintfL( stream, 2, "\n" );
}
else
Journal_PrintfL( stream, 2, "Not found.\n" );
}
return returnVal;
}
Dictionary_Entry_Value* _Stg_ComponentFactory_PluginGetNumericalValue( void* cf, void *codelet, Dictionary_Entry_Key key, Dictionary_Entry_Value* defaultVal ) {
Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf;
Dictionary_Entry_Value* returnVal;
Bool usedDefault = False;
Stream* stream = self->infoStream;
Stream* errorStream = Journal_Register( Error_Type, self->type );
Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_Component is NULL.\n", __func__ );
returnVal = _Stg_ComponentFactory_PluginGetDictionaryValue( self, codelet, key, defaultVal );
/* Check to see whether the type is a string -
* if it is then assume that this is a dictionary key linking to the root dictionary */
if ( returnVal ) {
Dictionary_Entry_Key rootDictKey = Dictionary_Entry_Value_AsString( returnVal );
Dictionary* rootDict = self->rootDict;
/* Check if the number really is a string or not */
if ( Stg_StringIsNumeric( rootDictKey ) )
return returnVal;
Journal_PrintfL( stream, 2, "Key '%s' points to key '%s' in the root dictionary: ", key, rootDictKey );
Journal_Firewall( rootDict != NULL, errorStream, "Root Dictionary NULL in component factory.\n" );
/* Get Value from dictionary */
returnVal = Dictionary_Get( rootDict, rootDictKey );
if ( !returnVal && defaultVal ) {
returnVal = Dictionary_GetDefault( rootDict, rootDictKey, defaultVal );
usedDefault = True;
}
/* Print Stuff */
if ( usedDefault ) {
Journal_PrintfL( stream, 2, "Using default value = " );
if ( Stream_IsPrintableLevel( stream, 2 ) )
Dictionary_Entry_Value_Print( returnVal, stream );
Journal_PrintfL( stream, 2, "\n" );
return returnVal;
}
else if ( returnVal ) {
Journal_PrintfL( stream, 2, "Found - Value = " );
if ( Stream_IsPrintableLevel( stream, 2 ) )
Dictionary_Entry_Value_Print( returnVal, stream );
Journal_PrintfL( stream, 2, "\n" );
}
else
Journal_PrintfL( stream, 2, "Not found.\n" );
}
return returnVal;
}
Stg_Component* _Stg_ComponentFactory_PluginConstructByKey(
void* cf,
void* codelet,
Dictionary_Entry_Key componentKey,
Type type,
Bool isEssential,
void* data )
{
Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf;
Stg_Component* plugin = (Stg_Component*)codelet;
Dictionary* thisPluginDict = NULL;
Dictionary* pluginDict = (Dictionary*)Dictionary_Get( self->rootDict, "plugins" );
Name componentName, redirect, pluginType;
Dictionary_Entry_Value* componentEntryVal;
Index pluginIndex;
Stream* errorStream = Journal_Register( Error_Type, self->type );
Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_Component is NULL.\n", __func__ );
/* Get this plugins Dictionary */
for( pluginIndex = 0; pluginIndex < Dictionary_Entry_Value_GetCount( (Dictionary_Entry_Value*)pluginDict ); pluginIndex++ ) {
thisPluginDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Entry_Value_GetElement( (Dictionary_Entry_Value*)pluginDict, pluginIndex ) );
pluginType = StG_Strdup( Dictionary_GetString( thisPluginDict, "Type" ) );
if( !strcmp( plugin->type, pluginType ) ){
Memory_Free( pluginType );
break;
}
Memory_Free( pluginType );
}
/* Get Dependency's Name */
componentEntryVal = Dictionary_Get( thisPluginDict, componentKey );
if ( componentEntryVal == NULL ) {
Journal_Firewall( !isEssential, errorStream,
"plugin '%s' cannot find essential component with key '%s'.\n", plugin->type, componentKey );
Journal_PrintfL( self->infoStream, 2, "plugin '%s' cannot find non-essential component with key '%s'.\n", plugin->type, componentKey );
return NULL;
}
componentName = Dictionary_Entry_Value_AsString( componentEntryVal );
/* If we can find the component's name in the root dictionary, use that value instead. */
if( self->rootDict ) {
redirect = Dictionary_GetString_WithDefault( self->rootDict, componentName, "" );
if( strcmp( redirect, "" ) )
componentName = redirect;
}
return self->constructByName( self, componentName, type, isEssential, data );
}
void _PeriodicBoundariesManager_Build( void* periodicBCsManager, void* data ) {
PeriodicBoundariesManager* self = (PeriodicBoundariesManager*)periodicBCsManager;
Dictionary_Entry_Value* periodicBCsList = NULL;
Stg_Component_Build( self->swarm, data, False );
Stg_Component_Build( self->mesh, data, False );
self->size = 4;
self->boundaries = Memory_Alloc_Array( PeriodicBoundary, self->size, "PeriodicBoundariesManager->boundaries" );
if ( self->dictionary ) {
periodicBCsList = Dictionary_Get( self->dictionary, (Dictionary_Entry_Key)"PeriodicBoundaries" );
/* Dictionary entry is optional - users may prefer to enter in code */
if ( periodicBCsList ) {
Index numPeriodicBCs = 0;
Index periodicBC_I = 0;
Dictionary_Entry_Value* periodicBC = NULL;
char* perBCAxis = NULL;
numPeriodicBCs = Dictionary_Entry_Value_GetCount( periodicBCsList );
for ( periodicBC_I = 0; periodicBC_I < numPeriodicBCs; periodicBC_I++ ) {
periodicBC = Dictionary_Entry_Value_GetElement( periodicBCsList, periodicBC_I );
perBCAxis = Dictionary_Entry_Value_AsString( periodicBC );
if ( 0 == strcmp( perBCAxis, "I_AXIS" ) ) {
PeriodicBoundariesManager_AddPeriodicBoundary( self, I_AXIS );
}
else if ( 0 == strcmp( perBCAxis, "J_AXIS" ) ) {
PeriodicBoundariesManager_AddPeriodicBoundary( self, J_AXIS );
}
else if ( 0 == strcmp( perBCAxis, "K_AXIS" ) ) {
PeriodicBoundariesManager_AddPeriodicBoundary( self, K_AXIS );
}
}
}
}
/* Test if mesh is periodic */
else if ( Stg_Class_IsInstance( self->mesh->generator, CartesianGenerator_Type ) ) {
CartesianGenerator* cartesianGenerator = (CartesianGenerator*) self->mesh->generator;
Dimension_Index dim_I;
for ( dim_I = 0 ; dim_I < self->swarm->dim ; dim_I++ ) {
/* Add boundaries straight from mesh generator */
if ( cartesianGenerator->periodic[ dim_I ] )
PeriodicBoundariesManager_AddPeriodicBoundary( self, dim_I );
}
}
}
char* Dictionary_Entry_Value_AsString( Dictionary_Entry_Value* self ) {
static char buf[256];
if( !self ) {
strcpy( buf, "" );
return buf;
}
switch( self->type ) {
case Dictionary_Entry_Value_Type_Struct:
strcpy( buf, "" );
return buf;
case Dictionary_Entry_Value_Type_List:
/* returns the first element as a string */
if (self->as.typeList->first) {
return Dictionary_Entry_Value_AsString( self->as.typeList->first );
} else {
return 0;
}
case Dictionary_Entry_Value_Type_String:
return self->as.typeString;
case Dictionary_Entry_Value_Type_Double:
sprintf( buf, "%g", self->as.typeDouble );
return buf;
case Dictionary_Entry_Value_Type_UnsignedInt:
sprintf( buf, "%u", self->as.typeUnsignedInt );
return buf;
case Dictionary_Entry_Value_Type_Int:
sprintf( buf, "%d", self->as.typeInt );
return buf;
case Dictionary_Entry_Value_Type_UnsignedLong:
sprintf( buf, "%ld", self->as.typeUnsignedLong );
return buf;
case Dictionary_Entry_Value_Type_Bool:
if (True == self->as.typeBool) {
sprintf( buf, "true" );
}
else if (False == self->as.typeBool) {
sprintf( buf, "false" );
}
return buf;
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 buf;
}
Stg_Component* _Stg_ComponentFactory_ConstructByKey(
void* cf,
Name parentComponentName,
Dictionary_Entry_Key componentKey,
Type type,
Bool isEssential,
void* data )
{
Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf;
Dictionary* thisComponentDict = NULL;
Dictionary* componentDict = NULL;
Name componentName, redirect;
Dictionary_Entry_Value* componentEntryVal;
Stream* errorStream = Journal_Register( Error_Type, self->type );
Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_Component is NULL.\n", __func__ );
/* Get this Stg_Component's Dictionary */
componentDict = self->componentDict;
Journal_Firewall( componentDict != NULL, errorStream,
"In func %s: Stg_Component Factory's dictionary is NULL.\n", __func__ );
thisComponentDict = Dictionary_GetDictionary( componentDict, parentComponentName );
/* Get Dependency's Name */
componentEntryVal = Dictionary_Get( thisComponentDict, componentKey );
if ( componentEntryVal == NULL ) {
Journal_Firewall( !isEssential, errorStream,
"Stg_Component '%s' cannot find essential component with key '%s'.\n", parentComponentName, componentKey );
Journal_PrintfL( self->infoStream, 2, "Stg_Component '%s' cannot find non-essential component with key '%s'.\n", parentComponentName, componentKey );
return NULL;
}
componentName = Dictionary_Entry_Value_AsString( componentEntryVal );
/* If we can find the component's name in the root dictionary, use that value instead. */
if( self->rootDict ) {
redirect = Dictionary_GetString_WithDefault( self->rootDict, componentName, "" );
if( strcmp( redirect, "" ) )
componentName = redirect;
}
return self->constructByName( self, componentName, type, isEssential, data );
}
void _MeshGenerator_Construct( void* meshGenerator, Stg_ComponentFactory* cf, void* data ) {
MeshGenerator* self = (MeshGenerator*)meshGenerator;
Dictionary* dict;
Dictionary_Entry_Value* meshList;
Mesh* mesh;
assert( self );
assert( cf );
/* Rip out the components structure as a dictionary. */
dict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, self->name ) );
/* Set the communicator to a default. */
MeshGenerator_SetComm( self, MPI_COMM_WORLD );
/* Read the individual mesh if specified. */
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, "mesh", Mesh, False, data );
if( mesh )
MeshGenerator_AddMesh( self, mesh );
/* Read the mesh list, if it's there. */
meshList = Dictionary_Get( dict, "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, Mesh, True, data );
MeshGenerator_AddMesh( self, mesh );
}
}
/* Add to live component register. */
LiveComponentRegister_Add( cf->LCRegister, (Stg_Component*)self );
}
void _MeshVariable_AssignFromXML( void* meshVariable, Stg_ComponentFactory* cf, void* data ) {
MeshVariable* self = (MeshVariable*)meshVariable;
SizeT dataOffsets[] = { 0 };
StgVariable_DataType dataTypes[] = { 0 }; /* Init value later */
Index dataTypeCounts[] = { 1 };
Dictionary* componentDict = NULL;
Dictionary* thisComponentDict = NULL;
Name dataTypeName = NULL;
Name rankName = NULL;
void* variableRegister = NULL;
Name* names = NULL;
Stream* error = Journal_Register( Error_Type, (Name)self->type );
Mesh* mesh;
AbstractContext* context;
assert( self );
componentDict = cf->componentDict;
assert( componentDict );
thisComponentDict = Dictionary_GetDictionary( componentDict, self->name );
assert( thisComponentDict );
context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", AbstractContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", AbstractContext, False, data );
/* Grab Registers */
if(context)
variableRegister = context->variable_Register;
/* Construct the mesh. */
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"mesh", Mesh, True, data );
MeshVariable_SetMesh( self, mesh );
/* Get the topological element we're intereseted in. */
self->topoDim = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"topologicalDim", 0 );
/* Get Type of Variable */
dataTypeName = Dictionary_GetString( thisComponentDict, (Dictionary_Entry_Key)"DataType" );
if ( !strcasecmp( dataTypeName, "Double" ) )
dataTypes[0] = StgVariable_DataType_Double;
else if ( !strcasecmp( dataTypeName, "Float" ) )
dataTypes[0] = StgVariable_DataType_Float;
else if ( !strcasecmp( dataTypeName, "Int" ) )
dataTypes[0] = StgVariable_DataType_Int;
else if ( !strcasecmp( dataTypeName, "Char" ) )
dataTypes[0] = StgVariable_DataType_Char;
else if ( !strcasecmp( dataTypeName, "Short" ) )
dataTypes[0] = StgVariable_DataType_Short;
else
Journal_Firewall( False, error, "Variable '%s' cannot understand data type '%s'\n", self->name, dataTypeName );
/* Get Rank of Variable - i.e. Scalar or Vector */
rankName = Dictionary_GetString( thisComponentDict, (Dictionary_Entry_Key)"Rank" );
if( !strcasecmp( rankName, "Scalar" ) ){
dataTypeCounts[0] = 1;
}
else if ( !strcasecmp( rankName, "Vector" ) ){
Dictionary_Entry_Value* list;
Index nameCount = 0;
dataTypeCounts[0] = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"VectorComponentCount", nameCount );
/* Get Names from list */
if (( list = Dictionary_Get( thisComponentDict, (Dictionary_Entry_Key)"names" ) )) {
Index entry_I;
nameCount = Dictionary_Entry_Value_GetCount( list );
names = Memory_Alloc_Array( Name, nameCount, "Variable Names" );
for ( entry_I = 0 ; entry_I < nameCount ; entry_I++ )
names[ entry_I ] = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement(list, entry_I ) );
Journal_Firewall( nameCount >= dataTypeCounts[0], error, "Variable '%s' has too few names in list for %d vector components.\n", self->name, dataTypeCounts[0] );
}
}
else
Journal_Firewall( False, error, "Variable '%s' cannot understand rank '%s'\n", self->name, rankName );
_StgVariable_Init(
(StgVariable*)self,
context,
1,
dataOffsets,
dataTypes,
dataTypeCounts,
names,
0,
NULL,
_MeshVariable_GetMeshArraySize,
(void**)&self->arrayPtr,
True,
variableRegister );
/* Clean Up */
if (names)
Memory_Free(names);
}
void _FieldVariable_AssignFromXML( void* fieldVariable, Stg_ComponentFactory* cf, void* data ) {
FieldVariable* self = (FieldVariable*)fieldVariable;
FieldVariable_Register* fV_Register=NULL;
Dimension_Index dim;
Index fieldComponentCount;
Bool isCheckpointedAndReloaded, isCheckpointedAndReloaded2;
Dictionary_Entry_Value* feVarsList = NULL;
char* o_units = NULL;
DomainContext* context;
Bool useCacheMaxMin;
context = Stg_ComponentFactory_ConstructByKey(
cf,
self->name,
(Dictionary_Entry_Key)"Context",
DomainContext,
False,
data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", DomainContext, False, data );
if (context) {
fV_Register = context->fieldVariable_Register;
assert( fV_Register );
}
dim = Stg_ComponentFactory_GetRootDictUnsignedInt( cf, (Dictionary_Entry_Key)"dim", 0 );
/* allow this to be overwritten by the component dub dict */
dim = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"dim", dim );
fieldComponentCount = Stg_ComponentFactory_GetUnsignedInt(
cf,
self->name,
(Dictionary_Entry_Key)"fieldComponentCount",
0 );
useCacheMaxMin = Stg_ComponentFactory_GetBool( cf, self->name, (Dictionary_Entry_Key)"useCacheMaxMin", False );
o_units = Stg_ComponentFactory_GetString( cf, self->name, (Dictionary_Entry_Key)"outputUnits", NULL );
/*
* Decide whether this FieldVariable will be checkpointed & reloaded, based on the dictionary list
* "fieldVariableToCheckpoint". NB may want to put this in the XML component definintion of a
* FieldVariable itself, but for now prefer list so it can be centrally set.
* -- Pat, Jules, Kath - 29 November 2006
*/
isCheckpointedAndReloaded2 = Stg_ComponentFactory_GetBool( cf, self->name, (Dictionary_Entry_Key)"isCheckpointedAndReloaded", False );
/* Case insensitive search */
feVarsList = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"fieldVariablesToCheckpoint" );
if( NULL == feVarsList ) {
feVarsList = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"FieldVariablesToCheckpoint" );
}
if( feVarsList != NULL ) {
Index listLength = Dictionary_Entry_Value_GetCount( feVarsList );
Index var_I = 0;
Dictionary_Entry_Value* feVarDictValue = NULL;
char* fieldVariableName;
/* if the 'fieldVariablesToCheckpoint' list is empty (but exists)
* checkpoint every field
* else selectively checkpoint based on list entries */
if( listLength == 0 ) {
isCheckpointedAndReloaded = True;
}
else {
isCheckpointedAndReloaded = False;
for ( var_I = 0; var_I < listLength; var_I++ ) {
feVarDictValue = Dictionary_Entry_Value_GetElement( feVarsList, var_I );
fieldVariableName = Dictionary_Entry_Value_AsString( feVarDictValue );
if ( 0 == strcmp( self->name, fieldVariableName ) ) {
isCheckpointedAndReloaded = True;
break;
}
}
}
}
else {
/* If there's no special list, just checkpoint/reload everything. */
isCheckpointedAndReloaded = True;
}
isCheckpointedAndReloaded = (isCheckpointedAndReloaded || isCheckpointedAndReloaded2 );
feVarsList = NULL;
/* also include check to see if this fevariable should be saved for analysis purposes */
feVarsList = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"fieldVariablesToSave" );
if( NULL == feVarsList ) {
feVarsList = Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"FieldVariablesToSave" );
}
if( feVarsList != NULL ) {
Index listLength = Dictionary_Entry_Value_GetCount( feVarsList );
Index var_I = 0;
Dictionary_Entry_Value* feVarDictValue = NULL;
char* fieldVariableName;
for( var_I = 0; var_I < listLength; var_I++ ) {
feVarDictValue = Dictionary_Entry_Value_GetElement( feVarsList, var_I );
fieldVariableName = Dictionary_Entry_Value_AsString( feVarDictValue );
if( 0 == strcmp( self->name, fieldVariableName ) ) {
self->isSavedData = True;
break;
}
}
}
_FieldVariable_Init(
self,
context,
fieldComponentCount,
dim,
isCheckpointedAndReloaded,
o_units,
MPI_COMM_WORLD,
fV_Register,
useCacheMaxMin );
}
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 );
}
}
char* Stg_ComponentFactory_PluginGetString( void* cf, void* codelet, Dictionary_Entry_Key key, const char* const defaultVal ) {
return Dictionary_Entry_Value_AsString(
_Stg_ComponentFactory_PluginGetDictionaryValue( cf, codelet, key,
Dictionary_Entry_Value_FromString( defaultVal ) ) );
}
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 );
}
}
void _SnacHillSlope_InitialConditions( void* _context, void* data ) {
Snac_Context *context = (Snac_Context*)_context;
SnacHillSlope_Context *contextExt = ExtensionManager_Get(context->extensionMgr,
context,
SnacHillSlope_ContextHandle );
Mesh *mesh = context->mesh;
MeshLayout *layout = (MeshLayout*)mesh->layout;
HexaMD *decomp = (HexaMD*)layout->decomp;
BlockGeometry *geometry = (BlockGeometry*)layout->elementLayout->geometry;
Node_GlobalIndex node_g, node_gI, node_gJ;
const int full_I_node_range=decomp->nodeGlobal3DCounts[0];
const int full_J_node_range=decomp->nodeGlobal3DCounts[1];
double new_x[full_I_node_range], new_y[full_J_node_range];
double reg_dx, reg_dy, new_xMax, new_xMin, new_xHalf, midOffset, old_yMax, new_yMax, new_yMin;
double slopeAngle = contextExt->slopeAngle * M_PI/180.0;
double resolveHeight = geometry->max[1]-contextExt->resolveDepth;
double xLeftFlatRamp = (contextExt->leftFlatFraction<0.0 ? 0.0 :
(contextExt->leftFlatFraction>1.0 ? 1.0 : contextExt->leftFlatFraction));
double xRightRampFlat = (contextExt->rightFlatFraction<0.0 ?
1.0-contextExt->leftFlatFraction : (contextExt->rightFlatFraction>1.0 ?
1.0 : contextExt->rightFlatFraction));
const double smoothFactor = contextExt->rampFlatSmoothFactor;
int restart = FALSE;
Dictionary_Entry_Value *pluginsList, *plugin;
#ifdef DEBUG
int imax=0;
#endif
pluginsList = PluginsManager_GetPluginsList( context->dictionary );
if (pluginsList) {
plugin = Dictionary_Entry_Value_GetFirstElement(pluginsList);
while ( plugin ) {
if ( 0 == strcmp( Dictionary_Entry_Value_AsString( plugin ),
"SnacRestart" ) ) {
restart = TRUE;
break;
}
plugin = plugin->next;
}
}
/*
if(context->restartTimestep > 0) {
restart = TRUE;
}
*/
if( restart ) {
fprintf(stderr, "Restarting: thus bailing from hillSlope/InitialConditions.c to avoid overwriting the mesh geometry\n");
return;
}
#ifdef DEBUG
printf( "In: %s\n", __func__ );
#endif
// fprintf(stderr, "Slope angle = %g degrees\n", slopeAngle/(M_PI/180.0));
/* Report HillSlope plugin variables picked up (?) from xml parameter file */
Journal_Printf( context->snacInfo, "\nSlope angle = %g degrees\n", slopeAngle/(M_PI/180.0) );
reg_dx = (geometry->max[0]-geometry->min[0])/(double)(full_I_node_range-1);
reg_dy = (geometry->max[1]-geometry->min[1])/(double)(full_J_node_range-1);
/*
* Decide at what height (prior to shearing) to switch from rombhoid to parallelopiped geometry,
* i.e., at what depth to resolve using "regular" elements parallel to the surface
* versus "irregular" elements deformed to fit to a horizontal bottom
* If contextExt->resolveDepth is negative, resolveHeight is set to zero and the whole domain is "regular"
*/
if(contextExt->resolveDepth<0.0 || resolveHeight<0.0) {
resolveHeight = 0.0;
} else if(resolveHeight>geometry->max[1]) {
resolveHeight = geometry->max[1];
}
for( node_gI = 0; node_gI < full_I_node_range; node_gI++ )
new_x[node_gI] = geometry->min[0] + node_gI*reg_dx;
for( node_gJ = 0; node_gJ <= (full_J_node_range-1); node_gJ++ )
new_y[node_gJ] = geometry->min[1] + node_gJ*reg_dy;
/* if((full_J_node_range-1)<4) { */
/* for( node_gJ = 0; node_gJ <= (full_J_node_range-1); node_gJ++ ) */
/* new_y[node_gJ] = geometry->min[1] + node_gJ*reg_dy; */
/* } else { */
/* for( node_gJ = 0; node_gJ <= (full_J_node_range-1)/4; node_gJ++ ) */
/* new_y[node_gJ] = geometry->min[1] + node_gJ*reg_dy*(stretchFactor/(1.0+stretchFactor)); */
/* for( ; node_gJ <= (full_J_node_range-1); node_gJ++ ) */
/* new_y[node_gJ] = geometry->min[1] + ((full_J_node_range-1)/4)*reg_dy*(stretchFactor/(1.0+stretchFactor)) */
/* + (node_gJ-((full_J_node_range-1)/4))*reg_dy*(1.0/(1.0+stretchFactor)); */
/* } */
/*
* Assume highest point in x,y is at the last mesh node
*/
new_xMin = new_x[0];
new_xMax = new_x[full_I_node_range-1];
new_xHalf = new_xMin+(new_xMax-new_xMin)/2.0;
new_yMin = new_y[0];
old_yMax = new_yMax = new_y[full_J_node_range-1]; /*+ tan(mesh_slope)*geometry->max[0]; */
xLeftFlatRamp=new_xMin+(new_xMax-new_xMin)*xLeftFlatRamp;
xRightRampFlat=new_xMin+(new_xMax-new_xMin)*xRightRampFlat;
fprintf(stderr, "Left flat <= %g -> %g\n", contextExt->leftFlatFraction, xLeftFlatRamp);
fprintf(stderr, "Right flat >= %g -> %g\n", contextExt->rightFlatFraction, xRightRampFlat);
fprintf(stderr, "Ramp-flat smoothness = %g\n", smoothFactor);
fprintf(stderr, "Flat/ramp/flat ranges: %g <-> %g <-> %g <-> %g\n", new_xMin, xLeftFlatRamp, xRightRampFlat, new_xMax);
/*
* Loop across all nodes in mesh
* - total of x*y*z nodes is given by context->mesh->nodeGlobalCount+1
*/
for( node_g = 0; node_g < context->mesh->nodeGlobalCount; node_g++ ) {
Node_LocalIndex node_l = Mesh_NodeMapGlobalToLocal( mesh, node_g );
Index i_g;
Index j_g;
Index k_g;
Coord* coord = 0;
Coord tmpCoord;
/*
* If a local node, directly change the node coordinates else use a temporary location
*/
if( node_l < context->mesh->nodeLocalCount ) { /* a local node */
coord = Snac_NodeCoord_P( context, node_l );
}
else {
/*
* If the node is running on another CPU, use dummy ptr
* - wouldn't it be better to just skip (continue) to next node?
*/
coord = &tmpCoord;
}
/*
* Convert 1d mesh node index to 3d i,j,k mesh node position
*/
RegularMeshUtils_Node_1DTo3D( decomp, node_g, &i_g, &j_g, &k_g );
/*
* Do nothing to x coordinate
*/
(*coord)[0] = new_x[i_g];
/*exp(-smoothFactor*(xRightRampFlat-new_x[i_g])/old_yMax)
* Transform y coordinates by shearing mesh parallel to vertical axis
*/
(*coord)[1] = new_y[j_g];
midOffset=( (xRightRampFlat-(xRightRampFlat-new_xHalf)*( 1.0-exp(-smoothFactor*(xRightRampFlat-new_xHalf)/old_yMax) ))
- (new_xHalf-xLeftFlatRamp)*( 1.0-exp(-smoothFactor*(new_xHalf-xLeftFlatRamp)/old_yMax) ) )*tan(slopeAngle);
if(new_x[i_g]<=new_xHalf) {
/* LHS */
(*coord)[1] +=
( (new_x[i_g]<xLeftFlatRamp ? 0 :
(new_x[i_g]-xLeftFlatRamp)*( 1.0-exp(-smoothFactor*(new_x[i_g]-xLeftFlatRamp)/old_yMax) )*tan(slopeAngle) )
*(new_y[j_g]>=resolveHeight ? 1.0 : new_y[j_g]/resolveHeight) );
} else {
/* RHS */
(*coord)[1] +=
( (new_x[i_g]>=xRightRampFlat ? xRightRampFlat*tan(slopeAngle)-midOffset :
(xRightRampFlat-(xRightRampFlat-new_x[i_g])*( 1.0-exp(-smoothFactor*(xRightRampFlat-new_x[i_g])/old_yMax) ))*tan(slopeAngle) - midOffset)
*(new_y[j_g]>=resolveHeight ? 1.0 : new_y[j_g]/resolveHeight) );
}
/*
* Track maximum y as mesh deforms
*/
if((*coord)[1]>new_yMax) new_yMax=(*coord)[1];
#ifdef DEBUG
fprintf( stderr, "\tnode_l: %2u, node_g: %2u, i: %2u, j: %2u, k: %2u, ",
node_l,
node_g,
i_g,
j_g,
k_g );
fprintf( stderr, "x: %12g, y: %12g, z: %12g\n", (*coord)[0], (*coord)[1], (*coord)[2] );
#endif
}
/*
* Reset vertical max
*/
geometry->max[1] = new_yMax;
}
char* _Stg_ComponentFactory_GetString( void* cf, Name componentName, Dictionary_Entry_Key key, const char* const defaultVal ) {
return Dictionary_Entry_Value_AsString(
_Stg_ComponentFactory_GetDictionaryValue( cf, componentName, key,
Dictionary_Entry_Value_FromString( defaultVal ) ) );
}
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 );
}
}
void stgGenerateFlattenedXML( Dictionary* dictionary, Dictionary* sources, char* timeStamp ) {
XML_IO_Handler* ioHandler;
char* outputPath;
char* flatFilename;
char* flatFilenameStamped;
char* slimFilename;
Stream* s;
Bool isEnabled;
Bool ret;
Bool outputSlim;
s = Journal_Register( Info_Type, (Name)XML_IO_Handler_Type );
/* Avoid confusing messages from XML_IO_Handler. Turn it off temporarily. */
isEnabled = Stream_IsEnable( s );
Stream_EnableSelfOnly( s, False );
ioHandler = XML_IO_Handler_New();
if( sources == NULL )
ioHandler->writeSources = False;
outputPath = StG_Strdup( Dictionary_Entry_Value_AsString( Dictionary_GetDefault( dictionary,
(Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString( "./" ) ) ) );
outputSlim = Dictionary_Entry_Value_AsBool( Dictionary_GetDefault( dictionary,
(Dictionary_Entry_Key)"outputSlimmedXML", Dictionary_Entry_Value_FromBool( True ) ) );
if( ! Stg_DirectoryExists( outputPath ) ) {
if( Stg_FileExists( outputPath ) )
Journal_Firewall( 0, s, "outputPath '%s' is a file an not a directory! Exiting...\n", outputPath );
Journal_Printf( s, "outputPath '%s' does not exist, attempting to create...\n", outputPath );
ret = Stg_CreateDirectory( outputPath );
Journal_Firewall( ret, s, "Unable to create non-existing outputPath to '%s'\n", outputPath );
Journal_Printf( s, "outputPath '%s' successfully created!\n", outputPath );
}
/* Set file names. */
Stg_asprintf( &flatFilename, "%s/%s", outputPath, "input.xml" );
IO_Handler_WriteAllToFile( ioHandler, flatFilename, dictionary, sources );
/* Format; path/input-YYYY.MM.DD-HH.MM.SS.xml. */
if (timeStamp) {
Stg_asprintf( &flatFilenameStamped, "%s/%s-%s.%s",
outputPath, "input", timeStamp, "xml" );
IO_Handler_WriteAllToFile( ioHandler, flatFilenameStamped, dictionary, sources );
Memory_Free( flatFilenameStamped );
}
if( outputSlim && timeStamp ) {
ioHandler->writeSources = False;
Stg_asprintf( &slimFilename, "%s/%s-%s.%s",
outputPath, "input-basic", timeStamp, "xml" );
IO_Handler_WriteAllToFile( ioHandler, slimFilename, dictionary, NULL);
}
Stream_EnableSelfOnly( s, isEnabled );
Stg_Class_Delete( ioHandler );
Memory_Free( flatFilename );
}
void ModulesManager_Load( void* modulesManager, void* _dictionary, Name contextName ) {
ModulesManager* self = (ModulesManager*)modulesManager;
Dictionary* dictionary = (Dictionary*)_dictionary;
unsigned int entryCount;
unsigned int entry_I;
Dictionary_Entry_Value* modulesVal;
/*
* First add the directory list onto LD_LIBRARY_PATH so that it can potentially
* resolve the unknown symbols */
#ifndef NOSHARED
char* curEnvPath;
char* newEnvPath;
Index newEnvPathLength;
Index dir_I;
Index i, count;
char* dir;
newEnvPathLength = 0;
if( dictionary ) {
Dictionary_Entry_Value* localLibDirList = Dictionary_Get( dictionary, "LD_LIBRARY_PATH" );
if( localLibDirList ) {
count = Dictionary_Entry_Value_GetCount( localLibDirList );
for( i = 0; i < count; ++i ) {
dir = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( localLibDirList, i ) );
ModulesManager_AddDirectory( "FromDictionary", dir );
}
}
}
for( dir_I = 0; dir_I < moduleDirectories->count; ++dir_I ) {
newEnvPathLength += strlen( (char*)Stg_ObjectList_ObjectAt( moduleDirectories, dir_I ) );
/* Add one make space for the ':' inbetween the directories */
newEnvPathLength += 1;
}
curEnvPath = getenv("LD_LIBRARY_PATH");
if( curEnvPath ) {
newEnvPathLength += strlen( curEnvPath );
}
if( newEnvPathLength > 0 ) {
/* Add one to make space for the Null Terminator '\0' */
newEnvPathLength += 1;
newEnvPath = Memory_Alloc_Array( char, newEnvPathLength, "LD_LIBRARY_PATH" );
newEnvPath[0] = '\0';
for( dir_I = 0; dir_I < moduleDirectories->count; ++dir_I ) {
strcat( newEnvPath, (char*)Stg_ObjectList_ObjectAt( moduleDirectories, dir_I ) );
strcat( newEnvPath, ":" );
}
if( curEnvPath ) {
strcat( newEnvPath, curEnvPath );
}
setenv( "LD_LIBRARY_PATH", newEnvPath, 1 );
Journal_Printf(
Journal_Register( Debug_Type, self->type ),
"Using LD_LIBRARY_PATH=%s\n",
newEnvPath );
Memory_Free( newEnvPath );
}
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;
}
Name _ToolboxesManager_GetModuleName( void* toolboxesManager, Dictionary_Entry_Value* moduleVal, unsigned int entry_I ) {
return Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( moduleVal, entry_I ) );
}
