void Mesh_CentroidType_SetElementMesh( void* centroidType, void* mesh ) {
Mesh_CentroidType* self = (Mesh_CentroidType*)centroidType;
assert( self && Stg_CheckType( self, Mesh_CentroidType ) );
assert( !mesh || Stg_CheckType( mesh, Mesh ) );
self->elMesh = mesh;
}
void SROpGenerator_SetFineVariable( void* srOpGenerator, void* _variable ) {
SROpGenerator* self = (SROpGenerator*)srOpGenerator;
FeVariable* variable = (FeVariable*)_variable;
assert( self && Stg_CheckType( self, SROpGenerator ) );
assert( !variable || Stg_CheckType( variable, FeVariable ) );
SROpGenerator_DestructMeshes( self );
self->fineVar = variable;
}
void C0SphericalGenerator_Generate( void* generator, void* _mesh ) {
C0SphericalGenerator* self = (C0SphericalGenerator*)generator;
FeMesh* mesh = (FeMesh*)_mesh;
assert( self && Stg_CheckType( self, C0SphericalGenerator ) );
assert( mesh && Stg_CheckType( mesh, FeMesh ) );
C0Generator_BuildTopology( (C0Generator*)self, mesh );
C0Generator_BuildGeometry( (C0Generator*) self, mesh );
C0Generator_BuildElementTypes( (C0Generator*) self, mesh );
mesh->elementMesh = True; // ie this mesh defines the elements, not the nodes
}
void Mesh_SetAlgorithms( void* mesh, void* algorithms ) {
Mesh* self = (Mesh*)mesh;
assert( self && Stg_CheckType( self, Mesh ) );
FreeObject( self->algorithms );
if( algorithms ) {
assert( Stg_CheckType( algorithms, Mesh_Algorithms ) );
self->algorithms = algorithms;
}
else
self->algorithms = Mesh_Algorithms_New( "", NULL );
Mesh_Algorithms_SetMesh( self->algorithms, self );
}
void MultigridSolver_UpdateOps( MultigridSolver* self ) {
MultigridSolver_Level* level;
//Matrix **pOps, **rOps;
Mat *pOps, *rOps;
unsigned l_i;
assert( self && Stg_CheckType( self, MultigridSolver ) );
MGOpGenerator_Generate( self->opGen, &pOps, &rOps );
for( l_i = 1; l_i < self->nLevels; l_i++ ) {
level = self->levels + l_i;
//if( !level->P ) {
if( level->P == PETSC_NULL ) {
level->P = pOps[l_i];
//Stg_Class_AddRef( level->P );
}
else
Stg_MatDestroy(&pOps[l_i] );
//Stg_Class_RemoveRef( pOps[l_i] );
//if( !level->R ) {
if( level->R == PETSC_NULL ) {
level->R = rOps[l_i];
//Stg_Class_AddRef( level->R );
}
else
Stg_MatDestroy(&rOps[l_i] );
//Stg_Class_RemoveRef( rOps[l_i] );
}
FreeArray( pOps );
FreeArray( rOps );
}
unsigned MultigridSolver_GetNumLevels( void* matrixSolver ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
assert( self && Stg_CheckType( self, MultigridSolver ) );
return self->nLevels;
}
void MultigridSolver_SetLevelDownSolver( void* matrixSolver, unsigned levelInd, void* solver ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
MultigridSolver_Level* level;
assert( self && Stg_CheckType( self, MultigridSolver ) );
assert( levelInd < self->nLevels );
//assert( !solver || Stg_CheckType( solver, MatrixSolver ) );
level = self->levels + levelInd;
if( level->downSolver != solver )
self->solversChanged = True;
if( level->downSolver ) {
// Stg_Class_RemoveRef( level->downSolver );
if( level->downSolver->ksp != PETSC_NULL ) Stg_KSPDestroy(&level->downSolver->ksp );
if( level->downSolver->matrix != PETSC_NULL ) Stg_MatDestroy(&level->downSolver->matrix );
if( level->downSolver->inversion != PETSC_NULL ) Stg_MatDestroy(&level->downSolver->inversion );
if( level->downSolver->residual != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->residual );
if( level->downSolver->curRHS != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->curRHS );
if( level->downSolver->curSolution != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->curSolution );
free( level->downSolver );
}
level->downSolver = solver;
//if( solver )
// Stg_Class_AddRef( solver );
}
void MultigridSolver_SetLevels( void* matrixSolver, unsigned nLevels ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
unsigned nProcs;
unsigned l_i;
assert( self && Stg_CheckType( self, MultigridSolver ) );
MultigridSolver_DestructLevels( self );
self->nLevels = nLevels;
self->levels = AllocArray( MultigridSolver_Level, nLevels );
//MPI_Comm_size( self->comm, (int*)&nProcs );
MPI_Comm_size( self->mgData->comm, (int*)&nProcs );
for( l_i = 0; l_i < nLevels; l_i++ ) {
MultigridSolver_Level* level = self->levels + l_i;
//level->downSolver = NULL;
level->downSolver = malloc( sizeof( MGSolver_PETScData ) );
level->nDownIts = 1;
//level->upSolver = NULL;
level->upSolver = malloc( sizeof( MGSolver_PETScData ) );
level->nUpIts = l_i ? 1 : 0;
level->nCycles = 1;
level->A = NULL;
level->R = NULL;
level->P = NULL;
level->workRHS = NULL;
level->workSol = NULL;
}
}
double MultigridSolver_GetResidualNorm( void* matrixSolver ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
assert( self && Stg_CheckType( self, MultigridSolver ) );
return _GetResidualNorm( self->outerSolver );
}
unsigned MultigridSolver_GetMaxIterations( void* matrixSolver ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
assert( self && Stg_CheckType( self, MultigridSolver ) );
return self->maxIts;
}
void MultigridSolver_SetUseInitialSolution( void* matrixSolver, Bool state ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
assert( self && Stg_CheckType( self, MultigridSolver ) );
self->useInitial = state;
}
void MultigridSolver_SetMaxIterations( void* matrixSolver, unsigned nIterations ) {
MultigridSolver* self = (MultigridSolver*)matrixSolver;
assert( self && Stg_CheckType( self, MultigridSolver ) );
self->maxIts = nIterations;
}
void _LaplacianStiffnessMatrixTerm_AssembleElement(
void* matrixTerm,
StiffnessMatrix* stiffnessMatrix,
Element_LocalIndex lElement_I,
SystemLinearEquations* sle,
FiniteElementContext* context,
double** elStiffMat )
{
LaplacianStiffnessMatrixTerm* self = Stg_CheckType( matrixTerm, LaplacianStiffnessMatrixTerm );
Swarm* swarm = self->integrationSwarm;
FeVariable* variable1 = stiffnessMatrix->rowVariable;
Dimension_Index dim = stiffnessMatrix->dim;
IntegrationPoint* currIntegrationPoint;
double* xi;
double weight;
Particle_InCellIndex cParticle_I, cellParticleCount;
Index nodesPerEl;
Index i,j;
Dimension_Index dim_I;
double** GNx;
double detJac;
Cell_Index cell_I;
ElementType* elementType;
/* Set the element type */
elementType = FeMesh_GetElementType( variable1->feMesh, lElement_I );
nodesPerEl = elementType->nodeCount;
if( nodesPerEl > self->max_nElNodes ) {
/* reallocate */
self->GNx = ReallocArray2D( self->GNx, double, dim, nodesPerEl );
self->max_nElNodes = nodesPerEl;
}
Bool Mesh_Search( void* mesh, double* point, MeshTopology_Dim* topodim, unsigned* ind ) {
Mesh* self = (Mesh*)mesh;
assert( self && Stg_CheckType( self, Mesh ) );
return Mesh_Algorithms_Search( self->algorithms, point, topodim, ind );
}
void _VectorAssemblyTerm_NA__Fn_AssembleElement( void* forceTerm, ForceVector* forceVector, Element_LocalIndex lElement_I, double* elForceVec ) {
VectorAssemblyTerm_NA__Fn* self = Stg_CheckType( forceTerm, VectorAssemblyTerm_NA__Fn );
IntegrationPointsSwarm* swarm = (IntegrationPointsSwarm*)self->integrationSwarm;
Dimension_Index dim = forceVector->dim;
IntegrationPoint* particle;
FeMesh* mesh;
double* xi;
Particle_InCellIndex cParticle_I;
Particle_InCellIndex cellParticleCount;
Element_NodeIndex nodesPerEl;
Node_ElementLocalIndex A;
ElementType* elementType;
Dof_Index dofsPerNode, i;
Cell_Index cell_I;
double detJac;
double factor;
double N[27];
/* Since we are integrating over the velocity mesh - we want the velocity mesh here and not the temperature mesh */
mesh = forceVector->feVariable->feMesh;
VectorAssemblyTerm_NA__Fn_cppdata* cppdata = (VectorAssemblyTerm_NA__Fn_cppdata*)self->cppdata;
debug_dynamic_cast<ParticleInCellCoordinate*>(cppdata->input->localCoord())->index() = lElement_I; // set the elementId as the owning cell for the particleCoord
cppdata->input->index() = lElement_I; // set the elementId for the fem coordinate
/* Set the element type */
elementType = FeMesh_GetElementType( mesh, lElement_I );
nodesPerEl = elementType->nodeCount;
/* assumes constant number of dofs per element */
dofsPerNode = forceVector->feVariable->fieldComponentCount;
cell_I = CellLayout_MapElementIdToCellId( swarm->cellLayout, lElement_I );
cellParticleCount = swarm->cellParticleCountTbl[ cell_I ];
for ( cParticle_I = 0 ; cParticle_I < cellParticleCount ; cParticle_I++ ) {
debug_dynamic_cast<ParticleInCellCoordinate*>(cppdata->input->localCoord())->particle_cellId(cParticle_I); // set the particleCoord cellId
particle = (IntegrationPoint*) Swarm_ParticleInCellAt( swarm, cell_I, cParticle_I );
xi = particle->xi;
/* Calculate Determinant of Jacobian and Shape Functions */
if (self->geometryMesh)
detJac = ElementType_JacobianDeterminant( FeMesh_GetElementType( self->geometryMesh, lElement_I ), self->geometryMesh, lElement_I, xi, dim );
else
detJac = ElementType_JacobianDeterminant( elementType, mesh, lElement_I, xi, dim );
ElementType_EvaluateShapeFunctionsAt( elementType, xi, N );
/* evaluate function */
const FunctionIO* funcout = debug_dynamic_cast<const FunctionIO*>(cppdata->func(cppdata->input.get()));
factor = detJac * particle->weight;
for( A = 0 ; A < nodesPerEl ; A++ )
for( i = 0 ; i < dofsPerNode ; i++ )
elForceVec[A * dofsPerNode + i ] += factor * funcout->at<double>(i) * N[A] ;
}
}
void PETScMGSolver_DestructLevels( PETScMGSolver* self ) {
unsigned l_i;
assert( self && Stg_CheckType( self, PETScMGSolver ) );
for( l_i = 0; l_i < self->nLevels; l_i++ ) {
PETScMGSolver_Level* level = self->levels + l_i;
if(level->R == level->P){
if( level->R != PETSC_NULL ){
Stg_MatDestroy(&level->R );
level->P = PETSC_NULL;
}
}else{/* not same so test individually */
if( level->R != PETSC_NULL ) Stg_MatDestroy(&level->R );
if( level->P != PETSC_NULL ) Stg_MatDestroy(&level->P );
}
if( level->workRes )
Stg_VecDestroy(&level->workRes );
if( level->workSol )
Stg_VecDestroy(&level->workSol );
if( level->workRHS )
Stg_VecDestroy(&level->workRHS );
}
KillArray( self->levels );
self->nLevels = 0;
self->solversChanged = True;
self->opsChanged = True;
}
void RegularTrilinear_ConvertGlobalCoordToElLocal( void* elementType, void* mesh, unsigned element,
const double* globalCoord, double* localCoord )
{
RegularTrilinear* self = (RegularTrilinear*)elementType;
unsigned nInc, *inc;
double* vert[2];
double w;
assert( self && Stg_CheckType( self, RegularTrilinear ) );
Mesh_GetIncidence( mesh, MT_VOLUME, element, MT_VERTEX, self->inc );
nInc = IArray_GetSize( self->inc );
inc = IArray_GetSize( self->inc );
vert[0] = Mesh_GetVertex( mesh, inc[0] );
vert[1] = Mesh_GetVertex( mesh, inc[7] );
w = vert[1][0] - vert[0][0];
localCoord[0] = 2.0 * (globalCoord[0] - vert[0][0]) / w - 1.0;
w = vert[1][1] - vert[0][1];
localCoord[1] = 2.0 * (globalCoord[1] - vert[0][1]) / w - 1.0;
w = vert[1][2] - vert[0][2];
localCoord[2] = 2.0 * (globalCoord[2] - vert[0][2]) / w - 1.0;
assert( Num_InRange( localCoord[0], -1.0, 1.0 ) );
assert( Num_InRange( localCoord[1], -1.0, 1.0 ) );
assert( Num_InRange( localCoord[2], -1.0, 1.0 ) );
}
unsigned PETScMGSolver_GetNumLevels( void* matrixSolver ) {
PETScMGSolver* self = (PETScMGSolver*)matrixSolver;
assert( self && Stg_CheckType( self, PETScMGSolver ) );
return self->nLevels;
}
void PETScMGSolver_UpdateOps( PETScMGSolver* self ) {
PC pc;
Mat *pOps, *rOps;
PetscErrorCode ec;
unsigned l_i;
assert( self && Stg_CheckType( self, PETScMGSolver ) );
ec = KSPGetPC( self->mgData->ksp, &pc );
CheckPETScError( ec );
MGOpGenerator_Generate( self->opGen, (Mat**)&pOps, (Mat**)&rOps );
for( l_i = 1; l_i < self->nLevels; l_i++ ) {
//assert( Stg_CheckType( pOps[l_i], PETScMatrix ) );
//assert( Stg_CheckType( rOps[l_i], PETScMatrix ) );
PETScMGSolver_SetProlongation( self, l_i, pOps[l_i] );
#if( ((PETSC_VERSION_MAJOR==2) && (PETSC_VERSION_MINOR==3) && (PETSC_VERSION_SUBMINOR==3)) || (PETSC_VERSION_MAJOR==3) )
ec = PCMGSetInterpolation( pc, l_i, pOps[l_i] );
#else
ec = PCMGSetInterpolate( pc, l_i, pOps[l_i] );
#endif
CheckPETScError( ec );
PETScMGSolver_SetRestriction( self, l_i, rOps[l_i] );
ec = PCMGSetRestriction( pc, l_i, rOps[l_i] );
CheckPETScError( ec );
}
FreeArray( pOps );
FreeArray( rOps );
}
void _PETScMGSolver_AssignFromXML( void* matrixSolver, Stg_ComponentFactory* cf, void* data ) {
PETScMGSolver* self = (PETScMGSolver*)matrixSolver;
Bool pure;
unsigned nLevels;
unsigned nCycles;
unsigned nDownIts, nUpIts;
assert( self && Stg_CheckType( self, PETScMGSolver ) );
assert( cf );
//_PETScMatrixSolver_AssignFromXML( self, cf, data );
pure = Stg_ComponentFactory_GetBool( cf, self->name, (Dictionary_Entry_Key)"pure", False );
nLevels = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"levels", 1 );
nCycles = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"cycles", 1 );
nDownIts = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"downIterations", 1 );
nUpIts = Stg_ComponentFactory_GetUnsignedInt( cf, self->name, (Dictionary_Entry_Key)"upIterations", 1 );
Journal_Firewall( nLevels>1, NULL, "In func %s: Multigrid required mgLevels>1", __func__ );
self->pure = pure;
PETScMGSolver_SetLevels( self, nLevels );
PETScMGSolver_SetLevelCycles( self, nLevels - 1, nCycles );
PETScMGSolver_SetAllDownIterations( self, nDownIts );
PETScMGSolver_SetAllUpIterations( self, nUpIts );
self->opGen = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"opGenerator", MGOpGenerator, True, data );
MGOpGenerator_SetMatrixSolver( self->opGen, self );
MGOpGenerator_SetNumLevels( self->opGen, nLevels );
}
void _SphericalGenerator_GenElementTypes( void* meshGenerator, Mesh* mesh )
{
SphericalGenerator* self = (SphericalGenerator*)meshGenerator;
Stream* stream;
unsigned nDomainEls;
unsigned e_i;
assert( self && Stg_CheckType( self, SphericalGenerator ) );
stream = Journal_Register( Info_Type, (Name)self->type );
Journal_Printf( stream, "Generating element types...\n" );
Stream_Indent( stream );
mesh->nElTypes = 1;
mesh->elTypes = Memory_Alloc_Array( Mesh_ElementType*, mesh->nElTypes, "Mesh::elTypes" );
mesh->elTypes[0] = (Mesh_ElementType*)Mesh_HexType_New();
Mesh_ElementType_SetMesh( mesh->elTypes[0], mesh );
nDomainEls = Mesh_GetDomainSize( mesh, Mesh_GetDimSize( mesh ) );
mesh->elTypeMap = Memory_Alloc_Array( unsigned, nDomainEls, "Mesh::elTypeMap" );
for( e_i = 0; e_i < nDomainEls; e_i++ )
mesh->elTypeMap[e_i] = 0;
Mesh_SetAlgorithms( mesh, Mesh_SphericalAlgorithms_New( "", NULL ) );
MPI_Barrier( self->mpiComm );
Journal_Printf( stream, "... element types are '%s',\n", mesh->elTypes[0]->type );
Journal_Printf( stream, "... mesh algorithm type is '%s',\n", mesh->algorithms->type );
Journal_Printf( stream, "... done.\n" );
Stream_UnIndent( stream );
}
void _PETScMGSolver_Init( PETScMGSolver* self ) {
assert( self && Stg_CheckType( self, PETScMGSolver ) );
self->mgData = malloc( sizeof( MGSolver_PETScData ) );
/* from the depreciated MatrixSolver_Init func */
self->mgData->comm = MPI_COMM_WORLD;
KSPCreate( MPI_COMM_WORLD, &self->mgData->ksp );
self->mgData->matrix = PETSC_NULL;
self->mgData->inversion = PETSC_NULL;
self->mgData->residual = PETSC_NULL;
self->mgData->expiredResidual = True;
self->mgData->matrixChanged = True;
self->mgData->optionsReady = False;
self->mgData->curRHS = PETSC_NULL;
self->mgData->curSolution = PETSC_NULL;
/* end of MatrixSolver_Init stuff */
self->nLevels = 0;
self->levels = NULL;
self->opGen = NULL;
self->solversChanged = True;
self->opsChanged = True;
}
void SROpGenerator_GenMeshes( SROpGenerator* self ) {
unsigned nLevels;
unsigned l_i;
assert( self && Stg_CheckType( self, SROpGenerator ) );
nLevels = self->nLevels;
self->meshes = AllocArray( Mesh*, nLevels );
memset( self->meshes, 0, nLevels * sizeof(Mesh*) );
self->topMaps = AllocArray( unsigned*, nLevels );
memset( self->topMaps, 0, nLevels * sizeof(unsigned*) );
self->eqNums = AllocArray( unsigned**, nLevels );
memset( self->eqNums, 0, nLevels * sizeof(unsigned**) );
self->nLocalEqNums = AllocArray( unsigned, nLevels );
memset( self->nLocalEqNums, 0, nLevels * sizeof(unsigned) );
self->eqNumBases = AllocArray( unsigned, nLevels );
memset( self->eqNumBases, 0, nLevels * sizeof(unsigned) );
self->meshes[nLevels - 1] = (Mesh*)self->fineEqNum->feMesh;
self->eqNumBases[nLevels - 1] = self->fineEqNum->firstOwnedEqNum;
for( l_i = nLevels - 2; l_i < nLevels; l_i-- ) {
SROpGenerator_GenLevelMesh( self, l_i );
SROpGenerator_GenLevelTopMap( self, l_i );
SROpGenerator_GenLevelEqNums( self, l_i );
}
}
Bool SROpGenerator_HasExpired( void* srOpGenerator ) {
SROpGenerator* self = (SROpGenerator*)srOpGenerator;
assert( self && Stg_CheckType( self, SROpGenerator ) );
return False;
}
void _MeshGenerator_SetDimSize( void* meshGenerator, unsigned nDims ) {
MeshGenerator* self = (MeshGenerator*)meshGenerator;
unsigned d_i, d_j;
assert( self && Stg_CheckType( self, MeshGenerator ) );
self->nDims = nDims;
self->enabledDims = ReallocArray( self->enabledDims, Bool, nDims + 1 );
self->enabledInc = ReallocArray2D( self->enabledInc, Bool, nDims + 1, nDims + 1 );
for( d_i = 0; d_i <= nDims; d_i++ ) {
if( d_i == 0 || d_i == nDims )
self->enabledDims[d_i] = True;
else
self->enabledDims[d_i] = False;
for( d_j = 0; d_j <= nDims; d_j++ ) {
if( (d_i == 0 || d_i == nDims) && (d_j == 0 || d_j == nDims) ) {
if( d_i == d_j && d_j == nDims )
self->enabledInc[d_i][d_j] = False;
else
self->enabledInc[d_i][d_j] = True;
}
else
self->enabledInc[d_i][d_j] = False;
}
}
}
void MultigridSolver_DestructLevels( MultigridSolver* self ) {
unsigned l_i;
assert( self && Stg_CheckType( self, MultigridSolver ) );
for( l_i = 0; l_i < self->nLevels; l_i++ ) {
MultigridSolver_Level* level = self->levels + l_i;
if( level->downSolver ) {
//Stg_Class_RemoveRef( MatrixSolver_GetMatrix( level->downSolver ) );
//Stg_Class_RemoveRef( level->downSolver );
if( level->downSolver->ksp != PETSC_NULL ) Stg_KSPDestroy(&level->downSolver->ksp );
if( level->downSolver->matrix != PETSC_NULL ) Stg_MatDestroy(&level->downSolver->matrix );
if( level->downSolver->inversion != PETSC_NULL ) Stg_MatDestroy(&level->downSolver->inversion );
if( level->downSolver->residual != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->residual );
if( level->downSolver->curRHS != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->curRHS );
if( level->downSolver->curSolution != PETSC_NULL ) Stg_VecDestroy(&level->downSolver->curSolution );
free( level->downSolver );
}
if( level->upSolver ) {
//Stg_Class_RemoveRef( MatrixSolver_GetMatrix( level->upSolver ) );
//Stg_Class_RemoveRef( level->upSolver );
if( level->upSolver->ksp != PETSC_NULL ) Stg_KSPDestroy(&level->upSolver->ksp );
if( level->upSolver->matrix != PETSC_NULL ) Stg_MatDestroy(&level->upSolver->matrix );
if( level->upSolver->inversion != PETSC_NULL ) Stg_MatDestroy(&level->upSolver->inversion );
if( level->upSolver->residual != PETSC_NULL ) Stg_VecDestroy(&level->upSolver->residual );
if( level->upSolver->curRHS != PETSC_NULL ) Stg_VecDestroy(&level->upSolver->curRHS );
if( level->upSolver->curSolution != PETSC_NULL ) Stg_VecDestroy(&level->upSolver->curSolution );
free( level->upSolver );
}
if( level->R != PETSC_NULL )
//Stg_Class_RemoveRef( level->R );
Stg_MatDestroy(&level->R );
if( level->P != PETSC_NULL )
//Stg_Class_RemoveRef( level->P );
Stg_MatDestroy(&level->P );
if( level->workRHS != PETSC_NULL )
//Stg_Class_RemoveRef( level->workRHS );
Stg_VecDestroy(&level->workRHS );
if( level->workSol != PETSC_NULL )
//Stg_Class_RemoveRef( level->workSol );
Stg_VecDestroy(&level->workSol );
}
KillArray( self->levels );
self->nLevels = 0;
self->solversChanged = True;
self->opsChanged = True;
/* Temporary. */
//KillObject( self->outerSolver );
if( self->outerSolver->ksp ) Stg_KSPDestroy(&self->outerSolver->ksp );
if( self->outerSolver->matrix ) Stg_MatDestroy(&self->outerSolver->matrix );
if( self->outerSolver->inversion ) Stg_MatDestroy(&self->outerSolver->inversion );
if( self->outerSolver->residual ) Stg_VecDestroy(&self->outerSolver->residual );
if( self->outerSolver->curRHS ) Stg_VecDestroy(&self->outerSolver->curRHS );
if( self->outerSolver->curSolution ) Stg_VecDestroy(&self->outerSolver->curSolution );
free( self->outerSolver );
}
void _SwarmDump_Execute( void* swarmDump, void* data ) {
SwarmDump* self = (SwarmDump*) swarmDump;
AbstractContext* context = Stg_CheckType( data, AbstractContext );
Stream* stream = Journal_Register( MPIStream_Type, Swarm_Type );
Particle_Index particleLocalCount;
SizeT particleSize;
Name filename;
Index swarm_I;
Swarm* swarm;
Stream* info = Journal_Register( Info_Type, self->type );
Processor_Index rank_I;
Journal_DPrintf( info, "Proc %d: beginning Swarm binary checkpoint in %s():\n", self->swarmList[0]->myRank, __func__ );
Stream_Indent( info );
for ( swarm_I = 0 ; swarm_I < self->swarmCount ; swarm_I++ ) {
swarm = self->swarmList[ swarm_I ];
particleLocalCount = swarm->particleLocalCount;
particleSize = (SizeT) swarm->particleExtensionMgr->finalSize;
if ( self->newFileEachTime ) {
if ( strlen(context->checkPointPrefixString) > 0 ) {
Stg_asprintf( &filename, "%s/%s.%s.%05d.dat", context->outputPath,
context->checkPointPrefixString, swarm->name, context->timeStep );
}
else {
Stg_asprintf( &filename, "%s/%s.%05d.dat", context->outputPath,
swarm->name, context->timeStep );
}
}
else {
if ( strlen(context->checkPointPrefixString) > 0 ) {
Stg_asprintf( &filename, "%s/%s.%s.dat", context->outputPath,
context->checkPointPrefixString, swarm->name );
}
else {
Stg_asprintf( &filename, "%s/%s.dat", context->outputPath, swarm->name );
}
}
for ( rank_I = 0; rank_I < swarm->nProc; rank_I++ ) {
if ( swarm->myRank == rank_I ) {
Journal_DPrintf( info, "Proc %d: for swarm \"%s\", dumping its %u particles of size %u bytes "
"each (= %g bytes total) to file %s\n", swarm->myRank, swarm->name, particleLocalCount,
particleSize, (float)(particleLocalCount * particleSize), filename );
}
MPI_Barrier( swarm->comm );
}
Stream_RedirectFile( stream, filename );
MPIStream_WriteAllProcessors( stream, swarm->particles, particleSize, (SizeT) particleLocalCount, swarm->comm );
Stream_CloseFile( stream );
Memory_Free( filename );
}
Stream_UnIndent( info );
Journal_DPrintf( info, "Proc %d: finished Swarm binary checkpoint.\n", self->swarmList[0]->myRank );
}
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 _SROpGenerator_Delete( void* srOpGenerator ) {
SROpGenerator* self = (SROpGenerator*)srOpGenerator;
assert( self && Stg_CheckType( self, SROpGenerator ) );
/* Delete the parent. */
_MGOpGenerator_Delete( self );
}
void _MaterialFeVariable_Init( MaterialFeVariable* self, Material* material ) {
IntegrationPointsSwarm* swarm;
/* Assign Pointers */
swarm = Stg_CheckType( self->assemblyTerm->integrationSwarm, IntegrationPointsSwarm );
self->picIntegrationPoints = swarm;
self->material = material;
}
