// Copyright (C) 2012 Corrado Maurini
//
// 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 .
//
// Modified by Corrado Maurini 2013
// Modified by Johannes Ring 2013
//
// First added: 2012-09-03
// Last changed: 2013-11-21
//
// This demo program uses the PETSc nonlinear solver for variational
// inequalities to solve a contact mechanics problems in FEniCS. The
// example considers a heavy elastic circle in a box of the same size.
#include
#include "HyperElasticity.h"
using namespace dolfin;
// Sub domain for symmetry condition
class SymmetryLine : public SubDomain
{
bool inside(const Array& x, bool on_boundary) const
{ return (std::abs(x[0]) < DOLFIN_EPS); }
};
// Lower bound for displacement
class LowerBound : public Expression
{
public:
LowerBound() : Expression(2) {}
void eval(Array& values, const Array& x) const
{
const double xmin = -1.0 - DOLFIN_EPS;
const double ymin = -1.0;
values[0] = xmin - x[0];
values[1] = ymin - x[1];
}
};
// Upper bound for displacement
class UpperBound : public Expression
{
public:
UpperBound() : Expression(2) {}
void eval(Array& values, const Array& x) const
{
const double xmax = 1.0 + DOLFIN_EPS;
const double ymax = 2.0;
values[0] = xmax - x[0];
values[1] = ymax - x[1];
}
};
int main()
{
#ifdef HAS_PETSC
// Read mesh and create function space
auto mesh = std::make_shared("../circle_yplane.xml.gz");
// Create function space
auto V = std::make_shared(mesh);
// Create Dirichlet boundary conditions
auto zero = std::make_shared(0.0);
auto s = std::make_shared();
auto bc = std::make_shared(V->sub(0), zero, s, "pointwise");
// Define source and boundary traction functions
auto B = std::make_shared(0.0, -0.05);
// Define solution function
auto u = std::make_shared(V);
// Set material parameters
const double E = 10.0;
const double nu = 0.3;
auto mu = std::make_shared(E/(2*(1 + nu)));
auto lambda = std::make_shared(E*nu/((1.0 + nu)*(1.0 - 2.0*nu)));
// Create (linear) form defining (nonlinear) variational problem
auto F = std::make_shared(V);
F->mu = mu; F->lmbda = lambda; F->B = B; F->u = u;
// Create jacobian dF = F' (for use in nonlinear solver).
auto J = std::make_shared(V, V);
J->mu = mu; J->lmbda = lambda; J->u = u;
// Interpolate expression for upper bound
UpperBound umax_exp;
Function umax(V);
umax.interpolate(umax_exp);
// Interpolate expression for lower bound
LowerBound umin_exp;
Function umin(V);
umin.interpolate(umin_exp);
// Set up the non-linear problem
std::vector> bcs = {bc};
auto problem = std::make_shared(F, u, bcs, J);
problem->set_bounds(umin, umax);
// Set up the non-linear solver
NonlinearVariationalSolver solver(problem);
solver.parameters["nonlinear_solver"] = "snes";
solver.parameters("snes_solver")["linear_solver"] = "lu";
solver.parameters("snes_solver")["maximum_iterations"] = 20;
solver.parameters("snes_solver")["report"] = true;
solver.parameters("snes_solver")["error_on_nonconvergence"] = false;
// Solve the problems
std::pair out;
out = solver.solve();
// Check for convergence. Convergence is one modifies the loading
// and the mesh size
cout << out.second;
if (out.second != true)
{
warning("This demo is a complex nonlinear problem. Convergence is not guaranteed when modifying parameters.");
}
// Save solution in VTK format
File file("displacement.pvd");
file << *u;
#endif
return 0;
}