void _RefinedRegionsGeometry_Init( RefinedRegionsGeometry* self, IJK size ) {
Dimension_Index dim_I;
Dictionary_Entry_Value* regionsList = NULL;
/* General and Virtual info should already be set */
/* RefinedRegionsGeometry info */
self->isConstructed = False;
self->min[ I_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "minX", 0.0f );
self->min[ J_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "minY", 0.0f );
self->min[ K_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "minZ", 0.0f );
self->max[ I_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "maxX", 1.0f );
self->max[ J_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "maxY", 1.0f );
self->max[ K_AXIS ] = Dictionary_GetDouble_WithDefault( self->dictionary, "maxZ", 1.0f );
if ( size ) {
memcpy( self->countPerDim, size, sizeof(IJK) );
}
else {
self->countPerDim[ I_AXIS ] = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "meshSizeI", 2 );
self->countPerDim[ J_AXIS ] = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "meshSizeJ", 2 );
self->countPerDim[ K_AXIS ] = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "meshSizeK", 2 );
}
for ( dim_I = 0; dim_I < 3; dim_I++ ) {
self->refinedRegionDeltas[dim_I] = 4;
}
/* Now Read in the refined regions */
regionsList = Dictionary_Get( self->dictionary, "RefinedRegions" );
if ( regionsList ) {
Index entryCount = Dictionary_Entry_Value_GetCount( regionsList );
Index entry_I = 0;
Dictionary_Entry_Value* regionEntry;
Dictionary* regionDict;
Dimension_Index dim = 0;
double regionStart = 0;
double regionEnd = 0;
unsigned int refinementFactor = 1;
for( entry_I = 0; entry_I < entryCount; entry_I++ ) {
regionEntry = Dictionary_Entry_Value_GetElement( regionsList, entry_I );
regionDict = Dictionary_Entry_Value_AsDictionary( regionEntry );
dim = Dictionary_GetUnsignedInt_WithDefault( regionDict, "dim", 0 );
regionStart = Dictionary_GetDouble_WithDefault( regionDict, "regionStart", 0.0 );
regionEnd = Dictionary_GetDouble_WithDefault( regionDict, "regionEnd", 1.0 );
refinementFactor = Dictionary_GetUnsignedInt_WithDefault( regionDict, "refinementFactor", 2 );
_RefinedRegionsGeometry_AddRefinedRegion( self, dim, regionStart, regionEnd, refinementFactor );
}
}
self->pointCount = self->countPerDim[I_AXIS] * self->countPerDim[J_AXIS] *
self->countPerDim[K_AXIS];
assert( self->pointCount );
}
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 SemiLagrangianIntegratorSuite_Line( Node_LocalIndex node_lI, Variable_Index var_I, void* _context, void* _data, void* _result ) {
FiniteElementContext* context = (FiniteElementContext*)_context;
Dictionary* dictionary = context->dictionary;
FeVariable* feVariable = (FeVariable*) FieldVariable_Register_GetByName( context->fieldVariable_Register, "PhiField" );
FeMesh* mesh = feVariable->feMesh;
double* coord = Mesh_GetVertex( mesh, node_lI );
double* result = (double*)_result;
double width = Dictionary_GetDouble_WithDefault( dictionary, (Dictionary_Entry_Key)"lineWidth", 1.0 );
double lineRadius = Dictionary_GetDouble_WithDefault( dictionary, (Dictionary_Entry_Key)"lineRadius", 10.0 );
double radius = sqrt( (coord[0] - 0.5)*(coord[0] - 0.5) + (coord[1] - 0.5)*(coord[1] - 0.5) );
if( fabs( coord[0] - coord[1] ) < width && radius < lineRadius )
*result = 2.0;
else
*result = 1.0;
}
double _Stg_ComponentFactory_GetRootDictDouble( void* cf, Dictionary_Entry_Key key, const double defaultVal ) {
Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf;
Journal_PrintfL( self->infoStream, 2, "Getting double from root dictionary with key '%s' and default value '%g'\n",
key, defaultVal );
assert( self->rootDict );
return Dictionary_GetDouble_WithDefault( self->rootDict, key, defaultVal );
}
void _ManualParticleLayout_InitialiseParticle(
void* manualParticleLayout,
void* _swarm,
Particle_Index newParticle_I,
void* _particle )
{
ManualParticleLayout* self = (ManualParticleLayout*)manualParticleLayout;
Dictionary_Entry_Value* manualParticlePositions = NULL;
Dictionary_Entry_Value* particlePositionEntry = NULL;
Dictionary* particlePositionDict = NULL;
GlobalParticle* particle = (GlobalParticle*)_particle;
manualParticlePositions = Dictionary_Get( self->dictionary, (Dictionary_Entry_Key)"manualParticlePositions" );
particlePositionEntry = Dictionary_Entry_Value_GetElement( manualParticlePositions, newParticle_I );
particlePositionDict = Dictionary_Entry_Value_AsDictionary( particlePositionEntry );
particle->coord[I_AXIS] = Dictionary_GetDouble_WithDefault( particlePositionDict, (Dictionary_Entry_Key)"x", 0.0 );
particle->coord[J_AXIS] = Dictionary_GetDouble_WithDefault( particlePositionDict, (Dictionary_Entry_Key)"y", 0.0 );
particle->coord[K_AXIS] = Dictionary_GetDouble_WithDefault( particlePositionDict, (Dictionary_Entry_Key)"z", 0.0 );
}
void CalcDeflectionAndCheckGravity( UnderworldContext* context ) {
IntegrationPointsSwarm* swarm = (IntegrationPointsSwarm*)LiveComponentRegister_Get( context->CF->LCRegister, (Name)"picIntegrationPoints" );
GlobalParticle* particle;
MaterialPointsSwarm** materialSwarms;
MaterialPointsSwarm* materialSwarm;
Index swarmLength;
double defMax = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"defMax", 0.35 );
double deflection = 0.0;
Coord coord;
double distance;
static int visits = 0;
static double initial_position = 0.0;
materialSwarms = IntegrationPointMapper_GetMaterialPointsSwarms( swarm->mapper, &swarmLength );
/* assume first swarm for now!!! */
materialSwarm = materialSwarms[0];
if (visits == 0) {
coord[0] = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"x_mid", 0.75 );
coord[1] = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"y_mid", 0.75 );
coord[2] = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"z_mid", 0.0 );
closestParticle_I = Swarm_FindClosestParticle( materialSwarm, 2, coord, &distance );
}
particle = (GlobalParticle*)Swarm_ParticleAt( materialSwarm, closestParticle_I );
if (visits==0)
initial_position = particle->coord[1];
visits=1;
deflection = initial_position - particle->coord[1];
if ( deflection >= defMax ) {
TurnOffGravity( context );
}
StgFEM_FrequentOutput_PrintValue( context, deflection );
}
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" ) );
}
void _FieldVariableConditionFunctionSecondCopy_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data ) {
FieldVariableConditionFunctionSecondCopy* self = (FieldVariableConditionFunctionSecondCopy*)component;
Dictionary* pluginDict = Codelet_GetPluginDictionary( component, cf->rootDict );
/** field variable which we will interrogate to determine values */
self->fieldVariable = Stg_ComponentFactory_PluginConstructByKey( cf, self, (Dictionary_Entry_Key)"FieldVariable", FieldVariable, True, data );
/** target fevariable */
self->targetfeVariable = Stg_ComponentFactory_PluginConstructByKey( cf, self, (Dictionary_Entry_Key)"TargetFeVariable", FeVariable, True, data );
self->failTolerance = Dictionary_GetDouble_WithDefault( pluginDict, (Dictionary_Entry_Key)"FailureTolerance" , 0.001 );
ConditionFunction_Register_Add( condFunc_Register, ConditionFunction_New( FieldVariableConditionFunctionSecondCopy_getVal, (Name)self->type, 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 StGermain_SingleAttractor_UpdatePositions( DomainContext* context ) {
Cell_LocalIndex lCell_I;
Particle_InCellIndex cParticle_I;
Particle* currParticle;
Index dim_I;
Swarm* swarm = (Swarm*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"swarm" );
Coord attractorPoint;
Mesh* mesh;
Stream* stream = Journal_Register( Info_Type, (Name)"particleUpdate" );
unsigned int movementSpeedDivisor = 0;
int movementSign = 1;
unsigned int explosionPeriod = 20;
double minCrd[3], maxCrd[3];
Stream_SetPrintingRank( stream, Dictionary_GetUnsignedInt_WithDefault( context->dictionary, "procToWatch", 0 ) );
movementSpeedDivisor = Dictionary_GetDouble_WithDefault( context->dictionary, (Dictionary_Entry_Key)"movementSpeedDivisor", 10 );
mesh = (Mesh* )LiveComponentRegister_Get( context->CF->LCRegister, (Name)"mesh-linear" );
Mesh_GetGlobalCoordRange( mesh, minCrd, maxCrd );
for ( dim_I=0; dim_I < 3; dim_I++ ) {
attractorPoint[dim_I] = (maxCrd[dim_I] - minCrd[dim_I]) / 3;
}
Journal_Printf( stream, "Calculated attractor point is at (%f,%f,%f):\n", attractorPoint[0], attractorPoint[1], attractorPoint[2] );
/* Now decide if we are attracting or repelling */
if ( ( ( (context->timeStep - 1) / explosionPeriod ) % 2 ) == 0 ) {
Journal_Printf( stream, "Timestep %d - Implosive mode\n", context->timeStep );
movementSign = 1;
}
else {
Journal_Printf( stream, "Timestep %d - Explosive mode\n", context->timeStep );
movementSign = -1;
}
for ( lCell_I=0; lCell_I < swarm->cellLocalCount; lCell_I++ ) {
Journal_Printf( stream, "\tUpdating Particles positions in local cell %d:\n", lCell_I );
for ( cParticle_I=0; cParticle_I < swarm->cellParticleCountTbl[lCell_I]; cParticle_I++ ) {
Coord movementVector = {0,0,0};
Coord newParticleCoord = {0,0,0};
Coord* oldCoord;
currParticle = (Particle*)Swarm_ParticleInCellAt( swarm, lCell_I, cParticle_I );
oldCoord = &currParticle->coord;
Journal_Printf( stream, "\t\tUpdating particleInCell %d:\n", cParticle_I );
for ( dim_I=0; dim_I < 3; dim_I++ ) {
movementVector[dim_I] = ( attractorPoint[dim_I] - (*oldCoord)[dim_I] ) /
movementSpeedDivisor;
movementVector[dim_I] *= movementSign;
if ( movementSign == -1 ) {
movementVector[dim_I] *= (float)movementSpeedDivisor / (movementSpeedDivisor-1);
}
newParticleCoord[dim_I] = (*oldCoord)[dim_I] + movementVector[dim_I];
}
memcpy( currParticle->velocity, movementVector, 3*sizeof(double) );
Journal_Printf( stream, "\t\tChanging its coords from (%f,%f,%f) to (%f,%f,%f):\n",
(*oldCoord)[0], (*oldCoord)[1], (*oldCoord)[2],
newParticleCoord[0], newParticleCoord[1], newParticleCoord[2] );
for ( dim_I=0; dim_I < 3; dim_I++ ) {
currParticle->coord[dim_I] = newParticleCoord[dim_I];
}
}
}
Swarm_UpdateAllParticleOwners( swarm );
}
void _ParticleMelting_Build( void* _self, void* data ) {
ParticleMelting* self = (ParticleMelting*) _self;
Materials_Register* matReg = self->materialSwarm->materials_Register;
ParticleMelting_MatExt *matExt = NULL;
unsigned materialCount, mat_i;
Material* material = NULL;
Stg_Component_Build( self->temperatureField, data, False );
Stg_Component_Build( self->materialSwarm, data, False );
if( self->pressureField )
Stg_Component_Build( self->pressureField, data, False );
if( self->scaling ) {
Stg_Component_Build( self->scaling, data, False );
self->refRho = Scaling_Scale( self->scaling, 3400, sDensity );
self->gravity = Scaling_Scale( self->scaling, 9.81, sAcceleration );
} else {
self->refRho = 1.0;
self->gravity = 1.0;
}
/* now we extend the materials with ParticleMelting_MatExt */
self->materialExtHandle = Materials_Register_AddMaterialExtension( matReg, self->type, sizeof(ParticleMelting_MatExt) );
materialCount = Materials_Register_GetCount( matReg );
for( mat_i = 0 ; mat_i < materialCount ; mat_i++ ) {
material = Materials_Register_GetByIndex( matReg, mat_i );
matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle );
/* get latent heat and specific heat from the material dictionary */
matExt->lhf = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"latentHeat_Fusion", 0.0 );
matExt->Cp = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"Cp", 1.0 );
matExt->TurnMeltOn = Dictionary_GetBool_WithDefault( material->dictionary, (Dictionary_Entry_Key)"TurnMeltOn", 0.0 );
/* read in values from xml file for solidus polynomial */
matExt->sCoeff[0] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff0", 0.0 );
matExt->sCoeff[1] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff1", 0.0 );
matExt->sCoeff[2] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff2", 0.0 );
matExt->sCoeff[3] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff3", 0.0 );
/* read in values from xml file for liquidus polynomial */
matExt->lCoeff[0] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff0", 0.0 );
matExt->lCoeff[1] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff1", 0.0 );
matExt->lCoeff[2] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff2", 0.0 );
matExt->lCoeff[3] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff3", 0.0 );
matExt->deepPressure = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"deepPressure", 0.0 );
/* read in values from xml file for solidus polynomial (deep)*/
matExt->sCoeffDeep[0] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff0_deep", matExt->sCoeff[0] );
matExt->sCoeffDeep[1] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff1_deep", matExt->sCoeff[1] );
matExt->sCoeffDeep[2] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff2_deep", matExt->sCoeff[2] );
matExt->sCoeffDeep[3] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"solidus_coeff3_deep", matExt->sCoeff[3] );
/* read in values from xml file for liquidus polynomial */
matExt->lCoeffDeep[0] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff0_deep", matExt->lCoeff[0] );
matExt->lCoeffDeep[1] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff1_deep", matExt->lCoeff[1] );
matExt->lCoeffDeep[2] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff2_deep", matExt->lCoeff[2] );
matExt->lCoeffDeep[3] = Dictionary_GetDouble_WithDefault( material->dictionary, (Dictionary_Entry_Key)"liquidus_coeff3_deep", matExt->lCoeff[3] );
}
EP_PrependClassHook_AlwaysFirst(
Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ),
ParticleMelting_MeltFrationUpdate,
self );
/*
EP_InsertClassHookBefore(
Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ),
"_ParticleFeVariable_Execute",
ParticleMelting_MeltFrationUpdate,
self );
*/
}