void
UiSettings::loadSettings()
{
QSettings s( "CS224", "snow" );
windowPosition() = s.value( "windowPosition", QPoint(0,0) ).toPoint();
windowSize() = s.value( "windowSize", QSize(1000,800) ).toSize();
fillNumParticles() = s.value( "fillNumParticles", 512*128 ).toInt();
fillResolution() = s.value( "fillResolution", 0.05f ).toFloat();
fillDensity() = s.value( "fillDensity", 150.f ).toFloat();
exportDensity() = s.value("exportDensity", false).toBool();
exportVelocity() = s.value("exportVelocity", false).toBool();
exportFPS() = s.value("exportFPS", 24).toInt();
maxTime() = s.value("maxTime", 3).toFloat();
gridPosition() = vec3( s.value("gridPositionX", 0.f).toFloat(),
s.value("gridPositionY", 0.f).toFloat(),
s.value("gridPositionZ", 0.f).toFloat() );
gridDimensions() = glm::ivec3( s.value("gridDimensionX", 128).toInt(),
s.value("gridDimensionY", 128).toInt(),
s.value("gridDimensionZ", 128).toInt() );
gridResolution() = s.value( "gridResolution", 0.05f ).toFloat();
timeStep() = s.value( "timeStep", 1e-5 ).toFloat();
implicit() = s.value( "implicit", true ).toBool();
materialPreset() = s.value( "materialPreset", MAT_DEFAULT).toInt();
showContainers() = s.value( "showContainers", true ).toBool();
showContainersMode() = s.value( "showContainersMode", WIREFRAME ).toInt();
showColliders() = s.value( "showColliders", true ).toBool();
showCollidersMode() = s.value( "showCollidersMode", SOLID ).toInt();
showGrid() = s.value( "showGrid", false ).toBool();
showGridMode() = s.value( "showGridMode", MIN_FACE_CELLS ).toInt();
showGridData() = s.value( "showGridData", false ).toBool();
showGridDataMode() = s.value( "showGridDataMode", NODE_DENSITY ).toInt();
showParticles() = s.value( "showParticles", true ).toBool();
showParticlesMode() = s.value( "showParticlesMode", PARTICLE_MASS ).toInt();
selectionColor() = glm::vec4( 0.302f, 0.773f, 0.839f, 1.f );
}
void
UiSettings::saveSettings()
{
QSettings s( "CS224", "snow" );
s.setValue( "windowPosition", windowPosition() );
s.setValue( "windowSize", windowSize() );
s.setValue( "fillNumParticles", fillNumParticles() );
s.setValue( "fillResolution", fillResolution() );
s.setValue( "fillDensity", fillDensity() );
s.setValue("exportDensity", exportDensity());
s.setValue("exportVelocity",exportVelocity());
s.setValue( "exportFPS", exportFPS());
s.setValue( "maxTime", maxTime());
s.setValue( "gridPositionX", gridPosition().x );
s.setValue( "gridPositionY", gridPosition().y );
s.setValue( "gridPositionZ", gridPosition().z );
s.setValue( "gridDimensionX", gridDimensions().x );
s.setValue( "gridDimensionY", gridDimensions().y );
s.setValue( "gridDimensionZ", gridDimensions().z );
s.setValue( "gridResolution", gridResolution() );
s.setValue( "timeStep", timeStep() );
s.setValue( "implicit", implicit() );
s.setValue("materialPreset", materialPreset());
s.setValue( "showContainers", showContainers() );
s.setValue( "showContainersMode", showContainersMode() );
s.setValue( "showColliders", showColliders() );
s.setValue( "showCollidersMode", showCollidersMode() );
s.setValue( "showGrid", showGrid() );
s.setValue( "showGridMode", showGridMode() );
s.setValue( "showGridData", showGridData() );
s.setValue( "showGridDataMode", showGridDataMode() );
s.setValue( "showParticles", showParticles() );
s.setValue( "showParticlesMode", showParticlesMode() );
}
int makeGeometry(
const Box& a_domain,
const RealVect& a_dx,
const RealVect& a_origin,
const RealVect& a_center,
const Real& a_radius)
{
int eekflag = 0;
RealVect normal = BASISV(0);
bool insideRegular = false;
SphereIF implicit(a_radius,a_center,insideRegular);
int verbosity = 0;
GeometryShop workshop(implicit,verbosity,a_dx);
CH_XD::EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain,a_origin,a_dx[0], workshop);
return eekflag;
}
int makeGeometry(Box& a_domain)
{
Real dx;
RealVect origin;
int eekflag = 0;
//parse input file
ParmParse pp;
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];
return(-1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim, 1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
dx = (prob_hi-prob_lo[0])/n_cell[0];
RealVect dxVect = dx*RealVect::Unit;
for (int idir = 0; idir < SpaceDim; idir++)
{
origin[idir] = prob_lo[idir];
}
int verbosity = 0;
int whichgeom;
pp.get("which_geom",whichgeom);
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
if (whichgeom == 0)
{
//allregular
pout() << "all regular geometry" << endl;
AllRegularService regserv;
ebisPtr->define(a_domain, origin, dx, regserv);
}
else if (whichgeom == 1)
{
pout() << "ramp geometry" << endl;
int upDir;
int indepVar;
Real startPt;
Real slope;
pp.get("up_dir",upDir);
pp.get("indep_var",indepVar);
pp.get("start_pt", startPt);
pp.get("ramp_slope", slope);
RealVect normal = RealVect::Zero;
normal[upDir] = 1.0;
normal[indepVar] = -slope;
RealVect point = RealVect::Zero;
point[upDir] = -slope*startPt;
bool normalInside = true;
PlaneIF ramp(normal,point,normalInside);
GeometryShop workshop(ramp,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else if (whichgeom == 5)
{
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);
bool insideRegular = false;
SphereIF implicit(sphereRadius,sphereCenter,insideRegular);
GeometryShop workshop(implicit,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else if (whichgeom == 13)
{
pout() << "rhodonea geometry" << endl;
vector<Real> tmp(SpaceDim);
pp.getarr("rhodonea_center", tmp, 0, SpaceDim);
RealVect rhodoneaCenter;
for (int idir = 0; idir < SpaceDim; idir++)
{
rhodoneaCenter[idir] = tmp[idir];
}
Real innerRadius;
pp.get("inner_radius", innerRadius);
Real outerRadius;
pp.get("outer_radius", outerRadius);
int frequency;
pp.get("frequency", frequency);
bool insideRegular = false;
RhodoneaIF implicit(innerRadius, outerRadius, frequency,
rhodoneaCenter, insideRegular);
GeometryShop workshop(implicit,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else if (whichgeom == 18)
{
pout() << "Low swirl burner geometry" << endl;
// AttachDebugger();
Box domain;
for (int idir = 0; idir < SpaceDim; idir++)
{
origin[idir] = prob_lo[idir];
}
Real outerRadius;
pp.get("outer_radius",outerRadius);
Real outerThick;
pp.get("outer_thick",outerThick);
Real outerHeight;
pp.get("outer_height",outerHeight);
Real outerOffset = ((prob_hi - prob_lo[0]) - outerHeight) / 2.0 + prob_lo[0];
Real innerRadius;
pp.get("inner_radius",innerRadius);
Real innerThick;
pp.get("inner_thick",innerThick);
Real innerOffset = 0.0;
innerOffset += outerOffset;
Real innerHeight;
pp.get("inner_height",innerHeight);
Real plateHeight;
pp.get("plate_height",plateHeight);
plateHeight += outerOffset;
Real plateThick;
pp.get("plate_thick",plateThick);
int doHoles;
pp.get("do_holes",doHoles);
Real holeRadius;
pp.get("hole_radius",holeRadius);
Real holeSpace;
pp.get("hole_space",holeSpace);
int vaneNum;
pp.get("vane_num",vaneNum);
Real vaneThick;
pp.get("vane_thick",vaneThick);
RealVect vaneNorm;
Vector<Real> vectVaneNorm;
pp.getarr("vane_norm",vectVaneNorm,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
vaneNorm[idir] = vectVaneNorm[idir];
}
Real vaneOffset;
pp.get("vane_offset",vaneOffset);
Real vaneHeight = innerHeight - 2*vaneOffset;
vaneOffset += outerOffset;
// Make the outer chamber
BaseIF* outerChamber = makeChamber(outerRadius,outerThick,
outerOffset,outerHeight);
// Make the inner chamber
BaseIF* innerChamber = makeChamber(innerRadius,innerThick,
innerOffset,innerHeight);
// Make the inner plate with holes
BaseIF* holyPlate = makePlate(plateHeight,plateThick,innerRadius,
doHoles,holeRadius,holeSpace);
// Make the vanes
BaseIF* vanes = makeVanes(vaneNum,vaneThick,vaneNorm,innerRadius,outerRadius,
vaneOffset,vaneHeight);
// Union all the pieces together
Vector<BaseIF*> pieces;
pieces.push_back(outerChamber);
pieces.push_back(innerChamber);
pieces.push_back(holyPlate);
pieces.push_back(vanes);
UnionIF swirl(pieces);
ComplementIF outside(swirl,true);
GeometryShop workshop(outside,verbosity,dxVect);
// This generates the new EBIS
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain, origin, dx, workshop);
}
else
{
//bogus which_geom
pout() << " bogus which_geom input = " << whichgeom;
eekflag = 33;
}
return eekflag;
}
BaseIF* makeGeometry(Box& a_domain,
RealVect& a_origin,
Real& a_dx)
{
RealVect point;
RealVect normal;
bool normalRegular;
// parse input file
ParmParse pp;
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];
exit(1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim,1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
a_dx = (prob_hi-prob_lo[0])/n_cell[0];
for (int idir = 0; idir < SpaceDim; idir++)
{
a_origin[idir] = prob_lo[idir];
}
// ParmParse doesn't get RealVects, so work-around with Vector<Real>
Vector<Real> vectorCenter;
pp.getarr("point",vectorCenter,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
point[idir] = vectorCenter[idir];
}
Vector<Real> vectorNormal;
pp.getarr("normal",vectorNormal,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
normal[idir] = vectorNormal[idir];
}
// Parm Parse doesn't get bools, so work-around with int
int intInsideRegular;
pp.get("normalRegular",intInsideRegular);
if (intInsideRegular != 0) normalRegular = true;
if (intInsideRegular == 0) normalRegular = false;
PlaneIF implicit(normal,point,normalRegular);
RealVect vectDx = RealVect::Unit;
vectDx *= a_dx;
GeometryShop workshop(implicit,0,vectDx);
// This generates the new EBIS
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain,a_origin,a_dx,workshop);
return implicit.newImplicitFunction();
}
int makeGeometry(Box& a_domain,
Real& a_dx,
RealVect& a_origin,
RealVect& a_center,
Real& a_radius,
bool& a_insideRegular)
{
int eekflag = 0;
// parse input file
ParmParse pp;
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];
return(-1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim,1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
a_dx = (prob_hi-prob_lo[0])/n_cell[0];
for (int idir = 0; idir < SpaceDim; idir++)
{
a_origin[idir] = prob_lo[idir];
}
pp.get("radius",a_radius);
// ParmParse doesn't get RealVects, so work-around with Vector<Real>
Vector<Real> vectorCenter;
pp.getarr("center",vectorCenter,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
a_center[idir] = vectorCenter[idir];
}
// Parm Parse doesn't get bools, so work-around with int
int intInsideRegular;
pp.get("intInsideRegular",intInsideRegular);
if (intInsideRegular == 1) a_insideRegular = true;
if (intInsideRegular == -1) a_insideRegular = false;
SphereIF implicit(a_radius,a_center,a_insideRegular);
// TorusIF implicit(a_radius,0.5*a_radius,a_center,a_insideRegular);
//
// TiltedCylinderIF implicit(0.5*a_radius,a_center,a_origin,a_insideRegular);
//
// RealVect spacing(D_DECL(1,2,3));
// RealVect origin(D_DECL(1,2,3));
// IntVect num(D_DECL(1,2,3));
// DataFileIF implicit(DataFileIF::ASCII,0.0,true);
//
// RealVect c1;
// c1 = a_center;
// c1[0] -= a_radius/3.0;
// SphereIF sphere1(a_radius/1.5,c1,a_insideRegular);
// ComplementIF invSph1(sphere1);
//
// RealVect c2;
// c2 = a_center;
// c2[0] += a_radius/3.0;
// SphereIF sphere2(a_radius/1.5,c2,a_insideRegular);
// ComplementIF invSph2(sphere2);
//
// SphereIF sphere3(a_radius/2.5,a_center,a_insideRegular);
//
// IntersectionIF inter(sphere1,invSph2);
// UnionIF implicit(inter,sphere3);
RealVect vectDx = RealVect::Unit;
vectDx *= a_dx;
GeometryShop workshop(implicit,0,vectDx);
// this generates the new EBIS
CH_XD::EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain,a_origin,a_dx,workshop);
return eekflag;
}
int main() {
const char* meow = "meow";
purr(meow);
purr( implicit() );
int convert = implicit{};
}
BaseIF* makeGeometry(Box& a_domain,
RealVect& a_origin,
Real& a_dx)
{
RealVect center1;
Real radius1;
RealVect center2;
Real radius2;
bool insideRegular;
// parse input file
ParmParse pp;
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];
exit(1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim,1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
a_dx = (prob_hi-prob_lo[0])/n_cell[0];
for (int idir = 0; idir < SpaceDim; idir++)
{
a_origin[idir] = prob_lo[idir];
}
// ParmParse doesn't get RealVects, so work-around with Vector<Real>
Vector<Real> vectorCenter;
pp.getarr("center1",vectorCenter,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
center1[idir] = vectorCenter[idir];
}
pp.get("radius1",radius1);
pp.getarr("center2",vectorCenter,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
center2[idir] = vectorCenter[idir];
}
pp.get("radius2",radius2);
// Parm Parse doesn't get bools, so work-around with int
int intInsideRegular;
pp.get("insideRegular",intInsideRegular);
if (intInsideRegular != 0) insideRegular = true;
if (intInsideRegular == 0) insideRegular = false;
// Stay inside until the end
bool inside = true;
// Sphere 1 is the given "radius1" and "center1"
SphereIF sphere1(radius1,center1,inside);
// Sphere 2 is the given "radius2" and "center2"
SphereIF sphere2(radius2,center2,inside);
// Take the union of the spheres
UnionIF implicit(sphere1,sphere2);
// Complement if necessary
ComplementIF insideOut(implicit,!insideRegular);
RealVect vectDx = RealVect::Unit;
vectDx *= a_dx;
GeometryShop workshop(insideOut,0,vectDx);
// This generates the new EBIS
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain,a_origin,a_dx,workshop);
return insideOut.newImplicitFunction();
}
void AstBasicDType::dump(ostream& str) {
this->AstNodeDType::dump(str);
str<<" kwd="<<keyword().ascii();
if (isRanged() && !rangep()) str<<" range=["<<msb()<<":"<<lsb()<<"]";
if (implicit()) str<<" [IMPLICIT]";
}
BaseIF* makeGeometry(Box& a_domain,
RealVect& a_origin,
Real& a_dx)
{
RealVect center;
RealVect radii;
bool insideRegular;
// parse input file
ParmParse pp;
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];
exit(1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim,1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
a_dx = (prob_hi-prob_lo[0])/n_cell[0];
for (int idir = 0; idir < SpaceDim; idir++)
{
a_origin[idir] = prob_lo[idir];
}
// ParmParse doesn't get RealVects, so work-around with Vector<Real>
Vector<Real> vectorCenter;
pp.getarr("center",vectorCenter,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
center[idir] = vectorCenter[idir];
}
Vector<Real> vectorRadii;
pp.getarr("radii",vectorRadii,0,SpaceDim);
for (int idir = 0; idir < SpaceDim; idir++)
{
radii[idir] = vectorRadii[idir];
}
int halfTurns;
pp.get("halfturns",halfTurns);
// Parm Parse doesn't get bools, so work-around with int
int intInsideRegular;
pp.get("insideRegular",intInsideRegular);
if (intInsideRegular != 0) insideRegular = true;
if (intInsideRegular == 0) insideRegular = false;
IntVect zero=IntVect::Zero;
bool inside = true;
EllipsoidIF ellipsoid(radii,center,inside);
Real coef = halfTurns / 2.0;
IntVect power(D_DECL(1,0,0));
Vector<PolyTerm> term;
term.resize(1);
term[0].coef = coef;
term[0].powers = power;
PolynomialIF rotate(term,inside);
LatheIF implicit(ellipsoid,rotate,center,insideRegular);
RealVect vectDx = RealVect::Unit;
vectDx *= a_dx;
GeometryShop workshop(implicit,0,vectDx);
// This generates the new EBIS
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
ebisPtr->define(a_domain,a_origin,a_dx,workshop);
return implicit.newImplicitFunction();
}
int makeGeometry(Box& a_domain)
{
Real dx;
RealVect origin;
int eekflag = 0;
//parse input file
ParmParse pp;
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];
return(-1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim, 1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
dx = (prob_hi-prob_lo[0])/n_cell[0];
RealVect dxVect = dx*RealVect::Unit;
for (int idir = 0; idir < SpaceDim; idir++)
{
origin[idir] = prob_lo[idir];
}
int verbosity = 0;
int whichgeom;
pp.get("which_geom",whichgeom);
EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
if (whichgeom == 0)
{
//allregular
pout() << "all regular geometry" << endl;
AllRegularService regserv;
ebisPtr->define(a_domain, origin, dx, regserv);
}
else if (whichgeom == 1)
{
pout() << "ramp geometry" << endl;
int upDir;
int indepVar;
Real startPt;
Real slope;
pp.get("up_dir",upDir);
pp.get("indep_var",indepVar);
pp.get("start_pt", startPt);
pp.get("ramp_slope", slope);
RealVect normal = RealVect::Zero;
normal[upDir] = 1.0;
normal[indepVar] = -slope;
RealVect point = RealVect::Zero;
point[upDir] = -slope*startPt;
bool normalInside = true;
PlaneIF ramp(normal,point,normalInside);
GeometryShop workshop(ramp,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else if (whichgeom == 5)
{
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);
bool insideRegular = false;
SphereIF implicit(sphereRadius,sphereCenter,insideRegular);
GeometryShop workshop(implicit,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else if (whichgeom == 13)
{
pout() << "rhodonea geometry" << endl;
vector<Real> tmp(SpaceDim);
pp.getarr("rhodonea_center", tmp, 0, SpaceDim);
RealVect rhodoneaCenter;
for (int idir = 0; idir < SpaceDim; idir++)
{
rhodoneaCenter[idir] = tmp[idir];
}
Real innerRadius;
pp.get("inner_radius", innerRadius);
Real outerRadius;
pp.get("outer_radius", outerRadius);
int frequency;
pp.get("frequency", frequency);
bool insideRegular = false;
RhodoneaIF implicit(innerRadius, outerRadius, frequency,
rhodoneaCenter, insideRegular);
GeometryShop workshop(implicit,verbosity,dxVect);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, dx, workshop);
}
else
{
//bogus which_geom
pout() << " bogus which_geom input = " << whichgeom;
eekflag = 33;
}
return eekflag;
}
void AllowedGroupTokensMessageArg::append(MessageBuilder &builder) const
{
const MessageFragment *fragment[4];
int nFragments = 0;
if (allow_.groupToken(GroupToken::dataTagLiteral))
fragment[nFragments++] = &ParserMessages::parameterLiteral;
if (allow_.groupToken(GroupToken::dataTagGroup))
fragment[nFragments++] = &ParserMessages::dataTagGroup;
switch (allow_.group()) {
case GroupToken::modelGroup:
fragment[nFragments++] = &ParserMessages::modelGroup;
break;
case GroupToken::dataTagTemplateGroup:
fragment[nFragments++] = &ParserMessages::dataTagTemplateGroup;
break;
default:
break;
}
switch (allow_.nameStart()) {
case GroupToken::name:
fragment[nFragments++] = &ParserMessages::name;
break;
case GroupToken::nameToken:
fragment[nFragments++] = &ParserMessages::nameToken;
break;
case GroupToken::elementToken:
fragment[nFragments++] = &ParserMessages::elementToken;
break;
default:
break;
}
Boolean first = 1;
for (int i = 0; i < nFragments; i++) {
if (!first)
builder.appendFragment(ParserMessages::listSep);
else
first = 0;
builder.appendFragment(*fragment[i]);
}
if (allow_.groupToken(GroupToken::pcdata)) {
if (!first)
builder.appendFragment(ParserMessages::listSep);
StringC pcdata(syntax_->delimGeneral(Syntax::dRNI));
pcdata += syntax_->reservedName(Syntax::rPCDATA);
builder.appendChars(pcdata.data(), pcdata.size());
}
if (allow_.groupToken(GroupToken::all)) {
if (!first)
builder.appendFragment(ParserMessages::listSep);
StringC all(syntax_->delimGeneral(Syntax::dRNI));
all += syntax_->reservedName(Syntax::rALL);
builder.appendChars(all.data(), all.size());
}
if (allow_.groupToken(GroupToken::implicit)) {
if (!first)
builder.appendFragment(ParserMessages::listSep);
StringC implicit(syntax_->delimGeneral(Syntax::dRNI));
implicit += syntax_->reservedName(Syntax::rIMPLICIT);
builder.appendChars(implicit.data(), implicit.size());
}
}
int makeGeometry(Box& a_domain,
RealVect& a_dx)
{
int eekflag = 0;
//parse input file
ParmParse pp;
int verbosity = 0;
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];
return(-1);
}
hi[ivec] = n_cell[ivec] - 1;
}
a_domain.setSmall(lo);
a_domain.setBig(hi);
Vector<Real> prob_lo(SpaceDim, 1.0);
Real prob_hi;
pp.getarr("prob_lo",prob_lo,0,SpaceDim);
pp.get("prob_hi",prob_hi);
for (int idir = 0; idir < SpaceDim; idir++)
{
a_dx[idir] = (prob_hi-prob_lo[idir])/n_cell[idir];
origin[idir] = prob_lo[idir];
}
int whichgeom;
pp.get("which_geom",whichgeom);
CH_XD::EBIndexSpace* ebisPtr = Chombo_EBIS::instance();
if (whichgeom == 0)
{
//allregular
pout() << "all regular geometry" << endl;
AllRegularService regserv;
ebisPtr->define(a_domain, origin, a_dx[0], regserv);
}
else if (whichgeom == 1)
{
pout() << "ramp geometry" << endl;
int upDir;
int indepVar;
Real startPt;
Real slope;
pp.get("up_dir",upDir);
pp.get("indep_var",indepVar);
pp.get("start_pt", startPt);
pp.get("ramp_slope", slope);
RealVect normal = RealVect::Zero;
normal[upDir] = 1.0;
normal[indepVar] = -slope;
RealVect point = RealVect::Zero;
point[upDir] = -slope*startPt;
bool normalInside = true;
PlaneIF ramp(normal,point,normalInside);
GeometryShop workshop(ramp,verbosity,a_dx);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, a_dx[0], workshop);
}
else if (whichgeom == 5)
{
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);
bool insideRegular = false;
SphereIF implicit(sphereRadius,sphereCenter,insideRegular);
GeometryShop workshop(implicit,verbosity,a_dx);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, a_dx[0], workshop);
}
else if (whichgeom == 6)
{
pout() << "multisphere geometry" << endl;
int numSpheres;
pp.get("num_spheres", numSpheres);
Vector<Real> radius(numSpheres);
Vector<RealVect> center(numSpheres);
for (int isphere = 0; isphere < numSpheres; isphere++)
{
char radiusString[80];
char centerString[80];
sprintf(radiusString, "sphere_radius_%d", isphere);
sprintf(centerString, "sphere_center_%d", isphere);
vector<Real> sphere_center(SpaceDim);
Real sphereRadius;
pp.get(radiusString, sphereRadius);
pp.getarr(centerString,sphere_center, 0, SpaceDim);
RealVect sphereCenter;
for (int idir = 0; idir < SpaceDim; idir++)
{
sphereCenter[idir] = sphere_center[idir];
}
center[isphere] = sphereCenter;
radius[isphere] = sphereRadius;
}
bool inside = false;
MultiSphereIF spheres(radius, center, inside);
GeometryShop workshop(spheres,verbosity,a_dx);
//this generates the new EBIS
ebisPtr->define(a_domain, origin, a_dx[0], workshop);
}
else
{
//bogus which_geom
pout() << " bogus which_geom input = " << whichgeom;
eekflag = 33;
}
return eekflag;
}
