예제 #1
0
void LogResSolver3D::vel_step ()
{
  if(m_nbIter > m_nbMaxIter)
    return;
  add_source (m_u, m_uSrc);
  add_source (m_v, m_vSrc);
  add_source (m_w, m_wSrc);
  addVorticityConfinement(m_u,m_v,m_w);
  SWAP (m_uPrev, m_u);
  diffuse (1, m_u, m_uPrev, m_aVisc);
  SWAP (m_vPrev, m_v);
  diffuse (2, m_v, m_vPrev, m_aVisc);
  SWAP (m_wPrev, m_w);
  diffuse (3, m_w, m_wPrev, m_aVisc);
  m_index = 0;
  project (m_uPrev, m_vPrev);
  SWAP (m_uPrev, m_u);
  SWAP (m_vPrev, m_v);
  SWAP (m_wPrev, m_w);
  advect (1, m_u, m_uPrev, m_uPrev, m_vPrev, m_wPrev);
  advect (2, m_v, m_vPrev, m_uPrev, m_vPrev, m_wPrev);
  advect (3, m_w, m_wPrev, m_uPrev, m_vPrev, m_wPrev);
  m_index = 1;
  project (m_uPrev, m_vPrev);

  if(m_nbIter == m_nbMaxIter)
    cout << "Simulation over" << endl;
}
예제 #2
0
//-----------------------------------------------------------------------------
void StamFluidSolver::vel_step ( float * u, float * v, float * u0, float * v0, float visc, float dt )
{
    addSource ( u, u0, dt );
    addSource ( v, v0, dt );

#if (VORTICITY_CONFINEMENT == 1)
    if(mUseVorticityConfinement)
    {
        // add in vorticity confinement force
        vorticityConfinement(u0, v0);
        addSource ( u, u0, dt );
        addSource ( v, v0, dt );
    }
#endif

#if 0
    // add in temperature force
    if(mSimulateTemperature)
    {
        heatRise(v0);
        addSource ( v, v0, dt );
    }
#endif

    SWAP ( u0, u );
    diffuse ( 1, u, u0, visc, dt );
    SWAP ( v0, v );
    diffuse ( 2, v, v0, visc, dt );
    project ( u, v, u0, v0 );
    SWAP ( u0, u );
    SWAP ( v0, v );
    advect ( 1, u, u0, u0, v0, dt );
    advect ( 2, v, v0, u0, v0, dt );
    project ( u, v, u0, v0 );
}
예제 #3
0
void vel_step
( int step
  , int method
  , int iters,  int N
  , float* u,   float* v
  , float* u0,  float* v0
  , float visc, float dt)
{
    add_source ( N, u, u0, dt );
    add_source ( N, v, v0, dt );

    SWAP    (u0, u);
    diffuse (method, iters, N, 1, u, u0, visc, dt);

    SWAP    (v0, v);
    diffuse (method, iters, N, 2, v, v0, visc, dt);

    project (method, iters, N, u, v, u0, v0);
    SWAP    (u0, u);
    SWAP    (v0, v);

    advect  (N, 1, u, u0, u0, v0, dt);
    advect  (N, 2, v, v0, u0, v0, dt);

    project (method, iters, N, u, v, u0, v0);
}
예제 #4
0
파일: fluid2d.c 프로젝트: jorgenfar/TDT4200
/*
	Function for setting up and running the fluid simulation kernels
*/
void solveFluid(struct Configuration* config) { 
	// Jacobi settings
	float alpha = -1.0f;
	// Should use alpha -1 here, but this gives nicer results
	//float alpha = -(1.0f/invhalfgridscale);
	float rbeta = 0.25;
	int iterations = 100;

	// grid scaling. this is currently not used
    if(rank == 0){
        float gridscale = 1.0f;
        float invgridscale = 1.0f/gridscale;
        float invhalfgridscale = 0.5f/gridscale; 

        // Timstep value
        float timestep = 0.05f;

        // Emitter settings
        float amount = 2.0f;
        float radius = 0.5*config->N/10.0f;
        float emitterposx = config->N/2;
        float emitterposy = config->N/3;

        // buoyancy settings
        float bdiry = 1.0f;
        float bdirx = 0.0f;
        float bstrength = 0.1f;

        // advection settings
        float veldamp = 0.01f;	


        // Velocity advection
        float *tmp = config->velx0; config->velx0 = config->velx; config->velx = tmp;
        float *tmp1 = config->vely0; config->vely0 = config->vely; config->vely = tmp1;
        advect(config->N, config->velx, config->velx0, config->velx0, config->vely0, timestep, veldamp, 1);
        advect(config->N, config->vely, config->vely0, config->velx0, config->vely0, timestep, veldamp, 2);

        // Density advection
        float *tmp2 = config->dens0; config->dens0 = config->dens; config->dens = tmp2;
        advect(config->N, config->dens, config->dens0, config->velx, config->vely, timestep, 0.0f, 0);

        // Add density and density buoyancy
        addDensity(config->N, config->dens, timestep, emitterposx, emitterposy, radius, amount);
        addDensityBuoyancy(config->N, config->velx, config->vely, config->dens, bdirx, bdiry, bstrength, timestep);

        // Divergence calculation
        divergence(config->N, config->velx, config->vely, config->div);	

        // Pressure jacobi calculation. First set pres array to zero as initial guess
        setMem(config->N, config->pres);
    }

	jacobi(iterations);
	
    if(rank == 0){
        // Calculate projection
        projection(config->N, config->velx, config->vely, config->pres);	
    }
}
예제 #5
0
///////////////////////////////////////////////////////////////////////////////
/// Calculate the velocity
///
///\param para Pointer to FFD parameters
///\param var Pointer to FFD simulation variables
///\param BINDEX Pointer to boundary index
///
///\return 0 if no error occurred
/////////////////////////////////////////////////////////////////////////////// 
int vel_step(PARA_DATA *para, REAL **var,int **BINDEX) {
  REAL *u  = var[VX],  *v  = var[VY],    *w  = var[VZ];
  REAL *u0 = var[TMP1], *v0 = var[TMP2], *w0 = var[TMP3];
  int flag = 0;

  flag = advect(para, var, VX, 0, u0, u, BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not advect for velocity X.", FFD_ERROR);
    return flag;
  }

  flag = advect(para, var, VY, 0, v0, v, BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not advect for velocity Y.", FFD_ERROR);
    return flag;
  }

  flag = advect(para, var, VZ, 0, w0, w, BINDEX); 
  if(flag!=0) {
    ffd_log("vel_step(): Could not advect for velocity Z.", FFD_ERROR);
    return flag;
  }

  flag = diffusion(para, var, VX, 0, u, u0, BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not diffuse velocity X.", FFD_ERROR);
    return flag;
  }

  flag = diffusion(para, var, VY, 0, v, v0, BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not diffuse velocity Y.", FFD_ERROR);
    return flag;
  }

  flag = diffusion(para, var, VZ, 0, w, w0, BINDEX); 
  if(flag!=0) {
    ffd_log("vel_step(): Could not diffuse velocity Z.", FFD_ERROR);
    return flag;
  }

  flag = project(para, var,BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not project velocity.", FFD_ERROR);
    return flag;
  }

  if(para->bc->nb_outlet!=0) flag = mass_conservation(para, var,BINDEX);
  if(flag!=0) {
    ffd_log("vel_step(): Could not conduct mass conservation correction.",
            FFD_ERROR);
    return flag;
  }

  return flag;
} // End of vel_step( )
예제 #6
0
void CompResAvgSolver3D::vel_step ()
{
  if(m_nbIter > m_nbMaxIter)
    if(m_omegaDiff < 1.9)
      {
	char file[100];
	m_omegaDiff += 0.1;
	m_omegaProj += 0.1;
	sprintf(file, "logs/%2.1f/residualsAverage.log", m_omegaDiff);
	cout << "Processing " << file << endl;
	m_file.open (file, ios::out | ios::trunc);
	if (!m_file.is_open ())
	  cerr << "Can't open file " << file << endl;

	m_nbIter = 0;
	m_perturbateCount = 0;
      }
    else
      return;

  add_source (m_u, m_uSrc);
  add_source (m_v, m_vSrc);
  add_source (m_w, m_wSrc);
  addVorticityConfinement(m_u,m_v,m_w);
  SWAP (m_uPrev, m_u);
  diffuse (1, m_u, m_uPrev, m_aVisc);
  SWAP (m_vPrev, m_v);
  diffuse (2, m_v, m_vPrev, m_aVisc);
  SWAP (m_wPrev, m_w);
  diffuse (3, m_w, m_wPrev, m_aVisc);

  m_index = NB_DIFF_LOGS;
  project (m_uPrev, m_vPrev);
  SWAP (m_uPrev, m_u);
  SWAP (m_vPrev, m_v);
  SWAP (m_wPrev, m_w);
  advect (1, m_u, m_uPrev, m_uPrev, m_vPrev, m_wPrev);
  advect (2, m_v, m_vPrev, m_uPrev, m_vPrev, m_wPrev);
  advect (3, m_w, m_wPrev, m_uPrev, m_vPrev, m_wPrev);

  m_index = NB_DIFF_LOGS+1;
  project (m_uPrev, m_vPrev);

  if(m_nbIter == m_nbMaxIter){
    for(uint i=0; i <= m_nbSteps; i++){
      m_file << i << " ";

      for(uint j=0; j < (NB_PROJ_LOGS+NB_DIFF_LOGS) ; j++)
	m_file << m_averages[j*(m_nbSteps+1) + i] << " ";

      m_file << endl;
    }
    cout << "Simulation over" << endl;
    m_file.close ();
  }
}
예제 #7
0
파일: sim.cpp 프로젝트: hero007feng/ICG2016
void vel_step(int width, int height, float *u, float *v, float *u0, float *v0, float visc, float dt)
{
    add_source(width, height, u, u0, dt); add_source(width, height, v, v0, dt);
    SWAP(u0, u); diffuse(width, height, 1, u, u0, visc, dt);
    SWAP(v0, v); diffuse(width, height, 2, v, v0, visc, dt);
    project(width, height, u, v, u0, v0);
    SWAP(u0, u); SWAP(v0, v);
    advect(width, height, 1, u, u0, u0, v0, dt); advect(width, height, 2, v, v0, u0, v0, dt);
    project(width, height, u, v, u0, v0);
}
예제 #8
0
void update_velocity(gaszone_type *gz, float * u, float * v, float * u0, float * v0,  float visc, float dt ) {
	add_source (gz, u, u0, dt );
	add_source (gz, v, v0, dt );
	SWAP ( u0, u ); diffuse (gz, 1, u, u0, visc, dt );
	SWAP ( v0, v ); diffuse (gz, 2, v, v0, visc, dt );
	project (gz, u, v, u0, v0 );
	SWAP ( u0, u ); SWAP ( v0, v );
	advect (gz, 1, u, u0, u0, v0, dt ); advect (gz, 2, v, v0, u0, v0, dt );
	project (gz, u, v, u0, v0 );
}
예제 #9
0
파일: main.cpp 프로젝트: AMouri/Rouge
void update_velocity( float * u, float * v, float * u0, float * v0,  float visc, float dt ) { 
	add_source ( u, u0, dt ); 
	add_source ( v, v0, dt ); 
	SWAP ( u0, u ); diffuse ( 1, u, u0, visc, dt ); 
	SWAP ( v0, v ); diffuse ( 2, v, v0, visc, dt ); 
	project ( u, v, u0, v0 ); 
	SWAP ( u0, u ); SWAP ( v0, v ); 
	advect ( 1, u, u0, u0, v0, dt ); advect ( 2, v, v0, u0, v0, dt ); 
	project ( u, v, u0, v0 ); 
} 
예제 #10
0
///////////////////////////////////////////////////////////////////////////////
/// Calculate the contaminant concentration
///
///\param para Pointer to FFD parameters
///\param var Pointer to FFD simulation variables
///\param BINDEX Pointer to boundary index
///
///\return 0 if no error occurred
/////////////////////////////////////////////////////////////////////////////// 
int den_step(PARA_DATA *para, REAL **var, int **BINDEX) {
  REAL *den, *den0 = var[TMP1];
  int i, flag = 0;

  /****************************************************************************
  | Solve the species
  ****************************************************************************/
  for(i=0; i<para->bc->nb_Xi; i++) {
    if(para->outp->version==DEBUG) {
      sprintf(msg, "den_step(): start to solve Xi%d", i+1);
      ffd_log(msg, FFD_NORMAL);
    }
    den = var[Xi1+i];
    flag = advect(para, var, Xi1+i, i, den0, den, BINDEX);
    if(flag!=0) {
      sprintf(msg, "den_step(): Could not advect species %d", i+1);
      ffd_log(msg, FFD_ERROR);
      return flag;
    }

    flag = diffusion(para, var, Xi1+i, i, den, den0, BINDEX);
    if(flag!=0) {
      sprintf(msg, "den_step(): Could not diffuse species %d", i+1);
      ffd_log(msg, FFD_ERROR);
      return flag;
    }
  }

  /****************************************************************************
  | Solve the trace substances
  ****************************************************************************/
  for(i=0; i<para->bc->nb_C; i++) {
    if(para->outp->version==DEBUG) {
      sprintf(msg, "den_step(): start to solve C%d", i+1);
      ffd_log(msg, FFD_NORMAL);
    }
    den = var[C1+i];
    flag = advect(para, var, Xi1, i, den0, den, BINDEX);
    if(flag!=0) {
      sprintf(msg, "den_step(): Could not advect trace substance %d", i+1);
      ffd_log(msg, FFD_ERROR);
      return flag;
    }

    flag = diffusion(para, var, Xi1, i, den, den0, BINDEX);
    if(flag!=0) {
      sprintf(msg, "den_step(): Could not diffuse trace substance %d", i+1);
      ffd_log(msg, FFD_ERROR);
      return flag;
    }
  }

  return flag;
} // End of den_step( )
예제 #11
0
void ShallowWater::computeOneStep() {

	Array2D<float> tempvX;
	Array2D<float> tempvY;

	m_n = advect(m_n);
	tempvX = advect(m_vX);
	tempvY = advect(m_vY);
	m_vX = tempvX; 
	m_vY = tempvY;
	updateHeight();
	plus(m_n, m_g, m_h);
	updateVelocities();
	reflectingBoundaries();
}
예제 #12
0
void FluidField::velocityStep (float * u, float * v, float * u0, float * v0, float visc, float dt )
{
	add_source (u,u0, dt );
	add_source (v,v0, dt );
	
	SWAP ( u0, u ); 
	diffuse (  1, u, u0, visc, dt );
	
	SWAP ( v0, v ); 
	diffuse (  2, v, v0, visc, dt );
	project (  u, v, u0, v0 );
	SWAP ( u0, u ); SWAP ( v0, v );
	advect (  1, u, u0, u0, v0, dt );
	advect (  2, v, v0, u0, v0, dt );
	project (  u, v, u0, v0 );
}
//The main fluid simulation step
void FluidSim::advance(float dt) {
   float t = 0;
   
   while(t < dt) {
      float substep = cfl();   
      if(t + substep > dt)
         substep = dt - t;
   
      //Passively advect particles
      advect_particles(substep);
     
      //Estimate the liquid signed distance
      compute_phi();

      //Advance the velocity
      advect(substep);
      add_force(substep);

      apply_viscosity(substep);

      apply_projection(substep); 
      
      //Pressure projection only produces valid velocities in faces with non-zero associated face area.
      //Because the advection step may interpolate from these invalid faces, 
      //we must extrapolate velocities from the fluid domain into these zero-area faces.
      extrapolate(u, u_valid);
      extrapolate(v, v_valid);

      //For extrapolated velocities, replace the normal component with
      //that of the object.
      constrain_velocity();
   
      t+=substep;
   }
}
예제 #14
0
파일: sim.cpp 프로젝트: mtao/MSc
void MACStableFluids::step(Scalar dt)
{
    float t=0;
    int count=0;
    while(t<dt)
    {
        float substep=cfl();

        if(substep<0.000001)
        {
            std::cerr << "SUBSTEP GOING TOO LOW QUITTING\n";
            return;
        }
        if(t+substep > dt)
            substep=dt-t;


        add_force(dt);
        advect(dt);
        diffuse(dt);
        project(dt);
        advect_particles(dt);
        ++count;
        t+=substep;
    }
    time += dt;


}
예제 #15
0
/***************************************************************
 * Solves the navier stokes equations for velocity...
 * i.e. satisfies: ∂u/∂t = -(div u)u + v Lap u + f
 ***************************************************************/
void FGS_Fluid_Solver2DS :: velocity_step(){
    
    // Add forces from the old grid (+f)
    add_source(UX, OLD_UX);
    add_source(UY, OLD_UY);
    
    // Compute diffusion of cells' velocities based on viscosity
    diffuse   (SET_FOR_HORIZONTAL_COMPONENT, OLD_UX, UX, viscosity);
    diffuse   (SET_FOR_VERTICAL_COMPONENT,   OLD_UY, UY, viscosity);
    
    // Compute the pressure so that the divergence in U = 0
    project   (OLD_UX, OLD_UY, UX, UY);
    advect    (SET_FOR_HORIZONTAL_COMPONENT, UX, OLD_UX, OLD_UX, OLD_UY);
    advect    (SET_FOR_VERTICAL_COMPONENT,   UY, OLD_UY, OLD_UX, OLD_UY);
    project   (UX, UY, OLD_UX, OLD_UY);
}
예제 #16
0
void SWSolver::advanceTimestep(){
		//std::cout << "advecting eta..." << std::endl;
		advect(ETA);
		//std::cout << "advecting velocity_x..." << std::endl;
		advect(VELOCITY_X);
		//std::cout << "advecting velocity_y..." << std::endl;
		advect(VELOCITY_Y);

		//std::cout << "updating heights..." << std::endl;
		updateHeight();

		//std::cout << "updating velocities..." << std::endl;
		updateVelocity();

		//std::cout << "setting boundaries..." << std::endl;
		setBoundary();
}
예제 #17
0
//-----------------------------------------------------------------------------
void StamFluidSolver::texture_step ( float * x, float * x0, float * u, float * v, float diff, float dt )
{
    //addSource ( N, x, x0, dt );
    SWAP ( x0, x );
    diffuse ( 0, x, x0, diff, dt );
    SWAP ( x0, x );
    advect ( 0, x, x0, u, v, dt );
}
예제 #18
0
void FluidSimulator::simulateAndDraw(){

	advect(0.01);
	project();
	

	draw();
}
예제 #19
0
void FluidField::densityStep (float * x, float * x0, float * u, float * v, float diff, float dt )
{
	add_source (  x, x0, dt );
	SWAP ( x0, x ); 
	diffuse (  0, x, x0, diff, dt );
	SWAP ( x0, x ); 
	advect (  0, x, x0, u, v, dt );
}
예제 #20
0
//-----------------------------------------------------------------------------
void StamFluidSolver::dens_step ( float * x, float * x0, float * u, float * v, float diff, float dt )
{
    addSource ( x, x0, dt );
    SWAP ( x0, x );
    diffuse ( 0, x, x0, diff, dt );
    SWAP ( x0, x );
    advect ( 0, x, x0, u, v, dt );
}
예제 #21
0
void advect(float dt, Field2f &u, Field2f &x0, Field2f &x1)
{
	for (int y = 1; y < GRID_RES - 1; ++y)
	{
		for (int x = 1; x < GRID_RES  - 1; ++x)
		{
			advect(x, y, dt, u, x0, x1);
		}
	}
}
예제 #22
0
void Smoke::densityStep()
{
	addSource( d, dOld );

    swap( dOld, d );
	diffuse( 0, d, dOld, diff );
    
	swap( dOld, d );
	advect( 0, d, dOld, u, v );
}
예제 #23
0
파일: fluid.cpp 프로젝트: wenderen/btp
void Fluid::dens_step(float dt)
{
	add_source(sd, d, dt);
#ifdef DIFFUSE
	SWAPFPTR(d0, d);
	diffuse(0, d0, d, diffusion, dt);
#endif
#ifdef ADVECT
	SWAPFPTR(d0, d);
	advect(0, d0, d, u, v, w, dt);
#endif
}
void FluidSystem::stepDensity(Scalar dt, const DyeField &addedDensity) {
    density += addedDensity * dt;
    std::array<BoundarySetter, density.coords> boundarySetters;
    for (std::size_t i = 0; i < density.coords; ++i) {
        boundarySetters[i] = std::bind(&setContinuityBoundaries, std::placeholders::_1, dim);
    }

    std::swap(density, densityPrev);
    diffuse(density, densityPrev, diffusionConstant, dt, dim, boundarySetters);
    std::swap(density, densityPrev);
    advect(density, densityPrev, velocity, dt, dim, boundarySetters);
}
예제 #25
0
void Smoke::velocityStep()
{
	addSource( u, uOld ); 
	addSource( v, vOld );

    buoyancy(vOld);
    addSource( v, vOld );
    
	swap( uOld, u ); 
	diffuse( 1, u, uOld, visc );   
    swap( vOld, v ); 
	diffuse( 2, v, vOld, visc );   
    
	project( uOld, vOld );   
    swap( uOld, u ); 
	swap( vOld, v );

    advect( 1, u, uOld, uOld, vOld ); 
	advect( 2, v, vOld, uOld, vOld );   
    project( uOld, vOld ); 
}
예제 #26
0
파일: smoke.c 프로젝트: anarsoul/weston
static void
redraw_handler(struct widget *widget, void *data)
{
	struct smoke *smoke = data;
	uint32_t time = smoke->time;
	struct wl_callback *callback;
	cairo_surface_t *surface;

	diffuse(smoke, time / 30, smoke->b[0].u, smoke->b[1].u);
	diffuse(smoke, time / 30, smoke->b[0].v, smoke->b[1].v);
	project(smoke, time / 30,
		smoke->b[1].u, smoke->b[1].v,
		smoke->b[0].u, smoke->b[0].v);
	advect(smoke, time / 30,
	       smoke->b[1].u, smoke->b[1].v,
	       smoke->b[1].u, smoke->b[0].u);
	advect(smoke, time / 30,
	       smoke->b[1].u, smoke->b[1].v,
	       smoke->b[1].v, smoke->b[0].v);
	project(smoke, time / 30,
		smoke->b[0].u, smoke->b[0].v,
		smoke->b[1].u, smoke->b[1].v);

	diffuse(smoke, time / 30, smoke->b[0].d, smoke->b[1].d);
	advect(smoke, time / 30,
	       smoke->b[0].u, smoke->b[0].v,
	       smoke->b[1].d, smoke->b[0].d);

	surface = window_get_surface(smoke->window);

	render(smoke, surface);

	window_damage(smoke->window, 0, 0, smoke->width, smoke->height);

	cairo_surface_destroy(surface);

	callback = wl_surface_frame(window_get_wl_surface(smoke->window));
	wl_callback_add_listener(callback, &listener, smoke);
	wl_surface_commit(window_get_wl_surface(smoke->window));
}
예제 #27
0
void ciMsaFluidSolver::update() {
	addSourceUV();
	
	if( doVorticityConfinement )
	{
		vorticityConfinement(uvOld);
		addSourceUV();
	}
	
	swapUV();
	
	diffuseUV( viscocity );
	
	project(uv, uvOld);
	
	swapUV();
	
	advect2d(uv, uvOld);
	
	project(uv, uvOld);
	
	if(doRGB)
	{
		addSourceRGB();
		swapRGB();
		
		if( colorDiffusion!=0. && _dt!=0. )
		{
			diffuseRGB(0, colorDiffusion );
			swapRGB();
		}
		
		advectRGB(0, uv);
		fadeRGB();
	} 
	else
	{
		addSource(r, rOld);
		swapR();
		
		if( colorDiffusion!=0. && _dt!=0. )
		{
			diffuse(0, r, rOld, colorDiffusion );
			swapRGB();
		}
		
		advect(0, r, rOld, uv);	
		fadeR();
	}
}
예제 #28
0
파일: fluid.cpp 프로젝트: wenderen/btp
void Fluid::vel_step(float dt)
{
	add_source(su, u, dt);
	add_source(sv, v, dt);
	add_source(sw, w, dt);
	add_buoyancy(dt);
	vorticity_confinement(dt);

#ifdef DIFFUSE
	SWAPFPTR(u0, u); SWAPFPTR(v0, v); SWAPFPTR(w0, w);
	diffuse(1, u0, u, viscosity, dt);
	diffuse(2, v0, v, viscosity, dt);
	diffuse(3, w0, w, viscosity, dt);
	project();
#endif
#ifdef ADVECT
	SWAPFPTR(u0, u); SWAPFPTR(v0, v); SWAPFPTR(w0, w);
	advect(1, u0, u, u0, v0, w0, dt);
	advect(2, v0, v, u0, v0, w0, dt);
	advect(3, w0, w, u0, v0, w0, dt);
	project();
#endif
}
예제 #29
0
/***************************************************************
 * Solves the navier stokes equations for density..
 * i.e. satisfies: ∂d/∂t = -(div u)d + k Lap d + S
 ***************************************************************/
void FGS_Fluid_Solver2DS :: density_step(){
    
    // Add density sources from the old grid (+S)
    add_source(DENSITY, OLD_DENSITY);
    
    // Compute diffusion of cells' densities into neighbours
    // If diffusion > 0 then densities will diffuse (+ k Lap d)
    diffuse   (SET_FOR_NON_VELOCITY_COMPONENT, OLD_DENSITY, DENSITY,     diffusion);
    
    // Advect the densities based on the velocities in the cell (-(div u)d)
    computing_density = true;
    advect    (SET_FOR_NON_VELOCITY_COMPONENT, DENSITY,     OLD_DENSITY, UX, UY);
    computing_density = false;
}
예제 #30
0
파일: smoke.c 프로젝트: Holusion/weston
static void
redraw_handler(struct widget *widget, void *data)
{
	struct smoke *smoke = data;
	uint32_t time = widget_get_last_time(smoke->widget);
	cairo_surface_t *surface;

	diffuse(smoke, time / 30, smoke->b[0].u, smoke->b[1].u);
	diffuse(smoke, time / 30, smoke->b[0].v, smoke->b[1].v);
	project(smoke, time / 30,
		smoke->b[1].u, smoke->b[1].v,
		smoke->b[0].u, smoke->b[0].v);
	advect(smoke, time / 30,
	       smoke->b[1].u, smoke->b[1].v,
	       smoke->b[1].u, smoke->b[0].u);
	advect(smoke, time / 30,
	       smoke->b[1].u, smoke->b[1].v,
	       smoke->b[1].v, smoke->b[0].v);
	project(smoke, time / 30,
		smoke->b[0].u, smoke->b[0].v,
		smoke->b[1].u, smoke->b[1].v);

	diffuse(smoke, time / 30, smoke->b[0].d, smoke->b[1].d);
	advect(smoke, time / 30,
	       smoke->b[0].u, smoke->b[0].v,
	       smoke->b[1].d, smoke->b[0].d);

	surface = window_get_surface(smoke->window);

	render(smoke, surface);

	window_damage(smoke->window, 0, 0, smoke->width, smoke->height);

	cairo_surface_destroy(surface);

	widget_schedule_redraw(smoke->widget);
}