naive_propagation.cpp File Reference

#include <algorithm>
#include "naive_propagation.h"

Include dependency graph for naive_propagation.cpp:

Go to the source code of this file.

Functions
void	grayscott_propagation (float *outMatU, float *outMatV, const float *matU, const float *matV, long nbRow, long nbCol, const float *matDeltaSquare, long nbStencilRow, long nbStencilCol, float diffudionRateU, float diffusionRateV, float feedRate, float killRate, float dt)
	Propagate the U and V species in the matU and matV. More...

Function Documentation

grayscott_propagation()

void grayscott_propagation	(	float *	outMatU,
		float *	outMatV,
		const float *	matU,
		const float *	matV,
		long	nbRow,
		long	nbCol,
		const float *	matDeltaSquare,
		long	nbStencilRow,
		long	nbStencilCol,
		float	diffudionRateU,
		float	diffusionRateV,
		float	feedRate,
		float	killRate,
		float	dt
	)

Propagate the U and V species in the matU and matV.

Parameters

[out]	outMatU	: updated matrix U version
[out]	outMatV	: updated matrix V version
	matU	: input of matrix U
	matV	: input of matrix V
	nbRow	: number of rows of the matrices
	nbCol	: number of columns of the matrices
	matDeltaSquare	: matrix of the delta square values
	nbStencilRow	: number of rows of the matrix matDeltaSquare
	nbStencilCol	: number of columns of the matrix matDeltaSquare
	diffudionRateU	: diffusion rate of the U specie
	diffudionRateV	: diffusion rate of the V specie
	feedRate	: rate of the process which feeds U and drains U, V and P
	killRate	: rate of the process which converts V into P
	dt	: time interval between two steps

Definition at line 35 of file naive_propagation.cpp.

{
/*{
Nous déterminons les \textbf{offset} de notre \textbf{stencil} (le nombre de couches à partir de la cellule centrale) :
}*/
        long offsetStencilRow((nbStencilRow - 1l)/2l);
        long offsetStencilCol((nbStencilCol - 1l)/2l);
/*{
Nous bouclons sur les lignes et les colonnes de nos matrices pour mettre à jour toutes nos cellules :
}*/
        for(long i(0l); i < nbRow; ++i){
                for(long j(0l); j < nbCol; ++j){
/*{
Il faut maintenant déterminer les bornes de nos calculs (voir section \ref{secNaiveImplStencil}) :
}*/
                        long firstRowStencil(std::max(i - offsetStencilRow, 0l));
                        long firstColStencil(std::max(j - offsetStencilCol, 0l));
                        
                        long lastRowStencil(std::min(i + offsetStencilRow + 1l, nbRow));
                        long lastColStencil(std::min(j + offsetStencilCol + 1l, nbCol));
/*{
Définissons quelques variables temporaires :
}*/
                        long stencilIndexRow(0l);
                        float u(matU[i*nbCol + j]), v(matV[i*nbCol + j]);
                        float fullU(0.0f), fullV(0.0f);
/*{
Nous devons maintenant boucler sur les lignes et les colonnes de notre \textbf{stencil} :
}*/
                        for(long k(firstRowStencil); k < lastRowStencil; ++k){
                                long stencilIndexCol(0l);
                                for(long l(firstColStencil); l < lastColStencil; ++l){
/*{
Nous pouvons enfin calculer notre gradient :
}*/
                                        float deltaSquare(matDeltaSquare[stencilIndexRow*nbStencilCol + stencilIndexCol]);
                                        fullU += (matU[k*nbCol + l] - u)*deltaSquare;
                                        fullV += (matV[k*nbCol + l] - v)*deltaSquare;
/*{
Il ne faut pas oublier d'incrémenter les indices qui nous permettent de parcourir la matrice \textbf{matDeltaSquare] :
}*/
                                        ++stencilIndexCol;
                                }
                                ++stencilIndexRow;
                        }
/*{
On finalise le calcul :
}*/
                        float uvSquare(u*v*v);
                        float du(diffudionRateU*fullU - uvSquare + feedRate*(1.0f - u));
                        float dv(diffusionRateV*fullV + uvSquare - (feedRate + killRate)*v);
/*{
Et on sauvegarde le résultat :
}*/
                        outMatU[i*nbCol + j] = u + du*dt;
                        outMatV[i*nbCol + j] = v + dv*dt;
/*{
Fin des deux boucles sur les lignes et les colonnes :
}*/
                }
        }
/*{
Fin de la fonction :
}*/
}