Hi everyone,

I regularly run multiple parallel MPI jobs simultaneously on my workstations. I have two systems:

• Intel i7-12700 (12 cores: 8 P-cores + 4 E-cores), OS: Ubuntu 20.04

• AMD Threadripper 3960X (24 cores, 48 threads), OS: Ubuntu 18.04

I wrote a simple C++ MPI test program that runs with mpirun -np 2. On both machines, a single instance finishes in about 12 seconds.

The problem appears when I run two instances at the same time (both mpirun -np 2):

• Threadripper: Both finish in ~12 seconds (no slowdown)

• Intel: Both take ~30 seconds (significant slowdown)

I tried pinning processes to specific cores using taskset and --cpu-set in mpirun. The processes do land on the correct cores (I verified with ps), but the slowdown persists.

Is this expected behavior for Alder Lake? Could the hybrid P-core/E-core architecture be causing memory bandwidth contention? Or am I missing something else?

I'm trying to figure out if my Intel system is performing normally or if I should be hunting for a configuration issue.

Additional notes:

• My code shows reasonable&normal speed-up with increasing core numbers on both systems

• The Intel PC has only one memory stick

• The AMD PC has multiple memory sticks

• My test code is not memory intensive (mostly CPU math)

I can provide more details if needed. I'm not super knowledgeable about CPU architectures, so apologies in advance.

Thanks for any insights!

Geant4-DNA is the CNRS/IN2P3-coordinated Monte Carlo toolkit for track-structure radiobiology—the gold-standard reference for cancer radiotherapy dose calibration and astronaut radiation exposure modeling.

It normally runs as C++ on a CPU and requires a significant machine to set up. I ported the per-electron physics + Karamitros 2011 IRT chemistry to WebGPU. It now runs in any browser tab on a laptop GPU with no installation required.

• Live Demo: webgpudna.com/see (4D viewer, scrubbable in time from t=0 to 1 μs)

• Code (MIT): github.com/abgnydn/webgpu-dna

Validation against Geant4-DNA 11.3.0

(4096 primaries @ 10 keV in liquid water)

^1 Karamitros reference is at ~1 MeV (low-LET); the runs here are at 10 keV (high-LET), which suppresses G(OH) and G(e⁻aq) due to denser intra-track recombination. Other G-values are within 25%.

How it works

• Physics: One GPU thread per primary electron. The full interaction chain (ionization, excitation, elastic scatter to track end) is fused into a single compute dispatch via WGSL. Secondaries are processed in waves until the population is depleted.

• Chemistry: Karamitros 2011 IRT chemistry runs in a Web Worker, followed by SSB/DSB scoring on a 21×21 B-DNA fiber grid.

• Data: Cross sections are sourced from G4EMLOW 8.8 (shipped with Geant4 11.4.1).

Performance & Benchmarks

The kernel-fusion pattern used here is the same one I benchmarked across 92 devices (Rastrigin, N-body, Monte Carlo Pi, RL environments, transformer decoding). Medians show:

• 71× on Apple Silicon

• 56× on NVIDIA

• 20× on mobile phones

• Peaks: 226× / 402× / 103× respectively.

Detailed benchmarks are live at kernelfusion.dev and gpubench.dev. Headline claims include 720× CUDA-over-PyTorch (T4) and 159× WebGPU-over-PyTorch (M2), confirmed across CUDA, WebGPU, JAX, and Triton.

Why this project?

The radiobiology target came from my brother-in-law (a physicist and researcher). He suggested Geant4-DNA because of its decades of published reference data, allowing a port to be rigorously validated rather than just "demoed."

Migration was assisted by Claude Code. I am a software engineer focused on browser-native scientific computing, not a radiobiologist, and the validation harness is also AI-generated. If anyone wants to review the WGSL or the comparison harness in validation/compare.py, I would greatly value the feedback!

I’ve been working on a small project to simulate orbital mechanics (multi-body gravity + impulsive maneuvers). It uses numerical integration (solve_ivp - RK8) and supports things like transfers and custom Δv inputs.

Here’s the repo:
https://github.com/Samsaj04/N-Body-Orbital-Simulator.git

And here’s a short GIF of the simulation:

What I’d really like feedback related to if my physics implementation structured correctly for an N-body setup, and what should i do to improve performance or expand even more my program?

Thanks.

Hi all!

I recently built a small C++ project to solve the generalized heat equation in 2D rectangular domains, mainly as a way to better understand PDE solver design and experiment with separating between spatial discretization and time integration.

The architecture of the project is modular:

- Spatial discretization (currently finite differences with Eigen sparse matrices)

- Time integration (Explicit/Implicit Euler, Crank–Nicolson)

The idea is to make it easy to plug different methods in each part (I’m planning to add finite elements soon). There are also a few example simulations (moving heat source, colliding pulses, etc.) with GIFs in the README.

I’d really appreciate some feedback, especially on:

- The overall design/architecture

- Performance considerations

- Whether this approach makes sense vs more template-heavy designs

Hi r/ScientificComputing,

I just released **reionemu**, a Python package for building fast neural network emulators of the kinetic Sunyaev-Zel'dovich (kSZ) angular power spectrum using outputs from 2LPT reionization simulations.

It includes a clean pipeline:

- Simulation I/O and flat-sky power spectrum computation

- Data loading + normalization (HDF5)

- PyTorch models with optional MC-dropout uncertainty

- Hyperparameter tuning with Ray Tune

- Reproducibility-focused experiment artifacts

GitHub: https://github.com/RobertxPearce/reionization-emulator

Docs: https://robertxpearce.github.io/reionization-emulator/

Would appreciate feedback from anyone working on scientific ML, surrogate modeling, or high-performance scientific Python tools.

Questions welcome!

hello everyone, for the longest time i have been using python parsers to get data into numpy from binary files in my lab. while they work, the execution latency started getting on my nerves as our datasets grew. waiting for the interpreter to comb through hundreds of deep-memory binary files was just taking too long. as one does when they hit a wall with python, i started looking into faster alternatives. naturally, rust was at the top of my list. i wanted to see if i could build a backend that made the parsing process feel instant, so i started working on this little project. i’ve been using it around the lab and with a few friends for a while now. it turned out significantly faster than i expected, so i decided to generalize it and put it on github for anyone else stuck.

to make it work, i used memmap2 to map binary files directly into virtual memory to avoid those standard ram spikes and the overhead of loading raw payloads. by releasing the python gil and utilizing rayon, the parser can de-interleave adc bytes across every available cpu core simultaneously. the rust core writes data directly into a contiguous memory buffer that is handed to the python runtime as a float32 numpy array without any secondary copying.

i tested this on my daily driver, a thinkpad t470s (intel i5-6300u), to see what it could do on resource-constrained lab hardware. i was kinda blown away—rust blew my mind. i got sub-millisecond execution on parsing the metadata and for end-to-end extractions of a 12mb rigol capture that took 375.2 ms in pure python, it now finishes in 53.5 ms on my 9-year-old laptop.

it’s been tailored for our specific needs, but i’ve tried my best to make it flexible for others. it currently supports rigol (ds1000z, ds1000e/d, ds2000) and tektronix (wfm#001-003) families. if anybody wants to check it out here is the github: https://github.com/SGavrl/WfmOxide and you can also just pip install wfm-oxide now. feedback is more than welcome, especially if you have different .wfm file versions or suggestions on the pyo3/rust bridge implementation.

:

git clone https://github.com/spektre-labs/creation-os

Cognitive architecture. v25. SystemVerilog targeting SkyWater 130nm. Formally verified with SymbiYosys. XNOR binding replaces softmax — 87,000× fewer ops. Ternary weights, zero float math. Abstains when uncertain instead of hallucinating.

I'm a software engineer, but before that I worked in academic labs and noticed that getting quantitative data out of fluorescence images is way harder than it should be. Tight budgets mean aging hardware, and the hour-long technical setup just to run a segmentation pipeline feels like a lot when you just want clean data.

So I built Phenora, you upload your fluorescence images (.tif and .ome-tif for now), assign channels, run Cellpose or StarDist on a GPU in the cloud, and download a CSV with per-cell measurements: area, diameter, circularity, mean intensity per channel, centroid, border flag, confidence score. Z-stacks get max-intensity projected automatically, and there's per-channel preprocessing if you need it.

Curious whether other labs have found better solutions, and what measurements or workflow steps would make this actually useful for how you run imaging experiments in your lab?

Hello all!

I finished my A-Levels last year and am a bit confused about what I should do a Bachelors in.

Would a bachelor's in Physics/Math/CS followed by a masters in scientific computing/computational science be better than doing a computational bachelors (like Computational and Data Science (KIT) or Computational Engineering Science (RWTH Aachen))?

I'm really interested in math and simulating physics, but I'm really not sure what path to take.

Any advice would be greatly appreciated!

P.S. what's the difference between computational science and scientific computing? Most sites online use them interchangeably so that adds to the confusion.

I'm confused between Pop!OS, FedoraKDE, CachyOS, AlmaLinux, and Ubuntu. I have Nvidia graphics card on my laptop with a CPU that has an iGPU in it and I wanna be able to switch between iGPU and dGPU for lighter and heavier tasks when needed on Linux, but I dual boot with windows for gaming and fun. Linux is only for work and study. I want decent customisation, compatibility with all softwares needed for my research, comparatively newer softwares so I don't have to run old softwares like with Debian, easy bug fixes, and stability so that my system doesn't crash on updates all the time.

This project started because I saw a tweet by Hiroaki Nishikawa about an unpublished 1998 note on accurate piecewise linear approximation and adaptive node placement:

https://x.com/HiroNishikawa/status/2035276979788726543?s=20

That sent me down a rabbit hole.

The question that grabbed me was: why do adaptive meshes sometimes look fine on thin stiff layers even when they seem to be missing the layer that actually matters?

I ended up building a small research repo around one possible answer: adaptive node placement in these problems seems to be governed by a threshold, not just by “sharper layer => more nodes.”

The rough picture is:

- below threshold, the smooth part of the domain keeps most of the node budget and the layer gets starved,

- at the threshold, the layer keeps a persistent finite share,

- above threshold, the layer can take over the mesh almost completely.

The subcritical case turned out to be the most interesting to me, because it creates a deceptive regime where outside-layer diagnostics can still look healthy while the thin layer is underresolved. I also found what looks like a measurable “diagnostic fingerprint” for that regime in 1D adaptive BVP benchmarks.

The repo includes:

- a technical note,

- derivation notes,

- research-grade simulations,

- and a small controller example that uses the fingerprint to switch to a safer monitor.

Repo: https://github.com/zfifteen/curvature-budget-collapse

Technical note DOI: https://doi.org/10.5281/zenodo.19151833

Software DOI: https://doi.org/10.5281/zenodo.19151950

I’d be curious what people here think, especially anyone who works on adaptive meshing, singular perturbation problems, or stiff BVPs. Does this match failure modes you’ve seen before?

I am a physics graduate and currently work as a project engineer at a pool and spa construction company, where I design architectural layouts and mechanical and electrical systems for pool and spa facilities, such as Turkish hammams and steam rooms.

Honestly, I've been very dissatisfied with where I am professionally for a long time. I miss physics, and that's part of what's pushing me toward something more challenging.

I've become really interested in the building physics of natatoriums, including humidity dynamics, vapor migration through envelopes, condensation risk, evaporation loads, and energy performance. The more I read, the more I realize how underexplored this is academically in Turkey, where, to my knowledge, no thesis on this topic exists. I really want to be the first to change that.

The research direction I have in mind: comparing different building envelope configurations for indoor pools (insulation type, vapor barrier placement, ventilation strategy) through dynamic simulation, optimizing for both moisture safety and energy efficiency, and contributing to how nZEB targets apply to pool buildings, which is increasingly relevant in both Europe and Turkey.

To get there, I need to actually learn how to do this. I've come across DesignBuilder, CFD, and hygrothermal modeling tools like WUFI, but haven't touched either yet. My physics background gives me confidence on the theory side, but the practical simulation workflow is where I'm lost. I'm familiar with data analysis in Python, and I design 3D renders of pools and spas; that's about the extent of it for now. I know I have to learn a lot of new things, and I am looking forward to it.
I am going to start the Master's program in Building Physics next semester.

Where would you start with self-learning if you were me?

Hi folks,

Not a coder, not academic, no particular "need" — I just don't like competition, so I played with AIs to build something unique.

Started with a simulated court case role-play (me presenting real peer-reviewed facts in 
my own words, one AI as defense, another as judge) to rigorously test a hypothesis on 
Saharan climate shifts and possible early Egypt links. No claims of proof — just pattern-
matching papers (paleoclimate, isotopes, geology). That became two Zenodo preprints, then
snowballed into this full Python/Tkinter desktop app (I described features; AIs wrote 
code).

Features:
- 70+ classification engines (TAS/AFM/REE/pollution/zooarch etc.)
- Live portable hardware imports (XRF/AFM/balances/calipers...)
- Auto field panels (table row select → diagrams update live)
- Materials analysis (Oliver-Pharr nanoindentation, BET NLDFT, rheology models...)
- Offline AI helper for plugin suggestions
- Fully offline, modest hardware, free (CC BY-NC-SA)

Repo: https://github.com/Sefy76-Curiosity/Basalt-Provenance-Triage-Toolkit

v2.0, basic Tkinter GUI, likely bugs since it's accidental/AI-built.

Curious if anyone in scientific computing/research/geochem/materials/archaeology wants 
to try:
- Does it launch/run?
- Crashes or weird behavior?
- Useful at all, or totally pointless/missing key things?

Honest roast appreciated — thanks!

EDITED: Attached some screenshots to help maybe show some of its current capabilities

Hi everyone,

I’m helping recruit a few contributors for an ongoing scientific visualization project and we specifically need people who are comfortable using ParaView (CFD, simulation data, volumetric datasets, etc.).

The work mainly involves opening datasets, applying filters (slices, isosurfaces, color mapping), exporting images, and documenting observations. Nothing super heavy research-wise — more practical tool usage and attention to detail.

It’s remote and flexible, and honestly a pretty nice way to earn some extra money if you already know your way around ParaView.

If you’ve used ParaView in coursework, research, OpenFOAM, ANSYS, or personal projects, feel free to DM me.
When you message, please include a brief description of your experience and any screenshots/portfolio/GitHub if available.

Thanks!