void _SnacViscoPlastic_CheckpointPlasticStrain( void* _context ) { Snac_Context* context = (Snac_Context*) _context; SnacViscoPlastic_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacViscoPlastic_ContextHandle ); Element_LocalIndex element_lI; #if DEBUG printf( "In %s()\n", __func__ ); #endif for( element_lI = 0; element_lI < context->mesh->elementLocalCount; element_lI++ ) { Snac_Element* element = Snac_Element_At( context, element_lI ); SnacViscoPlastic_Element* elementExt = ExtensionManager_Get( context->mesh->elementExtensionMgr, element, SnacViscoPlastic_ElementHandle ); Tetrahedra_Index tetra_I; for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) { float plasticStrain = elementExt->plasticStrain[tetra_I]; fwrite( &plasticStrain, sizeof(float), 1, contextExt->plStrainCheckpoint ); } fflush( contextExt->plStrainCheckpoint ); } }
void _SnacViscoPlastic_CheckpointViscosity( void* _context ) { Snac_Context* context = (Snac_Context*) _context; SnacViscoPlastic_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacViscoPlastic_ContextHandle ); Element_LocalIndex element_lI; #if DEBUG printf( "In %s()\n", __func__ ); #endif for( element_lI = 0; element_lI < context->mesh->elementLocalCount; element_lI++ ) { Snac_Element* element = Snac_Element_At( context, element_lI ); SnacViscoPlastic_Element* elementExt = ExtensionManager_Get( context->mesh->elementExtensionMgr, element, SnacViscoPlastic_ElementHandle ); Tetrahedra_Index tetra_I; double viscosity = 0.0f; float logviscosity = 0.0f; for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) { viscosity = elementExt->viscosity[tetra_I]; assert(viscosity>0.0); logviscosity = log10(viscosity); fwrite( &logviscosity, sizeof(float), 1, contextExt->viscCheckpoint ); } } fflush( contextExt->viscCheckpoint ); }
void interpolateNode( void* _context, Node_LocalIndex newNodeInd, Element_DomainIndex dEltInd ) { Snac_Context* context = (Snac_Context*)_context; SnacRemesher_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacRemesher_ContextHandle ); Mesh* mesh = context->mesh; SnacRemesher_Mesh* meshExt = ExtensionManager_Get( context->meshExtensionMgr, mesh, SnacRemesher_MeshHandle ); NodeLayout* nLayout = mesh->layout->nodeLayout; unsigned nEltNodes; Node_DomainIndex* eltNodes; Coord newNodeCoord; Coord crds[8]; double weights[4]; unsigned tetNodeInds[4]; unsigned eltNode_i; /* Extract the element's node indices. Note that there should always be eight of these. */ { Element_GlobalIndex gEltInd; nEltNodes = 8; eltNodes = Memory_Alloc_Array( Node_DomainIndex, nEltNodes, "SnacRemesher" ); gEltInd = Mesh_ElementMapDomainToGlobal( mesh, dEltInd ); nLayout->buildElementNodes( nLayout, gEltInd, eltNodes ); } /* Convert global node indices to domain. */ { unsigned eltNode_i; for( eltNode_i = 0; eltNode_i < nEltNodes; eltNode_i++ ) { eltNodes[eltNode_i] = Mesh_NodeMapGlobalToDomain( mesh, eltNodes[eltNode_i] ); } } /* Extract the new node's coordinate. */ Vector_Set( newNodeCoord, meshExt->newNodeCoords[newNodeInd] ); /* Copy coordinates. */ for( eltNode_i = 0; eltNode_i < nEltNodes; eltNode_i++ ) memcpy( crds[eltNode_i], mesh->nodeCoord[eltNodes[eltNode_i]], sizeof(Coord) ); if( !_HexaEL_FindTetBarycenter( crds, newNodeCoord, weights, tetNodeInds, INCLUSIVE_UPPER_BOUNDARY, NULL, 0 ) ) abort(); SnacRemesher_InterpolateNode( context, contextExt, newNodeInd, dEltInd, 0, tetNodeInds, weights, meshExt->newNodes ); /* Free the element node array. */ FreeArray( eltNodes ); }
void _ParticleMelting_Initialise( void* _self, void* data ) { ParticleMelting* self = (ParticleMelting*) _self; unsigned par_i, lpartCount; MaterialPoint *particle; ParticleMelting_ParExt *parExt; Stg_Component_Initialise( self->temperatureField, data, False ); Stg_Component_Initialise( self->materialSwarm, data, False ); if( self->pressureField ) Stg_Component_Initialise( self->pressureField, data, False ); if( self->scaling ) Stg_Component_Initialise( self->scaling, data, False ); if( !self->context->loadFromCheckPoint ) { lpartCount = self->materialSwarm->particleLocalCount; for( par_i = 0 ; par_i < lpartCount ; par_i++ ) { particle = (MaterialPoint*)Swarm_ParticleAt( self->materialSwarm, par_i ); parExt = ExtensionManager_Get( self->materialSwarm->particleExtensionMgr, particle, self->particleExtHandle ); /* initialise all */ parExt->melt = 0; parExt->F = 0; parExt->prevF = 0; parExt->maxTheta = 0; } } }
void _SnacDikeInjection_ConstructExtensions( void* _context, void* data ) { Snac_Context* context = (Snac_Context*)_context; SnacDikeInjection_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacDikeInjection_ContextHandle ); #ifdef DEBUG printf( "In %s()\n", __func__ ); #endif /* DikeInjection variables */ contextExt->startX = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "startX", Dictionary_Entry_Value_FromDouble( 29800.0f ) ) ); //printf("startX is not the value %d", startX ) contextExt->startZ = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "startZ", Dictionary_Entry_Value_FromDouble( 0.0f ) ) ); contextExt->endX = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "endX", Dictionary_Entry_Value_FromDouble( 30200.0f ) ) ); contextExt->endZ = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "endZ", Dictionary_Entry_Value_FromDouble( 1000.0f ) ) ); contextExt->dikeDepth = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "dikeDepth", Dictionary_Entry_Value_FromDouble( 6000.0 ) ) ); contextExt->dikeWidth = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "dikeWidth", Dictionary_Entry_Value_FromDouble( 720 ) ) ); /* 1.8 * dx looks appropriate. */ contextExt->injectionRate = Dictionary_Entry_Value_AsDouble( Dictionary_GetDefault( context->dictionary, "injectionRate", Dictionary_Entry_Value_FromDouble( 7.9e-10 ) ) ); /* a fraction of applied plate vel. */ }
void* MaterialPointsSwarm_GetMaterialExtensionOn( void* swarm, void *matPoint, Index extHandle ) { MaterialPointsSwarm *self = (MaterialPointsSwarm*)swarm; Material *mat; mat = MaterialPointsSwarm_GetMaterialOn(self, matPoint); return ExtensionManager_Get(mat->extensionMgr, mat, extHandle); }
void* MaterialPointsSwarm_GetMaterialExtensionAt( void* swarm, int matPointInd, Index extHandle ) { MaterialPointsSwarm *self = (MaterialPointsSwarm*)swarm; Material *mat; mat = MaterialPointsSwarm_GetMaterialAt(self, matPointInd); return ExtensionManager_Get(mat->extensionMgr, mat, extHandle); }
double _Pouliquen_etal_GetYieldCriterion( void* pouliquen_etal, ConstitutiveMatrix* constitutiveMatrix, MaterialPointsSwarm* materialPointsSwarm, Element_LocalIndex lElement_I, MaterialPoint* materialPoint, Coord xi ) { Pouliquen_etal* self = (Pouliquen_etal*) pouliquen_etal; double frictionalStrength; double pressure; Pouliquen_etal_Particle* particleExt; double strainRateInv; particleExt = (Pouliquen_etal_Particle*)ExtensionManager_Get( materialPointsSwarm->particleExtensionMgr, materialPoint, self->particleExtHandle ); FeVariable_InterpolateWithinElement( self->pressureField, lElement_I, xi, &pressure ); FeVariable_InterpolateWithinElement( self->strainRateInvField, lElement_I, xi, &strainRateInv ); particleExt->pressure = pressure; particleExt->strainRateInv = strainRateInv; frictionalStrength = self->mu_s * pressure; //the following is to ensure that every particle is yielding //frictionalStrength = -1.0; return frictionalStrength; }
void UpdateAverageTemp_LoopElements( void* _context ) { Snac_Context* context = (Snac_Context*)_context; Element_LocalIndex element_lI; Tetrahedra_Index tetra_I; Index tetraNode_I; for( element_lI = 0; element_lI < context->mesh->elementLocalCount; element_lI++ ) { Snac_Element* element = Snac_Element_At( context, element_lI ); for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) { Snac_Element_Tetrahedra* tetra = &element->tetra[tetra_I]; tetra->avgTemp = 0.0; for(tetraNode_I = 0; tetraNode_I < Tetrahedra_Point_Count; tetraNode_I++ ) { Snac_Node* contributingNode = Snac_Element_Node_P( context, element_lI, TetraToNode[tetra_I][tetraNode_I] ); SnacTemperature_Node* temperatureNodeExt = ExtensionManager_Get( context->mesh->nodeExtensionMgr, contributingNode, SnacTemperature_NodeHandle ); tetra->avgTemp += temperatureNodeExt->temperature/(1.0f*Tetrahedra_Point_Count); } } } }
void _SnacViscoPlastic_DumpPlasticStrainTensor( void* _context ) { Snac_Context* context = (Snac_Context*) _context; SnacViscoPlastic_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacViscoPlastic_ContextHandle ); #if DEBUG printf( "In %s()\n", __func__ ); #endif if( context->timeStep ==0 || (context->timeStep-1) % context->dumpEvery == 0 ) { Element_LocalIndex element_lI; for( element_lI = 0; element_lI < context->mesh->elementLocalCount; element_lI++ ) { Snac_Element* element = Snac_Element_At( context, element_lI ); SnacViscoPlastic_Element* elementExt = ExtensionManager_Get( context->mesh->elementExtensionMgr, element, SnacViscoPlastic_ElementHandle ); const Snac_Material* material = &context->materialProperty[element->material_I]; Tetrahedra_Index tetra_I; if( material->yieldcriterion == druckerprager ) { for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) { Index i,j; float tensor[3][3]; for(i=0;i<3;i++) for(j=0;j<3;j++) { tensor[i][j] = elementExt->plasticstrainTensor[tetra_I][i][j]; fwrite( &tensor[i][j], sizeof(float), 1, contextExt->plstrainTensorOut ); } } } else if( material->yieldcriterion == mohrcoulomb ) { for( tetra_I = 0; tetra_I < Tetrahedra_Count; tetra_I++ ) { float tetraStrain; tetraStrain = elementExt->plasticStrain[tetra_I]; fwrite( &tetraStrain, sizeof(float), 1, contextExt->plstrainTensorOut ); } } } fflush( contextExt->plstrainTensorOut ); } }
void* _Mesh_GetExtension( void* mesh, const unsigned int id ) { Mesh* self = (Mesh*)mesh; assert( self ); assert( id != -1 ); return ExtensionManager_Get( self->info, self, id ); }
void* MaterialPointsSwarm_GetExtensionAt( void* swarm, Index point_I, Index extHandle ) { MaterialPointsSwarm* self = (MaterialPointsSwarm*)swarm; MaterialPoint* point; point = (MaterialPoint*)Swarm_ParticleAt( self, point_I ); return ExtensionManager_Get( self->particleExtensionMgr, point, extHandle ); }
void* _OneToOneMapper_GetExtensionOn( void* mapper, void* point, ExtensionInfo_Index extHandle ) { OneToOneMapper* self = (OneToOneMapper*)mapper; MaterialPointsSwarm* swarm; MaterialPoint* materialPoint; /* Assumes that material swarm holds Material particle or derivative */ materialPoint = OneToOneMapper_GetMaterialPoint( self, point, &swarm ); return ExtensionManager_Get( swarm->particleExtensionMgr, materialPoint, extHandle ); }
void* GeneralSwarm_GetExtensionAt( void* swarm, Index point_I, Index extHandle ) { GeneralSwarm* self = (GeneralSwarm*)swarm; GlobalParticle* point; point = (GlobalParticle*)Swarm_ParticleAt( self, point_I ); return ExtensionManager_Get( self->particleExtensionMgr, point, extHandle ); }
int ParticleMelting_Get( void* _self, MaterialPoint* mp, ParticleMeltingProps prop, double *value ) { ParticleMelting* self = (ParticleMelting*) _self; ParticleMelting_MatExt *matExt; ParticleMelting_ParExt *parExt; /* Get the material of the particle */ Material *material = Materials_Register_GetByIndex( self->materialSwarm->materials_Register, mp->materialIndex ); switch( prop ) { case MELT_LATENTHEAT_FUSION: matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle ); *value = matExt->lhf; break; case MELT_HEATCAPACITY: matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle ); *value = matExt->Cp; break; case MELT_FRACTION: parExt = ExtensionManager_Get( self->materialSwarm->particleExtensionMgr, mp, self->particleExtHandle ); *value = parExt->melt; break; case MELT_DEPLETION: parExt = ExtensionManager_Get( self->materialSwarm->particleExtensionMgr, mp, self->particleExtHandle ); *value = parExt->F; break; case MELT_PREVDEPLETION: parExt = ExtensionManager_Get( self->materialSwarm->particleExtensionMgr, mp, self->particleExtHandle ); *value = parExt->prevF; break; case MELT_ON: matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle ); *value = matExt->TurnMeltOn; break; case MELT_SOLIDUS_POLY: matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle ); value = matExt->sCoeff; break; case MELT_LIQUIDUS_POLY: matExt = ExtensionManager_Get( material->extensionMgr, material, self->materialExtHandle ); value = matExt->lCoeff; break; default: printf("Error in %s; no valid property argument passed in\n", __func__ ); return -1; } return 0; }
void _DruckerPrager_Init( DruckerPrager* self, int pressure_id, int velocityGradients_id, double minimumYieldStress, double frictionCoefficient, double frictionCoefficientAfterSoftening ) { MaterialPointsSwarm* materialPointsSwarm; DruckerPrager_Particle* particleExt; StandardParticle materialPoint; Dimension_Index dim = 0; /* Assign Pointers */ self->frictionCoefficient = frictionCoefficient; self->minimumYieldStress = minimumYieldStress; self->pressureTag = pressure_id; self->velocityGradientsTag = velocityGradients_id; materialPointsSwarm = self->mgr->materialSwarm; dim = materialPointsSwarm->dim; /* Strain softening of Friction - (linear weakening is assumed ) */ /* needs a softening factor between +0 and 1 and a reference strain > 0 */ self->frictionCoefficientAfterSoftening = frictionCoefficientAfterSoftening; /* get the particle extension */ self->particleExtHandle = ExtensionManager_GetHandle( materialPointsSwarm->particleExtensionMgr, (Name)DruckerPrager_Type ); if( self->particleExtHandle == (unsigned)-1 ) { /* if no particles extension add it and add Update hook */ self->particleExtHandle = ExtensionManager_Add( materialPointsSwarm->particleExtensionMgr, (Name)DruckerPrager_Type, sizeof(DruckerPrager_Particle) ); particleExt = (double*)ExtensionManager_Get( materialPointsSwarm->particleExtensionMgr, &materialPoint, self->particleExtHandle ); /* The tensileFailure variable allows to check whether a materialPoint has failed in tensile mode or not */ self->tensileFailure = Swarm_NewScalarVariable( materialPointsSwarm, (Name)"DruckerPragerTensileFailure", (ArithPointer) &particleExt->tensileFailure - (ArithPointer) &materialPoint, Variable_DataType_Char ); LiveComponentRegister_Add( LiveComponentRegister_GetLiveComponentRegister(), (Stg_Component*)self->tensileFailure->variable ); LiveComponentRegister_Add( LiveComponentRegister_GetLiveComponentRegister(), (Stg_Component*)self->tensileFailure ); } else { /* get references to all swarm variables */ Name var_name = Stg_Object_AppendSuffix( materialPointsSwarm, (Name)"DruckerPragerTensileFailure" ); self->tensileFailure = SwarmVariable_Register_GetByName( materialPointsSwarm->swarmVariable_Register, var_name ); Memory_Free( var_name ); } self->curFrictionCoef = 0.0; }
void _SnacRemesher_RecoverNodes( void* _context ) { Snac_Context* context = (Snac_Context*)_context; SnacRemesher_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacRemesher_ContextHandle ); Mesh* mesh = context->mesh; Node_LocalIndex newNode_i; /* ** Populate arrays for recovered fields using the SPR method. */ for( newNode_i = 0; newNode_i < mesh->nodeLocalCount; newNode_i++ ) SnacRemesher_RecoverNode( context, contextExt, newNode_i ); }
void _SnacExchangerForceBC_Remesh( void* _context, void* data ) { Snac_Context* context = (Snac_Context*)_context; /* If criterion has passed */ { SnacExchangerForceBC_Mesh* meshExt = ExtensionManager_Get( context->meshExtensionMgr, context, SnacExchangerForceBC_MeshHandle ); /* initialise new nodes coordinates */ _SnacExchangerForceBC_NewCoords( context ); /* interpolate current values onto new coordinates */ _SnacExchangerForceBC_InterpolateNodes( context ); } }
void _SnacTemperature_CheckpointTemp( void* _context ) { Snac_Context* context = (Snac_Context*) _context; SnacTemperature_Context* contextExt = ExtensionManager_Get( context->extensionMgr, context, SnacTemperature_ContextHandle ); Node_LocalIndex node_lI; #if DEBUG printf( "In %s()\n", __func__ ); #endif for( node_lI = 0; node_lI < context->mesh->nodeLocalCount; node_lI++ ) { Snac_Node* node = Snac_Node_At( context, node_lI ); SnacTemperature_Node* nodeExt = ExtensionManager_Get( context->mesh->nodeExtensionMgr, node, SnacTemperature_NodeHandle ); float temperature = nodeExt->temperature; fwrite( &temperature, sizeof(float), 1, contextExt->temperatureCheckpoint ); } fflush( contextExt->temperatureCheckpoint ); }
void _HeatingForce_ValueAtParticle( void* heatingForce, IntegrationPointsSwarm* swarm, Element_LocalIndex lElement_I, IntegrationPoint* particle, double* value ) { HeatingForce* self = (HeatingForce*)heatingForce; Material* material; BuoyancyMaterial_MaterialExt* materialExt; material = IntegrationPointsSwarm_GetMaterialOn( swarm, particle ); materialExt = ExtensionManager_Get( material->extensionMgr, material, self->buoyancyMaterial->materialExtHandle ); *value = materialExt->extensions[self->materialIndex]; }
void _ParticleMelting_Init( ParticleMelting* self, Bool extractMelt, FeVariable* temperatureField, FeVariable* pressureField, MaterialPointsSwarm* materialSwarm, Scaling* scaling ) { ParticleMelting_ParExt *parExt = NULL; StandardParticle particle; /* extractMelt: * For mantle set to true, according to de Smet, 98 * For lithosphere set to false according to Patrice Rey */ self->extractMelt = extractMelt; self->temperatureField = temperatureField; self->pressureField = pressureField; self->materialSwarm = materialSwarm; self->scaling = scaling; /* add to EP, post time step, to save the previous value of melting depletion */ /* EntryPoint_AppendClassHook( AbstractContext_GetEntryPoint(self->context, AbstractContext_EP_UpdateClass), "MeltDepletionUpdate", ParticleMelting_MeltFrationUpdate, self->name, self ); */ /* EntryPoint_Append AbstractContext_EP_UpdateClass */ /* now we extend the particles with 3 doubles: F, prevF and maxTheta */ self->particleExtHandle = ExtensionManager_Add( self->materialSwarm->particleExtensionMgr, (Name)self->type, sizeof(ParticleMelting_ParExt) ); parExt = ExtensionManager_Get( self->materialSwarm->particleExtensionMgr, &particle, self->particleExtHandle ); self->meltVariable = Swarm_NewScalarVariable( self->materialSwarm, (Name)"Melt", (ArithPointer) &parExt->melt - (ArithPointer) &particle, Variable_DataType_Double ); self->FVariable = Swarm_NewScalarVariable( self->materialSwarm, (Name)"Depletion", (ArithPointer) &parExt->F - (ArithPointer) &particle, Variable_DataType_Double ); self->prevFVariable = Swarm_NewScalarVariable( self->materialSwarm, (Name)"PrevDepletion", (ArithPointer) &parExt->prevF - (ArithPointer) &particle, Variable_DataType_Double ); self->maxThetaVariable = Swarm_NewScalarVariable( self->materialSwarm, (Name)"MaxDegreeOfMelting", (ArithPointer) &parExt->maxTheta - (ArithPointer) &particle, Variable_DataType_Double ); }
/* Copy interpolated values stored in newElement array back to the original element array. */ void _SnacPlastic_CopyElement( void* _context, Element_LocalIndex eltInd, Tetrahedra_Index tetInd, SnacRemesher_Element* srcEltArray ) { Snac_Context* context = (Snac_Context*)_context; SnacRemesher_Element* srcElt = &srcEltArray[eltInd]; Snac_Element* dstElt = Snac_Element_At( context, eltInd ); SnacPlastic_Element* dstEltExt = ExtensionManager_Get( context->mesh->elementExtensionMgr, dstElt, SnacPlastic_ElementHandle ); dstEltExt->plasticStrain[tetInd] = srcElt->plasticStrain[tetInd]; }
void _StoreVisc_Init( StoreVisc* self, MaterialPointsSwarm* materialPointsSwarm ) { StandardParticle particle; StoreVisc_ParticleExt* particleExt; /* Assign Pointers */ self->materialPointsSwarm = materialPointsSwarm; self->particleExtHandle = ExtensionManager_Add( materialPointsSwarm->particleExtensionMgr, (Name)self->type, sizeof( StoreVisc_ParticleExt ) ); /* Add SwarmVariables for plotting */ particleExt = (StoreVisc_ParticleExt*)ExtensionManager_Get( materialPointsSwarm->particleExtensionMgr, &particle, self->particleExtHandle ); self->swarmVariable = Swarm_NewScalarVariable( materialPointsSwarm, (Name)"Viscosity", (ArithPointer) &particleExt->effVisc - (ArithPointer) &particle, Variable_DataType_Double ); }
void _SnacRemesher_DeleteExtensions( void* _context, void* data ) { Snac_Context* context = (Snac_Context*)_context; Mesh* mesh = context->mesh; SnacRemesher_Mesh* meshExt = ExtensionManager_Get( context->meshExtensionMgr, mesh, SnacRemesher_MeshHandle ); Journal_Printf( context->debug, "In: %s\n", __func__ ); /* ** Probably will not need to do this. */ if( meshExt->newNodes ) { ExtensionManager_Free( mesh->nodeExtensionMgr, meshExt->newNodes ); } #if 0 if( meshExt->newElements ) { ExtensionManager_Free( mesh->nodeExtensionMgr, meshExt->newElements ); } #endif /* ** Kill the mesh extension. */ KillArray( meshExt->newNodeCoords ); KillArray( meshExt->externalNodes ); KillArray( meshExt->externalElements ); KillArray( meshExt->topInternToLocal ); KillArray( meshExt->botInternToLocal ); KillArray( meshExt->topTriToDomain ); KillArray( meshExt->botTriToDomain ); KillArray( meshExt->yLineLTerm ); KillArray( meshExt->yLineUTerm ); KillArray( meshExt->yLineNYInds ); KillArray2D( meshExt->nYLines, meshExt->yLineYInds ); KillArray2D( meshExt->nYLines, meshExt->yLineLocalInds ); }
void _SnacSpherical_applyInitialVz( Index node_dI, Variable_Index var_I, void* _context, void* result ) { Snac_Context* context = (Snac_Context*)_context; Mesh* mesh = context->mesh; SnacSpherical_Mesh* meshExt = ExtensionManager_Get( context->meshExtensionMgr, mesh, SnacSpherical_MeshHandle ); MeshLayout* layout = (MeshLayout*)mesh->layout; HexaMD* decomp = (HexaMD*)layout->decomp; double* velComponent = (double*)result; IJK ijk; Coord* coord = Snac_NodeCoord_P( context, node_dI ); double r,lon,lat; double lambda = deg2rad * (meshExt->min[1]+meshExt->max[1])*0.5f; double phi = deg2rad * 90.0f; double E[3],VXL[3],VXR[3]; Node_GlobalIndex node_gI = _MeshDecomp_Node_LocalToGlobal1D( decomp, node_dI ); RegularMeshUtils_Node_1DTo3D( decomp, node_gI, &ijk[0], &ijk[1], &ijk[2] ); E[0] = sin(PI/2.0f-phi)*cos(lambda); E[1] = sin(PI/2.0f-phi)*sin(lambda); E[2] = cos(PI/2.0f-phi); r = sqrt((*coord)[0]*(*coord)[0] + (*coord)[1]*(*coord)[1] + (*coord)[2]*(*coord)[2]); lat = PI/2.0f - acos((*coord)[2] / r); lon = meshExt->min[1] * deg2rad; //85.0*deg2rad; //atan2((*coord)[1], (*coord)[0]); VXL[0] = omegaL*(E[1]*(*coord)[2] - E[2]*(*coord)[1]); VXL[1] = omegaL*(-1.0f * E[0]*(*coord)[2] + E[2]*(*coord)[0]); VXL[2] = omegaL*(E[0]*(*coord)[1] - E[1]*(*coord)[0]); lon = meshExt->max[1] * deg2rad; //85.0*deg2rad; //atan2((*coord)[1], (*coord)[0]); VXR[0] = omegaR*(E[1]*(*coord)[2] - E[2]*(*coord)[1]); VXR[1] = omegaR*(-1.0f * E[0]*(*coord)[2] + E[2]*(*coord)[0]); VXR[2] = omegaR*(E[0]*(*coord)[1] - E[1]*(*coord)[0]); (*velComponent) = VXL[2] + (VXR[2] - VXL[2])/(decomp->elementGlobal3DCounts[0])*ijk[0]; }
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 _StoreVisc_ModifyConstitutiveMatrix( void* rheology, ConstitutiveMatrix* constitutiveMatrix, MaterialPointsSwarm* materialPointsSwarm, Element_LocalIndex lElement_I, MaterialPoint* materialPoint, Coord xi ) { StoreVisc* self = (StoreVisc*) rheology; StoreVisc_ParticleExt* particleExt; #if 0 /* ** HAXOR: Throwing this flag in here to try and prevent REP from ** overwriting the previously calculated viscosity value. */ if ( !constitutiveMatrix->previousSolutionExists ) return; #endif /* Get Parameters From Material Extension */ particleExt = (StoreVisc_ParticleExt*)ExtensionManager_Get( materialPointsSwarm->particleExtensionMgr, materialPoint, self->particleExtHandle ); particleExt->effVisc = ConstitutiveMatrix_GetIsotropicViscosity(constitutiveMatrix); }
void _RateFieldTimeIntegrator_Build( void* rateFieldTimeIntegrator, void* data ) { RateFieldTimeIntegrator* self = (RateFieldTimeIntegrator*) rateFieldTimeIntegrator; ExtensionInfo_Index handle; Stg_Component_Build( self->swarm, data, False ); Stg_Component_Build( self->rateField, data, False ); handle = ExtensionManager_GetHandle( self->swarm->particleExtensionMgr, (Name)self->name ); if ( handle == (ExtensionInfo_Index) -1 ) { ArithPointer offset; handle = ExtensionManager_Add( self->swarm->particleExtensionMgr, (Name)RateFieldTimeIntegrator_Type, self->rateField->fieldComponentCount*sizeof(double) ); /* Adding required increment variable */ offset = (ArithPointer ) ExtensionManager_Get( self->swarm->particleExtensionMgr, NULL, handle ); /* Add variables for vizualization / analysis purposes */ self->particleTimeIntegral = Swarm_NewVectorVariable( self->swarm, self->name, offset, Variable_DataType_Double, self->rateField->fieldComponentCount, "STG_AUTONAME" ); LiveComponentRegister_Add( LiveComponentRegister_GetLiveComponentRegister(), (Stg_Component*)self->particleTimeIntegral->variable ); LiveComponentRegister_Add( LiveComponentRegister_GetLiveComponentRegister(), (Stg_Component*)self->particleTimeIntegral ); /* The RateFieldTimeIntegrator class inherits from the TimeIntegrand class - this class needs a 'Variable' to * integrate through time. */ self->variable = self->particleTimeIntegral->variable; } else Journal_Firewall(False, Journal_Register( Error_Type, (Name)"RateFieldTimeIntegrator" ), "\n\nError in '%s' - Extension with name %s should not already exists.\n" "An error has occurred. Please contact developers.", __func__, self->name); /* Build parent. Note that this needs to go last because it assumes that a variable has been set, which only just happens above */ /* Another example where the build/init/etc phases don't work */ _TimeIntegrand_Build( self, data ); Stg_Component_Build( self->particleTimeIntegral, data, False ); }
void _DruckerPrager_Extra_HasYielded( void* rheology, ConstitutiveMatrix* constitutiveMatrix, MaterialPointsSwarm* materialPointsSwarm, Element_LocalIndex lElement_I, MaterialPoint* materialPoint, double yieldCriterion, double yieldIndicator ) { DruckerPrager_Extra* self = (DruckerPrager_Extra*)rheology; DruckerPrager_Extra_Particle* particleExt; double viscosity = ConstitutiveMatrix_GetIsotropicViscosity( constitutiveMatrix ); particleExt = (DruckerPrager_Extra_Particle*)ExtensionManager_Get( materialPointsSwarm->particleExtensionMgr, materialPoint, self->particleExtHandle ); double beta = yieldCriterion/yieldIndicator; double viscosity_new = viscosity*beta; if (viscosity_new < self->minVisc) { viscosity_new = self->minVisc; } _VonMises_HasYielded( self, constitutiveMatrix, materialPointsSwarm, lElement_I, materialPoint, yieldCriterion, yieldIndicator ); /*set the plastic and background strainrate: plasticsr = tyield/eta_new - tyield/eta_old where eta_new = eta_old*(yieldC/yieldI)*/ particleExt->plasticStrainRate = yieldCriterion*( (1/viscosity_new) - (1/viscosity) ); particleExt->backgroundStrainRate = yieldCriterion/viscosity; if( constitutiveMatrix->sle && constitutiveMatrix->sle->nlFormJacobian ) { constitutiveMatrix->derivs[8] += viscosity * self->curFrictionCoef / yieldIndicator; } }
void _SnacSpherical_applyPlateVy( Index node_dI, Variable_Index var_I, void* _context, void* result ) { Snac_Context* context = (Snac_Context*)_context; Mesh* mesh = context->mesh; SnacSpherical_Mesh* meshExt = ExtensionManager_Get( context->meshExtensionMgr, mesh, SnacSpherical_MeshHandle ); MeshLayout* layout = (MeshLayout*)mesh->layout; HexaMD* decomp = (HexaMD*)layout->decomp; double* velComponent = (double*)result; const Node_GlobalIndex midI = (decomp->nodeGlobal3DCounts[0] + 1) / 2; IJK ijk; Node_GlobalIndex node_gI = _MeshDecomp_Node_LocalToGlobal1D( decomp, node_dI ); Coord* coord = Snac_NodeCoord_P( context, node_dI ); double lambda = deg2rad * (meshExt->min[1]+meshExt->max[1])*0.5f; double phi = deg2rad * 90.0f; double omega; double E[3],VX[3]; E[0] = sin(PI/2.0f-phi)*cos(lambda); E[1] = sin(PI/2.0f-phi)*sin(lambda); E[2] = cos(PI/2.0f-phi); RegularMeshUtils_Node_1DTo3D( decomp, node_gI, &ijk[0], &ijk[1], &ijk[2] ); if(ijk[0] < (midI-1)) omega = omegaL; else omega = omegaR; VX[0] = omega*(E[1]*(*coord)[2] - E[2]*(*coord)[1]); VX[1] = omega*(-1.0f * E[0]*(*coord)[2] + E[2]*(*coord)[0]); VX[2] = omega*(E[0]*(*coord)[1] - E[1]*(*coord)[0]); (*velComponent) = VX[1]; }