void Variable_SetValueFromDictionary( void* _variable, Index index, Dictionary* dictionary ) {
Variable* variable = (Variable*)_variable;
Variable_Update( variable );
/* Assign variable from dictionary according to data type */
switch (variable->dataTypes[0]) {
case Variable_DataType_Char:
Variable_SetValueChar( variable, index, Dictionary_GetUnsignedInt( dictionary, variable->name ));
break;
case Variable_DataType_Short:
Variable_SetValueShort( variable, index, Dictionary_GetUnsignedInt( dictionary, variable->name ));
break;
case Variable_DataType_Int:
Variable_SetValueInt( variable, index, Dictionary_GetInt( dictionary, (Dictionary_Entry_Key)variable->name ) );
break;
case Variable_DataType_Float:
Variable_SetValueFloat( variable, index, Dictionary_GetDouble( dictionary, variable->name ));
break;
case Variable_DataType_Double:
Variable_SetValueDouble( variable, index, Dictionary_GetDouble( dictionary, variable->name ));
break;
default: {
Journal_Printf(
Journal_MyStream( Error_Type, variable ),
"In func %s: Unable to set value of %s from dictionary.",
__func__,
variable->name );
}
}
}
void _SLE_Solver_Init( SLE_Solver* self, Bool useStatSolve, int statReps ) {
self->isConstructed = True;
self->extensionManager = ExtensionManager_New_OfExistingObject( self->name, self );
self->debug = Stream_RegisterChild( StgFEM_SLE_SystemSetup_Debug, self->type );
self->info = Journal_MyStream( Info_Type, self );
self->maxIterations = 0;
self->hasSolved = False;
self->previoustimestep = 0;
self->currenttimestep = 0;
self->nonlinearitsinitialtime = 0;
self->nonlinearitsendtime = 0;
self->totalnonlinearitstime = 0;
self->totalnumnonlinearits = 0;
self->avgtimenonlinearits = 0;
self->inneritsinitialtime = 0;
self->outeritsinitialtime = 0;
self->inneritsendtime = 0;
self->outeritsendtime = 0;
self->totalinneritstime = 0;
self->totalouteritstime = 0;
self->totalnuminnerits = 0;
self->totalnumouterits = 0;
self->avgnuminnerits = 0;
self->avgnumouterits = 0;
self->avgtimeinnerits = 0;
self->avgtimeouterits = 0;
self->useStatSolve = useStatSolve;
self->nStatReps = statReps;
}
void _GeneralSwarm_UpdateHook( void* timeIntegrator, void* swarm )
{
GeneralSwarm* self = (GeneralSwarm*)swarm;
Index cell;
Index point_I;
GlobalParticle* particle;
/* Need to check for escaped particles before the next block. */
if ( self->escapedRoutine )
{
Stg_Component_Execute( self->escapedRoutine, self, True );
}
/* Check that particles have not exited the box after advection */
if ( self->swarmAdvector )
{
for ( point_I = 0; point_I < self->particleLocalCount; ++point_I )
{
particle = (GlobalParticle*)Swarm_ParticleAt( self, point_I );
cell = particle->owningCell;
Journal_Firewall(
cell < self->cellLocalCount,
Journal_MyStream( Error_Type, self ),
"In func %s: GlobalParticle '%d' outside element. Coord = {%g, %g, %g}\n",
__func__,
point_I,
particle->coord[ I_AXIS ],
particle->coord[ J_AXIS ],
particle->coord[ K_AXIS ] );
}
}
}
void _FileParticleLayout_Init( void* particleLayout, Name filename )
{
FileParticleLayout* self = (FileParticleLayout*) particleLayout;
self->filename = StG_Strdup( filename );
self->file = NULL;
self->errorStream = Journal_MyStream( Error_Type, self );
_GlobalParticleLayout_Init( self, GlobalCoordSystem, False, 0, 0.0 );
}
void _OneToOneMapper_Init( void* mapper, MaterialPointsSwarm* materialSwarm ) {
OneToOneMapper* self = (OneToOneMapper*)mapper;
self->errorStream = Journal_MyStream( Error_Type, self );
self->materialSwarm = materialSwarm;
ExtensionManager_SetLockDown( self->integrationSwarm->particleExtensionMgr, False );
self->materialRefHandle = ExtensionManager_Add( self->integrationSwarm->particleExtensionMgr, (Name)materialSwarm->name, sizeof(MaterialPointRef) );
ExtensionManager_SetLockDown( self->integrationSwarm->particleExtensionMgr, True );
}
void _TimeIntegrator_ExecuteRK2Simultaneous( void* timeIntegrator, void* data ) {
TimeIntegrator* self = (TimeIntegrator*)timeIntegrator;
AbstractContext* context = (AbstractContext*) data;
Index integrand_I;
Index integrandCount = TimeIntegrator_GetCount( self );
double dt = self->dt;
TimeIntegrand* integrand;
Variable** originalVariableList;
assert(0); /* this shit be broken */
Journal_DPrintf( self->debug, "In %s for %s '%s'\n", __func__, self->type, self->name );
Journal_Firewall(
False,
Journal_MyStream( Error_Type, self ),
"Error in %s '%s' - This function is temporarily unavailable \n"
"Please only use non-simultaneous update or only first order update.\n",
self->type, self->name );
/* Set Time */
TimeIntegrator_SetTime( self, context->currentTime );
originalVariableList = Memory_Alloc_Array( Variable*, integrandCount, "originalVariableList" );
TimeIntegrator_Setup( self );
for ( integrand_I = 0 ; integrand_I < integrandCount ; integrand_I++ ) {
integrand = TimeIntegrator_GetByIndex( self, integrand_I );
Journal_RPrintf(self->info,"\t2nd order (simultaneous): %s\n", integrand->name);
/* Store Original */
originalVariableList[ integrand_I ] = Variable_NewFromOld( integrand->variable, "Original", True );
/* Predictor Step */
TimeIntegrand_FirstOrder( integrand, integrand->variable, 0.5 * dt );
}
TimeIntegrator_Finalise( self );
/* Set Time */
TimeIntegrator_SetTime( self, context->currentTime + 0.5 * dt );
TimeIntegrator_Setup( self );
for ( integrand_I = 0 ; integrand_I < integrandCount ; integrand_I++ ) {
integrand = TimeIntegrator_GetByIndex( self, integrand_I );
/* Corrector Step */
TimeIntegrand_FirstOrder( integrand, originalVariableList[ integrand_I ], dt );
/* Free Original */
Stg_Class_Delete( originalVariableList[ integrand_I ] );
}
TimeIntegrator_Finalise( self );
Memory_Free( originalVariableList );
}
void _MaterialPointsSwarm_Initialise( void* swarm, void* data ) {
MaterialPointsSwarm* self = (MaterialPointsSwarm*) swarm;
AbstractContext* context = (AbstractContext*)self->context;
Index var_I = 0;
Particle_Index lParticle_I=0;
MaterialPoint* matPoint=NULL;
_GeneralSwarm_Initialise( self, data );
if( self->material != NULL) Stg_Component_Initialise( self->material, data , False );
/* Now setup the material properties */
if( (False == context->loadFromCheckPoint) || False == (context->loadSwarmsFromCheckpoint) ) {
/* Beforehand, set each particle to have UNDEFINED_MATERIAL */
for ( lParticle_I = 0; lParticle_I < self->particleLocalCount; lParticle_I++ ) {
matPoint = (MaterialPoint*)Swarm_ParticleAt( self, lParticle_I );
matPoint->materialIndex = UNDEFINED_MATERIAL;
}
if( self->material == NULL ) {
/* Do it by the layout of all known materials */
Materials_Register_SetupSwarm( self->materials_Register, self );
}
else {
Material_Layout( self->material, self );
Materials_Register_AssignParticleProperties(
self->materials_Register,
self,
self->swarmVariable_Register->variable_Register );
}
}
if( self->overrideMaterialCheck == False ) {
/* Check to ensure all particles have a valid material */
for ( lParticle_I = 0; lParticle_I < self->particleLocalCount; lParticle_I++ ) {
matPoint = (MaterialPoint*)Swarm_ParticleAt( self, lParticle_I );
Journal_Firewall( (matPoint->materialIndex != UNDEFINED_MATERIAL), Journal_MyStream( Error_Type, self ),
"Error in function %s for swarm '%s'. Material point at (%.5g, %.5g, %.5g), has no material assigned to it.\n"
"This is most likely because the material geometries don't cover the entire domain - check material/geometry definitions\n\n"
"To check: visualise the material index field initialisation by running your model with the commandline options\n"
"\t\'--maxTimeSteps=-1 --components.%s.overrideMaterialCheck=True\'\n", __func__, self->name, matPoint->coord[0], matPoint->coord[1], matPoint->coord[2], self->name);
}
}
}
void _IntegrationPointsSwarm_AssignFromXML( void* integrationPoints, Stg_ComponentFactory* cf, void* data ) {
IntegrationPointsSwarm* self = (IntegrationPointsSwarm*) integrationPoints;
FeMesh* mesh;
TimeIntegrator* timeIntegrator;
WeightsCalculator* weights;
IntegrationPointMapper* mapper;
Materials_Register* materials_Register;
Bool recalculateWeights;
PICelleratorContext* context;
/* This will also call _Swarm_Init */
_Swarm_AssignFromXML( self, cf, data );
mesh = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"FeMesh", FeMesh, True, data );
timeIntegrator = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"TimeIntegrator", TimeIntegrator, False, data );
weights = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"WeightsCalculator", WeightsCalculator, False, data );
mapper = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"IntegrationPointMapper", IntegrationPointMapper, False, data );
recalculateWeights = Stg_ComponentFactory_GetBool( cf, self->name, (Dictionary_Entry_Key)"recalculateWeights", True );
if( mapper !=NULL ) {
Journal_Firewall (
weights != NULL ||
(weights == NULL && (Stg_Class_IsInstance( mapper, GaussMapper_Type ) ||
Stg_Class_IsInstance( mapper, GaussCoincidentMapper_Type) ||
!strcmp( mapper->type, "PCDVCGaussMapper"))),
Journal_MyStream( Error_Type, self ),
"In func %s, %s which is a %s must either have a %s or use %s\n",
__func__,
self->name,
self->type,
WeightsCalculator_Type,
GaussMapper_Type );
}
context = (PICelleratorContext*)self->context;
assert( Stg_CheckType( context, PICelleratorContext ) );
materials_Register = context->materials_Register;
assert( materials_Register );
_IntegrationPointsSwarm_Init( self, mesh, timeIntegrator, weights, mapper, materials_Register, recalculateWeights );
}
void _StiffnessMatrixTerm_Init(
void* stiffnessMatrixTerm,
FiniteElementContext* context,
StiffnessMatrix* stiffnessMatrix,
Swarm* integrationSwarm,
Stg_Component* extraInfo )
{
StiffnessMatrixTerm* self = (StiffnessMatrixTerm*) stiffnessMatrixTerm;
self->isConstructed = True;
self->context = context;
self->debug = Journal_MyStream( Debug_Type, self );
self->extraInfo = extraInfo;
self->integrationSwarm = integrationSwarm;
self->stiffnessMatrix = stiffnessMatrix;
self->max_nElNodes = 0; /* initialise to zero, in assembly routine it will change value */
self->GNx = NULL;
if(stiffnessMatrix)
StiffnessMatrix_AddStiffnessMatrixTerm( stiffnessMatrix, self );
}
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" );
}
}
/* remember this only has to initialise one cell of particles at a time */
void _TriGaussParticleLayout_InitialiseParticlesOfCell( void* triGaussParticleLayout, void* _swarm, Cell_Index cell_I )
{
#define MAX_DIM 3
#define MAX_GAUSS_POINTS_2D 1
#define MAX_GAUSS_POINTS_3D 1
TriGaussParticleLayout* self = (TriGaussParticleLayout*)triGaussParticleLayout;
Swarm* swarm = (Swarm*)_swarm;
IntegrationPoint* integrationPoint = NULL;
Particle_InCellIndex cParticle_I = 0;
Particle_InCellIndex ppc;
int dim;
double weight[1];
double xi[20][3];
static int beenHere = 0;
int d;
dim = self->dim;
ppc = self->particlesPerCell;
if( dim == 2 ) {
if( ppc == 1 ) {
weight[0] = 0.5;
xi[0][0] = 0.333333333333;
xi[0][1] = 0.333333333333;
}
if( ppc > MAX_GAUSS_POINTS_2D ) {
Journal_Firewall(
ppc > MAX_GAUSS_POINTS_2D,
Journal_MyStream( Error_Type, self ),
"In %s(), error: particlesPerCell greater than implementated tabulated gauss values of %d\n",
__func__,
MAX_GAUSS_POINTS_2D );
}
}
else if ( dim == 3 ) {
if( ppc == 1 ) {
weight[0] = 0.5;
xi[0][0] = 0.333333333333;
xi[0][1] = 0.333333333333;
xi[0][2] = 0.333333333333;
}
if( ppc > MAX_GAUSS_POINTS_3D ) {
Journal_Firewall(
ppc > MAX_GAUSS_POINTS_3D,
Journal_MyStream( Error_Type, self ),
"In %s(), error: particlesPerCell greater than implementated tabulated gauss values of %d\n",
__func__,
MAX_GAUSS_POINTS_3D );
}
}
assert( ppc <= swarm->cellParticleCountTbl[cell_I] );
for ( cParticle_I = 0; cParticle_I < ppc; cParticle_I++ ) {
integrationPoint = (IntegrationPoint*)Swarm_ParticleInCellAt( swarm, cell_I, cParticle_I );
integrationPoint->owningCell = cell_I;
for( d = 0; d < dim; d++ ) {
/*integrationPoint->coord[d] = xi[cParticle_I][d];*/
integrationPoint->xi[d] = xi[cParticle_I][d];
}
integrationPoint->weight = weight[cParticle_I];
beenHere = 1;
}
}