void
BaseFab<Real>::performCopy (const BaseFab<Real>& src,
const Box& srcbox,
int srccomp,
const Box& destbox,
int destcomp,
int numcomp)
{
BL_ASSERT(destbox.ok());
BL_ASSERT(src.box().contains(srcbox));
BL_ASSERT(box().contains(destbox));
BL_ASSERT(destbox.sameSize(srcbox));
BL_ASSERT(srccomp >= 0 && srccomp+numcomp <= src.nComp());
BL_ASSERT(destcomp >= 0 && destcomp+numcomp <= nComp());
if (destbox == domain && srcbox == src.box())
{
Real* data_dst = dataPtr(destcomp);
const Real* data_src = src.dataPtr(srccomp);
for (long i = 0, N = numcomp*numpts; i < N; i++)
{
*data_dst++ = *data_src++;
}
}
else
{
const int* destboxlo = destbox.loVect();
const int* destboxhi = destbox.hiVect();
const int* _th_plo = loVect();
const int* _th_phi = hiVect();
const int* _x_lo = srcbox.loVect();
const int* _x_plo = src.loVect();
const int* _x_phi = src.hiVect();
Real* _th_p = dataPtr(destcomp);
const Real* _x_p = src.dataPtr(srccomp);
FORT_FASTCOPY(_th_p,
ARLIM(_th_plo),
ARLIM(_th_phi),
D_DECL(destboxlo[0],destboxlo[1],destboxlo[2]),
D_DECL(destboxhi[0],destboxhi[1],destboxhi[2]),
_x_p,
ARLIM(_x_plo),
ARLIM(_x_phi),
D_DECL(_x_lo[0],_x_lo[1],_x_lo[2]),
&numcomp);
}
}
/* ********************************************************************* */
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
BaseFab<T>::maskLT (BaseFab<int> & mask)
{
mask.dataPtr();
}