本文整理汇总了C++中DataIterator类的典型用法代码示例。如果您正苦于以下问题:C++ DataIterator类的具体用法?C++ DataIterator怎么用?C++ DataIterator使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了DataIterator类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: homogeneousCFInterp
// -----------------------------------------------------------------------------
// Interpolate ghosts at CF interface using zeros on coarser grids.
// -----------------------------------------------------------------------------
void homogeneousCFInterp (LevelData<FArrayBox>& a_phif,
const RealVect& a_fineDx,
const RealVect& a_crseDx,
const CFRegion& a_cfRegion,
const IntVect& a_applyDirs)
{
CH_TIME("homogeneousCFInterp (full level)");
// Loop over grids, directions, and sides and call the worker function.
DataIterator dit = a_phif.dataIterator();
for (dit.begin(); dit.ok(); ++dit) {
if (a_phif[dit].box().isEmpty()) continue;
for (int dir = 0; dir < SpaceDim; ++dir) {
if (a_applyDirs[dir] == 0) continue;
SideIterator sit;
for (sit.begin(); sit.ok(); sit.next()) {
homogeneousCFInterp(a_phif,
dit(),
dir,
sit(),
a_fineDx[dir],
a_crseDx[dir],
a_cfRegion);
}
}
}
}
示例2: initializeBdry
/// Set up initial conditions
void SWIBC::initializeBdry(LevelData<FArrayBox>& a_B)
{
const Real tmpVal = 0.0;
const Real tmpVal2 = 100;
for (DataIterator dit = a_B.dataIterator(); dit.ok(); ++dit)
{
// Storage for current grid
FArrayBox& B = a_B[dit()];
// Box of current grid
Box bBox = B.box();
bBox &= m_domain;
// Set up initial condition in this grid
FORT_LINELASTSETFAB(CHF_FRA1(B,4),
CHF_BOX(bBox),
CHF_CONST_REAL(tmpVal));
FORT_LINELASTSETFAB(CHF_FRA1(B,5),
CHF_BOX(bBox),
CHF_CONST_REAL(tmpVal));
FORT_LINELASTSETFAB(CHF_FRA1(B,6),
CHF_BOX(bBox),
CHF_CONST_REAL(tmpVal2));
}
}
示例3: velBC
// ---------------------------------------------------------
void
AMRNavierStokes::computeLapVel(LevelData<FArrayBox>& a_lapVel,
LevelData<FArrayBox>& a_vel,
const LevelData<FArrayBox>* a_crseVelPtr)
{
// set BC's
VelBCHolder velBC(m_physBCPtr->viscousVelFuncBC());
bool isHomogeneous = false;
m_velocityAMRPoissonOp.applyOp(a_lapVel, a_vel, a_crseVelPtr,
isHomogeneous, velBC);
// may need to extend lapVel to cover ghost cells as well
{
BCHolder viscBC = m_physBCPtr->viscousFuncBC();
const DisjointBoxLayout& grids = a_lapVel.getBoxes();
DataIterator dit = a_lapVel.dataIterator();
for (dit.reset(); dit.ok(); ++dit)
{
viscBC(a_lapVel[dit], grids[dit],
m_problem_domain, m_dx,
false); // not homogeneous
}
}
// finally, do exchange
a_lapVel.exchange(a_lapVel.interval());
}
示例4: getJacobiRelaxCoeff
void EBPoissonOp::
getJacobiRelaxCoeff(LevelData<EBCellFAB>& a_relaxCoeff)
{
// Diagonal weight for Jacobi on regular grid
Real weightBase = m_alpha;
for (int idir = 0; idir < SpaceDim; idir++)
{
weightBase += -2.0 * m_beta * m_invDx2[idir];
}
weightBase = 1.0 / weightBase; // Weight for plain (non-weighted) Jacobi
Real weightRegular = EBPOISSONOP_JACOBI_OMEGA * weightBase; // ... for weighted Jacobi
for (DataIterator dit = m_eblg.getDBL().dataIterator(); dit.ok(); ++dit)
{
// Most of the grid is regular, so set the regular weighting by default
a_relaxCoeff[dit()].setVal(weightRegular);
// Walk the EB cells, and correct their weighting
const BaseIVFAB<Real>& curAlphaWeight = m_alphaDiagWeight[dit()];
const BaseIVFAB<Real>& curBetaWeight = m_betaDiagWeight[dit()];
VoFIterator& ebvofit = m_vofItIrreg[dit()];
for (ebvofit.reset(); ebvofit.ok(); ++ebvofit)
{
const VolIndex& vof = ebvofit();
Real weightIrreg = EBPOISSONOP_JACOBI_OMEGA / (m_alpha*curAlphaWeight(vof, 0) + m_beta*curBetaWeight(vof, 0));
a_relaxCoeff[dit()](vof, 0) = weightIrreg;
}
}
}
示例5: viscBC
// ---------------------------------------------------------
void
AMRNavierStokes::computeLapScal(LevelData<FArrayBox>& a_lapScal,
LevelData<FArrayBox>& a_scal,
const BCHolder& a_physBC,
const LevelData<FArrayBox>* a_crseScalPtr)
{
m_scalarsAMRPoissonOp.setBC(a_physBC);
bool isHomogeneous = false;
if (a_crseScalPtr != NULL)
{
m_scalarsAMRPoissonOp.AMROperatorNF(a_lapScal, a_scal, *a_crseScalPtr,
isHomogeneous);
}
else
{
m_scalarsAMRPoissonOp.applyOpI(a_lapScal, a_scal,
isHomogeneous);
}
BCHolder viscBC = m_physBCPtr->viscousFuncBC();
DataIterator dit = a_lapScal.dataIterator();
const DisjointBoxLayout& grids = a_lapScal.getBoxes();
for (dit.reset(); dit.ok(); ++dit)
{
viscBC(a_lapScal[dit],
grids[dit],
m_problem_domain, m_dx,
false); // not homogeneous
}
// finally, do exchange
a_lapScal.exchange(a_lapScal.interval());
}
示例6: scopingTest
int scopingTest()
{
Vector<Box> boxes;
int retflag = 0;
setGrids(boxes);
LevelData<FArrayBox> levelFab;
makeLevelData(boxes, levelFab);
const DisjointBoxLayout& dbl = levelFab.getBoxes();
DataIterator dit = dbl.dataIterator();
int ivec = 0;
for (dit.begin(); dit.ok(); ++dit)
{
if (!dbl.check(dit()))
{
if (verbose)
pout() << indent2 << pgmname
<< ": failed at box " << ivec << endl;
retflag = 1;
}
else
{
levelFab[dit].setVal(0.);
}
if (retflag > 0) break;
ivec++;
}
return retflag;
}
示例7: initData
void
initData(LevelData<FArrayBox>& a_data, const Real a_dx)
{
DataIterator dit = a_data.dataIterator();
const DisjointBoxLayout& interiorBoxes = a_data.getBoxes();
for (dit.begin(); dit.ok(); ++dit)
{
// first set to a bogus value which will persist in ghost cells
// after initialization
a_data[dit()].setVal(1.0e9);
// this will be slow, but who cares?
FArrayBox& localData = a_data[dit()];
BoxIterator boxIt(interiorBoxes[dit()]);
Real localVal;
for (boxIt.begin(); boxIt.ok(); ++boxIt)
{
const IntVect& loc = boxIt();
for (int comp=0; comp<localData.nComp(); comp++)
{
localVal = dataVal(loc, comp);
localData(loc, comp) = localVal;
}
}
}
}
示例8: initializeVelocity
void
NoFlowVortex::
initializeVelocity(LevelData<EBCellFAB>& a_velocity,
const DisjointBoxLayout& a_grids,
const EBISLayout& a_ebisl,
const ProblemDomain& a_domain,
const RealVect& a_origin,
const Real& a_time,
const RealVect& a_dx) const
{
Real pi = 4.0*atan(1.0);
for (DataIterator dit = a_grids.dataIterator(); dit.ok(); ++dit)
{
IntVectSet ivsBox(a_grids.get(dit()));
for (VoFIterator vofit(ivsBox, a_ebisl[dit()].getEBGraph()); vofit.ok(); ++vofit)
{
RealVect xval, velpt;
getXVal(xval, a_origin,vofit(), a_dx);
getVelPt(velpt, xval, pi);
for (int idir = 0; idir < SpaceDim; idir++)
{
a_velocity[dit()](vofit(), idir) = velpt[idir];
}
}
}
}
示例9: CH_TIME
void LevelPluto::setGridLevel()
{
CH_TIME("LevelPluto::setGrid");
m_structs_grid.define(m_grids);
#if GEOMETRY != CARTESIAN
m_dV.define(m_grids,CHOMBO_NDV,m_numGhost*IntVect::Unit);
#endif
Real dlMinLoc = 1.e30;
for (DataIterator dit = m_grids.dataIterator(); dit.ok(); ++dit)
{
// The current box
Box curBox = m_grids.get(dit());
struct GRID* grid = m_structs_grid[dit].getGrid();
#if GEOMETRY != CARTESIAN
FArrayBox& curdV = m_dV[dit()];
#else
FArrayBox curdV;
#endif
m_patchPluto->setGrid(curBox, grid, curdV);
for (int idir = 0; idir < SpaceDim; idir++) dlMinLoc = Min(dlMinLoc,grid[idir].dl_min);
}
#if (GEOMETRY == CARTESIAN) || (GEOMETRY == CYLINDRICAL)
D_EXPAND(m_dl_min = m_dx; ,
示例10: levelDivergenceMAC
// ---------------------------------------------------------
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));
}
}
}
示例11: computeNormalVel
void
EBLevelAdvect::
computeNormalVel(LevelData<EBCellFAB>& a_normalVel,
const LevelData<EBFluxFAB>& a_advectionVel,
const LayoutData<Vector<BaseIVFAB<Real> * > >& a_coveredVeloLo,
const LayoutData<Vector<BaseIVFAB<Real> * > >& a_coveredVeloHi,
const LayoutData<Vector<Vector<VolIndex> > >& a_coveredFaceLo,
const LayoutData<Vector<Vector<VolIndex> > >& a_coveredFaceHi) const
{
CH_TIME("EBLevelAdvect::computeNormalVel");
for (DataIterator dit = m_thisGrids.dataIterator(); dit.ok(); ++dit)
{
const Box& cellBox = m_thisGrids.get(dit());
Box grownBox = grow(cellBox, 1);
grownBox &= m_domain;
m_ebPatchAdvect[dit]->averageVelToCC(a_normalVel[dit()],
a_advectionVel[dit()],
a_coveredVeloLo[dit()],
a_coveredVeloHi[dit()],
a_coveredFaceLo[dit()],
a_coveredFaceHi[dit()],
grownBox);
}
}
示例12: define
//-----------------------------------------------------------------------
// AMR Factory define function, with coefficient data allocated automagically
// for operators.
void
VCAMRPoissonOp2Factory::
define(const ProblemDomain& a_coarseDomain,
const Vector<DisjointBoxLayout>& a_grids,
const Vector<int>& a_refRatios,
const Real& a_coarsedx,
BCHolder a_bc,
const IntVect& a_ghostVect)
{
// This just allocates coefficient data, sets alpha = beta = 1, and calls
// the other define() method.
Vector<RefCountedPtr<LevelData<FArrayBox> > > aCoef(a_grids.size());
Vector<RefCountedPtr<LevelData<FluxBox> > > bCoef(a_grids.size());
for (int i = 0; i < a_grids.size(); ++i)
{
aCoef[i] = RefCountedPtr<LevelData<FArrayBox> >(
new LevelData<FArrayBox>(a_grids[i], 1, a_ghostVect));
bCoef[i] = RefCountedPtr<LevelData<FluxBox> >(
new LevelData<FluxBox>(a_grids[i], 1, a_ghostVect));
// Initialize the a and b coefficients to 1 for starters.
for (DataIterator dit = aCoef[i]->dataIterator(); dit.ok(); ++dit)
{
(*aCoef[i])[dit()].setVal(1.0);
for (int idir = 0; idir < SpaceDim; ++idir)
(*bCoef[i])[dit()][idir].setVal(1.0);
}
}
Real alpha = 1.0, beta = 1.0;
define(a_coarseDomain, a_grids, a_refRatios, a_coarsedx, a_bc,
alpha, aCoef, beta, bCoef);
}
示例13: maxnorm
// ---------------------------------------------------------
// 27 March 2003:
// This is called by other functions, and should not be called directly.
Real
maxnorm(const BoxLayoutData<NodeFArrayBox>& a_layout,
const Interval& a_interval,
bool a_verbose)
{
Real normTotal = 0.;
// a_p == 0: max norm
for (DataIterator it = a_layout.dataIterator(); it.ok(); ++it)
{
const Box& thisBox(a_layout.box(it())); // CELL-centered
const NodeFArrayBox& thisNfab = a_layout[it()];
Real thisNfabNorm =
maxnorm(thisNfab, thisBox, a_interval.begin(), a_interval.size());
if (a_verbose)
cout << "maxnorm(" << thisBox << ") = " << thisNfabNorm << endl;
normTotal = Max(normTotal, thisNfabNorm);
}
# ifdef CH_MPI
Real recv;
int result = MPI_Allreduce(&normTotal, &recv, 1, MPI_CH_REAL,
MPI_MAX, Chombo_MPI::comm);
if (result != MPI_SUCCESS)
{ //bark!!!
MayDay::Error("sorry, but I had a communication error on maxnorm");
}
normTotal = recv;
# endif
return normTotal;
}
示例14: CH_TIME
// this preconditioner first initializes phihat to (IA)phihat = rhshat
// (diagonization of L -- A is the matrix version of L)
// then smooths with a couple of passes of levelGSRB
void VCAMRPoissonOp2::preCond(LevelData<FArrayBox>& a_phi,
const LevelData<FArrayBox>& a_rhs)
{
CH_TIME("VCAMRPoissonOp2::preCond");
// diagonal term of this operator in:
//
// alpha * a(i)
// + beta * sum_over_dir (b(i-1/2*e_dir) + b(i+1/2*e_dir)) / (dx*dx)
//
// The inverse of this is our initial multiplier.
int ncomp = a_phi.nComp();
CH_assert(m_lambda.isDefined());
CH_assert(a_rhs.nComp() == ncomp);
CH_assert(m_bCoef->nComp() == ncomp);
// Recompute the relaxation coefficient if needed.
resetLambda();
// don't need to use a Copier -- plain copy will do
DataIterator dit = a_phi.dataIterator();
for (dit.begin(); dit.ok(); ++dit)
{
// also need to average and sum face-centered bCoefs to cell-centers
Box gridBox = a_rhs[dit].box();
// approximate inverse
a_phi[dit].copy(a_rhs[dit]);
a_phi[dit].mult(m_lambda[dit], gridBox, 0, 0, ncomp);
}
relax(a_phi, a_rhs, 2);
}
示例15: CH_TIME
// -----------------------------------------------------------------------------
// Semi-implicitly handles the gravity forcing and projection.
// The old* inputs should be the values at t^n.
// The new* inputs should be the updated values from the TGA solver.
// -----------------------------------------------------------------------------
void AMRNavierStokes::doCCIGProjection (LevelData<FArrayBox>& a_newVel,
LevelData<FArrayBox>& a_newB,
const LevelData<FArrayBox>& a_oldVel,
const LevelData<FArrayBox>& a_oldB,
const LevelData<FluxBox>& a_advVel,
const Real a_oldTime,
const Real a_dt,
const bool a_doProj)
{
CH_TIME("AMRNavierStokes::doCCIGProjection");
const Real halfTime = a_oldTime + 0.5 * a_dt;
const Real newTime = a_oldTime + 1.0 * a_dt;
const Real dummyTime = -1.0e300;
const GeoSourceInterface& geoSource = *(m_levGeoPtr->getGeoSourcePtr());
const RealVect& dx = m_levGeoPtr->getDx();
const DisjointBoxLayout& grids = a_newVel.getBoxes();
DataIterator dit = grids.dataIterator();
// 1. Compute the background buoyancy, N, Dinv, etc...
// Fill the FC background buoyancy field.
LevelData<FluxBox> bbar(grids, 1, 2*IntVect::Unit);
for (dit.reset(); dit.ok(); ++dit) {
FluxBox& bbarFB = bbar[dit];
D_TERM(m_physBCPtr->setBackgroundScalar(bbarFB[0], 0, *m_levGeoPtr, dit(), dummyTime);,
m_physBCPtr->setBackgroundScalar(bbarFB[1], 0, *m_levGeoPtr, dit(), dummyTime);,