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 _AnalyticFeVariable_AssignFromXML( void* analyticFeVariable, Stg_ComponentFactory* cf, void* data ) {
AnalyticFeVariable* self = (AnalyticFeVariable*)analyticFeVariable;
Dictionary* dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
Name numericFieldName;
Name functionName;
FeVariable* numericField = NULL;
/*
* NOTE:
* This component is a special case where it calls its ancestor's *_AssignFromXML
* instead of its immediate parent's. This is because we don't want to re-declare
* the required FeVariable parameters in this component's XML block.
*/
_FieldVariable_AssignFromXML( self, cf, data );
numericFieldName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"NumericField" );
numericField = (FeVariable*)LiveComponentRegister_Get( cf->LCRegister, numericFieldName );
if( !numericField )
numericField = Stg_ComponentFactory_ConstructByName( cf, (Name)numericFieldName,
FeVariable, True, data );
functionName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"Function" );
/*
* NOTE:
* The parent's *_Init function needs to be called to initialise
* FeVariable-specific attributes.
*/
_FeVariable_Init( (FeVariable*)self, numericField->feMesh, NULL,
NULL, False, NULL, NULL, NULL, True, False );
_AnalyticFeVariable_Init( self, functionName, numericField );
}
void _StgFEM_Document_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data ) {
Codelet* self = (Codelet*)component;
AbstractContext* context;
ConditionFunction* condFunc;
Dictionary* pluginDict = Codelet_GetPluginDictionary( component, cf->rootDict );
DocumentationComponentFactory* dcf;
Stream* componentListStream;
context = (AbstractContext*)Stg_ComponentFactory_ConstructByName(
cf,
Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"Context" ),
AbstractContext,
True,
data );
/* Print list of all components */
componentListStream = Journal_Register( Info_Type, (Name)"componentList" );
Stream_RedirectFile_WithPrependedPath( componentListStream, context->outputPath, "ComponentList.txt" );
Stg_ComponentRegister_PrintAllTypes( Stg_ComponentRegister_Get_ComponentRegister(), componentListStream );
/* Print info for one component */
dcf = DocumentationComponentFactory_New( );
Stream_RedirectFile_WithPrependedPath( dcf->infoStream, context->outputPath, "Documentation.txt" );
DocumentationComponentFactory_DocumentType( dcf, Dictionary_GetString( context->dictionary, (Dictionary_Entry_Key)"documentType" ) );
exit( EXIT_SUCCESS );
}
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 );
}
Dictionary* Codelet_GetPluginDictionary( void* codelet, Dictionary* rootDict ) {
Codelet* self = (Codelet*)codelet;
Dictionary_Entry_Value* pluginsDEV = Dictionary_Get( rootDict, "plugins" );
Dictionary* pluginDict;
unsigned pluginIndex;
Name pluginType;
for( pluginIndex = 0; pluginIndex < Dictionary_Entry_Value_GetCount( pluginsDEV ); pluginIndex++ ) {
pluginDict = Dictionary_Entry_Value_AsDictionary(
Dictionary_Entry_Value_GetElement( pluginsDEV, pluginIndex ) );
pluginType = Dictionary_GetString( pluginDict, "Type" );
if( !strcmp( self->type, pluginType ) )
return pluginDict;
}
return NULL;
}
void Underworld_DensityChange_Setup( UnderworldContext* context ) {
/* Function pulls and checks user input from the xml file */
BuoyancyForceTerm* bft = NULL;
BuoyancyForceTerm_MaterialExt* materialExt = NULL;;
Stream* stream = Journal_Register( Info_Type, (Name)"cows" );
Name materialName = NULL;
int materialIndex;
/* Get self (the plugin) */
Underworld_DensityChange* self = (Underworld_DensityChange* )LiveComponentRegister_Get( context->CF->LCRegister, (Name)Underworld_DensityChange_Type );
/* Initialise plugin data */
self->bftExt = NULL;
self->swarm = NULL;
self->material = NULL;
self->height = 0;
self->newDensity = 0;
/* Need buoyancy force term, to get density infomation from bft extension + the integration swarm */
bft = Stg_ComponentFactory_ConstructByName( context->CF, (Name)"buoyancyForceTerm", BuoyancyForceTerm, True, NULL );
/* Read in input from root xml dictionary */
self->height = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"materialDensityChangeHeight", 0.5 );
self->newDensity = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"materialDensityNewDensity", 0.3 );
self->swarm = (IntegrationPointsSwarm* )bft->integrationSwarm;
materialName = Dictionary_GetString( context->dictionary, (Dictionary_Entry_Key)"materialDensityToChange" );
self->material = Materials_Register_GetByName( self->swarm->materials_Register, materialName );
/* check if material index exists */
if( self->material==NULL ) {
printf("Error\nCounld find the material with index %d\n", materialIndex ); exit(0);
}
materialExt = (BuoyancyForceTerm_MaterialExt*)ExtensionManager_Get( self->material->extensionMgr, self->material, bft->materialExtHandle );
Journal_RPrintf( stream, "Will change %s's density at height %g from %g to %g\n",
self->material->name, self->height, materialExt->density, self->newDensity );
self->bftExt = materialExt;
}
void _lecode_tools_Isostasy_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data )
{
lecode_tools_Isostasy* self = (lecode_tools_Isostasy*)component;
ConditionFunction *cond_func;
Dictionary* pluginDict = Codelet_GetPluginDictionary( component, cf->rootDict );
lecode_tools_Isostasy_self = self;
self->context = (AbstractContext*)Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"Context" ), UnderworldContext, True, data );
self->ctx = self->context;
self->mesh = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"mesh" ), FeMesh, True, data );
self->swarm = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"swarm" ), IntegrationPointsSwarm, True, data );
/*
self->heightField = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"HeightField" ), FeVariable, True, data );
*/
self->surfaceIdx = Stg_ComponentFactory_PluginGetInt( cf, self, "SurfaceIndex", -1 );
self->vertAxis = Stg_ComponentFactory_PluginGetInt( cf, self, "VerticalAxis", 1 );
if( self->vertAxis == 1 )
self->zontalAxis = 2;
else if( self->vertAxis == 2 )
self->zontalAxis = 1;
else
Journal_Firewall( NULL,
Journal_MyStream( Error_Type, self ),
"\n\nError in %s for %s - Isostasy plugin requires 'VerticalAxis' to be '1' (standard UW) or '2'.",
__func__,
self->type );
self->avg = Stg_ComponentFactory_PluginGetBool( cf, self, "UseAverage", True );
self->vel_field = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"velocityField" ), FeVariable, True, data );
self->buoyancy = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"buoyancy" ), BuoyancyForceTerm, False, data );
self->rho_zero_mat = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"rhoZeroMaterial" ), Material, True, data );
self->sle = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"sle" ), SystemLinearEquations, True, data );
self->thermalSLE = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"thermalSLE" ), SystemLinearEquations, False, data );
if (self->thermalSLE)
{
self->tempField = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"temperatureField" ), FeVariable, True, data );
self->tempDotField = Stg_ComponentFactory_ConstructByName( cf, Dictionary_GetString( pluginDict, (Dictionary_Entry_Key)"temperatureDotField" ), FeVariable, True, data );
}
self->maxIts = Stg_ComponentFactory_PluginGetInt( cf, self, "MaxIterations", -1 );
SystemLinearEquations_SetToNonLinear(self->sle);
SystemLinearEquations_AddNonLinearEP(self->sle, lecode_tools_Isostasy_Type, lecode_tools_Isostasy_NonLinearEP);
cond_func = ConditionFunction_New( (ConditionFunction_ApplyFunc*)lecode_tools_Isostasy_SetBC, (Name)"lecode_tools_Isostasy", NULL );
ConditionFunction_Register_Add( condFunc_Register, cond_func);
/** check if PPCing */
if(!self->buoyancy){
self->ppcManager = NULL;
self->ppcManager = Stg_ComponentFactory_PluginConstructByKey( cf, self, (Dictionary_Entry_Key)"Manager", PpcManager, False, data );
if( !self->ppcManager )
self->ppcManager = Stg_ComponentFactory_ConstructByName( cf, (Name)"default_ppcManager", PpcManager, False, data );
if( !self->ppcManager )
Journal_Firewall( NULL,
Journal_MyStream( Error_Type, self ),
"\n\nError in %s for %s - Neither a BuoyancyForceTerm or Ppc manager was found .\nIsostasy plugin requires one OR the other to operate.\n\n\n",
__func__,
self->type );
if( self->thermalSLE )
Journal_Firewall( NULL,
Journal_MyStream( Error_Type, self ),
"\n\nError in %s for %s - Ppc not compatible with thermalSLE option.\n\n\n",
__func__,
self->type );
self->densityID = PpcManager_GetPpcFromDict( self->ppcManager, cf, self->name, (Dictionary_Entry_Key)"DensityLabel", "DensityLabel" );
}
}
Dictionary_Entry_Value* _Stg_ComponentFactory_PluginGetDictionaryValue( void* cf, void *codelet, Dictionary_Entry_Key key, Dictionary_Entry_Value* defaultVal ) {
Stg_ComponentFactory* self = (Stg_ComponentFactory*) cf;
Stg_Component* plugin = (Stg_Component*)codelet;
Dictionary* thisPluginDict = NULL;
Dictionary* pluginDict = (Dictionary*)Dictionary_Get( self->rootDict, "plugins" );
Name pluginType;
Index pluginIndex;
Dictionary_Entry_Value* returnVal;
Bool usedDefault = False;
Stream* errorStream = Journal_Register( Error_Type, Stg_Component_Type );
Stream* stream = self->infoStream;
Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_ComponentFactory is NULL.\n", __func__ );
Journal_PrintfL( stream, 2, "Getting parameter '%s': ", key );
Journal_Firewall( pluginDict != NULL, errorStream,
"In func %s: Stg_Component Factory's dictionary 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 this Stg_Component's Dictionary */
Journal_Firewall( thisPluginDict != NULL, errorStream,
"In func %s: Can't find sub-dictionary for component '%s'.\n", __func__, plugin->name );
/* Get Value from dictionary */
returnVal = Dictionary_Get( thisPluginDict, key );
if ( !returnVal && defaultVal ) {
returnVal = Dictionary_GetDefault( thisPluginDict, key, 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;
}
void Stg_ComponentFactory_CreateComponents( Stg_ComponentFactory *self ) {
Dictionary_Entry* componentDictEntry = NULL;
Dictionary* currComponentDict = NULL;
Type componentType = NULL;
Name componentName = NULL;
Stg_Component_DefaultConstructorFunction* componentConstructorFunction;
Index component_I;
Stream* stream;
assert( self );
stream = self->infoStream;
if( self->componentDict ){
Stream_Indent( stream );
/* add the contexts to the live component register first (so these get constructed/built/initialised first) */
for( component_I = 0; component_I < Dictionary_GetCount( self->componentDict ) ; component_I++ ){
componentDictEntry = self->componentDict->entryPtr[ component_I ];
currComponentDict = Dictionary_Entry_Value_AsDictionary( componentDictEntry->value );
componentType = Dictionary_GetString( currComponentDict, "Type" );
componentName = componentDictEntry->key;
if( strcmp( componentType, "DomainContext" ) &&
strcmp( componentType, "FiniteElementContext" ) &&
strcmp( componentType, "PICelleratorContext" ) )
continue;
if( LiveComponentRegister_Get( self->LCRegister, componentName ) != NULL ) {
Journal_RPrintf( Journal_Register( Error_Type, self->type ),
"Error in func %s: Trying to instantiate two components with the name of '%s'\n"
"Each component's name must be unique.\n",
__func__, componentName );
exit(EXIT_FAILURE);
}
/* Print Message */
/* Journal_Printf( stream, "Instantiating %s as %s\n", componentType, componentName ); */
/* Get Default Constructor for this type */
componentConstructorFunction = Stg_ComponentRegister_AssertGet(
Stg_ComponentRegister_Get_ComponentRegister(), componentType, "0" );
/* Add to register */
LiveComponentRegister_Add( self->LCRegister, (Stg_Component*)componentConstructorFunction( componentName ) );
}
/* now add the rest of the components */
for( component_I = 0; component_I < Dictionary_GetCount( self->componentDict ) ; component_I++ ){
componentDictEntry = self->componentDict->entryPtr[ component_I ];
currComponentDict = Dictionary_Entry_Value_AsDictionary( componentDictEntry->value );
componentType = Dictionary_GetString( currComponentDict, "Type" );
componentName = componentDictEntry->key;
if( !strcmp( componentType, "DomainContext" ) ||
!strcmp( componentType, "FiniteElementContext" ) ||
!strcmp( componentType, "PICelleratorContext" ) )
continue;
if( LiveComponentRegister_Get( self->LCRegister, componentName ) != NULL ) {
Journal_RPrintf( Journal_Register( Error_Type, self->type ),
"Error in func %s: Trying to instantiate two components with the name of '%s'\n"
"Each component's name must be unique.\n",
__func__, componentName );
exit(EXIT_FAILURE);
}
Journal_Firewall( strcmp( componentType, "" ), NULL, "In func %s: Component with name '%s' does not have a 'Type' specified.\n"
"This is sometimes caused by incorrect or missing 'mergeType' resulting in clobbered input file components.\n"
"You may need to add 'mergeType=\"merge\"' to this component. Please check your input file.", __func__, componentName);
/* Print Message */
/* Journal_Printf( stream, "Instantiating %s as %s\n", componentType, componentName ); */
/* Get Default Constructor for this type */
componentConstructorFunction = Stg_ComponentRegister_AssertGet(
Stg_ComponentRegister_Get_ComponentRegister(), componentType, "0" );
/* Add to register */
LiveComponentRegister_Add( self->LCRegister, (Stg_Component*)componentConstructorFunction( componentName ) );
}
Stream_UnIndent( stream );
}
else{
Journal_Printf( stream, "No Stg_Component List found..!\n" );
}
}
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 _Geothermal_FieldMaps_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data ) {
Geothermal_FieldMaps* self = (Geothermal_FieldMaps*)component;
Dictionary* dict = Codelet_GetPluginDictionary( component, cf->rootDict );
Dictionary_Entry_Value* mapList;
unsigned map_i;
Stream* errorStream = Journal_Register( ErrorStream_Type, Geothermal_FieldMaps_Type );
Stream_SetPrintingRank( errorStream, 0 );
/* Plugin-wide stuff */
self->context = (AbstractContext*)Stg_ComponentFactory_ConstructByName(
cf, "context", UnderworldContext, True, data );
/*self->swarm = Stg_ComponentFactory_ConstructByName(
cf, Dictionary_GetString( dict, "Swarm" ), Swarm, True, data );*/
mapList = Dictionary_Get( dict, (Dictionary_Entry_Key)"maps" );
if( mapList ) {
self->numMaps = Dictionary_Entry_Value_GetCount( mapList );
self->maps = malloc( self->numMaps * sizeof(Map*) );
}
else {
self->numMaps = 0;
self->maps = NULL;
}
/* Per map stuff */
for( map_i = 0; map_i < self->numMaps; map_i++ ) {
self->maps[map_i] = malloc( sizeof(Map) );
Dictionary* mapEntryDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Entry_Value_GetElement( mapList, map_i ) );
char* tmpStr;
#define SDEK Dictionary_Entry_Key
#define SDGDWD Dictionary_GetDouble_WithDefault
#define SDGSWD Dictionary_GetString_WithDefault
#define SDGBWD Dictionary_GetBool_WithDefault
#define SCFCBN Stg_ComponentFactory_ConstructByName
strncpy( self->maps[map_i]->name, Dictionary_GetString( mapEntryDict, "name" ), FILENAME_MAX );
strncpy( self->maps[map_i]->outputPath, SDGSWD( mapEntryDict, (SDEK)"outputPath", self->context->outputPath ), FILENAME_MAX);
self->maps[map_i]->field = SCFCBN( cf, Dictionary_GetString( mapEntryDict, "Field" ), FeVariable, True, data );
self->maps[map_i]->depth = SDGDWD( mapEntryDict, (SDEK)"depthFromSurface", 0.0 );
/* Type of map */
self->maps[map_i]->outputAllNodes = False;
self->maps[map_i]->outputTopNodes = False;
self->maps[map_i]->outputDepth = False;
self->maps[map_i]->depth = 0.0;
self->maps[map_i]->heightField = NULL;
tmpStr = Dictionary_GetString( mapEntryDict, "of" );
if( strcmp( "surface", tmpStr ) == 0 ) {
self->maps[map_i]->outputTopNodes = True;
}
else if( strcmp( "volume", tmpStr ) == 0 ) {
self->maps[map_i]->outputAllNodes = True;
}
else if( strcmp( "depth", tmpStr ) == 0 ) {
self->maps[map_i]->outputDepth = True;
self->maps[map_i]->depth = SDGDWD( mapEntryDict, (SDEK)"depthFromSurface", 0.0 );
/* TODO: firewall if depth not given!!!*/
}
else if( strcmp( "height", tmpStr ) == 0 ) {
self->maps[map_i]->outputDepth = True;
self->maps[map_i]->heightField = SCFCBN( cf, Dictionary_GetString( mapEntryDict, "HeightField" ), FieldVariable, True, data );
/* TODO: firewall if HeightField not given!!!*/
}
Journal_Firewall(
self->maps[map_i]->outputTopNodes || self->maps[map_i]->outputAllNodes || self->maps[map_i]->outputDepth,
errorStream,
"Error: On FieldMaps plugin entry %u (named: \"%s\"), the \"of\" parameter must be either \"surface\", \"volume\", "
"\"depth\", or \"height\" (\"%s\" was given).\n",
map_i, self->maps[map_i]->name, tmpStr );
/* Formats */
self->maps[map_i]->gocadOutput = SDGBWD( mapEntryDict, (SDEK)"GOCADOutput", True );
self->maps[map_i]->nodeValues = 0;
self->maps[map_i]->nodeCoords = 0;
self->maps[map_i]->topNodesCount = 0;
}
ContextEP_Append( self->context, AbstractContext_EP_Dump, Geothermal_FieldMaps_Dump );
}
void TimeIntegrationSuite_TestDriver( TimeIntegrationSuiteData* data, char *_name, char *_DerivName0, char *_DerivName1, int _order ) {
Stg_ComponentFactory* cf;
Stream* stream;
Dictionary* dictionary;
TimeIntegrator* timeIntegrator;
TimeIntegrand* timeIntegrand;
TimeIntegrand* timeIntegrandList[2];
DomainContext* context;
Variable* variable;
Variable* variableList[2];
double* array;
double* array2;
Index size0 = 11;
Index size1 = 7;
Index array_I;
Index timestep = 0;
Index maxTimesteps = 10;
Bool simultaneous;
unsigned order;
double error = 0.0;
Name derivName;
double tolerance = 0.001;
Index integrand_I;
Index integrandCount = 2;
char expected_file[PCU_PATH_MAX];
dictionary = Dictionary_New();
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString("./output") );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"DerivName0", Dictionary_Entry_Value_FromString(_DerivName0) );
Dictionary_Add( dictionary, (Dictionary_Entry_Key)"DerivName1", Dictionary_Entry_Value_FromString(_DerivName1) );
context = DomainContext_New( "context", 0, 0, MPI_COMM_WORLD, NULL );
cf = stgMainConstruct( dictionary, NULL, data->comm, context );
stgMainBuildAndInitialise( cf );
ContextEP_Append( context, AbstractContext_EP_Dt, TimeIntegrationSuite_GetDt );
/* Create Stuff */
order = _order;
simultaneous = False;
variableList[0] = Variable_NewVector( "testVariable", (AbstractContext*)context, Variable_DataType_Double, 2, &size0, NULL, (void**)&array, NULL );
variableList[1] = Variable_NewVector( "testVariable2", (AbstractContext*)context, Variable_DataType_Double, 2, &size1, NULL, (void**)&array2, NULL );
timeIntegrator = TimeIntegrator_New( "testTimeIntegrator", order, simultaneous, NULL, NULL );
timeIntegrator->context = context;
timeIntegrandList[0] = TimeIntegrand_New( "testTimeIntegrand0", context, timeIntegrator, variableList[0], 0, NULL, True );
timeIntegrandList[1] = TimeIntegrand_New( "testTimeIntegrand1", context, timeIntegrator, variableList[1], 0, NULL, True );
Journal_Enable_AllTypedStream( True );
stream = Journal_Register( Info_Type, (Name)"EulerStream" );
Stream_RedirectFile( stream, _name );
Stream_Enable( timeIntegrator->info, False );
derivName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"DerivName0" );
timeIntegrandList[0]->_calculateTimeDeriv = TimeIntegrationSuite_GetFunctionPtr( derivName );
Journal_Printf( stream, "DerivName0 - %s\n", derivName );
derivName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"DerivName1" );
timeIntegrandList[1]->_calculateTimeDeriv = TimeIntegrationSuite_GetFunctionPtr( derivName );
Journal_Printf( stream, "DerivName1 - %s\n", derivName );
/* Print Stuff to file */
Journal_PrintValue( stream, order );
Journal_PrintBool( stream, simultaneous );
/* Add stuff to EPs */
TimeIntegrator_AppendSetupEP( timeIntegrator, "start1", TimeIntegrationSuite_TestContextType, CURR_MODULE_NAME, context );
TimeIntegrator_AppendFinishEP( timeIntegrator, "finish1", TimeIntegrationSuite_TestVariableType, CURR_MODULE_NAME, variableList[0] );
TimeIntegrator_PrependSetupEP( timeIntegrator, "start0", TimeIntegrationSuite_TestVariableType, CURR_MODULE_NAME, variableList[0] );
TimeIntegrator_PrependFinishEP( timeIntegrator, "finish0", TimeIntegrationSuite_TestContextType, CURR_MODULE_NAME, context );
/* Build */
Stg_Component_Build( variableList[0], context, False );
Stg_Component_Build( variableList[1], context, False );
Stg_Component_Build( timeIntegrator, context, False );
Stg_Component_Build( timeIntegrandList[0], context, False );
Stg_Component_Build( timeIntegrandList[1], context, False );
array = Memory_Alloc_Array( double, 2 * size0, "name" );
array2 = Memory_Alloc_Array( double, 2 * size1, "name" );
/* Initialise */
memset( array, 0, sizeof(double) * 2 * size0 );
memset( array2, 0, sizeof(double) * 2 * size1 );
Stg_Component_Initialise( timeIntegrator, context, False );
Stg_Component_Initialise( variableList[0], context, False );
Stg_Component_Initialise( variableList[1], context, False );
Stg_Component_Initialise( timeIntegrandList[0], context, False );
Stg_Component_Initialise( timeIntegrandList[1], context, False );
for ( timestep = 0.0 ; timestep < maxTimesteps ; timestep ++ ) {
Journal_Printf( stream, "Step %u - Time = %.3g\n", timestep, context->currentTime );
Stg_Component_Execute( timeIntegrator, context, True );
context->currentTime += AbstractContext_Dt( context );
for ( integrand_I = 0 ; integrand_I < integrandCount ; integrand_I++ ) {
timeIntegrand = timeIntegrandList[ integrand_I ];
variable = variableList[ integrand_I ];
for ( array_I = 0 ; array_I < variable->arraySize ; array_I++ ) {
if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - 2.0 * array_I * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + array_I * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.5 * array_I * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 3 * array_I * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - array_I * context->currentTime * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + 0.5 * array_I * context->currentTime * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.25 * array_I * context->currentTime * context->currentTime );
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 1.5 * array_I * context->currentTime * context->currentTime );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) - 2.0 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0)/3.0));
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) + array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0 )/3.0));
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv2 ) {
error += fabs( Variable_GetValueAtDouble( variable, array_I, 0 ) + 0.5 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0)/3.0));
error += fabs( Variable_GetValueAtDouble( variable, array_I, 1 ) - 3.0 * array_I * ( 0.25 * pow( context->currentTime, 4.0 ) - pow( context->currentTime, 3.0 )/3.0));
}
else
Journal_Firewall( 0 , Journal_Register( Error_Type, (Name)CURR_MODULE_NAME ), "Don't understand _calculateTimeDeriv = %p\n", timeIntegrand->_calculateTimeDeriv );
}
}
}
pcu_check_lt( error, tolerance );
if ( error < tolerance )
Journal_Printf( stream, "Passed\n" );
else
Journal_Printf( stream, "Failed - Error = %lf\n", error );
Journal_Enable_AllTypedStream( False );
if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_ConstantTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationEulerOutput.expected", expected_file );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_LinearTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationRK2Output.expected", expected_file );
}
else if ( timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv
|| timeIntegrand->_calculateTimeDeriv == TimeIntegrationSuite_CubicTimeDeriv2 ) {
pcu_filename_expected( "testTimeIntegrationRK4Output.expected", expected_file );
}
pcu_check_fileEq( _name, expected_file );
/* Destroy stuff */
Stream_CloseAndFreeFile( stream );
Memory_Free( array );
Memory_Free( array2 );
Stg_Class_Delete( variable );
_Stg_Component_Delete( timeIntegrator );
_Stg_Component_Delete( timeIntegrandList[0] );
_Stg_Component_Delete( timeIntegrandList[1] );
remove( _name );
}
void IsoviscousStiffness2D( IsoviscousStiffnessData* data ) {
StiffnessMatrix* stiffnessMatrix;
Dictionary* dictionary;
FiniteElementContext* context;
Stg_ComponentFactory* cf;
PetscViewer expViewer;
PetscReal matrixNorm, errorNorm, test;
Mat expected;
char expected_file[PCU_PATH_MAX];
char *filename, *matrixName;
double tolerance;
char xml_input[PCU_PATH_MAX];
Stream* infoStream = Journal_Register( Info_Type, (Name)CURR_MODULE_NAME );
char rFile[PCU_PATH_MAX];
int err;
pcu_docstring( "This test compares a Stiffness matrix against a previously generated stiffness matrix"
"The stiffness matrix is generated from a 2D FEM model for an isoviscous fluid flow."
"See testIsoviscous.xml for the actual xml used" );
/* read in the xml input file */
pcu_filename_input( "IsoviscousStiffnessMatrix.xml", xml_input );
cf = stgMainInitFromXML( xml_input, MPI_COMM_WORLD, NULL );
context = (FiniteElementContext*)LiveComponentRegister_Get( cf->LCRegister, (Name)"context" );
data->context = context;
dictionary = context->dictionary;
stgMainBuildAndInitialise( cf );
/* Test is to check the relative error between an
1 ) expected stiffness matrix, (made years ago)
2) the current stiffness matrix.
both matricies are built using only an Arrhenius rheology
*/
/* get the tolerance */
tolerance = Dictionary_GetDouble( dictionary, "StiffnessMatrixCompareTolerance" );
/* Get Matrix */
matrixName = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"CompareStiffnessMatrix" );
Journal_Printf( infoStream, "Comparing stiffness matrix '%s'\n", matrixName );
stiffnessMatrix = (StiffnessMatrix*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)matrixName );
assert( stiffnessMatrix );
StiffnessMatrix_Assemble( stiffnessMatrix, False, NULL, context );
/* Get Stored Matrix from file */
filename = Dictionary_GetString( dictionary, (Dictionary_Entry_Key)"StiffnessMatrixCompareFilename" );
Journal_Printf( infoStream, "Checking with file '%s'\n", filename );
pcu_filename_expected( filename, expected_file );
PetscViewerBinaryOpen( context->communicator, expected_file, FILE_MODE_READ, &expViewer );
Stg_MatLoad( expViewer, MATAIJ, &expected );
MatNorm( expected, NORM_FROBENIUS, &matrixNorm );
assert( matrixNorm != 0 );
MatAXPY( expected, -1, (stiffnessMatrix->matrix) , DIFFERENT_NONZERO_PATTERN );
MatNorm( expected, NORM_FROBENIUS, &errorNorm );
test = errorNorm / matrixNorm;
pcu_check_lt( test, tolerance );
/* Check tolerance */
/*
stream = Journal_Register( Info_Type, (Name)"StiffnessMatrixComparison" );
Stream_RedirectFile_WithPrependedPath( stream, context->outputPath, "StiffnessMatrixCompare.dat" );
Journal_PrintValue( infoStream, tolerance );
Journal_Printf( stream, "Comparison between stiffness matrix '%s' %s with tolerance %4g.\n",
matrixName,
( errorNorm/matrixNorm < tolerance ? "passed" : "failed" ),
tolerance );
*/
/*
Stream_CloseFile( stream );
To view the expected and computed matricies uncomment this
PetscViewerASCIIOpen(context->communicator, "numerical.dat",&currViewer);
PetscViewerASCIIOpen(context->communicator, "expected.dat",¶llelViewer);
MatView( stiffnessMatrix->matrix, currViewer ); //PETSC_VIEWER_STDOUT_WORLD );
MatView( expected, parallelViewer ); //PETSC_VIEWER_STDOUT_WORLD );
Stg_PetscViewerDestroy(&currViewer);
Stg_PetscViewerDestroy(¶llelViewer);
*/
if( data->context->rank == 0 ) {
/* Now clean output path */
sprintf(rFile, "%s/input.xml", data->context->outputPath );
err = remove( rFile );
if( err == -1 ) printf("Error in %s, can't delete the input.xml\n", __func__);
}
stgMainDestroy( cf );
}
