/* 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); }