void _RateFieldTimeIntegrator_Initialise( void* rateFieldTimeIntegrator, void* data ) { RateFieldTimeIntegrator* self = (RateFieldTimeIntegrator*) rateFieldTimeIntegrator; Stg_Component_Initialise( self->swarm , data, False ); Stg_Component_Initialise( self->rateField, data, False ); }
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 _DruckerPrager_Extra_Initialise( void* rheology, void* data ) { DruckerPrager_Extra* self = (DruckerPrager_Extra*) rheology; Particle_Index lParticle_I; Particle_Index particleLocalCount; XYZ slip = { 0.0,0.0,0.0 }; double* ptr; _VonMises_Initialise( self, data ); /* We should only set initial conditions if in regular non-restart mode. If in restart mode, then the particle-based variables will be set correcty when we re-load the Swarm. */ if ( self->context->loadSwarmsFromCheckpoint == False ) { Stg_Component_Initialise( self->tensileFailure, data, False ); Stg_Component_Initialise( self->slip, data, False ); Stg_Component_Initialise( self->slipRate, data, False ); Stg_Component_Initialise( self->fullySoftened, data, False ); /* We don't need to Initialise hasYieldedVariable because it's a parent variable and _YieldRheology_Initialise * has already been called */ particleLocalCount = self->hasYieldedVariable->variable->arraySize; for ( lParticle_I = 0 ; lParticle_I < particleLocalCount ; lParticle_I++ ) { Variable_SetValueChar( self->hasYieldedVariable->variable, lParticle_I, False ); Variable_SetValueChar( self->tensileFailure->variable,lParticle_I, False ); Variable_SetValueDouble( self->plasticStrainRate->variable, lParticle_I, 0.0 ); Variable_SetValueDouble( self->backgroundStrainRate->variable, lParticle_I, 0.0 ); ptr = Variable_GetPtrDouble( self->slip->variable, lParticle_I ); memcpy( ptr, slip, sizeof(Coord) ); Variable_SetValueDouble( self->slipRate->variable, data, 0.0 ); Variable_SetValueInt( self->fullySoftened->variable, data, 0 ); } } }
void _Mesh_Initialise( void* mesh, void* data ) { Mesh* self = (Mesh*)mesh; if( self->algorithms ) Stg_Component_Initialise( self->algorithms, data, False ); if( self->generator ) Stg_Component_Initialise( self->generator, data, False ); }
void _Trubitsyn2006_Initialise( void* analyticSolution, void* data ) { Trubitsyn2006* self = (Trubitsyn2006*)analyticSolution; Stg_Component_Initialise(self->velocityField, data, False); Stg_Component_Initialise(self->pressureField, data, False); _Codelet_Initialise( self, data ); }
void _MeshAdaptor_Initialise( void* _adaptor, void* data ) { MeshAdaptor* self = (MeshAdaptor*)_adaptor; if( self->generator ) Stg_Component_Initialise( self->generator, data, False ); if( self->srcMesh ) Stg_Component_Initialise( self->srcMesh, data, False ); _MeshGenerator_Initialise( self, data ); }
void _SwarmAdvector_Initialise( void* swarmAdvector, void* data ) { SwarmAdvector* self = (SwarmAdvector*) swarmAdvector; Stg_Component_Initialise( self->velocityField, data, False ); Stg_Component_Initialise( self->swarm, data, False ); if ( self->periodicBCsManager ) Stg_Component_Initialise( self->periodicBCsManager, data, False ); _TimeIntegrand_Initialise( self, data ); }
void _Spherical_CubedSphereNusselt_Initialise( void* component, void* data ) { Spherical_CubedSphereNusselt* self = (Spherical_CubedSphereNusselt*)component; Stg_Component_Initialise( self->gaussSwarm, data, False ); Stg_Component_Initialise( self->advectiveHeatFluxField, data, False ); Stg_Component_Initialise( self->temperatureTotalDerivField, data, False ); _Codelet_Initialise( component, data ); }
void _StoreVisc_Initialise( void* _self, void* data ) { StoreVisc* self = (StoreVisc*) _self; /* Initialise parent */ _Rheology_Initialise( self, data ); Stg_Component_Initialise( self->swarmVariable, data, False); Stg_Component_Initialise( self->materialPointsSwarm, data, False); }
void _SUPGAdvDiffTermPpc_Initialise( void* residual, void* data ) { SUPGAdvDiffTermPpc* self = (SUPGAdvDiffTermPpc*)residual; _ForceTerm_Initialise( self, data ); //Stg_Component_Initialise( self->sle, data, False ); Stg_Component_Initialise( self->velocityField, data, False ); Stg_Component_Initialise( self->phiField, data, False ); Stg_Component_Initialise( self->mgr, data, False ); }
void _Underworld_Vrms_Initialise( void* component, void* data ) { Underworld_Vrms* self = (Underworld_Vrms*)component; assert( self ); Stg_Component_Initialise( self->gaussSwarm, data, False ); Stg_Component_Initialise( self->velocityField, data, False ); Stg_Component_Initialise( self->velocitySquaredField, data, False ); _Codelet_Initialise( self, data ); }
void _StiffnessMatrixTerm_Initialise( void* stiffnessMatrixTerm, void* data ) { StiffnessMatrixTerm* self = (StiffnessMatrixTerm*)stiffnessMatrixTerm; Journal_DPrintf( self->debug, "In %s - for %s\n", __func__, self->name ); Stream_IndentBranch( StgFEM_Debug ); Stg_Component_Initialise( self->integrationSwarm, data, False ); if ( self->extraInfo ) Stg_Component_Initialise( self->extraInfo, data, False ); Stream_UnIndentBranch( StgFEM_Debug ); }
void ElementCellLayoutSuite_Setup( ElementCellLayoutSuiteData* data ) { Journal_Enable_AllTypedStream( False ); /* MPI Initializations */ data->comm = MPI_COMM_WORLD; MPI_Comm_rank( data->comm, &data->rank ); MPI_Comm_size( data->comm, &data->nProcs ); data->nDims = 3; data->meshSize[0] = 2; data->meshSize[1] = 3; data->meshSize[2] = 2; data->minCrds[0] = 0.0; data->minCrds[1] = 0.0; data->minCrds[2] = 0.0; data->maxCrds[0] = 300.0; data->maxCrds[1] = 12.0; data->maxCrds[2] = 300.0; /* Init mesh */ data->extensionMgr_Register = ExtensionManager_Register_New(); data->mesh = ElementCellLayout_BuildMesh( data->nDims, data->meshSize, data->minCrds, data->maxCrds, data->extensionMgr_Register ); /* Configure the element-cell-layout */ data->elementCellLayout = ElementCellLayout_New( "elementCellLayout", NULL, data->mesh ); Stg_Component_Build( data->elementCellLayout, NULL, False ); Stg_Component_Initialise( data->elementCellLayout, NULL, False ); }
void _NonNewtonianAbs_Initialise( void* _self, void* data ){ NonNewtonianAbs* self = (NonNewtonianAbs*)_self; _Rheology_Initialise( self, data ); Stg_Component_Initialise( self->strainRateInvField, data, False ); }
void _IntegrationPointsSwarm_Initialise( void* integrationPoints, void* data ) { IntegrationPointsSwarm* self = (IntegrationPointsSwarm*) integrationPoints; Journal_DPrintf( self->debug, "In %s(): for swarm \"%s\":\n", __func__, self->name ); Stream_IndentBranch( Swarm_Debug ); _Swarm_Initialise( self, data ); Stg_Component_Initialise( self->localCoordVariable, data, False ); Stg_Component_Initialise( self->weightVariable, data, False ); Stg_Component_Initialise( self->mesh, data, False ); Stream_UnIndentBranch( Swarm_Debug ); Journal_DPrintf( self->debug, "...done in %s() for swarm \"%s\".\n", __func__, self->name ); }
void _PpcFeVariable_Initialise( void* _self, void* data ) { PpcFeVariable* self = (PpcFeVariable*) _self; Stg_Component_Initialise( self->ppcMan, data, False ); _ParticleFeVariable_Initialise( self, data ); }
Variable* Mesh_GenerateElGlobalIdVar( void* mesh ) { /* Returns a Variable that stores the global element indices. * Assumes the number of mesh elements never changes. */ Mesh* self = (Mesh*)mesh; char* name; unsigned dim; // if variable already exists return it if( self->eGlobalIdsVar ) return self->eGlobalIdsVar; dim = Mesh_GetDimSize(mesh); // Create the Variable data structure, int[local node count] self->lEls = Mesh_GetLocalSize( self, dim ); self->elgid = Memory_Alloc_Array( int, self->lEls, "Mesh::vertsgid" ); Stg_asprintf( &name, "%s-%s", self->name, "verticesGlobalIds" ); self->eGlobalIdsVar = Variable_NewScalar( name, NULL, Variable_DataType_Int, &self->lEls, NULL, (void**)&self->elgid, NULL ); Stg_Component_Build(self->eGlobalIdsVar, NULL, False); Stg_Component_Initialise(self->eGlobalIdsVar, NULL, False); free(name); // Evaluate the global indices for the local nodes int ii, gid; for( ii=0; ii<self->lEls; ii++ ) { gid = Mesh_DomainToGlobal( self, dim, ii ); Variable_SetValue( self->eGlobalIdsVar, ii, (void*)&gid ); } // return new variable return self->eGlobalIdsVar; }
void _GALENonNewtonian_Initialise( void* _self, void* data ){ GALENonNewtonian* self = (GALENonNewtonian*)_self; _Rheology_Initialise( self, data ); Stg_Component_Initialise( self->strainRateInvField, data, False ); }
void _BelowHeightField_Initialise( void* belowHeightField, void* data ) { BelowHeightField* self = (BelowHeightField*)belowHeightField; Stg_Component_Initialise( self->heightField, NULL, False ); _Stg_Shape_Initialise( self, data ); }
void _MeshParticleLayout_Initialise( void* meshParticleLayout, void* data ) { MeshParticleLayout* self = (MeshParticleLayout*)meshParticleLayout; assert( self ); Stg_Component_Initialise( self->mesh, NULL, False ); }
void _VariableCondition_Initialise( void* variableCondition, void* data ) { VariableCondition* self = (VariableCondition*)variableCondition; Index i; Index cf_I; /* lets init any condition functions that require it */ if(self->conFunc_Register){ for( cf_I = 0; cf_I < self->conFunc_Register->count; cf_I++ ) { if( self->conFunc_Register->_cf[cf_I]->init ) ConditionFunction_InitFunc(self->conFunc_Register->_cf[cf_I], self->context); } } for( i = 0; i < self->indexCount; i++ ) { VariableCondition_VariableIndex vcVar_I; for( vcVar_I = 0; vcVar_I < self->vcVarCountTbl[i]; vcVar_I++ ) { Variable* var; /* Force the building of the variable (to be safe) */ var = self->variable_Register->_variable[self->vcTbl[i][vcVar_I].varIndex]; Stg_Component_Initialise( var, data, False ); } } }
void Stg_ComponentFactory_InitialiseComponents( Stg_ComponentFactory* self, void* data ) { Stg_Component* component = NULL; Index component_I; Stream* stream; assert( self ); stream = self->infoStream; if( self->componentDict ){ Journal_Printf( stream, "\nInitialising Stg_Components from the live-component register\n\n" ); Stream_Indent( stream ); for( component_I = 0; component_I < LiveComponentRegister_GetCount( self->LCRegister ); component_I++ ){ /* Grab component from register */ component = LiveComponentRegister_At( self->LCRegister, component_I ); if( component && !component->isInitialised ){ Stg_Component_Initialise( component, data, True ); } } Stream_UnIndent( stream ); } else{ Journal_Printf( stream, "No Stg_ComponentList found..!\n" ); } }
void _HeatingForce_Initialise( void* heatingForce, void* data ) { HeatingForce* self = (HeatingForce*)heatingForce; if( self->cmm ) Stg_Component_Initialise( self->cmm, data, False ); _ParticleFeVariable_Initialise( self, data ); }
void _MultigridSolver_Initialise( void* matrixSolver, void* data ) { MultigridSolver* self = (MultigridSolver*)matrixSolver; assert( self && Stg_CheckType( self, MultigridSolver ) ); if( self->opGen ) Stg_Component_Initialise( self->opGen, data, False ); }
void _SwarmDump_Initialise( void* swarmDump, void* data ) { SwarmDump* self = (SwarmDump*) swarmDump; Index swarm_I; for ( swarm_I = 0 ; swarm_I < self->swarmCount ; swarm_I++ ) { Stg_Component_Initialise( self->swarmList[ swarm_I ], data, False ); } }
void _PETScMGSolver_Initialise( void* matrixSolver, void* data ) { PETScMGSolver* self = (PETScMGSolver*)matrixSolver; assert( self && Stg_CheckType( self, PETScMGSolver ) ); if( self->opGen ) Stg_Component_Initialise( self->opGen, data, False ); }
void _Remesher_Initialise( void* remesher, void* data ) { Remesher* self = (Remesher*)remesher; assert( self ); /*Stg_Component_Initialise( self->remeshFunc, data, False );*/ Stg_Component_Initialise( self->mesh, data, False ); }
void _Ppc_IsInsideShape_Initialise( void* _self, void* data ) { Ppc_IsInsideShape* self = (Ppc_IsInsideShape*)_self; /* Initialize parent */ _Ppc_Initialise( self, data ); Stg_Component_Initialise( self->shape, NULL, False ); }
void _SwarmVariable_Initialise( void* swarmVariable, void* data ) { SwarmVariable* self = (SwarmVariable*)swarmVariable; if ( self->variable ) { Variable_Update( self->variable ); Stg_Component_Initialise( self->variable, data, False ); } }
void _ElementCellLayout_Initialise( void *elementCellLayout, void *data ){ ElementCellLayout* self = (ElementCellLayout*)elementCellLayout; Stg_Component_Initialise( self->mesh, data, False ); if( !self->mesh->isRegular ) { self->_cellOf = _ElementCellLayout_CellOf_Irregular; } }