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 ); }
char* _Stg_ComponentFactory_GetRootDictString( void* cf, Dictionary_Entry_Key key, const char* const defaultVal ) { Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf; Journal_PrintfL( self->infoStream, 2, "Getting string from root dictionary with key '%s' and default value '%s'\n", key, defaultVal ); assert( self->rootDict ); return Dictionary_GetString_WithDefault( self->rootDict, key, defaultVal ); }
void DictionarySuite_TestShortcuts( DictionarySuiteData* data ) { DictionarySuite_PopulateDictWithTestValues( data->dict, data->testDD ); /* Testing GetString_WithDefault. If an entry with that key already exists, then * the value of the existing key should be returned, and the default passed in * ignored. However if the given key _doesn't_ exist, the default should be * returned, and a new entry with the given key added to the dict. */ pcu_check_streq( data->testDD->testString, Dictionary_GetString_WithDefault( data->dict, "test_cstring", "heya" ) ); pcu_check_streq( "heya", Dictionary_GetString_WithDefault( data->dict, "test_cstring2", "heya" ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_cstring2" ) ); data->testDD->testDouble = Dictionary_GetDouble_WithDefault( data->dict, (Dictionary_Entry_Key)"test_double", 2.8 ); pcu_check_true( data->testDD->testDouble ); pcu_check_true( 2.8 == Dictionary_GetDouble_WithDefault( data->dict, (Dictionary_Entry_Key)"test_double2", 2.8 ) ); /* test_placeholder refers to test_double which equals 45.567 */ pcu_check_true( 45.567 == Dictionary_GetDouble_WithScopeDefault( data->dict, (Dictionary_Entry_Key)"test_placeholder", -1 ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_double2" ) ); data->testDD->testUint = Dictionary_GetUnsignedInt_WithDefault( data->dict, "test_uint", 33 ); pcu_check_true( data->testDD->testUint ); pcu_check_true( 33 == Dictionary_GetUnsignedInt_WithDefault( data->dict, "test_uint2", 33 ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_uint2" ) ); data->testDD->testInt = Dictionary_GetInt_WithDefault( data->dict, (Dictionary_Entry_Key)"test_int", -24 ); pcu_check_true( data->testDD->testInt ); pcu_check_true( -24 == Dictionary_GetInt_WithDefault( data->dict, (Dictionary_Entry_Key)"test_int2", -24 ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_int2" ) ); data->testDD->testUnsignedlong = Dictionary_GetUnsignedLong_WithDefault( data->dict, "test_unsignedlong", 32433 ); pcu_check_true( data->testDD->testUnsignedlong ); pcu_check_true( 32433 == Dictionary_GetUnsignedLong_WithDefault( data->dict, "test_unsignedlong2", 32433 ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_unsignedlong2" ) ); data->testDD->testBool = Dictionary_GetBool_WithDefault( data->dict, (Dictionary_Entry_Key)"test_bool", False ); pcu_check_true( data->testDD->testBool ); pcu_check_true( False == Dictionary_GetBool_WithDefault( data->dict, (Dictionary_Entry_Key)"test_bool2", False ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_bool2" ) ); pcu_check_streq( data->testDD->testString, Dictionary_GetString_WithPrintfDefault( data->dict, "test_cstring", "heya%s%u", "hey", 3 ) ); pcu_check_streq( "heyahey3", Dictionary_GetString_WithPrintfDefault( data->dict, "test_cstring3", "heya%s%u", "hey", 3 ) ); pcu_check_true( NULL != Dictionary_Get( data->dict, (Dictionary_Entry_Key)"test_cstring3" ) ); }
Stg_Component* _Stg_ComponentFactory_ConstructByName( void* cf, Name componentName, Type type, Bool isEssential, void* data ) { Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf; Stg_Component* component; Stream* stream = self->infoStream; Journal_PrintfL( stream, 2, "Looking for %sessential component '%s': ", (isEssential ? "" : "non-"), componentName ); component = LiveComponentRegister_Get( self->LCRegister, componentName ); /* Checking */ if (component) { Journal_PrintfL( stream, 2, "Found.\n" ); if ( !component->isConstructed ) { /* Journal_Printf( stream, "%s has not been constructed yet. Constructing now.\n", componentName ); */ Stream_Indent( stream ); Stg_Component_AssignFromXML( component, self, data, True ); Stream_UnIndent( stream ); } Stg_Class_CheckType( component, type ); } else { Name redirect; /* 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 ); } } Journal_PrintfL( stream, 2, "Not found.\n" ); if ( isEssential ) { Stream* errorStream = Journal_Register( Error_Type, self->type ); Journal_Printf( errorStream, "In func %s: Cannot find essential component '%s'.\n", __func__, componentName ); Journal_Printf( errorStream, "Could you have meant one of these?\n" ); Stream_Indent( errorStream ); LiveComponentRegister_PrintSimilar( self->LCRegister, componentName, errorStream, 5 ); Journal_Firewall( 0, errorStream, "" ); } } return component; }
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 ); }
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 ); }
char* Dictionary_GetString_WithPrintfDefault( Dictionary* dictionary, Dictionary_Entry_Key key, char* format, ... ) { char* returnString; char* defaultVal; va_list ap; va_start( ap, format ); /* Create Default String from format arguments */ Stg_vasprintf( &defaultVal, format, ap ); /* Read Dictionary */ returnString = Dictionary_GetString_WithDefault( dictionary, key, defaultVal ); /* Clean up */ Memory_Free( defaultVal ); va_end( ap ); return returnString; }
void Experimental_NodeTempProfile( PICelleratorContext* context ) { #if 0 static FeVariable* temperatureFe; FiniteElement_Mesh* mesh; double* nodeCoord; double lmaxTemp, nodeTemp; Index lNode_I, newNodeID; int startProfileNodeID; static Bool beenHere = False; Stream* stream = Journal_Register( Info_Type, (Name)"TempNodeHeight" ); char* filename; double* maxTempList = Memory_Alloc_Array( double, context->nproc, "Hold the max temperature of each array"); unsigned rootProc; rootProc = 0; if (!beenHere) { Name tempFeName; tempFeName = Dictionary_GetString_WithDefault( context->dictionary, "TemperatureField", "TemperatureField" ); /* Get TemperatureField FeVariable */ temperatureFe = (FeVariable*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)tempFeName ); assert( temperatureFe ); /* Set up stream */ Stg_asprintf( &filename, "CylinderNodeProfiling.%dof%d.dat", context->rank, context->nproc ); Stream_RedirectFile_WithPrependedPath( stream, context->outputPath, filename ); Memory_Free( filename ); Stream_SetAutoFlush( stream, True ); /* Print header to stream */ Journal_Printf( stream, "Timestep\tCentralPosition\t\tNodeTemperature\n" ); beenHere = True; } mesh = temperatureFe->feMesh; for( lNode_I = 0; lNode_I < temperatureFe->feMesh->nodeLocalCount ; lNode_I++ ) { nodeTemp = FeVariable_GetScalarAtNode( temperatureFe , lNode_I ); if( lNode_I == 0 ) { lmaxTemp = nodeTemp; startProfileNodeID = lNode_I; } if ( nodeTemp > lmaxTemp ) { lmaxTemp = nodeTemp; startProfileNodeID = lNode_I; } } MPI_Gather( &lmaxTemp, 1, MPI_DOUBLE, maxTempList, 1, MPI_DOUBLE, rootProc, context->communicator ); Journal_Printf( stream, "%.6g ******************************\n", (double)context->timeStep ); nodeCoord = Mesh_CoordAt( mesh , startProfileNodeID ); nodeTemp = FeVariable_GetScalarAtNode( temperatureFe, startProfileNodeID ); Journal_Printf( stream, "\t\tNode Profile in Y direction, starting at (%.6g, %.6g, %.6g)\tat temperature = %g\n", nodeCoord[0], nodeCoord[1], nodeCoord[2], nodeTemp ); newNodeID = mesh->nodeNeighbourTbl[ startProfileNodeID ][ 1 ]; /* 1 = +y direction, 2 = +z direction */ if( newNodeID >= mesh->nodeLocalCount ) { /* is node NOT a local, thus stop profiling */ Journal_Printf( stream, "\t\tProfiling has reached the boundary of the local processor\n"); } else { /* continue profiling */ nodeTemp = FeVariable_GetScalarAtNode( temperatureFe, newNodeID ); while( nodeTemp > 0.0 ) { nodeCoord = Mesh_CoordAt( mesh, newNodeID ); Journal_Printf( stream, "\t\t (%.6g, %.6g, %.6g)\tat temperature = %g\n", nodeCoord[0], nodeCoord[1], nodeCoord[2], nodeTemp ); newNodeID = mesh->nodeNeighbourTbl[ newNodeID ][ 1 ]; if( newNodeID >= mesh->nodeLocalCount ) { /* is node not a local i.e. not on processor, tus stop profiling */ Journal_Printf( stream, "\t\tProfiling has reached the boundary of the local processor\n"); break; } nodeTemp = FeVariable_GetScalarAtNode( temperatureFe, newNodeID ); } } Memory_Free( maxTempList ); MPI_Barrier( context->communicator ); #endif }
void _MeshDecomp_Init( MeshDecomp* self, MPI_Comm communicator, ElementLayout* elementLayout, NodeLayout* nodeLayout, Stg_ObjectList* pointer_Register ) { /* General and Virtual info should already be set */ /* MeshDecomp info */ char* storageStr; self->isConstructed = True; self->communicator = communicator; MPI_Comm_rank( self->communicator, (int*)&self->rank ); MPI_Comm_size( self->communicator, (int*)&self->nproc ); self->procsInUse = 0; self->allowUnusedCPUs = Dictionary_GetBool_WithDefault( self->dictionary, "allowUnusedCPUs", False ) ; self->allowPartitionOnNode = Dictionary_GetBool_WithDefault( self->dictionary, "allowPartitionOnNode", True ); self->allowPartitionOnElement = Dictionary_GetBool_WithDefault( self->dictionary, "allowPartitionOnElement", False ); assert( self->allowPartitionOnNode || self->allowPartitionOnElement ); self->allowUnbalancing = Dictionary_GetBool_WithDefault( self->dictionary, "allowUnbalancing", False ); self->procTopology = NULL; /* Determine IndexSet storage type */ storageStr = Dictionary_GetString_WithDefault( self->dictionary, "selfStorage", "storeNeighbours" ); if( !strcmp( storageStr, "storeAll" ) ) { self->storage = StoreAll; } else if( !strcmp( storageStr, "storeSelf" ) ) { self->storage = StoreSelf; } else { /* !strcmp( storageStr, "storeNeighbours" ) */ self->storage = StoreNeighbours; } self->elementLayout = elementLayout; self->nodeLayout = nodeLayout; self->localElementSets = NULL; self->shadowElementSets = NULL; self->localNodeSets = NULL; self->shadowNodeSets = NULL; self->nodeGlobalCount = 0; self->nodeLocalCount = 0; self->nodeShadowCount = 0; self->nodeDomainCount = 0; self->elementGlobalCount = 0; self->elementLocalCount = 0; self->elementShadowCount = 0; self->elementDomainCount = 0; /* TODO - Hack: Registering pointer to node domain count */ if (pointer_Register) { Name nodeDomainCountName; Stg_asprintf( &nodeDomainCountName, "%s-nodeDomainCount", self->name ); /* Need to free memory somewhere! */ Stg_ObjectList_GlobalPointerAppend( pointer_Register, &self->nodeDomainCount, nodeDomainCountName ); } }