void
CellBilinear::interp (const FArrayBox& crse,
int crse_comp,
FArrayBox& fine,
int fine_comp,
int ncomp,
const Box& fine_region,
const IntVect & ratio,
const Geometry& /*crse_geom*/,
const Geometry& /*fine_geom*/,
Array<BCRec>& /*bcr*/,
int actual_comp,
int actual_state)
{
BL_PROFILE("CellBilinear::interp()");
#if (BL_SPACEDIM == 3)
BoxLib::Error("interp: not implemented");
#endif
//
// Set up to call FORTRAN.
//
const int* clo = crse.box().loVect();
const int* chi = crse.box().hiVect();
const int* flo = fine.loVect();
const int* fhi = fine.hiVect();
const int* lo = fine_region.loVect();
const int* hi = fine_region.hiVect();
int num_slope = D_TERM(2,*2,*2)-1;
int len0 = crse.box().length(0);
int slp_len = num_slope*len0;
Array<Real> slope(slp_len);
int strp_len = len0*ratio[0];
Array<Real> strip(strp_len);
int strip_lo = ratio[0] * clo[0];
int strip_hi = ratio[0] * chi[0];
const Real* cdat = crse.dataPtr(crse_comp);
Real* fdat = fine.dataPtr(fine_comp);
const int* ratioV = ratio.getVect();
FORT_CBINTERP (cdat,ARLIM(clo),ARLIM(chi),ARLIM(clo),ARLIM(chi),
fdat,ARLIM(flo),ARLIM(fhi),ARLIM(lo),ARLIM(hi),
D_DECL(&ratioV[0],&ratioV[1],&ratioV[2]),&ncomp,
slope.dataPtr(),&num_slope,strip.dataPtr(),&strip_lo,&strip_hi,
&actual_comp,&actual_state);
}
void
NodeBilinear::interp (const FArrayBox& crse,
int crse_comp,
FArrayBox& fine,
int fine_comp,
int ncomp,
const Box& fine_region,
const IntVect& ratio,
const Geometry& /*crse_geom */,
const Geometry& /*fine_geom */,
Array<BCRec>& /*bcr*/,
int actual_comp,
int actual_state)
{
BL_PROFILE("NodeBilinear::interp()");
//
// Set up to call FORTRAN.
//
const int* clo = crse.box().loVect();
const int* chi = crse.box().hiVect();
const int* flo = fine.loVect();
const int* fhi = fine.hiVect();
const int* lo = fine_region.loVect();
const int* hi = fine_region.hiVect();
int num_slope = D_TERM(2,*2,*2)-1;
int len0 = crse.box().length(0);
int slp_len = num_slope*len0;
Array<Real> strip(slp_len);
const Real* cdat = crse.dataPtr(crse_comp);
Real* fdat = fine.dataPtr(fine_comp);
const int* ratioV = ratio.getVect();
FORT_NBINTERP (cdat,ARLIM(clo),ARLIM(chi),ARLIM(clo),ARLIM(chi),
fdat,ARLIM(flo),ARLIM(fhi),ARLIM(lo),ARLIM(hi),
D_DECL(&ratioV[0],&ratioV[1],&ratioV[2]),&ncomp,
strip.dataPtr(),&num_slope,&actual_comp,&actual_state);
}
// Set the grid[3] structure to be passed to updateState
// (or updateSolution and SWEEP in the next future)
void PatchPluto::setGrid(const Box& a_box, struct GRID *grid, FArrayBox& a_dV)
{
int i, j, k, idim;
int np_int, np_tot, np_int_glob, np_tot_glob;
double stretch, scrh, scrh1, scrh2, scrh3, dxmin[3];
double ***dV[CHOMBO_NDV];
struct GRID *G;
for (int dir = 0; dir < SpaceDim; ++dir){
grid[dir].level = m_level;
grid[dir].np_tot = a_box.size()[dir]+2*m_numGhost;
grid[dir].np_int = a_box.size()[dir];
grid[dir].np_tot_glob = m_domain.domainBox().size()[dir]+2*m_numGhost;
grid[dir].np_int_glob = m_domain.domainBox().size()[dir];
grid[dir].nghost = m_numGhost;
grid[dir].beg = a_box.loVect()[dir]+m_numGhost;
grid[dir].end = a_box.hiVect()[dir]+m_numGhost;
grid[dir].gbeg = m_domain.domainBox().loVect()[dir]+m_numGhost;
grid[dir].gend = m_domain.domainBox().hiVect()[dir]+m_numGhost;
grid[dir].lbeg = m_numGhost;
grid[dir].lend = grid[dir].np_int+m_numGhost-1;
grid[dir].lbound = 0;
grid[dir].rbound = 0;
// Set flags to compute boundary conditions
// is_gbeg (left boundary)
Box tmp = a_box;
tmp.shift(dir,-1);
tmp &= m_domain;
tmp.shift(dir,1);
if (tmp != a_box) grid[dir].lbound = 1;
// is_gend (right_boundary)
tmp = a_box;
tmp.shift(dir,1);
tmp &= m_domain;
tmp.shift(dir,-1);
if (tmp != a_box) grid[dir].rbound = 1;
}
for (int dir = 0; dir < 3; ++dir){
G = grid + dir;
if (dir >= SpaceDim) {
G->np_int = G->np_tot = G->np_int_glob = G->np_tot_glob = 1;
G->nghost = G->beg = G->end = G->gbeg = G->gend =
G->lbeg = G->lend = G->lbound = G->rbound = 0;
}
np_tot_glob = G->np_tot_glob;
np_int_glob = G->np_int_glob;
np_tot = G->np_tot;
np_int = G->np_int;
G->x = ARRAY_1D(np_tot, double);
G->xr = ARRAY_1D(np_tot, double);
G->xl = ARRAY_1D(np_tot, double);
G->dx = ARRAY_1D(np_tot, double);
stretch = 1.;
if (dir == JDIR) stretch = g_x2stretch;
if (dir == KDIR) stretch = g_x3stretch;
for (i = 0; i < np_tot; i++){
#if (CHOMBO_LOGR == YES)
if (dir == IDIR) {
G->xl[i] = g_domBeg[IDIR]*exp(Real( i+grid[dir].beg-2*grid[dir].nghost )*m_dx);
G->xr[i] = g_domBeg[IDIR]*exp(Real(i+1+grid[dir].beg-2*grid[dir].nghost)*m_dx);
G->x[i] = 0.5*(G->xr[i]+G->xl[i]);
G->dx[i] = G->xr[i]-G->xl[i];
} else {
#endif
G->xl[i] = Real(i+grid[dir].beg-2*grid[dir].nghost)*m_dx*stretch;
G->xl[i] += g_domBeg[dir];
G->x[i] = G->xl[i]+0.5*m_dx*stretch;
G->xr[i] = G->xl[i]+m_dx*stretch;
G->dx[i] = m_dx*stretch;
#if (CHOMBO_LOGR == YES)
}
#endif
}
}
CH_assert(m_isBoundarySet);
grid[IDIR].lbound *= left_bound_side[IDIR];
grid[IDIR].rbound *= right_bound_side[IDIR];
grid[JDIR].lbound *= left_bound_side[JDIR];
grid[JDIR].rbound *= right_bound_side[JDIR];
grid[KDIR].lbound *= left_bound_side[KDIR];
grid[KDIR].rbound *= right_bound_side[KDIR];
MakeGeometry(grid);
// compute cell volumes (dV/m_dx^3) and cylindrical radius
#if GEOMETRY != CARTESIAN
NX1_TOT = grid[IDIR].np_tot;
NX2_TOT = grid[JDIR].np_tot;
NX3_TOT = grid[KDIR].np_tot;
for (i = 0; i < CHOMBO_NDV; i++) dV[i] = ArrayMap(NX3_TOT, NX2_TOT, NX1_TOT, a_dV.dataPtr(i));
#if GEOMETRY == CYLINDRICAL
for (k = 0; k < NX3_TOT; k++) {
for (j = 0; j < NX2_TOT; j++) {
for (i = 0; i < NX1_TOT; i++) {
dV[0][k][j][i] = fabs(grid[IDIR].x[i]);
#if CH_SPACEDIM > 1
dV[0][k][j][i] *= g_x2stretch;
#endif
#if CHOMBO_CONS_AM == YES
dV[1][k][j][i] = grid[IDIR].x[i];
#endif
}}}
#endif
#if GEOMETRY == SPHERICAL
for (k = 0; k < NX3_TOT; k++) {
for (j = 0; j < NX2_TOT; j++) {
for (i = 0; i < NX1_TOT; i++) {
dV[0][k][j][i] = grid[IDIR].dV[i]/m_dx;
#if CH_SPACEDIM > 1
dV[0][k][j][i] *= grid[JDIR].dV[j]/m_dx;
#endif
#if CH_SPACEDIM == 3
dV[0][k][j][i] *= g_x3stretch;
#endif
#if CHOMBO_CONS_AM == YES
dV[1][k][j][i] = grid[IDIR].x[i];
#if CH_SPACEDIM > 1
dV[1][k][j][i] *= sin(grid[JDIR].x[j]);
#endif
#endif
}}}
#endif
#if GEOMETRY == POLAR
for (k = 0; k < NX3_TOT; k++) {
for (j = 0; j < NX2_TOT; j++) {
for (i = 0; i < NX1_TOT; i++) {
dV[0][k][j][i] = grid[IDIR].dV[i]/m_dx;
#if CH_SPACEDIM > 1
dV[0][k][j][i] *= g_x2stretch;
#endif
#if CH_SPACEDIM == 3
dV[0][k][j][i] *= g_x3stretch;
#endif
#if CHOMBO_CONS_AM == YES
dV[1][k][j][i] = grid[IDIR].x[i];
#endif
}}}
#endif
for (i = 0; i < CHOMBO_NDV; i++) FreeArrayMap(dV[i]);
#endif /* != CARTESIAN */
// compute dl_min
#if (GEOMETRY == CARTESIAN) || (GEOMETRY == CYLINDRICAL)
grid[IDIR].dl_min = m_dx;
grid[JDIR].dl_min = m_dx*g_x2stretch;
grid[KDIR].dl_min = m_dx*g_x3stretch;
#else
IBEG = grid[IDIR].lbeg; IEND = grid[IDIR].lend;
JBEG = grid[JDIR].lbeg; JEND = grid[JDIR].lend;
KBEG = grid[KDIR].lbeg; KEND = grid[KDIR].lend;
for (idim = 0; idim < 3; idim++) dxmin[idim] = 1.e30;
for (i = IBEG; i <= IEND; i++) {
for (j = JBEG; j <= JEND; j++) {
for (k = KBEG; k <= KEND; k++) {
#if (TIME_STEPPING == RK2)
D_EXPAND(scrh1 = Length_1(i, j, k, grid); ,
scrh2 = Length_2(i, j, k, grid); ,
scrh3 = Length_3(i, j, k, grid); )
scrh = D_EXPAND(1./scrh1, +1./scrh2, +1./scrh3);
scrh = (double)DIMENSIONS/scrh;
D_EXPAND(dxmin[IDIR] = MIN (dxmin[IDIR], scrh); ,
/* ********************************************************************* */
void PatchPluto::updateSolution(FArrayBox& a_U,
FArrayBox& a_Utmp,
const FArrayBox& a_dV,
FArrayBox& split_tags,
BaseFab<unsigned char>& a_Flags,
FluxBox& a_F,
Time_Step *Dts,
const Box& UBox,
Grid *grid)
/*
*
*
*
*
*********************************************************************** */
{
CH_assert(isDefined());
CH_assert(UBox == m_currentBox);
int nv, in;
int nxf, nyf, nzf, indf;
int nxb, nyb, nzb;
int *i, *j, *k;
int ii, jj, kk;
double ***UU[NVAR];
double *inv_dl, dl2, cylr;
static Data d;
#ifdef SKIP_SPLIT_CELLS
double ***splitcells;
#endif
#if (PARABOLIC_FLUX & EXPLICIT)
static double **dcoeff;
#endif
Index indx;
static State_1D state;
Riemann_Solver *Riemann;
Riemann = rsolver;
#if TIME_STEPPING == RK2
double wflux = 0.5;
#else
double wflux = 1.;
#endif
/* -----------------------------------------------------------------
Check algorithm compatibilities
----------------------------------------------------------------- */
if (NX1_TOT > NMAX_POINT || NX2_TOT > NMAX_POINT || NX3_TOT > NMAX_POINT){
print ("!updateSolution (Euler): need to re-allocate matrix\n");
QUIT_PLUTO(1);
}
/* -----------------------------------------------------------------
Allocate memory
----------------------------------------------------------------- */
#if GEOMETRY != CARTESIAN
for (nv = 0; nv < NVAR; nv++) a_U.divide(a_dV,0,nv);
#if CHOMBO_CONS_AM == YES
#if ROTATING_FRAME == YES
Box curBox = a_U.box();
for(BoxIterator bit(curBox); bit.ok(); ++bit) {
const IntVect& iv = bit();
a_U(iv,iMPHI) /= a_dV(iv,1);
a_U(iv,iMPHI) -= a_U(iv,RHO)*a_dV(iv,1)*g_OmegaZ;
}
#else
a_U.divide(a_dV,1,iMPHI);
#endif
#endif
#else
if (g_stretch_fact != 1.) a_U /= g_stretch_fact;
#endif
for (nv = 0; nv < NVAR; nv++){
UU[nv] = ArrayMap(NX3_TOT, NX2_TOT, NX1_TOT, a_U.dataPtr(nv));
}
#ifdef SKIP_SPLIT_CELLS
splitcells = ArrayBoxMap(KBEG, KEND, JBEG, JEND, IBEG, IEND,
split_tags.dataPtr(0));
#endif
#if (TIME_STEPPING == RK2)
d.flag = ArrayCharMap(NX3_TOT, NX2_TOT, NX1_TOT,a_Flags.dataPtr(0));
#endif
#if RESISTIVE_MHD != NO
if (d.J == NULL) d.J = ARRAY_4D(3,NX3_MAX, NX2_MAX, NX1_MAX, double);
#endif
/* -----------------------------------------------------------
Allocate static memory areas
----------------------------------------------------------- */
if (state.flux == NULL){
MakeState (&state);
nxf = nyf = nzf = 1;
D_EXPAND(nxf = NMAX_POINT; ,
/* ********************************************************************* */
void PatchPluto::updateSolution(FArrayBox& a_U,
FArrayBox& a_Utmp,
FArrayBox& split_tags,
BaseFab<unsigned char>& a_Flags,
FluxBox& a_F,
Time_Step *Dts,
const Box& UBox,
Grid *grid)
/*
*
*
*
*
*********************************************************************** */
{
CH_assert(isDefined());
CH_assert(UBox == m_currentBox);
int nv, in;
int nxf, nyf, nzf, indf;
int nxb, nyb, nzb;
int *i, *j, *k;
int ii, jj, kk;
double ***UU[NVAR];
#ifdef SKIP_SPLIT_CELLS
double ***splitcells;
#endif
double *inv_dl, dl2;
static Data d;
static Data_Arr UU_1;
static double ***C_dt[NVAR];
static double **u;
#if (PARABOLIC_FLUX & EXPLICIT)
static double **dcoeff;
#endif
Index indx;
static State_1D state;
Riemann_Solver *Riemann;
Riemann = rsolver;
/* -----------------------------------------------------------------
Check algorithm compatibilities
----------------------------------------------------------------- */
#if !(GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL || GEOMETRY == SPHERICAL)
print1 ("! RK only works in cartesian or cylindrical/spherical coordinates\n");
QUIT_PLUTO(1);
#endif
if (NX1_TOT > NMAX_POINT || NX2_TOT > NMAX_POINT || NX3_TOT > NMAX_POINT){
print ("!updateSolution (RK_MID): need to re-allocate matrix\n");
QUIT_PLUTO(1);
}
/* -----------------------------------------------------------------
Allocate memory
----------------------------------------------------------------- */
for (nv = 0; nv < NVAR; nv++){
UU[nv] = ArrayMap(NX3_TOT, NX2_TOT, NX1_TOT, a_U.dataPtr(nv));
}
#ifdef SKIP_SPLIT_CELLS
splitcells = ArrayBoxMap(KBEG, KEND, JBEG, JEND, IBEG, IEND,
split_tags.dataPtr(0));
#endif
/* -----------------------------------------------------------
Allocate static memory areas
----------------------------------------------------------- */
if (state.flux == NULL){
MakeState (&state);
nxf = nyf = nzf = 1;
D_EXPAND(nxf = NMAX_POINT; ,
void
CellConservativeLinear::interp (const FArrayBox& crse,
int crse_comp,
FArrayBox& fine,
int fine_comp,
int ncomp,
const Box& fine_region,
const IntVect& ratio,
const Geometry& crse_geom,
const Geometry& fine_geom,
Array<BCRec>& bcr,
int actual_comp,
int actual_state)
{
BL_PROFILE("CellConservativeLinear::interp()");
BL_ASSERT(bcr.size() >= ncomp);
//
// Make box which is intersection of fine_region and domain of fine.
//
Box target_fine_region = fine_region & fine.box();
//
// crse_bx is coarsening of target_fine_region, grown by 1.
//
Box crse_bx = CoarseBox(target_fine_region,ratio);
//
// Slopes are needed only on coarsening of target_fine_region.
//
Box cslope_bx(crse_bx);
cslope_bx.grow(-1);
//
// Make a refinement of cslope_bx
//
Box fine_version_of_cslope_bx = BoxLib::refine(cslope_bx,ratio);
//
// Get coarse and fine edge-centered volume coordinates.
//
Array<Real> fvc[BL_SPACEDIM];
Array<Real> cvc[BL_SPACEDIM];
int dir;
for (dir = 0; dir < BL_SPACEDIM; dir++)
{
fine_geom.GetEdgeVolCoord(fvc[dir],fine_version_of_cslope_bx,dir);
crse_geom.GetEdgeVolCoord(cvc[dir],crse_bx,dir);
}
//
// alloc tmp space for slope calc.
//
// In ucc_slopes and lcc_slopes , there is a slight abuse of
// the number of compenents argument
// --> there is a slope for each component in each coordinate
// direction
//
FArrayBox ucc_slopes(cslope_bx,ncomp*BL_SPACEDIM);
FArrayBox lcc_slopes(cslope_bx,ncomp*BL_SPACEDIM);
FArrayBox slope_factors(cslope_bx,BL_SPACEDIM);
FArrayBox cmax(cslope_bx,ncomp);
FArrayBox cmin(cslope_bx,ncomp);
FArrayBox alpha(cslope_bx,ncomp);
Real* fdat = fine.dataPtr(fine_comp);
const Real* cdat = crse.dataPtr(crse_comp);
Real* ucc_xsldat = ucc_slopes.dataPtr(0);
Real* lcc_xsldat = lcc_slopes.dataPtr(0);
Real* xslfac_dat = slope_factors.dataPtr(0);
#if (BL_SPACEDIM>=2)
Real* ucc_ysldat = ucc_slopes.dataPtr(ncomp);
Real* lcc_ysldat = lcc_slopes.dataPtr(ncomp);
Real* yslfac_dat = slope_factors.dataPtr(1);
#endif
#if (BL_SPACEDIM==3)
Real* ucc_zsldat = ucc_slopes.dataPtr(2*ncomp);
Real* lcc_zsldat = lcc_slopes.dataPtr(2*ncomp);
Real* zslfac_dat = slope_factors.dataPtr(2);
#endif
const int* flo = fine.loVect();
const int* fhi = fine.hiVect();
const int* clo = crse.loVect();
const int* chi = crse.hiVect();
const int* fblo = target_fine_region.loVect();
const int* fbhi = target_fine_region.hiVect();
const int* csbhi = cslope_bx.hiVect();
const int* csblo = cslope_bx.loVect();
int lin_limit = (do_linear_limiting ? 1 : 0);
const int* cvcblo = crse_bx.loVect();
const int* fvcblo = fine_version_of_cslope_bx.loVect();
int slope_flag = 1;
int cvcbhi[BL_SPACEDIM];
int fvcbhi[BL_SPACEDIM];
for (dir=0; dir<BL_SPACEDIM; dir++)
{
cvcbhi[dir] = cvcblo[dir] + cvc[dir].size() - 1;
fvcbhi[dir] = fvcblo[dir] + fvc[dir].size() - 1;
}
D_TERM(Real* voffx = new Real[fvc[0].size()]; ,