void integrate_2d_smaug(DomainS *pD)
{
GridS *pG=(pD->Grid);
Real dtodx1=pG->dt/pG->dx1, dtodx2=pG->dt/pG->dx2, dtodx3=pG->dt/pG->dx3;
Real hdt = 0.5*pG->dt, dx2=pG->dx2;
Real q1 = 0.5*dtodx1, q2 = 0.5*dtodx2, q3 = 0.5*dtodx3;
int dir;
int i,il,iu, is = pG->is, ie = pG->ie;
int j,jl,ju, js = pG->js, je = pG->je;
int k,kl,ku, ks = pG->ks, ke = pG->ke;
Real x1,x2,x3,phicl,phicr,phifc,phil,phir,phic,M1h,M2h,M3h,Bx=0.0,Bxb=0.0;
/*Used for hyperdiffusion computations*/
int ii1, dim, ii, ii0;
int field; /*integers map to following index rho, mom1, mom2, energy, b1, b2,energyb,rhob,b1b,b2b*/
#ifdef MHD
Real MHD_src_By,MHD_src_Bz,mdb1,mdb2,mdb3;
Real db1,db2,db3,l1,l2,l3,B1,B2,B3,V1,V2,V3;
Real B1ch,B2ch,B3ch;
#endif
// #if defined(MHD) || defined(SELF_GRAVITY)
Real dx1i=1.0/pG->dx1, dx2i=1.0/pG->dx2, dx3i=1.0/pG->dx3;
// #endif
#if (NSCALARS > 0)
int n;
#endif
#ifdef SELF_GRAVITY
Real gxl,gxr,gyl,gyr,gzl,gzr,flx_m1l,flx_m1r,flx_m2l,flx_m2r,flx_m3l,flx_m3r;
#endif
#ifdef FEEDBACK
Real dt1 = 1.0/pG->dt;
#endif
#ifdef STATIC_MESH_REFINEMENT
int ncg,npg,dim;
int ii,ics,ice,jj,jcs,jce,kk,kcs,kce,ips,ipe,jps,jpe,kps,kpe;
#endif
Real g,gl,gr;
Real lsf=1.0, rsf=1.0;
/* With particles, one more ghost cell must be updated in predict step */
#ifdef PARTICLES
Real d1;
il = is - 3;
iu = ie + 3;
jl = js - 3;
ju = je + 3;
kl = ks - 3;
ku = ke + 3;
#else
il = is - 2;
iu = ie + 2;
jl = js - 2;
ju = je + 2;
kl = ks - 2;
ku = ke + 2;
#endif
/* Set etah=0 so first calls to flux functions do not use H-correction */
etah = 0.0;
/* Compute predictor feedback from particle drag */
#ifdef FEEDBACK
feedback_predictor(pD);
exchange_gpcouple(pD,1);
#endif
/*=== STEP 1: Compute L/R x1-interface states and 1D x1-Fluxes ===============*/
/*--- Step 1a ------------------------------------------------------------------
* Load 1D vector of conserved variables;
* U1d = (d, M1, M2, M3, E, B2c, B3c, s[n])
*/
for (j=jl; j<=ju; j++) {
for (i=is-nghost; i<=ie+nghost; i++) {
U1d[i].d = pG->U[ks][j][i].d;
U1d[i].Mx = pG->U[ks][j][i].M1;
U1d[i].My = pG->U[ks][j][i].M2;
U1d[i].Mz = pG->U[ks][j][i].M3;
#ifndef BAROTROPIC
U1d[i].E = pG->U[ks][j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
U1d[i].By = pG->U[ks][j][i].B2c;
U1d[i].Bz = pG->U[ks][j][i].B3c;
Bxc[i] = pG->U[ks][j][i].B1c;
Bxi[i] = pG->B1i[ks][j][i];
B1_x1[j][i] = pG->B1i[ks][j][i];
#endif /* MHD */
#ifdef BKG
U1d[i].db = pG->U[ks][j][i].db;
U1d[i].Byb = pG->U[ks][j][i].B2cb;
U1d[i].Bzb = pG->U[ks][j][i].B3cb;
#endif
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) U1d[i].s[n] = pG->U[ks][j][i].s[n];
#endif
}
/*--- Step 1b ------------------------------------------------------------------
* Compute L and R states at X1-interfaces, add "MHD source terms" for 0.5*dt
*/
for (i=is-nghost; i<=ie+nghost; i++) {
W[i] = Cons1D_to_Prim1D(&U1d[i],&Bxc[i],&Bxb);
/*--- Step 1c ------------------------------------------------------------------
* Add source terms from static gravitational potential for 0.5*dt to L/R states
*/
/*if (StaticGravPot != NULL){
for (i=il+1; i<=iu; i++) {
cc_pos(pG,i,j,ks,&x1,&x2,&x3);
phicr = (*StaticGravPot)( x1 ,x2,x3);
phicl = (*StaticGravPot)((x1- pG->dx1),x2,x3);
phifc = (*StaticGravPot)((x1-0.5*pG->dx1),x2,x3);
gl = 2.0*(phifc - phicl)*dx1i;
gr = 2.0*(phicr - phifc)*dx1i;
#if defined(CYLINDRICAL) && defined(FARGO)
gl -= r[i-1]*SQR((*OrbitalProfile)(r[i-1]));
gr -= r[i ]*SQR((*OrbitalProfile)(r[i ]));
#endif
W[i].Vx -= hdt*gl;
}
}*/
/*--- Step 1c (cont) -----------------------------------------------------------
* Add the geometric source-terms now using cell-centered primitive
* variables at time t^n
*/
/*--- Step 1d ------------------------------------------------------------------
* Compute 1D fluxes in x1-direction, storing into 3D array
*/
for (i=il+1; i<=iu; i++) {
Uc_x1[j][i] = Prim1D_to_Cons1D(&W[i],&Bxi[i],&Bxb);
#ifdef MHD
Bx = B1_x1[j][i];
Bxb=0.0;//?????????????????????????
#endif
fluxes(Uc_x1[j][i],Uc_x1[j][i],W[i],W[i],Bx,Bxb,&x1Flux[j][i]);
}
}
/*=== STEP 2: Compute L/R x2-interface states and 1D x2-Fluxes ===============*/
/*--- Step 2a ------------------------------------------------------------------
* Load 1D vector of conserved variables;
* U1d = (d, M2, M3, M1, E, B3c, B1c, s[n])
*/
for (i=il; i<=iu; i++) {
#ifdef CYLINDRICAL
dx2 = r[i]*pG->dx2;
dx2i = 1.0/dx2;
dtodx2 = pG->dt*dx2i;
hdtodx2 = 0.5*dtodx2;
#endif
for (j=js-nghost; j<=je+nghost; j++) {
U1d[j].d = pG->U[ks][j][i].d;
U1d[j].Mx = pG->U[ks][j][i].M2;
U1d[j].My = pG->U[ks][j][i].M3;
U1d[j].Mz = pG->U[ks][j][i].M1;
#ifndef BAROTROPIC
U1d[j].E = pG->U[ks][j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
U1d[j].By = pG->U[ks][j][i].B3c;
U1d[j].Bz = pG->U[ks][j][i].B1c;
Bxc[j] = pG->U[ks][j][i].B2c;
Bxi[j] = pG->B2i[ks][j][i];
B2_x2[j][i] = pG->B2i[ks][j][i];
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) U1d[j].s[n] = pG->U[ks][j][i].s[n];
#endif
}
/*--- Step 2b ------------------------------------------------------------------
* Compute L and R states at X2-interfaces, add "MHD source terms" for 0.5*dt
*/
/*--- Step 2c ------------------------------------------------------------------
* Add source terms from static gravitational potential for 0.5*dt to L/R states
*/
/* if (StaticGravPot != NULL){
for (j=jl+1; j<=ju; j++) {
cc_pos(pG,i,j,ks,&x1,&x2,&x3);
phicr = (*StaticGravPot)(x1, x2 ,x3);
phicl = (*StaticGravPot)(x1,(x2- pG->dx2),x3);
phifc = (*StaticGravPot)(x1,(x2-0.5*pG->dx2),x3);
W[j].Vx -= dtodx2*(phifc - phicl);
}
}*/
/*--- Step 2d ------------------------------------------------------------------
* Compute 1D fluxes in x2-direction, storing into 3D array
*/
for (j=jl+1; j<=ju; j++) {
Uc_x2[j][i] = Prim1D_to_Cons1D(&W[j],&Bxi[j],&Bxb);
#ifdef MHD
Bx = B2_x2[j][i];
Bxb=0.0;//?????????????????????????
#endif
fluxes(Uc_x2[j][i],Uc_x2[j][i],W[j],W[j],Bx,Bxb,&x2Flux[j][i]);
}
}
/*--- Step 3c ------------------------------------------------------------------
* Add source terms from static gravitational potential for 0.5*dt to L/R states
*/
/* if (StaticGravPot != NULL){
for (k=kl+1; k<=ku; k++) {
cc_pos(pG,i,j,ks,&x1,&x2,&x3);
phicr = (*StaticGravPot)(x1,x2, x3 );
phicl = (*StaticGravPot)(x1,x2,(x3- pG->dx3));
phifc = (*StaticGravPot)(x1,x2,(x3-0.5*pG->dx3));
W[k].Vx -= dtodx3*(phifc - phicl);
}
}*/
/*--- Step 3d ------------------------------------------------------------------
* Compute 1D fluxes in x3-direction, storing into 3D array
*/
/*Not needed here for 2d problem*/
/*=== STEP 4: Update face-centered B for 0.5*dt =============================*/
/*--- Step 4a ------------------------------------------------------------------
* Calculate the cell centered value of emf1,2,3 at t^{n} and integrate
* to corner.
*/
/*--- Step 4b ------------------------------------------------------------------
* Update the interface magnetic fields using CT for a half time step.
*/
/*=== STEP 5: Correct x1-interface states with transverse flux gradients =====*/
/*--- Step 5a ------------------------------------------------------------------
* Correct x1-interface states using x2-fluxes computed in Step 2d.
* Since the fluxes come from an x2-sweep, (x,y,z) on RHS -> (z,x,y) on LHS
*/
/*--- Step 5b ------------------------------------------------------------------
* Correct x1-interface states using x3-fluxes computed in Step 3d.
* Since the fluxes come from an x3-sweep, (x,y,z) on RHS -> (y,z,x) on LHS
*/
/*--- Step 5c ------------------------------------------------------------------
* Add the "MHD source terms" from the x2- and x3-flux-gradients to the
* conservative variables on the x1Face. Limiting is used as in GS (2007)
*/
/*--- Step 5d ------------------------------------------------------------------
* Add source terms for a static gravitational potential arising from x2-Flux
* and x3-Flux gradients. To improve conservation of total energy, average
* the energy source term computed at cell faces.
* S_{M} = -(\rho) Grad(Phi); S_{E} = -(\rho v) Grad{Phi}
*/
/* if (StaticGravPot != NULL){
for (k=kl+1; k<=ku-1; k++) {
for (j=jl+1; j<=ju-1; j++) {
for (i=il+1; i<=iu; i++) {
cc_pos(pG,i,j,k,&x1,&x2,&x3);
phic = (*StaticGravPot)(x1, x2 ,x3);
phir = (*StaticGravPot)(x1,(x2+0.5*pG->dx2),x3);
phil = (*StaticGravPot)(x1,(x2-0.5*pG->dx2),x3); ---------*/
/* correct right states; x2 and x3 gradients */
/*-----------------------------
#ifdef CYLINDRICAL
q2 = hdt/(r[i]*pG->dx2);
#endif
Ur_x1Face[k][j][i].My -= q2*(phir-phil)*pG->U[k][j][i].d;
#ifndef BAROTROPIC
Ur_x1Face[k][j][i].E -= q2*(x2Flux[k][j ][i ].d*(phic - phil)
+ x2Flux[k][j+1][i ].d*(phir - phic));
#ifdef ROTATING_FRAME
Ur_x1Face[k][j][i].E += hdt * 0.5*(x2Flux[k][j ][i ].d*sin(x2-0.5*pG->dx2) +
x2Flux[k][j+1][i ].d*sin(x2+0.5*pG->dx2)) *SQR(Omega_0)*Rc;
#endif
#endif
phir = (*StaticGravPot)(x1,x2,(x3+0.5*pG->dx3));
phil = (*StaticGravPot)(x1,x2,(x3-0.5*pG->dx3));
Ur_x1Face[k][j][i].Mz -= q3*(phir-phil)*pG->U[k][j][i].d;
#ifndef BAROTROPIC
Ur_x1Face[k][j][i].E -= q3*(x3Flux[k ][j][i ].d*(phic - phil)
+ x3Flux[k+1][j][i ].d*(phir - phic));
#endif
-----------------------*/
/* correct left states; x2 and x3 gradients */
/*--------------------------------------------
phic = (*StaticGravPot)((x1-pG->dx1), x2 ,x3);
phir = (*StaticGravPot)((x1-pG->dx1),(x2+0.5*pG->dx2),x3);
phil = (*StaticGravPot)((x1-pG->dx1),(x2-0.5*pG->dx2),x3);
#ifdef CYLINDRICAL
q2 = hdt/(r[i-1]*pG->dx2);
#endif
Ul_x1Face[k][j][i].My -= q2*(phir-phil)*pG->U[k][j][i-1].d;
#ifndef BAROTROPIC
Ul_x1Face[k][j][i].E -= q2*(x2Flux[k][j ][i-1].d*(phic - phil)
+ x2Flux[k][j+1][i-1].d*(phir - phic));
#ifdef ROTATING_FRAME
Ul_x1Face[k][j][i].E += hdt * 0.5*(x2Flux[k][j ][i-1].d*sin(x2-0.5*pG->dx2) +
x2Flux[k][j+1][i-1].d*sin(x2+0.5*pG->dx2)) *SQR(Omega_0)*Rc;
#endif
#endif
phir = (*StaticGravPot)((x1-pG->dx1),x2,(x3+0.5*pG->dx3));
phil = (*StaticGravPot)((x1-pG->dx1),x2,(x3-0.5*pG->dx3));
Ul_x1Face[k][j][i].Mz -= q3*(phir-phil)*pG->U[k][j][i-1].d;
#ifndef BAROTROPIC
Ul_x1Face[k][j][i].E -= q3*(x3Flux[k ][j][i-1].d*(phic - phil)
+ x3Flux[k+1][j][i-1].d*(phir - phic));
#endif
}
}
}}*/
/*=== STEP 6: Correct x2-interface states with transverse flux gradients =====*/
/*--- Step 6a ------------------------------------------------------------------
* Correct x2-interface states using x1-fluxes computed in Step 1d.
* Since the fluxes come from an x1-sweep, (x,y,z) on RHS -> (y,z,x) on LHS
*/
/*--- Step 6b ------------------------------------------------------------------
* Correct x2-interface states using x3-fluxes computed in Step 3d.
* Since the fluxes come from an x3-sweep, (x,y,z) on RHS -> (z,x,y) on LHS
*/
/*--- Step 6c ------------------------------------------------------------------
* Add the "MHD source terms" from the x1- and x3-flux-gradients to the
* conservative variables on the x2Face. Limiting is used as in GS (2007)
*/
/*--- Step 6d ------------------------------------------------------------------
* Add source terms for a static gravitational potential arising from x1-Flux
* and x3-Flux gradients. To improve conservation of total energy,
* average the energy source term computed at cell faces.
* S_{M} = -(\rho) Grad(Phi); S_{E} = -(\rho v) Grad{Phi}
*/
/*=== STEP 7: Correct x3-interface states with transverse flux gradients =====*/
/*--- Step 7a ------------------------------------------------------------------
* Correct x3-interface states using x1-fluxes computed in Step 1d.
* Since the fluxes come from an x1-sweep, (x,y,z) on RHS -> (z,x,y) on LHS
*/
/*--- Step 7b ------------------------------------------------------------------
* Correct x3-interface states using x2-fluxes computed in Step 2d.
* Since the fluxes come from an x2-sweep, (x,y,z) on RHS -> (y,z,x) on LHS
*/
/*--- Step 7c ------------------------------------------------------------------
* Add the "MHD source terms" from the x1- and x2-flux-gradients to the
* conservative variables on the x3Face. Limiting is used as in GS07.
*/
/*--- Step 7d ------------------------------------------------------------------
* Add source terms for a static gravitational potential arising from x1-Flux
* and x2-Flux gradients. To improve conservation of total energy,
* average the energy source term computed at cell faces.
* S_{M} = -(\rho) Grad(Phi); S_{E} = -(\rho v) Grad{Phi}
*/
/*--- Step 7e ------------------------------------------------------------------
* Apply density floor
*/
/*=== STEP 8: Compute cell-centered values at n+1/2 ==========================*/
/*=== STEP 9: Compute 3D x1-Flux, x2-Flux, x3-Flux ===========================*/
/*--- Step 9a ------------------------------------------------------------------
* Compute maximum wavespeeds in multidimensions (eta in eq. 10 from Sanders et
* al. (1998)) for H-correction
*/
/*--- Step 9b ------------------------------------------------------------------
* Compute 3D x1-fluxes from corrected L/R states.
*/
/*--- Step 9c ------------------------------------------------------------------
* Compute 3D x2-fluxes from corrected L/R states.
*/
/*--- Step 9d ------------------------------------------------------------------
* Compute 3D x3-fluxes from corrected L/R states.
*/
/*=== STEP 10: Update face-centered B for a full timestep ====================*/
/*--- Step 10a -----------------------------------------------------------------
* Integrate emf*^{n+1/2} to the grid cell corners
*/
/*--- Step 10b -----------------------------------------------------------------
* Update the interface magnetic fields using CT for a full time step.
*/
/*=== STEP 11: Add source terms for a full timestep using n+1/2 states =======*/
/*=== STEP 12: Update cell-centered values for a full timestep ===============*/
/*--- Step 12a -----------------------------------------------------------------
* Update cell-centered variables in pG using 3D x1-Fluxes
*/
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
#ifdef CYLINDRICAL
rsf = ri[i+1]/r[i]; lsf = ri[i]/r[i];
#endif
pG->U[ks][j][i].d -= dtodx1*(rsf*x1Flux[j][i+1].d - lsf*x1Flux[j][i].d );
pG->U[ks][j][i].M1 -= dtodx1*(rsf*x1Flux[j][i+1].Mx - lsf*x1Flux[j][i].Mx);
pG->U[ks][j][i].M2 -= dtodx1*(SQR(rsf)*x1Flux[j][i+1].My - SQR(lsf)*x1Flux[j][i].My);
pG->U[ks][j][i].M3 -= dtodx1*(rsf*x1Flux[j][i+1].Mz - lsf*x1Flux[j][i].Mz);
#ifndef BAROTROPIC
pG->U[ks][j][i].E -= dtodx1*(rsf*x1Flux[j][i+1].E - lsf*x1Flux[j][i].E );
#endif /* BAROTROPIC */
#ifdef MHD
pG->U[ks][j][i].B2c -= dtodx1*(x1Flux[j][i+1].By - x1Flux[j][i].By);
pG->U[ks][j][i].B3c -= dtodx1*(rsf*x1Flux[j][i+1].Bz - lsf*x1Flux[j][i].Bz);
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->U[ks][j][i].s[n] -= dtodx1*(rsf*x1Flux[j][i+1].s[n]
- lsf*x1Flux[j][i ].s[n]);
#endif
}
}
/*--- Step 12b -----------------------------------------------------------------
* Update cell-centered variables in pG using 3D x2-Fluxes
*/
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
#ifdef CYLINDRICAL
dtodx2 = pG->dt/(r[i]*pG->dx2);
#endif
pG->U[ks][j][i].d -= dtodx2*(x2Flux[j+1][i].d - x2Flux[j][i].d );
pG->U[ks][j][i].M1 -= dtodx2*(x2Flux[j+1][i].Mz - x2Flux[j][i].Mz);
pG->U[ks][j][i].M2 -= dtodx2*(x2Flux[j+1][i].Mx - x2Flux[j][i].Mx);
pG->U[ks][j][i].M3 -= dtodx2*(x2Flux[j+1][i].My - x2Flux[j][i].My);
#ifndef BAROTROPIC
pG->U[ks][j][i].E -= dtodx2*(x2Flux[j+1][i].E - x2Flux[j][i].E );
#endif /* BAROTROPIC */
#ifdef MHD
pG->U[ks][j][i].B3c -= dtodx2*(x2Flux[j+1][i].By - x2Flux[j][i].By);
pG->U[ks][j][i].B1c -= dtodx2*(x2Flux[j+1][i].Bz - x2Flux[j][i].Bz);
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->U[ks][j][i].s[n] -= dtodx2*(x2Flux[j+1][i].s[n]
- x2Flux[j ][i].s[n]);
#endif
}
}
/*--- Step 12c -----------------------------------------------------------------
* Update cell-centered variables in pG using 3D x3-Fluxes
*/
//hyperdifvisc1r
//hyperdifvisc1l
//computec
//computemaxc
//density contribution
for(dim=0; dim<2; dim++) //each direction
{
//hyperdifvisc1ir
//hyperdifvisc1il
//hyperdifrhosource1
;
}
//energy hyperdiffusion term
for(dim=0; dim<2; dim++) //each direction
{
//hyperdifvisc1ir
//hyperdifvisc1il
//hyperdifesource1
;
}
//momentum hyperdiffusion term
for(dim=0; dim<2; dim++) //each direction
{
//hyperdifvisc1ir
//hyperdifvisc1il
//hyperdifesource1
for(ii1=0;ii1<=1;ii1++)
{
if (ii1 == 0)
{
ii=dim;
ii0=field; //f is field
}
else
{
ii=field;
ii0=dim;
}
if(ii==dim)
;// hyperdifmomsource1(ii,ii0,pG->dt);
else
;// hyperdifmomsourcene1(ii,ii0,pG->dt); //off diagonal
}
}
#ifdef MHD
//b field hyperdiffusion term
for(dim=0; dim<2; dim++) //each direction
{
//hyperdifvisc1ir
//hyperdifvisc1il
for(ii1=0;ii1<=1;ii1++)
{
if (ii1 == 0)
{
ii=dim;
ii0=field; //f is field
}
else
{
ii=field;
ii0=dim;
}
if(ii==dim)
;// hyperdifbsource(ii,ii0,pG->dt,pG);
else
;// hyperdifbsourcene(ii,ii0,pG->dt,pG); //off diagonal
}
}
#endif /*hyperdiffusion source term for bfield*/
/*static mesh refinement part goes here*/
#ifdef STATIC_MESH_REFINEMENT
/*--- Step 12e -----------------------------------------------------------------
* With SMR, store fluxes at boundaries of child and parent grids.
*/
for (ncg=0; ncg<pG->NCGrid; ncg++) {
/* x1-boundaries of child Grids (interior to THIS Grid) */
for (dim=0; dim<2; dim++){
if (pG->CGrid[ncg].myFlx[dim] != NULL) {
if (dim==0) i = pG->CGrid[ncg].ijks[0];
if (dim==1) i = pG->CGrid[ncg].ijke[0] + 1;
jcs = pG->CGrid[ncg].ijks[1];
jce = pG->CGrid[ncg].ijke[1];
for (j=jcs, jj=0; j<=jce; j++, jj++){
pG->CGrid[ncg].myFlx[dim][ks][jj].d = x1Flux[j][i].d;
pG->CGrid[ncg].myFlx[dim][ks][jj].M1 = x1Flux[j][i].Mx;
pG->CGrid[ncg].myFlx[dim][ks][jj].M2 = x1Flux[j][i].My;
pG->CGrid[ncg].myFlx[dim][ks][jj].M3 = x1Flux[j][i].Mz;
#ifndef BAROTROPIC
pG->CGrid[ncg].myFlx[dim][ks][jj].E = x1Flux[j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->CGrid[ncg].myFlx[dim][ks][jj].B1c = 0.0;
pG->CGrid[ncg].myFlx[dim][ks][jj].B2c = x1Flux[j][i].By;
pG->CGrid[ncg].myFlx[dim][ks][jj].B3c = x1Flux[j][i].Bz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->CGrid[ncg].myFlx[dim][ks][jj].s[n] = x1Flux[j][i].s[n];
#endif
}
#ifdef MHD
for (j=jcs, jj=0; j<=jce+1; j++, jj++){
pG->CGrid[ncg].myEMF3[dim][ks][jj] = emf3[j][i];
}
#endif /* MHD */
}
}
/* x2-boundaries of child Grids (interior to THIS Grid) */
for (dim=2; dim<4; dim++){
if (pG->CGrid[ncg].myFlx[dim] != NULL) {
ics = pG->CGrid[ncg].ijks[0];
ice = pG->CGrid[ncg].ijke[0];
if (dim==2) j = pG->CGrid[ncg].ijks[1];
if (dim==3) j = pG->CGrid[ncg].ijke[1] + 1;
for (i=ics, ii=0; i<=ice; i++, ii++){
pG->CGrid[ncg].myFlx[dim][ks][ii].d = x2Flux[j][i].d;
pG->CGrid[ncg].myFlx[dim][ks][ii].M1 = x2Flux[j][i].Mz;
pG->CGrid[ncg].myFlx[dim][ks][ii].M2 = x2Flux[j][i].Mx;
pG->CGrid[ncg].myFlx[dim][ks][ii].M3 = x2Flux[j][i].My;
#ifndef BAROTROPIC
pG->CGrid[ncg].myFlx[dim][ks][ii].E = x2Flux[j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->CGrid[ncg].myFlx[dim][ks][ii].B1c = x2Flux[j][i].Bz;
pG->CGrid[ncg].myFlx[dim][ks][ii].B2c = 0.0;
pG->CGrid[ncg].myFlx[dim][ks][ii].B3c = x2Flux[j][i].By;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->CGrid[ncg].myFlx[dim][ks][ii].s[n] = x2Flux[j][i].s[n];
#endif
}
#ifdef MHD
for (i=ics, ii=0; i<=ice+1; i++, ii++){
pG->CGrid[ncg].myEMF3[dim][ks][ii] = emf3[j][i];
}
#endif /* MHD */
}
}
}
for (npg=0; npg<pG->NPGrid; npg++) {
/* x1-boundaries of parent Grids (at boundaries of THIS Grid) */
for (dim=0; dim<2; dim++){
if (pG->PGrid[npg].myFlx[dim] != NULL) {
if (dim==0) i = pG->PGrid[npg].ijks[0];
if (dim==1) i = pG->PGrid[npg].ijke[0] + 1;
jps = pG->PGrid[npg].ijks[1];
jpe = pG->PGrid[npg].ijke[1];
for (j=jps, jj=0; j<=jpe; j++, jj++){
pG->PGrid[npg].myFlx[dim][ks][jj].d = x1Flux[j][i].d;
pG->PGrid[npg].myFlx[dim][ks][jj].M1 = x1Flux[j][i].Mx;
pG->PGrid[npg].myFlx[dim][ks][jj].M2 = x1Flux[j][i].My;
pG->PGrid[npg].myFlx[dim][ks][jj].M3 = x1Flux[j][i].Mz;
#ifndef BAROTROPIC
pG->PGrid[npg].myFlx[dim][ks][jj].E = x1Flux[j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->PGrid[npg].myFlx[dim][ks][jj].B1c = 0.0;
pG->PGrid[npg].myFlx[dim][ks][jj].B2c = x1Flux[j][i].By;
pG->PGrid[npg].myFlx[dim][ks][jj].B3c = x1Flux[j][i].Bz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->PGrid[npg].myFlx[dim][ks][jj].s[n] = x1Flux[j][i].s[n];
#endif
}
#ifdef MHD
for (j=jps, jj=0; j<=jpe+1; j++, jj++){
pG->PGrid[npg].myEMF3[dim][ks][jj] = emf3[j][i];
}
#endif /* MHD */
}
}
/* x2-boundaries of parent Grids (at boundaries of THIS Grid) */
for (dim=2; dim<4; dim++){
if (pG->PGrid[npg].myFlx[dim] != NULL) {
ips = pG->PGrid[npg].ijks[0];
ipe = pG->PGrid[npg].ijke[0];
if (dim==2) j = pG->PGrid[npg].ijks[1];
if (dim==3) j = pG->PGrid[npg].ijke[1] + 1;
for (i=ips, ii=0; i<=ipe; i++, ii++){
pG->PGrid[npg].myFlx[dim][ks][ii].d = x2Flux[j][i].d;
pG->PGrid[npg].myFlx[dim][ks][ii].M1 = x2Flux[j][i].Mz;
pG->PGrid[npg].myFlx[dim][ks][ii].M2 = x2Flux[j][i].Mx;
pG->PGrid[npg].myFlx[dim][ks][ii].M3 = x2Flux[j][i].My;
#ifndef BAROTROPIC
pG->PGrid[npg].myFlx[dim][ks][ii].E = x2Flux[j][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->PGrid[npg].myFlx[dim][ks][ii].B1c = x2Flux[j][i].Bz;
pG->PGrid[npg].myFlx[dim][ks][ii].B2c = 0.0;
pG->PGrid[npg].myFlx[dim][ks][ii].B3c = x2Flux[j][i].By;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->PGrid[npg].myFlx[dim][ks][ii].s[n] = x2Flux[j][i].s[n];
#endif
}
#ifdef MHD
for (i=ips, ii=0; i<=ipe+1; i++, ii++){
pG->PGrid[npg].myEMF3[dim][ks][ii] = emf3[j][i];
}
#endif /* MHD */
}
}
}
#endif /* STATIC_MESH_REFINEMENT */
}
return;
}
void fluxes(const Cons1DS Ul, const Cons1DS Ur,
const Prim1DS Wl, const Prim1DS Wr,
const Real Bxi, Cons1DS *pFlux)
{
Real sqrtdl,sqrtdr,isdlpdr,droe,v1roe,v2roe,v3roe,pbl=0.0,pbr=0.0;
Real asq,vaxsq=0.0,qsq,cfsq,cfl,cfr,bp,bm,ct2=0.0,tmp;
#ifndef ISOTHERMAL
Real hroe;
#endif
#ifdef MHD
Real b2roe,b3roe,x,y;
#endif
Real ev[NWAVE],al,ar;
Real *pFl, *pFc, *pFr, *pUc, *pF;
Prim1DS Wc;
Cons1DS Fl, Fc, Fr, Uc;
int n;
/* The first 5 steps are identical to those in hlle fluxes */
/*--- Step 1. ------------------------------------------------------------------
* Convert left- and right- states in conserved to primitive variables.
*/
/*
pbl = Cons1D_to_Prim1D(&Ul,&Wl,&Bxi);
pbr = Cons1D_to_Prim1D(&Ur,&Wr,&Bxi);
*/
/*--- Step 2. ------------------------------------------------------------------
* Compute Roe-averaged data from left- and right-states
*/
sqrtdl = sqrt((double)Wl.d);
sqrtdr = sqrt((double)Wr.d);
isdlpdr = 1.0/(sqrtdl + sqrtdr);
droe = sqrtdl*sqrtdr;
v1roe = (sqrtdl*Wl.Vx + sqrtdr*Wr.Vx)*isdlpdr;
v2roe = (sqrtdl*Wl.Vy + sqrtdr*Wr.Vy)*isdlpdr;
v3roe = (sqrtdl*Wl.Vz + sqrtdr*Wr.Vz)*isdlpdr;
/*
* The Roe average of the magnetic field is defined differently.
*/
#ifdef MHD
b2roe = (sqrtdr*Wl.By + sqrtdl*Wr.By)*isdlpdr;
b3roe = (sqrtdr*Wl.Bz + sqrtdl*Wr.Bz)*isdlpdr;
x = 0.5*(SQR(Wl.By - Wr.By) + SQR(Wl.Bz - Wr.Bz))/(SQR(sqrtdl + sqrtdr));
y = 0.5*(Wl.d + Wr.d)/droe;
pbl = 0.5*(SQR(Bxi) + SQR(Wl.By) + SQR(Wl.Bz));
pbr = 0.5*(SQR(Bxi) + SQR(Wr.By) + SQR(Wr.Bz));
#endif
/*
* Following Roe(1981), the enthalpy H=(E+P)/d is averaged for adiabatic flows,
* rather than E or P directly. sqrtdl*hl = sqrtdl*(el+pl)/dl = (el+pl)/sqrtdl
*/
#ifndef ISOTHERMAL
hroe = ((Ul.E + Wl.P + pbl)/sqrtdl + (Ur.E + Wr.P + pbr)/sqrtdr)*isdlpdr;
#endif
/*--- Step 3. ------------------------------------------------------------------
* Compute eigenvalues using Roe-averaged values
*/
#ifdef HYDRO
#ifdef ISOTHERMAL
esys_roe_iso_hyd(v1roe, v2roe, v3roe, ev, NULL, NULL);
#else
esys_roe_adb_hyd(v1roe, v2roe, v3roe, hroe, ev, NULL, NULL);
#endif /* ISOTHERMAL */
#endif /* HYDRO */
#ifdef MHD
#ifdef ISOTHERMAL
esys_roe_iso_mhd(droe,v1roe,v2roe,v3roe, Bxi,b2roe,b3roe,x,y,ev,NULL,NULL);
#else
esys_roe_adb_mhd(droe,v1roe,v2roe,v3roe,hroe,Bxi,b2roe,b3roe,x,y,ev,NULL,NULL);
#endif /* ISOTHERMAL */
#endif /* MHD */
/*--- Step 4. ------------------------------------------------------------------
* Compute the max and min wave speeds
*/
/* left state */
#ifdef ISOTHERMAL
asq = Iso_csound2;
#else
asq = Gamma*Wl.P/Wl.d;
#endif
#ifdef MHD
vaxsq = Bxi*Bxi/Wl.d;
ct2 = (Ul.By*Ul.By + Ul.Bz*Ul.Bz)/Wl.d;
#endif
qsq = vaxsq + ct2 + asq;
tmp = vaxsq + ct2 - asq;
cfsq = 0.5*(qsq + sqrt((double)(tmp*tmp + 4.0*asq*ct2)));
cfl = sqrt((double)cfsq);
/* right state */
#ifdef ISOTHERMAL
asq = Iso_csound2;
#else
asq = Gamma*Wr.P/Wr.d;
#endif
#ifdef MHD
vaxsq = Bxi*Bxi/Wr.d;
ct2 = (Ur.By*Ur.By + Ur.Bz*Ur.Bz)/Wr.d;
#endif
qsq = vaxsq + ct2 + asq;
tmp = vaxsq + ct2 - asq;
cfsq = 0.5*(qsq + sqrt((double)(tmp*tmp + 4.0*asq*ct2)));
cfr = sqrt((double)cfsq);
/* take max/min of Roe eigenvalues and L/R state wave speeds */
ar = MAX(ev[NWAVE-1],(Wr.Vx + cfr));
al = MIN(ev[0] ,(Wl.Vx - cfl));
bp = MAX(ar, 0.0);
bm = MIN(al, 0.0);
/*--- Step 5. ------------------------------------------------------------------
* Compute L/R fluxes along the line bm, bp
*/
Fl.d = Ul.Mx - bm*Ul.d;
Fr.d = Ur.Mx - bp*Ur.d;
Fl.Mx = Ul.Mx*(Wl.Vx - bm);
Fr.Mx = Ur.Mx*(Wr.Vx - bp);
Fl.My = Ul.My*(Wl.Vx - bm);
Fr.My = Ur.My*(Wr.Vx - bp);
Fl.Mz = Ul.Mz*(Wl.Vx - bm);
Fr.Mz = Ur.Mz*(Wr.Vx - bp);
#ifdef ISOTHERMAL
Fl.Mx += Wl.d*Iso_csound2;
Fr.Mx += Wr.d*Iso_csound2;
#else
Fl.Mx += Wl.P;
Fr.Mx += Wr.P;
Fl.E = Ul.E*(Wl.Vx - bm) + Wl.P*Wl.Vx;
Fr.E = Ur.E*(Wr.Vx - bp) + Wr.P*Wr.Vx;
#endif /* ISOTHERMAL */
#ifdef MHD
Fl.Mx -= 0.5*(Bxi*Bxi - SQR(Wl.By) - SQR(Wl.Bz));
Fr.Mx -= 0.5*(Bxi*Bxi - SQR(Wr.By) - SQR(Wr.Bz));
Fl.My -= Bxi*Wl.By;
Fr.My -= Bxi*Wr.By;
Fl.Mz -= Bxi*Wl.Bz;
Fr.Mz -= Bxi*Wr.Bz;
#ifndef ISOTHERMAL
Fl.E += (pbl*Wl.Vx - Bxi*(Bxi*Wl.Vx + Wl.By*Wl.Vy + Wl.Bz*Wl.Vz));
Fr.E += (pbr*Wr.Vx - Bxi*(Bxi*Wr.Vx + Wr.By*Wr.Vy + Wr.Bz*Wr.Vz));
#endif /* ISOTHERMAL */
Fl.By = Wl.By*(Wl.Vx - bm) - Bxi*Wl.Vy;
Fr.By = Wr.By*(Wr.Vx - bp) - Bxi*Wr.Vy;
Fl.Bz = Wl.Bz*(Wl.Vx - bm) - Bxi*Wl.Vz;
Fr.Bz = Wr.Bz*(Wr.Vx - bp) - Bxi*Wr.Vz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) {
Fl.s[n] = Fl.d*Wl.x[n];
Fr.s[n] = Fr.d*Wr.x[n];
}
#endif
/*--- Step 6. ------------------------------------------------------------------
* For supersonic flow, return the upwind flux.
*/
if(al >= 0.0){
*pFlux = Fl;
return;
}
if(ar <= 0.0){
*pFlux = Fr;
return;
}
/*--- Step 7. ------------------------------------------------------------------
* Compute the LW flux, start with the HLL mean state */
pFl = (Real *)&(Fl);
pFr = (Real *)&(Fr);
pUc = (Real *)&(Uc);
tmp = 1.0/(ar - al);
for (n=0; n<(NWAVE+NSCALARS); n++){
pUc[n] = (pFl[n] - pFr[n])*tmp;
}
/* Convert the HLL mean state to primitive variables */
Cons1D_to_Prim1D(&Uc,&Wc,&Bxi);
/* Compute the LW flux along the line dx/dt = 0 */
Fc.d = Uc.Mx;
Fc.Mx = Uc.Mx*Wc.Vx;
Fc.My = Uc.My*Wc.Vx;
Fc.Mz = Uc.Mz*Wc.Vx;
#ifdef ISOTHERMAL
Fc.Mx += Wc.d*Iso_csound2;
#else
Fc.Mx += Wc.P;
Fc.E = Uc.E*Wc.Vx + Wc.P*Wc.Vx;
#endif /* ISOTHERMAL */
#ifdef MHD
Fc.Mx -= 0.5*(Bxi*Bxi - SQR(Wc.By) - SQR(Wc.Bz));
Fc.My -= Bxi*Wc.By;
Fc.Mz -= Bxi*Wc.Bz;
#ifndef ISOTHERMAL
Fc.E += (pbl*Wc.Vx - Bxi*(Bxi*Wc.Vx + Wc.By*Wc.Vy + Wc.Bz*Wc.Vz));
#endif /* ISOTHERMAL */
Fc.By = Wc.By*Wc.Vx - Bxi*Wc.Vy;
Fc.Bz = Wc.Bz*Wc.Vx - Bxi*Wc.Vz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) {
Fc.s[n] = Fc.d*Wc.x[n];
}
#endif
/*--- Step 8. ------------------------------------------------------------------
* Compute the average of the Lax-Wendroff & HLLE flux
*/
pFl = (Real *)&(Fl);
pFc = (Real *)&(Fc);
pFr = (Real *)&(Fr);
pF = (Real *)pFlux;
tmp = 0.25*(bp + bm)/(bp - bm);
for (n=0; n<(NWAVE+NSCALARS); n++){
pF[n] = 0.5*pFc[n] + 0.25*(pFl[n] + pFr[n]) + (pFl[n] - pFr[n])*tmp;
}
return;
}
void integrate_1d_vl(DomainS *pD)
{
GridS *pG=(pD->Grid);
Real dtodx1=pG->dt/pG->dx1, hdtodx1=0.5*pG->dt/pG->dx1;
int i, is = pG->is, ie = pG->ie;
int js = pG->js;
int ks = pG->ks;
Real x1,x2,x3,phicl,phicr,phifc,phil,phir,phic;
#if (NSCALARS > 0)
int n;
#endif
#ifdef SELF_GRAVITY
Real gxl,gxr,flx_m1l,flx_m1r;
#endif
#ifdef STATIC_MESH_REFINEMENT
int ncg,npg,dim;
#endif
int il=is-(nghost-1), iu=ie+(nghost-1);
for (i=is-nghost; i<=ie+nghost; i++) {
Uhalf[i] = pG->U[ks][js][i];
}
/*=== STEP 1: Compute first-order fluxes at t^{n} in x1-direction ============*/
/* No source terms are needed since there is no temporal evolution */
/*--- Step 1a ------------------------------------------------------------------
* Load 1D vector of conserved variables;
* U1d = (d, M1, M2, M3, E, B2c, B3c, s[n])
*/
for (i=is-nghost; i<=ie+nghost; i++) {
U1d[i].d = pG->U[ks][js][i].d;
U1d[i].Mx = pG->U[ks][js][i].M1;
U1d[i].My = pG->U[ks][js][i].M2;
U1d[i].Mz = pG->U[ks][js][i].M3;
#ifndef BAROTROPIC
U1d[i].E = pG->U[ks][js][i].E;
#endif /* BAROTROPIC */
#ifdef MHD
U1d[i].By = pG->U[ks][js][i].B2c;
U1d[i].Bz = pG->U[ks][js][i].B3c;
Bxc[i] = pG->U[ks][js][i].B1c;
Bxi[i] = pG->B1i[ks][js][i];
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) U1d[i].s[n] = pG->U[ks][js][i].s[n];
#endif
}
/*--- Step 1b ------------------------------------------------------------------
* Compute first-order L/R states */
for (i=is-nghost; i<=ie+nghost; i++) {
W[i] = Cons1D_to_Prim1D(&U1d[i],&Bxc[i]);
}
for (i=il; i<=ie+nghost; i++) {
Wl[i] = W[i-1];
Wr[i] = W[i ];
Ul[i] = U1d[i-1];
Ur[i] = U1d[i ];
}
/*--- Step 1c ------------------------------------------------------------------
* No source terms needed */
/*--- Step 1d ------------------------------------------------------------------
* Compute flux in x1-direction */
for (i=il; i<=ie+nghost; i++) {
fluxes(Ul[i],Ur[i],Wl[i],Wr[i],Bxi[i],&x1Flux[i]);
}
/*=== STEPS 2-4: Not needed in 1D ===*/
/*=== STEP 5: Update cell-centered variables to half-timestep ================*/
/*--- Step 5a ------------------------------------------------------------------
* Update cell-centered variables (including B2c and B3c) to half-timestep
*/
for (i=il; i<=iu; i++) {
Uhalf[i].d -= hdtodx1*(x1Flux[i+1].d - x1Flux[i].d );
Uhalf[i].M1 -= hdtodx1*(x1Flux[i+1].Mx - x1Flux[i].Mx);
Uhalf[i].M2 -= hdtodx1*(x1Flux[i+1].My - x1Flux[i].My);
Uhalf[i].M3 -= hdtodx1*(x1Flux[i+1].Mz - x1Flux[i].Mz);
#ifndef BAROTROPIC
Uhalf[i].E -= hdtodx1*(x1Flux[i+1].E - x1Flux[i].E );
#endif /* BAROTROPIC */
#ifdef MHD
Uhalf[i].B2c -= hdtodx1*(x1Flux[i+1].By - x1Flux[i].By);
Uhalf[i].B3c -= hdtodx1*(x1Flux[i+1].Bz - x1Flux[i].Bz);
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
Uhalf[i].s[n] -= hdtodx1*(x1Flux[i+1].s[n] - x1Flux[i].s[n]);
#endif
}
/*=== STEP 6: Add source terms to predict values at half-timestep ============*/
/*--- Step 6a ------------------------------------------------------------------
* Add source terms from a static gravitational potential for 0.5*dt to predict
* step. To improve conservation of total energy, we average the energy
* source term computed at cell faces.
* S_{M} = -(\rho) Grad(Phi); S_{E} = -(\rho v) Grad{Phi}
*/
if (StaticGravPot != NULL){
for (i=il; i<=iu; i++) {
cc_pos(pG,i,js,ks,&x1,&x2,&x3);
phic = (*StaticGravPot)((x1 ),x2,x3);
phir = (*StaticGravPot)((x1+0.5*pG->dx1),x2,x3);
phil = (*StaticGravPot)((x1-0.5*pG->dx1),x2,x3);
Uhalf[i].M1 -= hdtodx1*pG->U[ks][js][i].d*(phir-phil);
#ifndef BAROTROPIC
Uhalf[i].E -= hdtodx1*(x1Flux[i ].d*(phic - phil) +
x1Flux[i+1].d*(phir - phic));
#endif
}
}
Real accl, accc1, accr;
if(1) {
accc = pG->AccX[i];
accl = pG->AccX[i-1];
accr = pG->AccX[i+1];
}
/*--- Step 6b ------------------------------------------------------------------
* Add source terms for self gravity for 0.5*dt to predict step.
* S_{M} = -(\rho) Grad(Phi); S_{E} = -(\rho v) Grad{Phi}
*/
#ifdef SELF_GRAVITY
for (i=il; i<=iu; i++) {
phic = pG->Phi[ks][js][i];
phir = 0.5*(pG->Phi[ks][js][i] + pG->Phi[ks][js][i+1]);
phil = 0.5*(pG->Phi[ks][js][i] + pG->Phi[ks][js][i-1]);
Uhalf[i].M1 -= hdtodx1*pG->U[ks][js][i].d*(phir-phil);
#ifndef BAROTROPIC
Uhalf[i].E -= hdtodx1*(x1Flux[i ].d*(phic - phil) +
x1Flux[i+1].d*(phir - phic));
#endif
}
#endif /* SELF_GRAVITY */
/*=== STEP 7: Compute second-order L/R x1-interface states ===================*/
/*--- Step 7a ------------------------------------------------------------------
* Load 1D vector of conserved variables;
* U = (d, M1, M2, M3, E, B2c, B3c, s[n])
*/
for (i=il; i<=iu; i++) {
U1d[i].d = Uhalf[i].d;
U1d[i].Mx = Uhalf[i].M1;
U1d[i].My = Uhalf[i].M2;
U1d[i].Mz = Uhalf[i].M3;
#ifndef BAROTROPIC
U1d[i].E = Uhalf[i].E;
#endif /* BAROTROPIC */
#ifdef MHD
U1d[i].By = Uhalf[i].B2c;
U1d[i].Bz = Uhalf[i].B3c;
Bxc[i] = Uhalf[i].B1c;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) U1d[i].s[n] = Uhalf[i].s[n];
#endif /* NSCALARS */
}
/*--- Step 7b ------------------------------------------------------------------
* Compute L/R states on x1-interfaces, store into arrays
*/
for (i=il; i<=iu; i++) {
W[i] = Cons1D_to_Prim1D(&U1d[i],&Bxc[i]);
}
lr_states(pG,W,Bxc,pG->dt,pG->dx1,is,ie,Wl,Wr,1);
for (i=is; i<=ie+1; i++) {
Wl_x1Face[i] = Wl[i];
Wr_x1Face[i] = Wr[i];
}
/*=== STEPS 8-9: Not needed in 1D ===*/
/*=== STEP 10: Compute x1-Flux ===============================================*/
/*--- Step 10b -----------------------------------------------------------------
* Compute second-order fluxes in x1-direction
*/
for (i=is; i<=ie+1; i++) {
Ul[i] = Prim1D_to_Cons1D(&Wl_x1Face[i],&Bxi[i]);
Ur[i] = Prim1D_to_Cons1D(&Wr_x1Face[i],&Bxi[i]);
fluxes(Ul[i],Ur[i],Wl_x1Face[i],Wr_x1Face[i],Bxi[i],&x1Flux[i]);
}
/*=== STEP 11: Not needed in 1D ===*/
/*=== STEP 12: Add source terms for a full timestep using n+1/2 states =======*/
/*--- Step 12a -----------------------------------------------------------------
* Add gravitational source terms due to a Static Potential
* To improve conservation of total energy, we average the energy
* source term computed at cell faces.
* S_{M} = -(\rho)^{n+1/2} Grad(Phi); S_{E} = -(\rho v)^{n+1/2} Grad{Phi}
*/
if (StaticGravPot != NULL){
for (i=is; i<=ie; i++) {
cc_pos(pG,i,js,ks,&x1,&x2,&x3);
phic = (*StaticGravPot)((x1 ),x2,x3);
phir = (*StaticGravPot)((x1+0.5*pG->dx1),x2,x3);
phil = (*StaticGravPot)((x1-0.5*pG->dx1),x2,x3);
pG->U[ks][js][i].M1 -= dtodx1*Uhalf[i].d*(phir-phil);
#ifndef BAROTROPIC
pG->U[ks][js][i].E -= dtodx1*(x1Flux[i ].d*(phic - phil) +
x1Flux[i+1].d*(phir - phic));
#endif
}
}
/*--- Step 12b -----------------------------------------------------------------
* Add gravitational source terms for self-gravity.
* A flux correction using Phi^{n+1} in the main loop is required to make
* the source terms 2nd order: see selfg_flux_correction().
*/
#ifdef SELF_GRAVITY
/* Add fluxes and source terms due to (d/dx1) terms */
for (i=is; i<=ie; i++){
phic = pG->Phi[ks][js][i];
phil = 0.5*(pG->Phi[ks][js][i-1] + pG->Phi[ks][js][i ]);
phir = 0.5*(pG->Phi[ks][js][i ] + pG->Phi[ks][js][i+1]);
/* gx, gy and gz centered at L and R x1-faces */
gxl = (pG->Phi[ks][js][i-1] - pG->Phi[ks][js][i ])/(pG->dx1);
gxr = (pG->Phi[ks][js][i ] - pG->Phi[ks][js][i+1])/(pG->dx1);
/* momentum fluxes in x1. 2nd term is needed only if Jean's swindle used */
flx_m1l = 0.5*(gxl*gxl)/four_pi_G + grav_mean_rho*phil;
flx_m1r = 0.5*(gxr*gxr)/four_pi_G + grav_mean_rho*phir;
/* Update momenta and energy with d/dx1 terms */
pG->U[ks][js][i].M1 -= dtodx1*(flx_m1r - flx_m1l);
#ifndef BAROTROPIC
pG->U[ks][js][i].E -= dtodx1*(x1Flux[i ].d*(phic - phil) +
x1Flux[i+1].d*(phir - phic));
#endif /* BAROTROPIC */
}
/* Save mass fluxes in Grid structure for source term correction in main loop */
for (i=is; i<=ie+1; i++) {
pG->x1MassFlux[ks][js][i] = x1Flux[i].d;
}
#endif /* SELF_GRAVITY */
/*=== STEP 13: Update cell-centered values for a full timestep ===============*/
/*--- Step 13a -----------------------------------------------------------------
* Update cell-centered variables in pG (including B2c and B3c) using x1-Fluxes
*/
for (i=is; i<=ie; i++) {
pG->U[ks][js][i].d -= dtodx1*(x1Flux[i+1].d - x1Flux[i].d );
pG->U[ks][js][i].M1 -= dtodx1*(x1Flux[i+1].Mx - x1Flux[i].Mx);
pG->U[ks][js][i].M2 -= dtodx1*(x1Flux[i+1].My - x1Flux[i].My);
pG->U[ks][js][i].M3 -= dtodx1*(x1Flux[i+1].Mz - x1Flux[i].Mz);
#ifndef BAROTROPIC
pG->U[ks][js][i].E -= dtodx1*(x1Flux[i+1].E - x1Flux[i].E );
#endif /* BAROTROPIC */
#ifdef MHD
pG->U[ks][js][i].B2c -= dtodx1*(x1Flux[i+1].By - x1Flux[i].By);
pG->U[ks][js][i].B3c -= dtodx1*(x1Flux[i+1].Bz - x1Flux[i].Bz);
/* For consistency, set B2i and B3i to cell-centered values. */
pG->B2i[ks][js][i] = pG->U[ks][js][i].B2c;
pG->B3i[ks][js][i] = pG->U[ks][js][i].B3c;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->U[ks][js][i].s[n] -= dtodx1*(x1Flux[i+1].s[n] - x1Flux[i].s[n]);
#endif
}
#ifdef STATIC_MESH_REFINEMENT
/*--- Step 13d -----------------------------------------------------------------
* With SMR, store fluxes at boundaries of child and parent grids.
*/
/* x1-boundaries of child Grids (interior to THIS Grid) */
for (ncg=0; ncg<pG->NCGrid; ncg++) {
for (dim=0; dim<2; dim++){
if (pG->CGrid[ncg].myFlx[dim] != NULL) {
if (dim==0) i = pG->CGrid[ncg].ijks[0];
if (dim==1) i = pG->CGrid[ncg].ijke[0] + 1;
pG->CGrid[ncg].myFlx[dim][ks][js].d = x1Flux[i].d;
pG->CGrid[ncg].myFlx[dim][ks][js].M1 = x1Flux[i].Mx;
pG->CGrid[ncg].myFlx[dim][ks][js].M2 = x1Flux[i].My;
pG->CGrid[ncg].myFlx[dim][ks][js].M3 = x1Flux[i].Mz;
#ifndef BAROTROPIC
pG->CGrid[ncg].myFlx[dim][ks][js].E = x1Flux[i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->CGrid[ncg].myFlx[dim][ks][js].B1c = 0.0;
pG->CGrid[ncg].myFlx[dim][ks][js].B2c = x1Flux[i].By;
pG->CGrid[ncg].myFlx[dim][ks][js].B3c = x1Flux[i].Bz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->CGrid[ncg].myFlx[dim][ks][js].s[n] = x1Flux[i].s[n];
#endif
}
}
}
/* x1-boundaries of parent Grids (at boundaries of THIS Grid) */
for (npg=0; npg<pG->NPGrid; npg++) {
for (dim=0; dim<2; dim++){
if (pG->PGrid[npg].myFlx[dim] != NULL) {
if (dim==0) i = pG->PGrid[npg].ijks[0];
if (dim==1) i = pG->PGrid[npg].ijke[0] + 1;
pG->PGrid[npg].myFlx[dim][ks][js].d = x1Flux[i].d;
pG->PGrid[npg].myFlx[dim][ks][js].M1 = x1Flux[i].Mx;
pG->PGrid[npg].myFlx[dim][ks][js].M2 = x1Flux[i].My;
pG->PGrid[npg].myFlx[dim][ks][js].M3 = x1Flux[i].Mz;
#ifndef BAROTROPIC
pG->PGrid[npg].myFlx[dim][ks][js].E = x1Flux[i].E;
#endif /* BAROTROPIC */
#ifdef MHD
pG->PGrid[npg].myFlx[dim][ks][js].B1c = 0.0;
pG->PGrid[npg].myFlx[dim][ks][js].B2c = x1Flux[i].By;
pG->PGrid[npg].myFlx[dim][ks][js].B3c = x1Flux[i].Bz;
#endif /* MHD */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++)
pG->PGrid[npg].myFlx[dim][ks][js].s[n] = x1Flux[i].s[n];
#endif
}
}
}
#endif /* STATIC_MESH_REFINEMENT */
return;
}
//#ifdef BKG
void fluxes(const Cons1DS Ul, const Cons1DS Ur,
const Prim1DS Wl, const Prim1DS Wr,
const Real Bxi, const Real Bxib, Cons1DS *pFlux)
//#else
//void fluxes(const Cons1DS Ul, const Cons1DS Ur,
// const Prim1DS Wl, const Prim1DS Wr,
// const Real Bxi, Cons1DS *pFlux)
//#endif
{
Real pbl=0.0;
Prim1DS W;
Cons1DS Fc; /*flux at cell centre the l values are passed in as values at cell centres*/
/*--- Step 1. ------------------------------------------------------------------
* Convert left- states in conserved to primitive variables.
*/
//#ifdef BKG
W = Cons1D_to_Prim1D(&Ul,&Bxi, &Bxib);
//#else
// pbl = Cons1D_to_Prim1D(&Ul,&Wl,&Bxi); //pbl is background energy
//#endif
/*--- Step 2. ------------------------------------------------------------------
* Compute L fluxes
*/
Fc.d = Ul.Mx; /*computed using (rho+rhob)*velocity */
Fc.Mx = Ul.Mx*Wl.Vx;
Fc.My = Ul.My*Wl.Vx;
Fc.Mz = Ul.Mz*Wl.Vx;
#ifdef ISOTHERMAL
Fc.Mx += (Wl.d+Wl.db)*Iso_csound2;
#else
Fc.Mx += Wl.P;
//Fc.E = (Ul.E + Ul.Eb+ Wl.P)*Wl.Vx;
Fc.E = (Ul.Eb+ Wl.P)*Wl.Vx;
#endif /* ISOTHERMAL */
#ifdef MHD
//Fc.Mx += 0.5*(Bxi*Bxi + SQR(Wl.By) + SQR(Wl.Bz))+(Bxi*Bxib+Wl.By*Wl.Byb+Wl.Bz*Wl.Bzb);/*thermal pressure plus mag pressure time*/
//Fc.Mx += -(Bxi*Bxi + SQR(Wl.By) + SQR(Wl.Bz));
//Fc.Mx -= (Bxi*Bxib+Bxi*Wl.Byb+Bxi*Wl.Bzb)+(Bxib*Bxi+Bxib*Wl.By+Bxib*Wl.Bz);
Fc.Mx -= (Bxi*Bxib+Bxib*Bxi+Bxi*Bxi);
//Fc.My -= (Wl.By*Bxib+Wl.By*Wl.Bzb+Bxi*Wl.Byb+Wl.Bz*Wl.Byb )-(Wl.By*Bxi+Wl.By*Wl.Bz);
Fc.My -= (Wl.By*Bxib+Bxi*Wl.Byb+Wl.By*Bxi);
//Fc.Mz -= (Wl.Bz*Bxib+Wl.Bz*Wl.Byb+Bxi*Wl.Bzb+Wl.By*Wl.Bzb )-(Wl.Bz*Bxi+Wl.Bz*Wl.By);
Fc.Mz -= (Wl.Bz*Bxib+Bxi*Wl.Bzb+Wl.Bz*Bxi );
#ifndef ISOTHERMAL
Fc.E += (pbl*Wl.Vx - Bxi*(Bxi*Wl.Vx + Wl.By*Wl.Vy + Wl.Bz*Wl.Vz)- Bxib*(Bxi*Wl.Vx + Wl.By*Wl.Vy + Wl.Bz*Wl.Vz)- Bxi*(Bxib*Wl.Vx + Wl.Byb*Wl.Vy + Wl.Bzb*Wl.Vz));
#endif /* ISOTHERMAL */
/*Fc.By = Wl.By*Wl.Vx - Bxi*Wl.Vy;
Fc.Bx = Wl.Bxib*Wl.Vx - Bxi*Wl.Vx;*/
Fc.By = Wl.Vx*(Wl.Byb)-Wl.Vy*(Bxi+Bxib);
Fc.Bz = Wl.Vx*(Wl.Bzb)-Wl.Vz*(Bxi+Bxib);
#endif /* MHD */
/* Fluxes of passively advected scalars, computed from density flux */
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) {
Fc.s[n] = Fc.d*Wl.r[n];
}
#endif
*pFlux = Fc;
return;
}
