// Copyright (C) 2009 Mirko Maraldi and 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 .
//
// Modified by Anders Logg, 2011
//
// First added: 2009-01-22
// Last changed: 2011-06-28
#include
#include "ElastoDynamics.h"
#include "DG0_eps_xx.h"
using namespace dolfin;
// External load
class Pressure : public Expression
{
public:
Pressure(const double& t, const double& dt, bool old)
: Expression(2), t(t), dt(dt), old(old) {}
void eval(Array& values, const Array& x) const
{
double time = t;
if(old && time > 0.0)
time -= dt;
const double cutoff_time = 10.0*1.0/32.0;
if (time < cutoff_time)
{
values[0] = 1.0*time/cutoff_time;
values[1] = 0.0;
}
else
{
values[0] = 1.0;
values[1] = 0.0;
}
}
private:
const double& t;
const double& dt;
const bool old;
};
// Right boundary
class RightBoundary : public SubDomain
{
bool inside(const Array& x, bool on_boundary) const
{
if (1.0 - x[0] < DOLFIN_EPS && on_boundary)
return true;
else
return false;
}
};
class LeftBoundary : public SubDomain
{
bool inside(const Array& x, bool on_boundary) const
{
if (x[0] < DOLFIN_EPS)
return true;
else
return false;
}
};
// Acceleration update
void update_a(Function& a, const Function& u, const Function& a0,
const Function& v0, const Function& u0,
double beta, double dt)
{
// a = 1/(2*beta)*((u - u0 - v0*dt)/(0.5*dt*dt) - (1-2*beta)*a0)
*a.vector() = *u.vector();
*a.vector() -= *u0.vector();
*a.vector() *= 1.0/dt;
*a.vector() -= *v0.vector();
*a.vector() *= 1.0/((0.5-beta)*dt);
*a.vector() -= *a0.vector();
*a.vector() *= (0.5-beta)/beta;
}
// Velocity update
void update_v(Function& v, const Function& a, const Function& a0,
const Function& v0, double gamma, double dt)
{
// v = dt * ((1-gamma)*a0 + gamma*a) + v0
*v.vector() = *a0.vector();
*v.vector() *= (1.0-gamma)/gamma;
*v.vector() += *a.vector();
*v.vector() *= dt*gamma;
*v.vector() += *v0.vector();
}
int main(int argc, char* argv[])
{
init(argc, argv);
// Create mesh
auto mesh = std::make_shared("../dolfin_fine.xml.gz");
// Create function space
auto V = std::make_shared(mesh);
// Material parameters
auto rho = std::make_shared(1.0); // mass density
auto eta = std::make_shared(0.25); // damping coefficient
double E = 1.0; // Youngs modulus
double nu = 0.0; // Poisson ratio
auto lambda = std::make_shared((nu*E)/((1.0 + nu)*(1.0 - 2.0 * nu))); // Lame coefficient
auto mu = std::make_shared(E/(2.0*(1.0 + nu))); // Lame coefficient
// Time stepping parameters
auto alpha_m = std::make_shared(0.2);
auto alpha_f = std::make_shared(0.4);
auto beta = std::make_shared(0.36);
auto gamma = std::make_shared(0.7);
auto dt = std::make_shared(1.0/32.0); // time step
double t = 0.0; // initial time
double T = 200*(*dt); // final time
// Body force
auto f = std::make_shared(0.0, 0.0);
// External load
RightBoundary right_boundary;
auto right_boundary_function
= std::make_shared>(mesh, 1);
right_boundary.mark(*right_boundary_function, 3);
auto p = std::make_shared(t, *dt, false);
auto p0 = std::make_shared(t, *dt, true);
// Dirichlet boundary conditions
auto left_boundary = std::make_shared();
auto zero = std::make_shared(0.0, 0.0);
DirichletBC bc(V, zero, left_boundary);
// Define solution vectors
auto u = std::make_shared(V); // displacement
auto u0 = std::make_shared(V);
Function v(V); // velocity
auto v0 = std::make_shared(V);
Function a(V); // acceleration
auto a0 = std::make_shared(V);
// Set initial conditions and initialise acceleration function
u0->vector()->zero();
v0->vector()->zero();
a0->vector()->zero();
// Create forms
ElastoDynamics::BilinearForm a_form(V, V);
ElastoDynamics::LinearForm L(V);
// Attach functions
a_form.lmbda = lambda; a_form.mu = mu; a_form.rho = rho;
a_form.eta = eta;
a_form.beta = beta;
a_form.gamma = gamma;
a_form.dt = dt;
a_form.alpha_m = alpha_m;
a_form.alpha_f = alpha_f;
L.lmbda = lambda; L.mu = mu; L.rho = rho;
L.eta = eta;
L.beta = beta;
L.gamma = gamma;
L.dt = dt;
L.alpha_m = alpha_m;
L.alpha_f = alpha_f;
L.u0 = u0; L.v0 = v0; L.a0 = a0;
L.f = f;
L.p = p;
L.p0 = p0;
// Attach subdomains
a_form.ds = right_boundary_function;
L.ds = right_boundary_function;
// Create projection to compute the normal strain eps_xx
auto Vdg = std::make_shared(mesh);
DG0_eps_xx::BilinearForm a_eps(Vdg, Vdg);
DG0_eps_xx::LinearForm L_eps(Vdg);
L_eps.u = u;
Function eps_xx(Vdg);
// Create output files
File file_u("u.pvd", "compressed");
File file_eps("eps_xx.pvd", "compressed");
// Start time stepping
std::size_t step = 0;
while (t < T)
{
// Update for next time step
t += *dt;
cout << "Time: " << t << endl;
// Solve
solve(a_form == L, *u, {&bc});
solve(a_eps == L_eps, eps_xx);
// Update velocity and acceleration
update_a(a, *u, *a0, *v0, *u0, *beta, *dt);
update_v(v, a, *a0, *v0, *gamma, *dt);
*u0 = *u; *v0 = v; *a0 = a;
// Save solutions to file
if (step % 2 == 0)
{
file_u << *u;
file_eps << eps_xx;
}
++step;
}
return 0;
}