void LayoutRepository::load(XmlOptionFile file)
{
// load custom layouts:
mLayouts.clear();
this->blockSignals(true);
QDomElement layouts = file.getElement("layouts");
QDomNode layout = layouts.firstChild();
for (; !layout.isNull(); layout = layout.nextSibling())
{
if (layout.toElement().tagName() != "layout")
continue;
LayoutData data;
data.parseXml(layout);
this->insert(data);
}
std::vector<QString> custom = this->getAvailable();
this->addDefaults(); // ensure we overwrite loaded layouts
this->blockSignals(false);
for (unsigned i=0; i<custom.size(); ++i)
emit layoutChanged(custom[i]);
}
void LayoutRepository::insert(const LayoutData& data)
{
unsigned pos = this->indexOf(data.getUid());
if (pos == mLayouts.size())
mLayouts.push_back(data);
else
mLayouts[pos] = data;
emit layoutChanged(data.getUid());
}
void FraxinusMainWindowApplicationComponent::addAdditionalDefaultLayouts()
{
std::cout << "addAdditionalDefaultLayouts" << std::endl;
ViewServicePtr viewService = logicManager()->getViewService();
{
LayoutData layout = LayoutData::create("LAYOUT_VB_FLY_THROUGH", "VB FLY-THROUGH", 3, 5);
layout.setView(2, View::VIEW_3D, LayoutRegion(0, 0, 3, 3));
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 3, 1, 2));
layout.setView(1, ptAXIAL, LayoutRegion(1, 3, 1, 2));
layout.setView(1, ptCORONAL, LayoutRegion(2, 3, 1, 2));
viewService->addDefaultLayout(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_VB_CUT_PLANES", "VB CUT-PLANES", 3, 5);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 3, 3));
layout.setView(2, View::VIEW_3D, LayoutRegion(0, 3, 1, 2));
layout.setView(1, ptAXIAL, LayoutRegion(1, 3, 1, 2));
layout.setView(1, ptCORONAL, LayoutRegion(2, 3, 1, 2));
viewService->addDefaultLayout(layout);
}
{
// ACS 3D
LayoutData layout = LayoutData::create("LAYOUT_ACAS", "ACAS", 2, 2);
layout.setView(1, ptAXIAL, LayoutRegion(0, 0));
layout.setView(1, ptCORONAL, LayoutRegion(0, 1));
layout.setView(1, ptSAGITTAL, LayoutRegion(1, 1));
layout.setView(0, ptAXIAL, LayoutRegion(1, 0));
viewService->addDefaultLayout(layout);
}
}
void
EBPoissonOp::
defineStencils()
{
CH_TIMERS("EBPoissonOp::defineStencils");
CH_TIMER("opStencil_define", t1);
CH_TIMER("colorStencil_define", t2);
// define ebstencil for irregular applyOp
m_opEBStencil.define(m_eblg.getDBL());
// create vofstencils for applyOp
LayoutData<BaseIVFAB<VoFStencil> > opStencil;
opStencil.define(m_eblg.getDBL());
//define bc stencils and create flux stencil
m_ebBC->define((*m_eblg.getCFIVS()), m_dxScale*m_beta);
LayoutData<BaseIVFAB<VoFStencil> >* fluxStencil = m_ebBC->getFluxStencil(0);
//create and define colored stencils (2 parts)
LayoutData<BaseIVFAB<VoFStencil> > colorStencil;
colorStencil.define(m_eblg.getDBL());
LayoutData<BaseIVFAB<VoFStencil> > rhsColorStencil;
rhsColorStencil.define(m_eblg.getDBL());
m_alphaDiagWeight.define( m_eblg.getDBL());
m_betaDiagWeight.define( m_eblg.getDBL());
m_vofItIrreg.define( m_eblg.getDBL()); // vofiterator cache
Box domainBox = m_eblg.getDomain().domainBox();
Box sideBoxLo[SpaceDim];
Box sideBoxHi[SpaceDim];
for (int idir = 0; idir < SpaceDim; idir++)
{
sideBoxLo[idir] = adjCellLo(domainBox, idir, 1);
sideBoxLo[idir].shift(idir, 1);
sideBoxHi[idir] = adjCellHi(domainBox, idir, 1);
sideBoxHi[idir].shift(idir, -1);
m_vofItIrregDomLo[idir].define( m_eblg.getDBL()); // vofiterator cache for domain lo
m_vofItIrregDomHi[idir].define( m_eblg.getDBL()); // vofiterator cache for domain hi
}
CH_START(t1);
for (DataIterator dit = m_eblg.getDBL().dataIterator(); dit.ok(); ++dit)
{
const Box& curBox = m_eblg.getDBL().get(dit());
const EBISBox& curEBISBox = m_eblg.getEBISL()[dit()];
const EBGraph& curEBGraph = curEBISBox.getEBGraph();
IntVectSet notRegular = curEBISBox.getIrregIVS (curBox);
BaseIVFAB<VoFStencil>& curStencilBaseIVFAB = opStencil[dit()];
BaseIVFAB<Real>& alphaWeight = m_alphaDiagWeight[dit()];
BaseIVFAB<Real>& betaWeight = m_betaDiagWeight[dit()];
curStencilBaseIVFAB.define(notRegular,curEBGraph, 1);
alphaWeight.define( notRegular,curEBGraph, 1);
betaWeight.define( notRegular,curEBGraph, 1);
//cache the vofIterators
m_vofItIrreg[dit()].define(notRegular,curEBISBox.getEBGraph());
for (int idir = 0; idir < SpaceDim; idir++)
{
IntVectSet loIrreg = notRegular;
IntVectSet hiIrreg = notRegular;
loIrreg &= sideBoxLo[idir];
hiIrreg &= sideBoxHi[idir];
m_vofItIrregDomLo[idir][dit()].define(loIrreg,curEBISBox.getEBGraph());
m_vofItIrregDomHi[idir][dit()].define(hiIrreg,curEBISBox.getEBGraph());
}
//Operator vofstencil
VoFIterator& vofit = m_vofItIrreg[dit()];
for (vofit.reset(); vofit.ok(); ++vofit)
{
const VolIndex& VoF = vofit();
VoFStencil& curStencil = curStencilBaseIVFAB(VoF,0);
getOpVoFStencil(curStencil,curEBISBox,VoF);
Real& curAlphaWeight = alphaWeight(VoF,0);
Real& curBetaWeight = betaWeight(VoF,0);
const Real kappa = curEBISBox.volFrac(VoF);
curAlphaWeight = kappa;
curBetaWeight = 0.0;
for (int i = 0; i < curStencil.size(); i++)
{
if (curStencil.vof(i) == VoF)
{
curBetaWeight += curStencil.weight(i);
break;
}
}
curStencil *= m_beta;
if (m_alpha != 0)
{
curStencil.add(VoF, kappa*m_alpha);
}
const IntVect& iv = VoF.gridIndex();
for (int idir = 0; idir < SpaceDim; idir++)
{
Box loSide = bdryLo(m_eblg.getDomain(),idir);
loSide.shiftHalf(idir,1);
if (loSide.contains(iv))
{
Real faceAreaFrac = 0.0;
Vector<FaceIndex> faces = curEBISBox.getFaces(VoF,idir,Side::Lo);
for (int i = 0; i < faces.size(); i++)
{
faceAreaFrac += curEBISBox.areaFrac(faces[i]);
}
curBetaWeight += -faceAreaFrac * m_invDx2[idir];
}
Box hiSide = bdryHi(m_eblg.getDomain(),idir);
hiSide.shiftHalf(idir,-1);
if (hiSide.contains(iv))
{
Real faceAreaFrac = 0.0;
Vector<FaceIndex> faces = curEBISBox.getFaces(VoF,idir,Side::Hi);
for (int i = 0; i < faces.size(); i++)
{
faceAreaFrac += curEBISBox.areaFrac(faces[i]);
}
curBetaWeight += -faceAreaFrac * m_invDx2[idir];
}
}
if (curBetaWeight == 0.0)
{
curBetaWeight = -1.0;
}
if (fluxStencil != NULL)
{
BaseIVFAB<VoFStencil>& fluxStencilBaseIVFAB = (*fluxStencil)[dit()];
VoFStencil& fluxStencilPt = fluxStencilBaseIVFAB(VoF,0);
curStencil += fluxStencilPt;
}
}//vofit
//Operator ebstencil
m_opEBStencil[dit()] = RefCountedPtr<EBStencil>(new EBStencil(m_vofItIrreg[dit()].getVector(), opStencil[dit()], m_eblg.getDBL().get(dit()), m_eblg.getEBISL()[dit()], m_ghostCellsPhi, m_ghostCellsRHS));
}//dit
CH_STOP(t1);
//color vofstencils and ebstencils
IntVect color = IntVect::Zero;
IntVect limit = IntVect::Unit;
color[0]=-1;
// Loop over all possibilities (in all dimensions)
CH_START(t2);
for (int icolor = 0; icolor < m_colors.size(); icolor++)
{
m_colorEBStencil[icolor].define(m_eblg.getDBL());
m_rhsColorEBStencil[icolor].define(m_eblg.getDBL());
m_vofItIrregColor[icolor].define( m_eblg.getDBL());
for (int idir = 0; idir < SpaceDim; idir++)
{
m_vofItIrregColorDomLo[icolor][idir].define( m_eblg.getDBL());
m_vofItIrregColorDomHi[icolor][idir].define( m_eblg.getDBL());
}
for (DataIterator dit = m_eblg.getDBL().dataIterator(); dit.ok(); ++dit)
{
IntVectSet ivsColor;
const EBISBox& curEBISBox = m_eblg.getEBISL()[dit()];
const EBGraph& curEBGraph = curEBISBox.getEBGraph();
Box dblBox( m_eblg.getDBL().get(dit()) );
BaseIVFAB<VoFStencil>& curStencilBaseIVFAB = opStencil[dit()];
BaseIVFAB<VoFStencil>& colorStencilBaseIVFAB = colorStencil[dit()];
BaseIVFAB<VoFStencil>& rhsColorStencilBaseIVFAB = rhsColorStencil[dit()];
const BaseIVFAB<Real>& curAlphaWeight = m_alphaDiagWeight[dit()];
const BaseIVFAB<Real>& curBetaWeight = m_betaDiagWeight[dit()];
VoFIterator& vofit = m_vofItIrreg[dit()];
int vofOrdinal = 0;
for (vofit.reset(); vofit.ok(); ++vofit, ++vofOrdinal)
{
const VolIndex& vof = vofit();
const IntVect& iv = vof.gridIndex();
bool doThisVoF = true;
for (int idir = 0; idir < SpaceDim; idir++)
{
if (iv[idir] % 2 != color[idir])
{
doThisVoF = false;
break;
}
}
if (doThisVoF)
{
ivsColor |= iv;
}
}
m_vofItIrregColor[icolor][dit()].define(ivsColor, curEBGraph);
colorStencilBaseIVFAB.define(ivsColor, curEBGraph, 1);
rhsColorStencilBaseIVFAB.define(ivsColor, curEBGraph, 1);
for (int idir = 0; idir < SpaceDim; idir++)
{
IntVectSet loIrregColor = ivsColor;
IntVectSet hiIrregColor = ivsColor;
loIrregColor &= sideBoxLo[idir];
hiIrregColor &= sideBoxHi[idir];
m_vofItIrregColorDomLo[icolor][idir][dit()].define(loIrregColor,curEBISBox.getEBGraph());
m_vofItIrregColorDomHi[icolor][idir][dit()].define(hiIrregColor,curEBISBox.getEBGraph());
}
VoFIterator& vofitcolor = m_vofItIrregColor[icolor][dit()];
for (vofitcolor.reset(); vofitcolor.ok(); ++vofitcolor)
{
const VolIndex& vof = vofitcolor();
VoFStencil& curStencil = curStencilBaseIVFAB(vof,0);
VoFStencil& colorStencil = colorStencilBaseIVFAB(vof,0);
VoFStencil& rhsColorStencil = rhsColorStencilBaseIVFAB(vof,0);
Real weightIrreg = m_alpha*curAlphaWeight(vof,0) + m_beta*curBetaWeight(vof,0);
colorStencil = curStencil;
colorStencil *= (-1.0/weightIrreg);
colorStencil.add(vof, 1.0);
rhsColorStencil.add(vof, 1.0/weightIrreg);
}
Vector<VolIndex> srcVofs = m_vofItIrregColor[icolor][dit()].getVector();
//color ebstencils
m_colorEBStencil[icolor][dit()] = RefCountedPtr<EBStencil>(new EBStencil(srcVofs, colorStencil[dit()] , m_eblg.getDBL().get(dit()), m_eblg.getEBISL()[dit()], m_ghostCellsPhi, m_ghostCellsPhi));
m_rhsColorEBStencil[icolor][dit()] = RefCountedPtr<EBStencil>(new EBStencil(srcVofs, rhsColorStencil[dit()] , m_eblg.getDBL().get(dit()) , m_eblg.getEBISL()[dit()], m_ghostCellsRHS, m_ghostCellsPhi));
}//dit
}//color
CH_STOP(t2);
}
void
BoxLayout::define(const LayoutData<Box>& a_newLayout)
{
const BoxLayout& baseLayout = a_newLayout.boxLayout();
// First copy from the base layout.
m_boxes = RefCountedPtr<Vector<Entry> >(
new Vector<Entry>(*(baseLayout.m_boxes)));
m_layout = baseLayout.m_layout;
#ifdef CH_MPI
m_dataIndex = baseLayout.m_dataIndex;
#endif
// Now replace each box with the new box.
// This is Vector<Box*> because a_newLayout is LayoutData<Box>.
// It is LOCAL only.
const Vector<Box*>& ptrNewBoxes = a_newLayout.m_vector;
#ifdef CH_MPI
int len = ptrNewBoxes.size();
Vector<Box> localNewBoxes(len);
for (int ivec = 0; ivec < len; ivec++)
{
localNewBoxes[ivec] = Box(*(ptrNewBoxes[ivec]));
}
Vector< Vector<Box> > gatheredNewBoxes;
int iprocdest = 0;
gather(gatheredNewBoxes, localNewBoxes, iprocdest);
// Now iprocdest has every Box gatheredNewBoxes[iproc][ivec].
// We want to broadcast gatheredNewBoxes to allNewBoxes,
// but we have to do it one Vector<Box> at a time.
Vector< Vector<Box> > allNewBoxes;
allNewBoxes.resize(numProc());
if (CHprocID() == iprocdest)
{
for (int iproc = 0; iproc < numProc(); iproc++)
{
allNewBoxes[iproc] = Vector<Box>(gatheredNewBoxes[iproc]);
}
}
// Processor iprocdest knows Vector< Vector<Box> > allNewBoxes.
// Now broadcast it.
for (int iproc = 0; iproc < numProc(); iproc++)
{
// void broadcast(T& a_inAndOut, int a_src) requires for T:
// linearSize<T>, linearIn<T>, linearOut<T>.
broadcast(allNewBoxes[iproc], iprocdest);
}
// Now every processor knows Vector< Vector<Box> > allNewBoxes.
// indexProc[proc] is current index within proc.
Vector<unsigned int> indexProc(numProc(), 0);
unsigned int proc;
unsigned int indexLocal;
for (int ivec = 0; ivec < m_boxes->size(); ivec++)
{
proc = (*m_boxes)[ivec].m_procID;
indexLocal = indexProc[proc];
(*m_boxes)[ivec].box = Box(allNewBoxes[proc][indexLocal]);
indexProc[proc]++;
}
#else
for (int ivec = 0; ivec < m_boxes->size(); ivec++)
{
(*m_boxes)[ivec].box = Box(*(ptrNewBoxes[ivec]));
}
#endif
closeNoSort(); // does: *m_sorted = false; *m_closed = true; buildDataIndex();
}
void LayoutRepository::addDefault(LayoutData data)
{
mDefaultLayouts.push_back(data.getUid());
mLayouts.push_back(data);
}
/** insert the hardcoded layouts into mLayouts.
*
*/
void LayoutRepository::addDefaults()
{
mDefaultLayouts.clear();
/*
*
3D______________
3D
3D AD
3D ACS
Oblique ________
3D AnyDual x1
3D AnyDual x2
AnyDual x3
Orthogonal______
3D ACS x1
3D ACS x2
ACS x3
RT______________
RT
Us Acq
*/
// ------------------------------------------------------
// --- group of 3D-based layouts ------------------------
// ------------------------------------------------------
this->addDefault(LayoutData::createHeader("LAYOUT_GROUP_3D", "3D"));
{
// 3D only
LayoutData layout = LayoutData::create("LAYOUT_3D", "3D", 1, 1);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0));
this->addDefault(layout);
}
{
// 3D ACS
LayoutData layout = LayoutData::create("LAYOUT_3D_ACS", "3D ACS", 3, 4);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 3, 3));
layout.setView(1, ptAXIAL, LayoutRegion(0, 3));
layout.setView(1, ptCORONAL, LayoutRegion(1, 3));
layout.setView(1, ptSAGITTAL, LayoutRegion(2, 3));
this->addDefault(layout);
}
{
// A 3DCS
LayoutData layout = LayoutData::create("LAYOUT_A_3DCS", "A 3DCS", 3, 4);
layout.setView(1, ptAXIAL, LayoutRegion(0, 0, 3, 3));
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 3));
layout.setView(1, ptCORONAL, LayoutRegion(1, 3));
layout.setView(1, ptSAGITTAL, LayoutRegion(2, 3));
this->addDefault(layout);
}
{
// 3D 3DAC
LayoutData layout = LayoutData::create("LAYOUT_3D_3DAC", "3D 3DAC", 3, 5);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 3, 3));
layout.setView(1, View::VIEW_3D, LayoutRegion(0, 3, 1, 2));
layout.setView(2, ptAXIAL, LayoutRegion(1, 3, 1, 2));
layout.setView(2, ptCORONAL, LayoutRegion(2, 3, 1, 2));
this->addDefault(layout);
}
{
// 3D Any
LayoutData layout = LayoutData::create("LAYOUT_3D_AD", "3D AnyDual", 2, 4);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 2, 3));
layout.setView(1, ptANYPLANE, LayoutRegion(0, 3));
layout.setView(1, ptSIDEPLANE, LayoutRegion(1, 3));
this->addDefault(layout);
}
{
// 3D ACS in a single view group
LayoutData layout = LayoutData::create("LAYOUT_3D_ACS_SINGLE", "3D ACS Connected", 3, 4);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 3, 3));
layout.setView(0, ptAXIAL, LayoutRegion(0, 3));
layout.setView(0, ptCORONAL, LayoutRegion(1, 3));
layout.setView(0, ptSAGITTAL, LayoutRegion(2, 3));
this->addDefault(layout);
}
{
// 3D Any in a single view group
LayoutData layout = LayoutData::create("LAYOUT_3D_AD_SINGLE", "3D AnyDual Connected", 2, 4);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 2, 3));
layout.setView(0, ptANYPLANE, LayoutRegion(0, 3));
layout.setView(0, ptSIDEPLANE, LayoutRegion(1, 3));
this->addDefault(layout);
}
// ------------------------------------------------------
// --- group of oblique (Anyplane-based) layouts --------
// ------------------------------------------------------
this->addDefault(LayoutData::createHeader("LAYOUT_GROUP_Oblique", "Oblique"));
{
LayoutData layout = LayoutData::create("LAYOUT_OBLIQUE_3DAnyDual_x1", "3D Any Dual x1", 1, 3);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0));
layout.setView(1, ptANYPLANE, LayoutRegion(0, 1));
layout.setView(1, ptSIDEPLANE, LayoutRegion(0, 2));
this->addDefault(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_OBLIQUE_3DAnyDual_x2", "3D Any Dual x2", 2, 3);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 2, 1));
layout.setView(1, ptANYPLANE, LayoutRegion(0, 1));
layout.setView(1, ptSIDEPLANE, LayoutRegion(1, 1));
layout.setView(2, ptANYPLANE, LayoutRegion(0, 2));
layout.setView(2, ptSIDEPLANE, LayoutRegion(1, 2));
this->addDefault(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_OBLIQUE_AnyDual_x3", "Any Dual x3", 2, 3);
layout.setView(0, ptANYPLANE, LayoutRegion(0, 0));
layout.setView(0, ptSIDEPLANE, LayoutRegion(1, 0));
layout.setView(1, ptANYPLANE, LayoutRegion(0, 1));
layout.setView(1, ptSIDEPLANE, LayoutRegion(1, 1));
layout.setView(2, ptANYPLANE, LayoutRegion(0, 2));
layout.setView(2, ptSIDEPLANE, LayoutRegion(1, 2));
this->addDefault(layout);
}
// ------------------------------------------------------
// --- group of orthogonal (ACS-based) layouts ----------
// ------------------------------------------------------
this->addDefault(LayoutData::createHeader("LAYOUT_GROUP_Orthogonal", "Orthogonal"));
{
LayoutData layout = LayoutData::create("LAYOUT_ORTHOGONAL_3DACS_x1", "3D ACS x1", 2, 2);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0));
layout.setView(1, ptAXIAL, LayoutRegion(0, 1));
layout.setView(1, ptCORONAL, LayoutRegion(1, 0));
layout.setView(1, ptSAGITTAL, LayoutRegion(1, 1));
this->addDefault(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_ORTHOGONAL_3DACS_x2", "3D ACS x2", 3, 3);
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 0, 3, 1));
layout.setView(1, ptAXIAL, LayoutRegion(0, 1));
layout.setView(1, ptCORONAL, LayoutRegion(1, 1));
layout.setView(1, ptSAGITTAL, LayoutRegion(2, 1));
layout.setView(2, ptAXIAL, LayoutRegion(0, 2));
layout.setView(2, ptCORONAL, LayoutRegion(1, 2));
layout.setView(2, ptSAGITTAL, LayoutRegion(2, 2));
this->addDefault(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_ORTHOGONAL_3DACS_x3", "ACS x3", 3, 3);
layout.setView(0, ptAXIAL, LayoutRegion(0, 0));
layout.setView(0, ptCORONAL, LayoutRegion(1, 0));
layout.setView(0, ptSAGITTAL, LayoutRegion(2, 0));
layout.setView(1, ptAXIAL, LayoutRegion(0, 1));
layout.setView(1, ptCORONAL, LayoutRegion(1, 1));
layout.setView(1, ptSAGITTAL, LayoutRegion(2, 1));
layout.setView(2, ptAXIAL, LayoutRegion(0, 2));
layout.setView(2, ptCORONAL, LayoutRegion(1, 2));
layout.setView(2, ptSAGITTAL, LayoutRegion(2, 2));
this->addDefault(layout);
}
// ------------------------------------------------------
// --- group of RTsource-based layouts - single viewgroup
// ------------------------------------------------------
this->addDefault(LayoutData::createHeader("LAYOUT_GROUP_RT", "Realtime Source"));
{
LayoutData layout = LayoutData::create("LAYOUT_RT_1X1", "RT", 1, 1);
layout.setView(0, View::VIEW_REAL_TIME, LayoutRegion(0, 0));
this->addDefault(layout);
}
{
LayoutData layout = LayoutData::create("LAYOUT_US_Acquisition", "US Acquisition", 2, 3);
layout.setView(0, ptANYPLANE, LayoutRegion(1, 2, 1, 1));
layout.setView(0, View::VIEW_3D, LayoutRegion(0, 2, 1, 1));
layout.setView(0, View::VIEW_REAL_TIME, LayoutRegion(0, 0, 2, 2));
this->addDefault(layout);
}
}
void
EBMGAverage::
defineStencils()
{
CH_TIME("EBMGInterp::defineStencils");
DisjointBoxLayout gridsStenCoar;
EBISLayout ebislStenCoar;
DisjointBoxLayout gridsStenFine;
EBISLayout ebislStenFine;
if (m_layoutChanged)
{
if (m_coarsenable)
{
gridsStenCoar = m_buffGrids;
ebislStenCoar = m_buffEBISL;
gridsStenFine = m_fineGrids;
ebislStenFine = m_fineEBISL;
}
else
{
gridsStenCoar = m_coarGrids;
ebislStenCoar = m_coarEBISL;
gridsStenFine = m_buffGrids;
ebislStenFine = m_buffEBISL;
}
}
else
{
gridsStenCoar = m_coarGrids;
ebislStenCoar = m_coarEBISL;
gridsStenFine = m_fineGrids;
ebislStenFine = m_fineEBISL;
}
{
CH_TIME("graph walking");
LayoutData<Vector<VoFStencil> > averageStencil;
LayoutData<VoFIterator > vofItIrregCoar;
LayoutData<VoFIterator > vofItIrregFine;
m_averageEBStencil.define(gridsStenCoar);
averageStencil.define( gridsStenCoar);
vofItIrregFine.define( gridsStenCoar); //not wrong. trust me.
vofItIrregCoar.define( gridsStenCoar);
for (DataIterator dit = gridsStenCoar.dataIterator(); dit.ok(); ++dit)
{
Box refBox(IntVect::Zero, IntVect::Zero);
refBox.refine(m_refRat);
int numFinePerCoar = refBox.numPts();
const Box& boxFine = gridsStenFine[dit()];
const EBISBox& ebisBoxFine = ebislStenFine[dit()];
const EBGraph& ebGraphFine = ebisBoxFine.getEBGraph();
const Box& boxCoar = gridsStenCoar[dit()];
const EBISBox& ebisBoxCoar = ebislStenCoar[dit()];
const EBGraph& ebGraphCoar = ebisBoxCoar.getEBGraph();
IntVectSet notRegularCoar = ebisBoxCoar.getIrregIVS(boxCoar);
vofItIrregCoar[dit()].define(notRegularCoar, ebGraphCoar);
IntVectSet ivsFine = refine(notRegularCoar, m_refRat);
vofItIrregFine[dit()].define(ivsFine, ebGraphFine);
const Vector<VolIndex>& allCoarVofs = vofItIrregCoar[dit()].getVector();
Vector<VoFStencil>& averageStencils = averageStencil[dit()];
averageStencils.resize(allCoarVofs.size());
for (int icoar = 0; icoar < allCoarVofs.size(); icoar++)
{
Vector<VolIndex> fineVofs;
if (m_refRat > 2)
{
fineVofs = ebislStenCoar.refine(allCoarVofs[icoar], m_refRat, dit());
}
else
{
fineVofs = ebislStenCoar[dit()].refine(allCoarVofs[icoar]);
}
VoFStencil& averageStencil = averageStencils[icoar];
for (int ifine = 0; ifine < fineVofs.size(); ifine++)
{
averageStencil.add(fineVofs[ifine], 1./numFinePerCoar);
}
}
m_averageEBStencil[dit()] = RefCountedPtr<EBStencil>(new EBStencil(allCoarVofs, averageStencil[dit()], boxCoar, boxFine, ebisBoxCoar, ebisBoxFine, m_ghost, m_ghost));
}
}
}
