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 _DomainContext_AssignFromXML( void* context, Stg_ComponentFactory* cf, void* data ) { DomainContext* self = (DomainContext*)context; Dictionary *contextDict = NULL; _AbstractContext_AssignFromXML( context, cf, data ); self->dim = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "dim", 2 ); self->verticalAxis = Dictionary_GetUnsignedInt_WithDefault( self->dictionary, "VerticalAxis", 1 ); /* try grab the scaling component and put it on the context * check for the contextDict first as ConstructByKey NEEDS the conextDict * and in units tests the contextDict sometime doesn't exist */ contextDict = Dictionary_GetDictionary( cf->componentDict, self->name ); if( contextDict ) { self->scaling = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)"Scaling", Scaling, False, data ); } if( !self->scaling ) { self->scaling = Stg_ComponentFactory_ConstructByName( cf, (Name)"default_scaling", Scaling, False, data ); } /* The following is for backward compatiblity with old (GALE) xml files. */ { /* Post change 1d3dc4e00549 in this repositroy, the old style of DofLayout * XML definition was illegal. This change allows for the old style. * * Here we build all 'MeshVariable' components first. * * This is a hack, selective construction of general component over other is * a weakness to the object model and should be avoided. This section should * be removed in future and xml files updated in accordance with change 1d3dc4e00549 */ Stg_Component *component=NULL; Index component_I; for( component_I = 0; component_I < LiveComponentRegister_GetCount( cf->LCRegister ); component_I++ ){ /* Grab component from register */ component = LiveComponentRegister_At( cf->LCRegister, component_I ); /* if not a "MeshVariable" do nothing */ if( strcmp( component->type, MeshVariable_Type ) ) continue; if( component && !component->isConstructed ){ Journal_Printf( cf->infoStream, "Constructing %s as %s\n", component->type, component->name ); Stg_Component_AssignFromXML( component, cf, data, True ); } } } _DomainContext_Init( self ); }
unsigned int _Stg_ComponentFactory_GetRootDictUnsignedInt( void* cf, Dictionary_Entry_Key key, const unsigned int defaultVal ) { Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf; Journal_PrintfL( self->infoStream,2, "Getting unsigned int from root dictionary with key '%s' and default value '%u'\n", key, defaultVal ); assert( self->rootDict ); return Dictionary_GetUnsignedInt_WithDefault( self->rootDict, key, defaultVal ); }
void _StGermain_SingleAttractor_AssignFromXML( void* component, Stg_ComponentFactory* cf, void* data ) { DomainContext* context; context = Stg_ComponentFactory_ConstructByName( cf, (Name)"context", DomainContext, True, data ); Stream_SetPrintingRank( Journal_Register( Info_Type, (Name)"Context" ), Dictionary_GetUnsignedInt_WithDefault( context->dictionary, "procToWatch", 0 ) ); ContextEP_ReplaceAll( context, AbstractContext_EP_Solve, StGermain_SingleAttractor_UpdatePositions ); }
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 SemiLagrangianIntegratorSuite_UpdatePositions( void* data, FiniteElementContext* context ) { Index reverseTimeStep = Dictionary_GetUnsignedInt_WithDefault( context->dictionary, "reverseTimeStep", 100 ); FeVariable* velocityField = (FeVariable*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"VelocityField" ); FeMesh* mesh = velocityField->feMesh; unsigned node_I; Index dim_I; unsigned nDims = Mesh_GetDimSize( mesh ); double velocity[3]; double phi; SemiLagrangianIntegrator* slIntegrator; FeVariable* phiField; FeVariable* phiStarField; _FeVariable_SyncShadowValues( velocityField ); /* reverse the numerically advected particles (& the semi lagrangian field also) */ if( context->timeStep == reverseTimeStep + 1 ) { for( node_I = 0; node_I < Mesh_GetLocalSize( mesh, MT_VERTEX ); node_I++ ) { _FeVariable_GetValueAtNode( velocityField, node_I, velocity ); for( dim_I = 0; dim_I < nDims; dim_I++ ) { velocity[dim_I] *= -1; } FeVariable_SetValueAtNode( velocityField, node_I, velocity ); } } slIntegrator = (SemiLagrangianIntegrator*)LiveComponentRegister_Get( context->CF->LCRegister, (Name)"integrator" ); phiField = (FeVariable* )LiveComponentRegister_Get( context->CF->LCRegister, (Name)"PhiField" ); phiStarField = (FeVariable* )LiveComponentRegister_Get( context->CF->LCRegister, (Name)"PhiStarField" ); SemiLagrangianIntegrator_Solve( slIntegrator, phiField, phiStarField ); for( node_I = 0; node_I < Mesh_GetLocalSize( mesh, MT_VERTEX ); node_I++ ) { FeVariable_GetValueAtNode( phiStarField, node_I, &phi ); FeVariable_SetValueAtNode( phiField, node_I, &phi ); } }
int main(int argc, char *argv[]) { MPI_Comm CommWorld; int rank; int procCount; int procToWatch; Dictionary* dictionary; Topology* nTopology; ElementLayout* eLayout; NodeLayout* nLayout; HexaMD* decompCorner; HexaMD* decompBody; Stream* stream; Index decompDims; XML_IO_Handler* ioHandler; Dimension_Index dim_I; /* Initialise MPI, get world info */ MPI_Init(&argc, &argv); MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld ); MPI_Comm_size(CommWorld, &procCount); MPI_Comm_rank(CommWorld, &rank); Base_Init( &argc, &argv ); DiscretisationGeometry_Init( &argc, &argv ); DiscretisationShape_Init( &argc, &argv ); DiscretisationMesh_Init( &argc, &argv ); MPI_Barrier( CommWorld ); /* Ensures copyright info always come first in output */ procToWatch = argc >= 2 ? atoi(argv[1]) : 0; Journal_Enable_TypedStream( DebugStream_Type, False ); stream = Journal_Register( DebugStream_Type, HexaMD_Type ); Stream_EnableBranch( stream, True ); Stream_SetLevelBranch( stream, 3 ); dictionary = Dictionary_New(); Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) ); Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) ); Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 5 ) ); Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 5 ) ); Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 5 ) ); Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( True ) ); Dictionary_Add( dictionary, "allowPartitionOnElement", Dictionary_Entry_Value_FromBool( False ) ); Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) ); Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( False ) ); Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 1 ) ); /* Moved afterwards to allow command line to over-ride */ ioHandler = XML_IO_Handler_New(); IO_Handler_ReadAllFromCommandLine( ioHandler, argc, argv, dictionary ); decompDims = Dictionary_GetUnsignedInt_WithDefault( dictionary, "decompDims", 1 ); nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary ); eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary ); nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology ); decompCorner = HexaMD_New_All( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout, decompDims ); if( rank == procToWatch ) { printf( "Corner Node Layout\n" ); PrintDecompInfoOfHexaMD( decompCorner, rank ); printf( "\n" ); } /* Do a run with body nodes */ Stg_Class_Delete( nLayout ); /* TODO: the following is a bit of a hack because of the weird way mesh size is defined by default in the dictionary (assumes a corner mesh ) */ for ( dim_I = 0; dim_I < 3; dim_I++ ) { if ( ((IJKTopology*)nTopology)->size[dim_I] > 1 ) { ((IJKTopology*)nTopology)->size[dim_I]--; } } nLayout = (NodeLayout*)BodyNL_New( "BodyNL", dictionary, eLayout, nTopology ); decompBody = HexaMD_New_All( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout, decompDims ); if( rank == procToWatch ) { Bool result; printf( "Body Node Layout\n" ); //PrintDecompInfoOfHexaMD( decompBody, rank ); printf( "Checking body node decomp has same element decomp as corner node decomp:\n" ); result = CheckDecompItemsAreDecomposedIdentically( decompCorner, ELEMENT_ITEM_TYPE, decompBody, ELEMENT_ITEM_TYPE, rank ); if ( result == True ) printf( "\tPassed.\n" ); else printf( "\tFailed.\n" ); printf( "Checking body node decomp has same node decomp as it's element decomp:\n" ); result = CheckDecompItemsAreDecomposedIdentically( decompBody, ELEMENT_ITEM_TYPE, decompBody, NODE_ITEM_TYPE, rank ); if ( result == True ) printf( "\tPassed.\n" ); else printf( "\tFailed.\n" ); } Stg_Class_Delete( decompBody ); Stg_Class_Delete( decompCorner ); Stg_Class_Delete( nLayout ); Stg_Class_Delete( eLayout ); Stg_Class_Delete( nTopology ); Stg_Class_Delete( dictionary ); DiscretisationMesh_Finalise(); DiscretisationShape_Finalise(); DiscretisationGeometry_Finalise(); Base_Finalise(); /* Close off MPI */ MPI_Finalize(); return EXIT_SUCCESS; }
void PCDVCSuite_TestExponentialInterface( PCDVCSuiteData* data ) { Swarm* integrationSwarm = (Swarm*)LiveComponentRegister_Get( data->context->CF->LCRegister, (Name)"integrationSwarm" ); Swarm* materialSwarm = (Swarm*)LiveComponentRegister_Get( data->context->CF->LCRegister, (Name)"materialPoints" ); FeMesh* mesh = (FeMesh*)LiveComponentRegister_Get( data->context->CF->LCRegister, (Name)"linearMesh" ); //WeightsCalculator* weights = (WeightsCalculator*)LiveComponentRegister_Get( data->context->CF->LCRegister, (Name)"weights" ); FeVariable* feVariable; Element_LocalIndex lElement_I = 0; double analyticValue = 0.0; double integral = 0.0; double error; double errorSquaredSum = 0.0; double errorSum = 0.0; Index loop_I; Index count = Dictionary_GetUnsignedInt_WithDefault( data->context->dictionary, "SampleSize", 5000 ); void* generic = NULL; double mean; double standardDeviation; /* Create FeVariable */ feVariable = FeVariable_New_Full( "feVariable", (DomainContext*)data->context, mesh, NULL, NULL, NULL, NULL, NULL, 1, data->context->dim, False, False, False, MPI_COMM_WORLD, data->context->fieldVariable_Register ); feVariable->_interpolateWithinElement = ExponentialInterface; analyticValue = 0.05 * (exp(2) - exp(-2)) + 2.0; for ( loop_I = 0 ; loop_I < count ; loop_I++ ) { /* Layout Particles */ Swarm_Random_Seed( (long)loop_I ); _Swarm_InitialiseParticles( materialSwarm, generic ); _IntegrationPointsSwarm_UpdateHook( NULL, integrationSwarm ); /* The following function should not be called here as it is already called ultimately via the above function */ /* calling this function again causes a first iteration in Lloyd's algorithm for the Voronoi cells which we don't want here */ //WeightsCalculator_CalculateCell( weights, integrationSwarm, lElement_I ); /* Evaluate Integral */ integral = FeVariable_IntegrateElement( feVariable, integrationSwarm, lElement_I ); /* Calculate Error */ error = fabs( integral - analyticValue )/fabs( analyticValue ); errorSum += error; errorSquaredSum += error*error; } /* Calculate Mean and Standard Deviation */ mean = errorSum / (double)count; standardDeviation = sqrt( errorSquaredSum / (double)count - mean * mean ); printf("In %s: Mean %lf SD %lf Sol %lf\n", __func__, mean, standardDeviation, analyticValue); Stg_Component_Destroy( feVariable, NULL, True ); compareAgainstReferenceSolution( data->context, data->stream, mean, standardDeviation, "testPCDVC_ExponentialInterface.expected" ); }
void StGermain_VaryingCornerAttractors_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; BlockGeometry* blockGeometry; Stream* stream = Journal_Register( Debug_Type, (Name)"particleUpdate" ); unsigned int movementSpeedDivisor = 10; int movementSign = 1; unsigned int cornerPeriod = 10; unsigned int numCorners = (swarm->dim-1 )*4; unsigned int explosionPeriod = numCorners*cornerPeriod; Coord cornerCoords[8]; int modValue = 0; int cornerIndex = 0; Stream_SetPrintingRank( stream, Dictionary_GetUnsignedInt_WithDefault( context->dictionary, "procToWatch", 0 ) ); blockGeometry = (BlockGeometry*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"geometry" ); /* Bottom left corner */ cornerCoords[0][I_AXIS] = blockGeometry->min[I_AXIS]; cornerCoords[0][J_AXIS] = blockGeometry->min[J_AXIS]; cornerCoords[0][K_AXIS] = blockGeometry->min[K_AXIS]; /* Bottom right corner */ cornerCoords[1][I_AXIS] = blockGeometry->max[I_AXIS]; cornerCoords[1][J_AXIS] = blockGeometry->min[J_AXIS]; cornerCoords[1][K_AXIS] = blockGeometry->min[K_AXIS]; /* Top right corner */ cornerCoords[2][I_AXIS] = blockGeometry->max[I_AXIS]; cornerCoords[2][J_AXIS] = blockGeometry->max[J_AXIS]; cornerCoords[2][K_AXIS] = blockGeometry->min[K_AXIS]; /* Top left corner */ cornerCoords[3][I_AXIS] = blockGeometry->min[I_AXIS]; cornerCoords[3][J_AXIS] = blockGeometry->max[J_AXIS]; cornerCoords[3][K_AXIS] = blockGeometry->min[K_AXIS]; /* Bottom left corner */ cornerCoords[4][I_AXIS] = blockGeometry->min[I_AXIS]; cornerCoords[4][J_AXIS] = blockGeometry->max[J_AXIS]; cornerCoords[4][K_AXIS] = blockGeometry->max[K_AXIS]; /* Bottom right corner */ cornerCoords[5][I_AXIS] = blockGeometry->min[I_AXIS]; cornerCoords[5][J_AXIS] = blockGeometry->min[J_AXIS]; cornerCoords[5][K_AXIS] = blockGeometry->max[K_AXIS]; /* Top right corner */ cornerCoords[6][I_AXIS] = blockGeometry->max[I_AXIS]; cornerCoords[6][J_AXIS] = blockGeometry->min[J_AXIS]; cornerCoords[6][K_AXIS] = blockGeometry->max[K_AXIS]; /* Top left corner */ cornerCoords[7][I_AXIS] = blockGeometry->max[I_AXIS]; cornerCoords[7][J_AXIS] = blockGeometry->max[J_AXIS]; cornerCoords[7][K_AXIS] = blockGeometry->max[K_AXIS]; /* calculate which corner */ modValue = (context->timeStep - 1) % (numCorners * cornerPeriod ); cornerIndex = modValue / cornerPeriod; memcpy( attractorPoint, cornerCoords[cornerIndex], 3 * sizeof(double) ); Journal_Printf( stream, "Calculated attractor point is at (%f,%f,%f):\n", attractorPoint[0], attractorPoint[1], attractorPoint[2] ); /* Can't really explode in this test as particles go out of box */ #if 0 /* 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; } #endif 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 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 StGermain_Bouncer_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" ); BlockGeometry* blockGeom; Stream* stream = Journal_Register( Debug_Type, (Name)"particleUpdate" ); unsigned int movementSpeedDivisor = 5; Particle_Index lParticle_I = 0; Stream_SetPrintingRank( stream, Dictionary_GetUnsignedInt_WithDefault( context->dictionary, "procToWatch", 0 ) ); blockGeom = (BlockGeometry*) LiveComponentRegister_Get( context->CF->LCRegister, (Name)"geometry" ); if ( context->timeStep == 1 ) { /* for each particle, set a random velocity */ for ( lParticle_I=0; lParticle_I < swarm->particleLocalCount; lParticle_I++ ) { currParticle = (Particle*)Swarm_ParticleAt( swarm, lParticle_I ); for ( dim_I=0; dim_I < 3; dim_I++ ) { currParticle->velocity[dim_I] = ((double) ( rand() - (double)(RAND_MAX)/2 )) / RAND_MAX * 0.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] = currParticle->velocity[dim_I] / movementSpeedDivisor; if ( ( currParticle->velocity[dim_I] < 0 ) && ( fabs(currParticle->velocity[dim_I] ) > ((*oldCoord)[dim_I] - blockGeom->min[dim_I]) ) ) { Journal_Printf( stream, "\t\tFlipping vel in %d dir\n", dim_I ); movementVector[dim_I] *= -1; currParticle->velocity[dim_I] *= -1; } if ( ( currParticle->velocity[dim_I] > 0 ) && ( fabs(currParticle->velocity[dim_I] ) > ( blockGeom->max[dim_I] - (*oldCoord)[dim_I] ) ) ) { Journal_Printf( stream, "\t\tFlipping vel in %d dir\n", dim_I ); movementVector[dim_I] *= -1; currParticle->velocity[dim_I] *= -1; } newParticleCoord[dim_I] = (*oldCoord)[dim_I] + movementVector[dim_I]; } 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 ); }