void computeRHSk(GRID *g,SOLN *s,double *l2rho, double*linfrho, int myid)
{
//
int i,j,k,m,f,n;
int f1,f2;
int is,ie;
int iface;
int idv;
int chainSize;
int itype;
int imode=1;
double ds[3];
double leftState[NVAR];
double rightState[NVAR];
double leftState0[NVAR];
double rightState0[NVAR];
double lmat[NVAR][NVAR];
double rmat[NVAR][NVAR];
double consVar[NVAR];
double flux[NVAR];
double gm1=gamm-1.0;
double gamma1=gamm;
double specRadius;
double faceVel=0.;
double dsnorm,nynx,nx2ny;
int node1,node2,node3,node4,leftCell,rightCell,icell;
double x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4;
double xa,ya,za,xb,yb,zb;
double pp;
double th,qt,eps;
double ref[3][3];
int iflag,nbase;
int n1,n2,n3,n4,n5,n6,n7,n8;
double xc,yc,zc;
int iface1,iface2,rightCell1,rightCell2,c1,c2,c3;
int nghost,order,ierr;
order = g->order;
nghost = 2;
if(order==5) nghost = 3;
nbase = (g->nfaces-(g->ncells)/(g->nstrand-1)*g->nstrand)/(g->nstrand-1);
//
// zero out residual and spectral radii
//
for(i=0;i<NVAR*g->ncells;i++) s->r[i]=0.0;
for(i=0;i<g->ncells;i++) s->sigma[i]=0.0;
//
// one loop per chain to evaluate fluxes
// on all the faces in the chain
//
for(i=0;i<g->nchains;i++)
{
iflag=0;
f1=g->faceStartPerChain[i];
f2=g->faceStartPerChain[i+1];
m=nghost;
for(f=f1;f<f2;f++)
{
iface=g->chainConn[f];
g->cindx[m]=g->faces[8*iface+4];
g->ctype[m]=1;
m++;
}
//
// add buffer cells to the chain
//
if (g->chainConn[f1]==g->chainConn[f2-1])
{
iflag = 0;
//
// this is a closed chain
// make it periodic
//
f = f1+1;
iface = g->chainConn[f];
g->cindx[m] = g->faces[8*iface+4];
g->ctype[m] = 1;
m++;
chainSize = m;
m=0;
for(f=f2-nghost-1;f<f2-1;f++)
{
iface=g->chainConn[f];
g->cindx[m]=g->faces[8*iface+4];
g->ctype[m]=1;
m++;
}
}
else
{
iflag=1;
//
// this is a open chain
// -ve index indicates necessity to create
// ghost cells
//
//solid bc
if(g->test!=1)
{
if(order==5)
{
m--;
g->cindx[m] = -g->cindx[m];
g->ctype[m] = -1;
m++;
g->cindx[m] = -g->cindx[m-3];
g->ctype[m] = -1;
m++;
g->cindx[m] = -g->cindx[m-5];
g->ctype[m] = -1;
chainSize = m+1;
m = 0;
g->cindx[m] = -g->cindx[m+5];
g->ctype[m] = -1;
m = 1;
g->cindx[m] = -g->cindx[m+3];
g->ctype[m] = -1;
m = 2;
g->cindx[m] = -g->cindx[m+1];
g->ctype[m] = -1;
}
else
{
m--;
g->cindx[m]=-g->cindx[m];
g->ctype[m]=-1;
m++;
g->cindx[m]=-g->cindx[m-3];
g->ctype[m]=-1;
chainSize=m+1;
m=0;
g->cindx[m]=-g->cindx[m+3];
g->ctype[m]=-1;
m=1;
g->cindx[m]=-g->cindx[m+1];
g->ctype[m]=-1;
}
//=========================
//add for parallization
//========================
iface1 = g->chainConn[f1];
iface2 = g->chainConn[f2-1];
rightCell1 = g->faces[8*iface1+6];
rightCell2 = g->faces[8*iface2+6];
if(rightCell1 == -5)
{
if(order==5)
{
c3 = g->cindx[5];
c2 = g->cindx[4];
c1 = g->cindx[3];
g->cindx[0] = -1*(c2);
g->cindx[1] = -1*(c2);
g->cindx[2] = -1*(c2);
}
else
{
c2 = g->cindx[3];
c1 = g->cindx[2];
g->cindx[0] = -1*(c2);
g->cindx[1] = -1*(c2);
}
}
if(rightCell2 == -5)
{
if(order==5)
{
c3 = g->cindx[chainSize-6];
c2 = g->cindx[chainSize-5];
c1 = g->cindx[chainSize-4];
g->cindx[chainSize-1] = -1*(c2);
g->cindx[chainSize-2] = -1*(c2);
g->cindx[chainSize-3] = -1*(c2);
}
else
{
c2 = g->cindx[chainSize-4];
c1 = g->cindx[chainSize-3];
g->cindx[chainSize-1] = -1*(c2);
g->cindx[chainSize-2] = -1*(c2);
}
}
// periodic bc at only strand grid
if(g->test==2)
{
iface = g->chainConn[f1];
//strand grid
if(iface>nbase*(g->nstrand-1)-1)
{
if(order==5)
{
m = chainSize-1;
g->cindx[2] = g->cindx[g->nstrand];
g->cindx[1] = g->cindx[g->nstrand-1];
g->cindx[0] = g->cindx[g->nstrand-2];
g->cindx[m-2] = g->cindx[3];
g->cindx[m-1] = g->cindx[4];
g->cindx[m] = g->cindx[5];
g->ctype[2] = 1;
g->ctype[1] = 1;
g->ctype[0] = 1;
g->ctype[m-2] = 1;
g->ctype[m-1] = 1;
g->ctype[m] = 1;
}
else
{
m = chainSize-1;
g->cindx[1] = g->cindx[g->nstrand];
g->cindx[0] = g->cindx[g->nstrand-1];
g->cindx[m-1] = g->cindx[2];
g->cindx[m] = g->cindx[3];
g->ctype[1] = 1;
g->ctype[0] = 1;
g->ctype[m-1] = 1;
g->ctype[m] = 1;
}
}
}
}
//periodic bc
if(g->test==1){
apply_periodic_LHS(&g[0],f1,f2,m);
chainSize=m+1;
if(order==5) chainSize = m+2;
}
}
//end
//============ print for verification===========
// if(iflag==1) //open chain
// {
// printf("i:%d Stopping code\n",i);
// printf("chain size=%d\n",chainSize);
//
// for(k=0;k<=chainSize-1;k++)
// {
// printf("cell index:%d\n",g->cindx[k]);
// }
// exit(1);
// }
//============================================
for(j=0;j<chainSize;j++)
{
icell=g->cindx[j];
itype=g->ctype[j];
if (itype >=0)
{
m=NVAR*icell;
for(k=0;k<NVAR;k++)
{
consVar[k]=s->q[m];
m++;
}
g->f[j][0]=consVar[0];
g->f[j][1]=consVar[1];
g->f[j][2]=consVar[2];
g->f[j][3]=consVar[3];
g->f[j][4]=consVar[4];
}
else //itype <0
{
//
// do ghost cells
// based on whether they are on the solid boundary on that
if (j < nghost)
{
iface=g->chainConn[f1];
}
else
{
iface=g->chainConn[f2-1];
}
rightCell=g->faces[8*iface+6];
if (rightCell==-2) /* this is a face on solid wall */
{
node1=g->faces[8*iface];
node2=g->faces[8*iface+1];
node3=g->faces[8*iface+2];
node4=g->faces[8*iface+3];
x1=g->x[3*node1];
y1=g->x[3*node1+1];
z1=g->x[3*node1+2];
x2=g->x[3*node2];
y2=g->x[3*node2+1];
z2=g->x[3*node2+2];
x3=g->x[3*node3];
y3=g->x[3*node3+1];
z3=g->x[3*node3+2];
x4=g->x[3*node4];
y4=g->x[3*node4+1];
z4=g->x[3*node4+2];
// 3D face normal vector (direction?)
xa = x1 - x3; xb = x2 - x4;
ya = y1 - y3; yb = y2 - y4;
za = z1 - z3; zb = z2 - z4;
ds[0] = 0.5*(za*yb - ya*zb);
ds[1] = 0.5*(xa*zb - za*xb);
ds[2] = 0.5*(ya*xb - xa*yb);
// for check!
if(icell>0){printf("Stopping! negative icell at i: %d\n",i);exit(1);}
icell=-icell;
//printf("icell:%d\n",icell);
//printf("=======\n");
m=NVAR*icell;
for(k=0;k<NVAR;k++)
{
consVar[k]=s->q[m];
m++;
}
dsnorm=ds[0]*ds[0]+ds[1]*ds[1]+ds[2]*ds[2];
//make reflection matrix
ref[0][0] = 1.-2.*ds[0]*ds[0]/dsnorm;
ref[0][1] = -2.*ds[0]*ds[1]/dsnorm;
ref[0][2] = -2.*ds[0]*ds[2]/dsnorm;
ref[1][1] = 1.-2.*ds[1]*ds[1]/dsnorm;
ref[1][0] = -2.*ds[1]*ds[0]/dsnorm;
ref[1][2] = -2.*ds[1]*ds[2]/dsnorm;
ref[2][2] = 1.-2.*ds[2]*ds[2]/dsnorm;
ref[2][0] = -2.*ds[2]*ds[0]/dsnorm;
ref[2][1] = -2.*ds[2]*ds[1]/dsnorm;
// calculate ghost cell conserve variables
g->f[j][0] = consVar[0];
g->f[j][1] = (consVar[1]*ref[0][0]+consVar[2]*ref[0][1]+consVar[3]*ref[0][2]);
g->f[j][2] = (consVar[1]*ref[1][0]+consVar[2]*ref[1][1]+consVar[3]*ref[1][2]);
g->f[j][3] = (consVar[1]*ref[2][0]+consVar[2]*ref[2][1]+consVar[3]*ref[2][2]);
g->f[j][4] = consVar[4];
}
//=========================================================
// add for parallization
//=========================================================
else if(rightCell == -5)
{
icell = -icell; //make positive(second cell index)
if(j==nghost-2 || j==chainSize-(nghost-1))
{
if(g->idup[icell]==2)
{
if(j==nghost-2) c1 = g->cindx[nghost];
if(j==chainSize-(nghost-1)) c1 = g->cindx[chainSize-(nghost+1)];
g->f[j][0] = g->dpsil[c1][0];
g->f[j][1] = g->dpsil[c1][1];
g->f[j][2] = g->dpsil[c1][2];
g->f[j][3] = g->dpsil[c1][3];
g->f[j][4] = g->dpsil[c1][4];
}
else
{
g->f[j][0] = g->psil[icell][0];
g->f[j][1] = g->psil[icell][1];
g->f[j][2] = g->psil[icell][2];
g->f[j][3] = g->psil[icell][3];
g->f[j][4] = g->psil[icell][4];
}
}
else if(j==nghost-1 || j==chainSize-(nghost)) //first cell
{
if(g->idup[icell]==2)
{
if(j==nghost-1) c1 = g->cindx[nghost];
if(j==chainSize-nghost) c1 = g->cindx[chainSize-(nghost+1)];
g->f[j][0] = g->dpsila[c1][0];
g->f[j][1] = g->dpsila[c1][1];
g->f[j][2] = g->dpsila[c1][2];
g->f[j][3] = g->dpsila[c1][3];
g->f[j][4] = g->dpsila[c1][4];
}
else
{
g->f[j][0] = g->psila[icell][0];
g->f[j][1] = g->psila[icell][1];
g->f[j][2] = g->psila[icell][2];
g->f[j][3] = g->psila[icell][3];
g->f[j][4] = g->psila[icell][4];
}
}
if(order==5 && (j==0 || j==chainSize-1))
{
if(g->idup[icell]==2)
{
if(j==0) c1 = g->cindx[3];
if(j==chainSize-1) c1 = g->cindx[chainSize-4];
g->f[j][0] = g->dpsilb[c1][0];
g->f[j][1] = g->dpsilb[c1][1];
g->f[j][2] = g->dpsilb[c1][2];
g->f[j][3] = g->dpsilb[c1][3];
g->f[j][4] = g->dpsilb[c1][4];
}
else
{
g->f[j][0] = g->psilb[icell][0];
g->f[j][1] = g->psilb[icell][1];
g->f[j][2] = g->psilb[icell][2];
g->f[j][3] = g->psilb[icell][3];
g->f[j][4] = g->psilb[icell][4];
}
}
}
else if (rightCell==-1)//far field bc
{
if(g->test==1) //for check!
{
printf("Periodic bc has a problem!\n");
exit(1);
}
g->f[j][0] = rinf;
g->f[j][1] = rinf*s->uinf;
g->f[j][2] = rinf*s->vinf;
g->f[j][3] = rinf*s->winf;
g->f[j][4] = pinf/gm1+0.5*rinf*(s->uinf*s->uinf+s->vinf*s->vinf+s->winf*s->winf);
}
} //icell
} //chainSize
is=nghost-1;
ie=chainSize-1;
th=1./3;
qt=0.25;
if (g->order==1) qt=0.0;
eps=1e-10;
//reconstruction for each chain
if(order==1 || order==3)
{
muscld(g->f,g->ql,g->qr,g->f2,is,ie,th,qt,eps,chainSize,NVAR);
}
if(order==5)
{
//weno(g->f,g->ql,g->qr,is,ie,eps,chainSize,NVAR);
crweno(g->f,g->ql,g->qr,is,ie,eps,chainSize,NVAR);
}
n=is;
idv=(g->chainConn[f1]==g->chainConn[f2-1]);
for(f=f1;f<f2-idv;f++)
{
iface=g->chainConn[f];
node1=g->faces[8*iface];
node2=g->faces[8*iface+1];
node3=g->faces[8*iface+2];
node4=g->faces[8*iface+3];
leftCell=g->faces[8*iface+4];
rightCell=g->faces[8*iface+6];
//3D case
x1=g->x[3*node1];
y1=g->x[3*node1+1];
z1=g->x[3*node1+2];
x2=g->x[3*node2];
y2=g->x[3*node2+1];
z2=g->x[3*node2+2];
x3=g->x[3*node3];
y3=g->x[3*node3+1];
z3=g->x[3*node3+2];
x4=g->x[3*node4];
y4=g->x[3*node4+1];
z4=g->x[3*node4+2];
// 3D face normal vector (direction?)
xa = x3 - x1; xb = x2 - x4;
ya = y3 - y1; yb = y2 - y4;
za = z3 - z1; zb = z2 - z4;
ds[0] = 0.5*(za*yb - ya*zb);
ds[1] = 0.5*(xa*zb - za*xb);
ds[2] = 0.5*(ya*xb - xa*yb);
for(m=0;m<NVAR;m++)
{
if (f==f2-idv-1 && idv==0)
{
leftState[m]=g->ql[n][m];
rightState[m]=g->qr[n+1][m];
}
else
{
leftState[m]=g->qr[n+1][m];
rightState[m]=g->ql[n][m];
}
leftState0[m]=s->q[NVAR*leftCell+m]; //g->ql[j][m];
if (rightCell > -1)
{
rightState0[m]=s->q[NVAR*rightCell+m]; //g->qr[j+1][m];
}
}
if (rightCell==-1 && g->test!=1)
{
rightState0[0]=rinf;
rightState0[1]=rinf*s->uinf;
rightState0[2]=rinf*s->vinf;
rightState0[3]=rinf*s->winf;
rightState0[4]=pinf/gm1+0.5*rinf*(s->uinf*s->uinf+
s->vinf*s->vinf+s->winf*s->winf);
}
//test
else if (rightCell==-2 && g->test!=1)
{
dsnorm=ds[0]*ds[0]+ds[1]*ds[1]+ds[2]*ds[2];
//make reflection matrix
//ref[0][0] = 1.-2.*ds[0]*ds[0]/dsnorm;
//ref[0][1] = -2.*ds[0]*ds[1]/dsnorm;
//ref[0][2] = -2.*ds[0]*ds[2]/dsnorm;
//ref[1][1] = 1.-2.*ds[1]*ds[1]/dsnorm;
//ref[1][0] = -2.*ds[1]*ds[0]/dsnorm;
//ref[1][2] = -2.*ds[1]*ds[2]/dsnorm;
//ref[2][2] = 1.-2.*ds[2]*ds[2]/dsnorm;
//ref[2][0] = -2.*ds[2]*ds[0]/dsnorm;
//ref[2][1] = -2.*ds[2]*ds[1]/dsnorm;
ref[0][0] = (-ds[0]*ds[0]+ds[1]*ds[1]+ds[2]*ds[2])/dsnorm;
ref[0][1] = -2.*ds[0]*ds[1]/dsnorm;
ref[0][2] = -2.*ds[0]*ds[2]/dsnorm;
ref[1][1] = (-ds[1]*ds[1]+ds[0]*ds[0]+ds[2]*ds[2])/dsnorm;
ref[1][0] = -2.*ds[1]*ds[0]/dsnorm;
ref[1][2] = -2.*ds[1]*ds[2]/dsnorm;
ref[2][2] = (-ds[2]*ds[2]+ds[0]*ds[0]+ds[1]*ds[1])/dsnorm;
ref[2][0] = -2.*ds[2]*ds[0]/dsnorm;
ref[2][1] = -2.*ds[2]*ds[1]/dsnorm;
// which fomular is in ?....is it variables? flux?
rightState0[0] = leftState0[0];
rightState0[1] = (leftState0[1]*ref[0][0]+leftState0[2]*ref[0][1]+leftState0[3]*ref[0][2]);
rightState0[2] = (leftState0[1]*ref[1][0]+leftState0[2]*ref[1][1]+leftState0[3]*ref[1][2]);
rightState0[3] = (leftState0[1]*ref[2][0]+leftState0[2]*ref[2][1]+leftState0[3]*ref[2][2]);
rightState0[4] = leftState0[4];
}
if (rightState[1]!=rightState0[1] && 0)
{
trace(leftCell);
trace(rightCell);
for(k=0;k<chainSize;k++)
printf("%d %d %.16e\n",k,g->cindx[k],g->f[k][1]);
trace(n);
tracef(leftState[1]);
tracef(leftState0[1]);
tracef(rightState[1]);
tracef(rightState0[1]);
tracef(s->q[leftCell*NVAR+1])
trace(i);
trace(n);
trace(f);
exit(0);
}
//
//roeflx(&specRadius,flux,leftState,rightState,faceVel,ds,gm1);
flux_roe3d_(ds,leftState,rightState,flux,&specRadius,&gamma1);
//
jac_roe_(ds,leftState,rightState,lmat,rmat,&gamma1,&imode);
//
for(j=0;j<NVAR;j++)
for(k=0;k<NVAR;k++)
{
(g->ff[iface]).lmat[j][k]=lmat[k][j];
(g->ff[iface]).rmat[j][k]=rmat[k][j];
}
//
m=NVAR*leftCell;
for(j=0;j<NVAR;j++)
{
s->r[m]-=flux[j];
m++;
}
s->sigma[leftCell]+=specRadius;
if (rightCell > -1)
{
m=NVAR*rightCell;
for(j=0;j<NVAR;j++)
{
s->r[m]+=flux[j];
m++;
}
s->sigma[rightCell]+=specRadius;
}
n++;
}
}
*linfrho=0.;
*l2rho =0.;
for(i=0;i<g->ncells;i++)
{
if((*linfrho) < fabs(s->r[5*i]))
{
icell=i;
*linfrho=fabs(s->r[5*i]);
}
*l2rho = *l2rho + (s->r[5*i])*(s->r[5*i]);
}
*l2rho = sqrt(*l2rho/(g->ncells));
//if(myid==0) tracef(s->r[0]);
//trace(icell);
}
void DualcomputeRHSk(GRID *g,SOLN *s,double *l2rho,double cflnum)
{
//
int i,j,k,m,f,n;
int f1,f2;
int is,ie;
int iface;
int idv;
int chainSize;
int itype;
int imode=1;
double ds[2];
double leftState[NVAR];
double rightState[NVAR];
double leftState0[NVAR];
double rightState0[NVAR];
double lmat[NVAR][NVAR];
double rmat[NVAR][NVAR];
double consVar[NVAR];
double flux[NVAR];
double gm1=gamm-1.0;
double gamma1=gamm;
double specRadius;
double faceVel=0.;
double dsnorm,nynx,nx2ny;
double rhoi;
int node1,node2,leftCell,rightCell,icell;
double x1,y1,x2,y2;
double pp;
double th,qt,eps;
double dscheck[2];
int nghost,order,iflag;
double dtfac;
// set number of ghost cells
order = g->order;
nghost = 2;
if(order ==5) nghost = 3;
//
// zero out residual and spectral radii
//
dscheck[0]=dscheck[1]=0;
for(i=0;i<g->ncells;i++)
{
for(j=0;j<NVAR;j++)
{
dtfac = cflnum/s->sigma[i];
s->r[i*NVAR+j]=-1.*(s->pq[i*NVAR+j]-s->q[i*NVAR+j])/dtfac;
}
}
for(i=0;i<g->ncells;i++) s->sigma[i]=0.0;
//
// one loop per chain to evaluate fluxes
// on all the faces in the chain
//
for(i=0;i<g->nchains;i++)
{
iflag=0;
f1=g->faceStartPerChain[i];
f2=g->faceStartPerChain[i+1];
m = nghost;
for(f=f1;f<f2;f++)
{
iface=g->chainConn[f];
g->cindx[m]=g->faces[6*iface+2];
g->ctype[m]=1;
m++;
}
//
// add buffer cells to the chain
//
if (g->chainConn[f1]==g->chainConn[f2-1])
{
iflag = 0;
//
// this is a closed chain
// make it periodic
//
f=f1+1;
iface=g->chainConn[f];
g->cindx[m]=g->faces[6*iface+2];
g->ctype[m]=1;
m++;
chainSize=m;
m=0;
for(f=f2-nghost-1;f<f2-1;f++)
{
iface=g->chainConn[f];
g->cindx[m]=g->faces[6*iface+2];
g->ctype[m]=1;
m++;
}
}
else
{
iflag = 1;
//construct ghost cell using other side cell index
//solid bc
if(g->test == 0)
{
if(order==5) //WENO 5
{
m--;
g->cindx[m] = -g->cindx[m];
g->ctype[m] = -1;
m++;
g->cindx[m] = -g->cindx[m-3];
g->ctype[m] = -1;
m++;
g->cindx[m] = -g->cindx[m-5];
g->ctype[m] = -1;
chainSize = m+1;
m = 0;
g->cindx[m] = -g->cindx[m+5];
g->ctype[m] = -1;
m = 1;
g->cindx[m] = -g->cindx[m+3];
g->ctype[m] = -1;
m = 2;
g->cindx[m] = -g->cindx[m+1];
g->ctype[m] = -1;
}
else
{
m--;
g->cindx[m] = -g->cindx[m];
g->ctype[m] = -1;
m++;
g->cindx[m] = -g->cindx[m-3];
g->ctype[m] = -1;
chainSize = m+1;
m = 0;
g->cindx[m] = -g->cindx[m+3];
g->ctype[m] = -1;
m = 1;
g->cindx[m] = -g->cindx[m+1];
g->ctype[m] = -1;
}
} //test=0
if(g->test==1)
{
apply_periodic_LHS(&g[0],f1,f2,m);
chainSize = m+1;
if(order==5) chainSize = m+2;
}
} //close or open loops
/////////////////////////////////////////////////
//if(i==0)
//{
// printf("Stopping code\n");
// printf("chain size=%d\n",chainSize);
// for(k=0;k<=chainSize-1;k++)
// {
// printf("cell index:%d\n",g->cindx[k]);
// }
// exit(1);
//}
/////////////////////////////////////////////////
for(j=0;j<chainSize;j++)
{
icell=g->cindx[j];
itype=g->ctype[j];
if(itype >=0)
{
m=NVAR*icell;
for(k=0;k<NVAR;k++)
{
consVar[k]=s->pq[m];
m++;
}
rhoi=1./consVar[0];
g->f[j][0]=consVar[0];
g->f[j][1]=consVar[1];
g->f[j][2]=consVar[2];
g->f[j][3]=consVar[3];
}
else
{
//
// do ghost cells
// based on whether they are on the solid boundary on that
if (j < nghost)
{
iface=g->chainConn[f1];
}
else
{
iface=g->chainConn[f2-1];
}
rightCell=g->faces[6*iface+4];
if(rightCell==-2) /* this is a face on solid wall */
{
node1=g->faces[6*iface];
node2=g->faces[6*iface+1];
x1=g->x[2*node1];
y1=g->x[2*node1+1];
x2=g->x[2*node2];
y2=g->x[2*node2+1];
ds[0]=(y2-y1);
ds[1]=-(x2-x1);
icell=-icell;
m=NVAR*icell;
for(k=0;k<NVAR;k++)
{
consVar[k]=s->pq[m];
m++;
}
dsnorm=ds[0]*ds[0]+ds[1]*ds[1];
nynx=ds[0]*ds[1]/dsnorm;
nx2ny=(ds[0]*ds[0]-ds[1]*ds[1])/dsnorm;
rhoi=1./consVar[0];
/*
g->f[j][0]=consVar[0];
g->f[j][1]=(-consVar[1]*nx2ny-2*consVar[2]*nynx)*rhoi;
g->f[j][2]=(consVar[2]*nx2ny-2*consVar[1]*nynx)*rhoi;
g->f[j][3]=gm1*(consVar[3]-0.5*(consVar[1]*consVar[1]+consVar[2]*consVar[2])*rhoi);
*/
g->f[j][0]=consVar[0];
g->f[j][1]=(-consVar[1]*nx2ny-2*consVar[2]*nynx);
g->f[j][2]=(consVar[2]*nx2ny-2*consVar[1]*nynx);
g->f[j][3]=consVar[3];
}
else
{
g->f[j][0]=rinf;
g->f[j][1]=rinf*s->uinf;
g->f[j][2]=rinf*s->vinf;
g->f[j][3]=pinf/gm1+0.5*rinf*(s->uinf*s->uinf+s->vinf*s->vinf);
}
}//ghost cell or not
}//chainsize
is=nghost-1;
ie=chainSize-1;
th=1./3;
qt=0.25;
if (g->order==1) qt=0.0;
eps=1e-10;
if(order==1 || order==3)
{
muscld(g->f,g->ql,g->qr,g->f2,is,ie,th,qt,eps,chainSize,NVAR);
}
if(order==5) weno(g->f,g->ql,g->qr,is,ie,eps,chainSize,NVAR);
n=is;
idv=(g->chainConn[f1]==g->chainConn[f2-1]);
for(f=f1;f<f2-idv;f++)
{
iface=g->chainConn[f];
node1=g->faces[6*iface];
node2=g->faces[6*iface+1];
leftCell=g->faces[6*iface+2];
rightCell=g->faces[6*iface+4];
x1=g->x[2*node1];
y1=g->x[2*node1+1];
x2=g->x[2*node2];
y2=g->x[2*node2+1];
ds[0]=(y2-y1);
ds[1]=-(x2-x1);
for(m=0;m<NVAR;m++)
{
if (f==f2-idv-1 && idv==0)
{
leftState[m]=g->ql[n][m];
rightState[m]=g->qr[n+1][m];
}
else
{
leftState[m]=g->qr[n+1][m];
rightState[m]=g->ql[n][m];
}
leftState0[m]=s->pq[NVAR*leftCell+m]; //g->ql[j][m];
if (rightCell > -1)
{
rightState0[m]=s->q[NVAR*rightCell+m]; //g->qr[j+1][m];
}
}
if (rightCell==-1 && g->test==0)
{ //periodic conditino always do!
rightState0[0]=rinf;
rightState0[1]=rinf*s->uinf;
rightState0[2]=rinf*s->vinf;
rightState0[3]=pinf/gm1+0.5*rinf*(s->uinf*s->uinf+s->vinf*s->vinf);
}
else if (rightCell==-2)
{
dsnorm=ds[0]*ds[0]+ds[1]*ds[1];
nynx=ds[0]*ds[1]/dsnorm;
nx2ny=(ds[0]*ds[0]-ds[1]*ds[1])/dsnorm;
rightState0[0]=leftState0[0];
rightState0[1]=-leftState0[1]*nx2ny-2*leftState0[2]*nynx;
rightState0[2]=leftState0[2]*nx2ny-2*leftState0[1]*nynx;
rightState0[3]=leftState0[3];
}
if (rightState[1]!=rightState0[1] && 0)
{
trace(leftCell);
trace(rightCell);
for(k=0;k<chainSize;k++)
printf("%d %d %.16e\n",k,g->cindx[k],g->f[k][1]);
trace(n);
tracef(leftState[1]);
tracef(leftState0[1]);
tracef(rightState[1]);
tracef(rightState0[1]);
tracef(s->q[leftCell*NVAR+1])
trace(i);
trace(n);
trace(f);
//exit(0);
}
//
flux_roe2d_(ds,leftState,rightState,flux,&specRadius,&gamma1);
//test
//if(i==0){
//printf("ds:%f %f \n",ds[0],ds[1]);
//printf("leftstate:%f %f %f %f %f\n",leftState[0],leftState[1],leftState[2],leftState[3],leftState[4]);
//printf("rightstate:%f %f %f %f %f\n",rightState[0],rightState[1],rightState[2],rightState[3],rightState[4]);
//}
//test
jac_roe2d_(ds,leftState,rightState,lmat,rmat,&gamma1,&imode);
//
for(j=0;j<NVAR;j++)
for(k=0;k<NVAR;k++)
{
(g->ff[iface]).lmat[j][k]=lmat[k][j];
(g->ff[iface]).rmat[j][k]=rmat[k][j];
//test
//if(i==0){
//printf("iface:%d,k:%d.j:%d\n",iface,k,j);
//tracef(lmat[k][j]);
//tracef(rmat[k][j]);
//}
//test
}
//
m=NVAR*leftCell;
for(j=0;j<NVAR;j++)
{
s->r[m]-=flux[j];
m++;
}
s->sigma[leftCell]+=specRadius;
if (rightCell > -1)
{
m=NVAR*rightCell;
for(j=0;j<NVAR;j++)
{
s->r[m]+=flux[j];
m++;
}
s->sigma[rightCell]+=specRadius;
}
n++;
//if(i==0){
//printf("leftcell:%d,ds[x]:%e, ds[y]:%e, ds[z]:%e,\n",leftCell,ds[0],ds[1],ds[2]);
//printf("rightcell:%d,ds[x]:%e, ds[y]:%e, ds[z]:%e,\n",rightCell,ds[0],ds[1],ds[2]);
//m = NVAR*leftCell;
//printf("leftCell:%d, res:%e,%e,%e,%e,%e\n",leftCell,s->r[m],s->r[m+1],s->r[m+2],s->r[m+3],s->r[m+4]);
//m = NVAR*rightCell;
//printf("rightCell:%d, res:%e,%e,%e,%e,%e\n",rightCell,s->r[m],s->r[m+1],s->r[m+2],s->r[m+3],s->r[m+4]);
//}
} // f1-f2
} //nchains
*l2rho=0.;
for(i=0;i<g->ncells;i++)
{
if ((*l2rho) < fabs(s->r[4*i]))
{
icell=i;
*l2rho=fabs(s->r[4*i]);
}
}
tracef(s->r[0]);
//trace(icell);
}
