// Copyright (C) 2014 Garth N. Wells
//
// 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 .
//
// This demo solves the equations of static linear elasticity for a
// pulley subjected to centripetal accelerations. The solver uses
// smoothed aggregation algerbaric multigri
#include
#include "Elasticity.h"
using namespace dolfin;
// Function to compute the near nullspace for elasticity - it is made
// up of the six rigid body modes
dolfin::VectorSpaceBasis build_near_nullspace(const dolfin::FunctionSpace& V,
const GenericVector& x)
{
// Get subspaces
auto V0 = V.sub(0);
auto V1 = V.sub(1);
auto V2 = V.sub(2);
// Create vectors for nullspace basis
std::vector> basis(6);
for (std::size_t i = 0; i < basis.size(); ++i)
basis[i] = x.copy();
// x0, x1, x2 translations
V0->dofmap()->set(*basis[0], 1.0);
V1->dofmap()->set(*basis[1], 1.0);
V2->dofmap()->set(*basis[2], 1.0);
// Rotations
V0->set_x(*basis[3], -1.0, 1);
V1->set_x(*basis[3], 1.0, 0);
V0->set_x(*basis[4], 1.0, 2);
V2->set_x(*basis[4], -1.0, 0);
V2->set_x(*basis[5], 1.0, 1);
V1->set_x(*basis[5], -1.0, 2);
// Apply
for (std::size_t i = 0; i < basis.size(); ++i)
basis[i]->apply("add");
// Create vector space and orthonormalize
VectorSpaceBasis vector_space(basis);
vector_space.orthonormalize();
return vector_space;
}
int main()
{
#ifdef HAS_PETSC
// Set backend to PETSC
parameters["linear_algebra_backend"] = "PETSc";
// Inner surface subdomain
class InnerSurface : public SubDomain
{
bool inside(const Array& x, bool on_boundary) const
{
const double r = 3.75 - x[2]*0.17;
return (x[0]*x[0] + x[1]*x[1]) < r*r and on_boundary;
}
};
// Centripetal loading function
class CentripetalLoading : public Expression
{
public:
CentripetalLoading() : Expression(3) {}
void eval(Array& values, const Array& x) const
{
const double omega = 300.0;
const double rho = 10.0;
values[0] = rho*omega*omega*x[0];;
values[1] = rho*omega*omega*x[1];
values[2] = 0.0;
}
};
// Read mesh
auto mesh = std::make_shared();
XDMFFile file("../pulley.xdmf");
file.read(*mesh);
// Create right-hand side loading function
auto f = std::make_shared();
// Set elasticity parameters
double E = 10.0;
double nu = 0.3;
auto mu = std::make_shared(E/(2.0*(1.0 + nu)));
auto lambda = std::make_shared(E*nu/((1.0 + nu)*(1.0 - 2.0*nu)));
// Create function space
auto V = std::make_shared(mesh);
// Define variational problem
Elasticity::Form_a a(V, V);
a.mu = mu; a.lmbda = lambda;
Elasticity::Form_L L(V);
L.f = f;
// Set up boundary condition on inner surface
auto inner_surface = std::make_shared();
auto zero = std::make_shared(0.0, 0.0, 0.0);
auto bc = std::make_shared(V, zero, inner_surface);
// Assemble system, applying boundary conditions and preserving
// symmetry)
PETScMatrix A;
PETScVector b;
assemble_system(A, b, a, L, {bc});
// Create solution function
auto u = std::make_shared(V);
// Create near null space basis (required for smoothed aggregation
// AMG). The solution vector is passed so that it can be copied to
// generate compatible vectors for the nullspace.
VectorSpaceBasis near_null_space = build_near_nullspace(*V, *u->vector());
// Attach near nullspace to matrix
A.set_near_nullspace(near_null_space);
// Create PETSc smoothed aggregation AMG preconditioner
auto pc = std::make_shared("petsc_amg");
// Use Chebyshev smoothing for multigrid
PETScOptions::set("mg_levels_ksp_type", "chebyshev");
PETScOptions::set("mg_levels_pc_type", "jacobi");
// Improve estimate of eigenvalues for Chebyshev smoothing
PETScOptions::set("mg_levels_esteig_ksp_type", "cg");
PETScOptions::set("mg_levels_ksp_chebyshev_esteig_steps", 50);
// Create CG PETSc linear solver and turn on convergence monitor
PETScKrylovSolver solver("cg", pc);
solver.parameters["monitor_convergence"] = true;
// Solve
solver.solve(A, *(u->vector()), b);
// Extract solution components (deep copy)
Function ux = (*u)[0];
Function uy = (*u)[1];
Function uz = (*u)[2];
std::cout << "Norm (u vector): " << u->vector()->norm("l2") << std::endl;
std::cout << "Norm (ux, uy, uz): " << ux.vector()->norm("l2") << " "
<< uy.vector()->norm("l2") << " "
<< uz.vector()->norm("l2") << std::endl;
// Save solution in VTK format
File vtk_file("elasticity.pvd", "compressed");
vtk_file << *u;
// Extract stress and write in VTK format
auto W = std::make_shared(mesh);
Elasticity::Form_a_s a_s(W, W);
Elasticity::Form_L_s L_s(W);
L_s.mu = mu;
L_s.lmbda = lambda;
L_s.disp = u;
// Compute stress for visualisation
Function stress(W);
LocalSolver local_solver(std::shared_ptr