예제 #1
0
void getufromG(double *h, double *G, double u0, double u1, double h0, double h1, double dx , int n, double *u)
{
    double idx = 1.0 / dx;
    double ithree = 1.0 / 3.0;
    double *a = malloc((n-1)*sizeof(double));
    double *b = malloc(n*sizeof(double));
    double *c = malloc((n-1)*sizeof(double));

    int i;
    double thx;


    for (i =1;i < n-1 ; i++)
    {
        thx = 0.5*idx*(h[i+1] - h[i-1]);
        
        a[i-1] = -ithree*idx*idx*h[i]*h[i]*h[i] + 0.5*idx*h[i]*h[i]*thx;
        b[i] = h[i] + 2.0*ithree*idx*idx*h[i]*h[i]*h[i];
        c[i] = -ithree*idx*idx*h[i]*h[i]*h[i] - 0.5*idx*h[i]*h[i]*thx;

    }

    //Boundaries
    i = 0;

    thx = 0.5*idx*(h[i+1] - h0);
        
    //a[i-1] = -ithree*idx*idx*h[i]*h[i]*h[i] + 0.5*idx*th*th*thx
    b[i] = h[i] + 2.0*ithree*idx*idx*h[i]*h[i]*h[i];
    c[i] = -ithree*idx*idx*h[i]*h[i]*h[i] - 0.5*idx*h[i]*h[i]*thx;

    double tmpG1 = G[i];

    G[i] = tmpG1 - u0*(-ithree*idx*idx*h[i]*h[i]*h[i] + 0.5*idx*h[i]*h[i]*thx);

    i = n-1;

    thx = 0.5*idx*(h1 - h[i-1]);
        
    a[i-1] = -ithree*idx*idx*h[i]*h[i]*h[i] + 0.5*idx*h[i]*h[i]*thx;
    b[i] = h[i] + 2.0*ithree*idx*idx*h[i]*h[i]*h[i];
    //c[i] = -ithree*idx*idx*h[i]*h[i]*h[i] - 0.5*idx*h[i]*h[i]*thx;

    double tmpG2 = G[i];
    G[i] = tmpG2 - u1*(-ithree*idx*idx*h[i]*h[i]*h[i] - 0.5*idx*h[i]*h[i]*thx);

    TDMA(a,b,c,G,n,u);

    G[0] = tmpG1;
    G[n-1] = tmpG2;


    free(a);
    free(b);
    free(c);

}
예제 #2
0
파일: matrix.cpp 프로젝트: lrm29/simpleCFD
void simpleCFD::matrix::solve()
{

    for (unsigned int i=1; i<=Grid_.nCells(); ++i) {
        a_p[i] += a_w[i]+a_e[i];
    }

    TDMA();

}
예제 #3
0
void evolveu(double *h, double *u, double *fh, double *ph, double *pu, double g, double dx, double dt, int nBC, int n,double *fu)
{
    //modifies nh and nG to give the new values of h and G after a single time step
    double idx = 1.0 / dx;
    double *a = malloc((n-1)*sizeof(double));
    double *b = malloc(n*sizeof(double));
    double *c = malloc((n-1)*sizeof(double));
    double *f = malloc(n*sizeof(double));

    int i,j;
    double nu,nh,nux,nuxx,nuxxx,nhx,pux,puxx,F,S;


    for (i =1;i < n-1 ; i++)
    {
        //i for tridiagonals, j for the BC u,h vectors 
        j = i + nBC;
        nhx = 0.5*idx*(h[j+1] - h[j-1]);
        
        a[i-1] = 0.5*idx*h[j]*h[j]*nhx - i3*idx*idx*h[j]*h[j]*h[j];
        b[i] = fh[j] + 2*i3*idx*idx*h[j]*h[j]*h[j];
        c[i] = -0.5*idx*h[j]*h[j]*nhx - i3*idx*idx*h[j]*h[j]*h[j];

        nu = u[j];
        nh = h[j];
        nux = 0.5*idx*(u[j+1] - u[j-1]);
        nuxx = idx*idx*(u[j+1] - 2*u[j] + u[j-1]);
        nuxxx = 0.5*idx*idx*idx*(u[j+2] - 2*u[j+1]  + 2*u[j-1] - u[j-2]);
        pux = 0.5*idx*(pu[j+1] - pu[j-1]);
        puxx = idx*idx*(pu[j+1] - 2*pu[j] + pu[j-1]);
        F = 2*nu*nh*nux + nu*nu*nhx + g*nh*nhx + nh*nh*nhx*nux*nux + i3*nh*nh*nh*nux*nuxx 
            - nh*nh*nhx*nu*nuxx -i3*nh*nh*nh*nu*nuxxx;

        S = 2*dt*F - pu[j]*ph[j] + nh*nh*nhx*pux + i3*nh*nh*nh*puxx;
        f[i] = -S;

    }

    //Boundaries
    i = 0;
    j = i + nBC;

    //a[i-1] = 0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j];
    b[i] = fh[j] + 2*i3*idx*idx*h[j]*h[j]*h[j];
    c[i] = -0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j];

    nu = u[j];
    nh = h[j];
    nux = 0.5*idx*(u[j+1] - u[j-1]);
    nuxx = idx*idx*(u[j+1] - 2*u[j] + u[j-1]);
    nuxxx = 0.5*idx*idx*idx*(u[j+2] - 2*u[j+1]  + 2*u[j-1] - u[j-2]);
    nhx = 0.5*idx*(h[j+1] - h[j-1]);
    pux = 0.5*idx*(pu[j+1] - pu[j-1]);
    puxx = idx*idx*(pu[j+1] - 2*pu[j] + pu[j-1]);
    F = 2*nu*nh*nux + nu*nu*nhx + g*nh*nhx + nh*nh*nux*nux + i3*nh*nh*nh*nux*nuxx - nh*nh*nu*nuxx 
            -i3*nh*nh*nh*nu*nuxxx;

    S = 2*dt*F - pu[j]*ph[j] + nh*nh*pux + i3*nh*nh*nh*puxx;
    f[i] = -S - u[j-1]*(0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j]);

    i = n-1;
    j = i + nBC;

    a[i-1] = 0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j];
    b[i] = fh[j] + 2*i3*idx*idx*h[j]*h[j]*h[j];
    //c[i] = -0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j];

    nu = u[j];
    nh = h[j];
    nux = 0.5*idx*(u[j+1] - u[j-1]);
    nuxx = idx*idx*(u[j+1] - 2*u[j] + u[j-1]);
    nuxxx = 0.5*idx*idx*idx*(u[j+2] - 2*u[j+1]  + 2*u[j-1] - u[j-2]);
    nhx = 0.5*idx*(h[j+1] - h[j-1]);
    pux = 0.5*idx*(pu[j+1] - pu[j-1]);
    puxx = idx*idx*(pu[j+1] - 2*pu[j] + pu[j-1]);
    F = 2*nu*nh*nux + nu*nu*nhx + g*nh*nhx + nh*nh*nux*nux + i3*nh*nh*nh*nux*nuxx - nh*nh*nu*nuxx 
            -i3*nh*nh*nh*nu*nuxxx;

    S = 2*dt*F - pu[j]*ph[j] + nh*nh*pux + i3*nh*nh*nh*puxx;
    f[i] = -S - u[j+1]*(-0.5*idx*h[j]*h[j] - i3*idx*idx*h[j]*h[j]*h[j]);

    TDMA(a,b,c,f,n,fu);

    free(a);
    free(b);
    free(c); 
    free(f);  
   
}
예제 #4
0
void getufromG(double *h, double *G,double *bed, double u0, double u1, double h0, double h1, double b0, double b1,double dx, int n,double *ublank)
{
	double idx = 1.0 / dx;
	double *a = malloc((n-1)*sizeof(double));
	double *b = malloc(n*sizeof(double));
	double *c = malloc((n-1)*sizeof(double));

	double th,thx,tbx,tbxx,D,ai,bi,ci;
	int i;
	for(i = 1; i < n-1; i++)
	{
		th = h[i];
		thx = 0.5*idx*(h[i+1] - h[i-1]);
		tbx = 0.5*idx*(bed[i+1] - bed[i-1]);
		tbxx = idx*idx*(bed[i+1] -2*bed[i]+ bed[i-1]);

		D = th + th*th*tbx + 0.5*th*th*tbxx + th*tbx*tbx;
		
		ai = -i3*idx*idx*th*th*th + 0.5*idx*th*th*thx;
		bi = D + 2.0*i3*idx*idx*th*th*th;
		ci = -i3*idx*idx*th*th*th - 0.5*idx*th*th*thx;

		a[i-1] = ai;
		b[i] = bi;
		c[i] = ci;
	}

	//Boundary 
	//i = 0
	i = 0;
	th = h[i];
	thx = 0.5*idx*(h[i+1] - h0);
	tbx = 0.5*idx*(bed[i+1] - b0);
	tbxx = idx*idx*(bed[i+1] -2*bed[i]+ b0);

	D = th + th*th*tbx + 0.5*th*th*tbxx + th*tbx*tbx;
	
	ai = -i3*idx*idx*th*th*th + 0.5*idx*th*th*thx;
	bi = D + 2.0*i3*idx*idx*th*th*th;
	ci = -i3*idx*idx*th*th*th - 0.5*idx*th*th*thx;

	b[i] = bi;
	c[i] = ci;	

	double tmpG1 = G[i];
	G[i] = tmpG1 - u0*ai;

	i = n-1;
	
	th = h[i];
	thx = 0.5*idx*(h1- h[i-1]);
	tbx = 0.5*idx*(b1 - bed[i-1]);
	tbxx = idx*idx*(b1 -2*bed[i]+ bed[i-1]);

	D = th + th*th*tbx + 0.5*th*th*tbxx + th*tbx*tbx;
	
	ai = -i3*idx*idx*th*th*th + 0.5*idx*th*th*thx;
	bi = D + 2.0*i3*idx*idx*th*th*th;
	ci = -i3*idx*idx*th*th*th - 0.5*idx*th*th*thx;

	a[i-1] = ai;
	b[i] = bi;	

	double tmpG2 = G[i];
	G[i] = tmpG2 - u1*ci;

	TDMA(a,b,c,G,n,ublank);
	
	G[0] = tmpG1;
	G[n-1] = tmpG2;


    free(a);
    free(b);
    free(c);
}