int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); // initialize MPI
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
int numElements = 3;
double xLeft = 0.0, xRight = 1.0;
int polyOrder = 1, delta_k = 1;
cmdp.setOption("numElements", &numElements );
cmdp.setOption("polyOrder", &polyOrder );
cmdp.setOption("delta_k", &delta_k );
cmdp.setOption("xLeft", &xLeft );
cmdp.setOption("xRight", &xRight );
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
int spaceDim = 1;
bool conformingTraces = true; // conformingTraces argument has no effect in 1D
PoissonFormulation poissonForm(spaceDim, conformingTraces);
MeshPtr mesh = MeshFactory::intervalMesh(poissonForm.bf(), xLeft, xRight, numElements, polyOrder + 1, delta_k); // 1D equispaced
RHSPtr rhs = RHS::rhs(); // zero RHS
IPPtr ip = poissonForm.bf()->graphNorm();
BCPtr bc = BC::bc();
bc->addDirichlet(poissonForm.phi_hat(), SpatialFilter::allSpace(), Function::zero());
SolutionPtr solution = Solution::solution(poissonForm.bf(), mesh, bc, rhs, ip);
solution->solve();
GDAMinimumRule* minRule = dynamic_cast<GDAMinimumRule*>(mesh->globalDofAssignment().get());
// minRule->printGlobalDofInfo();
Teuchos::RCP<Epetra_CrsMatrix> A = solution->getStiffnessMatrix();
EpetraExt::RowMatrixToMatrixMarketFile("A.dat",*A, NULL, NULL, false);
HDF5Exporter exporter(mesh);
return 0;
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
int rank=mpiSession.getRank();
int numProcs=mpiSession.getNProc();
#else
int rank = 0;
int numProcs = 1;
#endif
bool useCompliantGraphNorm = false;
bool enforceOneIrregularity = true;
bool writeStiffnessMatrices = false;
bool writeWorstCaseGramMatrices = false;
int numRefs = 10;
// problem parameters:
double eps = 1e-8;
vector<double> beta_const;
beta_const.push_back(2.0);
beta_const.push_back(1.0);
int k = 2, delta_k = 2;
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("numRefs",&numRefs,"number of refinements");
cmdp.setOption("eps", &eps, "epsilon");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
int H1Order = k + 1;
if (rank==0) {
string normChoice = useCompliantGraphNorm ? "unit-compliant graph norm" : "standard graph norm";
cout << "Using " << normChoice << "." << endl;
cout << "eps = " << eps << endl;
cout << "numRefs = " << numRefs << endl;
cout << "p = " << k << endl;
}
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory.fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u;
if (useCompliantGraphNorm) {
u = varFactory.fieldVar("u",HGRAD);
} else {
u = varFactory.fieldVar("u");
}
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(-uhat, tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( beta_const * u, - v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// mathematician's norm
IPPtr mathIP = Teuchos::rcp(new IP());
mathIP->addTerm(tau);
mathIP->addTerm(tau->div());
mathIP->addTerm(v);
mathIP->addTerm(v->grad());
// quasi-optimal norm
IPPtr qoptIP = Teuchos::rcp(new IP);
if (!useCompliantGraphNorm) {
qoptIP->addTerm( tau / eps + v->grad() );
qoptIP->addTerm( beta_const * v->grad() - tau->div() );
qoptIP->addTerm( v );
} else {
FunctionPtr h = Teuchos::rcp( new hFunction );
// here, we're aiming at optimality in 1/h^2 |u|^2 + 1/eps^2 |sigma|^2
qoptIP->addTerm( tau + eps * v->grad() );
qoptIP->addTerm( h * beta_const * v->grad() - tau->div() );
qoptIP->addTerm(v);
qoptIP->addTerm(tau);
}
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new OutflowSquareBoundary );
FunctionPtr u0 = Teuchos::rcp( new U0 );
bc->addDirichlet(uhat, outflowBoundary, u0);
bc->addDirichlet(uhat, inflowBoundary, u0);
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp(new PenaltyConstraints);
// pc->addConstraint(uhat==u0,inflowBoundary);
//////////////////// BUILD MESH ///////////////////////
// create a new mesh on a single-cell, unit square domain
Teuchos::RCP<Mesh> mesh = MeshFactory::quadMeshMinRule(confusionBF, H1Order, delta_k);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, qoptIP) );
// solution->setFilter(pc);
double energyThreshold = 0.2; // for mesh refinements
bool useRieszRepBasedRefStrategy = true;
if (rank==0) {
if (useRieszRepBasedRefStrategy) {
cout << "using RieszRep-based refinement strategy.\n";
} else {
cout << "using solution-based refinement strategy.\n";
}
}
Teuchos::RCP<RefinementStrategy> refinementStrategy;
if (!useRieszRepBasedRefStrategy) {
refinementStrategy = Teuchos::rcp( new RefinementStrategy( solution, energyThreshold ) );
} else {
LinearTermPtr residual = confusionBF->testFunctional(solution) - rhs->linearTerm();
refinementStrategy = Teuchos::rcp( new RefinementStrategy( mesh, residual, qoptIP, energyThreshold ) );
}
refinementStrategy->setReportPerCellErrors(true);
refinementStrategy->setEnforceOneIrregularity(enforceOneIrregularity);
for (int refIndex=0; refIndex<numRefs; refIndex++){
if (writeStiffnessMatrices) {
string stiffnessFile = fileNameForRefinement("confusion_stiffness", refIndex);
solution->setWriteMatrixToFile(true, stiffnessFile);
}
solution->solve();
if (writeWorstCaseGramMatrices) {
string gramFile = fileNameForRefinement("confusion_gram", refIndex);
bool jacobiScaling = true;
double condNum = MeshUtilities::computeMaxLocalConditionNumber(qoptIP, mesh, jacobiScaling, gramFile);
if (rank==0) {
cout << "estimated worst-case Gram matrix condition number: " << condNum << endl;
cout << "putative worst-case Gram matrix written to file " << gramFile << endl;
}
}
if (refIndex == numRefs-1) { // write out second-to-last mesh
if (rank==0)
GnuPlotUtil::writeComputationalMeshSkeleton("confusionMesh", mesh, true);
}
refinementStrategy->refine(rank==0); // print to console on rank 0
}
if (writeStiffnessMatrices) {
string stiffnessFile = fileNameForRefinement("confusion_stiffness", numRefs);
solution->setWriteMatrixToFile(true, stiffnessFile);
}
if (writeWorstCaseGramMatrices) {
string gramFile = fileNameForRefinement("confusion_gram", numRefs);
bool jacobiScaling = true;
double condNum = MeshUtilities::computeMaxLocalConditionNumber(qoptIP, mesh, jacobiScaling, gramFile);
if (rank==0) {
cout << "estimated worst-case Gram matrix condition number: " << condNum << endl;
cout << "putative worst-case Gram matrix written to file " << gramFile << endl;
}
}
// one more solve on the final refined mesh:
solution->solve();
#ifdef HAVE_EPETRAEXT_HDF5
ostringstream dir_name;
dir_name << "confusion_eps" << eps;
HDF5Exporter exporter(mesh,dir_name.str());
exporter.exportSolution(solution, varFactory, 0);
if (rank==0) cout << "wrote solution to " << dir_name.str() << endl;
#endif
return 0;
}
bool VectorizedBasisTestSuite::testPoisson()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr sigma_n = varFactory->fluxVar("\\widehat{\\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma = varFactory->fieldVar("\\sigma", VECTOR_L2);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( -sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr f = Function::constant(1.0);
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr boundary = SpatialFilter::allSpace();
FunctionPtr zero = Function::zero();
bc->addDirichlet(uhat, boundary, zero);
//////////////////// BUILD MESH ///////////////////////
int H1Order = 3, pToAdd = 2;
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = 0.0; // x1
meshBoundary(0,1) = 0.0; // y1
meshBoundary(1,0) = 1.0;
meshBoundary(1,1) = 0.0;
meshBoundary(2,0) = 1.0;
meshBoundary(2,1) = 1.0;
meshBoundary(3,0) = 0.0;
meshBoundary(3,1) = 1.0;
int horizontalCells = 1, verticalCells = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshFactory::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+pToAdd, false);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
#ifdef USE_VTK
VTKExporter exporter(solution, mesh, varFactory);
#endif
for (int refIndex=0; refIndex<=4; refIndex++)
{
solution->solve(false);
#ifdef USE_VTK
// output commented out because it's not properly part of the test.
// stringstream outfile;
// outfile << "test_" << refIndex;
// exporter.exportSolution(outfile.str());
#endif
if (refIndex < 4)
refinementStrategy.refine(false); // don't print to console
}
return success;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
int rank=mpiSession.getRank();
int numProcs=mpiSession.getNProc();
#else
int rank = 0;
int numProcs = 1;
#endif
int polyOrder = 2;
// define our manufactured solution or problem bilinear form:
double epsilon = 1e-3;
bool useTriangles = false;
int pToAdd = 2;
int nCells = 2;
if ( argc > 1)
{
nCells = atoi(argv[1]);
if (rank==0)
{
cout << "numCells = " << nCells << endl;
}
}
int numSteps = 20;
if ( argc > 2)
{
numSteps = atoi(argv[2]);
if (rank==0)
{
cout << "num NR steps = " << numSteps << endl;
}
}
int useHessian = 0; // defaults to "not use"
if ( argc > 3)
{
useHessian = atoi(argv[3]);
if (rank==0)
{
cout << "useHessian = " << useHessian << endl;
}
}
int thresh = numSteps; // threshhold for when to apply linesearch/hessian
if ( argc > 4)
{
thresh = atoi(argv[4]);
if (rank==0)
{
cout << "thresh = " << thresh << endl;
}
}
int H1Order = polyOrder + 1;
double energyThreshold = 0.2; // for mesh refinements
double nonlinearStepSize = 0.5;
double nonlinearRelativeEnergyTolerance = 1e-8; // used to determine convergence of the nonlinear solution
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// new-style bilinear form definition
VarFactory varFactory;
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_hat = varFactory.fluxVar("\\widehat{\\beta_n u - \\sigma_n}");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
VarPtr tau = varFactory.testVar("\\tau",HDIV);
VarPtr v = varFactory.testVar("v",HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) ); // initialize bilinear form
////////////////////////////////////////////////////////////////////
// CREATE MESH
////////////////////////////////////////////////////////////////////
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells, bf, H1Order, H1Order+pToAdd);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC,
nullRHS, nullIP) );
vector<double> e1(2); // (1,0)
e1[0] = 1;
vector<double> e2(2); // (0,1)
e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// tau parts:
// 1/eps (sigma, tau)_K + (u, div tau)_K - (u_hat, tau_n)_dK
bf->addTerm(sigma1 / epsilon, tau->x());
bf->addTerm(sigma2 / epsilon, tau->y());
bf->addTerm(u, tau->div());
bf->addTerm( - uhat, tau->dot_normal() );
// v:
// (sigma, grad v)_K - (sigma_hat_n, v)_dK - (u, beta dot grad v) + (u_hat * n dot beta, v)_dK
bf->addTerm( sigma1, v->dx() );
bf->addTerm( sigma2, v->dy() );
bf->addTerm( -u, beta * v->grad());
bf->addTerm( beta_n_u_minus_sigma_hat, v);
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr u0 = Teuchos::rcp( new U0 );
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u0;
functionMap[sigma1->ID()] = zero;
functionMap[sigma2->ID()] = zero;
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
// function to scale the squared guy by epsilon/h
FunctionPtr epsilonOverHScaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm( epsilonOverHScaling * (1.0/sqrt(epsilon))* tau);
ip->addTerm( tau->div());
// ip->addTerm( epsilonOverHScaling * v );
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
ip->addTerm(v->grad());
// ip->addTerm( beta * v->grad() );
////////////////////////////////////////////////////////////////////
// DEFINE RHS
////////////////////////////////////////////////////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr u_prev_squared_div2 = 0.5 * u_prev * u_prev;
rhs->addTerm((e1 * u_prev_squared_div2 + e2 * u_prev) * v->grad() - u_prev * tau->div());
////////////////////////////////////////////////////////////////////
// DEFINE DIRICHLET BC
////////////////////////////////////////////////////////////////////
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new TopBoundary);
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(outflowBoundary) );
BCPtr inflowBC = BC::bc();
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
inflowBC->addDirichlet(beta_n_u_minus_sigma_hat,inflowBoundary,
( e1 * u0_squared_div_2 + e2 * u0) * n );
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution);
////////////////////////////////////////////////////////////////////
// WARNING: UNFINISHED HESSIAN BIT
////////////////////////////////////////////////////////////////////
VarFactory hessianVars = varFactory.getBubnovFactory(VarFactory::BUBNOV_TRIAL);
VarPtr du = hessianVars.test(u->ID());
BFPtr hessianBF = Teuchos::rcp( new BF(hessianVars) ); // initialize bilinear form
// FunctionPtr e_v = Function::constant(1.0); // dummy error rep function for now - should do nothing
FunctionPtr u_current = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr sig1_prev = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma1) );
FunctionPtr sig2_prev = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma2) );
FunctionPtr sig_prev = (e1*sig1_prev + e2*sig2_prev);
FunctionPtr fnhat = Teuchos::rcp(new PreviousSolutionFunction(solution,beta_n_u_minus_sigma_hat));
FunctionPtr uhat_prev = Teuchos::rcp(new PreviousSolutionFunction(solution,uhat));
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
residual->addTerm(fnhat*v - (e1 * (u_prev_squared_div2 - sig1_prev) + e2 * (u_prev - sig2_prev)) * v->grad());
residual->addTerm((1/epsilon)*sig_prev * tau + u_prev * tau->div() - uhat_prev*tau->dot_normal());
LinearTermPtr Bdu = Teuchos::rcp(new LinearTerm);// residual
Bdu->addTerm( u_current*tau->div() - u_current*(beta*v->grad()));
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
Teuchos::RCP<RieszRep> duRiesz = Teuchos::rcp(new RieszRep(mesh, ip, Bdu));
riesz->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,riesz));
e_v->writeValuesToMATLABFile(mesh, "e_v.m");
FunctionPtr posErrPart = Teuchos::rcp(new PositivePart(e_v->dx()));
hessianBF->addTerm(e_v->dx()*u,du);
// hessianBF->addTerm(posErrPart*u,du);
Teuchos::RCP<HessianFilter> hessianFilter = Teuchos::rcp(new HessianFilter(hessianBF));
if (useHessian)
{
solution->setWriteMatrixToFile(true,"hessianStiffness.dat");
}
else
{
solution->setWriteMatrixToFile(true,"stiffness.dat");
}
Teuchos::RCP< LineSearchStep > LS_Step = Teuchos::rcp(new LineSearchStep(riesz));
ofstream out;
out.open("Burgers.txt");
double NL_residual = 9e99;
for (int i = 0; i<numSteps; i++)
{
solution->solve(false); // do one solve to initialize things...
double stepLength = 1.0;
stepLength = LS_Step->stepSize(backgroundFlow,solution, NL_residual);
if (useHessian)
{
solution->setFilter(hessianFilter);
}
backgroundFlow->addSolution(solution,stepLength);
NL_residual = LS_Step->getNLResidual();
if (rank==0)
{
cout << "NL residual after adding = " << NL_residual << " with step size " << stepLength << endl;
out << NL_residual << endl; // saves initial NL error
}
}
out.close();
////////////////////////////////////////////////////////////////////
// DEFINE REFINEMENT STRATEGY
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RefinementStrategy> refinementStrategy;
refinementStrategy = Teuchos::rcp(new RefinementStrategy(solution,energyThreshold));
int numRefs = 0;
Teuchos::RCP<NonlinearStepSize> stepSize = Teuchos::rcp(new NonlinearStepSize(nonlinearStepSize));
Teuchos::RCP<NonlinearSolveStrategy> solveStrategy;
solveStrategy = Teuchos::rcp( new NonlinearSolveStrategy(backgroundFlow, solution, stepSize,
nonlinearRelativeEnergyTolerance));
////////////////////////////////////////////////////////////////////
// SOLVE
////////////////////////////////////////////////////////////////////
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
solveStrategy->solve(rank==0); // print to console on rank 0
refinementStrategy->refine(rank==0); // print to console on rank 0
}
// solveStrategy->solve(rank==0);
if (rank==0)
{
backgroundFlow->writeToVTK("Burgers.vtu",min(H1Order+1,4));
solution->writeFluxesToFile(uhat->ID(), "burgers.dat");
cout << "wrote solution files" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
#endif
{
// 1D tests
CellTopoPtr line_2 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >() ) );
// let's draw a line
vector<double> v0 = makeVertex(0);
vector<double> v1 = makeVertex(1);
vector<double> v2 = makeVertex(2);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vector<unsigned> line1VertexList;
vector<unsigned> line2VertexList;
line1VertexList.push_back(0);
line1VertexList.push_back(1);
line2VertexList.push_back(1);
line2VertexList.push_back(2);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(line1VertexList);
elementVertices.push_back(line2VertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(line_2);
cellTopos.push_back(line_2);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x = Function::xn(1);
FunctionPtr function = x;
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(function);
vector<string> functionNames;
functionNames.push_back("function1");
functionNames.push_back("function2");
{
XDMFExporter exporter(meshTopology, "function1", false);
exporter.exportFunction(function, "function1");
}
{
XDMFExporter exporter(meshTopology, "boundary1", false);
exporter.exportFunction(fbdr, "boundary1");
}
{
XDMFExporter exporter(meshTopology, "functions1", false);
exporter.exportFunction(functions, functionNames);
}
}
{
// 2D tests
CellTopoPtr quad_4 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ) );
CellTopoPtr tri_3 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() ) );
// let's draw a little house
vector<double> v0 = makeVertex(-1,0);
vector<double> v1 = makeVertex(1,0);
vector<double> v2 = makeVertex(1,2);
vector<double> v3 = makeVertex(-1,2);
vector<double> v4 = makeVertex(0.0,3);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
vertices.push_back(v4);
vector<unsigned> quadVertexList;
quadVertexList.push_back(0);
quadVertexList.push_back(1);
quadVertexList.push_back(2);
quadVertexList.push_back(3);
vector<unsigned> triVertexList;
triVertexList.push_back(3);
triVertexList.push_back(2);
triVertexList.push_back(4);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(quadVertexList);
elementVertices.push_back(triVertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(quad_4);
cellTopos.push_back(tri_3);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x2 = Function::xn(2);
FunctionPtr y2 = Function::yn(2);
FunctionPtr function = x2 + y2;
FunctionPtr vect = Function::vectorize(x2, y2);
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(vect);
vector<string> functionNames;
functionNames.push_back("function");
functionNames.push_back("vect");
vector<FunctionPtr> bdrfunctions;
bdrfunctions.push_back(fbdr);
bdrfunctions.push_back(fbdr);
vector<string> bdrfunctionNames;
bdrfunctionNames.push_back("bdr1");
bdrfunctionNames.push_back("bdr2");
map<int, int> cellIDToNum1DPts;
cellIDToNum1DPts[1] = 4;
{
XDMFExporter exporter(meshTopology, "Grid2D", false);
// exporter.exportFunction(function, "function2", 0, 10);
// exporter.exportFunction(vect, "vect2", 1, 10, cellIDToNum1DPts);
// exporter.exportFunction(fbdr, "boundary2", 0);
exporter.exportFunction(functions, functionNames, 1, 10);
}
{
XDMFExporter exporter(meshTopology, "BdrGrid2D", false);
// exporter.exportFunction(function, "function2", 0, 10);
// exporter.exportFunction(vect, "vect2", 1, 10, cellIDToNum1DPts);
// exporter.exportFunction(fbdr, "boundary2", 0);
exporter.exportFunction(bdrfunctions, bdrfunctionNames, 1, 10);
}
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau = varFactory.testVar("tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory.traceVar("uhat");
VarPtr fhat = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma = varFactory.fieldVar("sigma", VECTOR_L2);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( fhat, v);
//////////////////// BUILD MESH ///////////////////////
int H1Order = 4, pToAdd = 2;
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh (meshTopology, bf, H1Order, pToAdd) );
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
// Teuchos::RCP<RHS> rhs = Teuchos::rcp( new RHS );
FunctionPtr one = Function::constant(1.0);
rhs->addTerm( one * v );
//////////////////// CREATE BCs ///////////////////////
// Teuchos::RCP<BC> bc = Teuchos::rcp( new BCEasy );
BCPtr bc = BC::bc();
FunctionPtr zero = Function::zero();
SpatialFilterPtr entireBoundary = Teuchos::rcp( new EntireBoundary );
bc->addDirichlet(uhat, entireBoundary, zero);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
RefinementStrategy refinementStrategy( solution, 0.2);
// Output solution
FunctionPtr uSoln = Function::solution(u, solution);
FunctionPtr sigmaSoln = Function::solution(sigma, solution);
FunctionPtr uhatSoln = Function::solution(uhat, solution);
FunctionPtr fhatSoln = Function::solution(fhat, solution);
{
XDMFExporter exporter(meshTopology, "Poisson", false);
exporter.exportFunction(uSoln, "u", 0, 4);
exporter.exportFunction(uSoln, "u", 1, 5);
exporter.exportFunction(uhatSoln, "uhat", 0, 4);
exporter.exportFunction(uhatSoln, "uhat", 1, 5);
// exporter.exportFunction(fhatSoln, "fhat", 0, 4);
// exporter.exportFunction(fhatSoln, "fhat", 1, 5);
}
{
XDMFExporter exporter(meshTopology, "PoissonSolution", false);
exporter.exportSolution(solution, mesh, varFactory, 0, 2, cellIDToSubdivision(mesh, 10));
refinementStrategy.refine(true);
solution->solve(false);
exporter.exportSolution(solution, mesh, varFactory, 1, 2, cellIDToSubdivision(mesh, 10));
}
// exporter.exportFunction(sigmaSoln, "Poisson-s", "sigma", 0, 5);
// exporter.exportFunction(uhatSoln, "Poisson-uhat", "uhat", 1, 6);
}
{
// 3D tests
CellTopoPtr hex = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() ));
// let's draw a little box
vector<double> v0 = makeVertex(0,0,0);
vector<double> v1 = makeVertex(1,0,0);
vector<double> v2 = makeVertex(1,1,0);
vector<double> v3 = makeVertex(0,1,0);
vector<double> v4 = makeVertex(0,0,1);
vector<double> v5 = makeVertex(1,0,1);
vector<double> v6 = makeVertex(1,1,1);
vector<double> v7 = makeVertex(0,1,1);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
vertices.push_back(v4);
vertices.push_back(v5);
vertices.push_back(v6);
vertices.push_back(v7);
vector<unsigned> hexVertexList;
hexVertexList.push_back(0);
hexVertexList.push_back(1);
hexVertexList.push_back(2);
hexVertexList.push_back(3);
hexVertexList.push_back(4);
hexVertexList.push_back(5);
hexVertexList.push_back(6);
hexVertexList.push_back(7);
// vector<unsigned> triVertexList;
// triVertexList.push_back(2);
// triVertexList.push_back(3);
// triVertexList.push_back(4);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(hexVertexList);
// elementVertices.push_back(triVertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(hex);
// cellTopos.push_back(tri_3);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr z = Function::zn(1);
FunctionPtr function = x + y + z;
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
FunctionPtr vect = Function::vectorize(x, y, z);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(vect);
vector<string> functionNames;
functionNames.push_back("function");
functionNames.push_back("vect");
{
XDMFExporter exporter(meshTopology, "function3", false);
exporter.exportFunction(function, "function3");
}
{
XDMFExporter exporter(meshTopology, "boundary3", false);
exporter.exportFunction(fbdr, "boundary3");
}
{
XDMFExporter exporter(meshTopology, "vect3", false);
exporter.exportFunction(vect, "vect3");
}
{
XDMFExporter exporter(meshTopology, "functions3", false);
exporter.exportFunction(functions, functionNames);
}
}
}
int main(int argc, char *argv[])
{
#ifdef ENABLE_INTEL_FLOATING_POINT_EXCEPTIONS
cout << "NOTE: enabling floating point exceptions for divide by zero.\n";
_MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~_MM_MASK_INVALID);
#endif
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int rank = Teuchos::GlobalMPISession::getRank();
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
const static double PI = 3.141592653589793238462;
bool useCondensedSolve = true; // condensed solve not yet compatible with minimum rule meshes
int k = 2; // poly order for u in every direction, including temporal
int numCells = 32; // in x, y
int numTimeCells = 1;
int numTimeSlabs = -1;
int numFrames = 201;
int delta_k = 3; // test space enrichment: should be 3 for 3D
int maxRefinements = 0; // maximum # of refinements on each time slab
bool useMumpsIfAvailable = true;
bool useConstantConvection = false;
double refinementTolerance = 0.1;
int checkPointFrequency = 50; // output solution and mesh every 50 time slabs
int previousSolutionTimeSlabNumber = -1;
string previousSolutionFile = "";
string previousMeshFile = "";
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("numCells",&numCells,"number of cells in x and y directions");
cmdp.setOption("numTimeCells",&numTimeCells,"number of time axis cells");
cmdp.setOption("numTimeSlabs",&numTimeSlabs,"number of time slabs");
cmdp.setOption("numFrames",&numFrames,"number of frames for export");
cmdp.setOption("useConstantConvection", "useVariableConvection", &useConstantConvection);
cmdp.setOption("useCondensedSolve", "useUncondensedSolve", &useCondensedSolve, "use static condensation to reduce the size of the global solve");
cmdp.setOption("useMumps", "useKLU", &useMumpsIfAvailable, "use MUMPS (if available)");
cmdp.setOption("refinementTolerance", &refinementTolerance, "relative error beyond which to stop refining");
cmdp.setOption("maxRefinements", &maxRefinements, "maximum # of refinements on each time slab");
cmdp.setOption("previousSlabNumber", &previousSolutionTimeSlabNumber, "time slab number of previous solution");
cmdp.setOption("previousSolution", &previousSolutionFile, "file with previous solution");
cmdp.setOption("previousMesh", &previousMeshFile, "file with previous mesh");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
int H1Order = k + 1;
VarFactory varFactory;
// traces:
VarPtr qHat = varFactory.fluxVar("\\widehat{q}");
// fields:
VarPtr u = varFactory.fieldVar("u", L2);
// test functions:
VarPtr v = varFactory.testVar("v", HGRAD);
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr c;
if (useConstantConvection)
{
c = Function::vectorize(Function::constant(0.5), Function::constant(0.5), Function::constant(1.0));
}
else
{
c = Function::vectorize(y-0.5, 0.5-x, Function::constant(1.0));
}
FunctionPtr n = Function::normal();
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
bf->addTerm( u, c * v->grad());
bf->addTerm(qHat, v);
double width = 2.0, height = 2.0;
int horizontalCells = numCells, verticalCells = numCells;
int depthCells = numTimeCells;
double x0 = -0.5;
double y0 = -0.5;
double t0 = 0;
double totalTime = 2.0 * PI;
vector<double> frameTimes;
for (int i=0; i<numFrames; i++)
{
frameTimes.push_back((totalTime*i) / (numFrames-1));
}
if (numTimeSlabs==-1)
{
// want the number of grid points in temporal direction to be about 2000. The temporal length is 2 * PI
numTimeSlabs = (int) 2000 / k;
}
double timeLengthPerSlab = totalTime / numTimeSlabs;
if (rank==0)
{
cout << "solving on " << numCells << " x " << numCells << " x " << numTimeCells << " mesh " << "of order " << k << ".\n";
cout << "numTimeSlabs: " << numTimeSlabs << endl;
}
SpatialFilterPtr inflowFilter = Teuchos::rcp( new InflowFilterForClockwisePlanarRotation (x0,x0+width,y0,y0+height,0.5,0.5));
vector<double> dimensions;
dimensions.push_back(width);
dimensions.push_back(height);
dimensions.push_back(timeLengthPerSlab);
vector<int> elementCounts(3);
elementCounts[0] = horizontalCells;
elementCounts[1] = verticalCells;
elementCounts[2] = depthCells;
vector<double> origin(3);
origin[0] = x0;
origin[1] = y0;
origin[2] = t0;
Teuchos::RCP<Solver> solver = Teuchos::rcp( new KluSolver );
#ifdef HAVE_AMESOS_MUMPS
if (useMumpsIfAvailable) solver = Teuchos::rcp( new MumpsSolver );
#endif
// double errorPercentage = 0.5; // for mesh refinements: ask to refine elements that account for 80% of the error in each step
// Teuchos::RCP<RefinementStrategy> refinementStrategy;
// refinementStrategy = Teuchos::rcp( new ErrorPercentageRefinementStrategy( soln, errorPercentage ));
if (maxRefinements != 0)
{
cout << "Warning: maxRefinements is not 0, but the slice exporter implicitly assumes there won't be any refinements.\n";
}
MeshPtr mesh;
MeshPtr prevMesh;
SolutionPtr prevSoln;
mesh = MeshFactory::rectilinearMesh(bf, dimensions, elementCounts, H1Order, delta_k, origin);
if (rank==0) cout << "Initial mesh has " << mesh->getTopology()->activeCellCount() << " active (leaf) cells " << "and " << mesh->globalDofCount() << " degrees of freedom.\n";
FunctionPtr sideParity = Function::sideParity();
int lastFrameOutputted = -1;
SolutionPtr soln;
IPPtr ip;
ip = bf->graphNorm();
FunctionPtr u0 = Teuchos::rcp( new Cone_U0(0.0, 0.25, 0.1, 1.0, false) );
BCPtr bc = BC::bc();
bc->addDirichlet(qHat, inflowFilter, Function::zero()); // zero BCs enforced at the inflow boundary.
bc->addDirichlet(qHat, SpatialFilter::matchingZ(t0), u0);
MeshPtr initialMesh = mesh;
int startingSlabNumber;
if (previousSolutionTimeSlabNumber != -1)
{
startingSlabNumber = previousSolutionTimeSlabNumber + 1;
if (rank==0) cout << "Loading mesh from " << previousMeshFile << endl;
prevMesh = MeshFactory::loadFromHDF5(bf, previousMeshFile);
prevSoln = Solution::solution(mesh, bc, RHS::rhs(), ip); // include BC and IP objects for sake of condensed dof interpreter setup...
prevSoln->setUseCondensedSolve(useCondensedSolve);
if (rank==0) cout << "Loading solution from " << previousSolutionFile << endl;
prevSoln->loadFromHDF5(previousSolutionFile);
double tn = (previousSolutionTimeSlabNumber+1) * timeLengthPerSlab;
origin[2] = tn;
mesh = MeshFactory::rectilinearMesh(bf, dimensions, elementCounts, H1Order, delta_k, origin);
FunctionPtr q_prev = Function::solution(qHat, prevSoln);
FunctionPtr q_transfer = Teuchos::rcp( new MeshTransferFunction(-q_prev, prevMesh, mesh, tn) ); // negate because the normals go in opposite directions
bc = BC::bc();
bc->addDirichlet(qHat, inflowFilter, Function::zero()); // zero BCs enforced at the inflow boundary.
bc->addDirichlet(qHat, SpatialFilter::matchingZ(tn), q_transfer);
double t_slab_final = (previousSolutionTimeSlabNumber+1) * timeLengthPerSlab;
int frameOrdinal = 0;
while (frameTimes[frameOrdinal] < t_slab_final)
{
lastFrameOutputted = frameOrdinal++;
}
}
else
{
startingSlabNumber = 0;
}
#ifdef HAVE_EPETRAEXT_HDF5
ostringstream dir_name;
dir_name << "spacetime_slice_convectingCone_k" << k << "_startSlab" << startingSlabNumber;
map<GlobalIndexType,GlobalIndexType> cellMap;
MeshPtr meshSlice = MeshTools::timeSliceMesh(initialMesh, 0, cellMap, H1Order);
HDF5Exporter sliceExporter(meshSlice,dir_name.str());
#endif
soln = Solution::solution(mesh, bc, RHS::rhs(), ip);
soln->setUseCondensedSolve(useCondensedSolve);
for(int timeSlab = startingSlabNumber; timeSlab<numTimeSlabs; timeSlab++)
{
double energyThreshold = 0.2; // for mesh refinements: ask to refine elements that account for 80% of the error in each step
Teuchos::RCP<RefinementStrategy> refinementStrategy;
refinementStrategy = Teuchos::rcp( new RefinementStrategy( soln, energyThreshold ));
FunctionPtr u_spacetime = Function::solution(u, soln);
double relativeEnergyError;
int refNumber = 0;
// {
// // DEBUGGING: just to try running the time slicing:
// double t_slab_final = (timeStep+1) * timeLengthPerSlab;
// int frameOrdinal = lastFrameOutputted + 1;
// while (frameTimes[frameOrdinal] < t_slab_final) {
// FunctionPtr u_spacetime = Function::solution(u, soln);
// ostringstream dir_name;
// dir_name << "spacetime_slice_convectingCone_k" << k;
// MeshTools::timeSliceExport(dir_name.str(), mesh, u_spacetime, frameTimes[frameOrdinal], "u_slice");
//
// cout << "Exported frame " << frameOrdinal << ", t=" << frameTimes[frameOrdinal] << endl;
// frameOrdinal++;
// }
// }
do
{
soln->solve(solver);
soln->reportTimings();
#ifdef HAVE_EPETRAEXT_HDF5
ostringstream dir_name;
dir_name << "spacetime_convectingCone_k" << k << "_t" << timeSlab;
HDF5Exporter exporter(soln->mesh(),dir_name.str());
exporter.exportSolution(soln, varFactory);
if (rank==0) cout << "Exported HDF solution for time slab to directory " << dir_name.str() << endl;
// string u_name = "u_spacetime";
// exporter.exportFunction(u_spacetime, u_name);
ostringstream file_name;
file_name << dir_name.str();
bool saveSolutionAndMeshForThisSlab = ((timeSlab + 1) % checkPointFrequency == 0); // +1 so that first output is nth, not first
if (saveSolutionAndMeshForThisSlab)
{
dir_name << ".soln";
soln->saveToHDF5(dir_name.str());
if (rank==0) cout << endl << "wrote " << dir_name.str() << endl;
file_name << ".mesh";
soln->mesh()->saveToHDF5(file_name.str());
}
#endif
FunctionPtr u_soln = Function::solution(u, soln);
double solnNorm = u_soln->l2norm(mesh);
double energyError = soln->energyErrorTotal();
relativeEnergyError = energyError / solnNorm;
if (rank==0)
{
cout << "Relative energy error for refinement " << refNumber++ << ": " << relativeEnergyError << endl;
}
if ((relativeEnergyError > refinementTolerance) && (refNumber < maxRefinements))
{
refinementStrategy->refine();
if (rank==0)
{
cout << "After refinement, mesh has " << mesh->getTopology()->activeCellCount() << " active (leaf) cells " << "and " << mesh->globalDofCount() << " degrees of freedom.\n";
}
}
}
while ((relativeEnergyError > refinementTolerance) && (refNumber < maxRefinements));
double t_slab_final = (timeSlab+1) * timeLengthPerSlab;
int frameOrdinal = lastFrameOutputted + 1;
vector<double> timesForSlab;
while (frameTimes[frameOrdinal] < t_slab_final)
{
double t = frameTimes[frameOrdinal];
if (rank==0) cout << "exporting t=" << t << " on slab " << timeSlab << endl;
FunctionPtr sliceFunction = MeshTools::timeSliceFunction(mesh, cellMap, u_spacetime, t);
sliceExporter.exportFunction(sliceFunction, "u_slice", t);
lastFrameOutputted = frameOrdinal++;
}
// set up next mesh/solution:
FunctionPtr q_prev = Function::solution(qHat, soln);
// cout << "Error in setup of q_prev: simple solution doesn't know about the map from the previous time slab to the current one. (TODO: fix this.)\n";
double tn = (timeSlab+1) * timeLengthPerSlab;
origin[2] = tn;
mesh = MeshFactory::rectilinearMesh(bf, dimensions, elementCounts, H1Order, delta_k, origin);
FunctionPtr q_transfer = Teuchos::rcp( new MeshTransferFunction(-q_prev, soln->mesh(), mesh, tn) ); // negate because the normals go in opposite directions
bc = BC::bc();
bc->addDirichlet(qHat, inflowFilter, Function::zero()); // zero BCs enforced at the inflow boundary.
bc->addDirichlet(qHat, SpatialFilter::matchingZ(tn), q_transfer);
// IMPORTANT: now that we are ready to step to next soln, nullify BC. If we do not do this, then we have an RCP chain
// that extends back to the first time slab, effectively a memory leak.
soln->setBC(BC::bc());
soln = Solution::solution(mesh, bc, RHS::rhs(), ip);
soln->setUseCondensedSolve(useCondensedSolve);
}
return 0;
}
void TransientTests::SetUp()
{
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
beta_n_u_hat = varFactory.fluxVar("\\widehat{\\beta \\cdot n }");
u = varFactory.fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// BUILD MESH ///////////////////////
bf = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = 0.0; // x1
meshBoundary(0,1) = -2.0; // y1
meshBoundary(1,0) = 4.0;
meshBoundary(1,1) = -2.0;
meshBoundary(2,0) = 4.0;
meshBoundary(2,1) = 2.0;
meshBoundary(3,0) = 0.0;
meshBoundary(3,1) = 2.0;
int horizontalCells = 4, verticalCells = 4;
// create a pointer to a new mesh:
mesh = MeshFactory::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+pToAdd);
////////////////////////////////////////////////////////////////////
// INITIALIZE FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
prevTimeFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
flowResidual = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
FunctionPtr u_prev_time = Teuchos::rcp( new PreviousSolutionFunction(prevTimeFlow, u) );
//////////////////// DEFINE BILINEAR FORM ///////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr invDt = Teuchos::rcp(new ScalarParamFunction(1.0/dt));
// v terms:
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_hat, v);
// transient terms
bf->addTerm( u, invDt*v );
rhs->addTerm( u_prev_time * invDt * v );
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
FunctionPtr u1 = Teuchos::rcp( new InletBC );
bc->addDirichlet(beta_n_u_hat, lBoundary, -u1);
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(prevTimeFlow);
mesh->registerSolution(flowResidual);
// ==================== SET INITIAL GUESS ==========================
double u_free = 0.0;
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = Teuchos::rcp( new ConstantScalarFunction(u_free) );
// prevTimeFlow->projectOntoMesh(functionMap);
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv, 0);
int spaceDim = 2;
int meshWidth = 2;
bool conformingTraces = true;
int H1Order = 2, delta_k = 3;
double domainWidth = 1.0e-3;
bool diagScaling = false;
double h = domainWidth / meshWidth;
double weight = h / 4.0; // ratio of area of square with sidelength h to its perimeter
double sigma_weight = 1.0; // h / 4.0; // sigma = sigma_weight * u->grad()
Space uHatSpace = conformingTraces ? HGRAD : L2;
VarFactoryPtr vf = VarFactory::varFactory();
// fields
VarPtr u = vf->fieldVar("u");
VarPtr sigma = vf->fieldVar("sigma", VECTOR_L2);
// traces
VarPtr u_hat = vf->traceVar("u_hat", uHatSpace);
VarPtr sigma_n = vf->fluxVar("sigma_n");
// tests
VarPtr v = vf->testVar("v", HGRAD);
VarPtr tau = vf->testVar("tau", HDIV);
BFPtr bf = BF::bf(vf);
// standard BF:
// bf->addTerm(sigma, v->grad());
// bf->addTerm(sigma_n, v);
//
// bf->addTerm(sigma, tau);
// bf->addTerm(u, tau->div());
// bf->addTerm(-u_hat, tau->dot_normal());
// weighted BF:
bf->addTerm(sigma, v->grad());
bf->addTerm(weight * sigma_n, v);
bf->addTerm(sigma, tau);
bf->addTerm(sigma_weight * u, tau->div());
bf->addTerm(- sigma_weight * weight * u_hat, tau->dot_normal());
IPPtr ip = IP::ip();
// standard IP:
ip->addTerm(tau + v->grad());
ip->addTerm(tau->div());
ip->addTerm(v);
ip->addTerm(tau);
// weighted IP:
// ip->addTerm(tau + v->grad());
// ip->addTerm(sigma_weight * tau->div());
// ip->addTerm(max(sigma_weight,1e-3) * v);
// ip->addTerm(sigma_weight * weight * tau);
BCPtr bc = BC::bc();
bc->addDirichlet(u_hat, SpatialFilter::allSpace(), Function::zero());
RHSPtr rhs = RHS::rhs();
rhs->addTerm(1.0 * sigma_weight * v);
vector<double> dimensions(spaceDim,domainWidth);
vector<int> elementCounts(spaceDim,meshWidth);
MeshPtr mesh = MeshFactory::rectilinearMesh(bf, dimensions, elementCounts, H1Order, delta_k);
SolutionPtr soln = Solution::solution(mesh, bc, rhs, ip);
soln->setUseCondensedSolve(true);
soln->initializeLHSVector();
soln->initializeStiffnessAndLoad();
soln->populateStiffnessAndLoad();
Teuchos::RCP<Epetra_RowMatrix> stiffness = soln->getStiffnessMatrix();
double condNumber = conditionNumberLAPACK(*stiffness, diagScaling);
cout << "condest (1-norm): " << condNumber << endl;
return 0;
}
bool ScratchPadTests::testResidualMemoryError()
{
int rank = Teuchos::GlobalMPISession::getRank();
double tol = 1e-11;
bool success = true;
int nCells = 2;
double eps = 1e-2;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
robIP->addTerm(tau);
robIP->addTerm(tau->div());
robIP->addTerm(v->grad());
robIP->addTerm(v);
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr zero = Function::constant(0.0);
FunctionPtr one = Function::constant(1.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = zero;
// FunctionPtr f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new LRInflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new LROutflowSquareBoundary);
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta*n*one);
bc->addDirichlet(uhat, outflowBoundary, zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
// mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
solution->solve(false);
mesh->registerSolution(solution);
double energyErr1 = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution));
RieszRepPtr rieszResidual = Teuchos::rcp(new RieszRep(mesh, robIP, residual));
rieszResidual->computeRieszRep();
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszResidual);
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
refinementStrategy.refine();
solution->solve(false);
double energyErr2 = solution->energyErrorTotal();
// if energy error rises
if (energyErr1 < energyErr2)
{
if (rank==0)
cout << "energy error increased from " << energyErr1 << " to " << energyErr2 << " after refinement.\n";
success = false;
}
return success;
}
// tests to make sure the energy error calculated thru direct integration works for vector valued test functions too
bool ScratchPadTests::testLTResidual()
{
double tol = 1e-11;
int rank = Teuchos::GlobalMPISession::getRank();
bool success = true;
int nCells = 2;
double eps = .1;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// choose the mesh-independent norm even though it may have boundary layers
ip->addTerm(v->grad());
ip->addTerm(v);
ip->addTerm(tau);
ip->addTerm(tau->div());
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one; // if this is set to zero instead, we pass the test (a clue?)
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr squareBoundary = Teuchos::rcp( new SquareBoundary );
bc->addDirichlet(uhat, squareBoundary, one);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
double energyError = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution),true);
// FunctionPtr uh = Function::solution(uhat,solution);
// FunctionPtr fn = Function::solution(beta_n_u_minus_sigma_n,solution);
// FunctionPtr uF = Function::solution(u,solution);
// FunctionPtr sigma = e1*Function::solution(sigma1,solution)+e2*Function::solution(sigma2,solution);
// residual->addTerm(- (fn*v - uh*tau->dot_normal()));
// residual->addTerm(- (uF*(tau->div() - beta*v->grad()) + sigma*((1/eps)*tau + v->grad())));
// residual->addTerm(-(fn*v - uF*beta*v->grad() + sigma*v->grad())); // just v portion
// residual->addTerm(uh*tau->dot_normal() - uF*tau->div() - sigma*((1/eps)*tau)); // just tau portion
Teuchos::RCP<RieszRep> rieszResidual = Teuchos::rcp(new RieszRep(mesh, ip, residual));
rieszResidual->computeRieszRep();
double energyErrorLT = rieszResidual->getNorm();
int cubEnrich = 0;
bool testVsTest = true;
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszResidual);
// experiment by Nate: manually specify the error (this appears to produce identical results, as it should)
// FunctionPtr err = e_v * e_v + e_tau * e_tau + e_v->grad() * e_v->grad() + e_tau->div() * e_tau->div();
map<int,FunctionPtr> errFxns;
errFxns[v->ID()] = e_v;
errFxns[tau->ID()] = e_tau;
LinearTermPtr ipAtErrFxns = ip->evaluate(errFxns);
FunctionPtr err = ip->evaluate(errFxns)->evaluate(errFxns);
double energyErrorIntegrated = sqrt(err->integrate(mesh,cubEnrich,testVsTest));
// check that energy error computed thru Solution and through rieszRep are the same
bool success1 = abs(energyError-energyErrorLT)<tol;
// checks that matrix-computed and integrated errors are the same
bool success2 = abs(energyErrorLT-energyErrorIntegrated)<tol;
success = success1==true && success2==true;
if (!success)
{
if (rank==0)
cout << "Failed testLTResidual; energy error = " << energyError << ", while linearTerm error is computed to be " << energyErrorLT << ", and when computing through integration of the Riesz rep function, error = " << energyErrorIntegrated << endl;
}
// VTKExporter exporter(solution, mesh, varFactory);
// exporter.exportSolution("testLTRes");
// cout << endl;
return success;
}
// tests residual computation on simple convection
bool ScratchPadTests::testLTResidualSimple()
{
double tol = 1e-11;
int rank = Teuchos::GlobalMPISession::getRank();
bool success = true;
int nCells = 2;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// choose the mesh-independent norm even though it may have BLs
ip->addTerm(v->grad());
ip->addTerm(v);
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one;
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr boundary = Teuchos::rcp( new InflowSquareBoundary );
FunctionPtr u_in = Teuchos::rcp(new Uinflow);
bc->addDirichlet(beta_n_u, boundary, beta*n*u_in);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
int cubEnrich = 0;
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
double energyError = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution),true);
Teuchos::RCP<RieszRep> rieszResidual = Teuchos::rcp(new RieszRep(mesh, ip, residual));
rieszResidual->computeRieszRep(cubEnrich);
double energyErrorLT = rieszResidual->getNorm();
bool testVsTest = true;
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
map<int,FunctionPtr> errFxns;
errFxns[v->ID()] = e_v;
FunctionPtr err = (ip->evaluate(errFxns,false))->evaluate(errFxns,false); // don't need boundary terms unless they're in IP
double energyErrorIntegrated = sqrt(err->integrate(mesh,cubEnrich,testVsTest));
// check that energy error computed thru Solution and through rieszRep are the same
success = abs(energyError-energyErrorLT) < tol;
if (success==false)
{
if (rank==0)
cout << "Failed testLTResidualSimple; energy error = " << energyError << ", while linearTerm error is computed to be " << energyErrorLT << endl;
return success;
}
// checks that matrix-computed and integrated errors are the same
success = abs(energyErrorLT-energyErrorIntegrated)<tol;
if (success==false)
{
if (rank==0)
cout << "Failed testLTResidualSimple; energy error = " << energyError << ", while error computed via integration is " << energyErrorIntegrated << endl;
return success;
}
return success;
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); // initialize MPI
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
int numElements = 3;
vector<vector<double>> domainDim(3,vector<double>{0.0,1.0}); // first index: spaceDim; second: 0/1 for x0, x1, etc.
int polyOrder = 2, delta_k = 1;
int spaceDim = 2;
cmdp.setOption("numElements", &numElements );
cmdp.setOption("polyOrder", &polyOrder );
cmdp.setOption("delta_k", &delta_k );
cmdp.setOption("x0", &domainDim[0][0] );
cmdp.setOption("x1", &domainDim[0][1] );
cmdp.setOption("y0", &domainDim[1][0] );
cmdp.setOption("y1", &domainDim[1][1] );
cmdp.setOption("z0", &domainDim[2][0] );
cmdp.setOption("z1", &domainDim[2][1] );
cmdp.setOption("spaceDim", &spaceDim);
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
vector<double> x0(spaceDim);
vector<double> domainSize(spaceDim);
vector<int> elementCounts(spaceDim);
for (int d=0; d<spaceDim; d++)
{
x0[d] = domainDim[d][0];
domainSize[d] = domainDim[d][1] - x0[d];
elementCounts[d] = numElements;
}
bool conformingTraces = true; // no difference for primal/continuous formulations
PoissonFormulation formCG(spaceDim, conformingTraces, PoissonFormulation::CONTINUOUS_GALERKIN);
VarPtr q = formCG.q();
VarPtr phi = formCG.phi();
BFPtr bf = formCG.bf();
MeshPtr bubnovMesh = MeshFactory::rectilinearMesh(bf, domainSize, elementCounts, polyOrder, 0, x0);
// Right now, hanging nodes don't work with continuous field variables
// there is a GDAMinimumRule test demonstrating the failure, SolvePoisson2DContinuousGalerkinHangingNode.
// make a mesh with hanging nodes (when spaceDim > 1)
// {
// set<GlobalIndexType> cellsToRefine = {0};
// bubnovMesh->hRefine(cellsToRefine);
// }
RHSPtr rhs = RHS::rhs();
rhs->addTerm(1.0 * q); // unit forcing
IPPtr ip = Teuchos::null; // will give Bubnov-Galerkin
BCPtr bc = BC::bc();
bc->addDirichlet(phi, SpatialFilter::allSpace(), Function::zero());
SolutionPtr solution = Solution::solution(bf, bubnovMesh, bc, rhs, ip);
solution->solve();
HDF5Exporter exporter(bubnovMesh, "PoissonContinuousGalerkin");
exporter.exportSolution(solution);
/**** Sort-of-primal experiment ****/
// an experiment: try doing "primal" DPG with IBP to the boundary
// ip = IP::ip();
// ip->addTerm(q->grad());
// ip->addTerm(q);
//
// solution = Solution::solution(bf, bubnovMesh, bc, rhs, ip);
// solution->solve();
//
// HDF5Exporter primalNoFluxExporter(bubnovMesh, "PoissonPrimalNoFlux");
// primalNoFluxExporter.exportSolution(solution);
//*** Primal Formulation ***//
PoissonFormulation form(spaceDim, conformingTraces, PoissonFormulation::PRIMAL);
q = form.q();
phi = form.phi();
bf = form.bf();
bc = BC::bc();
bc->addDirichlet(phi, SpatialFilter::allSpace(), Function::zero());
rhs = RHS::rhs();
rhs->addTerm(1.0 * q); // unit forcing
MeshPtr primalMesh = MeshFactory::rectilinearMesh(bf, domainSize, elementCounts, polyOrder, delta_k, x0);
ip = IP::ip();
ip->addTerm(q->grad());
ip->addTerm(q);
// Right now, hanging nodes don't work with continuous field variables
// there is a GDAMinimumRule test demonstrating the failure, SolvePoisson2DContinuousGalerkinHangingNode.
// make a mesh with hanging nodes (when spaceDim > 1)
// {
// set<GlobalIndexType> cellsToRefine = {0};
// primalMesh->hRefine(cellsToRefine);
// }
solution = Solution::solution(bf, primalMesh, bc, rhs, ip);
solution->solve();
HDF5Exporter primalExporter(primalMesh, "PoissonPrimal");
primalExporter.exportSolution(solution);
return 0;
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = coupled robust");
// Optional arguments (have defaults)
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation", false);
double Re = args.Input("--Re", "Reynolds number", 40);
double nu = 1./Re;
double lambda = Re/2.-sqrt(Re*Re/4+4*pi*pi);
int maxNewtonIterations = args.Input("--maxIterations", "maximum number of Newton iterations", 20);
int polyOrder = args.Input("--polyOrder", "polynomial order for field variables", 2);
int deltaP = args.Input("--deltaP", "how much to enrich test space", 2);
// string saveFile = args.Input<string>("--meshSaveFile", "file to which to save refinement history", "");
// string replayFile = args.Input<string>("--meshLoadFile", "file with refinement history to replay", "");
args.Process();
// if (commRank==0)
// {
// cout << "saveFile is " << saveFile << endl;
// cout << "loadFile is " << replayFile << endl;
// }
//////////////////// PROBLEM DEFINITIONS ///////////////////////
int H1Order = polyOrder+1;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau11 = varFactory.testVar("tau11", HGRAD);
VarPtr tau12 = varFactory.testVar("tau12", HGRAD);
VarPtr tau22 = varFactory.testVar("tau22", HGRAD);
VarPtr v1 = varFactory.testVar("v1", HGRAD);
VarPtr v2 = varFactory.testVar("v2", HGRAD);
// define trial variables
VarPtr u1 = varFactory.fieldVar("u1");
VarPtr u2 = varFactory.fieldVar("u2");
VarPtr sigma11 = varFactory.fieldVar("sigma11");
VarPtr sigma12 = varFactory.fieldVar("sigma12");
VarPtr sigma22 = varFactory.fieldVar("sigma22");
VarPtr u1hat = varFactory.traceVar("u1hat");
VarPtr u2hat = varFactory.traceVar("u2hat");
VarPtr t1hat = varFactory.fluxVar("t1hat");
VarPtr t2hat = varFactory.fluxVar("t2hat");
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
double xmin = -0.5;
double xmax = 1.0;
double ymin = -0.5;
double ymax = 1.5;
meshBoundary(0,0) = xmin; // x1
meshBoundary(0,1) = ymin; // y1
meshBoundary(1,0) = xmax;
meshBoundary(1,1) = ymin;
meshBoundary(2,0) = xmax;
meshBoundary(2,1) = ymax;
meshBoundary(3,0) = xmin;
meshBoundary(3,1) = ymax;
int horizontalCells = 6, verticalCells = 8;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshFactory::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+deltaP);
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
vector<double> e1(2); // (1,0)
e1[0] = 1;
vector<double> e2(2); // (0,1)
e2[1] = 1;
FunctionPtr u1_prev = Function::solution(u1, backgroundFlow);
FunctionPtr u2_prev = Function::solution(u2, backgroundFlow);
// FunctionPtr sigma11_prev = Function::solution(sigma11, backgroundFlow);
// FunctionPtr sigma12_prev = Function::solution(sigma12, backgroundFlow);
// FunctionPtr sigma22_prev = Function::solution(sigma22, backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
FunctionPtr u1Exact = Teuchos::rcp( new ExactU1(lambda) );
FunctionPtr u2Exact = Teuchos::rcp( new ExactU2(lambda) );
// ==================== SET INITIAL GUESS ==========================
map<int, Teuchos::RCP<Function> > functionMap;
// functionMap[u1->ID()] = u1Exact;
// functionMap[u2->ID()] = u2Exact;
functionMap[u1->ID()] = zero;
functionMap[u2->ID()] = zero;
backgroundFlow->projectOntoMesh(functionMap);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
// stress equation
bf->addTerm( 1./nu*sigma11, tau11 );
bf->addTerm( 1./nu*sigma12, tau12 );
bf->addTerm( 1./nu*sigma12, tau12 );
bf->addTerm( 1./nu*sigma22, tau22 );
bf->addTerm( -0.5/nu*sigma11, tau11 );
bf->addTerm( -0.5/nu*sigma22, tau11 );
bf->addTerm( -0.5/nu*sigma11, tau22 );
bf->addTerm( -0.5/nu*sigma22, tau22 );
bf->addTerm( 2*u1, tau11->dx() );
bf->addTerm( 2*u1, tau12->dy() );
bf->addTerm( 2*u2, tau12->dx() );
bf->addTerm( 2*u2, tau22->dy() );
bf->addTerm( -2*u1hat, tau11->times_normal_x() );
bf->addTerm( -2*u1hat, tau12->times_normal_y() );
bf->addTerm( -2*u2hat, tau12->times_normal_x() );
bf->addTerm( -2*u2hat, tau22->times_normal_y() );
// momentum equation
bf->addTerm( -2.*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( -2.*u2_prev*u2, v2->dy() );
bf->addTerm( sigma11, v1->dx() );
bf->addTerm( sigma12, v1->dy() );
bf->addTerm( sigma12, v2->dx() );
bf->addTerm( sigma22, v2->dy() );
bf->addTerm( t1hat, v1);
bf->addTerm( t2hat, v2);
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
// stress equation
rhs->addTerm( -2*u1_prev * tau11->dx() );
rhs->addTerm( -2*u1_prev * tau12->dy() );
rhs->addTerm( -2*u2_prev * tau12->dx() );
rhs->addTerm( -2*u2_prev * tau22->dy() );
// momentum equation
rhs->addTerm( u1_prev*u1_prev * v1->dx() );
rhs->addTerm( u2_prev*u1_prev * v1->dy() );
rhs->addTerm( u2_prev*u1_prev * v2->dx() );
rhs->addTerm( u2_prev*u2_prev * v2->dy() );
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (norm == 0)
{
ip = bf->graphNorm();
}
else if (norm == 1)
{
ip->addTerm( 0.5/nu*tau11-0.5/nu*tau22 + v1->dx() );
ip->addTerm( 1./nu*tau12 + v1->dy() );
ip->addTerm( 1./nu*tau12 + v2->dx() );
ip->addTerm( 0.5/nu*tau22-0.5/nu*tau11 + v2->dy() );
ip->addTerm( 2*tau11->dx() + 2*tau12->dy() - 2*u1_prev*v1->dx() - u2_prev*v1->dy() - u2_prev*v2->dx() );
ip->addTerm( 2*tau12->dx() + 2*tau22->dy() - 2*u2_prev*v2->dy() - u1_prev*v1->dy() - u1_prev*v2->dx() );
ip->addTerm( v1 );
ip->addTerm( v2 );
ip->addTerm( tau11 );
ip->addTerm( tau12 );
ip->addTerm( tau12 );
ip->addTerm( tau22 );
}
else if (norm == 2)
{
// ip->addTerm( 0.5/sqrt(nu)*tau11-0.5/nu*tau22 );
// ip->addTerm( 1./sqrt(nu)*tau12 );
// ip->addTerm( 1./sqrt(nu)*tau12 );
// ip->addTerm( 0.5/sqrt(nu)*tau22-0.5/nu*tau11 );
ip->addTerm( tau11 );
ip->addTerm( tau12 );
ip->addTerm( tau12 );
ip->addTerm( tau22 );
ip->addTerm( 2*tau11->dx() + 2*tau12->dy() - 2*u1_prev*v1->dx() - u2_prev*v1->dy() - u2_prev*v2->dx() );
ip->addTerm( 2*tau12->dx() + 2*tau22->dy() - 2*u2_prev*v2->dy() - u1_prev*v1->dy() - u1_prev*v2->dx() );
ip->addTerm( 2*u1_prev*v1->dx() + u2_prev*v1->dy() + u2_prev*v2->dx() );
ip->addTerm( 2*u2_prev*v2->dy() + u1_prev*v1->dy() + u1_prev*v2->dx() );
ip->addTerm( sqrt(nu)*v1->grad() );
ip->addTerm( sqrt(nu)*v2->grad() );
ip->addTerm( v1 );
ip->addTerm( v2 );
}
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
SpatialFilterPtr left = Teuchos::rcp( new ConstantXBoundary(-0.5) );
SpatialFilterPtr right = Teuchos::rcp( new ConstantXBoundary(1) );
SpatialFilterPtr top = Teuchos::rcp( new ConstantYBoundary(-0.5) );
SpatialFilterPtr bottom = Teuchos::rcp( new ConstantYBoundary(1.5) );
bc->addDirichlet(u1hat, left, u1Exact);
bc->addDirichlet(u2hat, left, u2Exact);
bc->addDirichlet(u1hat, right, u1Exact);
bc->addDirichlet(u2hat, right, u2Exact);
bc->addDirichlet(u1hat, top, u1Exact);
bc->addDirichlet(u2hat, top, u2Exact);
bc->addDirichlet(u1hat, bottom, u1Exact);
bc->addDirichlet(u2hat, bottom, u2Exact);
// bc->addDirichlet(u1hat, left, zero);
// bc->addDirichlet(u2hat, left, zero);
// bc->addDirichlet(u1hat, right, zero);
// bc->addDirichlet(u2hat, right, zero);
// bc->addDirichlet(u1hat, top, zero);
// bc->addDirichlet(u2hat, top, zero);
// bc->addDirichlet(u1hat, bottom, zero);
// bc->addDirichlet(u2hat, bottom, zero);
// pc->addConstraint(u1hat*u2hat-t1hat == zero, top);
// pc->addConstraint(u2hat*u2hat-t2hat == zero, top);
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// solution->setFilter(pc);
// if (enforceLocalConservation) {
// solution->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y() == zero);
// }
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(backgroundFlow);
// Teuchos::RCP< RefinementHistory > refHistory = Teuchos::rcp( new RefinementHistory );
// mesh->registerObserver(refHistory);
//////////////////// SOLVE & REFINE ///////////////////////
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
HDF5Exporter exporter(mesh, "Kovasznay_np");
ofstream convOut;
stringstream convOutFile;
convOutFile << "Kovasznay_conv_" << Re <<".txt";
if (commRank == 0)
convOut.open(convOutFile.str().c_str());
set<int> nonlinearVars;
nonlinearVars.insert(u1->ID());
nonlinearVars.insert(u2->ID());
double nonlinearRelativeEnergyTolerance = 1e-5; // used to determine convergence of the nonlinear solution
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
double L2Update = 1e10;
int iterCount = 0;
while (L2Update > nonlinearRelativeEnergyTolerance && iterCount < maxNewtonIterations)
{
solution->solve(false);
double u1L2Update = solution->L2NormOfSolutionGlobal(u1->ID());
double u2L2Update = solution->L2NormOfSolutionGlobal(u2->ID());
L2Update = sqrt(u1L2Update*u1L2Update + u2L2Update*u2L2Update);
// Check local conservation
if (commRank == 0)
{
cout << "L2 Norm of Update = " << L2Update << endl;
// if (saveFile.length() > 0) {
// std::ostringstream oss;
// oss << string(saveFile) << refIndex ;
// cout << "on refinement " << refIndex << " saving mesh file to " << oss.str() << endl;
// refHistory->saveToFile(oss.str());
// }
}
// line search algorithm
double alpha = 1.0;
backgroundFlow->addSolution(solution, alpha, nonlinearVars);
iterCount++;
}
exporter.exportSolution(backgroundFlow, varFactory, refIndex, 2, cellIDToSubdivision(mesh, 4));
FunctionPtr u1Soln = Function::solution(u1, backgroundFlow);
FunctionPtr u2Soln = Function::solution(u2, backgroundFlow);
FunctionPtr u1Sqr = (u1Soln-u1Exact)*(u1Soln-u1Exact);
FunctionPtr u2Sqr = (u2Soln-u2Exact)*(u2Soln-u2Exact);
double u1L2Error = u1Sqr->integrate(mesh, 1e-5);
double u2L2Error = u2Sqr->integrate(mesh, 1e-5);
double l2Error = sqrt(u1L2Error+u2L2Error);
double energyError = solution->energyErrorTotal();
cout << "L2 Error: " << l2Error << " Energy Error: " << energyError << endl;
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
return 0;
}
int main(int argc, char *argv[])
{
#ifdef ENABLE_INTEL_FLOATING_POINT_EXCEPTIONS
cout << "NOTE: enabling floating point exceptions for divide by zero.\n";
_MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~_MM_MASK_INVALID);
#endif
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int rank = Teuchos::GlobalMPISession::getRank();
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
bool useCondensedSolve = false; // condensed solve not yet compatible with minimum rule meshes
int numGridPoints = 32; // in x,y -- idea is to keep the overall order of approximation constant
int k = 4; // poly order for u
double theta = 0.5;
int numTimeSteps = 2000;
int numCells = -1; // in x, y (-1 so we can set a default if unset from the command line.)
int numFrames = 50;
int delta_k = 2; // test space enrichment: should be 2 for 2D
bool useMumpsIfAvailable = true;
bool convertSolutionsToVTK = false; // when true assumes we've already run with precisely the same options, except without VTK support (so we have a bunch of .soln files)
bool usePeriodicBCs = false;
bool useConstantConvection = false;
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("numCells",&numCells,"number of cells in x and y directions");
cmdp.setOption("theta",&theta,"theta weight for time-stepping");
cmdp.setOption("numTimeSteps",&numTimeSteps,"number of time steps");
cmdp.setOption("numFrames",&numFrames,"number of frames for export");
cmdp.setOption("usePeriodicBCs", "useDirichletBCs", &usePeriodicBCs);
cmdp.setOption("useConstantConvection", "useVariableConvection", &useConstantConvection);
cmdp.setOption("useCondensedSolve", "useUncondensedSolve", &useCondensedSolve, "use static condensation to reduce the size of the global solve");
cmdp.setOption("useMumps", "useKLU", &useMumpsIfAvailable, "use MUMPS (if available)");
cmdp.setOption("convertPreComputedSolutionsToVTK", "computeSolutions", &convertSolutionsToVTK);
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
bool saveSolutionFiles = true;
if (numCells==-1) numCells = numGridPoints / k;
if (rank==0)
{
cout << "solving on " << numCells << " x " << numCells << " mesh " << "of order " << k << ".\n";
}
set<int> timeStepsToExport;
timeStepsToExport.insert(numTimeSteps);
int timeStepsPerFrame = numTimeSteps / (numFrames - 1);
if (timeStepsPerFrame==0) timeStepsPerFrame = 1;
for (int n=0; n<numTimeSteps; n += timeStepsPerFrame)
{
timeStepsToExport.insert(n);
}
int H1Order = k + 1;
const static double PI = 3.141592653589793238462;
double dt = 2 * PI / numTimeSteps;
VarFactory varFactory;
// traces:
VarPtr qHat = varFactory.fluxVar("\\widehat{q}");
// fields:
VarPtr u = varFactory.fieldVar("u", L2);
// test functions:
VarPtr v = varFactory.testVar("v", HGRAD);
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr c;
if (useConstantConvection)
{
c = Function::vectorize(Function::constant(0.5), Function::constant(0.5));
}
else
{
c = Function::vectorize(y-0.5, 0.5-x);
}
// FunctionPtr c = Function::vectorize(y, x);
FunctionPtr n = Function::normal();
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
bf->addTerm(u / dt, v);
bf->addTerm(- theta * u, c * v->grad());
// bf->addTerm(theta * u_hat, (c * n) * v);
bf->addTerm(qHat, v);
double width = 2.0, height = 2.0;
int horizontalCells = numCells, verticalCells = numCells;
double x0 = -0.5;
double y0 = -0.5;
if (usePeriodicBCs)
{
x0 = 0.0;
y0 = 0.0;
width = 1.0;
height = 1.0;
}
BCPtr bc = BC::bc();
SpatialFilterPtr inflowFilter = Teuchos::rcp( new InflowFilterForClockwisePlanarRotation (x0,x0+width,y0,y0+height,0.5,0.5));
vector< PeriodicBCPtr > periodicBCs;
if (! usePeriodicBCs)
{
// bc->addDirichlet(u_hat, SpatialFilter::allSpace(), Function::zero());
bc->addDirichlet(qHat, inflowFilter, Function::zero()); // zero BCs enforced at the inflow boundary.
}
else
{
periodicBCs.push_back(PeriodicBC::xIdentification(x0, x0+width));
periodicBCs.push_back(PeriodicBC::yIdentification(y0, y0+height));
}
MeshPtr mesh = MeshFactory::quadMeshMinRule(bf, H1Order, delta_k, width, height,
horizontalCells, verticalCells, false, x0, y0, periodicBCs);
FunctionPtr u0 = Teuchos::rcp( new Cone_U0(0.0, 0.25, 0.1, 1.0, usePeriodicBCs) );
RHSPtr initialRHS = RHS::rhs();
initialRHS->addTerm(u0 / dt * v);
initialRHS->addTerm((1-theta) * u0 * c * v->grad());
IPPtr ip;
// ip = Teuchos::rcp( new IP );
// ip->addTerm(v);
// ip->addTerm(c * v->grad());
ip = bf->graphNorm();
// create two Solution objects; we'll switch between these for time steps
SolutionPtr soln0 = Solution::solution(mesh, bc, initialRHS, ip);
soln0->setCubatureEnrichmentDegree(5);
FunctionPtr u_soln0 = Function::solution(u, soln0);
FunctionPtr qHat_soln0 = Function::solution(qHat, soln0);
RHSPtr rhs1 = RHS::rhs();
rhs1->addTerm(u_soln0 / dt * v);
rhs1->addTerm((1-theta) * u_soln0 * c * v->grad());
SolutionPtr soln1 = Solution::solution(mesh, bc, rhs1, ip);
soln1->setCubatureEnrichmentDegree(5);
FunctionPtr u_soln1 = Function::solution(u, soln1);
FunctionPtr qHat_soln1 = Function::solution(qHat, soln1);
RHSPtr rhs2 = RHS::rhs(); // after the first solve on soln0, we'll swap out initialRHS for rhs2
rhs2->addTerm(u_soln1 / dt * v);
rhs2->addTerm((1-theta) * u_soln1 * c * v->grad());
Teuchos::RCP<Solver> solver = Teuchos::rcp( new KluSolver );
#ifdef HAVE_AMESOS_MUMPS
if (useMumpsIfAvailable) solver = Teuchos::rcp( new MumpsSolver );
#endif
// double energyErrorSum = 0;
ostringstream filePrefix;
filePrefix << "convectingCone_k" << k << "_t";
int frameNumber = 0;
#ifdef USE_HDF5
ostringstream dir_name;
dir_name << "convectingCone_k" << k;
HDF5Exporter exporter(mesh,dir_name.str());
#endif
#ifdef USE_VTK
VTKExporter soln0Exporter(soln0,mesh,varFactory);
VTKExporter soln1Exporter(soln1,mesh,varFactory);
#endif
if (convertSolutionsToVTK)
{
#ifdef USE_VTK
if (rank==0)
{
cout << "Converting .soln files to VTK.\n";
for (int frameNumber=0; frameNumber<=numFrames; frameNumber++)
{
ostringstream filename;
filename << filePrefix.str() << frameNumber << ".soln";
soln0->readFromFile(filename.str());
filename.str("");
filename << filePrefix.str() << frameNumber;
soln0Exporter.exportFields(filename.str());
}
}
#else
if (rank==0) cout << "Driver was built without USE_VTK defined. This must be defined to convert solution files to VTK files.\n";
#endif
exit(0);
}
if (timeStepsToExport.find(0) != timeStepsToExport.end())
{
map<int,FunctionPtr> solnMap;
solnMap[u->ID()] = u0; // project field variables
if (rank==0) cout << "About to project initial solution onto mesh.\n";
soln0->projectOntoMesh(solnMap);
if (rank==0) cout << "...projected initial solution onto mesh.\n";
ostringstream filename;
filename << filePrefix.str() << frameNumber++;
if (rank==0) cout << "About to export initial solution.\n";
#ifdef USE_VTK
if (rank==0) soln0Exporter.exportFields(filename.str());
#endif
#ifdef USE_HDF5
exporter.exportSolution(soln0, varFactory,0);
#endif
if (saveSolutionFiles)
{
if (rank==0)
{
filename << ".soln";
soln0->writeToFile(filename.str());
cout << endl << "wrote " << filename.str() << endl;
}
}
if (rank==0) cout << "...exported initial solution.\n";
}
if (rank==0) cout << "About to solve initial time step.\n";
// first time step:
soln0->setReportTimingResults(true); // added to gain insight into why MPI blocks in some cases on the server...
if (useCondensedSolve) soln0->condensedSolve(solver);
else soln0->solve(solver);
soln0->setReportTimingResults(false);
// energyErrorSum += soln0->energyErrorTotal();
soln0->setRHS(rhs2);
if (rank==0) cout << "Solved initial time step.\n";
if (timeStepsToExport.find(1) != timeStepsToExport.end())
{
ostringstream filename;
filename << filePrefix.str() << frameNumber++;
#ifdef USE_VTK
if (rank==0) soln0Exporter.exportFields(filename.str());
#endif
#ifdef USE_HDF5
exporter.exportSolution(soln0, varFactory);
#endif
if (saveSolutionFiles)
{
if (rank==0)
{
filename << ".soln";
soln0->writeToFile(filename.str());
cout << endl << "wrote " << filename.str() << endl;
}
}
}
bool reportTimings = false;
for (int n=1; n<numTimeSteps; n++)
{
bool odd = (n%2)==1;
SolutionPtr soln_n = odd ? soln1 : soln0;
if (useCondensedSolve) soln_n->solve(solver);
else soln_n->solve(solver);
if (reportTimings)
{
if (rank==0) cout << "time step " << n << ", timing report:\n";
soln_n->reportTimings();
}
if (rank==0)
{
cout << "\x1B[2K"; // Erase the entire current line.
cout << "\x1B[0E"; // Move to the beginning of the current line.
cout << "Solved time step: " << n;
flush(cout);
}
if (timeStepsToExport.find(n+1)!=timeStepsToExport.end())
{
ostringstream filename;
filename << filePrefix.str() << frameNumber++;
#ifdef USE_VTK
if (rank==0)
{
if (odd)
{
soln1Exporter.exportFields(filename.str());
}
else
{
soln0Exporter.exportFields(filename.str());
}
}
#endif
#ifdef USE_HDF5
double t = n * dt;
if (odd)
{
exporter.exportSolution(soln1, varFactory, t);
}
else
{
exporter.exportSolution(soln0, varFactory, t);
}
#endif
if (saveSolutionFiles)
{
if (rank==0)
{
filename << ".soln";
if (odd)
{
soln1->writeToFile(filename.str());
}
else
{
soln0->writeToFile(filename.str());
}
cout << endl << "wrote " << filename.str() << endl;
}
}
}
// energyErrorSum += soln_n->energyErrorTotal();
}
// if (rank==0) cout << "energy error, sum over all time steps: " << energyErrorSum << endl;
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
Comm.Barrier(); // set breakpoint here to allow debugger attachment to other MPI processes than the one you automatically attached to.
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
// problem parameters:
double mu = 0.1;
double permCoef = 1e4;
int numRefs = 0;
int k = 2, delta_k = 2;
string norm = "Graph";
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("numRefs",&numRefs,"number of refinements");
cmdp.setOption("norm", &norm, "norm");
cmdp.setOption("mu", &mu, "mu");
cmdp.setOption("permCoef", &permCoef, "Permeability coefficient");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
FunctionPtr zero = TFunction<double>::zero();
FunctionPtr one = TFunction<double>::constant(1);
FunctionPtr sin2pix = Teuchos::rcp( new Sin_ax(2*pi) );
FunctionPtr cos2pix = Teuchos::rcp( new Cos_ax(2*pi) );
FunctionPtr sin2piy = Teuchos::rcp( new Sin_ay(2*pi) );
FunctionPtr cos2piy = Teuchos::rcp( new Cos_ay(2*pi) );
FunctionPtr u1_exact = sin2pix*cos2piy;
FunctionPtr u2_exact = -cos2pix*sin2piy;
FunctionPtr x2 = TFunction<double>::xn(2);
FunctionPtr y2 = TFunction<double>::yn(2);
FunctionPtr p_exact = x2*y2 - 1./9;
FunctionPtr permInv = permCoef*(sin2pix + 1.1);
VarFactoryPtr vf = VarFactory::varFactory();
//fields:
VarPtr sigma1 = vf->fieldVar("sigma1", VECTOR_L2);
VarPtr sigma2 = vf->fieldVar("sigma2", VECTOR_L2);
VarPtr u1 = vf->fieldVar("u1", L2);
VarPtr u2 = vf->fieldVar("u2", L2);
VarPtr p = vf->fieldVar("p", L2);
// traces:
VarPtr u1hat = vf->traceVar("u1hat");
VarPtr u2hat = vf->traceVar("u2hat");
VarPtr t1c = vf->fluxVar("t1c");
VarPtr t2c = vf->fluxVar("t2c");
// test:
VarPtr v1 = vf->testVar("v1", HGRAD);
VarPtr v2 = vf->testVar("v2", HGRAD);
VarPtr tau1 = vf->testVar("tau1", HDIV);
VarPtr tau2 = vf->testVar("tau2", HDIV);
VarPtr q = vf->testVar("q", HGRAD);
BFPtr bf = Teuchos::rcp( new BF(vf) );
bf->addTerm(1./mu*sigma1, tau1);
bf->addTerm(1./mu*sigma2, tau2);
bf->addTerm(u1, tau1->div());
bf->addTerm(u2, tau2->div());
bf->addTerm(-u1hat, tau1->dot_normal());
bf->addTerm(-u2hat, tau2->dot_normal());
bf->addTerm(sigma1, v1->grad());
bf->addTerm(sigma2, v2->grad());
bf->addTerm(-p, v1->dx());
bf->addTerm(-p, v2->dy());
bf->addTerm(t1c, v1);
bf->addTerm(t2c, v2);
bf->addTerm(mu*permInv*u1, v1);
bf->addTerm(mu*permInv*u2, v2);
bf->addTerm(-u1, q->dx());
bf->addTerm(-u2, q->dy());
bf->addTerm(u1hat, q->times_normal_x());
bf->addTerm(u2hat, q->times_normal_y());
RHSPtr rhs = RHS::rhs();
BCPtr bc = BC::bc();
SpatialFilterPtr y_equals_one = SpatialFilter::matchingY(1.0);
SpatialFilterPtr y_equals_zero = SpatialFilter::matchingY(0);
SpatialFilterPtr x_equals_one = SpatialFilter::matchingX(1.0);
SpatialFilterPtr x_equals_zero = SpatialFilter::matchingX(0.0);
bc->addDirichlet(u1hat, y_equals_zero, u1_exact);
bc->addDirichlet(u2hat, y_equals_zero, u2_exact);
bc->addDirichlet(u1hat, x_equals_zero, u1_exact);
bc->addDirichlet(u2hat, x_equals_zero, u2_exact);
bc->addDirichlet(u1hat, y_equals_one, u1_exact);
bc->addDirichlet(u2hat, y_equals_one, u2_exact);
bc->addDirichlet(u1hat, x_equals_one, u1_exact);
bc->addDirichlet(u2hat, x_equals_one, u2_exact);
bc->addZeroMeanConstraint(p);
MeshPtr mesh = MeshFactory::quadMesh(bf, k+1, delta_k, 1, 1, 4, 4);
map<string, IPPtr> brinkmanIPs;
brinkmanIPs["Graph"] = bf->graphNorm();
brinkmanIPs["Decoupled"] = Teuchos::rcp(new IP);
brinkmanIPs["Decoupled"]->addTerm(tau1);
brinkmanIPs["Decoupled"]->addTerm(tau2);
brinkmanIPs["Decoupled"]->addTerm(tau1->div());
brinkmanIPs["Decoupled"]->addTerm(tau2->div());
brinkmanIPs["Decoupled"]->addTerm(permInv*v1);
brinkmanIPs["Decoupled"]->addTerm(permInv*v2);
brinkmanIPs["Decoupled"]->addTerm(v1->grad());
brinkmanIPs["Decoupled"]->addTerm(v2->grad());
brinkmanIPs["Decoupled"]->addTerm(q);
brinkmanIPs["Decoupled"]->addTerm(q->grad());
// brinkmanIPs["CoupledRobust"] = Teuchos::rcp(new IP);
// brinkmanIPs["CoupledRobust"]->addTerm(tau->div()-beta*v->grad());
// brinkmanIPs["CoupledRobust"]->addTerm(Function<double>::min(one/Function<double>::h(),Function<double>::constant(1./sqrt(epsilon)))*tau);
// brinkmanIPs["CoupledRobust"]->addTerm(sqrt(epsilon)*v->grad());
// brinkmanIPs["CoupledRobust"]->addTerm(beta*v->grad());
// brinkmanIPs["CoupledRobust"]->addTerm(Function<double>::min(sqrt(epsilon)*one/Function<double>::h(),one)*v);
IPPtr ip = brinkmanIPs[norm];
SolutionPtr soln = TSolution<double>::solution(mesh, bc, rhs, ip);
double threshold = 0.20;
RefinementStrategy refStrategy(soln, threshold);
ostringstream refName;
refName << "brinkman";
HDF5Exporter exporter(mesh,refName.str());
for (int refIndex=0; refIndex <= numRefs; refIndex++)
{
soln->solve(false);
double energyError = soln->energyErrorTotal();
if (commRank == 0)
{
// if (refIndex > 0)
// refStrategy.printRefinementStatistics(refIndex-1);
cout << "Refinement:\t " << refIndex << " \tElements:\t " << mesh->numActiveElements()
<< " \tDOFs:\t " << mesh->numGlobalDofs() << " \tEnergy Error:\t " << energyError << endl;
}
exporter.exportSolution(soln, refIndex);
if (refIndex != numRefs)
refStrategy.refine();
}
return 0;
}
bool ScratchPadTests::testGalerkinOrthogonality()
{
double tol = 1e-11;
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
ip->addTerm(v);
ip->addTerm(beta*v->grad());
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
//////////////////// BUILD MESH ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
FunctionPtr n = Function::normal();
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u, v);
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(4, convectionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE ///////////////////////
RHSPtr rhs = RHS::rhs();
BCPtr bc = BC::bc();
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(inflowBoundary) );
FunctionPtr uIn;
uIn = Teuchos::rcp(new Uinflow); // uses a discontinuous piecewise-constant basis function on left and bottom sides of square
bc->addDirichlet(beta_n_u, inflowBoundary, beta*n*uIn);
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
FunctionPtr uFxn = Function::solution(u, solution);
FunctionPtr fnhatFxn = Function::solution(beta_n_u,solution);
// make residual for riesz representation function
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
FunctionPtr parity = Function::sideParity();
residual->addTerm(-fnhatFxn*v + (beta*uFxn)*v->grad());
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
riesz->computeRieszRep();
map<int,FunctionPtr> err_rep_map;
err_rep_map[v->ID()] = RieszRep::repFunction(v,riesz);
//////////////////// GET BOUNDARY CONDITION DATA ///////////////////////
FieldContainer<GlobalIndexType> bcGlobalIndices;
FieldContainer<double> bcGlobalValues;
mesh->boundary().bcsToImpose(bcGlobalIndices,bcGlobalValues,*(solution->bc()), NULL);
set<int> bcInds;
for (int i=0; i<bcGlobalIndices.dimension(0); i++)
{
bcInds.insert(bcGlobalIndices(i));
}
//////////////////// CHECK GALERKIN ORTHOGONALITY ///////////////////////
BCPtr nullBC;
RHSPtr nullRHS;
IPPtr nullIP;
SolutionPtr solnPerturbation = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
map< int, vector<DofInfo> > infoMap = constructGlobalDofToLocalDofInfoMap(mesh);
for (map< int, vector<DofInfo> >::iterator mapIt = infoMap.begin();
mapIt != infoMap.end(); mapIt++)
{
int dofIndex = mapIt->first;
vector< DofInfo > dofInfoVector = mapIt->second; // all the local dofs that map to dofIndex
// create perturbation in direction du
solnPerturbation->clear(); // clear all solns
// set each corresponding local dof to 1.0
for (vector< DofInfo >::iterator dofInfoIt = dofInfoVector.begin();
dofInfoIt != dofInfoVector.end(); dofInfoIt++)
{
DofInfo info = *dofInfoIt;
FieldContainer<double> solnCoeffs(info.basisCardinality);
solnCoeffs(info.basisOrdinal) = 1.0;
solnPerturbation->setSolnCoeffsForCellID(solnCoeffs, info.cellID, info.trialID, info.sideIndex);
}
// solnPerturbation->setSolnCoeffForGlobalDofIndex(1.0,dofIndex);
LinearTermPtr b_du = convectionBF->testFunctional(solnPerturbation);
FunctionPtr gradient = b_du->evaluate(err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)); // use boundary part only if flux
double grad = gradient->integrate(mesh,10);
if (!TestingUtilities::isFluxOrTraceDof(mesh,dofIndex) && abs(grad)>tol) // if we're not single-precision zero FOR FIELDS
{
// int cellID = mesh->getGlobalToLocalMap()[dofIndex].first;
cout << "Failed testGalerkinOrthogonality() for fields with diff " << abs(grad) << " at dof " << dofIndex << "; info:" << endl;
cout << dofInfoString(infoMap[dofIndex]);
success = false;
}
}
FieldContainer<double> errorJumps(mesh->numGlobalDofs()); //initialized to zero
// just test fluxes ON INTERNAL SKELETON here
set<GlobalIndexType> activeCellIDs = mesh->getActiveCellIDsGlobal();
for (GlobalIndexType activeCellID : activeCellIDs)
{
ElementPtr elem = mesh->getElement(activeCellID);
for (int sideIndex = 0; sideIndex < 4; sideIndex++)
{
ElementTypePtr elemType = elem->elementType();
vector<int> localDofIndices = elemType->trialOrderPtr->getDofIndices(beta_n_u->ID(), sideIndex);
for (int i = 0; i<localDofIndices.size(); i++)
{
int globalDofIndex = mesh->globalDofIndex(elem->cellID(), localDofIndices[i]);
vector< DofInfo > dofInfoVector = infoMap[globalDofIndex];
solnPerturbation->clear();
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,1.0,globalDofIndex);
// also add in BCs
for (int i = 0; i<bcGlobalIndices.dimension(0); i++)
{
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,bcGlobalValues(i),bcGlobalIndices(i));
}
LinearTermPtr b_du = convectionBF->testFunctional(solnPerturbation);
FunctionPtr gradient = b_du->evaluate(err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,globalDofIndex)); // use boundary part only if flux
double jump = gradient->integrate(mesh,10);
errorJumps(globalDofIndex) += jump;
}
}
}
for (int i = 0; i<mesh->numGlobalDofs(); i++)
{
if (abs(errorJumps(i))>tol)
{
cout << "Failing Galerkin orthogonality test for fluxes with diff " << errorJumps(i) << " at dof " << i << endl;
cout << dofInfoString(infoMap[i]);
success = false;
}
}
return success;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// {
// // 1D tests
// CellTopoPtrLegacy line_2 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >() ) );
// // let's draw a line
// vector<double> v0 = makeVertex(0);
// vector<double> v1 = makeVertex(1);
// vector<double> v2 = makeVertex(2);
// vector< vector<double> > vertices;
// vertices.push_back(v0);
// vertices.push_back(v1);
// vertices.push_back(v2);
// vector<unsigned> line1VertexList;
// vector<unsigned> line2VertexList;
// line1VertexList.push_back(0);
// line1VertexList.push_back(1);
// line2VertexList.push_back(1);
// line2VertexList.push_back(2);
// vector< vector<unsigned> > elementVertices;
// elementVertices.push_back(line1VertexList);
// elementVertices.push_back(line2VertexList);
// vector< CellTopoPtrLegacy > cellTopos;
// cellTopos.push_back(line_2);
// cellTopos.push_back(line_2);
// MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
// MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
// FunctionPtr x = Function::xn(1);
// FunctionPtr function = x;
// FunctionPtr fbdr = Function::restrictToCellBoundary(function);
// vector<FunctionPtr> functions;
// functions.push_back(function);
// functions.push_back(function);
// vector<string> functionNames;
// functionNames.push_back("function1");
// functionNames.push_back("function2");
// // {
// // HDF5Exporter exporter(mesh, "function1", false);
// // exporter.exportFunction(function, "function1");
// // }
// // {
// // HDF5Exporter exporter(mesh, "boundary1", false);
// // exporter.exportFunction(fbdr, "boundary1");
// // }
// // {
// // HDF5Exporter exporter(mesh, "functions1", false);
// // exporter.exportFunction(functions, functionNames);
// // }
// }
{
// 2D tests
// CellTopoPtrLegacy quad_4 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ) );
// CellTopoPtrLegacy tri_3 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() ) );
CellTopoPtr quad_4 = CellTopology::quad();
CellTopoPtr tri_3 = CellTopology::triangle();
// let's draw a little house
vector<double> v0 = makeVertex(-1,0);
vector<double> v1 = makeVertex(1,0);
vector<double> v2 = makeVertex(1,2);
vector<double> v3 = makeVertex(-1,2);
vector<double> v4 = makeVertex(0.0,3);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
vertices.push_back(v4);
vector<unsigned> quadVertexList;
quadVertexList.push_back(0);
quadVertexList.push_back(1);
quadVertexList.push_back(2);
quadVertexList.push_back(3);
vector<unsigned> triVertexList;
triVertexList.push_back(3);
triVertexList.push_back(2);
triVertexList.push_back(4);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(quadVertexList);
elementVertices.push_back(triVertexList);
// vector< CellTopoPtrLegacy > cellTopos;
vector< CellTopoPtr> cellTopos;
cellTopos.push_back(quad_4);
cellTopos.push_back(tri_3);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr vf = VarFactory::varFactory();
VarPtr tau = vf->testVar("tau", HDIV);
VarPtr v = vf->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = vf->traceVar("uhat");
VarPtr fhat = vf->fluxVar("fhat");
VarPtr u = vf->fieldVar("u");
VarPtr sigma = vf->fieldVar("sigma", VECTOR_L2);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(vf) );
// tau terms:
bf->addTerm(sigma, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( fhat, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr one = Function::constant(1.0);
rhs->addTerm( one * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
FunctionPtr zero = Function::zero();
SpatialFilterPtr entireBoundary = SpatialFilter::allSpace();
bc->addDirichlet(uhat, entireBoundary, zero);
//////////////////// SOLVE & REFINE ///////////////////////
// Output solution
Intrepid::FieldContainer<GlobalIndexType> savedCellPartition;
Teuchos::RCP<Epetra_FEVector> savedLHSVector;
{
//////////////////// BUILD MESH ///////////////////////
int H1Order = 4, pToAdd = 2;
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh (meshTopology, bf, H1Order, pToAdd) );
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
RefinementStrategy refinementStrategy( solution, 0.2);
HDF5Exporter exporter(mesh, "Poisson");
// exporter.exportSolution(solution, vf, 0, 2, cellIDToSubdivision(mesh, 4));
exporter.exportSolution(solution, 0, 2);
mesh->saveToHDF5("MeshSave.h5");
solution->saveToHDF5("SolnSave.h5");
solution->save("PoissonProblem");
// int numRefs = 1;
// for (int ref = 1; ref <= numRefs; ref++)
// {
// refinementStrategy.refine(commRank==0);
// solution->solve(false);
// mesh->saveToHDF5("MeshSave.h5");
// solution->saveToHDF5("SolnSave.h5");
// exporter.exportSolution(solution, vf, ref, 2, cellIDToSubdivision(mesh, 4));
// }
mesh->globalDofAssignment()->getPartitions(savedCellPartition);
savedLHSVector = solution->getLHSVector();
}
{
SolutionPtr loadedSolution = Solution::load(bf, "PoissonProblem");
HDF5Exporter exporter(loadedSolution->mesh(), "ProblemLoaded");
// exporter.exportSolution(loadedSolution, vf, 0, 2, cellIDToSubdivision(loadedSolution->mesh(), 4));
exporter.exportSolution(loadedSolution, 0, 2);
}
// {
// MeshPtr loadedMesh = MeshFactory::loadFromHDF5(bf, "Test0.h5");
// Teuchos::RCP<Solution> loadedSolution = Teuchos::rcp( new Solution(loadedMesh, bc, rhs, ip) );
// loadedSolution->solve(false);
// HDF5Exporter exporter(loadedMesh, "MeshLoaded");
// exporter.exportSolution(loadedSolution, vf, 0, 2, cellIDToSubdivision(loadedMesh, 4));
// }
{
MeshPtr loadedMesh = MeshFactory::loadFromHDF5(bf, "MeshSave.h5");
Intrepid::FieldContainer<GlobalIndexType> loadedCellPartition;
loadedMesh->globalDofAssignment()->getPartitions(loadedCellPartition);
if (loadedCellPartition.size() != savedCellPartition.size())
{
cout << "Error: the loaded partition has different size/shape than the saved one.\n";
cout << "loaded size: " << loadedCellPartition.size() << "; saved size: " << savedCellPartition.size() << endl;
}
else
{
bool partitionsMatch = true;
for (int i=0; i<loadedCellPartition.size(); i++)
{
if (loadedCellPartition[i] != savedCellPartition[i])
{
partitionsMatch = false;
break;
}
}
if (partitionsMatch) cout << "Saved and loaded cell partitions match!\n";
else
{
cout << "Saved and loaded cell partitions differ.\n";
cout << "saved:\n" << savedCellPartition;
cout << "loaded:\n" << loadedCellPartition;
}
}
Teuchos::RCP<Solution> loadedSolution = Teuchos::rcp( new Solution(loadedMesh, bc, rhs, ip) );
loadedSolution->loadFromHDF5("SolnSave.h5");
Teuchos::RCP<Epetra_FEVector> loadedLHSVector = loadedSolution->getLHSVector();
if (loadedLHSVector->Map().MinLID() != savedLHSVector->Map().MinLID())
{
cout << "On rank " << commRank << ", loaded min LID = " << loadedLHSVector->Map().MinLID();
cout << ", but saved min LID = " << savedLHSVector->Map().MinLID() << endl;
}
else if (loadedLHSVector->Map().MaxLID() != savedLHSVector->Map().MaxLID())
{
cout << "On rank " << commRank << ", loaded max LID = " << loadedLHSVector->Map().MaxLID();
cout << ", but saved max LID = " << savedLHSVector->Map().MaxLID() << endl;
}
else
{
bool globalIDsMatch = true;
for (int lid = loadedLHSVector->Map().MinLID(); lid <= loadedLHSVector->Map().MaxLID(); lid++)
{
if (loadedLHSVector->Map().GID(lid) != savedLHSVector->Map().GID(lid))
{
globalIDsMatch = false;
}
}
if (! globalIDsMatch)
{
cout << "On rank " << commRank << ", loaded and saved solution vector maps differ in their global IDs.\n";
}
else
{
cout << "On rank " << commRank << ", loaded and saved solution vector maps match in their global IDs.\n";
}
bool entriesMatch = true;
double tol = 1e-16;
if (loadedLHSVector->Map().MinLID() != loadedLHSVector->Map().MaxLID())
{
for (int lid = loadedLHSVector->Map().MinLID(); lid <= loadedLHSVector->Map().MaxLID(); lid++)
{
double loadedValue = (*loadedLHSVector)[0][lid];
double savedValue = (*savedLHSVector)[0][lid];
double diff = abs( loadedValue - savedValue );
if (diff > tol)
{
entriesMatch = false;
cout << "On rank " << commRank << ", loaded and saved solution vectors differ in entry with lid " << lid;
cout << "; loaded value = " << loadedValue << "; saved value = " << savedValue << ".\n";
}
}
if (entriesMatch)
{
cout << "On rank " << commRank << ", loaded and saved solution vectors match!\n";
}
else
{
cout << "On rank " << commRank << ", loaded and saved solution vectors do not match.\n";
}
}
}
HDF5Exporter exporter(loadedMesh, "SolutionLoaded");
// exporter.exportSolution(loadedSolution, vf, 0, 2, cellIDToSubdivision(loadedMesh, 4));
exporter.exportSolution(loadedSolution, 0, 2);
}
}
// {
// // 3D tests
// CellTopoPtrLegacy hex = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() ));
// // let's draw a little box
// vector<double> v0 = makeVertex(0,0,0);
// vector<double> v1 = makeVertex(1,0,0);
// vector<double> v2 = makeVertex(1,1,0);
// vector<double> v3 = makeVertex(0,1,0);
// vector<double> v4 = makeVertex(0,0,1);
// vector<double> v5 = makeVertex(1,0,1);
// vector<double> v6 = makeVertex(1,1,1);
// vector<double> v7 = makeVertex(0,1,1);
// vector< vector<double> > vertices;
// vertices.push_back(v0);
// vertices.push_back(v1);
// vertices.push_back(v2);
// vertices.push_back(v3);
// vertices.push_back(v4);
// vertices.push_back(v5);
// vertices.push_back(v6);
// vertices.push_back(v7);
// vector<unsigned> hexVertexList;
// hexVertexList.push_back(0);
// hexVertexList.push_back(1);
// hexVertexList.push_back(2);
// hexVertexList.push_back(3);
// hexVertexList.push_back(4);
// hexVertexList.push_back(5);
// hexVertexList.push_back(6);
// hexVertexList.push_back(7);
// // vector<unsigned> triVertexList;
// // triVertexList.push_back(2);
// // triVertexList.push_back(3);
// // triVertexList.push_back(4);
// vector< vector<unsigned> > elementVertices;
// elementVertices.push_back(hexVertexList);
// // elementVertices.push_back(triVertexList);
// vector< CellTopoPtrLegacy > cellTopos;
// cellTopos.push_back(hex);
// // cellTopos.push_back(tri_3);
// MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
// MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
// FunctionPtr x = Function::xn(1);
// FunctionPtr y = Function::yn(1);
// FunctionPtr z = Function::zn(1);
// FunctionPtr function = x + y + z;
// FunctionPtr fbdr = Function::restrictToCellBoundary(function);
// FunctionPtr vect = Function::vectorize(x, y, z);
// vector<FunctionPtr> functions;
// functions.push_back(function);
// functions.push_back(vect);
// vector<string> functionNames;
// functionNames.push_back("function");
// functionNames.push_back("vect");
// // {
// // HDF5Exporter exporter(mesh, "function3", false);
// // exporter.exportFunction(function, "function3");
// // }
// // {
// // HDF5Exporter exporter(mesh, "boundary3", false);
// // exporter.exportFunction(fbdr, "boundary3");
// // }
// // {
// // HDF5Exporter exporter(mesh, "vect3", false);
// // exporter.exportFunction(vect, "vect3");
// // }
// // {
// // HDF5Exporter exporter(mesh, "functions3", false);
// // exporter.exportFunction(functions, functionNames);
// // }
// }
}
// tests to make sure that the rieszNorm computed via matrices is the same as the one computed thru direct integration
bool ScratchPadTests::testRieszIntegration()
{
double tol = 1e-11;
bool success = true;
int nCells = 2;
double eps = .25;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// just H1 projection
ip->addTerm(v->grad());
ip->addTerm(v);
ip->addTerm(tau);
ip->addTerm(tau->div());
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr squareBoundary = Teuchos::rcp( new SquareBoundary );
bc->addDirichlet(uhat, squareBoundary, zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
LinearTermPtr lt = Teuchos::rcp(new LinearTerm);
FunctionPtr fxn = Function::xn(1); // fxn = x
lt->addTerm(fxn*v + fxn->grad()*v->grad());
lt->addTerm(fxn*tau->x() + fxn*tau->y() + (fxn->dx() + fxn->dy())*tau->div());
Teuchos::RCP<RieszRep> rieszLT = Teuchos::rcp(new RieszRep(mesh, ip, lt));
rieszLT->computeRieszRep();
double rieszNorm = rieszLT->getNorm();
FunctionPtr e_v = RieszRep::repFunction(v,rieszLT);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszLT);
map<int,FunctionPtr> repFxns;
repFxns[v->ID()] = e_v;
repFxns[tau->ID()] = e_tau;
double integratedNorm = sqrt((lt->evaluate(repFxns,false))->integrate(mesh,5,true));
success = abs(rieszNorm-integratedNorm)<tol;
if (success==false)
{
cout << "Failed testRieszIntegration; riesz norm is computed to be = " << rieszNorm << ", while using integration it's computed to be " << integratedNorm << endl;
return success;
}
return success;
}
int main(int argc, char *argv[])
{
int rank = 0;
#ifdef HAVE_MPI
// TODO: figure out the right thing to do here...
// may want to modify argc and argv before we make the following call:
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
rank=mpiSession.getRank();
#else
#endif
bool useLineSearch = false;
int pToAdd = 2; // for optimal test function approximation
int pToAddForStreamFunction = 2;
double nonlinearStepSize = 1.0;
double dt = 0.5;
double nonlinearRelativeEnergyTolerance = 0.015; // used to determine convergence of the nonlinear solution
// double nonlinearRelativeEnergyTolerance = 0.15; // used to determine convergence of the nonlinear solution
double eps = 1.0/64.0; // width of ramp up to 1.0 for top BC; eps == 0 ==> soln not in H1
// epsilon above is chosen to match our initial 16x16 mesh, to avoid quadrature errors.
// double eps = 0.0; // John Evans's problem: not in H^1
bool enforceLocalConservation = false;
bool enforceOneIrregularity = true;
bool reportPerCellErrors = true;
bool useMumps = true;
int horizontalCells, verticalCells;
int maxIters = 50; // for nonlinear steps
vector<double> ReValues;
// usage: polyOrder [numRefinements]
// parse args:
if (argc < 6)
{
cout << "Usage: NavierStokesCavityFlowContinuationFixedMesh fieldPolyOrder hCells vCells energyErrorGoal Re0 [Re1 ...]\n";
return -1;
}
int polyOrder = atoi(argv[1]);
horizontalCells = atoi(argv[2]);
verticalCells = atoi(argv[3]);
double energyErrorGoal = atof(argv[4]);
for (int i=5; i<argc; i++)
{
ReValues.push_back(atof(argv[i]));
}
if (rank == 0)
{
cout << "L^2 order: " << polyOrder << endl;
cout << "initial mesh size: " << horizontalCells << " x " << verticalCells << endl;
cout << "energy error goal: " << energyErrorGoal << endl;
cout << "Reynolds number values for continuation:\n";
for (int i=0; i<ReValues.size(); i++)
{
cout << ReValues[i] << ", ";
}
cout << endl;
}
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
// define meshes:
int H1Order = polyOrder + 1;
bool useTriangles = false;
bool meshHasTriangles = useTriangles;
double minL2Increment = 1e-8;
// get variable definitions:
VarFactory varFactory = VGPStokesFormulation::vgpVarFactory();
u1 = varFactory.fieldVar(VGP_U1_S);
u2 = varFactory.fieldVar(VGP_U2_S);
sigma11 = varFactory.fieldVar(VGP_SIGMA11_S);
sigma12 = varFactory.fieldVar(VGP_SIGMA12_S);
sigma21 = varFactory.fieldVar(VGP_SIGMA21_S);
sigma22 = varFactory.fieldVar(VGP_SIGMA22_S);
p = varFactory.fieldVar(VGP_P_S);
u1hat = varFactory.traceVar(VGP_U1HAT_S);
u2hat = varFactory.traceVar(VGP_U2HAT_S);
t1n = varFactory.fluxVar(VGP_T1HAT_S);
t2n = varFactory.fluxVar(VGP_T2HAT_S);
v1 = varFactory.testVar(VGP_V1_S, HGRAD);
v2 = varFactory.testVar(VGP_V2_S, HGRAD);
tau1 = varFactory.testVar(VGP_TAU1_S, HDIV);
tau2 = varFactory.testVar(VGP_TAU2_S, HDIV);
q = varFactory.testVar(VGP_Q_S, HGRAD);
FunctionPtr u1_0 = Teuchos::rcp( new U1_0(eps) );
FunctionPtr u2_0 = Teuchos::rcp( new U2_0 );
FunctionPtr zero = Function::zero();
ParameterFunctionPtr Re_param = ParameterFunction::parameterFunction(1);
VGPNavierStokesProblem problem = VGPNavierStokesProblem(Re_param,quadPoints,
horizontalCells,verticalCells,
H1Order, pToAdd,
u1_0, u2_0, // BC for u
zero, zero); // zero forcing function
SolutionPtr solution = problem.backgroundFlow();
SolutionPtr solnIncrement = problem.solutionIncrement();
Teuchos::RCP<Mesh> mesh = problem.mesh();
mesh->registerSolution(solution);
mesh->registerSolution(solnIncrement);
///////////////////////////////////////////////////////////////////////////
// define bilinear form for stream function:
VarFactory streamVarFactory;
VarPtr phi_hat = streamVarFactory.traceVar("\\widehat{\\phi}");
VarPtr psin_hat = streamVarFactory.fluxVar("\\widehat{\\psi}_n");
VarPtr psi_1 = streamVarFactory.fieldVar("\\psi_1");
VarPtr psi_2 = streamVarFactory.fieldVar("\\psi_2");
VarPtr phi = streamVarFactory.fieldVar("\\phi");
VarPtr q_s = streamVarFactory.testVar("q_s", HGRAD);
VarPtr v_s = streamVarFactory.testVar("v_s", HDIV);
BFPtr streamBF = Teuchos::rcp( new BF(streamVarFactory) );
streamBF->addTerm(psi_1, q_s->dx());
streamBF->addTerm(psi_2, q_s->dy());
streamBF->addTerm(-psin_hat, q_s);
streamBF->addTerm(psi_1, v_s->x());
streamBF->addTerm(psi_2, v_s->y());
streamBF->addTerm(phi, v_s->div());
streamBF->addTerm(-phi_hat, v_s->dot_normal());
Teuchos::RCP<Mesh> streamMesh, overkillMesh;
streamMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
streamBF, H1Order+pToAddForStreamFunction,
H1Order+pToAdd+pToAddForStreamFunction, useTriangles);
mesh->registerObserver(streamMesh); // will refine streamMesh in the same way as mesh.
map<int, double> dofsToL2error; // key: numGlobalDofs, value: total L2error compared with overkill
vector< VarPtr > fields;
fields.push_back(u1);
fields.push_back(u2);
fields.push_back(sigma11);
fields.push_back(sigma12);
fields.push_back(sigma21);
fields.push_back(sigma22);
fields.push_back(p);
if (rank == 0)
{
cout << "Starting mesh has " << horizontalCells << " x " << verticalCells << " elements and ";
cout << mesh->numGlobalDofs() << " total dofs.\n";
cout << "polyOrder = " << polyOrder << endl;
cout << "pToAdd = " << pToAdd << endl;
cout << "eps for top BC = " << eps << endl;
if (useTriangles)
{
cout << "Using triangles.\n";
}
if (enforceLocalConservation)
{
cout << "Enforcing local conservation.\n";
}
else
{
cout << "NOT enforcing local conservation.\n";
}
if (enforceOneIrregularity)
{
cout << "Enforcing 1-irregularity.\n";
}
else
{
cout << "NOT enforcing 1-irregularity.\n";
}
}
//////////////////// CREATE BCs ///////////////////////
SpatialFilterPtr entireBoundary = Teuchos::rcp( new SpatialFilterUnfiltered );
FunctionPtr u1_prev = Function::solution(u1,solution);
FunctionPtr u2_prev = Function::solution(u2,solution);
FunctionPtr u1hat_prev = Function::solution(u1hat,solution);
FunctionPtr u2hat_prev = Function::solution(u2hat,solution);
//////////////////// SOLVE & REFINE ///////////////////////
FunctionPtr vorticity = Teuchos::rcp( new PreviousSolutionFunction(solution, - u1->dy() + u2->dx() ) );
// FunctionPtr vorticity = Teuchos::rcp( new PreviousSolutionFunction(solution,sigma12 - sigma21) );
RHSPtr streamRHS = RHS::rhs();
streamRHS->addTerm(vorticity * q_s);
((PreviousSolutionFunction*) vorticity.get())->setOverrideMeshCheck(true);
((PreviousSolutionFunction*) u1_prev.get())->setOverrideMeshCheck(true);
((PreviousSolutionFunction*) u2_prev.get())->setOverrideMeshCheck(true);
BCPtr streamBC = BC::bc();
// streamBC->addDirichlet(psin_hat, entireBoundary, u0_cross_n);
streamBC->addDirichlet(phi_hat, entireBoundary, zero);
// streamBC->addZeroMeanConstraint(phi);
IPPtr streamIP = Teuchos::rcp( new IP );
streamIP->addTerm(q_s);
streamIP->addTerm(q_s->grad());
streamIP->addTerm(v_s);
streamIP->addTerm(v_s->div());
SolutionPtr streamSolution = Teuchos::rcp( new Solution( streamMesh, streamBC, streamRHS, streamIP ) );
if (enforceLocalConservation)
{
FunctionPtr zero = Function::zero();
solution->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y()==zero);
solnIncrement->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y()==zero);
}
if (true)
{
FunctionPtr u1_incr = Function::solution(u1, solnIncrement);
FunctionPtr u2_incr = Function::solution(u2, solnIncrement);
FunctionPtr sigma11_incr = Function::solution(sigma11, solnIncrement);
FunctionPtr sigma12_incr = Function::solution(sigma12, solnIncrement);
FunctionPtr sigma21_incr = Function::solution(sigma21, solnIncrement);
FunctionPtr sigma22_incr = Function::solution(sigma22, solnIncrement);
FunctionPtr p_incr = Function::solution(p, solnIncrement);
FunctionPtr l2_incr = u1_incr * u1_incr + u2_incr * u2_incr + p_incr * p_incr
+ sigma11_incr * sigma11_incr + sigma12_incr * sigma12_incr
+ sigma21_incr * sigma21_incr + sigma22_incr * sigma22_incr;
double energyThreshold = 0.20;
Teuchos::RCP< RefinementStrategy > refinementStrategy = Teuchos::rcp( new RefinementStrategy( solnIncrement, energyThreshold ));
for (int i=0; i<ReValues.size(); i++)
{
double Re = ReValues[i];
Re_param->setValue(Re);
if (rank==0) cout << "Solving with Re = " << Re << ":\n";
double energyErrorTotal;
do
{
double incr_norm;
do
{
problem.iterate(useLineSearch);
incr_norm = sqrt(l2_incr->integrate(problem.mesh()));
if (rank==0)
{
cout << "\x1B[2K"; // Erase the entire current line.
cout << "\x1B[0E"; // Move to the beginning of the current line.
cout << "Iteration: " << problem.iterationCount() << "; L^2(incr) = " << incr_norm;
flush(cout);
}
}
while ((incr_norm > minL2Increment ) && (problem.iterationCount() < maxIters));
if (rank==0) cout << endl;
problem.setIterationCount(1); // 1 means reuse background flow (which we must, given that we want continuation in Re...)
energyErrorTotal = solnIncrement->energyErrorTotal(); //solution->energyErrorTotal();
if (energyErrorTotal > energyErrorGoal)
{
refinementStrategy->refine(false);
}
if (rank==0)
{
cout << "Energy error: " << energyErrorTotal << endl;
}
}
while (energyErrorTotal > energyErrorGoal);
}
}
double energyErrorTotal = solution->energyErrorTotal();
double incrementalEnergyErrorTotal = solnIncrement->energyErrorTotal();
if (rank == 0)
{
cout << "final mesh has " << mesh->numActiveElements() << " elements and " << mesh->numGlobalDofs() << " dofs.\n";
cout << "energy error: " << energyErrorTotal << endl;
cout << " (Incremental solution's energy error is " << incrementalEnergyErrorTotal << ".)\n";
}
FunctionPtr u1_sq = u1_prev * u1_prev;
FunctionPtr u_dot_u = u1_sq + (u2_prev * u2_prev);
FunctionPtr u_mag = Teuchos::rcp( new SqrtFunction( u_dot_u ) );
FunctionPtr u_div = Teuchos::rcp( new PreviousSolutionFunction(solution, u1->dx() + u2->dy() ) );
FunctionPtr massFlux = Teuchos::rcp( new PreviousSolutionFunction(solution, u1hat->times_normal_x() + u2hat->times_normal_y()) );
// check that the zero mean pressure is being correctly imposed:
FunctionPtr p_prev = Teuchos::rcp( new PreviousSolutionFunction(solution,p) );
double p_avg = p_prev->integrate(mesh);
if (rank==0)
cout << "Integral of pressure: " << p_avg << endl;
// integrate massFlux over each element (a test):
// fake a new bilinear form so we can integrate against 1
VarPtr testOne = varFactory.testVar("1",CONSTANT_SCALAR);
BFPtr fakeBF = Teuchos::rcp( new BF(varFactory) );
LinearTermPtr massFluxTerm = massFlux * testOne;
CellTopoPtrLegacy quadTopoPtr = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ));
DofOrderingFactory dofOrderingFactory(fakeBF);
int fakeTestOrder = H1Order;
DofOrderingPtr testOrdering = dofOrderingFactory.testOrdering(fakeTestOrder, *quadTopoPtr);
int testOneIndex = testOrdering->getDofIndex(testOne->ID(),0);
vector< ElementTypePtr > elemTypes = mesh->elementTypes(); // global element types
map<int, double> massFluxIntegral; // cellID -> integral
double maxMassFluxIntegral = 0.0;
double totalMassFlux = 0.0;
double totalAbsMassFlux = 0.0;
double maxCellMeasure = 0;
double minCellMeasure = 1;
for (vector< ElementTypePtr >::iterator elemTypeIt = elemTypes.begin(); elemTypeIt != elemTypes.end(); elemTypeIt++)
{
ElementTypePtr elemType = *elemTypeIt;
vector< ElementPtr > elems = mesh->elementsOfTypeGlobal(elemType);
vector<GlobalIndexType> cellIDs;
for (int i=0; i<elems.size(); i++)
{
cellIDs.push_back(elems[i]->cellID());
}
FieldContainer<double> physicalCellNodes = mesh->physicalCellNodesGlobal(elemType);
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType,mesh,polyOrder) ); // enrich by trial space order
basisCache->setPhysicalCellNodes(physicalCellNodes,cellIDs,true); // true: create side caches
FieldContainer<double> cellMeasures = basisCache->getCellMeasures();
FieldContainer<double> fakeRHSIntegrals(elems.size(),testOrdering->totalDofs());
massFluxTerm->integrate(fakeRHSIntegrals,testOrdering,basisCache,true); // true: force side evaluation
// cout << "fakeRHSIntegrals:\n" << fakeRHSIntegrals;
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
// pick out the ones for testOne:
massFluxIntegral[cellID] = fakeRHSIntegrals(i,testOneIndex);
}
// find the largest:
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
}
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
maxCellMeasure = max(maxCellMeasure,cellMeasures(i));
minCellMeasure = min(minCellMeasure,cellMeasures(i));
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
totalMassFlux += massFluxIntegral[cellID];
totalAbsMassFlux += abs( massFluxIntegral[cellID] );
}
}
if (rank==0)
{
cout << "largest mass flux: " << maxMassFluxIntegral << endl;
cout << "total mass flux: " << totalMassFlux << endl;
cout << "sum of mass flux absolute value: " << totalAbsMassFlux << endl;
cout << "largest h: " << sqrt(maxCellMeasure) << endl;
cout << "smallest h: " << sqrt(minCellMeasure) << endl;
cout << "ratio of largest / smallest h: " << sqrt(maxCellMeasure) / sqrt(minCellMeasure) << endl;
}
if (rank == 0)
{
cout << "phi ID: " << phi->ID() << endl;
cout << "psi1 ID: " << psi_1->ID() << endl;
cout << "psi2 ID: " << psi_2->ID() << endl;
cout << "streamMesh has " << streamMesh->numActiveElements() << " elements.\n";
cout << "solving for approximate stream function...\n";
}
streamSolution->solve(useMumps);
energyErrorTotal = streamSolution->energyErrorTotal();
if (rank == 0)
{
cout << "...solved.\n";
cout << "Stream mesh has energy error: " << energyErrorTotal << endl;
}
if (rank==0)
{
solution->writeToVTK("nsCavitySoln.vtk");
if (! meshHasTriangles )
{
massFlux->writeBoundaryValuesToMATLABFile(solution->mesh(), "massFlux.dat");
u_mag->writeValuesToMATLABFile(solution->mesh(), "u_mag.m");
u_div->writeValuesToMATLABFile(solution->mesh(), "u_div.m");
solution->writeFieldsToFile(u1->ID(), "u1.m");
solution->writeFluxesToFile(u1hat->ID(), "u1_hat.dat");
solution->writeFieldsToFile(u2->ID(), "u2.m");
solution->writeFluxesToFile(u2hat->ID(), "u2_hat.dat");
solution->writeFieldsToFile(p->ID(), "p.m");
streamSolution->writeFieldsToFile(phi->ID(), "phi.m");
streamSolution->writeFluxesToFile(phi_hat->ID(), "phi_hat.dat");
streamSolution->writeFieldsToFile(psi_1->ID(), "psi1.m");
streamSolution->writeFieldsToFile(psi_2->ID(), "psi2.m");
vorticity->writeValuesToMATLABFile(streamMesh, "vorticity.m");
FunctionPtr ten = Teuchos::rcp( new ConstantScalarFunction(10) );
ten->writeBoundaryValuesToMATLABFile(solution->mesh(), "skeleton.dat");
cout << "wrote files: u_mag.m, u_div.m, u1.m, u1_hat.dat, u2.m, u2_hat.dat, p.m, phi.m, vorticity.m.\n";
}
else
{
solution->writeToFile(u1->ID(), "u1.dat");
solution->writeToFile(u2->ID(), "u2.dat");
solution->writeToFile(u2->ID(), "p.dat");
cout << "wrote files: u1.dat, u2.dat, p.dat\n";
}
FieldContainer<double> points = pointGrid(0, 1, 0, 1, 100);
FieldContainer<double> pointData = solutionData(points, streamSolution, phi);
GnuPlotUtil::writeXYPoints("phi_patch_navierStokes_cavity.dat", pointData);
set<double> patchContourLevels = diagonalContourLevels(pointData,1);
vector<string> patchDataPath;
patchDataPath.push_back("phi_patch_navierStokes_cavity.dat");
GnuPlotUtil::writeContourPlotScript(patchContourLevels, patchDataPath, "lidCavityNavierStokes.p");
GnuPlotUtil::writeExactMeshSkeleton("lid_navierStokes_continuation_adaptive", mesh, 2);
writePatchValues(0, 1, 0, 1, streamSolution, phi, "phi_patch.m");
writePatchValues(0, .1, 0, .1, streamSolution, phi, "phi_patch_detail.m");
writePatchValues(0, .01, 0, .01, streamSolution, phi, "phi_patch_minute_detail.m");
writePatchValues(0, .001, 0, .001, streamSolution, phi, "phi_patch_minute_minute_detail.m");
}
return 0;
}
void Boundary::bcsToImpose( map< GlobalIndexType, Scalar > &globalDofIndicesAndValues, TBC<Scalar> &bc,
GlobalIndexType cellID, DofInterpreter* dofInterpreter)
{
// this is where we actually compute the BCs; the other bcsToImpose variants call this one.
CellPtr cell = _mesh->getTopology()->getCell(cellID);
// define a couple of important inner products:
TIPPtr<Scalar> ipL2 = Teuchos::rcp( new TIP<Scalar> );
TIPPtr<Scalar> ipH1 = Teuchos::rcp( new TIP<Scalar> );
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr trace = varFactory->traceVar("trace");
VarPtr flux = varFactory->traceVar("flux");
ipL2->addTerm(flux);
ipH1->addTerm(trace);
ipH1->addTerm(trace->grad());
ElementTypePtr elemType = _mesh->getElementType(cellID);
DofOrderingPtr trialOrderingPtr = elemType->trialOrderPtr;
vector< int > trialIDs = _mesh->bilinearForm()->trialIDs();
vector<unsigned> boundarySides = cell->boundarySides();
if (boundarySides.size() > 0)
{
BasisCachePtr basisCache = BasisCache::basisCacheForCell(_mesh, cellID);
for (vector< int >::iterator trialIt = trialIDs.begin(); trialIt != trialIDs.end(); trialIt++)
{
int trialID = *(trialIt);
if ( bc.bcsImposed(trialID) )
{
// // DEBUGGING: keep track of which sides we impose BCs on:
// set<unsigned> bcImposedSides;
//
// Determine global dof indices and values, in one pass per side
for (int i=0; i<boundarySides.size(); i++)
{
unsigned sideOrdinal = boundarySides[i];
// TODO: here, we need to treat the volume basis case.
/*
To do this:
1. (Determine which dofs in the basis have support on the side.)
2. (Probably should resize dirichletValues to match number of dofs with support on the side.)
3. (Within coefficientsForBC, and the projection method it calls, when it's a side cache, check whether the basis being projected has a higher dimension. If so, do the same determination regarding the support of basis on the side as #1.)
4. DofInterpreter::interpretLocalBasisCoefficients() needs to handle the case that trialID has volume support, and in this case interpret the provided data appropriately.
*/
BasisPtr basis;
int numDofsSide;
if (trialOrderingPtr->getSidesForVarID(trialID).size() == 1)
{
// volume basis
basis = trialOrderingPtr->getBasis(trialID);
// get the dof ordinals for the side (interpreted as a "continuous" basis)
numDofsSide = basis->dofOrdinalsForSide(sideOrdinal).size();
}
else if (! trialOrderingPtr->hasBasisEntry(trialID, sideOrdinal))
{
continue;
}
else
{
basis = trialOrderingPtr->getBasis(trialID,sideOrdinal);
numDofsSide = basis->getCardinality();
}
GlobalIndexType numCells = 1;
if (numCells > 0)
{
FieldContainer<double> dirichletValues(numCells,numDofsSide);
// project bc function onto side basis:
BCPtr bcPtr = Teuchos::rcp(&bc, false);
Teuchos::RCP<BCFunction<double>> bcFunction = BCFunction<double>::bcFunction(bcPtr, trialID);
bcPtr->coefficientsForBC(dirichletValues, bcFunction, basis, basisCache->getSideBasisCache(sideOrdinal));
dirichletValues.resize(numDofsSide);
if (bcFunction->imposeOnCell(0))
{
FieldContainer<double> globalData;
FieldContainer<GlobalIndexType> globalDofIndices;
dofInterpreter->interpretLocalBasisCoefficients(cellID, trialID, sideOrdinal, dirichletValues, globalData, globalDofIndices);
for (int globalDofOrdinal=0; globalDofOrdinal<globalDofIndices.size(); globalDofOrdinal++)
{
GlobalIndexType globalDofIndex = globalDofIndices(globalDofOrdinal);
Scalar value = globalData(globalDofOrdinal);
// sanity check: if this has been previously set, do the two values roughly agree?
if (globalDofIndicesAndValues.find(globalDofIndex) != globalDofIndicesAndValues.end())
{
double tol = 1e-10;
Scalar prevValue = globalDofIndicesAndValues[globalDofIndex];
double absDiff = abs(prevValue - value);
if (absDiff > tol)
{
double relativeDiff = absDiff / max(abs(prevValue),abs(value));
int rank = _mesh->Comm()->MyPID();
if (relativeDiff > tol)
{
cout << "WARNING: in Boundary::bcsToImpose(), inconsistent values for BC: " << prevValue << " and ";
cout << value << " prescribed for global dof index " << globalDofIndex;
cout << " on rank " << rank << endl;
}
}
}
globalDofIndicesAndValues[globalDofIndex] = value;
}
}
}
}
}
}
}
}
int main(int argc, char *argv[])
{
#ifdef ENABLE_INTEL_FLOATING_POINT_EXCEPTIONS
cout << "NOTE: enabling floating point exceptions for divide by zero.\n";
_MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~_MM_MASK_INVALID);
#endif
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int rank = Teuchos::GlobalMPISession::getRank();
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
//cout << "rank: " << rank << " of " << numProcs << endl;
#else
Epetra_SerialComm Comm;
#endif
Comm.Barrier(); // set breakpoint here to allow debugger attachment to other MPI processes than the one you automatically attached to.
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
double minTol = 1e-8;
bool use3D = false;
int refCount = 10;
int k = 4; // poly order for field variables
int delta_k = use3D ? 3 : 2; // test space enrichment
int k_coarse = 0;
bool useMumps = true;
bool useGMGSolver = true;
bool enforceOneIrregularity = true;
bool useStaticCondensation = false;
bool conformingTraces = false;
bool useDiagonalScaling = false; // of the global stiffness matrix in GMGSolver
bool printRefinementDetails = false;
bool useWeightedGraphNorm = true; // graph norm scaled according to units, more or less
int numCells = 2;
int AztecOutputLevel = 1;
int gmgMaxIterations = 10000;
int smootherOverlap = 0;
double relativeTol = 1e-6;
double D = 1.0; // characteristic length scale
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("k_coarse", &k_coarse, "polynomial order for field variables on coarse mesh");
cmdp.setOption("numRefs",&refCount,"number of refinements");
cmdp.setOption("D", &D, "domain dimension");
cmdp.setOption("useConformingTraces", "useNonConformingTraces", &conformingTraces);
cmdp.setOption("enforceOneIrregularity", "dontEnforceOneIrregularity", &enforceOneIrregularity);
cmdp.setOption("smootherOverlap", &smootherOverlap, "overlap for smoother");
cmdp.setOption("printRefinementDetails", "dontPrintRefinementDetails", &printRefinementDetails);
cmdp.setOption("azOutput", &AztecOutputLevel, "Aztec output level");
cmdp.setOption("numCells", &numCells, "number of cells in the initial mesh");
cmdp.setOption("useScaledGraphNorm", "dontUseScaledGraphNorm", &useWeightedGraphNorm);
// cmdp.setOption("gmgTol", &gmgTolerance, "tolerance for GMG convergence");
cmdp.setOption("relativeTol", &relativeTol, "Energy error-relative tolerance for iterative solver.");
cmdp.setOption("gmgMaxIterations", &gmgMaxIterations, "tolerance for GMG convergence");
bool enhanceUField = false;
cmdp.setOption("enhanceUField", "dontEnhanceUField", &enhanceUField);
cmdp.setOption("useStaticCondensation", "dontUseStaticCondensation", &useStaticCondensation);
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
double width = D, height = D, depth = D;
VarFactory varFactory;
// fields:
VarPtr u = varFactory.fieldVar("u", L2);
VarPtr sigma = varFactory.fieldVar("\\sigma", VECTOR_L2);
FunctionPtr n = Function::normal();
// traces:
VarPtr u_hat;
if (conformingTraces)
{
u_hat = varFactory.traceVar("\\widehat{u}", u);
}
else
{
cout << "Note: using non-conforming traces.\n";
u_hat = varFactory.traceVar("\\widehat{u}", u, L2);
}
VarPtr sigma_n_hat = varFactory.fluxVar("\\widehat{\\sigma}_{n}", sigma * n);
// test functions:
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
BFPtr poissonBF = Teuchos::rcp( new BF(varFactory) );
FunctionPtr alpha = Function::constant(1); // viscosity
// tau terms:
poissonBF->addTerm(sigma / alpha, tau);
poissonBF->addTerm(-u, tau->div()); // (sigma1, tau1)
poissonBF->addTerm(u_hat, tau * n);
// v terms:
poissonBF->addTerm(- sigma, v->grad()); // (mu sigma1, grad v1)
poissonBF->addTerm( sigma_n_hat, v);
int horizontalCells = numCells, verticalCells = numCells, depthCells = numCells;
vector<double> domainDimensions;
domainDimensions.push_back(width);
domainDimensions.push_back(height);
vector<int> elementCounts;
elementCounts.push_back(horizontalCells);
elementCounts.push_back(verticalCells);
if (use3D)
{
domainDimensions.push_back(depth);
elementCounts.push_back(depthCells);
}
MeshPtr mesh, k0Mesh;
int H1Order = k + 1;
int H1Order_coarse = k_coarse + 1;
if (!use3D)
{
Teuchos::ParameterList pl;
map<int,int> trialOrderEnhancements;
if (enhanceUField)
{
trialOrderEnhancements[u->ID()] = 1;
}
BFPtr poissonBilinearForm = poissonBF;
pl.set("useMinRule", true);
pl.set("bf",poissonBilinearForm);
pl.set("H1Order", H1Order);
pl.set("delta_k", delta_k);
pl.set("horizontalElements", horizontalCells);
pl.set("verticalElements", verticalCells);
pl.set("divideIntoTriangles", false);
pl.set("useConformingTraces", conformingTraces);
pl.set("trialOrderEnhancements", &trialOrderEnhancements);
pl.set("x0",(double)0);
pl.set("y0",(double)0);
pl.set("width", width);
pl.set("height",height);
mesh = MeshFactory::quadMesh(pl);
pl.set("H1Order", H1Order_coarse);
k0Mesh = MeshFactory::quadMesh(pl);
}
else
{
mesh = MeshFactory::rectilinearMesh(poissonBF, domainDimensions, elementCounts, H1Order, delta_k);
k0Mesh = MeshFactory::rectilinearMesh(poissonBF, domainDimensions, elementCounts, H1Order_coarse, delta_k);
}
mesh->registerObserver(k0Mesh); // ensure that the k0 mesh refinements track those of the solution mesh
RHSPtr rhs = RHS::rhs(); // zero
FunctionPtr sin_pi_x = Teuchos::rcp( new Sin_ax(PI/D) );
FunctionPtr sin_pi_y = Teuchos::rcp( new Sin_ay(PI/D) );
FunctionPtr u_exact = sin_pi_x * sin_pi_y;
FunctionPtr f = -(2.0 * PI * PI / (D * D)) * sin_pi_x * sin_pi_y;
rhs->addTerm( f * v );
BCPtr bc = BC::bc();
SpatialFilterPtr boundary = SpatialFilter::allSpace();
bc->addDirichlet(u_hat, boundary, u_exact);
IPPtr graphNorm;
FunctionPtr h = Teuchos::rcp( new hFunction() );
if (useWeightedGraphNorm)
{
graphNorm = IP::ip();
graphNorm->addTerm( tau->div() ); // u
graphNorm->addTerm( (h / alpha) * tau - h * v->grad() ); // sigma
graphNorm->addTerm( v ); // boundary term (adjoint to u)
graphNorm->addTerm( h * tau );
// // new effort, with the idea that the test norm should be considered in reference space, basically
// graphNorm = IP::ip();
// graphNorm->addTerm( tau->div() ); // u
// graphNorm->addTerm( tau / h - v->grad() ); // sigma
// graphNorm->addTerm( v / h ); // boundary term (adjoint to u)
// graphNorm->addTerm( tau / h );
}
else
{
map<int, double> trialWeights; // on the squared terms in the trial space norm
trialWeights[u->ID()] = 1.0 / (D * D);
trialWeights[sigma->ID()] = 1.0;
graphNorm = poissonBF->graphNorm(trialWeights, 1.0); // 1.0: weight on the L^2 terms
}
SolutionPtr solution = Solution::solution(mesh, bc, rhs, graphNorm);
solution->setUseCondensedSolve(useStaticCondensation);
mesh->registerSolution(solution); // sign up for projection of old solution onto refined cells.
double energyThreshold = 0.2;
RefinementStrategy refinementStrategy( solution, energyThreshold );
refinementStrategy.setReportPerCellErrors(true);
refinementStrategy.setEnforceOneIrregularity(enforceOneIrregularity);
Teuchos::RCP<Solver> coarseSolver, fineSolver;
if (useMumps)
{
#ifdef HAVE_AMESOS_MUMPS
coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#else
cout << "useMumps=true, but MUMPS is not available!\n";
exit(0);
#endif
}
else
{
coarseSolver = Teuchos::rcp( new KluSolver );
}
GMGSolver* gmgSolver;
if (useGMGSolver)
{
double tol = relativeTol;
int maxIters = gmgMaxIterations;
BCPtr zeroBCs = bc->copyImposingZero();
gmgSolver = new GMGSolver(zeroBCs, k0Mesh, graphNorm, mesh, solution->getDofInterpreter(),
solution->getPartitionMap(), maxIters, tol, coarseSolver,
useStaticCondensation);
gmgSolver->setAztecOutput(AztecOutputLevel);
gmgSolver->setUseConjugateGradient(true);
gmgSolver->gmgOperator()->setSmootherType(GMGOperator::IFPACK_ADDITIVE_SCHWARZ);
gmgSolver->gmgOperator()->setSmootherOverlap(smootherOverlap);
fineSolver = Teuchos::rcp( gmgSolver );
}
else
{
fineSolver = coarseSolver;
}
// if (rank==0) cout << "experimentally starting by solving with MUMPS on the fine mesh.\n";
// solution->solve( Teuchos::rcp( new MumpsSolver) );
solution->solve(fineSolver);
#ifdef HAVE_EPETRAEXT_HDF5
ostringstream dir_name;
dir_name << "poissonCavityFlow_k" << k;
HDF5Exporter exporter(mesh,dir_name.str());
exporter.exportSolution(solution,varFactory,0);
#endif
#ifdef HAVE_AMESOS_MUMPS
if (useMumps) coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#endif
solution->reportTimings();
if (useGMGSolver) gmgSolver->gmgOperator()->reportTimings();
for (int refIndex=0; refIndex < refCount; refIndex++)
{
double energyError = solution->energyErrorTotal();
GlobalIndexType numFluxDofs = mesh->numFluxDofs();
if (rank==0)
{
cout << "Before refinement " << refIndex << ", energy error = " << energyError;
cout << " (using " << numFluxDofs << " trace degrees of freedom)." << endl;
}
bool printToConsole = printRefinementDetails && (rank==0);
refinementStrategy.refine(printToConsole);
if (useStaticCondensation)
{
CondensedDofInterpreter* condensedDofInterpreter = dynamic_cast<CondensedDofInterpreter*>(solution->getDofInterpreter().get());
if (condensedDofInterpreter != NULL)
{
condensedDofInterpreter->reinitialize();
}
}
GlobalIndexType fineDofs = mesh->globalDofCount();
GlobalIndexType coarseDofs = k0Mesh->globalDofCount();
if (rank==0)
{
cout << "After refinement, coarse mesh has " << k0Mesh->numActiveElements() << " elements and " << coarseDofs << " dofs.\n";
cout << " Fine mesh has " << mesh->numActiveElements() << " elements and " << fineDofs << " dofs.\n";
}
if (!use3D)
{
ostringstream fineMeshLocation, coarseMeshLocation;
fineMeshLocation << "poissonFineMesh_k" << k << "_ref" << refIndex;
GnuPlotUtil::writeComputationalMeshSkeleton(fineMeshLocation.str(), mesh, true); // true: label cells
coarseMeshLocation << "poissonCoarseMesh_k" << k << "_ref" << refIndex;
GnuPlotUtil::writeComputationalMeshSkeleton(coarseMeshLocation.str(), k0Mesh, true); // true: label cells
}
if (useGMGSolver) // create fresh fineSolver now that the meshes have changed:
{
#ifdef HAVE_AMESOS_MUMPS
if (useMumps) coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#endif
double tol = max(relativeTol * energyError, minTol);
int maxIters = gmgMaxIterations;
BCPtr zeroBCs = bc->copyImposingZero();
gmgSolver = new GMGSolver(zeroBCs, k0Mesh, graphNorm, mesh, solution->getDofInterpreter(),
solution->getPartitionMap(), maxIters, tol, coarseSolver, useStaticCondensation);
gmgSolver->setAztecOutput(AztecOutputLevel);
gmgSolver->setUseDiagonalScaling(useDiagonalScaling);
fineSolver = Teuchos::rcp( gmgSolver );
}
solution->solve(fineSolver);
solution->reportTimings();
if (useGMGSolver) gmgSolver->gmgOperator()->reportTimings();
#ifdef HAVE_EPETRAEXT_HDF5
exporter.exportSolution(solution,varFactory,refIndex+1);
#endif
}
double energyErrorTotal = solution->energyErrorTotal();
GlobalIndexType numFluxDofs = mesh->numFluxDofs();
GlobalIndexType numGlobalDofs = mesh->numGlobalDofs();
if (rank==0)
{
cout << "Final mesh has " << mesh->numActiveElements() << " elements and " << numFluxDofs << " trace dofs (";
cout << numGlobalDofs << " total dofs, including fields).\n";
cout << "Final energy error: " << energyErrorTotal << endl;
}
#ifdef HAVE_EPETRAEXT_HDF5
exporter.exportSolution(solution,varFactory,0);
#endif
if (!use3D)
{
GnuPlotUtil::writeComputationalMeshSkeleton("poissonRefinedMesh", mesh, true);
}
coarseSolver = Teuchos::rcp((Solver*) NULL); // without this when useMumps = true and running on one rank, we see a crash on exit, which may have to do with MPI being finalized before coarseSolver is deleted.
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
Comm.Barrier(); // set breakpoint here to allow debugger attachment to other MPI processes than the one you automatically attached to.
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
// problem parameters:
int spaceDim = 2;
double epsilon = 1e-2;
int numRefs = 0;
int k = 2, delta_k = 2;
int numXElems = 1;
bool useConformingTraces = true;
string solverChoice = "KLU";
string coarseSolverChoice = "KLU"; // often this beats SuperLU_Dist as coarse solver (true on BG/Q with 6000 3D elements on 256 ranks)
double solverTolerance = 1e-6;
string norm = "CoupledRobust";
cmdp.setOption("spaceDim", &spaceDim, "spatial dimension");
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("numRefs",&numRefs,"number of refinements");
cmdp.setOption("numXElems",&numXElems,"number of elements in x direction");
cmdp.setOption("epsilon", &epsilon, "epsilon");
cmdp.setOption("norm", &norm, "norm");
cmdp.setOption("conformingTraces", "nonconformingTraces", &useConformingTraces, "use conforming traces");
cmdp.setOption("coarseSolver", &coarseSolverChoice, "KLU, SuperLU");
cmdp.setOption("solver", &solverChoice, "KLU, SuperLU, MUMPS, GMG-Direct, GMG-ILU, GMG-IC");
cmdp.setOption("solverTolerance", &solverTolerance, "iterative solver tolerance");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
FunctionPtr beta;
FunctionPtr beta_x = Function::constant(1);
FunctionPtr beta_y = Function::constant(2);
FunctionPtr beta_z = Function::constant(3);
if (spaceDim == 1)
beta = beta_x;
else if (spaceDim == 2)
beta = Function::vectorize(beta_x, beta_y);
else if (spaceDim == 3)
beta = Function::vectorize(beta_x, beta_y, beta_z);
ConvectionDiffusionFormulation form(spaceDim, useConformingTraces, beta, epsilon);
// Define right hand side
RHSPtr rhs = RHS::rhs();
// Set up boundary conditions
BCPtr bc = BC::bc();
VarPtr uhat = form.uhat();
VarPtr tc = form.tc();
SpatialFilterPtr inflowX = SpatialFilter::matchingX(-1);
SpatialFilterPtr inflowY = SpatialFilter::matchingY(-1);
SpatialFilterPtr inflowZ = SpatialFilter::matchingZ(-1);
SpatialFilterPtr outflowX = SpatialFilter::matchingX(1);
SpatialFilterPtr outflowY = SpatialFilter::matchingY(1);
SpatialFilterPtr outflowZ = SpatialFilter::matchingZ(1);
FunctionPtr zero = Function::zero();
FunctionPtr one = Function::constant(1);
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr z = Function::zn(1);
if (spaceDim == 1)
{
bc->addDirichlet(tc, inflowX, -one);
bc->addDirichlet(uhat, outflowX, zero);
}
if (spaceDim == 2)
{
bc->addDirichlet(tc, inflowX, -1*.5*(one-y));
bc->addDirichlet(uhat, outflowX, zero);
bc->addDirichlet(tc, inflowY, -2*.5*(one-x));
bc->addDirichlet(uhat, outflowY, zero);
}
if (spaceDim == 3)
{
bc->addDirichlet(tc, inflowX, -1*.25*(one-y)*(one-z));
bc->addDirichlet(uhat, outflowX, zero);
bc->addDirichlet(tc, inflowY, -2*.25*(one-x)*(one-z));
bc->addDirichlet(uhat, outflowY, zero);
bc->addDirichlet(tc, inflowZ, -3*.25*(one-x)*(one-y));
bc->addDirichlet(uhat, outflowZ, zero);
}
// Build mesh
vector<double> x0 = vector<double>(spaceDim,-1.0);
double width = 2.0;
vector<double> dimensions;
vector<int> elementCounts;
for (int d=0; d<spaceDim; d++)
{
dimensions.push_back(width);
elementCounts.push_back(numXElems);
}
MeshPtr mesh = MeshFactory::rectilinearMesh(form.bf(), dimensions, elementCounts, k+1, delta_k, x0);
MeshPtr k0Mesh = Teuchos::rcp( new Mesh (mesh->getTopology()->deepCopy(), form.bf(), 1, delta_k) );
mesh->registerObserver(k0Mesh);
// Set up solution
SolutionPtr soln = Solution::solution(form.bf(), mesh, bc, rhs, form.ip(norm));
double threshold = 0.20;
RefinementStrategy refStrategy(soln, threshold);
ostringstream refName;
refName << "confusion" << spaceDim << "D_" << norm << "_" << epsilon << "_k" << k << "_" << solverChoice;
// HDF5Exporter exporter(mesh,refName.str());
Teuchos::RCP<Time> solverTime = Teuchos::TimeMonitor::getNewCounter("Solve Time");
if (commRank == 0)
Solver::printAvailableSolversReport();
map<string, SolverPtr> solvers;
solvers["KLU"] = Solver::getSolver(Solver::KLU, true);
SolverPtr superluSolver = Solver::getSolver(Solver::SuperLUDist, true);
solvers["SuperLU"] = superluSolver;
int maxIters = 2000;
bool useStaticCondensation = false;
int azOutput = 20; // print residual every 20 CG iterations
ofstream dataFile(refName.str()+".txt");
dataFile << "ref\t " << "elements\t " << "dofs\t " << "error\t " << "solvetime\t" << "iterations\t " << endl;
for (int refIndex=0; refIndex <= numRefs; refIndex++)
{
solverTime->start(true);
Teuchos::RCP<GMGSolver> gmgSolver;
if (solverChoice[0] == 'G')
{
gmgSolver = Teuchos::rcp( new GMGSolver(soln, k0Mesh, maxIters, solverTolerance, solvers[coarseSolverChoice], useStaticCondensation));
gmgSolver->setAztecOutput(azOutput);
if (solverChoice == "GMG-Direct")
gmgSolver->gmgOperator().setSchwarzFactorizationType(GMGOperator::Direct);
if (solverChoice == "GMG-ILU")
gmgSolver->gmgOperator().setSchwarzFactorizationType(GMGOperator::ILU);
if (solverChoice == "GMG-IC")
gmgSolver->gmgOperator().setSchwarzFactorizationType(GMGOperator::IC);
soln->solve(gmgSolver);
}
else
soln->condensedSolve(solvers[solverChoice]);
double solveTime = solverTime->stop();
double energyError = soln->energyErrorTotal();
if (commRank == 0)
{
// if (refIndex > 0)
// refStrategy.printRefinementStatistics(refIndex-1);
if (solverChoice[0] == 'G')
{
cout << "Refinement: " << refIndex
<< " \tElements: " << mesh->numActiveElements()
<< " \tDOFs: " << mesh->numGlobalDofs()
<< " \tEnergy Error: " << energyError
<< " \tSolve Time: " << solveTime
<< " \tIteration Count: " << gmgSolver->iterationCount()
<< endl;
dataFile << refIndex
<< " " << mesh->numActiveElements()
<< " " << mesh->numGlobalDofs()
<< " " << energyError
<< " " << solveTime
<< " " << gmgSolver->iterationCount()
<< endl;
}
else
{
cout << "Refinement: " << refIndex
<< " \tElements: " << mesh->numActiveElements()
<< " \tDOFs: " << mesh->numGlobalDofs()
<< " \tEnergy Error: " << energyError
<< " \tSolve Time: " << solveTime
<< endl;
dataFile << refIndex
<< " " << mesh->numActiveElements()
<< " " << mesh->numGlobalDofs()
<< " " << energyError
<< " " << solveTime
<< endl;
}
}
// exporter.exportSolution(soln, refIndex);
if (refIndex != numRefs)
refStrategy.refine();
}
dataFile.close();
return 0;
}