float3 NBodySystemInitializator::getNewVelocity(float3 pos) {
// Csak a 2D van támogatva
if (mp_properties->dimension != TWO)
return getNewVelocity();
float x, y, z;
float dist = sqrt(pos.x * pos.x + pos.y * pos.y);
float temp = (2*mp_properties->positionScale - dist) / mp_properties->positionScale * mp_properties->velocityScale;
x = abs(mp_properties->initVelocityFactor * normalvalue(0.0f, mp_properties->velocityScale + temp));
y = abs(mp_properties->initVelocityFactor * normalvalue(0.0f, mp_properties->velocityScale + temp));
if (pos.x >= 0) {
if (pos.y >= 0) {
x = -x;
y = y;
}
else{
x = x;
y = y;
}
}
else {
if (pos.y >= 0) {
x = -x;
y = -y;
}
else {
x = x;
y = -y;
}
}
z = 0.0f;
float3 result;
result.x = x; result.y = y; result.z = z;
return result;
}
// -----------------------------------------------------------------------------
// This does the actual computation to update the state variables.
// I've included this function since the initializeGlobalPressure() and advance()
// functions are, for the most part, the same piece of code.
// -----------------------------------------------------------------------------
void AMRNavierStokes::PPMIGTimeStep (const Real a_oldTime,
const Real a_dt,
const bool a_updatePassiveScalars,
const bool a_doLevelProj)
{
CH_TIME("AMRNavierStokes::PPMIGTimeStep");
pout() << setiosflags(ios::scientific) << setprecision(8) << flush;
// Set up some basic values
const RealVect& dx = m_levGeoPtr->getDx();
const DisjointBoxLayout& grids = newVel().getBoxes();
DataIterator dit = grids.dataIterator();
const Box domainBox = m_problem_domain.domainBox();
const bool isViscous = (s_nu > 0.0);
// Initialize all flux registers
if (!finestLevel()) {
m_vel_flux_reg.setToZero();
for (int comp = 0; comp < s_num_scal_comps; ++comp) {
m_scal_fluxreg_ptrs[comp]->setToZero();
}
m_lambda_flux_reg.setToZero();
}
// Sanity checks
CH_assert(m_levGeoPtr->getBoxes() == grids);
CH_assert(m_levGeoPtr->getDomain() == m_problem_domain);
CH_assert(Abs(a_oldTime - (m_time - a_dt)) < TIME_EPS);
CH_assert(s_num_scal_comps <= 1);
CH_assert(s_num_scal_comps > 0 || s_gravityMethod == ProblemContext::GravityMethod::NONE);
// Reference new holders
LevelData<FArrayBox>& new_vel = newVel();
LevelData<FArrayBox>& new_lambda = newLambda();
LevelData<FArrayBox> new_b;
if (s_num_scal_comps > 0) {
aliasLevelData(new_b, &(newScal(0)), Interval(0,0));
}
// Compute advecting velocities
LevelData<FArrayBox> old_vel(grids, SpaceDim, m_tracingGhosts);
fillVelocity(old_vel, a_oldTime);
old_vel.exchange(m_tracingExCopier);
LevelData<FluxBox> adv_vel(grids, 1, IntVect::Unit); // Changed from m_tracingGhosts to 1
computeAdvectingVelocities(adv_vel, old_vel, a_oldTime, a_dt);
if (a_updatePassiveScalars) {
// Lambda update
LevelData<FArrayBox> old_lambda;
fillLambda(old_lambda, a_oldTime);
old_lambda.exchange(m_tracingExCopier);
LevelData<FArrayBox> dLdt(grids, 1);
getNewLambda(dLdt, new_lambda, old_lambda, old_vel, adv_vel, a_oldTime, a_dt, a_dt);
}
LevelData<FArrayBox> old_b;
if (s_num_scal_comps > 0) {
// Scalar update
fillScalars(old_b, a_oldTime, 0);
old_b.exchange(m_tracingExCopier);
LevelData<FArrayBox> dSdt(grids, 1);
getNewScalar(dSdt, new_b, old_b, old_vel, adv_vel, a_oldTime, a_dt, a_dt, 0);
}
for (int comp = 1; comp < s_num_scal_comps; ++comp) {
// Scalar update
LevelData<FArrayBox> old_scal;
fillScalars(old_scal, a_oldTime, comp);
old_scal.exchange(m_tracingExCopier);
LevelData<FArrayBox> dSdt(grids, 1);
getNewScalar(dSdt, newScal(comp), old_scal, old_vel, adv_vel, a_oldTime, a_dt, a_dt, comp);
}
{ // Update CC velocities
LevelData<FArrayBox> dUdt(grids, SpaceDim);
getNewVelocity(dUdt, new_vel, old_vel, adv_vel, a_oldTime, a_dt, a_dt);
}
if (s_num_scal_comps > 0) {
// Do implicit gravity update and CC projection.
doCCIGProjection(new_vel, new_b, old_vel, old_b, adv_vel, a_oldTime, a_dt, a_doLevelProj);
} else {
// Do a standard CC projection.
doCCProjection(new_vel, a_oldTime + a_dt, a_dt, a_doLevelProj);
}
}
