Dear Lucas,
As a by-product of my worked I have implemented (or, rather, I am
implementing) something similar to what you describe, though the focus
is not on mechanics alone, but rather on coupled problems. Essentially,
the library I have written is solving problems where a possibly
non-linear potential A(u) exists (u are the "independent fields" which
may also include some scalar unknowns) such that the problem you want to
solve is equivalent to requiring that A(u) is stationary. [Actually the
implementation also works for many cases where the potential does not
exist - just like in mechanics where you can obtain the weak form by
pretending that there is a potential energy and afterwards you throw
this assumption away and say that the stress doesn't derive from a
strain energy potential.]
To give you an idea how it works here is a description of the general
process when solving a problem with the library:
(1) you set up a domain mesh, which may be composed of different domain
portions. If you have got unknowns living on boundaries or interfaces
between different domain portions, you can additionally define a
boundary/interface mesh based on the domain mesh.
(2) You define the independent fields and the finite elements you want
to use for their discretization (you can use a different one for each
independent field). Each of these independent fields may either live on
the domain or on boundaries/interfaces. Also you can, for each field,
specify domain/boundary/interface portions where it is generally zero
(e.g. to account for problems where the physics are different in
different domain portions).
(3) You define a number of dependent fields in terms of the independent
fields (each dependent field can be a linear function of all u and the
first derivatives thereof - second derivatives would require C1
elements, which are anyway not available with deal.II). An example for
such a dependent field would be the deformation gradient defined in
terms of the displacement.
(4) You define the form of A(u) as a general function of an arbitrary
number of integrals over domain portions and possibly boundary/interface
portions [If A(u) is not just a sum of integrals, which it actually is
for the majority of cases, you will have to implement the form of this
general function and its first and second derivatives].
(5) You define the first and second derivatives of the integrands
appearing in A(u) with respect to the dependent fields and the
quadrature schemes to be used for evaluation of the integrals (you can
use a different quadrature for each integral). This is the really
problem specific part. In a mechanics context you would have to
implement the stress-strain relation and the corresponding material
tangent as well as possible forcing terms here.
(6) You define constraints (the library already provides with functions
for hanging nodes constraints and Dirichlet constraints, but if you want
to do something more complicated, you'll have to do this yourself).
(7) Sparsity pattern generation and assembly of the system matrix and
the right hand side is then done automatically [in case A(u) is not just
a sum of domain / boundary / interface integrals, but rather a general
function, there's not just a matrix, but also three other matrices which
are there to avoid dealing with a dense system matrix].
(8) Solve the system (if you use a direct solver there's not much you
have to do here).
(9) Repeat if the problem is non-linear and you have to iterate or if
the problem is time dependent.
The status right now is that a basic version works in sequential and I
have done the first distributed parallel computation just today.
However, it's really work in progress, so there are many gaps to fill
and things which are not quite like I want to have them. For example I
haven't implemented the transfer of the solution (and possible hidden
variables like plastic strains appearing in the definition of the
constitutive relations) after mesh refinement yet. Having this said, I
would be really happy if somebody is interested to contribute to the
library and use and test it. For now, I have made it public on github,
so that you can have a look at it
(https://github.com/starki0815/GalerkinTools). In the doc folder there
are two pdfs which may give you some more insight; also there is the
Dogygen generated code documentation. If you are interested to try it,
let me know (you'll probably need some guidance, because a few
modifications to deal.II - missing template instantiations, etc. - have
to be done). Also, I have just created an examples folder with an
example resembling the deal.II tutorial step-46, where you can see how a
typical use of the library looks like (the fun fact is that I wanted to
use the example as a verification of my implementation, but it turned
out that there was a bug in the original step-46 matrix assembly :) ).
Hope that gives you an idea.
Regards, Sebastian
Am 16.08.19 um 10:57 schrieb Lukas Lamm:
Hey Lucas,
thanks for your response. I was actually searching for some
application somehow similar to FE software like e.g. FEAP or Deadalon,
where you can e.g. easily implement any desired material model but do
not have to care about the whole assembly and solution process. At
least not if you do not explicitly want to. Writing it by myself would
not be a problem I guess, but would still be some effort. Therefore, I
thought that maybe someone alse is already working on such a package
and I could participate in the development process.
Best regards,
Lukas
Am Freitag, 16. August 2019 10:11:24 UTC+2 schrieb Lucas Campos:
Dear Lukas,
I am working with Continuum Mechanics, although I would not call
my research "more advanced" than the stuff in tutorial-44, at
least from a computational point of view. Mostly, growing
materials. Could you be a bit more specific on your needs?
Bests,
Lucas
On Thursday, 15 August 2019 09:45:12 UTC+2, Lukas Lamm wrote:
Dear dealii community,
first of all I would like to thank you for this wonderful
piece of work you all have produced. It is by far the most
well designed and documented open source FE library I have
seen so far.
I am working in the field of computational continuum mechanics
and was wondering, if anyone of you know about (or is even
working on) an application built on top of dealii for the use
in continuum mechanics. Something like tutorial 44, but more
sophisticated and advanced. If there is anything out there, I
would be really happy to recieve a short feedback with links
to github etc.
Thank you very much for your help.
Mit freundlichen Grüßen / kind regards,
***Lukas Lamm, M. Sc.*
Research Associate / Ph.D. candidate
RWTH Aachen UniversityInstitute of Applied
MechanicsMies-van-der-Rohe-Str. 1 Room 308dD-52074
AachenPhone: +49(0)241 80 25006Mail:
[email protected] Web: www.ifam.rwth-aachen.de
<http://www.ifam.rwth-aachen.de>
--
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see
https://groups.google.com/d/forum/dealii?hl=en
---
You received this message because you are subscribed to the Google
Groups "deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send
an email to [email protected]
<mailto:[email protected]>.
To view this discussion on the web visit
https://groups.google.com/d/msgid/dealii/ca8fda63-788b-419f-94fc-705ef3ec85f9%40googlegroups.com
<https://groups.google.com/d/msgid/dealii/ca8fda63-788b-419f-94fc-705ef3ec85f9%40googlegroups.com?utm_medium=email&utm_source=footer>.
--
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see
https://groups.google.com/d/forum/dealii?hl=en
---
You received this message because you are subscribed to the Google Groups "deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/dealii/8d8b43cb-26e5-81cb-e17d-2801988ea269%40gmx.de.
