void NewPoissonOp::restrictResidual(FArrayBox& a_resCoarse, FArrayBox& a_phiFine, const FArrayBox& a_rhsFine) { Real dx = m_dx[0]; FArrayBox& phi = a_phiFine; m_bc(phi, m_domain.domainBox(), m_domain, dx, true); const FArrayBox& rhs = a_rhsFine; FArrayBox& res = a_resCoarse; Box region = rhs.box(); res.setVal(0.0); Real alpha = 0; Real beta = 1.0; FORT_RESTRICTRES(CHF_FRA(res), CHF_CONST_FRA(phi), CHF_CONST_FRA(rhs), CHF_CONST_REAL(alpha), CHF_CONST_REAL(beta), CHF_BOX(region), CHF_CONST_REAL(dx)); }
// Set boundary fluxes void RampIBC::primBC(FArrayBox& a_WGdnv, const FArrayBox& a_Wextrap, const FArrayBox& a_W, const int& a_dir, const Side::LoHiSide& a_side, const Real& a_time) { CH_assert(m_isFortranCommonSet == true); CH_assert(m_isDefined == true); // Neither the x or y direction can be periodic if ((a_dir == 0 || a_dir == 1) && m_domain.isPeriodic(a_dir)) { MayDay::Error("RampIBC::primBC: Neither the x or y boundaries can be periodic"); } Box boundaryBox; getBoundaryFaces(boundaryBox, a_WGdnv.box(), a_dir, a_side); if (! boundaryBox.isEmpty() ) { // Set the boundary fluxes int lohisign = sign(a_side); FORT_RAMPBCF(CHF_FRA(a_WGdnv), CHF_CONST_FRA(a_Wextrap), CHF_CONST_FRA(a_W), CHF_CONST_REAL(a_time), CHF_CONST_INT(lohisign), CHF_CONST_REAL(m_dx), CHF_CONST_INT(a_dir), CHF_BOX(boundaryBox)); } }
/** Given input left and right states in a direction, a_dir, compute a Riemann problem and generate fluxes at the faces within a_box. */ void LinElastPhysics::riemann(/// face-centered solution to Riemann problem FArrayBox& a_WStar, /// left state, on cells to left of each face const FArrayBox& a_WLeft, /// right state, on cells to right of each face const FArrayBox& a_WRight, /// state on cells, used to set boundary conditions const FArrayBox& a_W, /// current time const Real& a_time, /// direction of faces const int& a_dir, /// face-centered box on which to set a_WStar const Box& a_box) { //JK pout() << "LinElastPhysics::riemann" << endl; CH_assert(isDefined()); CH_assert(a_WStar.box().contains(a_box)); // Get the numbers of relevant variables int numPrim = numPrimitives(); CH_assert(a_WStar .nComp() == numPrim); CH_assert(a_WLeft .nComp() == numPrim); CH_assert(a_WRight.nComp() == numPrim); // Cast away "const" inputs so their boxes can be shifted left or right // 1/2 cell and then back again (no net change is made!) FArrayBox& shiftWLeft = (FArrayBox&)a_WLeft; FArrayBox& shiftWRight = (FArrayBox&)a_WRight; // Solution to the Riemann problem // Shift the left and right primitive variable boxes 1/2 cell so they are // face centered shiftWLeft .shiftHalf(a_dir, 1); shiftWRight.shiftHalf(a_dir,-1); CH_assert(shiftWLeft .box().contains(a_box)); CH_assert(shiftWRight.box().contains(a_box)); // Riemann solver computes Wgdnv all edges that are not on the physical // boundary. FORT_RIEMANNF(CHF_FRA(a_WStar), CHF_CONST_FRA(shiftWLeft), CHF_CONST_FRA(shiftWRight), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); // Call boundary Riemann solver (note: periodic BC's are handled there). m_bc->primBC(a_WStar,shiftWLeft ,a_W,a_dir,Side::Hi,a_time); m_bc->primBC(a_WStar,shiftWRight,a_W,a_dir,Side::Lo,a_time); // Shift the left and right primitive variable boxes back to their original // position. shiftWLeft .shiftHalf(a_dir,-1); shiftWRight.shiftHalf(a_dir, 1); }
// Compute a Riemann problem and generate fluxes at the faces. void PolytropicPhysics::riemann(FArrayBox& a_WGdnv, const FArrayBox& a_WLeft, const FArrayBox& a_WRight, const FArrayBox& a_W, const Real& a_time, const int& a_dir, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_WGdnv.box().contains(a_box)); // Get the numbers of relevant variables int numPrim = numPrimitives(); CH_assert(a_WGdnv .nComp() == numPrim); CH_assert(a_WLeft .nComp() == numPrim); CH_assert(a_WRight.nComp() == numPrim); // Cast away "const" inputs so their boxes can be shifted left or right // 1/2 cell and then back again (no net change is made!) FArrayBox& shiftWLeft = (FArrayBox&)a_WLeft; FArrayBox& shiftWRight = (FArrayBox&)a_WRight; // Solution to the Riemann problem // Shift the left and right primitive variable boxes 1/2 cell so they are // face centered shiftWLeft .shiftHalf(a_dir, 1); shiftWRight.shiftHalf(a_dir,-1); CH_assert(shiftWLeft .box().contains(a_box)); CH_assert(shiftWRight.box().contains(a_box)); // Riemann solver computes Wgdnv all edges that are not on the physical // boundary. FORT_RIEMANNF(CHF_FRA(a_WGdnv), CHF_CONST_FRA(shiftWLeft), CHF_CONST_FRA(shiftWRight), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); // Call boundary Riemann solver (note: periodic BC's are handled there). m_bc->primBC(a_WGdnv,shiftWLeft ,a_W,a_dir,Side::Hi,a_time); m_bc->primBC(a_WGdnv,shiftWRight,a_W,a_dir,Side::Lo,a_time); // Shift the left and right primitive variable boxes back to their original // position. shiftWLeft .shiftHalf(a_dir,-1); shiftWRight.shiftHalf(a_dir, 1); }
// Set boundary slopes: // The boundary slopes in a_dW are already set to one sided difference // approximations. If this function doesn't change them they will be // used for the slopes at the boundaries. void ExplosionIBC::setBdrySlopes(FArrayBox& a_dW, const FArrayBox& a_W, const int& a_dir, const Real& a_time) { CH_assert(m_isFortranCommonSet == true); CH_assert(m_isDefined == true); // In periodic case, this doesn't do anything if (!m_domain.isPeriodic(a_dir)) { Box loBox,hiBox,centerBox,domain; int hasLo,hasHi; Box slopeBox = a_dW.box(); slopeBox.grow(a_dir,1); // Generate the domain boundary boxes, loBox and hiBox, if there are // domain boundarys there loHiCenter(loBox,hasLo,hiBox,hasHi,centerBox,domain, slopeBox,m_domain,a_dir); // Set the boundary slopes if necessary if ((hasLo != 0) || (hasHi != 0)) { FORT_SLOPEBCSF(CHF_FRA(a_dW), CHF_CONST_FRA(a_W), CHF_CONST_INT(a_dir), CHF_BOX(loBox), CHF_CONST_INT(hasLo), CHF_BOX(hiBox), CHF_CONST_INT(hasHi)); } } }
// ---------------------------------------------------------- void CoarseAverageEdge::averageGridData(FluxBox& a_coarsenedFine, const FluxBox& a_fine) const { for (int dir=0; dir<SpaceDim; dir++) { FArrayBox& coarseFab = a_coarsenedFine[dir]; const FArrayBox& fineFab = a_fine[dir]; const Box& coarseBox = coarseFab.box(); // set up refinement box int boxHi = m_nRef-1; IntVect hiVect(D_DECL(boxHi,boxHi,boxHi)); // don't want to index at all in dir direction -- // instead, want to just march along edge. hiVect.setVal(dir,0); IntVect loVect(D_DECL(0,0,0)); Box refBox(loVect, hiVect); FORT_AVERAGEEDGE( CHF_FRA(coarseFab), CHF_CONST_FRA(fineFab), CHF_BOX(coarseBox), CHF_CONST_INT(dir), CHF_CONST_INT(m_nRef), CHF_BOX(refBox)); } }
// --------------------------------------------------------- void levelDivergenceMAC(LevelData<FArrayBox>& a_div, const LevelData<FluxBox>& a_uEdge, const Real a_dx) { // silly way to do this until i figure out a better // way to make this dimensionally-independent CH_assert (a_uEdge.nComp() >= a_div.nComp()); DataIterator dit = a_div.dataIterator(); for (dit.reset(); dit.ok(); ++dit) { a_div[dit()].setVal(0.0); const FluxBox& thisFluxBox = a_uEdge[dit()]; Box cellBox(thisFluxBox.box()); // just to be sure we don't accidentally trash memory... cellBox &= a_div[dit()].box(); // now loop over coordinate directions and add to divergence for (int dir=0; dir<SpaceDim; dir++) { const FArrayBox& uEdgeDir = thisFluxBox[dir]; FORT_DIVERGENCE(CHF_CONST_FRA(uEdgeDir), CHF_FRA(a_div[dit()]), CHF_BOX(cellBox), CHF_CONST_REAL(a_dx), CHF_INT(dir)); } } }
void NewPoissonOp:: levelGSRB(FArrayBox& a_phi, const FArrayBox& a_rhs) { CH_assert(a_phi.nComp() == a_rhs.nComp()); Real dx = m_dx[0]; // do first red, then black passes for (int whichPass =0; whichPass <= 1; whichPass++) { m_bc(a_phi, m_domain.domainBox(), m_domain, dx, true); // now step through grids... //fill in intersection of ghostcells and a_phi's boxes // dfm -- for a 5 point stencil, this should not be necessary //a_phi.exchange(a_phi.interval(), m_exchangeCopier); // invoke physical BC's where necessary //m_bc(a_phi, m_domain, dx, true); //new approach to help with checker #ifndef NDEBUG #endif FORT_GSRBLAPLACIAN(CHF_FRA(a_phi), CHF_CONST_FRA(a_rhs), CHF_BOX(a_rhs.box()), CHF_CONST_REAL(dx), CHF_CONST_INT(whichPass)); } // end loop through red-black }
EBCellFAB& EBCellFAB::divide(const EBCellFAB& a_src, int a_srccomp, int a_destcomp, int a_numcomp) { CH_assert(isDefined()); CH_assert(a_src.isDefined()); // Dan G. feels strongly that the assert below should NOT be commented out // Brian feels that a weaker version of the CH_assert (if possible) is needed // Terry is just trying to get his code to work //CH_assert(m_ebisBox == a_src.m_ebisBox); CH_assert(a_srccomp + a_numcomp <= a_src.m_nComp); CH_assert(a_destcomp + a_numcomp <= m_nComp); bool sameRegBox = (a_src.m_regFAB.box() == m_regFAB.box()); Box locRegion = a_src.m_region & m_region; if (!locRegion.isEmpty()) { FORT_DIVIDETWOFAB(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_src.m_regFAB), CHF_BOX(locRegion), CHF_INT(a_srccomp), CHF_INT(a_destcomp), CHF_INT(a_numcomp)); if (sameRegBox && (locRegion == m_region && locRegion == a_src.m_region)) { Real* l = m_irrFAB.dataPtr(a_destcomp); const Real* r = a_src.m_irrFAB.dataPtr(a_srccomp); int nvof = m_irrFAB.numVoFs(); CH_assert(nvof == a_src.m_irrFAB.numVoFs()); for (int i=0; i<a_numcomp*nvof; i++) l[i]/=r[i]; } else { IntVectSet ivsMulti = a_src.getMultiCells(); ivsMulti &= getMultiCells(); ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; for (int icomp = 0; icomp < a_numcomp; ++icomp) { m_irrFAB(vof, a_destcomp+icomp) /= a_src.m_irrFAB(vof, a_srccomp+icomp); } } } } } return *this; }
// Set boundary fluxes void ExplosionIBC::primBC(FArrayBox& a_WGdnv, const FArrayBox& a_Wextrap, const FArrayBox& a_W, const int& a_dir, const Side::LoHiSide& a_side, const Real& a_time) { CH_assert(m_isFortranCommonSet == true); CH_assert(m_isDefined == true); // In periodic case, this doesn't do anything if (!m_domain.isPeriodic(a_dir)) { int lohisign; Box tmp = a_WGdnv.box(); // Determine which side and thus shifting directions lohisign = sign(a_side); tmp.shiftHalf(a_dir,lohisign); // Is there a domain boundary next to this grid if (!m_domain.contains(tmp)) { tmp &= m_domain; Box boundaryBox; // Find the strip of cells next to the domain boundary if (a_side == Side::Lo) { boundaryBox = bdryLo(tmp,a_dir); } else { boundaryBox = bdryHi(tmp,a_dir); } // Set the boundary fluxes FORT_SOLIDBCF(CHF_FRA(a_WGdnv), CHF_CONST_FRA(a_Wextrap), CHF_CONST_FRA(a_W), CHF_CONST_INT(lohisign), CHF_CONST_INT(a_dir), CHF_BOX(boundaryBox)); } } }
void VCAMRPoissonOp2::applyOpNoBoundary(LevelData<FArrayBox>& a_lhs, const LevelData<FArrayBox>& a_phi) { CH_TIME("VCAMRPoissonOp2::applyOpNoBoundary"); LevelData<FArrayBox>& phi = (LevelData<FArrayBox>&)a_phi; const DisjointBoxLayout& dbl = a_lhs.disjointBoxLayout(); DataIterator dit = phi.dataIterator(); phi.exchange(phi.interval(), m_exchangeCopier); for (dit.begin(); dit.ok(); ++dit) { const Box& region = dbl[dit()]; const FluxBox& thisBCoef = (*m_bCoef)[dit]; #if CH_SPACEDIM == 1 FORT_VCCOMPUTEOP1D #elif CH_SPACEDIM == 2 FORT_VCCOMPUTEOP2D #elif CH_SPACEDIM == 3 FORT_VCCOMPUTEOP3D #else This_will_not_compile! #endif (CHF_FRA(a_lhs[dit]), CHF_CONST_FRA(phi[dit]), CHF_CONST_REAL(m_alpha), CHF_CONST_FRA((*m_aCoef)[dit]), CHF_CONST_REAL(m_beta), #if CH_SPACEDIM >= 1 CHF_CONST_FRA(thisBCoef[0]), #endif #if CH_SPACEDIM >= 2 CHF_CONST_FRA(thisBCoef[1]), #endif #if CH_SPACEDIM >= 3 CHF_CONST_FRA(thisBCoef[2]), #endif #if CH_SPACEDIM >= 4 This_will_not_compile! #endif CHF_BOX(region), CHF_CONST_REAL(m_dx)); } // end loop over boxes }
// Compute increment of primitive variables. void PolytropicPhysics::quasilinearUpdate(FArrayBox& a_dWdx, const FArrayBox& a_WHalf, const FArrayBox& a_W, const Real& a_scale, const int& a_dir, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_dWdx.box().contains(a_box)); FORT_GETADWDXF(CHF_FRA(a_dWdx), CHF_CONST_FRA(a_WHalf), CHF_CONST_FRA(a_W), CHF_CONST_REAL(a_scale), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
void LinElastPhysics::quasilinearUpdate(FArrayBox& a_dWdx, const FArrayBox& a_wHalf, const FArrayBox& a_W, const Real& a_scale, const int& a_dir, const Box& a_box) { //JK pout() << "LinElastPhysics::quasilinear" << endl; CH_assert(isDefined()); CH_assert(a_dWdx.box().contains(a_box)); FORT_GETADWDXF(CHF_FRA(a_dWdx), CHF_CONST_FRA(a_wHalf), CHF_CONST_FRA(a_W), CHF_CONST_REAL(a_scale), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
EBCellFAB& EBCellFAB::plus(const EBCellFAB& a_src, const Box& a_region, int a_srccomp, int a_destcomp, int a_numcomp) { CH_assert(isDefined()); CH_assert(a_src.isDefined()); CH_assert(a_srccomp + a_numcomp <= a_src.m_nComp); CH_assert(a_destcomp + a_numcomp <= m_nComp); const Box& locRegion = a_region; bool sameRegBox = (a_src.m_regFAB.box() == m_regFAB.box()); if (!locRegion.isEmpty()) { FORT_ADDTWOFAB(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_src.m_regFAB), CHF_BOX(locRegion), CHF_INT(a_srccomp), CHF_INT(a_destcomp), CHF_INT(a_numcomp)); if (sameRegBox && (locRegion == m_region && locRegion == a_src.m_region)) { Real* l = m_irrFAB.dataPtr(a_destcomp); const Real* r = a_src.m_irrFAB.dataPtr(a_srccomp); int nvof = m_irrFAB.numVoFs(); CH_assert(nvof == a_src.m_irrFAB.numVoFs()); for (int i=0; i<a_numcomp*nvof; i++) l[i]+=r[i]; } else { IntVectSet ivsMulti = a_src.getMultiCells(); ivsMulti &= getMultiCells(); ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; for (int icomp = 0; icomp < a_numcomp; ++icomp) { m_irrFAB(vof, a_destcomp+icomp) += a_src.m_irrFAB(vof, a_srccomp+icomp); } } } } } return *this; }
void RSIBC::updateBoundary(const FArrayBox& a_WHalf,int a_dir,const Real& a_dt,const Real& a_dx,const Real& a_time,const bool a_final) { if(a_dir == 1 && bdryLo(m_domain,a_dir).contains(bdryLo(a_WHalf.box(),a_dir))) { if(a_final) { FORT_RSSETBND( CHF_FRA((*m_bdryData)), CHF_BOX(bdryLo(a_WHalf.box(),a_dir)), CHF_CONST_FRA((*m_bdryData)), CHF_CONST_FRA(a_WHalf), CHF_CONST_REAL(a_dt), CHF_CONST_REAL(a_dx), CHF_CONST_REAL(a_time)); } // THIS MAY BE NECESSARY IN 3-D, NOT SURE!!! // else if(m_tmpBdryDataSet) // { // FORT_RSSETBND( // CHF_FRA((*m_tmpBdryData)), // CHF_BOX(bdryLo(a_WHalf.box(),a_dir)), // CHF_CONST_FRA((*m_tmpBdryData)), // CHF_CONST_FRA(a_WHalf), // CHF_CONST_REAL(a_dt), // CHF_CONST_REAL(a_dx), // CHF_CONST_REAL(a_time)); // } else { // m_tmpBdryData = new FArrayBox(m_bdryData->box(), m_numBdryVars); FORT_RSSETBND( CHF_FRA((*m_tmpBdryData)), CHF_BOX(bdryLo(a_WHalf.box(),a_dir)), CHF_CONST_FRA((*m_bdryData)), CHF_CONST_FRA(a_WHalf), CHF_CONST_REAL(a_dt), CHF_CONST_REAL(a_dx), CHF_CONST_REAL(a_time)); m_tmpBdryDataSet = true; } } }
void PolytropicPhysics::charValues(FArrayBox& a_lambda, const FArrayBox& a_W, const int& a_dir, const Box& a_box) { CH_assert(isDefined()); FORT_CHARVALUESF(CHF_FRA(a_lambda), CHF_CONST_FRA(a_W), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
// Compute the primitive variables from the conserved variables void PolytropicPhysics::consToPrim(FArrayBox& a_W, const FArrayBox& a_U, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_U.box().contains(a_box)); CH_assert(a_W.box().contains(a_box)); FORT_CONSTOPRIMF(CHF_FRA(a_W), CHF_CONST_FRA(a_U), CHF_BOX(a_box)); }
void PolytropicPhysics::charSynthesis(FArrayBox& a_dW, const FArrayBox& a_W, const int& a_dir, const Box& a_box) { CH_assert(isDefined()); FORT_CHARSYNTHESISF(CHF_FRA(a_dW), CHF_CONST_FRA(a_W), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
// Compute the speed of sound void PolytropicPhysics::soundSpeed(FArrayBox& a_speed, const FArrayBox& a_U, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_U.contains(a_box)); CH_assert(a_speed.contains(a_box)); FORT_SOUNDSPEEDF(CHF_CONST_FRA1(a_speed, 0), CHF_CONST_FRA(a_U), CHF_BOX(a_box)); }
void PolytropicPhysics::getFlux(FArrayBox& a_flux, const FArrayBox& a_whalf, const int& a_dir, const Box& a_box) { CH_assert(isDefined()); FORT_GETFLUXF(CHF_FRA(a_flux), CHF_CONST_FRA(a_whalf), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
void LinElastPhysics::getFlux(FArrayBox& a_flux, const FArrayBox& a_whalf, const int& a_dir, const Box& a_box) { //JK pout() << "LinElastPhysics::getFlux :: " << a_dir << endl; CH_assert(isDefined()); FORT_GETFLUXF(CHF_FRA(a_flux), CHF_CONST_FRA(a_whalf), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
/** On input, a_dW contains the increments of the characteristic variables. On output, it contains the increments in the primitive variables. IMPORTANT NOTE: It is assumed that the characteristic analysis puts the smallest eigenvalue first, the largest eigenvalue last, and orders the characteristic variables accordingly. */ void LinElastPhysics::charSynthesis(FArrayBox& a_dW, const FArrayBox& a_W, const int& a_dir, const Box& a_box) { //JK pout() << "LinElastPhysics::charSynthesis" << endl; CH_assert(isDefined()); FORT_CHARSYNTHESISF(CHF_FRA(a_dW), CHF_CONST_FRA(a_W), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
void EBPlanarShockIBC:: initialize(LevelData<EBCellFAB>& a_conState, const EBISLayout& a_ebisl) const { CH_assert(m_isDefined); CH_assert(m_isFortranCommonSet); // Iterator of all grids in this level for(DataIterator dit = a_conState.dataIterator(); dit.ok(); ++dit) { const EBISBox& ebisBox = a_ebisl[dit()]; // Storage for current grid EBCellFAB& conFAB = a_conState[dit()]; BaseFab<Real>& regConFAB = conFAB.getSingleValuedFAB(); // Box of current grid Box uBox = regConFAB.box(); uBox &= m_domain; // Set up initial condition in this grid /**/ FORT_PLANARSHOCKINIT(CHF_CONST_FRA(regConFAB), CHF_CONST_REAL(m_dx), CHF_BOX(uBox)); /**/ //now for the multivalued cells. Since it is pointwise, //the regular calc is correct for all single-valued cells. IntVectSet ivs = ebisBox.getMultiCells(uBox); for(VoFIterator vofit(ivs, ebisBox.getEBGraph()); vofit.ok(); ++vofit) { const VolIndex& vof = vofit(); const IntVect& iv = vof.gridIndex(); RealVect momentum; Real energy, density; /**/ FORT_POINTPLANARSHOCKINIT(CHF_REAL(density), CHF_REALVECT(momentum), CHF_REAL(energy), CHF_CONST_INTVECT(iv), CHF_CONST_REAL(m_dx)); /**/ conFAB(vof, CRHO) = density; conFAB(vof, CENG) = energy; for(int idir = 0; idir < SpaceDim; idir++) { conFAB(vof, CMOMX+idir) = momentum[idir]; } }//end loop over multivalued cells } //end loop over boxes }
void VCAMRPoissonOp2::residualI(LevelData<FArrayBox>& a_lhs, const LevelData<FArrayBox>& a_phi, const LevelData<FArrayBox>& a_rhs, bool a_homogeneous) { CH_TIME("VCAMRPoissonOp2::residualI"); LevelData<FArrayBox>& phi = (LevelData<FArrayBox>&)a_phi; Real dx = m_dx; const DisjointBoxLayout& dbl = a_lhs.disjointBoxLayout(); DataIterator dit = phi.dataIterator(); { CH_TIME("VCAMRPoissonOp2::residualIBC"); for (dit.begin(); dit.ok(); ++dit) { m_bc(phi[dit], dbl[dit()],m_domain, dx, a_homogeneous); } } phi.exchange(phi.interval(), m_exchangeCopier); for (dit.begin(); dit.ok(); ++dit) { const Box& region = dbl[dit()]; const FluxBox& thisBCoef = (*m_bCoef)[dit]; #if CH_SPACEDIM == 1 FORT_VCCOMPUTERES1D #elif CH_SPACEDIM == 2 FORT_VCCOMPUTERES2D #elif CH_SPACEDIM == 3 FORT_VCCOMPUTERES3D #else This_will_not_compile! #endif (CHF_FRA(a_lhs[dit]), CHF_CONST_FRA(phi[dit]), CHF_CONST_FRA(a_rhs[dit]), CHF_CONST_REAL(m_alpha), CHF_CONST_FRA((*m_aCoef)[dit]), CHF_CONST_REAL(m_beta), #if CH_SPACEDIM >= 1 CHF_CONST_FRA(thisBCoef[0]), #endif #if CH_SPACEDIM >= 2 CHF_CONST_FRA(thisBCoef[1]), #endif #if CH_SPACEDIM >= 3 CHF_CONST_FRA(thisBCoef[2]), #endif #if CH_SPACEDIM >= 4 This_will_not_compile! #endif CHF_BOX(region), CHF_CONST_REAL(m_dx)); } // end loop over boxes }
// Compute the maximum wave speed Real PolytropicPhysics::getMaxWaveSpeed(const FArrayBox& a_U, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_U.contains(a_box)); Real speed = 0.0; FORT_MAXWAVESPEEDF(CHF_REAL(speed), CHF_CONST_FRA(a_U), CHF_BOX(a_box)); return speed; }
void LinElastPhysics::consToPrim(FArrayBox& a_W, const FArrayBox& a_U, const Box& a_box) { //JK Our primitives are our conserved variables //JK pout() << "LinElastPhysics::consToPrim" << endl; CH_assert(isDefined()); CH_assert(a_U.box().contains(a_box)); CH_assert(a_W.box().contains(a_box)); FORT_COPYF(CHF_FRA(a_W), CHF_CONST_FRA(a_U), CHF_BOX(a_box)); }
void PolytropicPhysics::postNormalPred(FArrayBox& a_dWMinus, FArrayBox& a_dWPlus, const FArrayBox& a_W, const Real& a_dt, const Real& a_dx, const int& a_dir, const Box& a_box) { // Bound "a_dWMinus" and "a_dWPlus" so that density and pressure will never // be less than "smallr" and "smallp", respectively FORT_POSTNORMALPREDF(CHF_FRA(a_dWMinus), CHF_FRA(a_dWPlus), CHF_CONST_FRA(a_W), CHF_BOX(a_box)); }
// --------------------------------------------------------- void AMRNavierStokes::computeKineticEnergy(LevelData<FArrayBox>& a_energy) const { // this is simple since no BC's need to be set. const LevelData<FArrayBox>& levelVel = *m_vel_new_ptr; const DisjointBoxLayout& levelGrids = levelVel.getBoxes(); DataIterator dit = a_energy.dataIterator(); for (dit.begin(); dit.ok(); ++dit) { FORT_KINETICENERGY(CHF_FRA1(a_energy[dit],0), CHF_CONST_FRA(levelVel[dit]), CHF_BOX(levelGrids[dit])); } }
/** On input, a_dW contains the increments of the primitive variables. On output, it contains the increments in the characteristic variables. IMPORTANT NOTE: It is assumed that the characteristic analysis puts the smallest eigenvalue first, the largest eigenvalue last, and orders the characteristic variables accordingly. */ void LinElastPhysics::charAnalysis(FArrayBox& a_dW, const FArrayBox& a_W, const int& a_dir, const Box& a_box) { //JK pout() << "LinElastPhysics::charAnalysis" << endl; CH_assert(isDefined()); /* * This routine assumes that cp >= cs */ FORT_CHARANALYSISF(CHF_FRA(a_dW), CHF_CONST_FRA(a_W), CHF_CONST_INT(a_dir), CHF_BOX(a_box)); }
/// Compute the maximum wave speed Real LinElastPhysics::getMaxWaveSpeed(const FArrayBox& a_U, const Box& a_box) { CH_assert(isDefined()); CH_assert(a_U.contains(a_box)); Real speed = 0.0; FORT_MAXWAVESPEEDF(CHF_REAL(speed), CHF_CONST_FRA(a_U), CHF_BOX(a_box)); //JK pout() << "LinElastPhysics::getMaxWaveSpeed :: SPEED = " << speed << endl; return speed; }