/* weak form of poisson with Nitsche-type weak BC's */
Expr poissonEquationNitsche( bool splitBC,
Expr u ,
Expr v ,
Expr alpha ,
QuadratureFamily quad )
{
CellFilter interior = new MaximalCellFilter();
CellFilter boundary = new BoundaryCellFilter();
CellFilter left = boundary.subset( new LeftPointTest() );
CellFilter right = boundary.subset( new RightPointTest() );
CellFilter top = boundary.subset( new TopPointTest() );
CellFilter bottom = boundary.subset( new BottomPointTest() );
CellFilter allBdry = left+right+top+bottom;
Expr dx = new Derivative(0);
Expr dy = new Derivative(1);
Expr x = new CoordExpr(0);
Expr y = new CoordExpr(1);
Expr grad = List( dx , dy );
Expr uvTerm;
if (splitBC)
{
Out::os() << "BC expressions split over domains" << std::endl;
uvTerm = Integral( left , alpha*u * v , quad )
+ Integral( right , alpha*u * v , quad )
+ Integral( top , alpha*u * v , quad )
+ Integral( bottom , alpha*u * v , quad );
}
else
{
Out::os() << "BC expressions not split over domains" << std::endl;
uvTerm = Integral( allBdry , alpha*u * v , quad );
}
const double pi = 4.0*atan(1.0);
Expr force = 2.0*pi*pi*sin(pi*x)*sin(pi*y);
return Integral( interior , (grad*v) * (grad*u) - force * v , quad )
/* du/dn term */
- Integral( left , -(dx*u)*v , quad )
- Integral( top , (dy*u)*v , quad )
- Integral( right , (dx*u)*v , quad )
- Integral( bottom , -(dy*u)*v , quad )
/* dv/dn term */
- Integral( left , -(dx*v)*u , quad )
- Integral( top , (dy*v)*u , quad )
- Integral( right , (dx*v)*u , quad )
- Integral( bottom , -(dy*v)*u , quad )
/* u,v term -- alpha = C / h */
+ uvTerm;
}
int main(int argc, char** argv)
{
try
{
Sundance::init(&argc, &argv);
int np = MPIComm::world().getNProc();
// DOFMapBase::classVerbosity() = VerbExtreme;
const double density = 1000.0; // kg/m^3
const double porosity = 0.442; // dimensionless %
const double A = 175.5; // dimensionless fit parameter
const double B = 1.83; // dimensionless fit parameter
const double criticalRe = 36.73; // dimensionless fit parameter
const double dynvisc = 1.31; // kg/(m-s)
const double graindia = 1.9996e-4; // m
const double charvel = 1.0; // m/s
double Reynolds = density*graindia*charvel/(dynvisc*porosity);
Expr Re = new Parameter(Reynolds);
/* We will do our linear algebra using Epetra */
VectorType<double> vecType = new EpetraVectorType();
/* Create a mesh. It will be of type BasisSimplicialMesh, and will
* be built using a PartitionedLineMesher. */
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, 1000.0, 100*np, meshType);
Mesh mesh = mesher.getMesh();
/* Create a cell filter that will identify the maximal cells
* in the interior of the domain */
CellFilter interior = new MaximalCellFilter();
CellFilter points = new DimensionalCellFilter(0);
CellPredicate leftPointFunc = new PositionalCellPredicate(leftPointTest);
CellPredicate rightPointFunc = new PositionalCellPredicate(rightPointTest);
CellFilter leftPoint = points.subset(leftPointFunc);
CellFilter rightPoint = points.subset(rightPointFunc);
/* Create unknown and test functions, discretized using first-order
* Lagrange interpolants */
Expr p = new UnknownFunction(new Lagrange(2), "p");
Expr q = new UnknownFunction(new Lagrange(2), "q");
Expr u = new TestFunction(new Lagrange(2), "u");
Expr v = new TestFunction(new Lagrange(2), "v");
/* Create differential operator and coordinate function */
Expr dx = new Derivative(0);
Expr x = new CoordExpr(0);
/* We need a quadrature rule for doing the integrations */
QuadratureFamily quad = new GaussianQuadrature(4);
/* Define the weak form */
Expr MassEqn = Integral(interior, q*(dx*u), quad)
+ Integral(leftPoint, - q*u,quad)
+ Integral(rightPoint, - q*u,quad);
Expr MomEqn = Integral(interior, (density/porosity)*q*q*(dx*v) + porosity*p*(dx*v) - porosity*q*v*A - (porosity*q*v*B*Re*Re)/((Re+criticalRe)*(1-porosity)), quad)
+ Integral(leftPoint, - density*q*q*v/porosity - porosity*p*v,quad)
+ Integral(rightPoint,- density*q*q*v/porosity - porosity*p*v,quad);
/* Define the Dirichlet BC */
Expr leftbc = EssentialBC(leftPoint, v*(q-charvel), quad);
Expr rightbc = EssentialBC(rightPoint, v*(q-charvel), quad);
/* Create a discrete space, and discretize the function 1.0 on it */
BasisFamily L2 = new Lagrange(2);
Array<BasisFamily> basis = tuple(L2, L2);
DiscreteSpace discSpace(mesh, basis, vecType);
Expr u0 = new DiscreteFunction(discSpace, 1.0, "u0");
Expr p0 = u0[0];
Expr q0 = u0[1];
/* Create a TSF NonlinearOperator object */
std::cerr << "about to make nonlinear object" << std::endl;
std::cerr.flush();
NonlinearOperator<double> F
= new NonlinearProblem(mesh, MassEqn+MomEqn, leftbc+rightbc, Sundance::List(u,v),Sundance::List(p,q) , u0, vecType);
// F.verbosity() = VerbExtreme;
/* Get the initial guess */
Vector<double> x0 = F.getInitialGuess();
/* Create an Aztec solver for solving the linear subproblems */
std::map<int,int> azOptions;
std::map<int,double> azParams;
azOptions[AZ_solver] = AZ_gmres;
azOptions[AZ_precond] = AZ_dom_decomp;
azOptions[AZ_subdomain_solve] = AZ_ilu;
azOptions[AZ_graph_fill] = 1;
azOptions[AZ_max_iter] = 1000;
azParams[AZ_tol] = 1.0e-13;
LinearSolver<double> linSolver = new AztecSolver(azOptions,azParams);
/* Now let's create a NOX solver */
NOX::TSF::Group grp(x0, F, linSolver);
grp.verbosity() = VerbExtreme;
// Set up the status tests
NOX::StatusTest::NormF statusTestA(grp, 1.0e-10);
NOX::StatusTest::MaxIters statusTestB(20);
NOX::StatusTest::Combo statusTestsCombo(NOX::StatusTest::Combo::OR, statusTestA, statusTestB);
// Create the list of solver parameters
NOX::Parameter::List solverParameters;
// Set the solver (this is the default)
solverParameters.setParameter("Nonlinear Solver", "Line Search Based");
// Create the line search parameters sublist
NOX::Parameter::List& lineSearchParameters = solverParameters.sublist("Line Search");
// Set the line search method
lineSearchParameters.setParameter("Method","More'-Thuente");
// Create the solver
NOX::Solver::Manager solver(grp, statusTestsCombo, solverParameters);
// Solve the nonlinear system
NOX::StatusTest::StatusType status = solver.solve();
// Print the answer
cout << "\n" << "-- Parameter List From Solver --" << "\n";
solver.getParameterList().print(cout);
// Get the answer
grp = solver.getSolutionGroup();
// Print the answer
cout << "\n" << "-- Final Solution From Solver --" << "\n";
grp.print();
double tol = 1.0e-12;
Sundance::passFailTest(0, tol);
}
catch(std::exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize(); return Sundance::testStatus();
}
int main(int argc, char** argv)
{
try
{
int nx = 32;
double convTol = 1.0e-8;
double lambda = 0.5;
Sundance::setOption("nx", nx, "Number of elements");
Sundance::setOption("tol", convTol, "Convergence tolerance");
Sundance::setOption("lambda", lambda, "Lambda (parameter in Bratu's equation)");
Sundance::init(&argc, &argv);
Out::root() << "Bratu problem (lambda=" << lambda << ")" << endl;
Out::root() << "Newton's method, linearized by hand" << endl << endl;
VectorType<double> vecType = new EpetraVectorType();
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, nx, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter sides = new DimensionalCellFilter(mesh.spatialDim()-1);
CellFilter left = sides.subset(new CoordinateValueCellPredicate(0, 0.0));
CellFilter right = sides.subset(new CoordinateValueCellPredicate(0, 1.0));
BasisFamily basis = new Lagrange(1);
Expr w = new UnknownFunction(basis, "w");
Expr v = new TestFunction(basis, "v");
Expr grad = gradient(1);
Expr x = new CoordExpr(0);
const double pi = 4.0*atan(1.0);
Expr uExact = sin(pi*x);
Expr R = pi*pi*uExact - lambda*exp(uExact);
QuadratureFamily quad4 = new GaussianQuadrature(4);
QuadratureFamily quad2 = new GaussianQuadrature(2);
DiscreteSpace discSpace(mesh, basis, vecType);
Expr uPrev = new DiscreteFunction(discSpace, 0.5);
Expr stepVal = copyDiscreteFunction(uPrev);
Expr eqn
= Integral(interior, (grad*v)*(grad*w) + (grad*v)*(grad*uPrev)
- v*lambda*exp(uPrev)*(1.0+w) - v*R, quad4);
Expr h = new CellDiameterExpr();
Expr bc = EssentialBC(left+right, v*(uPrev+w)/h, quad2);
LinearProblem prob(mesh, eqn, bc, v, w, vecType);
LinearSolver<double> linSolver
= LinearSolverBuilder::createSolver("amesos.xml");
Out::root() << "Newton iteration" << endl;
int maxIters = 20;
Expr soln ;
bool converged = false;
for (int i=0; i<maxIters; i++)
{
/* solve for the next u */
prob.solve(linSolver, stepVal);
Vector<double> stepVec = getDiscreteFunctionVector(stepVal);
double deltaU = stepVec.norm2();
Out::root() << "Iter=" << setw(3) << i << " ||Delta u||=" << setw(20)
<< deltaU << endl;
addVecToDiscreteFunction(uPrev, stepVec);
if (deltaU < convTol)
{
soln = uPrev;
converged = true;
break;
}
}
TEUCHOS_TEST_FOR_EXCEPTION(!converged, std::runtime_error,
"Newton iteration did not converge after "
<< maxIters << " iterations");
FieldWriter writer = new DSVWriter("HandCodedBratu.dat");
writer.addMesh(mesh);
writer.addField("soln", new ExprFieldWrapper(soln[0]));
writer.write();
Out::root() << "Converged!" << endl << endl;
double L2Err = L2Norm(mesh, interior, soln-uExact, quad4);
Out::root() << "L2 Norm of error: " << L2Err << endl;
Sundance::passFailTest(L2Err, 1.5/((double) nx*nx));
}
catch(std::exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize();
}
bool DuffingFloquet()
{
int np = MPIComm::world().getNProc();
TEUCHOS_TEST_FOR_EXCEPT(np != 1);
const double pi = 4.0*atan(1.0);
/* We will do our linear algebra using Epetra */
VectorType<double> vecType = new EpetraVectorType();
/* Create a periodic mesh */
int nx = 128;
MeshType meshType = new PeriodicMeshType1D();
MeshSource mesher = new PeriodicLineMesher(0.0, 2.0*pi, nx, meshType);
Mesh mesh = mesher.getMesh();
/* Create a cell filter that will identify the maximal cells
* in the interior of the domain */
CellFilter interior = new MaximalCellFilter();
CellFilter pts = new DimensionalCellFilter(0);
CellFilter left = pts.subset(new CoordinateValueCellPredicate(0,0.0));
CellFilter right = pts.subset(new CoordinateValueCellPredicate(0,2.0*pi));
/* Create unknown and test functions, discretized using first-order
* Lagrange interpolants */
Expr u1 = new UnknownFunction(new Lagrange(1), "u1");
Expr u2 = new UnknownFunction(new Lagrange(1), "u2");
Expr v1 = new TestFunction(new Lagrange(1), "v1");
Expr v2 = new TestFunction(new Lagrange(1), "v2");
/* Create differential operator and coordinate function */
Expr dx = new Derivative(0);
Expr x = new CoordExpr(0);
/* We need a quadrature rule for doing the integrations */
QuadratureFamily quad = new GaussianQuadrature(4);
double F0 = 0.5;
double gamma = 2.0/3.0;
double a0 = 1.0;
double w0 = 1.0;
double eps = 0.5;
Expr u1Guess = -0.75*cos(x) + 0.237*sin(x);
Expr u2Guess = 0.237*cos(x) + 0.75*sin(x);
DiscreteSpace discSpace(mesh,
List(new Lagrange(1), new Lagrange(1)),
vecType);
L2Projector proj(discSpace, List(u1Guess, u2Guess));
Expr u0 = proj.project();
Expr rhs1 = u2;
Expr rhs2 = -w0*w0*u1 - gamma*u2 - eps*w0*w0*pow(u1,3.0)/a0/a0
+ F0*w0*w0*sin(x);
/* Define the weak form */
Expr eqn = Integral(interior,
v1*(dx*u1 - rhs1) + v2*(dx*u2 - rhs2),
quad);
Expr dummyBC ;
NonlinearProblem prob(mesh, eqn, dummyBC, List(v1,v2), List(u1,u2),
u0, vecType);
ParameterXMLFileReader reader("nox.xml");
ParameterList solverParams = reader.getParameters();
Out::root() << "finding periodic solution" << endl;
NOXSolver solver(solverParams);
prob.solve(solver);
/* unfold the solution onto a non-periodic mesh */
Expr uP = unfoldPeriodicDiscreteFunction(u0, "u_p");
Out::root() << "uP=" << uP << endl;
Mesh unfoldedMesh = DiscreteFunction::discFunc(uP)->mesh();
DiscreteSpace unfDiscSpace = DiscreteFunction::discFunc(uP)->discreteSpace();
FieldWriter writer = new MatlabWriter("Floquet.dat");
writer.addMesh(unfoldedMesh);
writer.addField("u_p[0]", new ExprFieldWrapper(uP[0]));
writer.addField("u_p[1]", new ExprFieldWrapper(uP[1]));
Array<Expr> a(2);
a[0] = new Sundance::Parameter(0.0, "a1");
a[1] = new Sundance::Parameter(0.0, "a2");
Expr bc = EssentialBC(left, v1*(u1-uP[0]-a[0]) + v2*(u2-uP[1]-a[1]), quad);
NonlinearProblem unfProb(unfoldedMesh, eqn, bc,
List(v1,v2), List(u1,u2), uP, vecType);
unfProb.setEvalPoint(uP);
LinearOperator<double> J = unfProb.allocateJacobian();
Vector<double> b = J.domain().createMember();
LinearSolver<double> linSolver
= LinearSolverBuilder::createSolver("amesos.xml");
SerialDenseMatrix<int, double> F(a.size(), a.size());
for (int i=0; i<a.size(); i++)
{
Out::root() << "doing perturbed orbit #" << i << endl;
for (int j=0; j<a.size(); j++)
{
if (i==j) a[j].setParameterValue(1.0);
else a[j].setParameterValue(0.0);
}
unfProb.computeJacobianAndFunction(J, b);
Vector<double> w = b.copy();
linSolver.solve(J, b, w);
Expr w_i = new DiscreteFunction(unfDiscSpace, w);
for (int j=0; j<a.size(); j++)
{
Out::root() << "postprocessing" << i << endl;
writer.addField("w[" + Teuchos::toString(i)
+ ", " + Teuchos::toString(j) + "]", new ExprFieldWrapper(w_i[j]));
Expr g = Integral(right, w_i[j], quad);
F(j,i) = evaluateIntegral(unfoldedMesh, g);
}
}
writer.write();
Out::root() << "Floquet matrix = " << endl
<< F << endl;
Out::root() << "doing eigenvalue analysis" << endl;
Array<double> ew_r(a.size());
Array<double> ew_i(a.size());
int lWork = 6*a.size();
Array<double> work(lWork);
int info = 0;
LAPACK<int, double> lapack;
lapack.GEEV('N','N', a.size(), F.values(),
a.size(), &(ew_r[0]), &(ew_i[0]), 0, 1, 0, 1, &(work[0]), lWork,
&info);
TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
std::runtime_error,
"LAPACK GEEV returned error code =" << info);
Array<double> ew(a.size());
for (int i=0; i<a.size(); i++)
{
ew[i] = sqrt(ew_r[i]*ew_r[i]+ew_i[i]*ew_i[i]);
Out::root() << setw(5) << i
<< setw(16) << ew_r[i]
<< setw(16) << ew_i[i]
<< setw(16) << ew[i]
<< endl;
}
double err = ::fabs(ew[0] - 0.123);
return SundanceGlobal::checkTest(err, 0.001);
}
int main(int argc, char** argv)
{
try
{
int nx = 32;
double convTol = 1.0e-8;
double lambda = 0.5;
Sundance::setOption("nx", nx, "Number of elements");
Sundance::setOption("tol", convTol, "Convergence tolerance");
Sundance::setOption("lambda", lambda, "Lambda (parameter in Bratu's equation)");
Sundance::init(&argc, &argv);
Out::root() << "Bratu problem (lambda=" << lambda << ")" << endl;
Out::root() << "Fixed-point iteration" << endl << endl;
VectorType<double> vecType = new EpetraVectorType();
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, nx, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter sides = new DimensionalCellFilter(mesh.spatialDim()-1);
CellFilter left = sides.subset(new CoordinateValueCellPredicate(0, 0.0));
CellFilter right = sides.subset(new CoordinateValueCellPredicate(0, 1.0));
BasisFamily basis = new Lagrange(1);
Expr u = new UnknownFunction(basis, "u");
Expr v = new TestFunction(basis, "v");
Expr grad = gradient(1);
Expr x = new CoordExpr(0);
const double pi = 4.0*atan(1.0);
Expr uExact = sin(pi*x);
Expr R = pi*pi*uExact - lambda*exp(uExact);
QuadratureFamily quad4 = new GaussianQuadrature(4);
QuadratureFamily quad2 = new GaussianQuadrature(2);
DiscreteSpace discSpace(mesh, basis, vecType);
Expr uPrev = new DiscreteFunction(discSpace, 0.5);
Expr uCur = copyDiscreteFunction(uPrev);
Expr eqn
= Integral(interior, (grad*u)*(grad*v) - v*lambda*exp(uPrev) - v*R, quad4);
Expr h = new CellDiameterExpr();
Expr bc = EssentialBC(left+right, v*u/h, quad4);
LinearProblem prob(mesh, eqn, bc, v, u, vecType);
Expr normSqExpr = Integral(interior, pow(u-uPrev, 2.0), quad2);
Functional normSqFunc(mesh, normSqExpr, vecType);
FunctionalEvaluator normSqEval = normSqFunc.evaluator(u, uCur);
LinearSolver<double> linSolver
= LinearSolverBuilder::createSolver("amesos.xml");
Out::root() << "Fixed-point iteration" << endl;
int maxIters = 20;
Expr soln ;
bool converged = false;
for (int i=0; i<maxIters; i++)
{
/* solve for the next u */
prob.solve(linSolver, uCur);
/* evaluate the norm of (uCur-uPrev) using
* the FunctionalEvaluator defined above */
double deltaU = sqrt(normSqEval.evaluate());
Out::root() << "Iter=" << setw(3) << i << " ||Delta u||=" << setw(20)
<< deltaU << endl;
/* check for convergence */
if (deltaU < convTol)
{
soln = uCur;
converged = true;
break;
}
/* get the vector from the current discrete function */
Vector<double> uVec = getDiscreteFunctionVector(uCur);
/* copy the vector into the previous discrete function */
setDiscreteFunctionVector(uPrev, uVec);
}
TEUCHOS_TEST_FOR_EXCEPTION(!converged, std::runtime_error,
"Fixed point iteration did not converge after "
<< maxIters << " iterations");
FieldWriter writer = new DSVWriter("FixedPointBratu.dat");
writer.addMesh(mesh);
writer.addField("soln", new ExprFieldWrapper(soln[0]));
writer.write();
Out::root() << "Converged!" << endl << endl;
double L2Err = L2Norm(mesh, interior, soln-uExact, quad4);
Out::root() << "L2 Norm of error: " << L2Err << endl;
Sundance::passFailTest(L2Err, 1.5/((double) nx*nx));
}
catch(exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize();
}
int main(int argc, char** argv)
{
try
{
int nx = 32;
double convTol = 1.0e-8;
double lambda = 0.5;
Sundance::setOption("nx", nx, "Number of elements");
Sundance::setOption("tol", convTol, "Convergence tolerance");
Sundance::setOption("lambda", lambda, "Lambda (parameter in Bratu's equation)");
Sundance::init(&argc, &argv);
Out::root() << "Bratu problem (lambda=" << lambda << ")" << endl;
Out::root() << "Newton's method with automated linearization"
<< endl << endl;
VectorType<double> vecType = new EpetraVectorType();
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, nx, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter sides = new DimensionalCellFilter(mesh.spatialDim()-1);
CellFilter left = sides.subset(new CoordinateValueCellPredicate(0, 0.0));
CellFilter right = sides.subset(new CoordinateValueCellPredicate(0, 1.0));
BasisFamily basis = new Lagrange(1);
Expr u = new UnknownFunction(basis, "w");
Expr v = new TestFunction(basis, "v");
Expr grad = gradient(1);
Expr x = new CoordExpr(0);
const double pi = 4.0*atan(1.0);
Expr uExact = sin(pi*x);
Expr R = pi*pi*uExact - lambda*exp(uExact);
QuadratureFamily quad4 = new GaussianQuadrature(4);
QuadratureFamily quad2 = new GaussianQuadrature(2);
DiscreteSpace discSpace(mesh, basis, vecType);
Expr uPrev = new DiscreteFunction(discSpace, 0.5);
Expr eqn
= Integral(interior, (grad*v)*(grad*u) - v*lambda*exp(u) - v*R, quad4);
Expr h = new CellDiameterExpr();
Expr bc = EssentialBC(left+right, v*u/h, quad2);
NonlinearProblem prob(mesh, eqn, bc, v, u, uPrev, vecType);
NonlinearSolver<double> solver
= NonlinearSolverBuilder::createSolver("playa-newton-amesos.xml");
Out::root() << "Newton solve" << endl;
SolverState<double> state = prob.solve(solver);
TEUCHOS_TEST_FOR_EXCEPTION(state.finalState() != SolveConverged,
std::runtime_error,
"Nonlinear solve failed to converge: message=" << state.finalMsg());
Expr soln = uPrev;
FieldWriter writer = new DSVWriter("AutoLinearizedBratu.dat");
writer.addMesh(mesh);
writer.addField("soln", new ExprFieldWrapper(soln[0]));
writer.write();
Out::root() << "Converged!" << endl << endl;
double L2Err = L2Norm(mesh, interior, soln-uExact, quad4);
Out::root() << "L2 Norm of error: " << L2Err << endl;
Sundance::passFailTest(L2Err, 1.5/((double) nx*nx));
}
catch(std::exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize();
return Sundance::testStatus();
}
bool BlockStochPoissonTest1D()
{
/* We will do our linear algebra using Epetra */
VectorType<double> vecType = new EpetraVectorType();
/* Read a mesh */
MeshType meshType = new BasicSimplicialMeshType();
int nx = 32;
MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, nx,
meshType);
Mesh mesh = mesher.getMesh();
/* Create a cell filter that will identify the maximal cells
* in the interior of the domain */
CellFilter interior = new MaximalCellFilter();
CellFilter pts = new DimensionalCellFilter(0);
CellFilter left = pts.subset(new CoordinateValueCellPredicate(0,0.0));
CellFilter right = pts.subset(new CoordinateValueCellPredicate(0,1.0));
Expr x = new CoordExpr(0);
/* Create the stochastic coefficients */
int nDim = 1;
int order = 6;
#ifdef HAVE_SUNDANCE_STOKHOS
Out::root() << "using Stokhos hermite basis" << std::endl;
SpectralBasis pcBasis = new Stokhos::HermiteBasis<int,double>(order);
#else
Out::root() << "using George's hermite basis" << std::endl;
SpectralBasis pcBasis = new HermiteSpectralBasis(nDim, order);
#endif
Array<Expr> q(pcBasis.nterms());
Array<Expr> kappa(pcBasis.nterms());
Array<Expr> uEx(pcBasis.nterms());
double a = 0.1;
q[0] = -2 + pow(a,2)*(4 - 9*x)*x - 2*pow(a,3)*(-1 + x)*(1 + 3*x*(-3 + 4*x));
q[1] = -(a*(-3 + 10*x + 2*a*(-1 + x*(8 - 9*x +
a*(-4 + 3*(5 - 4*x)*x + 12*a*(-1 + x)*(1 + 5*(-1 + x)*x))))));
q[2] = a*(-4 + 6*x + a*(1 - x*(2 + 3*x) + a*(4 - 28*x + 30*pow(x,2))));
q[3] = -(pow(a,2)*(-3 + x*(20 - 21*x +
a*(-4 + 3*(5 - 4*x)*x + 24*a*(-1 + x)*(1 + 5*(-1 + x)*x)))));
q[4] = pow(a,3)*(1 + x*(-6 + x*(3 + 4*x)));
q[5] = -4*pow(a,4)*(-1 + x)*x*(1 + 5*(-1 + x)*x);
q[6] = 0.0;
uEx[0] = -((-1 + x)*x);
uEx[1] = -(a*(-1 + x)*pow(x,2));
uEx[2] = a*pow(-1 + x,2)*x;
uEx[3] = pow(a,2)*pow(-1 + x,2)*pow(x,2);
uEx[4] = 0.0;
uEx[5] = 0.0;
uEx[6] = 0.0;
kappa[0] = 1.0;
kappa[1] = a*x;
kappa[2] = -(pow(a,2)*(-1 + x)*x);
kappa[3] = 1.0; // unused
kappa[4] = 1.0; // unused
kappa[5] = 1.0; // unused
kappa[6] = 1.0; // unused
Array<Expr> uBC(pcBasis.nterms());
for (int i=0; i<pcBasis.nterms(); i++) uBC[i] = 0.0;
int L = nDim+2;
int P = pcBasis.nterms();
Out::os() << "L = " << L << std::endl;
Out::os() << "P = " << P << std::endl;
/* Create the unknown and test functions. Do NOT use the spectral
* basis here */
Expr u = new UnknownFunction(new Lagrange(4), "u");
Expr v = new TestFunction(new Lagrange(4), "v");
/* Create differential operator and coordinate function */
Expr dx = new Derivative(0);
Expr grad = dx;
/* We need a quadrature rule for doing the integrations */
QuadratureFamily quad = new GaussianQuadrature(12);
/* Now we create problem objects to build each $K_j$ and $f_j$.
* There will be L matrix-vector pairs */
Array<Expr> eqn(P);
Array<Expr> bc(P);
Array<LinearProblem> prob(P);
Array<LinearOperator<double> > KBlock(L);
Array<Vector<double> > fBlock(P);
Array<Vector<double> > solnBlock;
for (int j=0; j<P; j++)
{
eqn[j] = Integral(interior, kappa[j]*(grad*v)*(grad*u) + v*q[j], quad);
bc[j] = EssentialBC(left+right, v*(u-uBC[j]), quad);
prob[j] = LinearProblem(mesh, eqn[j], bc[j], v, u, vecType);
if (j<L) KBlock[j] = prob[j].getOperator();
fBlock[j] = -1.0*prob[j].getSingleRHS();
}
/* Read the solver to be used on the diagonal blocks */
LinearSolver<double> diagSolver
= LinearSolverBuilder::createSolver("amesos.xml");
double convTol = 1.0e-12;
int maxIters = 30;
int verb = 1;
StochBlockJacobiSolver solver(diagSolver, pcBasis,
convTol, maxIters, verb);
solver.solve(KBlock, fBlock, solnBlock);
/* write the solution */
FieldWriter w = new MatlabWriter("Stoch1D");
w.addMesh(mesh);
DiscreteSpace discSpace(mesh, new Lagrange(4), vecType);
for (int i=0; i<P; i++)
{
L2Projector proj(discSpace, uEx[i]);
Expr ue_i = proj.project();
Expr df = new DiscreteFunction(discSpace, solnBlock[i]);
w.addField("u["+ Teuchos::toString(i)+"]",
new ExprFieldWrapper(df));
w.addField("uEx["+ Teuchos::toString(i)+"]",
new ExprFieldWrapper(ue_i));
}
w.write();
double totalErr2 = 0.0;
DiscreteSpace discSpace4(mesh, new Lagrange(4), vecType);
for (int i=0; i<P; i++)
{
Expr df = new DiscreteFunction(discSpace4, solnBlock[i]);
Expr errExpr = Integral(interior, pow(uEx[i]-df, 2.0), quad);
Expr scaleExpr = Integral(interior, pow(uEx[i], 2.0), quad);
double errSq = evaluateIntegral(mesh, errExpr);
double scale = evaluateIntegral(mesh, scaleExpr);
if (scale > 0.0)
Out::os() << "mode i=" << i << " error=" << sqrt(errSq/scale) << std::endl;
else
Out::os() << "mode i=" << i << " error=" << sqrt(errSq) << std::endl;
}
double tol = 1.0e-12;
return SundanceGlobal::checkTest(sqrt(totalErr2), tol);
}
bool NonlinReducedIntegration()
{
int np = MPIComm::world().getNProc();
int n = 4;
bool increaseProbSize = true;
if ( (np % 4)==0 ) increaseProbSize = false;
Array<double> h;
Array<double> errQuad;
Array<double> errReduced;
for (int i=0; i<4; i++)
{
n *= 2;
int nx = n;
int ny = n;
VectorType<double> vecType = new EpetraVectorType();
MeshType meshType = new BasicSimplicialMeshType();
int npx = -1;
int npy = -1;
PartitionedRectangleMesher::balanceXY(np, &npx, &npy);
TEUCHOS_TEST_FOR_EXCEPT(npx < 1);
TEUCHOS_TEST_FOR_EXCEPT(npy < 1);
TEUCHOS_TEST_FOR_EXCEPT(npx * npy != np);
if (increaseProbSize)
{
nx = nx*npx;
ny = ny*npy;
}
MeshSource mesher = new PartitionedRectangleMesher(0.0, 1.0, nx, npx,
0.0, 1.0, ny, npy, meshType);
Mesh mesh = mesher.getMesh();
WatchFlag watchMe("watch eqn");
watchMe.setParam("integration setup", 0);
watchMe.setParam("integration", 0);
watchMe.setParam("fill", 0);
watchMe.setParam("evaluation", 0);
watchMe.deactivate();
WatchFlag watchBC("watch BCs");
watchBC.setParam("integration setup", 0);
watchBC.setParam("integration", 0);
watchBC.setParam("fill", 0);
watchBC.setParam("evaluation", 0);
watchBC.deactivate();
CellFilter interior = new MaximalCellFilter();
CellFilter edges = new DimensionalCellFilter(1);
CellFilter left = edges.subset(new CoordinateValueCellPredicate(0,0.0));
CellFilter right = edges.subset(new CoordinateValueCellPredicate(0,1.0));
CellFilter top = edges.subset(new CoordinateValueCellPredicate(1,1.0));
CellFilter bottom = edges.subset(new CoordinateValueCellPredicate(1,0.0));
BasisFamily basis = new Lagrange(1);
Expr u = new UnknownFunction(basis, "u");
Expr v = new TestFunction(basis, "v");
Expr dx = new Derivative(0);
Expr dy = new Derivative(1);
Expr grad = List(dx, dy);
Expr x = new CoordExpr(0);
Expr y = new CoordExpr(1);
QuadratureFamily quad = new ReducedQuadrature();
QuadratureFamily quad2 = new GaussianQuadrature(2);
/* Define the weak form */
const double pi = 4.0*atan(1.0);
Expr c = cos(pi*x);
Expr s = sin(pi*x);
Expr ch = cosh(y);
Expr sh = sinh(y);
Expr s2 = s*s;
Expr c2 = c*c;
Expr sh2 = sh*sh;
Expr ch2 = ch*ch;
Expr pi2 = pi*pi;
Expr uEx = s*ch;
Expr eu = exp(uEx);
Expr f = -(ch*eu*(-1 + pi2)*s) + ch2*(c2*eu*pi2 - s2) + eu*s2*sh2;
Expr eqn = Integral(interior, exp(u)*(grad*u)*(grad*v)
+ v*f + v*u*u, quad, watchMe)
+ Integral(right, v*exp(u)*pi*cosh(y), quad,watchBC);
/* Define the Dirichlet BC */
Expr bc = EssentialBC(left+top, v*(u-uEx), quad, watchBC);
Expr eqn2 = Integral(interior, exp(u)*(grad*u)*(grad*v)
+ v*f + v*u*u, quad2, watchMe)
+ Integral(right, v*exp(u)*pi*cosh(y), quad2,watchBC);
/* Define the Dirichlet BC */
Expr bc2 = EssentialBC(left+top, v*(u-uEx), quad2, watchBC);
DiscreteSpace discSpace(mesh, new Lagrange(1), vecType);
Expr soln1 = new DiscreteFunction(discSpace, 0.0, "u0");
Expr soln2 = new DiscreteFunction(discSpace, 0.0, "u0");
L2Projector proj(discSpace, uEx);
Expr uEx0 = proj.project();
NonlinearProblem nlp(mesh, eqn, bc, v, u, soln1, vecType);
NonlinearProblem nlp2(mesh, eqn2, bc2, v, u, soln2, vecType);
ParameterXMLFileReader reader("nox-aztec.xml");
ParameterList noxParams = reader.getParameters();
NOXSolver solver(noxParams);
nlp.solve(solver);
nlp2.solve(solver);
FieldWriter w = new VTKWriter("NonlinReduced-n" + Teuchos::toString(n));
w.addMesh(mesh);
w.addField("soln1", new ExprFieldWrapper(soln1[0]));
w.addField("soln2", new ExprFieldWrapper(soln2[0]));
w.addField("exact", new ExprFieldWrapper(uEx0[0]));
w.write();
Expr err1 = uEx - soln1;
Expr errExpr1 = Integral(interior,
err1*err1,
new GaussianQuadrature(4));
Expr err2 = uEx - soln2;
Expr errExpr2 = Integral(interior,
err2*err2,
new GaussianQuadrature(4));
Expr err12 = soln2 - soln1;
Expr errExpr12 = Integral(interior,
err12*err12,
new GaussianQuadrature(4));
double error1 = ::sqrt(evaluateIntegral(mesh, errExpr1));
double error2 = ::sqrt(evaluateIntegral(mesh, errExpr2));
double error12 = ::sqrt(evaluateIntegral(mesh, errExpr12));
Out::root() << "final result: " << n << " " << error1 << " " << error2 << " " << error12
<< endl;
h.append(1.0/((double) n));
errQuad.append(error2);
errReduced.append(error1);
}
double pQuad = fitPower(h, errQuad);
double pRed = fitPower(h, errReduced);
Out::root() << "exponent (reduced integration) " << pRed << endl;
Out::root() << "exponent (full integration) " << pQuad << endl;
return SundanceGlobal::checkTest(::fabs(pRed-2.0), 0.1);
}
