Giter Club home page Giter Club logo

materials.jl's Introduction

JuliaFEM.jl - an open source solver for both industrial and academia usage

logo

DOI License Gitter Build Status Coverage Status Stable documentation Latest documentation Issues


Everything is outdated. See other FEM options from here: https://github.com/JuliaPDE/SurveyofPDEPackages?tab=readme-ov-file#fem


JuliaFEM organization web-page: http://www.juliafem.org

The JuliaFEM project develops open-source software for reliable, scalable, distributed Finite Element Method.

The JuliaFEM software library is a framework that allows for the distributed processing of large Finite Element Models across clusters of computers using simple programming models. It is designed to scale up from single servers to thousands of machines, each offering local computation and storage. The basic design principle is: everything is nonlinear. All physics models are nonlinear from which the linearization are made as a special cases.

At the moment, users can perform the following analyses with JuliaFEM: elasticity, thermal, eigenvalue, contact mechanics, and quasi-static solutions. Typical examples in industrial applications include non-linear solid mechanics, contact mechanics, finite strains, and fluid structure interaction problems. For visualization, JuliaFEM uses ParaView which prefers XDMF file format using XML to store light data and HDF to store large data-sets, which is more or less the open-source standard.

Vision

On one hand, the vision of the JuliaFEM includes the opportunity for massive parallelization using multiple computers with MPI and threading as well as cloud computing resources in Amazon, Azure and Google Cloud services together with a company internal server. And on the other hand, the real application complexity including the simulation model complexity as well as geometric complexity. Not to forget that the reuse of the existing material models as well as the whole simulation models are considered crucial features of the JuliaFEM package.

Recreating the wheel again is definitely not anybody's goal, and thus we try to use and embrace good practices and formats as much as possible. We have implemented Abaqus / CalculiX input-file format support and maybe will in the future extend to other FEM solver formats. Using modern development environments encourages the user towards fast development time and high productivity. For developing and creating new ideas and tutorials, we have used Jupyter notebooks to make easy-to-use handouts.

The user interface for JuliaFEM is Jupyter Notebook, and Julia language itself is a real programming language. This makes it possible to use JuliaFEM as a part of a bigger solution cycle, including for example data mining, automatic geometry modifications, mesh generation, solution, and post-processing and enabling efficient optimization loops.

Installing JuliaFEM

Inside Julia REPL, type:

Pkg.add("JuliaFEM")

Initial road map

JuliaFEM current status: project planning

Version Number of degree of freedom Number of cores
0.1.0 1 000 000 10
0.2.0 10 000 000 100
1.0.0 100 000 000 1 000
2.0.0 1 000 000 000 10 000
3.0.0 10 000 000 000 100 000

We strongly believe in the test driven development as well as building on top of previous work. Thus all the new code in this project should be 100% tested. Also other people have wisdom in style as well:

The Zen of Python:

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Errors should never pass silently.

Citing

If you like using our package, please consider citing our article

@article{frondelius2017juliafem,
  title={Julia{FEM} - open source solver for both industrial and academia usage},
  volume={50}, 
  url={https://rakenteidenmekaniikka.journal.fi/article/view/64224},
  DOI={10.23998/rm.64224},
  number={3},
  journal={Rakenteiden Mekaniikka},
  author={Frondelius, Tero and Aho, Jukka},
  year={2017},
  pages={229-233}
}

Contributing

Developing JuliaFEM encourages good practices, starting from unit testing both for smaller and larger functions and continuing to full integration testing of different platforms.

Interested in participating? Please start by reading contributing.

materials.jl's People

Contributors

ahojukka5 avatar janingithubaccount avatar juliatagbot avatar jvaara avatar kristofferc avatar nblomberg avatar ovainola avatar technologicat avatar terofrondelius avatar vjhaanpaa avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

materials.jl's Issues

isotropic_elasticity_tensor over written

WARNING: Method definition isotropic_elasticity_tensor(Any, Any) in module Materials at C:\Users\travis\.julia\packages\Materials\mSWeT\src\idealplastic.jl:5 overwritten at C:\Users\travis\.julia\packages\Materials\mSWeT\src\chaboche.jl:5.

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Separate Material properties and internal state variables

Currently the Material base struct looks like this:

mutable struct Material{M<:AbstractMaterial}
    stress :: Vector{Float64}
    strain :: Vector{Float64}
    dstress :: Vector{Float64}
    dstrain :: Vector{Float64}
    jacobian :: Matrix{Float64}
    time :: Float64
    dtime :: Float64
    properties :: M
end

where properties holds both material specific parameters (read from fields and material does not change them) as well as the internal state variables (stored in integration points and material integration needs them to keep track of its state).

Separating these would make sense for in the future if someone wants to automatize e.g. material_preprocess_analysis, material_preprocess_increment and material_postprocess_increment. Also keeping track of changes in parameters is something we need to look at in some point.

Proof of concept using Tensors.jl

I made a small example writing a perfect plastic material using Tensors.jl in https://gist.github.com/KristofferC/a7e9df0c94e9212604d5d1601c3e7c19. Running the benchmark (1000 timesteps) it takes

julia> include("dev/Materials/src/idealplastic2.jl")
  168.545 μs (12 allocations: 16.67 KiB)

The implementation probably has some bugs but the gist of it should be visible anyway.

Running

function bench_mat()
           mat = Material(IdealPlastic, tuple())
           mat = Material(IdealPlastic, tuple())
           mat.properties.youngs_modulus = 200.0e3
           mat.properties.poissons_ratio = 0.3
           mat.properties.yield_stress = 100.0

           mat.dtime = 0.25
           mat.dstrain .= 1.0e-5*[-0.3, -0.3, 1.0, 0.0, 0.0, 0.0]*mat.dtime
           for i in 1:1000
               integrate_material!(mat)
               mat.strain .+= mat.dstrain
               mat.stress .+= mat.dstress
           end
       end

which I hope should be an equal benchmark takes

julia> @btime bench_mat()
  1.437 ms (16638 allocations: 2.63 MiB)

which is ~10x slower and also allocates quite a lot.

I know my code doesn't fit perfectly into the existing codebase here but I just wanted to show that using Tensors can give good speedup and perhaps make the code clearer (since there is no need to preallocate things and Tensors.jl has some convenience functions).

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.