void VCAMRPoissonOp2::reflux(const LevelData<FArrayBox>& a_phiFine,
const LevelData<FArrayBox>& a_phi,
LevelData<FArrayBox>& a_residual,
AMRLevelOp<LevelData<FArrayBox> >* a_finerOp)
{
CH_TIME("VCAMRPoissonOp2::reflux");
int ncomp = 1;
ProblemDomain fineDomain = refine(m_domain, m_refToFiner);
LevelFluxRegister levfluxreg(a_phiFine.disjointBoxLayout(),
a_phi.disjointBoxLayout(),
fineDomain,
m_refToFiner,
ncomp);
levfluxreg.setToZero();
Interval interv(0,a_phi.nComp()-1);
DataIterator dit = a_phi.dataIterator();
for (dit.reset(); dit.ok(); ++dit)
{
const FArrayBox& coarfab = a_phi[dit];
const FluxBox& coarBCoef = (*m_bCoef)[dit];
const Box& gridBox = a_phi.getBoxes()[dit];
for (int idir = 0; idir < SpaceDim; idir++)
{
FArrayBox coarflux;
Box faceBox = surroundingNodes(gridBox, idir);
getFlux(coarflux, coarfab, coarBCoef , faceBox, idir);
Real scale = 1.0;
levfluxreg.incrementCoarse(coarflux, scale,dit(),
interv,interv,idir);
}
}
LevelData<FArrayBox>& p = ( LevelData<FArrayBox>&)a_phiFine;
// has to be its own object because the finer operator
// owns an interpolator and we have no way of getting to it
VCAMRPoissonOp2* finerAMRPOp = (VCAMRPoissonOp2*) a_finerOp;
QuadCFInterp& quadCFI = finerAMRPOp->m_interpWithCoarser;
quadCFI.coarseFineInterp(p, a_phi);
// p.exchange(a_phiFine.interval()); // BVS is pretty sure this is not necesary.
IntVect phiGhost = p.ghostVect();
DataIterator ditf = a_phiFine.dataIterator();
const DisjointBoxLayout& dblFine = a_phiFine.disjointBoxLayout();
for (ditf.reset(); ditf.ok(); ++ditf)
{
const FArrayBox& phifFab = a_phiFine[ditf];
const FluxBox& fineBCoef = (*(finerAMRPOp->m_bCoef))[ditf];
const Box& gridbox = dblFine.get(ditf());
for (int idir = 0; idir < SpaceDim; idir++)
{
int normalGhost = phiGhost[idir];
SideIterator sit;
for (sit.begin(); sit.ok(); sit.next())
{
Side::LoHiSide hiorlo = sit();
Box fabbox;
Box facebox;
// assumption here that the stencil required
// to compute the flux in the normal direction
// is 2* the number of ghost cells for phi
// (which is a reasonable assumption, and probably
// better than just assuming you need one cell on
// either side of the interface
// (dfm 8-4-06)
if (sit() == Side::Lo)
{
fabbox = adjCellLo(gridbox,idir, 2*normalGhost);
fabbox.shift(idir, 1);
facebox = bdryLo(gridbox, idir,1);
}
else
{
fabbox = adjCellHi(gridbox,idir, 2*normalGhost);
fabbox.shift(idir, -1);
facebox = bdryHi(gridbox, idir, 1);
}
// just in case we need ghost cells in the transverse direction
// (dfm 8-4-06)
for (int otherDir=0; otherDir<SpaceDim; ++otherDir)
{
if (otherDir != idir)
{
fabbox.grow(otherDir, phiGhost[otherDir]);
}
}
CH_assert(!fabbox.isEmpty());
FArrayBox phifab(fabbox, a_phi.nComp());
phifab.copy(phifFab);
FArrayBox fineflux;
getFlux(fineflux, phifab, fineBCoef, facebox, idir,
m_refToFiner);
Real scale = 1.0;
levfluxreg.incrementFine(fineflux, scale, ditf(),
interv, interv, idir, hiorlo);
}
}
}
Real scale = 1.0/m_dx;
levfluxreg.reflux(a_residual, scale);
}
void CollisionTest::display()
{
const static GLfloat lightPosition[] = {1, -1, 0, 0};
const static GLfloat lightPositionMirror[] = { 1, 1, 0, 0 };
// Update the transform matrices of each box in turn.
for (Box *box = boxData; box < boxData + boxes; box++)
{
box->calculateInternals();
box->isOverlapping = false;
}
// Update the transform matrices of each ball in turn.
for (Ball *ball = ballData; ball < ballData + balls; ball++)
{
// Run the physics.
ball->calculateInternals();
}
// Clear the viewport and set the camera direction.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(18.0f, 0, 0, 0, 0, 0, 0, 1.0f, 0);
glRotatef(-phi, 0, 0, 1);
glRotatef(theta, 0, 1, 0);
glTranslatef(0, -5.0f, 0);
// Render each element in turn as a shadow.
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
glEnable(GL_LIGHT0);
glPushMatrix();
glMultMatrixf(floorMirror);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
for (Box *box = boxData; box < boxData + boxes; box++)
{
box->render();
}
for (Ball *ball = ballData; ball < ballData + balls; ball++)
{
ball->render();
}
glPopMatrix();
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
DrawGrid(Vector3(35, 0, 30), 60);
// Render each shadow in turn
glEnable(GL_BLEND);
glColor4f(0, 0, 0, 0.1f);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for (Box *box = boxData; box < boxData + boxes; box++)
{
box->renderShadow();
}
for (Ball *ball = ballData; ball < ballData + balls; ball++)
{
ball->renderShadow();
}
glDisable(GL_BLEND);
// Render the boxes themselves
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_POSITION, lightPositionMirror);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
for (Box *box = boxData; box < boxData + boxes; box++)
{
box->render();
}
for (Ball *ball = ballData; ball < ballData + balls; ball++)
{
ball->render();
}
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
drawDebug();
}
void
LevelFluxRegisterEdge::refluxCurl(LevelData<FluxBox>& a_uCoarse,
Real a_scale)
{
CH_assert(isDefined());
CH_assert(a_uCoarse.nComp() == m_nComp);
SideIterator side;
// idir is the normal direction to the coarse-fine interface
for (int idir=0 ; idir<SpaceDim; ++idir)
{
for (side.begin(); side.ok(); ++side)
{
LevelData<FluxBox>& fineReg = m_fabFine[index(idir, side())];
// first, create temp LevelData<FluxBox> to hold "coarse flux"
const DisjointBoxLayout coarseBoxes = m_regCoarse.getBoxes();
// this fills the place of what used to be m_fabCoarse in the old
// implementation
LevelData<FluxBox> coarReg(coarseBoxes, m_nComp, IntVect::Unit);
// now fill the coarReg with the curl of the stored coarse-level
// edge-centered flux
DataIterator crseDit = coarseBoxes.dataIterator();
for (crseDit.begin(); crseDit.ok(); ++crseDit)
{
FluxBox& thisCoarReg = coarReg[crseDit];
thisCoarReg.setVal(0.0);
EdgeDataBox& thisEdgeData = m_regCoarse[crseDit];
for (int edgeDir=0; edgeDir<SpaceDim; edgeDir++)
{
if (idir != edgeDir)
{
FArrayBox& crseEdgeDataDir = thisEdgeData[edgeDir];
for (int faceDir = 0; faceDir<SpaceDim; faceDir++)
{
if (faceDir != edgeDir)
{
FArrayBox& faceData = thisCoarReg[faceDir];
int shiftDir = -1;
for (int i=0; i<SpaceDim; i++)
{
if ((i != faceDir) && (i != edgeDir) )
{
shiftDir = i;
}
}
CH_assert(shiftDir >= 0);
crseEdgeDataDir.shiftHalf(shiftDir, sign(side()));
// scaling already taken care of in incrementCrse
Real scale = 1.0;
faceData.plus(crseEdgeDataDir, scale, 0, 0, faceData.nComp());
crseEdgeDataDir.shiftHalf(shiftDir, -sign(side()));
} // end if not normal direction
} // end loop over face directions
} // end if edgeDir != idir
} // end loop over edge directions
} // end loop over crse boxes
// first, we need to create a temp LevelData<FluxBox>
// to make a local copy in the coarse layout space of
// the fine register increments
LevelData<FluxBox> fineRegLocal(coarReg.getBoxes(), m_nComp, IntVect::Unit);
fineReg.copyTo(fineReg.interval(), fineRegLocal,
fineRegLocal.interval(),
m_crseCopiers[index(idir,side())]);
for (DataIterator it = a_uCoarse.dataIterator(); it.ok(); ++it)
{
// loop over flux components here
for (int fluxComp=0; fluxComp < SpaceDim; fluxComp++)
{
// we don't do anything in the normal direction
if (fluxComp != idir)
{
// fluxDir is the direction of the face-centered flux
FArrayBox& U = a_uCoarse[it()][fluxComp];
// set up IntVectSet to avoid double counting of updates
Box coarseGridBox = U.box();
// transfer to Cell-centered, then create IVS
coarseGridBox.shiftHalf(fluxComp,1);
IntVectSet nonUpdatedEdges(coarseGridBox);
// remember, we want to take the curl here
// also recall that fluxComp is the component
// of the face-centered curl (not the edge-centered
// vector field that we're refluxing, which is why
// the sign may seem like it's the opposite of what
// you might expect!
Real local_scale = -sign(side())*a_scale;
//int testDir = (fluxComp+1)%(SpaceDim);
if (((fluxComp+1)%(SpaceDim)) == idir) local_scale *= -1;
Vector<IntVectSet>& ivsV =
m_refluxLocations[index(idir, side())][it()][fluxComp];
Vector<DataIndex>& indexV =
m_coarToCoarMap[index(idir, side())][it()];
IVSIterator iv;
for (int i=0; i<ivsV.size(); ++i)
{
iv.define(ivsV[i]);
const FArrayBox& coar = coarReg[indexV[i]][fluxComp];
const FArrayBox& fine = fineRegLocal[indexV[i]][fluxComp];
for (iv.begin(); iv.ok(); ++iv)
{
IntVect thisIV = iv();
if (nonUpdatedEdges.contains(thisIV))
{
for (int comp=0; comp <m_nComp; ++comp)
{
//Real coarVal = coar(thisIV, comp);
//Real fineVal = fine(thisIV, comp);
U(thisIV, comp) -=
local_scale*(coar(thisIV, comp)
+fine(thisIV, comp));
}
nonUpdatedEdges -= thisIV;
}
}
}
} // end if not normal face
} // end loop over fluxbox directions
} // end loop over coarse boxes
} // end loop over sides
} // end loop over directions
}
// Computes omega = A*psi
void execute( const vector<complex>& psi, vector<complex>& omega )
{
#if STAGE_TIMES
StopWatch timer;
timer.start();
#endif
int nLevels = tree.numLevels();
// Compute lowest level multipole
Level<DIM>& leafLevel = getLevel(nLevels);
leafLevel.zeroFields();
for( BoxIter bi = leafLevel.boxbegin(); bi != leafLevel.boxend(); ++bi ) {
Box* b = *bi;
const Vec3& center = b->center;
const Box::pointIter piEnd = b->pointIndex.end();
for( Box::pointIter pi = b->pointIndex.begin(); pi != piEnd; ++pi ) {
int index = *pi;
const Vec3 r = center - sourcefield[index];
cout << "Accumulating " << index << " into Box " << b->n << endl;
Translation_Function::add( r, psi[index], b->getMultipole() );
}
}
#if STAGE_TIMES
cout << "Lowest Level Multipoles Done " << timer.stop() << endl;
#endif
// Upward Pass - Compute the multipoles
for( int L = nLevels; L >= 3; --L ) {
Level<DIM>& level = getLevel(L);
Level<DIM>& pLevel = getLevel(L-1);
pLevel.zeroFields();
NFunction& Ms = pLevel.getScratch();
// For all boxes at level L
for( BoxIter bi = level.boxbegin(); bi != level.boxend(); ++bi ) {
Box* b = *bi;
// Interpolate to the parent level L-1
level.getInterp().apply( b->getMultipole(), Ms );
// Multiply by the transfer function and accumulate into parent
b->parent->getMultipole().addProduct( Ms, pLevel.getTranslationUp(b) );
}
}
#if STAGE_TIMES
cout << "Upward Pass Done " << timer.stop() << endl;
#endif
// Do the Transfers
for( int L = nLevels; L >= 2; --L ) {
getLevel(L).applyTransferFunctions();
}
#if STAGE_TIMES
cout << "Transfer List Applied " << timer.stop() << endl;
#endif
for( int L = 3; L <= nLevels; ++L ) {
Level<DIM>& level = getLevel(L);
Level<DIM>& pLevel = getLevel(L-1);
NFunction& Lb = level.getScratch();
NFunction& LB = pLevel.getScratch();
// For all boxes at level L
for( BoxIter bi = level.boxbegin(); bi != level.boxend(); ++bi ) {
Box* b = *bi;
// Multiply parent's local expansion by translation function
LB.setProduct( b->parent->getLocal(), pLevel.getTranslationDown(b) );
// Anterpolate
pLevel.getAnterp().apply( LB, Lb );
// Accumulate into the box's local expansion
b->getLocal().add( Lb );
}
}
#if STAGE_TIMES
cout << "Downward Pass Done " << timer.stop() << endl;
#endif
// Zero omega
omega.assign( omega.size(), 0 );
// Integrate and add close interactions
// For all the boxes at the lowest level, integrate local
NFunction& LE = leafLevel.getScratch(); // Scratch space
for( BoxIter bi = leafLevel.boxbegin(); bi != leafLevel.boxend(); ++bi ) {
Box* b = *bi;
Vec3& center = b->center;
// for all interior points
const Box::pointIter nEnd = b->pointIndex.end();
for( Box::pointIter ni = b->pointIndex.begin(); ni != nEnd; ++ni ) {
int n = *ni;
const Vec3& pn = sourcefield[n];
Vec3 r = pn - center;
//cout << "Integrating for " << n << " from box " << b->n << endl;
Translation_Function::times( b->getLocal(), r, LE );
omega[n] += LE.integrate();
// Add contributions from other points inside this box
for( Box::pointIter mi = b->pointIndex.begin(); mi != ni; ++mi ) {
int m = *mi;
double r = pn.dist(sourcefield[m]);
complex E = K(r);
omega[m] += psi[n] * E;
omega[n] += psi[m] * E;
}
}
}
#if STAGE_TIMES
cout << "Local Integration Done " << timer.stop() << endl;
#endif
leafLevel.applyClose(K, psi, sourcefield, omega);
#if STAGE_TIMES
cout << "Close List Applied " << timer.stop() << endl;
#endif
}
void drawScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//brown color of the board
glPushMatrix();
glTranslatef(0.0f, 0.0f, -8.0f);
glBegin(GL_QUADS);
glColor3f(0.0f, 0.0f, 0.0f);
glVertex2f(-3.0f , -3.0f);
glVertex2f(-3.0f , 3.0f);
glVertex2f(3.0f , 3.0f);
glVertex2f(3.0f , -3.0f);
glEnd();
glPopMatrix();
//cream color of the board
glPushMatrix();
glTranslatef(0.0f, 0.0f, -8.0f);
glBegin(GL_QUADS);
glColor3f(1.0f, 0.8f, 0.45f);
glVertex2f(-2.75f , -2.75f);
glVertex2f(-2.75f , 2.75f);
glVertex2f(2.75f , 2.75f);
glVertex2f(2.75f , -2.75f);
glEnd();
glPopMatrix();
//holes
glTranslatef(0.0f, 0.0f, -8.0f);
glPushMatrix();
hol[0].drawhole(hol[0].a,hol[0].c,-8.0f,0.0f,0.0f,0.0f,hol[0].rad);
glPopMatrix();
glPushMatrix();
hol[0].drawhole(hol[1].a,hol[1].c,-8.0f,0.0f,0.0f,0.0f,hol[1].rad);
glPopMatrix();
glPushMatrix();
hol[0].drawhole(hol[2].a,hol[2].c,-8.0f,0.0f,0.0f,0.0f,hol[2].rad);
glPopMatrix();
glPushMatrix();
hol[0].drawhole(hol[3].a,hol[3].c,-8.0f,0.0f,0.0f,0.0f,hol[3].rad);
glPopMatrix();
//circle at centre
glPushMatrix();
c.drawCircle(0.0f,0.0f,-8.0f,0.0f,0.0f,0.0f,1.50f);
glPopMatrix();
//striker box
glPushMatrix();
u.drawstrikerbox(7.0f,0.58f,0.0f,4.0f,-8.0f,0.0f,0.0f,0.0f);
glPopMatrix();
glPushMatrix();
u1.drawstrikerbox(7.0f,0.58f,0.0f,-4.0f,-8.0f,0.0f,0.0f,0.0f);
glPopMatrix();
glPushMatrix();
u2.drawstrikerbox(0.58f,7.0f,4.0f,0.0f,-8.0f,0.0f,0.0f,0.0f);
glPopMatrix();
glPushMatrix();
u3.drawstrikerbox(0.58f,7.0f,-4.0f,0.0f,-8.0f,0.0f,0.0f,0.0f);
glPopMatrix();
//stricker box holes
glPushMatrix();
hole[0].drawhole(3.5f,4.0f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[1].drawhole(-4.0f,3.5f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[2].drawhole(-3.5f,-4.0f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[3].drawhole(4.0f,-3.5f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[4].drawhole(3.5f,-4.0f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[5].drawhole(4.0f,3.5f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[6].drawhole(-3.5f,4.0f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
glPushMatrix();
hole[7].drawhole(-4.0f,-3.5f,-8.0f,1.0f,0.0f,0.0f,0.3f);
glPopMatrix();
//coins
glPushMatrix();
coin[0].drawcoin(coin[0].a,coin[0].c,-8.0f,0.0f,0.0f,0.0f,coin[0].rad);
glPopMatrix();
glPushMatrix();
coin[1].drawcoin(coin[1].a,coin[1].c,-8.0f,0.0f,0.0f,0.0f,coin[1].rad);
glPopMatrix();
glPushMatrix();
coin[2].drawcoin(coin[2].a,coin[2].c,-8.0f,0.0f,0.0f,0.0f,coin[2].rad);
glPopMatrix();
glPushMatrix();
coin[3].drawcoin(coin[3].a,coin[3].c,-8.0f,0.0f,0.0f,0.0f,coin[3].rad);
glPopMatrix();
glPushMatrix();
coin[4].drawcoin(coin[4].a,coin[4].c,-8.0f,0.8f,0.4f,0.0f,coin[4].rad);
glPopMatrix();
glPushMatrix();
coin[5].drawcoin(coin[5].a,coin[5].c,-8.0f,0.8f,0.4f,0.0f,coin[5].rad);
glPopMatrix();
glPushMatrix();
coin[6].drawcoin(coin[6].a,coin[6].c,-8.0f,0.8f,0.4f,0.0f,coin[6].rad);
glPopMatrix();
glPushMatrix();
coin[7].drawcoin(coin[7].a,coin[7].c,-8.0f,0.8f,0.4f,0.0f,coin[7].rad);
glPopMatrix();
glPushMatrix();
coin[8].drawcoin(coin[8].a,coin[8].c,-8.0f,1.0f,0.0f,0.0f,coin[8].rad);
glPopMatrix();
// striker
glPushMatrix();
s[0].drawstriker(s[0].a,s[0].c,-8.0f,0.0f,1.0f,0.0f,s[0].rad);
glPopMatrix();
//striker pointer
glPushMatrix();
glTranslatef(s[0].a,s[0].c,-8.0f);
glColor3f(0.0f,0.0f,0.0f);
glRotatef(theta,0.0f,0.0f,-1.0f);
glBegin(GL_LINES);
glVertex2f(0.0f,0.0f);
glVertex2f(lx,ly);
glEnd();
glPopMatrix();
// speedometer
glPushMatrix();
glBegin(GL_QUADS);
glColor3f(0.0,1.0,0.0);
glVertex2f(3.8,-3.0);
glVertex2f(4.0,-3.0);
glVertex2f(4.0,pointer);
glVertex2f(3.8,pointer);
glColor3f(1.0,0.0,0.1);
glVertex2f(4.0,2.0);
glVertex2f(3.8,2.0);
glVertex2f(3.8,pointer);
glVertex2f(4.0,pointer);
glEnd();
glColor3f(0.4,0.3,0.1);
glVertex2f(0.48,pointer);
glVertex2f(0.55,pointer);
glPopMatrix();
//score-board
scoreBoard.drawBox();
glColor3f(0.0f,0.0f,1.0f);
char string[] = "Score";
scoreBoard.drawText(string,strlen(string),-0.7f,0.2f);
ostringstream sc;
sc<<scoreBoard.score1;
score1 = sc.str();
scoreBoard.drawText(score1.data(),score1.size(),-0.2f,-0.4f);
glutSwapBuffers();
}
KOKKOS_INLINE_FUNCTION
bool isValid( Box const &b )
{
return isValid( b.minCorner() ) && isValid( b.maxCorner() );
}
Mesh* Sphere::GenerateMesh()
{
Box box;
return box.GenerateMesh();
}
void MeshFromSpline2D (SplineGeometry2d & geometry,
Mesh *& mesh,
MeshingParameters & mp)
{
PrintMessage (1, "Generate Mesh from spline geometry");
double h = mp.maxh;
Box<2> bbox = geometry.GetBoundingBox ();
if (bbox.Diam() < h)
{
h = bbox.Diam();
mp.maxh = h;
}
mesh = new Mesh;
mesh->SetDimension (2);
geometry.PartitionBoundary (h, *mesh);
// marks mesh points for hp-refinement
for (int i = 0; i < geometry.GetNP(); i++)
if (geometry.GetPoint(i).hpref)
{
double mindist = 1e99;
PointIndex mpi(0);
Point<2> gp = geometry.GetPoint(i);
Point<3> gp3(gp(0), gp(1), 0);
for (PointIndex pi = PointIndex::BASE;
pi < mesh->GetNP()+PointIndex::BASE; pi++)
if (Dist2(gp3, (*mesh)[pi]) < mindist)
{
mpi = pi;
mindist = Dist2(gp3, (*mesh)[pi]);
}
(*mesh)[mpi].Singularity(1.);
}
int maxdomnr = 0;
for (SegmentIndex si = 0; si < mesh->GetNSeg(); si++)
{
if ( (*mesh)[si].domin > maxdomnr) maxdomnr = (*mesh)[si].domin;
if ( (*mesh)[si].domout > maxdomnr) maxdomnr = (*mesh)[si].domout;
}
mesh->ClearFaceDescriptors();
for (int i = 1; i <= maxdomnr; i++)
mesh->AddFaceDescriptor (FaceDescriptor (i, 0, 0, i));
// set Array<string*> bcnames...
// number of bcnames
int maxsegmentindex = 0;
for (SegmentIndex si = 0; si < mesh->GetNSeg(); si++)
{
if ( (*mesh)[si].si > maxsegmentindex) maxsegmentindex = (*mesh)[si].si;
}
mesh->SetNBCNames(maxsegmentindex);
for ( int sindex = 0; sindex < maxsegmentindex; sindex++ )
mesh->SetBCName ( sindex, geometry.GetBCName( sindex+1 ) );
for (SegmentIndex si = 0; si < mesh->GetNSeg(); si++)
(*mesh)[si].SetBCName ( (*mesh).GetBCNamePtr( (*mesh)[si].si-1 ) );
Point3d pmin(bbox.PMin()(0), bbox.PMin()(1), -bbox.Diam());
Point3d pmax(bbox.PMax()(0), bbox.PMax()(1), bbox.Diam());
mesh->SetLocalH (pmin, pmax, mparam.grading);
mesh->SetGlobalH (h);
mesh->CalcLocalH();
int bnp = mesh->GetNP(); // boundary points
int hquad = mparam.quad;
for (int domnr = 1; domnr <= maxdomnr; domnr++)
if (geometry.GetDomainTensorMeshing (domnr))
{ // tensor product mesh
Array<PointIndex, PointIndex::BASE> nextpi(bnp);
Array<int, PointIndex::BASE> si1(bnp), si2(bnp);
PointIndex firstpi;
nextpi = -1;
si1 = -1;
si2 = -1;
for (SegmentIndex si = 0; si < mesh->GetNSeg(); si++)
{
int p1 = -1, p2 = -2;
if ( (*mesh)[si].domin == domnr)
{ p1 = (*mesh)[si][0]; p2 = (*mesh)[si][1]; }
if ( (*mesh)[si].domout == domnr)
{ p1 = (*mesh)[si][1]; p2 = (*mesh)[si][0]; }
if (p1 == -1) continue;
nextpi[p1] = p2; // counter-clockwise
int index = (*mesh)[si].si;
if (si1[p1] != index && si2[p1] != index)
{ si2[p1] = si1[p1]; si1[p1] = index; }
if (si1[p2] != index && si2[p2] != index)
{ si2[p2] = si1[p2]; si1[p2] = index; }
}
PointIndex c1(0), c2, c3, c4; // 4 corner points
int nex = 1, ney = 1;
for (PointIndex pi = 1; pi <= si2.Size(); pi++)
if (si2[pi] != -1)
{ c1 = pi; break; }
for (c2 = nextpi[c1]; si2[c2] == -1; c2 = nextpi[c2], nex++);
for (c3 = nextpi[c2]; si2[c3] == -1; c3 = nextpi[c3], ney++);
for (c4 = nextpi[c3]; si2[c4] == -1; c4 = nextpi[c4]);
Array<PointIndex> pts ( (nex+1) * (ney+1) ); // x ... inner loop
pts = -1;
for (PointIndex pi = c1, i = 0; pi != c2; pi = nextpi[pi], i++)
pts[i] = pi;
for (PointIndex pi = c2, i = 0; pi != c3; pi = nextpi[pi], i++)
pts[(nex+1)*i+nex] = pi;
for (PointIndex pi = c3, i = 0; pi != c4; pi = nextpi[pi], i++)
pts[(nex+1)*(ney+1)-i-1] = pi;
for (PointIndex pi = c4, i = 0; pi != c1; pi = nextpi[pi], i++)
pts[(nex+1)*(ney-i)] = pi;
for (PointIndex pix = nextpi[c1], ix = 0; pix != c2; pix = nextpi[pix], ix++)
for (PointIndex piy = nextpi[c2], iy = 0; piy != c3; piy = nextpi[piy], iy++)
{
Point<3> p = (*mesh)[pix] + ( (*mesh)[piy] - (*mesh)[c2] );
pts[(nex+1)*(iy+1) + ix+1] = mesh -> AddPoint (p , 1, FIXEDPOINT);
}
for (int i = 0; i < ney; i++)
for (int j = 0; j < nex; j++)
{
Element2d el(QUAD);
el[0] = pts[i*(nex+1)+j];
el[1] = pts[i*(nex+1)+j+1];
el[2] = pts[(i+1)*(nex+1)+j+1];
el[3] = pts[(i+1)*(nex+1)+j];
el.SetIndex (domnr);
mesh -> AddSurfaceElement (el);
}
}
for (int domnr = 1; domnr <= maxdomnr; domnr++)
{
if (geometry.GetDomainTensorMeshing (domnr)) continue;
if ( geometry.GetDomainMaxh ( domnr ) > 0 )
h = geometry.GetDomainMaxh(domnr);
PrintMessage (3, "Meshing domain ", domnr, " / ", maxdomnr);
int oldnf = mesh->GetNSE();
mparam.quad = hquad || geometry.GetDomainQuadMeshing (domnr);
Meshing2 meshing (Box<3> (pmin, pmax));
for (PointIndex pi = PointIndex::BASE; pi < bnp+PointIndex::BASE; pi++)
meshing.AddPoint ( (*mesh)[pi], pi);
PointGeomInfo gi;
gi.trignum = 1;
for (SegmentIndex si = 0; si < mesh->GetNSeg(); si++)
{
if ( (*mesh)[si].domin == domnr)
meshing.AddBoundaryElement ( (*mesh)[si][0] + 1 - PointIndex::BASE,
(*mesh)[si][1] + 1 - PointIndex::BASE, gi, gi);
if ( (*mesh)[si].domout == domnr)
meshing.AddBoundaryElement ( (*mesh)[si][1] + 1 - PointIndex::BASE,
(*mesh)[si][0] + 1 - PointIndex::BASE, gi, gi);
}
mparam.checkoverlap = 0;
meshing.GenerateMesh (*mesh, h, domnr);
for (SurfaceElementIndex sei = oldnf; sei < mesh->GetNSE(); sei++)
(*mesh)[sei].SetIndex (domnr);
// astrid
char * material;
geometry.GetMaterial( domnr, material );
if ( material )
{
(*mesh).SetMaterial ( domnr, material );
}
}
mparam.quad = hquad;
int hsteps = mp.optsteps2d;
mp.optimize2d = "smcm";
mp.optsteps2d = hsteps/2;
Optimize2d (*mesh, mp);
mp.optimize2d = "Smcm";
mp.optsteps2d = (hsteps+1)/2;
Optimize2d (*mesh, mp);
mp.optsteps2d = hsteps;
mesh->Compress();
mesh -> SetNextMajorTimeStamp();
extern void Render();
Render();
}
void
Moof::ParseTraf(Box& aBox, Trex& aTrex, Mvhd& aMvhd, Mdhd& aMdhd, Edts& aEdts, Sinf& aSinf, uint64_t* aDecodeTime, bool aIsAudio)
{
MOZ_ASSERT(aDecodeTime);
Tfhd tfhd(aTrex);
Tfdt tfdt;
for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
if (box.IsType("tfhd")) {
tfhd = Tfhd(box, aTrex);
} else if (!aTrex.mTrackId || tfhd.mTrackId == aTrex.mTrackId) {
if (box.IsType("tfdt")) {
tfdt = Tfdt(box);
} else if (box.IsType("saiz")) {
mSaizs.AppendElement(Saiz(box, aSinf.mDefaultEncryptionType));
} else if (box.IsType("saio")) {
mSaios.AppendElement(Saio(box, aSinf.mDefaultEncryptionType));
}
}
}
if (aTrex.mTrackId && tfhd.mTrackId != aTrex.mTrackId) {
return;
}
// Now search for TRUN boxes.
uint64_t decodeTime =
tfdt.IsValid() ? tfdt.mBaseMediaDecodeTime : *aDecodeTime;
for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
if (box.IsType("trun")) {
if (ParseTrun(box, tfhd, aMvhd, aMdhd, aEdts, &decodeTime, aIsAudio)) {
mValid = true;
} else {
mValid = false;
break;
}
}
}
*aDecodeTime = decodeTime;
}
int main(int argc, char* argv[])
{
#ifdef CH_MPI
MPI_Init(&argc, &argv);
// setChomboMPIErrorHandler();
MPI_Barrier(Chombo_MPI::comm); // Barrier #1
#endif
// ------------------------------------------------
// parse command line and input file
// ------------------------------------------------
// infile must be first
if (argc < 2)
{
cerr << " need inputs file" << endl;
abort();
}
char* in_file = argv[1];
ParmParse pp(argc-2, argv+2, NULL, in_file);
#ifdef CH_MPI
MPI_Barrier(Chombo_MPI::comm);
#endif
pout().setf(ios::scientific);
pout().precision(4);
// set defaults
bool isSameSize = false;
bool doGhostCells = false;
bool doPlots = true;
bool isTimeDep = false;
bool verbose = false;
bool computeRelativeError = false;
bool removeMean = false;
bool useUnitDomain = false;
bool HOaverage = false;
// this is the initial value for the error
Real bogusValue = 0.0;
string exactRoot, computedRoot, errorRoot;
Vector<string> errorVars;
int numCrseFinish, numCrseStart, crseStep, crseMult, intFieldSize;
init(exactRoot, computedRoot, errorRoot, intFieldSize,
numCrseStart, errorVars, numCrseFinish, crseStep,
crseMult, doPlots, isTimeDep, isSameSize, bogusValue,
computeRelativeError, removeMean, doGhostCells, useUnitDomain,
HOaverage,verbose);
int nStep, exactStep;
if (!isTimeDep)
{
crseStep = 1;
numCrseFinish = numCrseStart;
}
for (nStep = numCrseStart; nStep <= numCrseFinish; nStep += crseStep)
{
if (verbose)
{
pout() << "starting step " << nStep << endl;
}
exactStep = nStep*crseMult;
ostrstream exactFile;
ostrstream computedFile;
ostrstream errorFile;
exactFile.fill('0');
computedFile.fill('0');
errorFile.fill('0');
if (isTimeDep)
{
constructPlotFileName(exactFile, exactRoot, intFieldSize, exactStep);
constructPlotFileName(computedFile, computedRoot, intFieldSize, nStep);
constructPlotFileName(errorFile, errorRoot, intFieldSize, nStep);
}
else
{
// if not time dependent, file roots are really filenames
exactFile << exactRoot << ends;
computedFile << computedRoot << ends;
errorFile << errorRoot << ends;
}
pout() << "exact Filename = " << exactFile.str() << endl;
pout() << "computed Filename = " << computedFile.str() << endl;
if (doPlots)
{
pout() << "error Filename = " << errorFile.str() << endl;
}
// declare memory
Vector<LevelData<FArrayBox>* > exactSoln;
Vector<string> exactVars; // exact solution variable names
Vector<DisjointBoxLayout> exactGrids;
Box exactDomain;
Real exactDx, exactDt, exactTime;
Vector<int> exactRefRatio;
int exactNumLevels;
IntVect ghostVect = IntVect::Unit;
string exactFileName(exactFile.str());
// get exact solution
if (verbose)
{
pout() << "read exact solution..." << endl;
}
ReadAMRHierarchyHDF5(exactFileName,
exactGrids,
exactSoln,
exactVars,
exactDomain,
exactDx,
exactDt,
exactTime,
exactRefRatio,
exactNumLevels);
if (verbose)
{
pout () << "done reading exact soln" << endl;
}
// we assume that exact soln is single-grid if we're doing averaging
if (!isSameSize)
{
CH_assert(exactNumLevels == 1);
}
Vector<LevelData<FArrayBox>* > computedSoln;
Vector<string> computedVars; // computed soln variable names
Vector<DisjointBoxLayout> computedGrids;
Box computedDomain;
Real computedDx, computedDt, computedTime;
Vector<int> computedRefRatio;
int computedNumLevels;
string computedFileName(computedFile.str());
//ghostVect = IntVect::Zero;
// now read in computed solution
if (verbose)
{
pout() << "read computed solution..." << endl;
}
ReadAMRHierarchyHDF5(computedFileName,
computedGrids,
computedSoln,
computedVars,
computedDomain,
computedDx,
computedDt,
computedTime,
computedRefRatio,
computedNumLevels);
if (verbose)
{
pout() << "done reading computed solution" << endl;
}
// reality check
if ((computedDomain != exactDomain) && isSameSize)
{
MayDay::Error("Incompatible exact and computed domains for sameSize comparison");
}
int numExact = exactVars.size();
int numComputed = computedVars.size();
int numError = errorVars.size();
// If no errorVars were specified
if (numError == 0)
{
// Set errorVars to the intersection of exactVars and computedVars
// This numVars^2 method should be changed to something more efficient
for (int iExact = 0; iExact < numExact; iExact++)
{
for (int iComp = 0; iComp < numComputed; iComp++)
{
if (exactVars[iExact] == computedVars[iComp])
{
errorVars.push_back(exactVars[iExact]);
break;
}
}
}
numError = errorVars.size();
}
else
{
// if errorVars were specified, then do a quick check that
// they're present in both exactVars and computedVars
for (int errVarNo = 0; errVarNo<errorVars.size(); ++errVarNo)
{
bool foundComputed = false;
for (int i=0; i<numComputed; i++)
{
if (errorVars[errVarNo] == computedVars[i])
{
foundComputed = true;
}
} // end loop over exact variables
if (!foundComputed)
{
pout() << "errorVar " << errorVars[errVarNo]
<< " not found in computed solution!"
<< endl;
MayDay::Error();
}
bool foundExact = false;
for (int i=0; i<numExact; i++)
{
if (errorVars[errVarNo] == exactVars[i])
{
foundExact = true;
}
} // end loop over exact variables
if (!foundExact)
{
pout() << "errorVar " << errorVars[errVarNo]
<< " not found in exact solution!"
<< endl;
MayDay::Error();
}
} // end loop over errorVars
} // end if errorVars was specified in the inputs file
Vector<string> errorNames;
errorNames.resize(numError);
constructErrorNames(errorNames, errorVars);
Vector<LevelData<FArrayBox>* > error(computedNumLevels);
// allocate error -- same domain as computed solution
for (int level = 0; level < computedNumLevels; level++)
{
error[level] = new LevelData<FArrayBox>(computedGrids[level],
numError, ghostVect);
}
if (!isSameSize)
{
if (verbose)
{
pout () << "compute AMR error..." << endl;
}
computeAMRError(error,
errorVars,
computedSoln,
computedVars,
computedGrids,
computedDx,
computedRefRatio,
exactSoln,
exactVars,
exactDx,
bogusValue,
HOaverage,
computeRelativeError);
if (verbose)
{
pout() << "done computing AMR error" << endl;
}
}
else
{
// first make sure refRatios are the same
for (int lev = 0; lev < computedRefRatio.size() - 1; lev++)
{
CH_assert(computedRefRatio[lev] == exactRefRatio[lev]);
}
CH_assert(exactDx == computedDx);
if (verbose)
{
pout () << "compute sameSize error..." << endl;
}
computeSameSizeError(error,
errorVars,
computedSoln,
computedVars,
computedGrids,
computedDx,
computedRefRatio,
exactSoln,
exactVars,
bogusValue,
computeRelativeError,
doGhostCells);
if (verbose)
{
pout() << "done computing sameSize error" << endl;
}
}
Vector<Real> mean(numError);
// remove mean
if (removeMean)
{
int lBase = 0;
int numLevels = error.size();
for (int err = 0; err < numError; err++)
{
Interval errComps(err, err);
if (verbose)
{
pout() << "compute mean for component " << err << endl;
}
Real volume;
mean[err] = computeSum(volume,
error,
computedRefRatio,
computedDx,
errComps,
lBase);
mean[err] /= volume;
if (verbose)
{
pout() << "comp = " << err
<< ", mean = " << mean
<< ", vol = " << volume
<< endl;
}
for (int level = 0; level < numLevels; level++)
{
LevelData<FArrayBox>& thisLevelError = *error[level];
const DisjointBoxLayout levelGrids = error[level]->getBoxes();
DataIterator dit = levelGrids.dataIterator();
for (dit.reset(); dit.ok(); ++dit)
{
const Box thisBox = levelGrids[dit()];
FArrayBox& thisFabError = thisLevelError[dit()];
thisFabError.plus(-mean[err],err);
} // end loop over errors
thisLevelError.exchange();
} // end loop over levels
} // end loop over errors
}
// now compute norms
pout() << "error, step " << nStep << ": L1, L2, Max, sum" << endl;
for (int err = 0; err < numError; err++)
{
Interval errComps(err, err);
Real L0, L1, L2, sum;
if (verbose)
{
pout() << "compute error for component " << err << endl;
}
int lBase = 0;
int normType = 0;
Real normDx = computedDx;
if (useUnitDomain)
{
normDx = 1.0/computedDomain.size(0);
}
L0 = computeNorm(error,
computedRefRatio,
normDx,
errComps,
normType,
lBase);
normType = 1;
L1 = computeNorm(error,
computedRefRatio,
normDx,
errComps,
normType,
lBase);
normType = 2;
L2 = computeNorm(error,
computedRefRatio,
normDx,
errComps,
normType,
lBase);
sum = computeSum(error,
computedRefRatio,
normDx,
errComps,
lBase);
pout() << errorNames[err] << ": "
<< L1 << ", "
<< L2 << ", "
<< L0 << ", "
<< sum;
if (removeMean)
{
pout() << " (" << mean[err] << ")";
}
pout() << endl;
} // end loop over errors
if (doPlots)
{
if (verbose)
{
pout() << "begin writing hdf5 file..." << endl;
}
WriteAMRHierarchyHDF5(errorFile.str(),
computedGrids,
error,
errorNames,
computedDomain,
computedDx,
computedDt,
computedTime,
computedRefRatio,
computedNumLevels);
if (verbose)
{
pout() << "done writing hdf5 file" << endl;
}
}
// clean up memory
for (int level = 0; level < exactNumLevels; level++)
{
if (exactSoln[level] != NULL)
{
delete exactSoln[level];
exactSoln[level] = NULL;
}
}
for (int level = 0; level < computedNumLevels; level++)
{
if (computedSoln[level] != NULL)
{
delete computedSoln[level];
computedSoln[level] = NULL;
}
if (error[level] != NULL)
{
delete error[level];
error[level] = NULL;
}
}
} // end loop over timesteps
#ifdef CH_MPI
dumpmemoryatexit();
MPI_Finalize();
#endif
} // end main
// this function averages down the fine solution to the valid
// regions of the computed solution, then subtracts ir from
// the computed solution. (error is exact-computed)
void computeAMRError(Vector<LevelData<FArrayBox>* >& a_error,
const Vector<string>& a_errorVars,
const Vector<LevelData<FArrayBox>* >& a_computedSoln,
const Vector<string>& a_computedVars,
const Vector<DisjointBoxLayout>& a_computedGrids,
const Real a_computedDx,
const Vector<int>& a_computedRefRatio,
const Vector<LevelData<FArrayBox>* >& a_exactSoln,
const Vector<string>& a_exactVars,
const Real a_exactDx,
Real a_bogus_value,
bool a_HOaverage,
bool a_computeRelativeError)
{
int numLevels = a_computedSoln.size();
CH_assert(a_exactSoln.size() == 1);
CH_assert(a_error.size() == numLevels);
CH_assert(a_exactDx <= a_computedDx);
CH_assert(a_computedRefRatio.size() >= numLevels - 1);
if (a_exactDx == a_computedDx)
{
cerr << "Exact dx and computed dx are equal." << endl;
}
// check whether input file selects "sum all variables"
bool sumAll = false;
ParmParse pp;
pp.query("sumAll",sumAll);
// const DisjointBoxLayout& exactGrids = a_exactSoln[0]->getBoxes();
Real dxLevel = a_computedDx;
// do a bit of sleight-of-hand in the case where there are no
// ghost cells in the exact solution -- allocate a temporary which
// _has_ ghost cells, and do a copyTo
LevelData<FArrayBox>* exactSolnPtr = NULL;
bool allocatedMemory = false;
if (a_exactSoln[0]->ghostVect() == IntVect::Zero)
{
exactSolnPtr = new LevelData<FArrayBox>(a_exactSoln[0]->getBoxes(),
a_exactSoln[0]->nComp(),
IntVect::Unit);
a_exactSoln[0]->copyTo(*exactSolnPtr);
allocatedMemory = true;
}
else
{
// if there are ghost cells, we can use the exactSoln as-is
exactSolnPtr = a_exactSoln[0];
}
LevelData<FArrayBox>& exactSolnRef = *exactSolnPtr;
// first need to set boundary conditions on exactsoln
// this is for the Laplacian which is needed in AverageHO
DataIterator ditFine = exactSolnRef.dataIterator();
DomainGhostBC exactBC;
Interval exactComps(0, a_exactVars.size() - 1);
for (int dir = 0; dir < SpaceDim; dir++)
{
SideIterator sit;
for (sit.reset(); sit.ok(); ++sit)
{
// use HO extrapolation at physical boundaries
HOExtrapBC thisBC(dir, sit(), exactComps);
exactBC.setBoxGhostBC(thisBC);
}
}
for (ditFine.begin(); ditFine.ok(); ++ditFine)
{
FArrayBox& thisFineSoln = exactSolnRef[ditFine()];
const Box& fineBox = exactSolnRef.getBoxes()[ditFine()];
exactBC.applyInhomogeneousBCs(thisFineSoln, fineBox, a_exactDx);
}
exactSolnRef.exchange(exactComps);
// outer loop is over levels
for (int level = 0; level < numLevels; level++)
{
LevelData<FArrayBox>& thisLevelError = *a_error[level];
LevelData<FArrayBox>& thisLevelComputed = *a_computedSoln[level];
// compute refinement ratio between solution at this level
// and exact solution
Real nRefTemp = (dxLevel / a_exactDx);
int nRefExact = (int) nRefTemp;
// this is to do rounding properly if necessary
if (nRefTemp - nRefExact > 0.5) nRefExact += 1;
// make sure it's not zero
if (nRefExact == 0) nRefExact =1;
const DisjointBoxLayout levelGrids = a_error[level]->getBoxes();
const DisjointBoxLayout fineGrids = a_exactSoln[0]->getBoxes();
DisjointBoxLayout coarsenedFineGrids;
// petermc, 14 Jan 2014: Replace this because fineGrids might
// not be coarsenable by nRefExact.
// coarsen(coarsenedFineGrids, fineGrids, nRefExact);
int nCoarsenExact = nRefExact;
while ( !fineGrids.coarsenable(nCoarsenExact) && (nCoarsenExact > 0) )
{
// Divide nCoarsenExact by 2 until fineGrids is coarsenable by it.
nCoarsenExact /= 2;
}
if (nCoarsenExact == 0)
{
nCoarsenExact = 1;
}
coarsen(coarsenedFineGrids, fineGrids, nCoarsenExact);
int numExact = a_exactVars.size();
LevelData<FArrayBox> averagedExact(coarsenedFineGrids, numExact);
Box fineRefBox(IntVect::Zero, (nCoarsenExact-1)*IntVect::Unit);
// average fine solution down to coarsened-fine level
// loop over grids and do HO averaging down
//DataIterator crseExactDit = coarsenedFineGrids.dataIterator();
for (ditFine.reset(); ditFine.ok(); ++ditFine)
{
const Box fineBox = exactSolnRef.getBoxes()[ditFine()];
FArrayBox fineTemp(fineBox, 1);
Box coarsenedFineBox(fineBox);
coarsenedFineBox.coarsen(nCoarsenExact);
if (a_exactDx < a_computedDx)
{
// loop over components
for (int comp = 0; comp < numExact; comp++)
{
Box coarseBox(coarsenedFineGrids.get(ditFine()));
coarseBox &= coarsenedFineBox;
if (!coarseBox.isEmpty())
{
// for now, this is a quick and dirty way to avoid
// stepping out of bounds if there are no ghost cells.
// LapBox will be the box over which we are
// able to compute the Laplacian.
Box LapBox = exactSolnRef[ditFine()].box();
LapBox.grow(-1);
LapBox &= fineBox;
fineTemp.setVal(0.0);
int doHO = 0;
if (a_HOaverage)
{
doHO = 1;
}
// average by default
int doAverage = 1;
if (sumAll || sumVar(a_exactVars[comp]))
{
doAverage = 0;
}
// average or sum, based on booleans
FORT_AVERAGEHO(CHF_FRA1(averagedExact[ditFine], comp),
CHF_CONST_FRA1(exactSolnRef[ditFine], comp),
CHF_FRA1(fineTemp, 0),
CHF_BOX(coarseBox),
CHF_BOX(LapBox),
CHF_CONST_INT(nCoarsenExact),
CHF_BOX(fineRefBox),
CHF_INT(doHO),
CHF_INT(doAverage));
} // end if crseBox not empty
} // end loop over comps
}
else
{
// if cell sizes are the same, then copy
averagedExact[ditFine].copy(exactSolnRef[ditFine]);
}
} // end loop over exact solution boxes
int nRefineComputed = nRefExact / nCoarsenExact;
LevelData<FArrayBox>* thisLevelComputedRefinedPtr = &thisLevelComputed;
LevelData<FArrayBox>* thisLevelErrorRefinedPtr = &thisLevelError;
if (nRefineComputed > 1)
{
// Do piecewise constant interpolation (replication) by nRefineComputed
// on thisLevelComputed.
DisjointBoxLayout levelRefinedGrids;
refine(levelRefinedGrids, levelGrids, nRefineComputed);
int nCompComputed = thisLevelComputed.nComp();
IntVect ghostVectComputed = nRefineComputed * thisLevelComputed.ghostVect();
thisLevelComputedRefinedPtr =
new LevelData<FArrayBox>(levelRefinedGrids, nCompComputed, ghostVectComputed);
ProblemDomain levelDomain = levelRefinedGrids.physDomain();
FineInterp interpolator(levelRefinedGrids, nCompComputed, nRefineComputed,
levelDomain);
interpolator.pwcinterpToFine(*thisLevelComputedRefinedPtr, thisLevelComputed);
int nCompErr = thisLevelError.nComp();
IntVect ghostVectErr = nRefineComputed * thisLevelError.ghostVect();
thisLevelErrorRefinedPtr =
new LevelData<FArrayBox>(levelRefinedGrids, nCompErr, ghostVectErr);
}
// initialize error to 0
// also initialize error to a bogus value
DataIterator levelDit = thisLevelError.dataIterator();
for (levelDit.begin(); levelDit.ok(); ++levelDit)
{
(*thisLevelErrorRefinedPtr)[levelDit].setVal(a_bogus_value);
}
Box refComputedBox(IntVect::Zero, (nRefineComputed-1)*IntVect::Unit);
// loop over variables
for (int nErr = 0; nErr < a_errorVars.size(); nErr++)
{
string thisErrVar = a_errorVars[nErr];
bool done = false;
// first loop over exact variables
for (int exactComp = 0; exactComp < a_exactVars.size(); exactComp++)
{
string thisExactVar = a_exactVars[exactComp];
// check if this exact variable is "the one"
if ((thisExactVar == thisErrVar) || nonAverageVar(thisErrVar))
{
int computedComp = 0;
// now loop over computed variables
while (!done && (computedComp < a_computedVars.size()))
{
if (a_computedVars[computedComp] == thisErrVar)
{
if (!nonAverageVar(thisErrVar))
{
// copy averaged exact solution -> error
// and then subtract computed solution
Interval exactInterval(exactComp, exactComp);
Interval errorInterval(nErr, nErr);
averagedExact.copyTo(exactInterval, *thisLevelErrorRefinedPtr,
errorInterval);
}
DataIterator levelDit = thisLevelError.dataIterator();
for (levelDit.reset(); levelDit.ok(); ++levelDit)
{
FArrayBox& thisComputedRefined = (*thisLevelComputedRefinedPtr)[levelDit];
FArrayBox& thisErrorRefined = (*thisLevelErrorRefinedPtr)[levelDit];
if (a_computeRelativeError)
{
// do this a little strangely -- relative
// error is one - computed/exact.
thisErrorRefined.divide(thisComputedRefined, computedComp, nErr, 1);
thisErrorRefined.invert(-1.0, nErr, 1);
thisErrorRefined.plus(1.0, nErr, 1);
}
else
{
thisErrorRefined.minus(thisComputedRefined, computedComp, nErr, 1);
}
if (nRefineComputed > 1)
{
FArrayBox& thisError = thisLevelError[levelDit];
Box coarseBox = thisError.box();
// Average thisErrorRefined to thisError.
int doHO = 0;
if (a_HOaverage)
{
doHO = 1;
}
CH_assert(doHO == 0);
// for now, this is a quick and dirty way to avoid
// stepping out of bounds if there are no ghost cells.
// LapBox will be the box over which we are
// able to compute the Laplacian.
Box LapBox = thisErrorRefined.box();
LapBox.grow(-1);
// LapBox &= fineBox;
FArrayBox fineTemp(thisErrorRefined.box(), 1);
fineTemp.setVal(0.0);
// average by default
int doAverage = 1;
// average or sum, based on booleans
FORT_AVERAGEHO(CHF_FRA1(thisError, nErr),
CHF_CONST_FRA1(thisErrorRefined, nErr),
CHF_FRA1(fineTemp, 0),
CHF_BOX(coarseBox),
CHF_BOX(LapBox),
CHF_CONST_INT(nRefineComputed),
CHF_BOX(refComputedBox),
CHF_INT(doHO),
CHF_INT(doAverage));
}
} // end loop over coarse grids
done = true;
} // if computedVar is a_errorVar
computedComp += 1;
} // end loop over a_computedVars
if (!done)
{
pout() << "Variable " << thisErrVar << " not found!!!" << endl;
MayDay::Error();
}
} // end if this exactVar is correct
} // end loop over exact variables
} // end loop over errors
if (nRefineComputed > 1)
{
delete thisLevelComputedRefinedPtr;
delete thisLevelErrorRefinedPtr;
}
// now need to set covered regions to 0
if (level < numLevels - 1)
{
// will need to loop over all boxes in finer level, not just
// those on this processor...
const BoxLayout& finerGrids = a_computedSoln[level + 1]->boxLayout();
LayoutIterator fineLit = finerGrids.layoutIterator();
// outer loop over this level's grids, since there are fewer of them
DataIterator levelDit = thisLevelError.dataIterator();
for (levelDit.reset(); levelDit.ok(); ++levelDit)
{
const Box& coarseBox = levelGrids[levelDit()];
FArrayBox& thisError = thisLevelError[levelDit()];
int numError = thisError.nComp();
for (fineLit.reset(); fineLit.ok(); ++fineLit)
{
Box fineBox(finerGrids[fineLit()]);
// now coarsen box down to this level
fineBox.coarsen(a_computedRefRatio[level]);
// if coarsened fine box intersects error's box, set
// overlap to 0
fineBox &= coarseBox;
if (!fineBox.isEmpty())
{
thisError.setVal(0.0, fineBox, 0, numError);
}
} // end loop over finer-level grids
} // end loop over this-level grids
// this is a good place to update dx as well
dxLevel = dxLevel / a_computedRefRatio[level];
} // end if there is a finer level
thisLevelError.exchange();
} // end loop over levels
// clean up if we need to
if (allocatedMemory)
{
delete exactSolnPtr;
exactSolnPtr = NULL;
}
}
void
CartCellDoubleBoundsPreservingConservativeLinearRefine::refine(Patch<NDIM>& fine,
const Patch<NDIM>& coarse,
const int dst_component,
const int src_component,
const Box<NDIM>& fine_box,
const IntVector<NDIM>& ratio)
const
{
// Determine the box over which we can apply the bounds-preserving
// correction, and construct a list of boxes that will not be corrected.
bool empty_correction_box = false;
Box<NDIM> correction_box = Box<NDIM>::refine(Box<NDIM>::coarsen(fine_box, ratio), ratio);
for (unsigned int axis = 0; axis < NDIM; ++axis)
{
int& lower = correction_box.lower()(axis);
while (lower < fine_box.lower()(axis))
{
lower += ratio(axis);
}
int& upper = correction_box.upper()(axis);
while (upper > fine_box.upper()(axis))
{
upper -= ratio(axis);
}
if (lower >= upper)
{
empty_correction_box = true;
}
}
const Box<NDIM> coarse_correction_box = Box<NDIM>::coarsen(correction_box, ratio);
BoxList<NDIM> uncorrected_boxes(fine_box);
if (!empty_correction_box)
{
uncorrected_boxes.removeIntersections(correction_box);
}
// Employ limited conservative interpolation to prolong data on the
// correction box.
d_conservative_linear_refine_op.refine(
fine, coarse, dst_component, src_component, correction_box, ratio);
// Employ constant interpolation to prolong data on the rest of the fine
// box.
for (BoxList<NDIM>::Iterator b(uncorrected_boxes); b; b++)
{
d_constant_refine_op.refine(fine, coarse, dst_component, src_component, b(), ratio);
}
// There is nothing left to do if the correction box is empty.
if (empty_correction_box) return;
// Correct the data within the correction box.
Pointer<CellData<NDIM, double> > fdata = fine.getPatchData(dst_component);
Pointer<CellData<NDIM, double> > cdata = coarse.getPatchData(src_component);
#if !defined(NDEBUG)
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata->getDepth() == cdata->getDepth());
#endif
const int data_depth = fdata->getDepth();
const Box<NDIM>& patch_box_crse = coarse.getBox();
const Index<NDIM>& patch_lower_crse = patch_box_crse.lower();
const Index<NDIM>& patch_upper_crse = patch_box_crse.upper();
Pointer<CartesianPatchGeometry<NDIM> > pgeom_crse = coarse.getPatchGeometry();
for (int depth = 0; depth < data_depth; ++depth)
{
for (Box<NDIM>::Iterator b(coarse_correction_box); b; b++)
{
const Index<NDIM>& i_crse = b();
const Index<NDIM> i_fine = i_crse * ratio;
// Determine the lower/upper bounds.
Box<NDIM> stencil_box_crse(i_crse, i_crse);
for (unsigned int axis = 0; axis < NDIM; ++axis)
{
if (i_crse(axis) > patch_lower_crse(axis) ||
!pgeom_crse->getTouchesRegularBoundary(axis, 0))
{
stencil_box_crse.growLower(axis, 1);
}
if (i_crse(axis) < patch_upper_crse(axis) ||
!pgeom_crse->getTouchesRegularBoundary(axis, 1))
{
stencil_box_crse.growUpper(axis, 1);
}
}
double l = std::numeric_limits<double>::max();
double u = -(l - std::numeric_limits<double>::epsilon());
for (Box<NDIM>::Iterator b(stencil_box_crse); b; b++)
{
const double& m = (*cdata)(b(), depth);
l = std::min(l, m);
u = std::max(u, m);
}
// Force all refined data to lie within the bounds, accumulating the
// discrepancy.
Box<NDIM> stencil_box_fine(i_fine, i_fine);
stencil_box_fine.growUpper(ratio - IntVector<NDIM>(1));
double Delta = 0.0;
for (Box<NDIM>::Iterator b(stencil_box_fine); b; b++)
{
double& m = (*fdata)(b(), depth);
Delta += std::max(0.0, m - u) - std::max(0.0, l - m);
m = std::max(std::min(m, u), l);
}
// Distribute the discrepancy to maintain conservation.
if (Delta >= std::numeric_limits<double>::epsilon())
{
double K = 0.0;
for (Box<NDIM>::Iterator b(stencil_box_fine); b; b++)
{
const double& m = (*fdata)(b(), depth);
double k = u - m;
K += k;
}
for (Box<NDIM>::Iterator b(stencil_box_fine); b; b++)
{
double& m = (*fdata)(b(), depth);
double k = u - m;
m += Delta * k / K;
}
}
else if (Delta <= -std::numeric_limits<double>::epsilon())
{
double K = 0.0;
for (Box<NDIM>::Iterator b(stencil_box_fine); b; b++)
{
const double& m = (*fdata)(b(), depth);
double k = m - l;
K += k;
}
for (Box<NDIM>::Iterator b(stencil_box_fine); b; b++)
{
double& m = (*fdata)(b(), depth);
double k = m - l;
m += Delta * k / K;
}
}
}
}
return;
} // refine
DTboolean PrimitiveCollisions::ray_intersect_box ( const Vector3 &from, const Vector3 &direction,
const Box &b, DTfloat &t)
{
DTfloat tmin = -std::numeric_limits<DTfloat>::infinity();
DTfloat tmax = std::numeric_limits<DTfloat>::infinity();
DTfloat t1,t2;
// X axis
if (direction.x > EPSILON || direction.x < -EPSILON) {
DTfloat direction_inverse = 1.0F / direction.x;
t1 = (b.minus_x() - from.x) * direction_inverse;
t2 = (b.plus_x() - from.x) * direction_inverse;
tmin = MoreMath::min(tmin,t1,t2);
tmax = MoreMath::max(tmin,t1,t2);
if (tmin > tmax) return false;
if (tmax < 0.0F) return false;
} else if (from.x < b.minus_x() || from.x > b.plus_x()) {
return false;
}
// Y axis
if (direction.y > EPSILON || direction.y < -EPSILON) {
DTfloat direction_inverse = 1.0F / direction.y;
t1 = (b.minus_y() - from.y) * direction_inverse;
t2 = (b.plus_y() - from.y) * direction_inverse;
tmin = MoreMath::min(tmin,t1,t2);
tmax = MoreMath::max(tmin,t1,t2);
if (tmin > tmax) return false;
if (tmax < 0.0F) return false;
} else if (from.y < b.minus_y() || from.y > b.plus_y()) {
return false;
}
// Z axis
if (direction.z > EPSILON || direction.z < -EPSILON) {
DTfloat direction_inverse = 1.0F / direction.z;
t1 = (b.minus_z() - from.z) * direction_inverse;
t2 = (b.plus_z() - from.z) * direction_inverse;
tmin = MoreMath::min(tmin,t1,t2);
tmax = MoreMath::max(tmin,t1,t2);
if (tmin > tmax) return false;
if (tmax < 0.0F) return false;
} else if (from.z < b.minus_z() || from.z > b.plus_z()) {
return false;
}
if (tmin <= tmax) {
t = tmin;
return true;
}
return false;
}
// Set boundary fluxes
void VelIBC::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_isDefined == true);
// In periodic case, this doesn't do anything
if (!m_domain.isPeriodic(a_dir))
{
// This needs to be fixed
// CH_assert(m_isBCvalSet);
int lohisign;
Box tmp = a_WGdnv.box() & m_domain;
Real bcVal;
// Determine which side and thus shifting directions
if (a_side == Side::Lo)
{
lohisign = -1;
bcVal = m_bcVal[a_dir][0];
}
else
{
lohisign = 1;
bcVal = m_bcVal[a_dir][1];
}
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_SOLIDVELBCF(CHF_FRA(a_WGdnv),
CHF_CONST_FRA(a_Wextrap),
CHF_CONST_REAL(bcVal),
CHF_CONST_INT(lohisign),
CHF_CONST_REAL(m_dx),
CHF_CONST_INT(a_dir),
CHF_BOX(boundaryBox));
}
}
}
// calculate the centroid of a box
KOKKOS_INLINE_FUNCTION
void centroid( Box const &box, Point &c )
{
for ( int d = 0; d < 3; ++d )
c[d] = 0.5 * ( box.minCorner()[d] + box.maxCorner()[d] );
}
bool can_stack(const Box& b, const Tower& t){
return b.compare(*(t.begin())) == '>';
}
KOKKOS_INLINE_FUNCTION
bool equals( Box const &l, Box const &r )
{
return equals( l.minCorner(), r.minCorner() ) &&
equals( l.maxCorner(), r.maxCorner() );
}
Box::Box( Box const& rhs ) : Primitive( rhs ), min( rhs.getMin() ), max( rhs.getMax() ) {}
Box operator()(Box data)
{
typedef typename Box::ValueType ValueType;
Box dstBox = Box(PitchedBox<ValueType, DIM2 > (
(ValueType*) filteredData,
Space(),
header.simSize,
header.simSize.x() * sizeof (ValueType)
));
MessageHeader mHeader;
MessageHeader* fakeHeader = &mHeader;
memcpy(fakeHeader, &header, MessageHeader::bytes);
char* recvHeader = new char[ MessageHeader::bytes * numRanks];
if (fullData == NULL && mpiRank == 0)
fullData = (char*) new ValueType[header.nodeSize.productOfComponents() * numRanks];
MPI_CHECK(MPI_Gather(fakeHeader, MessageHeader::bytes, MPI_CHAR, recvHeader, MessageHeader::bytes,
MPI_CHAR, 0, comm));
const size_t elementsCount = header.nodeSize.productOfComponents() * sizeof (ValueType);
MPI_CHECK(MPI_Gather(
(char*) (data.getPointer()), elementsCount, MPI_CHAR,
fullData, elementsCount, MPI_CHAR,
0, comm));
if (mpiRank == 0)
{
if (filteredData == NULL)
filteredData = (char*) new ValueType[header.simSize.productOfComponents()];
/*create box with valid memory*/
dstBox = Box(PitchedBox<ValueType, DIM2 > (
(ValueType*) filteredData,
Space(),
header.simSize,
header.simSize.x() * sizeof (ValueType)
));
for (int i = 0; i < numRanks; ++i)
{
MessageHeader* head = (MessageHeader*) (recvHeader + MessageHeader::bytes * i);
Box srcBox = Box(PitchedBox<ValueType, DIM2 > (
(ValueType*) fullData,
Space(0, head->nodeSize.y() * i),
head->nodeSize,
head->nodeSize.x() * sizeof (ValueType)
));
insertData(dstBox, srcBox, head->nodeOffset, head->nodePictureSize, head->nodeGuardCells);
}
}
delete[] recvHeader;
return dstBox;
}
__host__ void parseShape(const std::smatch& matches, Box& shape)
{
shape.setPosition(ParseUtils::parseVec3(matches[3].str()));
shape.setRotation(glm::quat(ParseUtils::parseVec3(matches[4].str())));
shape.setSize(ParseUtils::parseVec3(matches[5].str()));
}
Meshing2OCCSurfaces :: Meshing2OCCSurfaces (const TopoDS_Shape & asurf,
const Box<3> & abb, int aprojecttype)
: Meshing2(Box<3>(abb.PMin(), abb.PMax())), surface(TopoDS::Face(asurf), aprojecttype)
{
;
}
void
sphereGeometry(Box& a_coarsestDomain,
Real& a_dx)
{
ParmParse ppgodunov;
//parse input file
int max_level = 0;
ppgodunov.get("max_level",max_level);
int num_read_levels = Max(max_level,1);
std::vector<int> refRatios; // (num_read_levels,1);
// note this requires a refRatio to be defined for the
// finest level (even though it will never be used)
ppgodunov.getarr("ref_ratio",refRatios,0,num_read_levels+1);
ParmParse pp;
RealVect origin = RealVect::Zero;
Vector<int> n_cell(SpaceDim);
pp.getarr("n_cell",n_cell,0,SpaceDim);
CH_assert(n_cell.size() == SpaceDim);
IntVect lo = IntVect::Zero;
IntVect hi;
for (int ivec = 0; ivec < SpaceDim; ivec++)
{
if (n_cell[ivec] <= 0)
{
pout() << " bogus number of cells input = " << n_cell[ivec];
MayDay::Error();
}
hi[ivec] = n_cell[ivec] - 1;
}
a_coarsestDomain = Box(lo, hi);
Box finestDomain = a_coarsestDomain;
for (int ilev = 0; ilev < max_level; ilev++)
{
finestDomain.refine(refRatios[ilev]);
}
Real prob_hi;
int numOpen = n_cell[0];
pp.get("domain_length",prob_hi);
a_dx = prob_hi/numOpen;
Real fineDx = a_dx;
int ebMaxCoarsen = 2;
for (int ilev = 0; ilev < max_level; ilev++)
{
fineDx /= refRatios[ilev];
ebMaxCoarsen += refRatios[ilev]/2;
}
int ebMaxSize;
ppgodunov.get("max_grid_size", ebMaxSize);
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
pout() << "sphere geometry" << endl;
vector<Real> sphere_center(SpaceDim);
pp.getarr("sphere_center",sphere_center, 0, SpaceDim);
RealVect sphereCenter;
for (int idir = 0; idir < SpaceDim; idir++)
{
sphereCenter[idir] = sphere_center[idir];
}
Real sphereRadius;
pp.get("sphere_radius", sphereRadius);
int inside_fluid;
pp.get("sphere_fluid_inside", inside_fluid);
bool insideFluid = (inside_fluid==1);
SphereIF sphereIF(sphereRadius, sphereCenter, insideFluid);
RealVect vectFineDx(D_DECL(fineDx,fineDx,fineDx));
GeometryShop workshop(sphereIF,0,vectFineDx);
//this generates the new EBIS
ebisPtr->define(finestDomain, origin, fineDx, workshop, ebMaxSize, ebMaxCoarsen);
}
// Shape* s2 = new Sphere(position, 1.2, "sphere1", red);
// s1->print(std::cout);
// std::cout << "\n";
// s2->print(std::cout);
// delete s1;
// delete s2;
// }
//7
TEST_CASE("box_intersect", "[intersect_box]"){
glm::vec3 vec1{0.0f,0.0f,0.0f};
glm::vec3 vec2{1.0f,1.0f,1.0f};
Box b1{vec1, vec2};
glm::vec3 origin(-1.0,0.0,0.0);
glm::vec3 direction(1.0,0.5,0.0);
Ray r{origin, direction};
float distance(0.0);
REQUIRE(b1.intersect(r, distance));
std::cout <<"\n" << distance << std::endl;
}
TEST_CASE("box_intersect2", "[intersect_box2]"){
glm::vec3 vec1{0.0f,0.0f,0.0f};
glm::vec3 vec2{1.0f,1.0f,1.0f};
Box b1{vec1, vec2};
glm::vec3 origin(12.0,0.5,0.5);
glm::vec3 direction(1.0,0.0,0.0);
void set_box(const Box& b)
{
set_min_corner(b.min_corner());
set_max_corner(b.max_corner());
}
void draw()
{
// Rotate box and position (and the spheres will orbitate around it)
box.rotateY( angle );
}
void GameplayScreen::onEntry() {
b2Vec2 gravity(0.0f, -25.0);
m_world = std::make_unique<b2World>(gravity);
m_debugRenderer.init();
// Make the ground
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, -20.0f);
b2Body* groundBody = m_world->CreateBody(&groundBodyDef);
// Make the ground fixture
b2PolygonShape groundBox;
groundBox.SetAsBox(50.0f, 10.0f);
groundBody->CreateFixture(&groundBox, 0.0f);
// Load the texture
m_texture = Bengine::ResourceManager::getTexture("Assets/bricks_top.png");
// Make a bunch of boxes
std::mt19937 randGenerator;
std::uniform_real_distribution<float> xPos(-10.0, 10.0f);
std::uniform_real_distribution<float> yPos(-10.0, 25.0f);
std::uniform_real_distribution<float> size(0.5, 2.5f);
std::uniform_int_distribution<int> color(50, 255);
const int NUM_BOXES = 10;
for (int i = 0; i < NUM_BOXES; i++) {
Bengine::ColorRGBA8 randColor;
randColor.r = color(randGenerator);
randColor.g = color(randGenerator);
randColor.b = color(randGenerator);
randColor.a = 255;
Box newBox;
newBox.init(m_world.get(), glm::vec2(xPos(randGenerator), yPos(randGenerator)), glm::vec2(size(randGenerator), size(randGenerator)), m_texture, randColor, false);
m_boxes.push_back(newBox);
}
// Initialize spritebatch
m_spriteBatch.init();
// Shader init
// Compile our texture
m_textureProgram.compileShaders("Shaders/textureShading.vert", "Shaders/textureShading.frag");
m_textureProgram.addAttribute("vertexPosition");
m_textureProgram.addAttribute("vertexColor");
m_textureProgram.addAttribute("vertexUV");
m_textureProgram.linkShaders();
// Compile our light shader
m_lightProgram.compileShaders("Shaders/lightShading.vert", "Shaders/lightShading.frag");
m_lightProgram.addAttribute("vertexPosition");
m_lightProgram.addAttribute("vertexColor");
m_lightProgram.addAttribute("vertexUV");
m_lightProgram.linkShaders();
// Init camera
m_camera.init(m_window->getScreenWidth(), m_window->getScreenHeight());
m_camera.setScale(32.0f);
// Init player
m_player.init(m_world.get(), glm::vec2(0.0f, 30.0f), glm::vec2(2.0f), glm::vec2(1.0f, 1.8f), Bengine::ColorRGBA8(255, 255, 255, 255));
// Init the UI
m_gui.init("GUI");
m_gui.loadScheme("TaharezLook.scheme");
m_gui.setFont("DejaVuSans-10");
CEGUI::PushButton* testButton = static_cast<CEGUI::PushButton*>(m_gui.createWidget("TaharezLook/Button", glm::vec4(0.5f, 0.5f, 0.1f, 0.05f), glm::vec4(0.0f), "TestButton"));
testButton->setText("Hello World!");
CEGUI::Combobox* TestCombobox = static_cast<CEGUI::Combobox*>(m_gui.createWidget("TaharezLook/Combobox", glm::vec4(0.2f, 0.2f, 0.1f, 0.05f), glm::vec4(0.0f), "TestCombobox"));
m_gui.setMouseCursor("TaharezLook/MouseArrow");
m_gui.showMouseCursor();
SDL_ShowCursor(0);
}
void
LevelFluxRegisterEdge::incrementFine(
FArrayBox& a_fineFlux,
Real a_scale,
const DataIndex& a_fineDataIndex,
const Interval& a_srcInterval,
const Interval& a_dstInterval,
int a_dir,
Side::LoHiSide a_sd)
{
CH_assert(isDefined());
CH_assert(!a_fineFlux.box().isEmpty());
CH_assert(a_srcInterval.size() == a_dstInterval.size());
CH_assert(a_srcInterval.begin() >= 0);
CH_assert(a_srcInterval.end() < a_fineFlux.nComp());
CH_assert(a_dstInterval.begin() >= 0);
CH_assert(a_dstInterval.end() < m_nComp);
CH_assert(a_dir >= 0);
CH_assert(a_dir < SpaceDim);
CH_assert((a_sd == Side::Lo)||(a_sd == Side::Hi));
//
//
//denom is the number of fine faces per coarse face
//this is intrinsically dimension-dependent
#if (CH_SPACEDIM == 2)
Real denom = 1;
#elif (CH_SPACEDIM == 3)
Real denom = m_nRefine;
#else
// This code doesn't make any sense in 1D, and hasn't been implemented
// for DIM > 3
Real denom = -1.0;
MayDay::Error("LevelFluxRegisterEdge -- bad SpaceDim");
#endif
Real scale = a_scale/denom;
// need which fluxbox face we're doing this for
Box thisBox = a_fineFlux.box();
int fluxComp = -1;
for (int sideDir=0; sideDir<SpaceDim; sideDir++)
{
// we do nothing in the direction normal to face
if (sideDir != a_dir)
{
if (thisBox.type(sideDir) == IndexType::CELL)
{
fluxComp = sideDir;
}
}
}
CH_assert (fluxComp >= 0);
int regcomp = getRegComp(a_dir, fluxComp);
FluxBox& thisReg = m_fabFine[index(a_dir, a_sd)][a_fineDataIndex];
FArrayBox& reg = thisReg[regcomp];
a_fineFlux.shiftHalf(a_dir, sign(a_sd));
// this is a way of geting a face-centered domain
// box which we can then use to intersect with things
// to screen out cells outside the physical domain
// (nothing is screened out in periodic case)
Box shiftedValidDomain = m_domainCoarse.domainBox();
shiftedValidDomain.grow(2);
shiftedValidDomain &= m_domainCoarse;
shiftedValidDomain.surroundingNodes(regcomp);
BoxIterator regIt(reg.box() & shiftedValidDomain);
for (regIt.begin(); regIt.ok(); ++regIt)
{
const IntVect& coarseIndex = regIt();
// create a cell-centered box, then shift back to face-centered
Box box(coarseIndex, coarseIndex);
box.shiftHalf(regcomp,-1);
// to avoid adding in edges which do not overlie coarse-grid
// edges, will refine only in non-fluxComp directions to
// determine box from which to grab fluxes.
IntVect refineVect(m_nRefine*IntVect::Unit);
//refineVect.setVal(fluxComp,1);
box.refine(refineVect);
if (a_sd == Side::Lo) box.growLo(a_dir,-(m_nRefine-1));
else box.growHi(a_dir,-(m_nRefine-1));
BoxIterator fluxIt(box);
for (fluxIt.begin(); fluxIt.ok(); ++fluxIt)
{
int src = a_srcInterval.begin();
int dest = a_dstInterval.begin();
for ( ; src <=a_srcInterval.end(); ++src,++dest)
reg(coarseIndex, dest) += scale*a_fineFlux(fluxIt(), src);
}
}
a_fineFlux.shiftHalf(a_dir, -sign(a_sd));
}
template <class T> void
_fillHullT(T *_m, const XYPoint &srcsize) {
int nobj = 0, i, x, y;
XYPoint size = srcsize;
// computes maximum number of different objects
for (i=0; i < srcsize.x*srcsize.y; i++)
if ((int)_m[i] > nobj) nobj = (int)_m[i];
// nothing to do if no objects
if (nobj < 1) return;
// extend m by 2 pixels, copy content of _m inside, the frame - 0;
// initialize temporary canvas with 0
size.x += 2;
size.y += 2;
typedef T* pT;
T ** m = new pT[size.x];
T ** canvas = new pT[size.x];
for (x=0; x < size.x; x++) {
m[x] = new T[size.y];
canvas[x] = new T[size.y];
for (y=0; y < size.y; y++) {
canvas[x][y] = (T)0;
if (x==0 || x==size.x-1 || y==0 || y==size.y-1) m[x][y] = (T)0;
else m[x][y] = _m[x-1 + (y-1)*srcsize.x];
}
}
// allocate and compute bounding boxes for all objects (the one for 0 never used)
Box * bbox = new Box[nobj+1];
for (i=1; i <= nobj; i++) {
bbox[i].l = size.x-2;
bbox[i].t = size.y-2;
}
for (x=1; x < size.x-1; x++)
for (y=1; y < size.y-1; y++) {
if ( (i=(int)m[x][y]) == 0) continue;
if (x < bbox[i].l) bbox[i].l = x;
else if (bbox[i].r < x) bbox[i].r = x;
if (y < bbox[i].t) bbox[i].t = y;
else if (bbox[i].b < y) bbox[i].b = y;
}
// reverse filling
for (i=1; i <= nobj; i++) {
Box box = bbox[i];
box.expand(1);
_fillAroundObjectHullT<T>(m, canvas, box, i);
// fill back the original matrix!
for (x=box.l+1; x <= box.r-1; x++)
for (y=box.t+1; y <= box.b-1; y++) {
// if ((int)_m[x-1+(y-1)*srcsize.x] > 0) continue;
if ((int)m[x][y] != 0 || (int)canvas[x][y]==i) continue;
// this should never happen, but just in case
if (x-1<0 || x-1>=srcsize.x || y-1<0 || y-1>=srcsize.y) continue;
_m[x-1+(y-1)*srcsize.x] = (T)i;
}
}
// cleanup
for (x=0; x < size.x; x++) {
delete[] m[x];
delete[] canvas[x];
}
delete[] m;
delete[] canvas;
delete[] bbox;
}
// confine the view to keep as much of the image onscreen as possible.
void EditView::ConfineView()
{
Box const& p = Proj().ImgConst(Frame()).Bounds();
Box v = ViewToProj( m_ViewBox );
#if 0
if( p.W() < v.W() )
m_Offset.x = -(v.W()-p.W())/2; // center
else if( v.XMin() < 0 )
m_Offset.x = 0;
else if( v.XMax() > p.XMax() )
m_Offset.x = (p.x + p.W()) - v.W();
if( p.H() < v.H() )
m_Offset.y = -(v.H()-p.H())/2; // center
else if( v.YMin() < 0 )
m_Offset.y = 0;
else if( v.YMax() > p.YMax() )
m_Offset.y = (p.y+p.H()) - v.H();
#endif
if( p.W() < v.W() )
{
// view is wider than proj
if( v.XMin() > p.XMin() )
m_Offset.x = p.XMin();
if( v.XMax() < p.XMax() )
m_Offset.x = (p.x + p.W())-v.W();
}
else
{
// proj is wider than view
if( v.XMin() < 0 )
m_Offset.x = 0;
else if( v.XMax() > p.XMax() )
m_Offset.x = (p.x + p.W()) - v.W();
}
if( p.H() < v.H() )
{
// view is taller than proj
if( v.YMin() > p.YMin() )
m_Offset.y = p.YMin();
if( v.YMax() < p.YMax() )
m_Offset.y = (p.y + p.H())-v.H();
}
else
{
// proj is taller than view
if( v.YMin() < 0 )
m_Offset.y = 0;
else if( v.YMax() > p.YMax() )
m_Offset.y = (p.y+p.H()) - v.H();
}
}
void VCAMRPoissonOp2::restrictResidual(LevelData<FArrayBox>& a_resCoarse,
LevelData<FArrayBox>& a_phiFine,
const LevelData<FArrayBox>& a_rhsFine)
{
CH_TIME("VCAMRPoissonOp2::restrictResidual");
homogeneousCFInterp(a_phiFine);
const DisjointBoxLayout& dblFine = a_phiFine.disjointBoxLayout();
for (DataIterator dit = a_phiFine.dataIterator(); dit.ok(); ++dit)
{
FArrayBox& phi = a_phiFine[dit];
m_bc(phi, dblFine[dit()], m_domain, m_dx, true);
}
a_phiFine.exchange(a_phiFine.interval(), m_exchangeCopier);
for (DataIterator dit = a_phiFine.dataIterator(); dit.ok(); ++dit)
{
FArrayBox& phi = a_phiFine[dit];
const FArrayBox& rhs = a_rhsFine[dit];
FArrayBox& res = a_resCoarse[dit];
const FArrayBox& thisACoef = (*m_aCoef)[dit];
const FluxBox& thisBCoef = (*m_bCoef)[dit];
Box region = dblFine.get(dit());
const IntVect& iv = region.smallEnd();
IntVect civ = coarsen(iv, 2);
res.setVal(0.0);
#if CH_SPACEDIM == 1
FORT_RESTRICTRESVC1D
#elif CH_SPACEDIM == 2
FORT_RESTRICTRESVC2D
#elif CH_SPACEDIM == 3
FORT_RESTRICTRESVC3D
#else
This_will_not_compile!
#endif
(CHF_FRA_SHIFT(res, civ),
CHF_CONST_FRA_SHIFT(phi, iv),
CHF_CONST_FRA_SHIFT(rhs, iv),
CHF_CONST_REAL(m_alpha),
CHF_CONST_FRA_SHIFT(thisACoef, iv),
CHF_CONST_REAL(m_beta),
#if CH_SPACEDIM >= 1
CHF_CONST_FRA_SHIFT(thisBCoef[0], iv),
#endif
#if CH_SPACEDIM >= 2
CHF_CONST_FRA_SHIFT(thisBCoef[1], iv),
#endif
#if CH_SPACEDIM >= 3
CHF_CONST_FRA_SHIFT(thisBCoef[2], iv),
#endif
#if CH_SPACEDIM >= 4
This_will_not_compile!
#endif
CHF_BOX_SHIFT(region, iv),
CHF_CONST_REAL(m_dx));
}
}
