// Copyright (C) 2010-2011 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-08-30 // Last changed: 2013-03-21 // // This demo program solves the incompressible Navier-Stokes equations // on an L-shaped domain using Chorin's splitting method. // Begin demo #include #include "TentativeVelocity.h" #include "PressureUpdate.h" #include "VelocityUpdate.h" using namespace dolfin; // Define noslip domain class NoslipDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return (on_boundary && (x[0] < DOLFIN_EPS || x[1] < DOLFIN_EPS || (x[0] > 0.5 - DOLFIN_EPS && x[1] > 0.5 - DOLFIN_EPS))); } }; // Define inflow domain class InflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[1] > 1.0 - DOLFIN_EPS; } }; // Define inflow domain class OutflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[0] > 1.0 - DOLFIN_EPS; } }; // Define pressure boundary value at inflow class InflowPressure : public Expression { public: // Constructor InflowPressure() : t(0) {} // Evaluate pressure at inflow void eval(Array& values, const Array& x) const { values[0] = sin(3.0*t); } // Current time double t; }; int main() { // Print log messages only from the root process in parallel parameters["std_out_all_processes"] = false; // Load mesh from file auto mesh = std::make_shared("../lshape.xml.gz"); // Create function spaces auto V = std::make_shared(mesh); auto Q = std::make_shared(mesh); // Set parameter values double dt = 0.01; double T = 3; // Define values for boundary conditions auto p_in = std::make_shared(); auto zero = std::make_shared(0.0); auto zero_vector = std::make_shared(0.0, 0.0); // Define subdomains for boundary conditions auto noslip_domain = std::make_shared(); auto inflow_domain = std::make_shared(); auto outflow_domain = std::make_shared() ; // Define boundary conditions DirichletBC noslip(V, zero_vector, noslip_domain); DirichletBC inflow(Q, p_in, inflow_domain); DirichletBC outflow(Q, zero, outflow_domain); std::vector bcu = {&noslip}; std::vector bcp = {{&inflow, &outflow}}; // Create functions auto u0 = std::make_shared(V); auto u1 = std::make_shared(V); auto p1 = std::make_shared(Q); // Create coefficients auto k = std::make_shared(dt); auto f = std::make_shared(0, 0); // Create forms TentativeVelocity::BilinearForm a1(V, V); TentativeVelocity::LinearForm L1(V); PressureUpdate::BilinearForm a2(Q, Q); PressureUpdate::LinearForm L2(Q); VelocityUpdate::BilinearForm a3(V, V); VelocityUpdate::LinearForm L3(V); // Set coefficients a1.k = k; L1.k = k; L1.u0 = u0; L1.f = f; L2.k = k; L2.u1 = u1; L3.k = k; L3.u1 = u1; L3.p1 = p1; // Assemble matrices Matrix A1, A2, A3; assemble(A1, a1); assemble(A2, a2); assemble(A3, a3); // Create vectors Vector b1, b2, b3; // Use amg preconditioner if available const std::string prec(has_krylov_solver_preconditioner("amg") ? "amg" : "default"); // Create files for storing solution File ufile("results/velocity.pvd"); File pfile("results/pressure.pvd"); // Time-stepping double t = dt; while (t < T + DOLFIN_EPS) { // Update pressure boundary condition p_in->t = t; // Compute tentative velocity step begin("Computing tentative velocity"); assemble(b1, L1); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A1, b1); solve(A1, *u1->vector(), b1, "gmres", "default"); end(); // Pressure correction begin("Computing pressure correction"); assemble(b2, L2); for (std::size_t i = 0; i < bcp.size(); i++) { bcp[i]->apply(A2, b2); bcp[i]->apply(*p1->vector()); } solve(A2, *p1->vector(), b2, "bicgstab", prec); end(); // Velocity correction begin("Computing velocity correction"); assemble(b3, L3); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A3, b3); solve(A3, *u1->vector(), b3, "gmres", "default"); end(); // Save to file ufile << *u1; pfile << *p1; // Move to next time step *u0 = *u1; t += dt; cout << "t = " << t << endl; } return 0; }