dolfinx
ModelingToolkit.jl
dolfinx  ModelingToolkit.jl  

18  15  
777  1,427  
5.0%  1.0%  
9.7  9.9  
3 days ago  2 days ago  
C++  Julia  
GNU Lesser General Public License v3.0 only  GNU General Public License v3.0 or later 
Stars  the number of stars that a project has on GitHub. Growth  month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
dolfinx
 What's your main programming language?

rodin alternatives  mfem and FreeFemsources
7 projects  8 Mar 2023

Learn PDE constrained optimization
One thing that is a pain when learning this stuff is that actually performing the optimization requires a good understanding of the numerical discretization of PDEs. Finite elements are a natural choice because it is very easy to characterize the adjoint with this formulation. There are some good free tools that you can use to actually learn and do some computations yourself. The first is hIPPYlib (paper, code), which is built on top of FEniCS (link), for which there are many good tutorials. Beware trying to install this on Windows though. You will need to work in Docker or in Ubuntu via Windows Linux Subsystem.

Open source FEA tools instead of ANSYS Workbench and APDL
If you're ok with coding, fenics is a solid place to start. Also if you're comfortable with coding, openfoam is FVM, rather than FEM, but it can handle solidmechanics.

Eighty Years of the Finite Element Method: Birth, Evolution, and Future
> FEniCs made FEM so easy
https://fenicsproject.org/
Indeed, was blown away when I saw it for the first time over a decade ago, compared to the convoluted C++ FEM libraries I had seen before that.

Best Python package(s) to solve PDEs numerically?
Have you looked at FEniCS? Pretty much everything else I'm aware of is probably overkill (e.g., MOOSE in C++, HYPRE's Python bindings, etc.)

Opensource FEA software
FEniCSx is quite good.

The Julia language has a number of correctness flaws
You mean Python? For many research tasks it's fine. High level libraries let you define your computation in a minimal amount of code. FEniCS is a great example of this  underneath it compiles the abstracted high level stuff to calls to lowlevel libraries that do the heavy lifting. For many applications you can just write vectorized code with Numpy that performs well, or use Numba to JIT what you can't vectorize. For some tasks, however, you need interfaces that don't exist in the high level libraries, and that was the case for me.

What's a good book to learn to numerically solve ODEs and PDEs in python?
I just came across FEniCSX. I’m not sure if it’s what you want but here’s the description:

Okay, let's end this Tabs vs Space debate once and for all
Fenics: Very popular finite element framework “UseTab: Never” https://github.com/FEniCS/dolfinx/blob/main/.clangformat
ModelingToolkit.jl

Mathematically Modelling a PRV
I'd use a modeling tool like https://mtk.sciml.ai/dev/ Using the standard library, you wouldn't need to come up with all equations yourself. Depending on the details of your use case, system identification as suggested before might be a faster approach though.
 Simulating a simple circuit with the ModelingToolkit
 “Why I still recommend Julia”
 ‘Machine Scientists’ Distill the Laws of Physics from Raw Data

How do I force it to answer in a decimal format.
In this case, yes, this should just be done numerically. But using symbolic transformations to optimize numeric code is also a really neat application of symbolic computing that doesn't get enough attention, imo. [This library](https://github.com/SciML/ModelingToolkit.jl), for example, uses symbolics to do sparsity detection, automatic derivative/gradient/jacobian/hessian calculations, index reduction, etc. to speed up numerical differential equation solving.
 Julia 1.7 has been released

[Research] Input Arbitrary PDE > Output Approximate Solution
PDEs are difficult because you don't have a simple numerical definition over all PDEs because they can be defined by arbitrarily many functions. u' = Laplace u + f? Define f. u' = g(u) * Laplace u + f? Define f and g. Etc. To cover the space of PDEs you have to go symbolic at some point, and make the discretization methods dependent on the symbolic form. This is precisely what the ModelingToolkit.jl ecosystem is doing. One instantiation of a discretizer on this symbolic form is NeuralPDE.jl which takes a symbolic PDESystem and generates an OptimizationProblem for a neural network which represents the solution via a PhysicsInformed Neural Network (PINN).

Should I switch over completely to Julia from Python for numerical analysis/computing?
There's a very clear momentum for Julia here in this domain of modeling and simulation. With JuliaSim funding an entire modeling and simulation department within Julia Computing dedicated to building out an ecosystem that accelerates this domain and the centralization around the SciML tooling, this is an area where we absolutely have both a manpower and momentum advantage. We're getting many universities (PhD students and professors) involved on the open source side, while building out different commercial tools and GUIs on top of the open numerical core. The modeling and simulation domain itself is soon going to have its own SciMLCon since our developer community has gotten too large to just be a few JuliaCon talks: it needs its own days to fit everyone! Not only that, in many aspects we're not just moving faster but have already passed. Not in every way, there's still some important discussion in controls that needs to happen, but that's what the momentum is for.
 What should a graduate engineer know about MATLAB?

I'm considering Rust, Go, or Julia for my next language and I'd like to hear your thoughts on these
Julia has great support for modeling, have a look at ModelingToolkit.jl. From the README:
What are some alternatives?
Gridap.jl  Gridbased approximation of partial differential equations in Julia
casadi  CasADi is a symbolic framework for numeric optimization implementing automatic differentiation in forward and reverse modes on sparse matrixvalued computational graphs. It supports selfcontained Ccode generation and interfaces stateoftheart codes such as SUNDIALS, IPOPT etc. It can be used from C++, Python or Matlab/Octave.
mfem  Lightweight, general, scalable C++ library for finite element methods
DifferentialEquations.jl  Multilanguage suite for highperformance solvers of differential equations and scientific machine learning (SciML) components. Ordinary differential equations (ODEs), stochastic differential equations (SDEs), delay differential equations (DDEs), differentialalgebraic equations (DAEs), and more in Julia.
taichi  Productive, portable, and performant GPU programming in Python.
NeuralPDE.jl  PhysicsInformed Neural Networks (PINN) Solvers of (Partial) Differential Equations for Scientific Machine Learning (SciML) accelerated simulation
pykokkos  Performance portable parallel programming in Python.
Symbolics.jl  Symbolic programming for the next generation of numerical software
libmesh  libMesh github repository
FreeFemsources  FreeFEM source code
SymEngine.jl  Julia wrappers of SymEngine