int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); // initialize MPI
int rank = Teuchos::GlobalMPISession::getRank();
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
string meshFileName;
bool readInParallel = true;
cmdp.setOption("meshFile", &meshFileName );
cmdp.setOption("readDistributed", "readReplicated", &readInParallel );
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
MeshTopologyPtr meshTopo = MeshFactory::importMOABMesh(meshFileName, readInParallel);
int spaceDim = meshTopo->getDimension();
int cellCount = meshTopo->activeCellCount();
if (rank==0) cout << spaceDim << "D mesh topology has " << cellCount << " cells.\n";
return 0;
}
MeshTopologyPtr MeshTopologyTests::makeHexMesh(double x0, double y0, double z0, double width, double height, double depth,
unsigned horizontalCells, unsigned verticalCells, unsigned depthCells)
{
unsigned spaceDim = 3;
MeshTopologyPtr mesh = Teuchos::rcp( new MeshTopology(spaceDim) );
double dx = width / horizontalCells;
double dy = height / verticalCells;
double dz = depth / depthCells;
CellTopoPtrLegacy hexTopo = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() ) );
for (unsigned i=0; i<horizontalCells; i++)
{
double x = x0 + dx * i;
for (unsigned j=0; j<verticalCells; j++)
{
double y = y0 + dy * j;
for (unsigned k=0; k<depthCells; k++)
{
double z = z0 + dz * k;
vector< vector<double> > vertices = hexPoints(x, y, z, dx, dy, dz);
mesh->addCell(hexTopo, vertices);
}
}
}
return mesh;
}
CellTopoPtrLegacy getBottomTopology(MeshTopologyPtr meshTopo, IndexType cellID) {
int spaceDim = meshTopo->getSpaceDim() - 1;
// determine cell topology:
vector<IndexType> cellVertexIndices = meshTopo->getCell(cellID)->vertices();
set<IndexType> bottomVertexIndices;
int bottomNodeCount = cellVertexIndices.size() / 2;
for (int i=0; i<bottomNodeCount; i++) {
bottomVertexIndices.insert(cellVertexIndices[i]);
}
IndexType bottomEntityIndex = meshTopo->getEntityIndex(spaceDim, bottomVertexIndices);
unsigned bottomCellTopoKey = meshTopo->getEntityTopology(spaceDim, bottomEntityIndex).getKey();
CellTopoPtrLegacy cellTopo = CamelliaCellTools::cellTopoForKey(bottomCellTopoKey);
return cellTopo;
}
void printMeshInfo(MeshTopologyPtr mesh)
{
unsigned spaceDim = mesh->getDimension();
unsigned vertexCount = mesh->getEntityCount(0);
unsigned edgeCount = (spaceDim > 1) ? mesh->getEntityCount(1) : 0;
unsigned faceCount = (spaceDim > 2) ? mesh->getEntityCount(2) : 0;
if (vertexCount > 0)
{
cout << "Vertices:\n";
for (int vertexIndex=0; vertexIndex < vertexCount; vertexIndex++)
{
mesh->printEntityVertices(0, vertexIndex);
}
}
if (edgeCount > 0)
{
cout << "Edges:\n";
for (int edgeIndex=0; edgeIndex < edgeCount; edgeIndex++)
{
cout << "Edge " << edgeIndex << ":\n";
mesh->printEntityVertices(1, edgeIndex);
}
}
if (faceCount > 0)
{
cout << "Faces:\n";
for (int faceIndex=0; faceIndex < faceCount; faceIndex++)
{
cout << "Face " << faceIndex << ":\n";
mesh->printEntityVertices(2, faceIndex);
}
}
}
MeshPtr MeshTools::timeSliceMesh(MeshPtr spaceTimeMesh, double t,
map<GlobalIndexType, GlobalIndexType> &sliceCellIDToSpaceTimeCellID, int H1OrderForSlice) {
MeshTopologyPtr meshTopo = spaceTimeMesh->getTopology();
set<IndexType> cellIDsToCheck = meshTopo->getRootCellIndices();
set<IndexType> activeCellIDsForTime;
set<IndexType> allActiveCellIDs = meshTopo->getActiveCellIndices();
int spaceDim = meshTopo->getSpaceDim() - 1; // # of true spatial dimensions
MeshTopologyPtr sliceTopo = Teuchos::rcp( new MeshTopology(spaceDim) );
set<IndexType> rootCellIDs = meshTopo->getRootCellIndices();
for (set<IndexType>::iterator rootCellIt = rootCellIDs.begin(); rootCellIt != rootCellIDs.end(); rootCellIt++) {
IndexType rootCellID = *rootCellIt;
FieldContainer<double> physicalNodes = spaceTimeMesh->physicalCellNodesForCell(rootCellID);
if (cellMatches(physicalNodes, t)) { // cell and some subset of its descendents should be included in slice mesh
vector< vector< double > > sliceNodes = timeSliceForCell(physicalNodes, t);
CellTopoPtrLegacy cellTopo = getBottomTopology(meshTopo, rootCellID);
CellPtr sliceCell = sliceTopo->addCell(cellTopo, sliceNodes);
sliceCellIDToSpaceTimeCellID[sliceCell->cellIndex()] = rootCellID;
}
}
MeshPtr sliceMesh = Teuchos::rcp( new Mesh(sliceTopo, spaceTimeMesh->bilinearForm(), H1OrderForSlice, spaceDim) );
// process refinements. For now, we assume isotropic refinements, which means that each refinement in spacetime induces a refinement in the spatial slice
set<IndexType> sliceCellIDsToCheckForRefinement = sliceTopo->getActiveCellIndices();
while (sliceCellIDsToCheckForRefinement.size() > 0) {
set<IndexType>::iterator cellIt = sliceCellIDsToCheckForRefinement.begin();
IndexType sliceCellID = *cellIt;
sliceCellIDsToCheckForRefinement.erase(cellIt);
CellPtr sliceCell = sliceTopo->getCell(sliceCellID);
CellPtr spaceTimeCell = meshTopo->getCell(sliceCellIDToSpaceTimeCellID[sliceCellID]);
if (spaceTimeCell->isParent()) {
set<GlobalIndexType> cellsToRefine;
cellsToRefine.insert(sliceCellID);
sliceMesh->hRefine(cellsToRefine, RefinementPattern::regularRefinementPattern(sliceCell->topology()->getKey()));
vector<IndexType> spaceTimeChildren = spaceTimeCell->getChildIndices();
for (int childOrdinal=0; childOrdinal<spaceTimeChildren.size(); childOrdinal++) {
IndexType childID = spaceTimeChildren[childOrdinal];
FieldContainer<double> childNodes = meshTopo->physicalCellNodesForCell(childID);
if (cellMatches(childNodes, t)) {
vector< vector<double> > childSlice = timeSliceForCell(childNodes, t);
CellPtr childSliceCell = sliceTopo->findCellWithVertices(childSlice);
sliceCellIDToSpaceTimeCellID[childSliceCell->cellIndex()] = childID;
sliceCellIDsToCheckForRefinement.insert(childSliceCell->cellIndex());
}
}
}
}
return sliceMesh;
}
MeshPtr MeshTools::timeSliceMesh(MeshPtr spaceTimeMesh, double t,
map<GlobalIndexType, GlobalIndexType> &sliceCellIDToSpaceTimeCellID, int H1OrderForSlice)
{
MeshTopology* meshTopo = dynamic_cast<MeshTopology*>(spaceTimeMesh->getTopology().get());
TEUCHOS_TEST_FOR_EXCEPTION(!meshTopo, std::invalid_argument, "timeSliceMesh() called with spaceTimeMesh that appears to be pure MeshTopologyView. This is not supported.");
set<IndexType> cellIDsToCheck = meshTopo->getRootCellIndices();
set<IndexType> activeCellIDsForTime;
set<IndexType> allActiveCellIDs = meshTopo->getActiveCellIndices();
int spaceDim = meshTopo->getDimension() - 1; // # of true spatial dimensions
MeshTopologyPtr sliceTopo = Teuchos::rcp( new MeshTopology(spaceDim) );
set<IndexType> rootCellIDs = meshTopo->getRootCellIndices();
for (set<IndexType>::iterator rootCellIt = rootCellIDs.begin(); rootCellIt != rootCellIDs.end(); rootCellIt++)
{
IndexType rootCellID = *rootCellIt;
FieldContainer<double> physicalNodes = spaceTimeMesh->physicalCellNodesForCell(rootCellID);
if (cellMatches(physicalNodes, t)) // cell and some subset of its descendents should be included in slice mesh
{
vector< vector< double > > sliceNodes = timeSliceForCell(physicalNodes, t);
CellTopoPtr cellTopo = getBottomTopology(meshTopo, rootCellID);
GlobalIndexType newCellID = sliceTopo->cellCount();
CellPtr sliceCell = sliceTopo->addCell(newCellID, cellTopo, sliceNodes); // for consistency, this is only valid if run on every MPI rank.
sliceCellIDToSpaceTimeCellID[sliceCell->cellIndex()] = rootCellID;
}
}
MeshPtr sliceMesh = Teuchos::rcp( new Mesh(sliceTopo, spaceTimeMesh->bilinearForm(), H1OrderForSlice, spaceDim) );
// process refinements. For now, we assume isotropic refinements, which means that each refinement in spacetime induces a refinement in the spatial slice
set<IndexType> sliceCellIDsToCheckForRefinement = sliceTopo->getActiveCellIndices();
while (sliceCellIDsToCheckForRefinement.size() > 0)
{
set<IndexType>::iterator cellIt = sliceCellIDsToCheckForRefinement.begin();
IndexType sliceCellID = *cellIt;
sliceCellIDsToCheckForRefinement.erase(cellIt);
CellPtr sliceCell = sliceTopo->getCell(sliceCellID);
CellPtr spaceTimeCell = meshTopo->getCell(sliceCellIDToSpaceTimeCellID[sliceCellID]);
if (spaceTimeCell->isParent(spaceTimeMesh->getTopology()))
{
set<GlobalIndexType> cellsToRefine;
cellsToRefine.insert(sliceCellID);
sliceMesh->hRefine(cellsToRefine, RefinementPattern::regularRefinementPattern(sliceCell->topology()));
vector<IndexType> spaceTimeChildren = spaceTimeCell->getChildIndices(spaceTimeMesh->getTopology());
for (int childOrdinal=0; childOrdinal<spaceTimeChildren.size(); childOrdinal++)
{
IndexType childID = spaceTimeChildren[childOrdinal];
FieldContainer<double> childNodes = meshTopo->physicalCellNodesForCell(childID);
if (cellMatches(childNodes, t))
{
vector< vector<double> > childSlice = timeSliceForCell(childNodes, t);
CellPtr childSliceCell = sliceTopo->findCellWithVertices(childSlice);
sliceCellIDToSpaceTimeCellID[childSliceCell->cellIndex()] = childID;
sliceCellIDsToCheckForRefinement.insert(childSliceCell->cellIndex());
}
}
}
}
MeshPartitionPolicyPtr partitionPolicy = MeshPartitionPolicy::inducedPartitionPolicy(sliceMesh, spaceTimeMesh, sliceCellIDToSpaceTimeCellID);
sliceMesh->setPartitionPolicy(partitionPolicy);
return sliceMesh;
}
SpaceTimeIncompressibleFormulation::SpaceTimeIncompressibleFormulation(Teuchos::RCP<IncompressibleProblem> problem, Teuchos::ParameterList ¶meters)
{
int spaceDim = parameters.get<int>("spaceDim", 2);
bool steady = parameters.get<bool>("steady", true);
double mu = parameters.get<double>("mu", 1e-2);
bool useConformingTraces = parameters.get<bool>("useConformingTraces", false);
int fieldPolyOrder = parameters.get<int>("fieldPolyOrder", 2);
int delta_p = parameters.get<int>("delta_p", 2);
int numTElems = parameters.get<int>("numTElems", 2);
string norm = parameters.get<string>("norm", "Graph");
string savedSolutionAndMeshPrefix = parameters.get<string>("savedSolutionAndMeshPrefix", "");
_spaceDim = spaceDim;
_steady = steady;
_mu = mu;
_useConformingTraces = useConformingTraces;
MeshTopologyPtr meshTopo = problem->meshTopology(numTElems);
MeshGeometryPtr meshGeometry = problem->meshGeometry();
if (!steady)
{
TEUCHOS_TEST_FOR_EXCEPTION(meshTopo->getDimension() != _spaceDim + 1, std::invalid_argument, "MeshTopo must be space-time mesh for transient");
}
else
{
TEUCHOS_TEST_FOR_EXCEPTION(meshTopo->getDimension() != _spaceDim, std::invalid_argument, "MeshTopo must be spatial mesh for steady");
}
TEUCHOS_TEST_FOR_EXCEPTION(mu==0, std::invalid_argument, "mu may not be 0!");
TEUCHOS_TEST_FOR_EXCEPTION(spaceDim==1, std::invalid_argument, "Incompressible Navier-Stokes is trivial for spaceDim=1");
TEUCHOS_TEST_FOR_EXCEPTION((spaceDim != 2) && (spaceDim != 3), std::invalid_argument, "spaceDim must be 2 or 3");
Space uHatSpace = useConformingTraces ? HGRAD : L2;
FunctionPtr zero = Function::constant(1);
FunctionPtr one = Function::constant(1);
FunctionPtr n_x = TFunction<double>::normal(); // spatial normal
// FunctionPtr n_x_parity = n_x * TFunction<double>::sideParity();
FunctionPtr n_xt = TFunction<double>::normalSpaceTime();
// FunctionPtr n_xt_parity = n_xt * TFunction<double>::sideParity();
// declare all possible variables -- will only create the ones we need for spaceDim
// fields
VarPtr u1, u2, u3;
VarPtr sigma11, sigma12, sigma13;
VarPtr sigma21, sigma22, sigma23;
VarPtr sigma31, sigma32, sigma33;
VarPtr p;
// traces
VarPtr u1hat, u2hat, u3hat;
VarPtr tm1hat, tm2hat, tm3hat;
// tests
VarPtr v1, v2, v3;
VarPtr tau1, tau2, tau3;
VarPtr q;
_vf = VarFactory::varFactory();
if (spaceDim == 1)
{
u1 = _vf->fieldVar(s_u1);
sigma11 = _vf->fieldVar(s_sigma11);
p = _vf->fieldVar(s_p);
u1hat = _vf->traceVarSpaceOnly(s_u1hat, 1.0 * u1, uHatSpace);
tm1hat = _vf->fluxVar(s_tm1hat);
v1 = _vf->testVar(s_v1, HGRAD);
tau1 = _vf->testVar(s_tau1, HGRAD); // scalar
q = _vf->testVar(s_q, HGRAD);
}
if (spaceDim == 2)
{
u1 = _vf->fieldVar(s_u1);
u2 = _vf->fieldVar(s_u2);
sigma11 = _vf->fieldVar(s_sigma11);
sigma12 = _vf->fieldVar(s_sigma12);
sigma21 = _vf->fieldVar(s_sigma21);
sigma22 = _vf->fieldVar(s_sigma22);
p = _vf->fieldVar(s_p);
u1hat = _vf->traceVarSpaceOnly(s_u1hat, 1.0 * u1, uHatSpace);
u2hat = _vf->traceVarSpaceOnly(s_u2hat, 1.0 * u2, uHatSpace);
// LinearTermPtr tm1_lt, tm2_lt;
// tm1_lt = p * n_x->x() - sigma11 * n_x->x() - sigma12 * n_x->y();
// tm2_lt = p * n_x->y() - sigma21 * n_x->x() - sigma22 * n_x->y();
// tm1hat = _vf->fluxVar(s_tm1hat, tm1_lt);
// tm2hat = _vf->fluxVar(s_tm2hat, tm2_lt);
tm1hat = _vf->fluxVar(s_tm1hat);
tm2hat = _vf->fluxVar(s_tm2hat);
v1 = _vf->testVar(s_v1, HGRAD);
v2 = _vf->testVar(s_v2, HGRAD);
tau1 = _vf->testVar(s_tau1, HDIV); // vector
tau2 = _vf->testVar(s_tau2, HDIV); // vector
q = _vf->testVar(s_q, HGRAD);
}
if (spaceDim == 3)
{
u1 = _vf->fieldVar(s_u1);
u2 = _vf->fieldVar(s_u2);
u3 = _vf->fieldVar(s_u3);
sigma11 = _vf->fieldVar(s_sigma11);
sigma12 = _vf->fieldVar(s_sigma12);
sigma13 = _vf->fieldVar(s_sigma13);
sigma21 = _vf->fieldVar(s_sigma21);
sigma22 = _vf->fieldVar(s_sigma22);
sigma23 = _vf->fieldVar(s_sigma23);
sigma31 = _vf->fieldVar(s_sigma31);
sigma32 = _vf->fieldVar(s_sigma32);
sigma33 = _vf->fieldVar(s_sigma33);
p = _vf->fieldVar(s_p);
u1hat = _vf->traceVarSpaceOnly(s_u1hat, 1.0 * u1, uHatSpace);
u2hat = _vf->traceVarSpaceOnly(s_u2hat, 1.0 * u2, uHatSpace);
u3hat = _vf->traceVarSpaceOnly(s_u3hat, 1.0 * u3, uHatSpace);
tm1hat = _vf->fluxVar(s_tm1hat);
tm2hat = _vf->fluxVar(s_tm2hat);
tm3hat = _vf->fluxVar(s_tm3hat);
v1 = _vf->testVar(s_v1, HGRAD);
v2 = _vf->testVar(s_v2, HGRAD);
v3 = _vf->testVar(s_v3, HGRAD);
tau1 = _vf->testVar(s_tau1, HDIV); // vector
tau2 = _vf->testVar(s_tau2, HDIV); // vector
tau3 = _vf->testVar(s_tau3, HDIV); // vector
q = _vf->testVar(s_q, HGRAD);
}
// LinearTermPtr tc_lt;
// if (spaceDim == 1)
// {
// tc_lt = beta->x()*n_x_parity->x()*u
// -sigma1 * n_x_parity->x()
// + u*n_xt_parity->t();
// }
// else if (spaceDim == 2)
// {
// tc_lt = beta->x()*n_x_parity->x()*u
// + beta->y()*n_x_parity->y()*u
// - sigma1 * n_x_parity->x()
// - sigma2 * n_x_parity->y()
// + u*n_xt_parity->t();
// }
// else if (spaceDim == 3)
// {
// tc_lt = beta->x()*n_x_parity->x()*u
// + beta->y()*n_x_parity->y()*u
// + beta->z()*n_x_parity->z()*u
// - sigma1 * n_x_parity->x()
// - sigma2 * n_x_parity->y()
// - sigma3 * n_x_parity->z()
// + u*n_xt_parity->t();
// }
// tc = _vf->fluxVar(s_tc, tc_lt);
_bf = Teuchos::rcp( new BF(_vf) );
// Define mesh
BCPtr bc = BC::bc();
vector<int> H1Order(2);
H1Order[0] = fieldPolyOrder + 1;
H1Order[1] = fieldPolyOrder + 1; // for now, use same poly. degree for temporal bases...
if (savedSolutionAndMeshPrefix == "")
{
map<int,int> trialOrderEnhancements;
// trialOrderEnhancements[tm1hat->ID()] = fieldPolyOrder;
// trialOrderEnhancements[tm2hat->ID()] = fieldPolyOrder;
// trialOrderEnhancements[u1hat->ID()] = fieldPolyOrder;
// trialOrderEnhancements[u2hat->ID()] = fieldPolyOrder;
// MeshPtr proxyMesh = Teuchos::rcp( new Mesh(meshTopo->deepCopy(), _bf, H1Order, delta_p) ) ;
_mesh = Teuchos::rcp( new Mesh(meshTopo, _bf, H1Order, delta_p, trialOrderEnhancements) ) ;
if (meshGeometry != Teuchos::null)
_mesh->setEdgeToCurveMap(meshGeometry->edgeToCurveMap());
// problem->preprocessMesh(_mesh);
// proxyMesh->registerObserver(_mesh);
// problem->preprocessMesh(proxyMesh);
// _mesh->enforceOneIrregularity();
_solutionUpdate = Solution::solution(_bf, _mesh, bc);
_solutionBackground = Solution::solution(_bf, _mesh, bc);
map<int, FunctionPtr> initialGuess;
initialGuess[u(1)->ID()] = problem->u1_exact();
initialGuess[u(2)->ID()] = problem->u2_exact();
initialGuess[sigma(1,1)->ID()] = problem->sigma1_exact()->x();
initialGuess[sigma(1,2)->ID()] = problem->sigma1_exact()->y();
initialGuess[sigma(2,1)->ID()] = problem->sigma2_exact()->x();
initialGuess[sigma(2,2)->ID()] = problem->sigma2_exact()->y();
// initialGuess[p()->ID()] = problem->p_exact();
initialGuess[uhat(1)->ID()] = problem->u1_exact();
initialGuess[uhat(2)->ID()] = problem->u2_exact();
// initialGuess[tmhat(1)->ID()] =
// (problem->u1_exact()*problem->u1_exact()-problem->sigma1_exact()->x()+problem->p_exact())*n_x->x()
// + (problem->u1_exact()*problem->u2_exact()-problem->sigma1_exact()->y())*n_x->y();
// initialGuess[tmhat(2)->ID()] =
// (problem->u1_exact()*problem->u2_exact()-problem->sigma2_exact()->x())*n_x->x()
// + (problem->u2_exact()*problem->u2_exact()-problem->sigma2_exact()->y()+problem->p_exact())*n_x->y();
_solutionBackground->projectOntoMesh(initialGuess);
}
else
{
// // BFPTR version should be deprecated
_mesh = MeshFactory::loadFromHDF5(_bf, savedSolutionAndMeshPrefix+".mesh");
_solutionBackground = Solution::solution(_bf, _mesh, bc);
_solutionBackground->loadFromHDF5(savedSolutionAndMeshPrefix+".soln");
_solutionUpdate = Solution::solution(_bf, _mesh, bc);
// _solutionUpdate->loadFromHDF5(savedSolutionAndMeshPrefix+"_update.soln");
}
// _solutionUpdate->setFilter(problem->pc());
// _solutionBackground->setFilter(problem->pc());
FunctionPtr u1_prev = Function::solution(u1, _solutionBackground);
FunctionPtr u2_prev = Function::solution(u2, _solutionBackground);
FunctionPtr u_prev = Function::vectorize(u1_prev, u2_prev);
if (spaceDim == 2)
{
// stress equation
_bf->addTerm((1.0 / _mu) * sigma11, tau1->x());
_bf->addTerm((1.0 / _mu) * sigma12, tau1->y());
_bf->addTerm((1.0 / _mu) * sigma21, tau2->x());
_bf->addTerm((1.0 / _mu) * sigma22, tau2->y());
_bf->addTerm(u1, tau1->div());
_bf->addTerm(u2, tau2->div());
_bf->addTerm(-u1hat, tau1 * n_x);
_bf->addTerm(-u2hat, tau2 * n_x);
// momentum equation
if (!steady)
{
_bf->addTerm(-u1, v1->dt());
_bf->addTerm(-u2, v2->dt());
}
_bf->addTerm(-u1_prev*u1, v1->dx());
_bf->addTerm(-u1_prev*u1, v1->dx());
_bf->addTerm(-u2_prev*u1, v1->dy());
_bf->addTerm(-u1_prev*u2, v1->dy());
_bf->addTerm(-u2_prev*u1, v2->dx());
_bf->addTerm(-u1_prev*u2, v2->dx());
_bf->addTerm(-u2_prev*u2, v2->dy());
_bf->addTerm(-u2_prev*u2, v2->dy());
_bf->addTerm(sigma11, v1->dx());
_bf->addTerm(sigma12, v1->dy());
_bf->addTerm(sigma21, v2->dx());
_bf->addTerm(sigma22, v2->dy());
_bf->addTerm(-p, v1->dx());
_bf->addTerm(-p, v2->dy());
_bf->addTerm(tm1hat, v1);
_bf->addTerm(tm2hat, v2);
// _bf->addTerm(2*u1_prev*u1hat*n_x->x(), v1);
// _bf->addTerm((u2_prev*u1hat+u1_prev*u2hat)*n_x->y(), v1);
// _bf->addTerm((u2_prev*u1hat+u1_prev*u2hat)*n_x->x(), v2);
// _bf->addTerm(2*u2_prev*u2hat*n_x->y(), v2);
// continuity equation
_bf->addTerm(-u1, q->dx());
_bf->addTerm(-u2, q->dy());
// _bf->addTerm(u1hat, q->times_normal_x());
// _bf->addTerm(u2hat, q->times_normal_y());
_bf->addTerm(u1hat*n_x->x(), q);
_bf->addTerm(u2hat*n_x->y(), q);
}
// Add residual to RHS
_rhs = RHS::rhs();
// stress equation
_rhs->addTerm( -u1_prev * tau1->div() );
_rhs->addTerm( -u2_prev * tau2->div() );
// momentum equation
if (!steady)
{
_rhs->addTerm( u1_prev * v1->dt());
_rhs->addTerm( u2_prev * v2->dt());
}
_rhs->addTerm( u1_prev * u1_prev*v1->dx() );
_rhs->addTerm( u1_prev * u2_prev*v1->dy() );
_rhs->addTerm( u2_prev * u1_prev*v2->dx() );
_rhs->addTerm( u2_prev * u2_prev*v2->dy() );
// _rhs->addTerm( -u1_prev*u1_prev*n_x->x() * v1 );
// _rhs->addTerm( -u2_prev*u1_prev*n_x->y() * v1 );
// _rhs->addTerm( -u2_prev*u1_prev*n_x->x() * v2 );
// _rhs->addTerm( -u2_prev*u2_prev*n_x->y() * v2 );
// continuity equation
_rhs->addTerm( u1_prev*q->dx());
_rhs->addTerm( u2_prev*q->dy());
_ips["Graph"] = _bf->graphNorm();
_ips["CoupledRobust"] = Teuchos::rcp(new IP);
// _ips["CoupledRobust"]->addTerm(_beta*v->grad());
_ips["CoupledRobust"]->addTerm(u_prev*v1->grad());
_ips["CoupledRobust"]->addTerm(u_prev*v2->grad());
_ips["CoupledRobust"]->addTerm(u1_prev*v1->dx() + u2_prev*v2->dx());
_ips["CoupledRobust"]->addTerm(u1_prev*v1->dy() + u2_prev*v2->dy());
// _ips["CoupledRobust"]->addTerm(Function::min(one/Function::h(),Function::constant(1./sqrt(_mu)))*tau);
_ips["CoupledRobust"]->addTerm(Function::min(one/Function::h(),Function::constant(1./sqrt(_mu)))*tau1);
_ips["CoupledRobust"]->addTerm(Function::min(one/Function::h(),Function::constant(1./sqrt(_mu)))*tau2);
// _ips["CoupledRobust"]->addTerm(sqrt(_mu)*v->grad());
_ips["CoupledRobust"]->addTerm(sqrt(_mu)*v1->grad());
_ips["CoupledRobust"]->addTerm(sqrt(_mu)*v2->grad());
// _ips["CoupledRobust"]->addTerm(Function::min(sqrt(_mu)*one/Function::h(),one)*v);
_ips["CoupledRobust"]->addTerm(Function::min(sqrt(_mu)*one/Function::h(),one)*v1);
_ips["CoupledRobust"]->addTerm(Function::min(sqrt(_mu)*one/Function::h(),one)*v2);
// _ips["CoupledRobust"]->addTerm(tau->div() - v->dt() - beta*v->grad());
if (!steady)
{
_ips["CoupledRobust"]->addTerm(tau1->div() -v1->dt() - u_prev*v1->grad() - u1_prev*v1->dx() - u2_prev*v2->dx());
_ips["CoupledRobust"]->addTerm(tau2->div() -v2->dt() - u_prev*v2->grad() - u1_prev*v1->dy() - u2_prev*v2->dy());
}
else
{
_ips["CoupledRobust"]->addTerm(tau1->div() - u_prev*v1->grad() - u1_prev*v1->dx() - u2_prev*v2->dx());
_ips["CoupledRobust"]->addTerm(tau2->div() - u_prev*v2->grad() - u1_prev*v1->dy() - u2_prev*v2->dy());
}
// _ips["CoupledRobust"]->addTerm(v1->dx() + v2->dy());
_ips["CoupledRobust"]->addTerm(q->grad());
_ips["CoupledRobust"]->addTerm(q);
_ips["NSDecoupledH1"] = Teuchos::rcp(new IP);
// _ips["NSDecoupledH1"]->addTerm(one/Function::h()*tau);
_ips["NSDecoupledH1"]->addTerm(one/Function::h()*tau1);
_ips["NSDecoupledH1"]->addTerm(one/Function::h()*tau2);
// _ips["NSDecoupledH1"]->addTerm(v->grad());
_ips["NSDecoupledH1"]->addTerm(v1->grad());
_ips["NSDecoupledH1"]->addTerm(v2->grad());
// _ips["NSDecoupledH1"]->addTerm(_beta*v->grad()+v->dt());
if (!steady)
{
_ips["NSDecoupledH1"]->addTerm(v1->dt() + u_prev*v1->grad() + u1_prev*v1->dx() + u2_prev*v2->dx());
_ips["NSDecoupledH1"]->addTerm(v2->dt() + u_prev*v2->grad() + u1_prev*v1->dy() + u2_prev*v2->dy());
}
else
{
_ips["NSDecoupledH1"]->addTerm(u_prev*v1->grad() + u1_prev*v1->dx() + u2_prev*v2->dx());
_ips["NSDecoupledH1"]->addTerm(u_prev*v2->grad() + u1_prev*v1->dy() + u2_prev*v2->dy());
}
// _ips["NSDecoupledH1"]->addTerm(tau->div());
_ips["NSDecoupledH1"]->addTerm(tau1->div());
_ips["NSDecoupledH1"]->addTerm(tau2->div());
// _ips["NSDecoupledH1"]->addTerm(v);
_ips["NSDecoupledH1"]->addTerm(v1);
_ips["NSDecoupledH1"]->addTerm(v2);
// _ips["CoupledRobust"]->addTerm(v1->dx() + v2->dy());
_ips["NSDecoupledH1"]->addTerm(q->grad());
_ips["NSDecoupledH1"]->addTerm(q);
IPPtr ip = _ips.at(norm);
if (problem->forcingFunction != Teuchos::null)
{
_rhs->addTerm(problem->forcingFunction->x() * v1);
_rhs->addTerm(problem->forcingFunction->y() * v2);
}
_solutionUpdate->setRHS(_rhs);
_solutionUpdate->setIP(ip);
// impose zero mean constraint
// if (problem->imposeZeroMeanPressure())
// _solutionUpdate->bc()->shouldImposeZeroMeanConstraint(p->ID());
// _solutionUpdate->bc()->singlePointBC(p->ID());
_mesh->registerSolution(_solutionBackground);
_mesh->registerSolution(_solutionUpdate);
LinearTermPtr residual = _rhs->linearTerm() - _bf->testFunctional(_solutionUpdate, false); // false: don't exclude boundary terms
// double energyThreshold = 0.2;
double energyThreshold = 0;
_refinementStrategy = Teuchos::rcp( new RefinementStrategy( _mesh, residual, ip, energyThreshold ) );
}
bool checkConstraints( MeshTopologyPtr mesh, unsigned entityDim, map<unsigned,pair<IndexType,unsigned> > &expectedConstraints, string meshName = "mesh")
{
bool success = true;
// check constraints for entities belonging to active cells
set<IndexType> myActiveCells = mesh->getMyActiveCellIndices();
for (IndexType cellIndex : myActiveCells)
{
CellPtr cell = mesh->getCell(cellIndex);
vector<unsigned> entitiesForCell = cell->getEntityIndices(entityDim);
for (vector<unsigned>::iterator entityIt = entitiesForCell.begin(); entityIt != entitiesForCell.end(); entityIt++)
{
unsigned entityIndex = *entityIt;
pair<IndexType,unsigned> constrainingEntity = mesh->getConstrainingEntity(entityDim, entityIndex);
unsigned constrainingEntityIndex = constrainingEntity.first;
unsigned constrainingEntityDim = constrainingEntity.second;
if ((constrainingEntityIndex==entityIndex) && (constrainingEntityDim == entityDim))
{
// then we should expect not to have an entry in expectedConstraints:
if (expectedConstraints.find(entityIndex) != expectedConstraints.end())
{
cout << "Expected entity constraint is not imposed in " << meshName << ".\n";
cout << "Expected " << typeString(entityDim) << " " << entityIndex << " to be constrained by ";
cout << typeString(expectedConstraints[entityIndex].second) << " " << expectedConstraints[entityIndex].first << endl;
cout << typeString(entityDim) << " " << entityIndex << " vertices:\n";
mesh->printEntityVertices(entityDim, entityIndex);
cout << typeString(expectedConstraints[entityIndex].second) << " " << expectedConstraints[entityIndex].first << " vertices:\n";
mesh->printEntityVertices(entityDim, expectedConstraints[entityIndex].first);
success = false;
}
}
else
{
if (expectedConstraints.find(entityIndex) == expectedConstraints.end())
{
cout << "Unexpected entity constraint is imposed in " << meshName << ".\n";
string entityType;
if (entityDim==0)
{
entityType = "Vertex ";
}
else if (entityDim==1)
{
entityType = "Edge ";
}
else if (entityDim==2)
{
entityType = "Face ";
}
else if (entityDim==3)
{
entityType = "Volume ";
}
string constrainingEntityType;
if (constrainingEntityDim==0)
{
constrainingEntityType = "Vertex ";
}
else if (constrainingEntityDim==1)
{
constrainingEntityType = "Edge ";
}
else if (constrainingEntityDim==2)
{
constrainingEntityType = "Face ";
}
else if (constrainingEntityDim==3)
{
constrainingEntityType = "Volume ";
}
cout << entityType << entityIndex << " unexpectedly constrained by " << constrainingEntityType << constrainingEntityIndex << endl;
cout << entityType << entityIndex << " vertices:\n";
mesh->printEntityVertices(entityDim, entityIndex);
cout << constrainingEntityType << constrainingEntityIndex << " vertices:\n";
mesh->printEntityVertices(constrainingEntityDim, constrainingEntityIndex);
success = false;
}
else
{
unsigned expectedConstrainingEntity = expectedConstraints[entityIndex].first;
if (expectedConstrainingEntity != constrainingEntityIndex)
{
cout << "The constraining entity is not the expected one in " << meshName << ".\n";
cout << "Expected " << typeString(entityDim) << " " << entityIndex << " to be constrained by ";
cout << typeString(expectedConstraints[entityIndex].second) << " " << expectedConstrainingEntity;
cout << "; was constrained by " << constrainingEntityIndex << endl;
cout << typeString(entityDim) << " " << entityIndex << " vertices:\n";
mesh->printEntityVertices(entityDim, entityIndex);
cout << typeString(expectedConstraints[entityIndex].second) << " " << expectedConstrainingEntity << " vertices:\n";
mesh->printEntityVertices(entityDim, expectedConstrainingEntity);
cout << typeString(constrainingEntityDim) << " " << constrainingEntityIndex << " vertices:\n";
mesh->printEntityVertices(constrainingEntityDim, constrainingEntityIndex);
success = false;
}
}
}
}
}
return success;
}
