Albany::PUMIMeshStruct::PUMIMeshStruct(
const Teuchos::RCP<Teuchos::ParameterList>& params,
const Teuchos::RCP<const Teuchos_Comm>& commT)
{
params->validateParameters(
*(PUMIMeshStruct::getValidDiscretizationParameters()), 0);
outputFileName = params->get<std::string>("PUMI Output File Name", "");
outputInterval = params->get<int>("PUMI Write Interval", 1); // write every time step default
std::string model_file;
if(params->isParameter("Mesh Model Input File Name"))
model_file = params->get<std::string>("Mesh Model Input File Name");
#ifdef SCOREC_SIMMODEL
if (params->isParameter("Acis Model Input File Name"))
model_file = params->get<std::string>("Parasolid Model Input File Name");
if(params->isParameter("Parasolid Model Input File Name"))
model_file = params->get<std::string>("Parasolid Model Input File Name");
#endif
if (params->isParameter("PUMI Input File Name")) {
std::string mesh_file = params->get<std::string>("PUMI Input File Name");
mesh = 0;
// If we are running in parallel but have a single mesh file, split it and rebalance
bool useSerialMesh = params->get<bool>("Use Serial Mesh", false);
if (useSerialMesh && commT->getSize() > 1){ // do the equivalent of the SCOREC "split" utility
apf::Migration* plan = 0;
gmi_model* g = 0;
g = gmi_load(model_file.c_str());
bool isOriginal = ((PCU_Comm_Self() % commT->getSize()) == 0);
switchToOriginals(commT->getSize());
if (isOriginal) {
mesh = apf::loadMdsMesh(g, mesh_file.c_str());
plan = getPlan(mesh, commT->getSize());
}
switchToAll();
mesh = repeatMdsMesh(mesh, g, plan, commT->getSize());
}
else {
mesh = apf::loadMdsMesh(model_file.c_str(), mesh_file.c_str());
}
} else {
int nex = params->get<int>("1D Elements", 0);
int ney = params->get<int>("2D Elements", 0);
int nez = params->get<int>("3D Elements", 0);
double wx = params->get<double>("1D Scale", 1);
double wy = params->get<double>("2D Scale", 1);
double wz = params->get<double>("3D Scale", 1);
bool is = ! params->get<bool>("Hexahedral", true);
buildBoxMesh(nex, ney, nez, wx, wy, wz, is);
}
model = mesh->getModel();
// Tell the mesh that we'll handle deleting the model.
apf::disownMdsModel(mesh);
bool isQuadMesh = params->get<bool>("2nd Order Mesh",false);
if (isQuadMesh)
apf::changeMeshShape(mesh, apf::getSerendipity(), false);
// Resize mesh after input if indicated in the input file
// User has indicated a desired element size in input file
if(params->isParameter("Resize Input Mesh Element Size")){
SizeFunction sizeFunction(params->get<double>(
"Resize Input Mesh Element Size", 0.1));
int num_iters = params->get<int>(
"Max Number of Mesh Adapt Iterations", 1);
ma::Input* input = ma::configure(mesh,&sizeFunction);
input->maximumIterations = num_iters;
input->shouldSnap = false;
ma::adapt(input);
}
// get the continuation step to write a restart file
restartWriteStep = params->get<int>("Write Restart File at Step",0);
APFMeshStruct::init(params, commT);
// if we have a restart time, we will want to override some of
// the default paramaters set by APFMeshStruct::init
if (params->isParameter("PUMI Restart Time")) {
hasRestartSolution = true;
restartDataTime = params->get<double>("PUMI Restart Time", 0.0);
std::string name = params->get<std::string>("PUMI Input File Name");
if (!PCU_Comm_Self())
std::cout << "Restarting from time: " << restartDataTime
<< " from restart file: " << name << std::endl;
}
if (params->isParameter("Load FELIX Data"))
shouldLoadFELIXData = true;
}
bool linearSpatial::cellSize
(
const point& pt,
scalar& size
) const
{
if (sideMode_ == rmBothsides)
{
size = sizeFunction(pt);
return true;
}
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, sqr(snapToSurfaceTol_)),
regionIndices_,
hits
);
const pointIndexHit& hitInfo = hits[0];
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (hitInfo.hit())
{
size = sizeFunction(pt);
return true;
}
pointField ptF(1, pt);
List<volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == volumeType::INSIDE
)
{
size = sizeFunction(pt);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == volumeType::OUTSIDE
)
{
size = sizeFunction(pt);
functionApplied = true;
}
return functionApplied;
}
bool surfaceOffsetLinearDistance::cellSize
(
const point& pt,
scalar& size
) const
{
size = 0;
List<pointIndexHit> hits;
surface_.findNearest
(
pointField(1, pt),
scalarField(1, totalDistanceSqr_),
regionIndices_,
hits
);
const pointIndexHit& hitInfo = hits[0];
if (hitInfo.hit())
{
const point& hitPt = hitInfo.hitPoint();
const label hitIndex = hitInfo.index();
const scalar dist = mag(pt - hitPt);
if (sideMode_ == rmBothsides)
{
size = sizeFunction(hitPt, dist, hitIndex);
return true;
}
// If the nearest point is essentially on the surface, do not do a
// getVolumeType calculation, as it will be prone to error.
if (mag(pt - hitInfo.hitPoint()) < snapToSurfaceTol_)
{
size = sizeFunction(hitPt, 0, hitIndex);
return true;
}
pointField ptF(1, pt);
List<volumeType> vTL;
surface_.getVolumeType(ptF, vTL);
bool functionApplied = false;
if
(
sideMode_ == smInside
&& vTL[0] == volumeType::INSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
else if
(
sideMode_ == smOutside
&& vTL[0] == volumeType::OUTSIDE
)
{
size = sizeFunction(hitPt, dist, hitIndex);
functionApplied = true;
}
return functionApplied;
}
return false;
}
