void problem_read_restart(MeshS *pM, FILE *fp)
{
int nl,nd;
if (pM->Nx[2] == 1) {
StaticGravPot = grav_pot2;
for (nl=0; nl<(pM->NLevels); nl++){
for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){
bvals_mhd_fun(&(pM->Domain[nl][nd]), left_x2, reflect_ix2);
bvals_mhd_fun(&(pM->Domain[nl][nd]), right_x2, reflect_ox2);
}
}
}
if (pM->Nx[2] > 1) {
StaticGravPot = grav_pot3;
for (nl=0; nl<(pM->NLevels); nl++){
for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){
bvals_mhd_fun(&(pM->Domain[nl][nd]), left_x3, reflect_ix3);
bvals_mhd_fun(&(pM->Domain[nl][nd]), right_x3, reflect_ox3);
}
}
}
return;
}
void problem(DomainS *pDomain)
{
GridS *pGrid = pDomain->Grid;
int i=0,j=0;
int is,ie,js,je,ks;
Real d0,e0,u0,v0,x1_shock,x1,x2,x3;
is = pGrid->is;
ie = pGrid->ie;
js = pGrid->js;
je = pGrid->je;
ks = pGrid->ks;
if (pGrid->Nx[0] == 1 || pGrid->Nx[1] == 1) {
ath_error("[dmr]: this test only works with Nx1 & Nx2 > 1\n");
}
if (pGrid->Nx[2] > 1) {
ath_error("[dmr]: this test only works for 2D problems, with Nx3=1\n");
}
/* Initialize shock using parameters defined in Woodward & Colella */
d0 = 8.0;
e0 = 291.25;
u0 = 8.25*sqrt(3.0)/2.0;
v0 = -8.25*0.5;
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
cc_pos(pGrid,i,j,ks,&x1,&x2,&x3);
x1_shock = 0.1666666666 + x2/sqrt((double)3.0);
/* upstream conditions */
pGrid->U[ks][j][i].d = 1.4;
pGrid->U[ks][j][i].E = 2.5;
pGrid->U[ks][j][i].M1 = 0.0;
pGrid->U[ks][j][i].M2 = 0.0;
/* downstream conditions */
if (x1 < x1_shock) {
pGrid->U[ks][j][i].d = d0;
pGrid->U[ks][j][i].E = e0 + 0.5*d0*(u0*u0+v0*v0);
pGrid->U[ks][j][i].M1 = d0*u0;
pGrid->U[ks][j][i].M2 = d0*v0;
}
}
}
/* Set boundary value function pointers */
if (pDomain->Disp[0] == 0) bvals_mhd_fun(pDomain, left_x1, dmrbv_iib);
if (pDomain->Disp[1] == 0) bvals_mhd_fun(pDomain, left_x2, dmrbv_ijb);
if (pDomain->MaxX[1] == pDomain->RootMaxX[1])
bvals_mhd_fun(pDomain, right_x2, dmrbv_ojb);
}
void problem_read_restart(MeshS *pM, FILE *fp)
{
int nl,nd,BCFlag_ix1,BCFlag_ox1;
/* Read Omega, and with viscosity and/or resistivity, read eta_Ohm and nu_V */
#ifdef SHEARING_BOX
Omega_0 = par_getd_def("problem","omega",1.0e-3);
qshear = par_getd_def("problem","qshear",1.5);
#endif
Mp = par_getd_def("problem","Mplanet",0.0);
Xplanet = par_getd_def("problem","Xplanet",0.0);
Yplanet = par_getd_def("problem","Yplanet",0.0);
Zplanet = par_getd_def("problem","Zplanet",0.0);
Rsoft = par_getd_def("problem","Rsoft",0.1);
ramp_time = 0.0;
insert_time = par_getd_def("problem","insert_time",0.0);
#ifdef VISCOSITY
nu_iso = par_getd_def("problem","nu_iso",0.0);
nu_aniso = par_getd_def("problem","nu_aniso",0.0);
#endif
/* enroll gravitational potential of planet & shearing-box potential fns */
StaticGravPot = PlanetPot;
ShearingBoxPot = UnstratifiedDisk;
/* enroll new history variables */
dump_history_enroll(hst_rho_Vx_dVy, "<rho Vx dVy>");
dump_history_enroll(hst_rho_dVy2, "<rho dVy^2>");
#ifdef ADIABATIC
dump_history_enroll(hst_E_total, "<E + rho Phi>");
#endif
BCFlag_ix1 = par_geti_def("domain1","bc_ix1",0);
BCFlag_ox1 = par_geti_def("domain1","bc_ox1",0);
for (nl=0; nl<(pM->NLevels); nl++){
for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){
if (pM->Domain[nl][nd].Disp[0] == 0 && BCFlag_ix1 != 4)
bvals_mhd_fun(&(pM->Domain[nl][nd]), left_x1, constant_iib);
if (pM->Domain[nl][nd].MaxX[0] == pM->Domain[nl][nd].RootMaxX[0]
&& BCFlag_ox1 != 4)
bvals_mhd_fun(&(pM->Domain[nl][nd]), right_x1, constant_oib);
}
}
return;
}
void problem_read_restart(MeshS *pM, FILE *fp)
{
R0 = par_getd_def("problem", "R0",2.0);
Hbc = par_getd_def("problem","Hbc",1);
Mbc = par_getd_def("problem","Mbc",1);
StaticGravPot = grav_pot;
x1GravAcc = grav_acc;
bvals_mhd_fun(&(pM->Domain[0][0]),left_x1,disk_ir);
bvals_mhd_fun(&(pM->Domain[0][0]),right_x1,disk_or);
#ifdef FARGO
OrbitalProfile = Omega;
ShearProfile = Shear;
#endif
// Enroll history functions
//
#ifdef MHD
dump_history_enroll(Br, "<Br>");
dump_history_enroll(Bp, "<Bp>");
dump_history_enroll(Bz, "<Bz>");
dump_history_enroll(Mrp, "<Mrp>");
dump_history_enroll(Trp, "<Trp>");
dump_history_enroll(MdotR1, "<MdotR1>");
dump_history_enroll(MdotR2, "<MdotR2>");
dump_history_enroll(MdotR3, "<MdotR3>");
dump_history_enroll(MdotR4, "<MdotR4>");
dump_history_enroll(Msub, "<Msub>");
dump_history_enroll(Mrpsub, "<Mrpsub>");
dump_history_enroll(Bpsub, "<Bpsub>");
dump_history_enroll(Bzsub, "<Bzsub>");
dump_history_enroll(Pbsub, "<Pbsub>");
#endif
return;
}
void problem(DomainS *pDomain)
{
GridS *pGrid = pDomain->Grid;
int is = pGrid->is, ie = pGrid->ie;
int js = pGrid->js, je = pGrid->je;
int ks = pGrid->ks, ke = pGrid->ke;
int i,j,k,BCFlag;
Real x1,x2,x3;
Real den = 1.0, pres = 1.0e-6;
static int frst=1; /* flag so new history variables enrolled only once */
#ifdef SHEARING_BOX
/* specify xy (r-phi) plane */
ShBoxCoord = xy;
#endif
/* Read problem parameters. Note Omega_0 set to 10^{-3} by default */
#ifdef SHEARING_BOX
Omega_0 = par_getd_def("problem","omega",1.0e-3);
qshear = par_getd_def("problem","qshear",1.5);
#endif
Mp = par_getd_def("problem","Mplanet",0.0);
Xplanet = par_getd_def("problem","Xplanet",0.0);
Yplanet = par_getd_def("problem","Yplanet",0.0);
Zplanet = par_getd_def("problem","Zplanet",0.0);
Rsoft = par_getd_def("problem","Rsoft",0.1);
ramp_time = 0.0;
insert_time = par_getd_def("problem","insert_time",0.0);
/* Compute field strength based on beta. */
#ifdef ISOTHERMAL
pres = Iso_csound2;
#endif
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
cc_pos(pGrid,i,j,k,&x1,&x2,&x3);
/* Initialize d, M, and P. With FARGO do not initialize the background shear */
pGrid->U[k][j][i].d = den;
// pGrid->U[k][j][i].d = 1.0+.5*(1-.02)*(tanh((x1-10.0)/3.5)-tanh((x1+10.0)/3.5))-.5*1.1*(tanh((x1-10.0)/15.0)-tanh((x1+10.0)/15.0));
pGrid->U[k][j][i].M1 = 0.0;
pGrid->U[k][j][i].M2 = 0.0;
#ifdef SHEARING_BOX
#ifndef FARGO
pGrid->U[k][j][i].M2 -= den*(qshear*Omega_0*x1);
#endif
#endif
pGrid->U[k][j][i].M3 = 0.0;
#ifdef ADIABATIC
pGrid->U[k][j][i].E = pres/Gamma_1
+ 0.5*(SQR(pGrid->U[k][j][i].M1) + SQR(pGrid->U[k][j][i].M2)
+ SQR(pGrid->U[k][j][i].M3))/den;
#endif
}
}}
/* enroll gravitational potential of planet & shearing-box potential fns */
StaticGravPot = PlanetPot;
ShearingBoxPot = UnstratifiedDisk;
/* enroll new history variables, only once */
if (frst == 1) {
dump_history_enroll(hst_rho_Vx_dVy, "<rho Vx dVy>");
dump_history_enroll(hst_rho_dVy2, "<rho dVy^2>");
#ifdef ADIABATIC
dump_history_enroll(hst_E_total, "<E + rho Phi>");
#endif
frst = 0;
}
/* With viscosity and/or resistivity, read diffusion coeffs */
#ifdef VISCOSITY
nu_iso = par_getd_def("problem","nu_iso",0.0);
nu_aniso = par_getd_def("problem","nu_aniso",0.0);
#endif
/* Enroll outflow BCs if perdiodic BCs NOT selected. This assumes the root
* level grid is specified by the <domain1> block in the input file */
BCFlag = par_geti_def("domain1","bc_ix1",0);
if (BCFlag != 4) {
if (pDomain->Disp[0] == 0) bvals_mhd_fun(pDomain, left_x1, constant_iib);
}
BCFlag = par_geti_def("domain1","bc_ox1",0);
if (BCFlag != 4) {
if (pDomain->MaxX[0] == pDomain->RootMaxX[0])
bvals_mhd_fun(pDomain, right_x1, constant_oib);
}
return;
}
void problem(DomainS *pDomain)
{
GridS *pGrid=(pDomain->Grid);
int i, is = pGrid->is, ie = pGrid->ie;
int j, js = pGrid->js, je = pGrid->je;
int k, ks = pGrid->ks, ke = pGrid->ke;
Real x1,x2,x3;
Real rho, p, prat, density, pressure, pi, vel, n, amp, lx, ly;
dt_line_integral_output = par_getd("problem", "dt_line_integral");
/* size of the domain (in physical coordinates) */
lx = pDomain->RootMaxX[0] - pDomain->RootMinX[0];
ly = pDomain->RootMaxX[1] - pDomain->RootMinX[1];
p = 1.0;
/* if prat=0.8, vx = -1.8965 (t&e find other vals)*/
pi=3.14159;
n = 2; /*Oscillations of perturbation*/
amp = 0.05 ; /* Size of perturbation ~ 0.05 */
/* setup uniform ambient medium with spherical over-pressured region */
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
cc_pos(pGrid,i,j,k,&x1,&x2,&x3);
if (x1 > amp*sin(n*pi*x2/ly)) {
pressure = 0.1175;
} else {
pressure = 1;
}
if (x1 > amp*sin(n*pi*x2/ly)) {
vel= -1.96071;
} else {
vel= -0.7;
}
if (x1 > amp*sin(n*pi*x2/ly)) {
density= 0.357013;
} else {
density= 1;
}
pGrid->U[0][j][i].d = density;
pGrid->U[0][j][i].M1 = density*vel;
pGrid->U[0][j][i].M2 = 0.0;
#ifndef ISOTHERMAL
pGrid->U[0][j][i].E = pressure/Gamma_1 + (SQR(pGrid->U[0][j][i].M1) + SQR(pGrid->U[0][j][i].M2))/(2.0*(pGrid->U[0][j][i].d));
#endif
}
}
}
/* Adding history dumps*/
void dump_history_enroll(const ConsFun_t pfun, const char *label);
dump_history_enroll(pleft, "<pbvals>");
dump_history_enroll(vyintegral, "<vyintegral>");
/* enroll special functions */
bvals_mhd_fun(pDomain,left_x1, bc_ix1);
return;
}
/* problem: */
void problem(DomainS *pDomain)
{
GridS *pG = pDomain->Grid;
int i,j,k,n,converged;
int is,ie,il,iu,js,je,jl,ju,ks,ke,kl,ku;
int nx1, nx2, nx3;
Real x1, x2, x3;
Real a,b,c,d,xmin,xmax,ymin,ymax;
Real x,y,xslow,yslow,xfast,yfast;
Real R0,R1,R2,rho,Mdot,K,Omega,Pgas,beta,vR,BR,vphi,Bphi;
ConsS *Wind=NULL;
Real *pU=NULL,*pUl=NULL,*pUr=NULL;
Real lsf,rsf;
is = pG->is; ie = pG->ie; nx1 = ie-is+1;
js = pG->js; je = pG->je; nx2 = je-js+1;
ks = pG->ks; ke = pG->ke; nx3 = ke-ks+1;
il = is-nghost*(nx1>1); iu = ie+nghost*(nx1>1); nx1 = iu-il+1;
jl = js-nghost*(nx2>1); ju = je+nghost*(nx2>1); nx2 = ju-jl+1;
kl = ks-nghost*(nx3>1); ku = ke+nghost*(nx3>1); nx3 = ku-kl+1;
#ifndef CYLINDRICAL
ath_error("[cylwindrotb]: This problem only works in cylindrical!\n");
#endif
#ifndef MHD
ath_error("[cylwindrotb]: This problem only works in MHD!\n");
#endif
if (nx1==1) {
ath_error("[cylwindrotb]: Only R can be used in 1D!\n");
}
else if (nx2==1 && nx3>1) {
ath_error("[cylwindrotb]: Only (R,phi) can be used in 2D!\n");
}
/* Allocate memory for wind solution */
if ((Wind = (ConsS*)calloc_1d_array(nx1+1,sizeof(ConsS))) == NULL)
ath_error("[cylwindrotb]: Error allocating memory\n");
/* Allocate memory for grid solution */
if ((RootSoln = (ConsS***)calloc_3d_array(nx3,nx2,nx1,sizeof(ConsS))) == NULL)
ath_error("[cylwindrotb]: Error allocating memory\n");
theta = par_getd("problem","theta");
omega = par_getd("problem","omega");
vz = par_getd("problem","vz");
/* This numerical solution was obtained from MATLAB.
* Ideally, we replace this with a nonlinear solver... */
xslow = 0.5243264128;
yslow = 2.4985859152;
xfast = 1.6383327831;
yfast = 0.5373957134;
E = 7.8744739104;
eta = 2.3608500383;
xmin = par_getd("domain1","x1min")/R_A;
xmax = par_getd("domain1","x1max")/R_A;
ymin = 0.45/rho_A;
ymax = 2.6/rho_A;
printf("theta = %f,\t omega = %f,\t eta = %f,\t E = %f\n", theta,omega,eta,E);
printf("xslow = %f,\t yslow = %f,\t xfast = %f,\t yfast = %f\n", xslow,yslow,xfast,yfast);
printf("xmin = %f,\t ymin = %f,\t xmax = %f,\t ymax = %f\n", xmin,ymin,xmax,ymax);
/* Calculate the 1D wind solution at cell-interfaces */
for (i=il; i<=iu+1; i++) {
memset(&(Wind[i]),0.0,sizeof(ConsS));
cc_pos(pG,i,js,ks,&x1,&x2,&x3);
/* Want the solution at R-interfaces */
R0 = x1 - 0.5*pG->dx1;
x = R0/R_A;
/* Look for a sign change interval */
if (x < xslow) {
sign_change(myfunc,yslow,10.0*ymax,x,&a,&b);
sign_change(myfunc,b,10.0*ymax,x,&a,&b);
} else if (x < 1.0) {
sign_change(myfunc,1.0+TINY_NUMBER,yslow,x,&a,&b);
} else if (x < xfast) {
sign_change(myfunc,yfast,1.0-TINY_NUMBER,x,&a,&b);
if (!sign_change(myfunc,b,1.0-TINY_NUMBER,x,&a,&b)) {
a = yfast;
b = 1.0-TINY_NUMBER;
}
} else {
sign_change(myfunc,0.5*ymin,yfast,x,&a,&b);
}
/* Use bisection to find the root */
converged = bisection(myfunc,a,b,x,&y);
if(!converged) {
ath_error("[cylwindrotb]: Bisection did not converge!\n");
}
/* Construct the solution */
rho = rho_A*y;
Mdot = sqrt(R_A*SQR(rho_A)*GM*eta);
Omega = sqrt((GM*omega)/pow(R_A,3));
K = (GM*theta)/(Gamma*pow(rho_A,Gamma_1)*R_A);
Pgas = K*pow(rho,Gamma);
vR = Mdot/(R0*rho);
beta = sqrt(1.0/rho_A);
BR = beta*rho*vR;
vphi = R0*Omega*(1.0/SQR(x)-y)/(1.0-y);
Bphi = beta*rho*(vphi-R0*Omega);
Wind[i].d = rho;
Wind[i].M1 = rho*vR;
Wind[i].M2 = rho*vphi;
Wind[i].M3 = rho*vz;
Wind[i].B1c = BR;
Wind[i].B2c = Bphi;
Wind[i].B3c = 0.0;
Wind[i].E = Pgas/Gamma_1
+ 0.5*(SQR(Wind[i].B1c) + SQR(Wind[i].B2c) + SQR(Wind[i].B3c))
+ 0.5*(SQR(Wind[i].M1 ) + SQR(Wind[i].M2 ) + SQR(Wind[i].M3 ))/Wind[i].d;
}
/* Average the wind solution across the zone for cc variables */
for (i=il; i<=iu; i++) {
memset(&(pG->U[ks][js][i]),0.0,sizeof(ConsS));
cc_pos(pG,i,js,ks,&x1,&x2,&x3);
lsf = (x1 - 0.5*pG->dx1)/x1;
rsf = (x1 + 0.5*pG->dx1)/x1;
pU = (Real*)&(pG->U[ks][js][i]);
pUl = (Real*)&(Wind[i]);
pUr = (Real*)&(Wind[i+1]);
for (n=0; n<NWAVE; n++) {
pU[n] = 0.5*(lsf*pUl[n] + rsf*pUr[n]);
}
pG->B1i[ks][js][i] = Wind[i].B1c;
pG->B2i[ks][js][i] = 0.5*(lsf*Wind[i].B2c + rsf*Wind[i+1].B2c);
pG->B3i[ks][js][i] = 0.5*(lsf*Wind[i].B3c + rsf*Wind[i+1].B3c);
}
/* Copy 1D solution across the grid and save */
for (k=kl; k<=ku; k++) {
for (j=jl; j<=ju; j++) {
for (i=il; i<=iu; i++) {
pG->U[k][j][i] = pG->U[ks][js][i];
pG->B1i[k][j][i] = pG->B1i[ks][js][i];
pG->B2i[k][j][i] = pG->B2i[ks][js][i];
pG->B3i[k][j][i] = pG->B3i[ks][js][i];
RootSoln[k][j][i] = pG->U[ks][js][i];
}
}
}
StaticGravPot = grav_pot;
bvals_mhd_fun(pDomain,left_x1,do_nothing_bc);
bvals_mhd_fun(pDomain,right_x1,do_nothing_bc);
free_1d_array((void *)Wind);
return;
}
void problem(DomainS *pDomain)
{
GridS *pGrid = pDomain->Grid;
int i=0,j=0,k=0;
int is,ie,js,je,ks,ke,iprob;
long int iseed = -1;
Real amp,x1,x2,x3,lx,ly,lz,rhoh,L_rot,fact;
#ifdef MHD
Real b0,angle;
#endif
int ixs, jxs, kxs;
is = pGrid->is; ie = pGrid->ie;
js = pGrid->js; je = pGrid->je;
ks = pGrid->ks; ke = pGrid->ke;
lx = pDomain->RootMaxX[0] - pDomain->RootMinX[0];
ly = pDomain->RootMaxX[1] - pDomain->RootMinX[1];
lz = pDomain->RootMaxX[2] - pDomain->RootMinX[2];
/* Ensure a different initial random seed for each process in an MPI calc. */
ixs = pGrid->Disp[0];
jxs = pGrid->Disp[1];
kxs = pGrid->Disp[2];
iseed = -1 - (ixs + pDomain->Nx[0]*(jxs + pDomain->Nx[1]*kxs));
/* Read perturbation amplitude, problem switch, background density */
amp = par_getd("problem","amp");
iprob = par_geti("problem","iprob");
rhoh = par_getd_def("problem","rhoh",3.0);
/* Distance over which field is rotated */
L_rot = par_getd_def("problem","L_rot",0.0);
/* Read magnetic field strength, angle [should be in degrees, 0 is along +ve
* X-axis (no rotation)] */
#ifdef MHD
b0 = par_getd("problem","b0");
angle = par_getd("problem","angle");
angle = (angle/180.)*PI;
#endif
/* 2D PROBLEM --------------------------------------------------------------- */
/* Initialize two fluids with interface at y=0.0. Pressure scaled to give a
* sound speed of 1 at the interface in the light (lower, d=1) fluid
* Perturb V2 using single (iprob=1) or multiple (iprob=2) mode
*/
if (pGrid->Nx[2] == 1) {
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
cc_pos(pGrid,i,j,k,&x1,&x2,&x3);
pGrid->U[k][j][i].d = 1.0;
pGrid->U[k][j][i].E = (1.0/Gamma - 0.1*x2)/Gamma_1;
pGrid->U[k][j][i].M1 = 0.0;
if (iprob == 1) {
pGrid->U[k][j][i].M2 = amp/4.0*
(1.0+cos(2.0*PI*x1/lx))*(1.0+cos(2.0*PI*x2/ly));
}
else {
pGrid->U[k][j][i].M2 = amp*(ran2(&iseed) - 0.5)*
(1.0+cos(2.0*PI*x2/ly));
}
pGrid->U[k][j][i].M3 = 0.0;
if (x2 > 0.0) {
pGrid->U[k][j][i].d = 2.0;
pGrid->U[k][j][i].M2 *= 2.0;
pGrid->U[k][j][i].E = (1.0/Gamma - 0.2*x2)/Gamma_1;
}
pGrid->U[k][j][i].E+=0.5*SQR(pGrid->U[k][j][i].M2)/pGrid->U[k][j][i].d;
#ifdef MHD
pGrid->B1i[k][j][i] = b0;
pGrid->U[k][j][i].B1c = b0;
pGrid->U[k][j][i].E += 0.5*b0*b0;
#endif
}
#ifdef MHD
pGrid->B1i[k][j][ie+1] = b0;
#endif
}
}
/* Enroll gravitational potential to give acceleration in y-direction for 2D
* Use special boundary condition routines. In 2D, gravity is in the
* y-direction, so special boundary conditions needed for x2
*/
StaticGravPot = grav_pot2;
if (pDomain->Disp[1] == 0) bvals_mhd_fun(pDomain, left_x2, reflect_ix2);
if (pDomain->MaxX[1] == pDomain->RootMaxX[1])
bvals_mhd_fun(pDomain, right_x2, reflect_ox2);
} /* end of 2D initialization */
/* 3D PROBLEM ----------------------------------------------------------------*/
/* Initialize two fluids with interface at z=0.0
* Pressure scaled to give a sound speed of 1 at the interface
* in the light (lower, d=1) fluid
* iprob = 1 -- Perturb V3 using single mode
* iprob = 2 -- Perturb V3 using multiple mode
* iprob = 3 -- B in light fluid only, with multimode perturbation
* iprob = 4 -- B rotated by "angle" at interface, multimode perturbation
*/
if (pGrid->Nx[2] > 1) {
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
cc_pos(pGrid,i,j,k,&x1,&x2,&x3);
pGrid->U[k][j][i].d = 1.0;
pGrid->U[k][j][i].E = (1.0/Gamma - 0.1*x3)/Gamma_1;
pGrid->U[k][j][i].M1 = 0.0;
pGrid->U[k][j][i].M2 = 0.0;
if (iprob == 1) {
pGrid->U[k][j][i].M3 = amp/8.0*(1.0+cos(2.0*PI*x1/lx))*
(1.0+cos(2.0*PI*x2/ly))*(1.0+cos(2.0*PI*x3/lz));
}
else {
pGrid->U[k][j][i].M3 = amp*(ran2(&iseed) - 0.5)*
(1.0+cos(2.0*PI*x3/lz));
}
if (x3 > 0.0) {
pGrid->U[k][j][i].d = rhoh;
pGrid->U[k][j][i].M3 *= rhoh;
pGrid->U[k][j][i].E = (1.0/Gamma - 0.1*rhoh*x3)/Gamma_1;
}
pGrid->U[k][j][i].E+=0.5*SQR(pGrid->U[k][j][i].M3)/pGrid->U[k][j][i].d;
#ifdef MHD
switch(iprob){
case 3: /* B only in light fluid, do not add B^2 to E, total P const */
if (x3 <= 0.0) {
pGrid->B1i[k][j][i] = b0;
if (i == ie) pGrid->B1i[k][j][ie+1] = b0;
pGrid->U[k][j][i].B1c = b0;
}
break;
case 4: /* discontinuous rotation of B by angle at interface */
if (x3 <= 0.0) {
pGrid->B1i[k][j][i] = b0;
if (i == ie) pGrid->B1i[k][j][ie+1] = b0;
pGrid->U[k][j][i].B1c = b0;
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
else {
pGrid->B1i[k][j][i] = b0*cos(angle);
pGrid->B2i[k][j][i] = b0*sin(angle);
if (i == ie) pGrid->B1i[k][j][ie+1] = b0*cos(angle);
if (j == je) pGrid->B2i[k][je+1][i] = b0*sin(angle);
pGrid->U[k][j][i].B1c = b0*cos(angle);
pGrid->U[k][j][i].B2c = b0*sin(angle);
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
break;
case 5: /* rotation of B by angle over distance L_rot at interface */
if (x3 <= (-L_rot/2.0)) {
pGrid->B1i[k][j][i] = b0;
if (i == ie) pGrid->B1i[k][j][ie+1] = b0;
pGrid->U[k][j][i].B1c = b0;
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
else if (x3 >= (L_rot/2.0)) {
pGrid->B1i[k][j][i] = b0*cos(angle);
pGrid->B2i[k][j][i] = b0*sin(angle);
if (i == ie) pGrid->B1i[k][j][ie+1] = b0*cos(angle);
if (j == je) pGrid->B2i[k][je+1][i] = b0*sin(angle);
pGrid->U[k][j][i].B1c = b0*cos(angle);
pGrid->U[k][j][i].B2c = b0*sin(angle);
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
else {
fact = ((L_rot/2.0)+x3)/L_rot;
pGrid->B1i[k][j][i] = b0*cos(fact*angle);
pGrid->B2i[k][j][i] = b0*sin(fact*angle);
if (i == ie) pGrid->B1i[k][j][ie+1] = b0*cos(fact*angle);
if (j == je) pGrid->B2i[k][je+1][i] = b0*sin(fact*angle);
pGrid->U[k][j][i].B1c = b0*cos(fact*angle);
pGrid->U[k][j][i].B2c = b0*sin(fact*angle);
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
break;
default:
pGrid->B1i[k][j][i] = b0;
if (i == ie) pGrid->B1i[k][j][ie+1] = b0;
pGrid->U[k][j][i].B1c = b0;
pGrid->U[k][j][i].E += 0.5*b0*b0;
}
#endif
}
}
}
/* Enroll gravitational potential to give accn in z-direction for 3D
* Use special boundary condition routines. In 3D, gravity is in the
* z-direction, so special boundary conditions needed for x3
*/
StaticGravPot = grav_pot3;
//if (pDomain->Disp[2] == 0) bvals_mhd_fun(pDomain, left_x3, reflect_ix3);
//if (pDomain->MaxX[2] == pDomain->RootMaxX[2])
// bvals_mhd_fun(pDomain, right_x3, reflect_ox3);
} /* end of 3D initialization */
return;
}
void problem(DomainS *pDomain)
{
int i,j,k;
int is,ie,il,iu,js,je,jl,ju,ks,ke,kl,ku;
int nx1,nx2,nx3,myid=0;
Real x1,x2,x3,y1, r;
GridS *pG = pDomain->Grid;
is = pG->is; ie = pG->ie; nx1 = ie-is+1;
js = pG->js; je = pG->je; nx2 = je-js+1;
ks = pG->ks; ke = pG->ke; nx3 = ke-ks+1;
il = is-nghost*(nx1>1); iu = ie+nghost*(nx1>1); nx1 = iu-il+1;
jl = js-nghost*(nx2>1); ju = je+nghost*(nx2>1); nx2 = ju-jl+1;
kl = ks-nghost*(nx3>1); ku = ke+nghost*(nx3>1); nx3 = ku-kl+1;
rho0 = par_getd_def("problem", "rho0", 100.0);
Amp = par_getd_def("problem", "Amp", 1.0e-2);
Beta = par_getd_def("problem", "Beta",100.0);
R0 = par_getd_def("problem", "R0",2.0);
rhomin = par_getd_def("problem","rhomin",1.0e-3);
Field = par_getd_def("problem","Field",0);
Hbc = par_getd_def("problem","Hbc",1);
Mbc = par_getd_def("problem","Mbc",1);
Mc = par_getd_def("problem","Mc",20.0);
srand(SEED + myID_Comm_world);
for (k=kl; k<=ku; k++) {
for (j=jl; j<=ju; j++) {
for (i=il; i<=iu; i++) {
cc_pos(pG,i,j,k,&x1,&x2,&x3);
x1 = x1vc(pG,i);
r = 2.0*rand()/((double)RAND_MAX) - 1.0;
pG->U[k][j][i].d = rho0;
#ifdef FARGO
pG->U[k][j][i].M2 = 0.0;
#else
pG->U[k][j][i].M2 = pG->U[k][j][i].d*avg1d(vphi,pG,i,j,k);
#endif
pG->U[k][j][i].M2 += pG->U[k][j][i].d*Amp*r*Iso_csound*ChiMag(x1);
r = 2.0*rand()/((double)RAND_MAX)-1.0;
pG->U[k][j][i].M1 = 0.0;
pG->U[k][j][i].M3 = pG->U[k][j][i].d*Amp*r*Iso_csound*ChiMag(x1);
#ifdef MHD
pG->U[k][j][i].B1c = 0.0;
if (Field == 2) {
pG->U[k][j][i].B2c = BpNet(x1,x2,x3);
} else {
pG->U[k][j][i].B2c = 0.0;
}
if (Field == 0) {
pG->U[k][j][i].B3c = BzZero(x1,x2,x3);
} else if (Field == 1) {
pG->U[k][j][i].B3c = BzNet(x1,x2,x3);
} else {
pG->U[k][j][i].B3c = 0.0;
}
pG->B1i[k][j][i] = 0.0;
pG->B2i[k][j][i] = pG->U[k][j][i].B2c;
pG->B3i[k][j][i] = pG->U[k][j][i].B3c;
#endif
}
}
}
#ifdef MHD
if (Field != 2) {
ScaleToBeta(pG,Beta);
}
#endif /* MHD */
StaticGravPot = grav_pot;
x1GravAcc = grav_acc;
bvals_mhd_fun(pDomain,left_x1,disk_ir);
bvals_mhd_fun(pDomain,right_x1,disk_or);
#ifdef FARGO
OrbitalProfile = Omega;
ShearProfile = Shear;
#endif
// Enroll history functions
//
#ifdef MHD
dump_history_enroll(Br, "<Br>");
dump_history_enroll(Bp, "<Bp>");
dump_history_enroll(Bz, "<Bz>");
dump_history_enroll(Mrp, "<Mrp>");
dump_history_enroll(Trp, "<Trp>");
dump_history_enroll(MdotR1, "<MdotR1>");
dump_history_enroll(MdotR2, "<MdotR2>");
dump_history_enroll(MdotR3, "<MdotR3>");
dump_history_enroll(MdotR4, "<MdotR4>");
dump_history_enroll(Msub, "<Msub>");
dump_history_enroll(Mrpsub, "<Mrpsub>");
dump_history_enroll(Bpsub, "<Bpsub>");
dump_history_enroll(Bzsub, "<Bzsub>");
dump_history_enroll(Pbsub, "<Pbsub>");
#endif
return;
}
/* problem: */
void problem(DomainS *pDomain)
{
GridS *pG = pDomain->Grid;
int i,j,k;
int is,ie,il,iu,js,je,jl,ju,ks,ke,kl,ku;
int nx1,nx2,nx3;
Real x1,x2,x3;
Real xs,vs,v,pgas0,pgas,alpha,beta,a,b,converged;
is = pG->is; ie = pG->ie; nx1 = ie-is+1;
js = pG->js; je = pG->je; nx2 = je-js+1;
ks = pG->ks; ke = pG->ke; nx3 = ke-ks+1;
il = is-nghost*(nx1>1); iu = ie+nghost*(nx1>1); nx1 = iu-il+1;
jl = js-nghost*(nx2>1); ju = je+nghost*(nx2>1); nx2 = ju-jl+1;
kl = ks-nghost*(nx3>1); ku = ke+nghost*(nx3>1); nx3 = ku-kl+1;
#ifdef MHD
ath_error("[cylwindrot]: This problem only works in hydro!\n");
#endif
#ifndef CYLINDRICAL
ath_error("[cylwindrot]: This problem only works in cylindrical!\n");
#endif
if (nx1==1) {
ath_error("[cylwindrot]: This problem can only be run in 2D or 3D!\n");
}
else if (nx2==1 && nx3>1) {
ath_error("[cylwindrot]: Only (R,phi) can be used in 2D!\n");
}
/* Allocate memory for solution */
if ((RootSoln = (ConsS***)calloc_3d_array(nx3,nx2,nx1,sizeof(ConsS))) == NULL)
ath_error("[cylwindrot]: Error allocating memory for solution\n");
ang_mom = par_getd("problem","ang_mom");
c_infty = par_getd("problem","c_infty");
vz0 = par_getd("problem","vz0");
iprob = par_geti("problem","iprob");
printf("gamma = %f,\t ang_mom = %f,\t c_infty = %f\n", Gamma, ang_mom, c_infty);
beta = 2.0*Gamma_1/(Gamma+1.0);
xs = (3.0-Gamma+sqrt(SQR(Gamma-3.0)-16.0*SQR(ang_mom)))/4.0;
lambda_s = 1.0/Gamma_1*pow(xs,beta)+pow(xs,beta-1.0)-0.5*SQR(ang_mom)*pow(xs,beta-2.0);
lambda_s = pow(lambda_s/(0.5+1.0/Gamma_1),1.0/beta);
vs = c_infty*pow(lambda_s/xs,0.5*beta);
printf("xs = %13.10f,\t lambda_s = %13.10f,\t vs = %13.10f\n", xs, lambda_s, vs);
// Compute 1D wind/accretion solution
for (i=il; i<=iu; i++) {
cc_pos(pG,i,j,k,&x1,&x2,&x3);
memset(&(pG->U[ks][js][i]),0.0,sizeof(ConsS));
vs = pow(lambda_s/x1,0.5*beta);
switch(iprob) {
case 1: /* Wind */
if (x1 < xs) {
a = TINY_NUMBER; b = vs;
}
else {
a = vs; b = HUGE_NUMBER;
}
break;
case 2: /* Accretion */
if (x1 < xs) {
a = vs; b = HUGE_NUMBER;
}
else {
a = TINY_NUMBER; b = vs;
}
break;
default: ath_error("[cylwindrot]: Not an accepted problem number!\n");
}
converged = bisection(myfunc,a,b,x1,&v);
if (!converged) ath_error("[cylwindrot]: Bisection did not converge!\n");
pG->U[ks][js][i].d = lambda_s/(x1*v);
pG->U[ks][js][i].M1 = lambda_s/x1;
if (iprob==2)
pG->U[ks][js][i].M1 *= -1.0;
pG->U[ks][js][i].M2 = pG->U[ks][js][i].d*ang_mom/x1;
pG->U[ks][js][i].M3 = pG->U[ks][js][i].d*vz0;
/* Initialize total energy */
#ifndef ISOTHERMAL
pgas0 = 1.0/Gamma;
pgas = pgas0*pow(pG->U[ks][js][i].d,Gamma);
pG->U[ks][js][i].E = pgas/Gamma_1
+ 0.5*(SQR(pG->U[ks][js][i].M1) + SQR(pG->U[ks][js][i].M2) + SQR(pG->U[ks][js][i].M3))/pG->U[ks][js][i].d;
#endif /* ISOTHERMAL */
}
/* Copy 1D solution and save */
for (k=kl; k<=ku; k++) {
for (j=jl; j<=ju; j++) {
for (i=il; i<=iu; i++) {
pG->U[k][j][i] = pG->U[ks][js][i];
RootSoln[k][j][i] = pG->U[ks][js][i];
}
}
}
StaticGravPot = grav_pot;
bvals_mhd_fun(pDomain,left_x1,do_nothing_bc);
bvals_mhd_fun(pDomain,right_x1,do_nothing_bc);
return;
}
