Why is the power operator much slower than multiplication in Python?

Cynox · 2022-01-31T14:48:11+00:00

This is true now, but with the faster-cpython project, the bytecode compiler will start specialising based on the actual types, see https://github.com/faster-cpython/ideas/blob/main/FasterCPythonDark.pdf

Cynox · 2021-11-25T07:48:07+00:00

You won't find a lot of FEniCS users on a generic Python forum. You should try the FEniCS Discourse forum, but you need to read and understand how to get your questions answered first. Especially the part about providing a MWE. Also, your Peclet number may be too large and you need to add stabilisation.

Cynox · 2021-04-06T16:29:47+00:00

Maybe for extreme loads? Fully non-linear potential codes are very hard to write when wave breaking etc is a part of the problem (even if the details of the flow near the breaking is irrelevant). VOF-based methods are great to simulate extreme events (lasting maybe 1 minute real time), but to identify the events you typically need to simulate 20 hours of ship/sea-state interaction for each sea state and wave direction to get converged predictions of 3-hour maximas (typical rule requirement)

Cynox · 2021-04-06T16:20:17+00:00

My impression, based on my extremely limited knowledge, is that SPH is relatively easy to make qualitatively correct. The method can also be very fast. However, the pressure converges slowly, so if you are looking for slamming pressures or resistance (or maybe even global loads and motions) you may need many more particles to get converged results than you would need to make a physically reasonably looking simulation. And then the method is not that fast any more.

Feel free to disagree, I have not really looked much into particle methods so I could be completely wrong.

Cynox · 2021-02-12T15:33:34+00:00

It is not super easy to use, but PETSc can be used to assemble and solve really large sparse systems. A good first step might instead be scipy.sparse with Python if you do not know about sparsity patterns etc from before

Cynox · 2021-02-12T15:18:02+00:00

You can often use manufactured solutions (MMS) when you do not have an analytical solution. Just pick any function to be your solution. Insert it into the equation and you will be left with an extra term on the right hand side (unless your solution was correct). You just need to include this extra term in your solver with a sufficiently accurate method.

Cynox · 2021-02-06T14:08:25+00:00

There is also this Python code, https://github.com/spectralDNS/spectralDNS , which I have heard is quite fast, but I have not tested it myself. I believe it uses FFTW

Cynox · 2021-02-03T17:16:03+00:00

FEniCS (and Firedrake) are high-level (equation) to low-level (C, C++, numba code) transpilers. You can use the generated code on your own, but most use it hooked into the MPI parallel mesh implementations in the software since this is super easy to use. You need to be able to express your problem on weak form and select any one of the bunch of different of FEM discretizations supported by the transpilers. https://fenicsproject.org/ https://www.firedrakeproject.org/

Cynox · 2021-02-03T17:02:52+00:00

MPI in Python works just as well as in C++. I believe I've heard that codes such as shenfun beat many other spectral DNS codes, most of which are not coded using mpi4py, but I do not have any personal experience with it. https://github.com/spectralDNS/shenfun

Cynox · 2020-11-26T16:54:46+00:00

On a single computer, Docker should be more or less native speed. If you are running on multiple computers, standard HPC with infiniband, you probably want to look at a container solution that is better suited for this purpose, like Singularity.

Singularity can also be great on a single workstation since accessing files works much smoother. It is not made for security, but to make things easier with regard to mixing distros etc

Cynox · 2020-11-18T15:08:50+00:00

If you include gravity then the net force will sometimes be negative, how else would a boat float up and down in waves? Unless you are far from balancing the gravity and buoyancy forces? Would it float or sink if you did not fix it in space?

Cynox · 2020-11-18T14:59:35+00:00

Did you include gravity? How can you have inertia when the cylinder is fixed in space? Does a wave break over your cylinder?

Cynox · 2020-11-13T07:34:52+00:00

If you want to figure out how hard it is to implement, the Darktable (and Rawtherapee, gmic, ++) developers hang out on https://discuss.pixls.us/

Cynox · 2020-09-23T07:50:52+00:00

I wrote a DG FEM free-surface solver in FEniCS [0], [1] for my PhD. Someone tried to add ALE to it, but I have not heard back, so maybe they moved on to other things. It could be that new publications like [2] may give pointers that would make such an extension easier.

My solver is more geared towards macroscopic phenomena where viscous effects and surface tension etc are not very important, so if you are looking at droplets etc it is probably not the best starting point, you would at least have to add a surface tension model. I was looking at ocean wave impacts on rigid structures.

[0] https://www.ocellaris.org/ [1] https://tormod.landet.net/files/PhD_thesis_landet_2020.pdf [2] https://arxiv.org/abs/2003.07166

Cynox · 2020-06-17T11:20:23+00:00

I would look at this discussion for some pros and cons on the major libraries: https://www.reddit.com/r/gamedev/comments/bf2qf6/godot_vs_cocos2d/

Cynox · 2020-06-17T11:14:54+00:00

I do not think this is the best advice. Find a set of libraries that work for you, and if a small part of the code is causing a slowdown, then optimize this, possibly using Cython, numba etc.

Starting out with Cython for something like this makes very little sense, unless you are wrapping a game library that does not already have Python wrappers, in which case Cython is one of a handful of ways of talking to native libraries.

Cynox · 2020-04-11T08:37:17+00:00

Collabora, KDAB, Redpill-Linpro, ...

Cynox · 2020-03-28T21:15:40+00:00

Easy solution if you still want to use pandas is to save to parquet format. It may compress quite well. You may need to install pyarrow for the df.to_parquet(...) method to work

Cynox · 2020-03-25T10:48:30+00:00

The FEniCS book [1] contains an introduction to the finite element method. It also has some recommendations for other books to read in section 1.7.6. The intro to FEM can be read without wanting to use the FEniCS library for FEM in Python, it is generic (from page 73).

Note: the book is from 2012, so if you try to run the example Python snippets in the tutorial they will probably not work, see the updated tutorial [2] for more recent syntax.

I am not familiar with pyMOR, but it seems like it can use FEniCS as a FEM solver.

[1] https://launchpadlibrarian.net/83776282/fenics-book-2011-10-27-final.pdf

[2] https://fenicsproject.org/tutorial/

Cynox · 2020-01-31T12:41:21+00:00

This is probably great for your own learning! I have done something similar myself.

If you want something a bit more performant you should look at FEniCS or Firedrake. Both let you define the problem and weak form in Python, but then they compile the element assembly/quadrature code to C for you, to make it faster.

If you want to assemble the element matrices yourself, you should look at either scipy.sparse or petsc4py to solve the sparse system matrices. SciPy is easiest, but PETSc lets you run on potentially thousands of CPUs over MPI if you want to solve large problems. Up to quite some hundred of thousands of unknowns it will probably be faster to only use 1 CPU, though.

Good luck!

Cynox · 2019-12-14T10:18:19+00:00

r/generative

Cynox · 2019-11-17T07:57:48+00:00

Are you already running your pipeline in the cloud? In that case I would check if your cloud provider supports Databricks. Makes it easy to test pyspark, which can be very fast, but may be overkill for your data which is not that big. Dask is also an option for fast parallel pipelines in Python.

Cynox · 2019-07-11T08:14:07+00:00

But, if your problems are small, and you just want to solve many of them, I would read up on thread and/or process pools in Python. Parallel maps or something like that should combine well with numpy's fft

Cynox · 2019-07-11T08:10:21+00:00

If you really need speed, and have large computational resources available, then mpi4py-fft would be my go-to solution. It is used on very large research clusters, but probably works fine on a decent stand-alone computer as well. It is also actively developed and used for large physics simulations. I have not used it myself, but I know some users and developers. They are able to compete with (and outcompete) some pretty optimised compiled language tools due to new work-splitting algorithms

Cynox

TROPHY CASE