void _RefinedRegionsGeometry_Construct( void* refinedRegionsGeometry, Stg_ComponentFactory *cf, void* data ) {
RefinedRegionsGeometry* self = (RefinedRegionsGeometry*)refinedRegionsGeometry;
IJK size;
int shift;
Dimension_Index dim;
Dimension_Index dim_I;
self->dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
/* Get Size from Dictionary */
dim = Stg_ComponentFactory_GetRootDictUnsignedInt( cf, "dim", 0 );
size[ I_AXIS ] = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, "sizeI", 1 );
size[ J_AXIS ] = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, "sizeJ", 1 );
size[ K_AXIS ] = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, "sizeK", 1 );
if ( dim == 2 )
size[ K_AXIS ] = 1;
/* Shift the size if nessesary */
shift = Stg_ComponentFactory_GetInt( cf, self->name, "sizeShift", 0 );
for ( dim_I = I_AXIS ; dim_I < dim ; dim_I++ )
size[ dim_I ] += shift;
_Geometry_Init( (Geometry*)self );
_RefinedRegionsGeometry_Init( self, size );
}
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 _DomainContext_AssignFromXML( void* context, Stg_ComponentFactory* cf, void* data ) {
DomainContext* self = (DomainContext*)context;
Dictionary *contextDict = NULL;
_AbstractContext_AssignFromXML( context, cf, data );
self->dim = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "dim", 2 );
self->verticalAxis = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "VerticalAxis", 1 );
/* try grab the scaling component and put it on the context
* check for the contextDict first as ConstructByKey NEEDS the conextDict
* and in units tests the contextDict sometime doesn't exist */
contextDict = Dictionary_GetDictionary( cf->componentDict, self->name );
if( contextDict ) {
self->scaling = Stg_ComponentFactory_ConstructByKey(
cf,
self->name,
(Dictionary_Entry_Key)"Scaling",
Scaling,
False,
data );
}
if( !self->scaling ) {
self->scaling = Stg_ComponentFactory_ConstructByName(
cf,
(Name)"default_scaling",
Scaling, False, data );
}
/* The following is for backward compatiblity with old (GALE) xml files. */
{
/* Post change 1d3dc4e00549 in this repositroy, the old style of DofLayout
* XML definition was illegal. This change allows for the old style.
*
* Here we build all 'MeshVariable' components first.
*
* This is a hack, selective construction of general component over other is
* a weakness to the object model and should be avoided. This section should
* be removed in future and xml files updated in accordance with change 1d3dc4e00549
*/
Stg_Component *component=NULL;
Index component_I;
for( component_I = 0; component_I < LiveComponentRegister_GetCount( cf->LCRegister ); component_I++ ){
/* Grab component from register */
component = LiveComponentRegister_At( cf->LCRegister, component_I );
/* if not a "MeshVariable" do nothing */
if( strcmp( component->type, MeshVariable_Type ) ) continue;
if( component && !component->isConstructed ){
Journal_Printf( cf->infoStream, "Constructing %s as %s\n", component->type, component->name );
Stg_Component_AssignFromXML( component, cf, data, True );
}
}
}
_DomainContext_Init( self );
}
void _ManualParticleLayout_AssignFromXML( void* manualParticleLayout, Stg_ComponentFactory *cf, void* data ) {
ManualParticleLayout* self = (ManualParticleLayout*) manualParticleLayout;
Dictionary* dictionary;
_GlobalParticleLayout_AssignFromXML( self, cf, data );
dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
_ManualParticleLayout_Init( self, dictionary );
}
Dictionary_Entry_Value* _Stg_ComponentFactory_GetDictionaryValue( void* cf, Name componentName, Dictionary_Entry_Key key, Dictionary_Entry_Value* defaultVal ) {
Stg_ComponentFactory* self = (Stg_ComponentFactory*) cf;
Dictionary* componentDict = NULL;
Dictionary* thisComponentDict = NULL;
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 );
/* 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, componentName );
if( thisComponentDict == NULL )
return defaultVal;
/* Get Value from dictionary */
returnVal = Dictionary_Get( thisComponentDict, key );
if ( !returnVal && defaultVal ) {
returnVal = Dictionary_GetDefault( thisComponentDict, 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 _ConvexHull_AssignFromXML( void* convexHull, Stg_ComponentFactory* cf, void* data ) {
ConvexHull* self = (ConvexHull*)convexHull;
Index vertexCount;
Index vertex_I;
Coord_List vertexList;
double* coord;
Dictionary_Entry_Value* optionSet;
Dictionary_Entry_Value* optionsList;
Dictionary* dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
Stream* stream = cf->infoStream;
_Stg_Shape_AssignFromXML( self, cf, data );
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"vertices" );
Journal_Firewall( optionsList != NULL,
Journal_Register( Error_Type, (Name)self->type ),
"In func %s: The list 'vertices' specifying the convexHull is NULL.\n", __func__);
vertexCount = Dictionary_Entry_Value_GetCount(optionsList);
Journal_Firewall( ( self->dim == 2 && vertexCount < 4 ) || ( self->dim == 3 && vertexCount < 5 ),
Journal_Register( Error_Type, (Name)self->type ),
"In func %s: Sorry, but we got lazy, you can only specify 3 (2D) or 4 (3D) points. "
"Please feel free to hassle developers for this feature.\n", __func__);
/* Allocate space */
vertexList = Memory_Alloc_Array( Coord , vertexCount, "Vertex Array" );
memset( vertexList, 0, vertexCount * sizeof(Coord) );
Stream_Indent( stream );
for ( vertex_I = 0 ; vertex_I < vertexCount ; vertex_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, vertex_I );
coord = vertexList[vertex_I];
/* Read Vertex */
coord[ I_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"x") );
coord[ J_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"y") );
coord[ K_AXIS ] = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"z"));
optionSet = optionSet->next;
}
Stream_UnIndent( stream );
_ConvexHull_Init( self, vertexList, vertexCount);
}
void _PeriodicBoundariesManager_AssignFromXML( void* periodicBCsManager, Stg_ComponentFactory* cf, void* data ) {
PeriodicBoundariesManager* self = (PeriodicBoundariesManager*)periodicBCsManager;
Dictionary* dictionary = NULL;
Mesh* mesh = NULL;
Swarm* swarm = NULL;
PICelleratorContext* context;
context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", PICelleratorContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", PICelleratorContext, True, data );
dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"mesh", Mesh, True, data );
swarm = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Swarm", Swarm, True, data );
_PeriodicBoundariesManager_Init( self, context, mesh, swarm, dictionary );
}
void _LinkedDofInfo_AssignFromXML( void* linkedDofInfo, Stg_ComponentFactory *cf, void* data ){
LinkedDofInfo* self = (LinkedDofInfo*)linkedDofInfo;
Dictionary* dictionary;
Mesh* mesh = NULL;
DofLayout* dofLayout = NULL;
DomainContext* context;
dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", DomainContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", DomainContext, True, data );
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Mesh", Mesh, True, data );
dofLayout = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)DofLayout_Type, DofLayout, True, data );
_LinkedDofInfo_Init( self, context, mesh, dofLayout, dictionary );
}
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 SwarmOutputSuite_TestSwarmOutput( SwarmOutputSuiteData* data ) {
int procToWatch = data->nProcs > 1 ? 1 : 0;
if( data->rank == procToWatch ) {
Dictionary* dictionary;
Dictionary* componentDict;
Stg_ComponentFactory* cf;
DomainContext* context;
char input_file[PCU_PATH_MAX];
Swarm* swarm;
SwarmOutput* swarmOutput;
SpaceFillerParticleLayout* particleLayout;
pcu_filename_input( "testSwarmOutput.xml", input_file );
cf = stgMainInitFromXML( input_file, data->comm, NULL );
context = (DomainContext*) LiveComponentRegister_Get( cf->LCRegister, (Name)"context" );
dictionary = context->dictionary;
Journal_ReadFromDictionary( dictionary );
stgMainBuildAndInitialise( cf );
ContextEP_Append( context, AbstractContext_EP_Dt, SwarmOutputSuite_Dt );
ContextEP_Append( context, AbstractContext_EP_Step, SwarmOutputSuite_MoveParticles );
componentDict = Dictionary_GetDictionary( dictionary, "components" );
assert( componentDict );
AbstractContext_Dump( context );
Stg_Component_Execute( context, 0, False );
particleLayout = (SpaceFillerParticleLayout*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"particleLayout" );
swarmOutput = (SwarmOutput* ) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"swarmOutput" );
swarm = (Swarm* ) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"swarm" );
pcu_check_true( particleLayout->isConstructed && particleLayout->isBuilt && particleLayout->isInitialised );
pcu_check_true( swarmOutput->isConstructed && swarmOutput->isBuilt && swarmOutput->isInitialised );
pcu_check_true( swarm->isConstructed && swarm->isBuilt && swarm->isInitialised );
pcu_check_streq( swarm->name, swarmOutput->swarm->name );
stgMainDestroy( cf );
}
}
void _ShapedMaterial_AssignFromXML( void* shapedMaterial, Stg_ComponentFactory* cf, void* data ) {
ShapedMaterial* self = (ShapedMaterial*) shapedMaterial;
Materials_Register* Materials_Register;
PICelleratorContext* context;
FieldVariable* materialIndexField;
Dictionary* materialDictionary;
context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", PICelleratorContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", PICelleratorContext, True, data );
materialDictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
/** user must provide a field which represents the shapes, with field values corresponding to current material index */
/** (this field should be initialised later, so no circular dependency should result) */
materialIndexField = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"MaterialIndexField", FieldVariable, True, data ) ;
Materials_Register = context->materials_Register;
_ShapedMaterial_Init( self, context, materialIndexField, materialDictionary, Materials_Register );
}
/*----------------------------------------------------------------------------------------------------------
** Virtual functions
*/
void _LinearSpaceAdaptor_AssignFromXML( void* _self, Stg_ComponentFactory* cf, void* data ) {
LinearSpaceAdaptor* self = (LinearSpaceAdaptor*)_self;
Dictionary* dictionary = Dictionary_GetDictionary( cf->componentDict, self->name );
Dictionary_Entry_Value* optionsList = NULL;
Dictionary_Entry_Value* optionSet = NULL;
linearSpaceAdaptor_Segment* seg = NULL;
Index segmentCount;
Index segment_I;
AbstractContext* context;
assert( self );
assert( cf );
/* Call parent construct. */
_MeshAdaptor_AssignFromXML( self, cf, data );
context = (AbstractContext*)Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Context", AbstractContext, False, data );
if( !context )
context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", AbstractContext, True, data );
self->loadFromCheckPoint = context->loadFromCheckPoint;
if( self->loadFromCheckPoint )
return;
self->minX = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minX" ) );
self->maxX = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxX" ) );
self->minY = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minY" ) );
self->maxY = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxY" ) );
self->minZ = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"minZ" ) );
self->maxZ = Dictionary_Entry_Value_AsDouble( Dictionary_Get( cf->rootDict, (Dictionary_Entry_Key)"maxZ" ) );
/* Read mapping functions - X axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionX" );
if( optionsList ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsx = segmentCount;
self->tablex = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table x" );
memset( self->tablex, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0 ; segment_I < segmentCount ; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tablex[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsx = 0;
}
/* Read mapping functions - Y axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionY" );
if( optionsList ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsy = segmentCount;
self->tabley = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table y" );
memset( self->tabley, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0; segment_I < segmentCount; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tabley[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsy = 0;
}
/* Read mapping functions - Z axis*/
optionsList = Dictionary_Get( dictionary, (Dictionary_Entry_Key)"mappingFunctionZ" );
if( optionsList && ((DomainContext*)context)->dim==3 ) {
segmentCount = Dictionary_Entry_Value_GetCount(optionsList );
self->nSegmentsz = segmentCount;
self->tablez = Memory_Alloc_Array( linearSpaceAdaptor_Segment , segmentCount, "mapping table z" );
memset( self->tablez, 0, segmentCount * sizeof(linearSpaceAdaptor_Segment) );
for ( segment_I = 0 ; segment_I < segmentCount ; segment_I++) {
optionSet = Dictionary_Entry_Value_GetElement(optionsList, segment_I );
seg = &(self->tablez[segment_I]);
seg->x = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"point" ) );
seg->y = Dictionary_Entry_Value_AsDouble( Dictionary_Entry_Value_GetMember( optionSet, (Dictionary_Entry_Key)"mappedTo" ) );
}
} else {
self->nSegmentsz = 0;
}
_LinearSpaceAdaptor_Init( self );
}
int main( int argc, char *argv[] ) {
int rank;
int procCount;
int procToWatch;
Stream* stream;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &procCount );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
BaseFoundation_Init( &argc, &argv );
RegressionTest_Init( "Base/Automation/Stg_Component" );
BaseIO_Init( &argc, &argv );
BaseContainer_Init( &argc, &argv );
BaseAutomation_Init( &argc, &argv );
stream = Journal_Register( Info_Type, __FILE__ );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) {
Stg_ComponentMeta* metaTest;
XML_IO_Handler* io;
Dictionary* allDict;
Dictionary* compDict;
CompositeVC* vc;
Journal_Printf( stream, "%s\n", Stg_Component_GetMetadata() );
metaTest = Stg_Component_CreateMeta( "blah", Variable_Type );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
allDict = Dictionary_New();
io = XML_IO_Handler_New();
IO_Handler_ReadAllFromFile( io, "data/metatest.xml", allDict );
compDict = Dictionary_GetDictionary( allDict, "components" );
vc = CompositeVC_DefaultNew( "vc" );
metaTest = Stg_Component_Validate( vc, CompositeVC_Type, compDict );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
Stg_Class_Delete( io );
Stg_Class_Delete( compDict );
}
BaseAutomation_Finalise();
BaseContainer_Finalise();
BaseIO_Finalise();
RegressionTest_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
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);
}
