Home on ben.land

Simulating and visualizing the double slit experiment with Python

Sat, 31 Jan 2026 00:00:00 +0000

Several years ago I wrote a post on simulation the Schrodinger Equation that had a brief intro to Quantum Mechanics paired with a simple Python simulation and visualization. That ended up being one of my more popular pages, despite the follow up post with 2D visualizations being arguably more visually appealing. Probably down to the titles in the end — people love a Python simulation. After that I was following up on trying to do 3D simulations on the GPU, which diverted me down the path raytracing and photorealistic rendering, then I got into beekeeping and astrophotography and just didn’t get back to this… until now!

Deep-sky images vol. 3: a refined technique for higher quality results

Tue, 30 Dec 2025 00:00:00 +0000

It’s been a bit over a year since my last astrophotography post highlighting galaxies and a bit over two years doing serious astrophotography. Even though my rig has been nearly static, with the exception of adding an Antlia ALP-T 5nm Ha+Oiii filter to retire the Svbony and its impressive Oiii halos and replacing my flexible spider vane with a rigid one including better adjustment screws for the secondary mount, I have learned a lot about how to handle the raw data to produce more impressive results. Now it’s your turn, or you can skip to the end and just enjoy the images.

Receiving and decoding transmissions from weather satellites

Sat, 31 May 2025 00:00:00 +0000

I’ve always been a bit fascinated by radio and wireless communication, so I decided to get some commodity SDR dongles like the RTL-SDR blog V4 and see what I could hear, if you know what I mean. Several DIY antennas and long distance receptions later, I started to wonder what else (beyond communication with other enthusiasts) easy access to an SDR receiver could unlock. That led me down the path of amateur satellite reception — a relatively niche corner of the already niche amateur radio hobby.

BeeLogger, an ESP32-based sensor platform for monitoring a beehive

Sun, 06 Apr 2025 00:00:00 +0000

Hive One sitting on the first BeeLogger platform after surviving the 2024-2025 Winter.

With the success of my beehive livefeed and bee-counting neural network in monitoring bee activity, I decided last year it was time to augment my data collection capabilities. Beyond the general activity of the bees that I can already assess, there are several aspects of bee health that can be addressed with off the shelf sensor technology:

Deep-sky images vol. 2: galaxy edition

Sun, 13 Oct 2024 00:00:00 +0000

The last astrophotography post covered all the details on the technique for capturing deep-sky images and went into some detail about precisely how to interpret these images. Check it out if you’re not sure what you’re seeing below. The only downside of the last post is that it only showcased the “best” images of various different types. Unfortunately, the “best” criteria ruled out a lot of what I consider to be more interesting images: other galaxies. I did get the Whirlpool and Triangulum galaxies in, but these are among the brightest. The Leo Triplet image is more typical of the majority of galaxies to image: small enough to be near typical resolution limits, pretty dim, and perhaps a bit hard to appreciate if you don’t know what you’re looking at.

Several ways to "add two number strings"

Sun, 29 Sep 2024 00:00:00 +0000

I was presented with an anecdote from a guy doing software development job interviews that went like this:

   Interviewer: Show me how you would add two big numbers represented as strings?
   Candidate:   How about `adder = lambda a,b: return int(a)+int(b)`?
   Interviewer: No, the numbers are too big `int(a)` would fail.
   Candidate:   ...

First off, Python is a bit unique among modern languages in that it does support integers of arbitrary size out of the box with no special fiddling. It generally uses native size integers but transparently supports integers as large as will fit in the system’s memory, and has since at least Python 2.5.

Deep-sky images vol. 1: from the Philadelphia suburbs

Sat, 28 Sep 2024 00:00:00 +0000

None of the images here were taken with this rig, but its where I started in 2010.

It’s been a while since my last post, largely due to time spent on beekeeping and astrophotograpy. So, to move the needle, I’ve pulled together some of the best images of deep-sky (meaning: far away) objects I’ve taken at night from the relatively light polluted (Bortle 7) Philadelphia suburbs. I’ve included with each image some notes about the acquisition, general information about the target (distance, type of object, etc), and a pretty thorough description of the visible objects (what am I seeing?). All of these images are from my yard, with streetlights and porch lights nearby, using a technique I described in a previous post to collect calibrated data for fighting light pollution.

Astrophotography from light polluted skies

Sun, 24 Dec 2023 00:00:00 +0000

I’m now the proud owner of a Sky Watcher Quattro 200P on a EQ6-R Pro mount. Currently paired with a Sony α7C and coma corrector, along with the occasional OSC filter. Guiding to 0.6" with a ZWO ASI120MM on a Svbony 60mm F/4 106SV guide scope. Living the dream.

Counting bees in a video feed with a neural network

Fri, 15 Dec 2023 00:00:00 +0000

Technically not from the BeeCam, but about the same perspective.

After the previous post where I setup a live stream for my beehive, I decided I wanted a quantitative measure of the bee activity going into the winter. The most straightforward thing to start with was simply identifying and counting the bees in each frame of the feed. While not directly measuring anything particularly interesting, this should be well correlated with foraging activity at any time. One might imagine going a step further and identifying attributes about the bees in the image, but I’ll consider that a future improvement for now. A lot of time has passed since the initial development (the year flew by!), but now that I have decent backlog of data, it’s a good time to document my process for counting bees in a video feed.

Hacking together a live stream video feed for a beehive

Tue, 20 Jun 2023 00:00:00 +0000

A still frame from the BeeCam. The carnage on the front is a rogue black cherry. The bees are friendly.

This post is begging for an initial post on how I ended up with bees, but as this isn’t a beekeeping blog (yet), I’ll first go into some detail on the live stream I setup to watch the bees come and go. There are a lot of live streaming guides targeted at social media enthusiasts, but these gloss over the weatherproofing and power difficulties of outdoor deployments, as well as assume some app (Youtube, Twitch, …) is going to be involved (via a mobile phone). So, I started to piece together bits of tech to arrive at something robust and self-hosted.

Low level concepts in quantum computing

Sun, 12 Feb 2023 00:00:00 +0000

This post will try to give a grounded conceptual (with a side of mathematical) understanding of quantum computing by comparing it to classical computing. This can be a bit tricky, since robust quantum computers are still a nascent technology, but I’ll stick to the low level concepts here instead of getting into the esoteric science that is programming quantum computers. Primarily I want to motivate why quantum computing is fundamentally different from classical computing, and how it is the same.

Special Relativity, conceptually speaking

Sun, 29 Jan 2023 00:00:00 +0000

When people learn that I have a physics degree, they typically reveal that they have a question about physics they’ve always wanted to have answered. Often it’s something along the lines of trying to understand time dilation in relativity: the phenomenon where observers at different velocities disagree about the amount of time between events (in other words, the rate of time). To address that question, here’s a refined version of what I usually sketch out on a napkin.

DIY smart plug with integration to Home Assistant

Thu, 12 Jan 2023 00:00:00 +0000

Motivation

In this post, I will run through the construction of a 30A 125V smart plug based on the ESP32 platform that can be either controlled from a simple webpage, or integrated into a system like Home Assistant.

While there are many good commercial options for smart plugs for home devices, and there are many industrial options for controlling heavy machinery, there’s a bit of a gap in the market for easy to use smart plugs for more heavy-duty workloads. By “heavy-duty” here, I mean larger than 15A @ 125V to be switched. This is (likely) because the standard “three prong” plug (NEMA 5-15) is only rated for 15A. Devices with NEMA 5-20 or better may exist, but one of the loose design constraints here will be supporting a NEMA 5-15 plug, at least in an initial phase, while being able to switch large currents. (Note: I am no expert here, and following any of my advice is done at your own risk!)

Photorealistic rendering with global illumination from scratch

Mon, 22 Aug 2022 00:00:00 +0000

In a previous post I discussed the development and capabilities of the sdfray package, which represents scene geometries as signed distance functions (SDFs), and supports several rendering approaches. In this post, I’ll be discussing the rendering approach I previously called true optics, which tries to realistically simulate most commonly observed properties of light, to achieve a maximally realistic image. This falls under the umbrella of global illumination as it can accurately reproduce caustics and the effects of intra-illumination, which I would say is a bold enough claim to warrant some evidence.

Raytracing and Raycasting with Signed Distance Functions

Mon, 15 Aug 2022 00:00:00 +0000

I stumbled onto the concept of using signed distance functions (SDFs) to represent a three dimensional geometry almost by accident when looking up ways to generate 3D models (for 3D printers) programatically, as opposed to using traditional CAD software. Unlike more standard CAD processes for 3D printers, which tends to boil down to triangular meshes, SDFs are mathematical functions that can represent exact surface curvature. As I also have a background in physics-accurate optics I realized this property made SDFs ideal for high precision optical simulations, which is essentially the same thing as photo realistic rendering. It was immediately apparent with some quick googling that other people had previously explored the same ideas to great effect, but was interested enough that I got hooked, and decided to play around with writing my own rendering engine based on SDFs, and learn a bit along the way.

Visualizing complex numbers and wavefunctions in one and two dimensions

Thu, 17 Mar 2022 00:00:00 +0000

The HSV colorspace, matching angle to hue around the circle, and saturation to the radius.

In a previous post on simulating quantum mechanics, I visualized the complex numbers in the wavefunctions by plotting their real, imaginary, and magnitude (square root of probability) separately. As I mentioned briefly in that post, this is a bit lacking compared to the more intuitive way to think of complex numbers: as a magnitude and phase (angle). The magnitude was accounted for, but the real and imaginary parts can obfuscate the phase.

Simulating quantum mechanics with Python

Wed, 09 Mar 2022 00:00:00 +0000

I was reading an article about scientists who created an accurate simulation of the behavior of simple cells, to really understand their dynamics, and I wondered whether it would be possible to do the same for “simple” atoms or molecules. Some quick exploration into the topic indicates that’s a fairly difficult problem, not to mention an area of active research for multi-electron atoms and simple molecules alike. That said, I can certainly take a stab at some simpler simulations and see how far it can scale up, which should result in some interesting visualizations at the very least.

A possible optimal solution to Wordle

Fri, 11 Feb 2022 00:00:00 +0000

At this point, probably everyone has heard of the game Wordle where one has six guesses to determine a secret five letter word. Each time you guess, the letters are colored to represent the following:

Gray — the letter is not in the word.
Orange — the letter is in the word, but not at this position.
Green — the letter is in the word at this position.

There are lots of strategies floating around for how to play this game optimally, from looking at character distributions at different positions and picking words with common characters in those positions, to using good old-fashioned intuition. Here, I’ll describe a solution that can be summarized as follows: the optimal word to guess is the word that results in the fewest possible words remaining, on average.

Adding client-side search for a statically generated Hugo website

Thu, 02 Dec 2021 00:00:00 +0000

Statically generated sites, like this blog and other sites built with tools like Hugo, are great for simple deployment and fast serving pages, but they lack some features like live editing and other dynamically generated content. Fortunately, most of these shortcomings have been sorted out by the community. Here, I’ll focus on search functionality.

Typically, when searching some website, the query will be sent to a server, which will perform some internal scan of its database, and build a page containing results that match the query. This dynamically generated page will then be sent to the client to be shown on the browser. In a statically generated site, this is simply not an option. There is no database to query, no framework on the server to search anything, and no concept of generating pages on the fly.

Beginnings of a low frequency RF receiver with a MicroZed FPGA board

Sun, 31 Oct 2021 00:00:00 +0000

My initial motivation was to build a device that could receive and decode the WWVB time code broadcast from Fort Collins, CO at 60 kHz, and used to synchronize so-called atomic clocks seen on people walls or on their wrists. These clocks really just decode the broadcasts on the WWVB station, which is synchronised to actual atomic clocks co-located with the radio broadcast. The protocol is simple, well understood, and certainly commercial receivers exist, which means a DIY solution has a high likelihood of actually working. The idea here was to build a direct conversion receiver in the style of software defined radio (SDR) on a field programmable gate array (FPGA). This was a great intersection of my interest in FPGAs and SDR, with some mildly practical application, and without having to invest in specialized hardware capable of receiving higher frequencies typical shortwave amateur ratio or FM/AM audio transmissions.

Raspberry Pi IPv4/IPv6 router for a dual WAN household

Thu, 28 Oct 2021 00:00:00 +0000

When I ended up with a second connection to the internet (courtesy of being a Comcast employee), there was a potentially painful decision to make. Xfinity includes a lot of streaming features, which require being on Xfinity’s network to utilize. Key here is the ability to turn many streaming devices (including a Roku) into a live and on-demand streaming platform for TV with the Xfinity Stream app. So, do I convert the entire home network over to Comcast’s asymmetric cable network, or do I keep the symmetric gigabit fiber connection already in place and miss out on streaming? Fortunately, there is a third option: connect the streaming devices to the Xfinity network, and maintain the symmetric gigabit fiber for the rest of the machines. What’s better is that it’s totally possible to accomplish this with consumer networking devices, without having to purchase (much) new hardware.

Do-it-yourself dimmable LED patio lights

Sun, 10 Oct 2021 00:00:00 +0000

We recently had a new large patio put in to replace the old, broken one, but there was no outdoor lighting or even outdoor power, so it was quite difficult to enjoy this investment after dusk. Instead of hiring an electrician and contractor to remedy this, I decided to flex my handyman skills, and do it myself.

The design goal was overhead string lights, approximately 10 feet off the ground, so that patio-goers were unlikely to hit them, even with raised arms. The string should zigzag across the patio, requiring around 140ft of lights. Edison bulbs were an option, for aesthetics, but LED options were more attractive, since the lower temperatures and heat allow for shatter-proof plastic bulbs. The longer life, and lower energy usage were anther plus. Modern LED bulbs can have an extended ‘filament’ similar to the Edison style, though this can increase cost. The other main factor here is bulb spacing. Cheaper options tend to be 2+ feet apart, which significantly reduces the appeal (and brightness) of string lights. We opted for some round, clear, plastic LED bulbs spaced at one foot intervals on 50’ strands found on Amazon.

Leaving academia for industry: from physics to data science

Mon, 20 Sep 2021 00:00:00 +0000

This post is a (likely one-off) departure from the technical themes of previous posts to focus a bit on the career trajectory and prospects of academia compared to industry. I have had the opportunity to develop a lot of very marketable skills in particle physics research. The chance to manipulate and analyze some of the biggest datasets in big data is itself a great resume booster. Combine that with the programming, analytical, and mathematical skills one needs to excel in particle physics, and potential industry jobs are plentiful. Toss in a bit of machine learning, and the ability to distill and convey information effectively, and you’re quite marketable indeed. Top it off with a Ph.D. and a track record of mentoring students, and suddenly you’re a bit of a datascience unicorn.

Deconvolving photon detector signals with convolution to count photons

Thu, 24 Jun 2021 00:00:00 +0000

Neutrino detector often detect neutrino indirectly by recording information about photons produced in the neutrino interaction. Simulations are used to understand how light propagates through the detector, and this allows one to understand the kinds of optical signals produced by different types of interactions. Many techniques can be exploited to maximize the amount of information detected, but ultimately the data boils down to the time at which photons are detected on light-sensitive elements in the detector. These light sensitive elements could be photomultiplier tubes (PMTs), large area picosecond photodetectors (LAPPDs), silicon photomultipliers (SiPMs), or something more exotic. All ultimately produce some electrical pulse, which is measured as a time-varying voltage.

GDML importer for simulating DUNE in Chroma

Wed, 02 Jun 2021 00:00:00 +0000

Photon simulations for DUNE

The DUNE experiment is nominally a time projection chamber (TPC), which records the paths of high energy charged particles by collecting the ionized electrons left in their wake. Studying the paths of these particles gives information on the particular type of physical interaction responsible for creating them. DUNE is particularly interested in the particles produced by neutrino interactions, and will be constructed in a high intensity neutrino beam to make those interactions much more common. The energy deposited by the high energy particles as they travel through the liquid argon does more than just ionize the argon atoms, it also produces scintillation and Cherenkov light. These optical signals can provide complimentary information to the tracks from the TPC, and are especially interesting for lower energy physics, like solar neutrino interactions.

Automating computer games with a contemporary software stack

Fri, 21 May 2021 00:00:00 +0000

A historical perspective on automation

As I’ve mentioned before, the desire to automate (cheat, bot, macro, …) games like RuneScape was the primary reason I learned to program at such a young age. Back in 2002, there was no Stack Overflow to rely on for code snippets, no Reddit to connect me with like-minded individuals in the niche of game automation, and (thankfully) no YouTube to host poorly-edited video tutorials. The one saving grace was that Google, at least, had been around for four years, so twelve-year-old-me could google for “runescape cheats” and find utilities people had designed to make the game less monotonous.

Physics posters from graduate school and beyond

Tue, 11 May 2021 00:00:00 +0000

One could argue that the goal of a physicist is to write and publish peer-reviewed papers, which incidentally require enough research, novelty, and scientific merit to pass peer-review at some major journal. There are, however, a lot of papers out there, so some advertising is necessary in the form of conference talks to generate interest in the physics community or public talks to inform the masses. Sometimes a more interactive discussion is a good idea, especially when discussing new approaches or preliminary results, or when a funding agency wants to show off the ongoing research to a bunch of suits who really don’t want to sit through physics talks. This is the realm of the poster, which is really just a prop to point to when talking about ideas.

Setting up a large Synology NAS for particle physics simulations

Tue, 04 May 2021 00:00:00 +0000

Particle physics is the original big data field, and science in general produces some of the largest datasets in the world. The desire to store, transfer, and process particle physics data has driven the development of large, distributed computer clusters and the internet itself. Underpinning all of this is the ability to store and access the data produced by experiments and simulations. Many technologies exist to facilitate this, including tape drives for long-term archival, solid-state drives for high-bandwidth data storage, and the venerable hard disk drive that falls somewhere in between tape and solid-state. To store large, petabyte-sized datasets, thousands and thousands of individual drives are used together to provide redundancy for failure of individual drives, fast access to any particular part of a dataset, and enough raw storage to hold entire datasets.

WindMouse, an algorithm for generating human-like mouse motion

Sun, 25 Apr 2021 00:00:00 +0000

This is a post about an algorithm I developed over a decade ago to generate mouse movements that could be mistaken for actual human input. The algorithm, called WindMouse, has been used in many different places, as a quick google search will show, and often appears unattributed in stackoverflow questions, despite being licensed under the GPL. Since it’s seen rather wide use, and was presented by a much-younger me with little explanation, I figured it would perhaps be beneficial to provide some context and insight into the algorithm.

Unbinned maximum likelihood fitting with kernel density estimation

Sun, 18 Apr 2021 00:00:00 +0000

I have previously posted about the basics of maximum likelihood fitting, and how to perform such a fit using binned histograms for both the data and the probability density functions (PDFs). For context, and a gentler introduction to the math, I’d suggest skimming the previous post. In summary, maximum likelihood fitting is a method of statistically determining the makeup of some dataset under the assumption that all possible types of data are described by a finite set of PDFs. Each of the PDFs represent a particular type or class of events in the dataset and describe how the events in that class are distributed along some observable quantities. Observable quantities are things that can be measured for each event, such as energy or position, and different classes of events should have distinct distributions for the maximum likelihood technique to work well. When these PDFs are weighted by a number of events in the class it describes and added together, the resulting distribution can be compared to the total dataset. The correct weighted sum of the PDFs will be maximally similar to the dataset, and an optimization algorithm can be used to find the correct weights.

Computing π to many digits with a custom math library

Tue, 06 Apr 2021 00:00:00 +0000

In previous posts I implemented a math library that can do perform computations on arbitrarily large (or small) numbers. First came algorithms to manipulate lists of symbols as integer numbers, which represented signed numbers in a little endian binary format with an arbitrarily large number of bits, along with the mathematical operations of addition, subtraction, multiplication, and division. Then this was extended to approximate real numbers in the form $a2^b$ where $a$ and $b$ are integers using the representation and manipulations from the earlier post. The ultimate goal here was to implement a math library for the emulation of a simple Turing-complete programmable machine L2, but so far has only been implemented in Python using language features of L2 (except for a teaser of L2 code for integer math). But now that I have a custom math library capable of arbitrarily precise floating point calculations, given enough time, I might as well use it for something interesting, like calculating $\pi$ .

Floating point math algorithms without float datatypes or math-specific hardware

Mon, 05 Apr 2021 00:00:00 +0000

Following the previous post on implementing integer math without utilizing some lower-level math implementation, this post will extend the functionality to approximate real numbers using the building blocks for representing integers. As before, this is targeted for the simple LISP-like language L2 but will be done with Python code first, using only functionality present in L2.

Representation

Rational numbers can always be represented exactly as ratios of integers, or a fraction. Many rational number can be represented exactly as a decimal fraction that terminates (has a finite number of digits), and the remaining rational numbers can be represented as decimal fractions with repeating patterns at the end. To work with only rational numbers, a representation that stores the numerator and denominator can exactly represent any possible calculation.

Integer math algorithms without integer datatypes or math-specific hardware

Wed, 31 Mar 2021 00:00:00 +0000

I previously posted about simple, programmable, Turing-complete machines. That post discussed a programmable machine that optimized ease-of-programming and ease-of-implementation while still being able to run any program. With those goals in mind I put together a Python package L2 which emulates such a simple machine in software. For the L2 emulator, I used math operations and datatypes that were simply provided by Python to create the mathematical functionality. This is a bit of a cop out, because mathematical operations are a very important part of computing, and a machine that simply borrows them from Python, which uses the CPUs math operations, cannot really said to be simple. With that in mind, and in light of a recent post about implementing exp and other functions without using some standard library, I thought it would be neat to try to bootstrap mathematical operations from the cells, symbols, and primitive operations of L2.

Spectral photon sorting for neutrino detection

Tue, 16 Mar 2021 00:00:00 +0000

Detecting neutrinos

Neutrino interactions produce energetic electrons which in turn produce Cherenkov (directional) and scintillation (isotropic) photons in scintillators.

Rare processes like neutrinoless double beta decay, which produces two energetic electrons, can also be studied by neutrino detectors.

SNO+ experiment nearly full of scintillator

Mon, 01 Mar 2021 00:00:00 +0000

The SNO+ experiment will eventually search for neutrinoless double beta decay ( $0\nu\beta\beta$ ) by loading Tellurium metal into the organic liquid scintillator Linear alkylbenzene (LAB) and precisely measuring the energy of electrons produced by double beta decay of Te $^{130}$ . The amount scintillation light produced by the double beta decay electrons is proportional to their energy, and the energy distribution of the electrons encodes the physical process that resulted in the double beta decay. Usually, two electrons and two neutrinos are emitted, and the neutrinos carry away a fraction of the energy, resulting in electrons with less energy than the nuclear transition (about 2.6 MeV). However, if neutrinos and anti-neutrinos are the same thing (that is, if neutrinos are Majorana particles) the neutrinos could be virtual particles of the interaction, and only electrons would be emitted. These electrons would have the full energy of the nuclear transition, about 2.6 MeV.

Implementing exponentiation without a standard math library

Wed, 24 Feb 2021 00:00:00 +0000

Exponentiation, or $x^y$ , is typically provided by a standard math library on the system you are using as the function pow(x,y), or similar. However, if you are programming on some embedded system without standard libraries, or have some externally imposed constraints preventing you from using standard math libraries, it is possible to implement it yourself. Of course, you could look up existing implementations, copy them, and call it a day, but where’s the fun in that?

Reinforcement learning puzzle solving with a "Deep Q-Learning" neural network

Mon, 15 Feb 2021 00:00:00 +0000

Solutions to the puzzle

This is (perhaps?) the final post in the series about solving a dust-matching puzzle pictured below, where the whole cluster of similar-colored piles are removed when one in the cluster is clicked, and the piles the fall down and towards the center to fill any voids that are created. I wrote a depth first search (DFS) solver that is able to find the best solution, given enough time, and have also written a deep neural network (NN) solver that can be trained to approximate the DFS solutions, to solve puzzles faster. Both of these methods effectively relied on brute force enumeration of possible results to find a good answer, which is arguably not a very “intelligent” way of approaching a problem. The benefit here is that an exhaustive brute force search is guaranteed to find the shortest solution, while the downside is that a lot of computation has to go into finding these solutions. Indeed, the NN solution took several days to train to reliably reproduce the DFS approach, but this was only done for a time-limited DFS approach, which required the DFS solution finder to terminate within 15 seconds, and therefore rarely finding the actual shortest solution. It could take months (or more!) to produce enough training data for a neural network to reliably find the best solution with this approach.

Machine learning puzzle solving with a deep neural network

Wed, 10 Feb 2021 00:00:00 +0000

Previous solutions

Previously I wrote a depth first search (DFS) solver for the dust matching game pictured below, and have since done some thinking on how it might be solved more efficiently. As a reminder, the rules of the game were that any similar color pile touching a pile of dust that is clicked are removed from the board, then the piles fall down and towards the center. The DFS solver relied on a brute force method which would (eventually) find the ideal order in which to click dust clusters such that the board is cleared in a minimal number of moves. The issue with this is that there are often more than 15 steps in the solution for a randomly generated board, and it can take an intractably long time for the solver to find the best solution, even with the help of several heuristics and shortcuts.

fastjson library for reading/writing JSON in C++

Thu, 28 Jan 2021 00:00:00 +0000

The case for a fast JSON database

Simulation programs and data acquisition (DAQ) systems for physics experiments are typically driven by databases which contain the numerous parameters that can be changed to control the behavior of the simulation. This can vary from the mundane, such as how many events to simulate for this particular run, to the exotic, such as the neutron capture cross-section of hundreds of isotopes present in a detector. Historically each set of input data will define its own format in some contrived ASCII file that, while perhaps not difficult to parse, requires dedicated code to read that specific format. That’s not ideal, and a large push has been made in the last decade to normalize these formats. Fortunately, some modern simulation toolkits, like RAT-PAC have opted to adopt industry standard serialization formats like JSON to serialize their databases. I have opted to take a similar approach for DAQ systems I have written, as seen in the WbLSdaq program I designed to read out CAEN digitizers to HDF5 files for the CHESS experiment at UC Berkeley.

Depth first search puzzle solving with heuristics

Mon, 25 Jan 2021 00:00:00 +0000

The dust matching game

I was presented with a simple puzzle minigame from the MMORPG Nodiatis, which I had never heard of and know nothing about. I have quite a history of automating computer games with tedious mechanics (looking at you, RuneScape), so I couldn’t resist taking a stab at this one. The minigame consists of a 8x6 grid of five different colored piles of stuff (dust?) randomly selected for each position. In a mechanic reminiscent of Bejewled or Candy Crush, one selects a particular pile, and any similarly colored connected tiles are removed from the grid. Then any piles above a void fall down, and tiles are pulled towards the center to remove other voids. Or so I’m told… at any rate, the goal here is to clear the board in as few moves as possible, where 10-12 moves is really good (gets you stuff), and >16 is not so good (gets you no stuff). So the question becomes: given a board and the rules of this game, what is the optimal solution?

L2, a Python emulation of a machine to execute LISP-like code

Thu, 21 Jan 2021 00:00:00 +0000

Programming a machine

Von Neumann machines, such as a typical desktop computer or smartphone, can (in principle) have programs written for them by hand using the machine’s assembly language. In practice, program compilers have been constructed to transform high level languages (like C or C++, which are even easier to write) into assembly language programs. Still, there is a very close correspondence between the high level code and machine code, which can be explored with tools like Compiler Explorer. A von Neumann machine like this is very (very) complicated to build, with modern CPUs requiring billions of elements in addition to the rest of the supporting hardware necessary for the machine to function. They are also conceptually complicated, containing large swaths of addressable memory, and many hundreds of possible operations, which are encoded to and read from that memory, and modify the memory in predetermined ways. Much simpler Turing-complete machines exist, such as Rule 110 automatons, but the proof that these are Turing-complete (meaning that they can execute any program any other Turing-complete machine could execute) is complicated enough that one would not want to attempt to program anything useful into these by hand. It would also be quite difficult to write a compiler for any high level language into the glider language that runs on such machines. Bonafide Turing machines are somewhat of a middle ground here, being Turing-complete, reasonably programmable, not not (conceptually) too difficult to construct. They are a bit esoteric, however, and there aren’t really any simple schemes for programming simple-to-build Turing machines.

Basic maximum likelihood fitting with two (or more) event classes in Python

Sat, 09 Jan 2021 00:00:00 +0000

Context

In a particle physics experiment, a lot of data is produced and must be analyzed to extract useful information. This data typically consists of many independent observations of a “physics event” inside of some detector, which records information about the event. Often the analysis boils down to classifying a large dataset of events into a few categories, with the most simple example having only ‘signal’ and ‘background’ types of events. For instance, in a neutrinoless double beta decay ( $0\nu\beta\beta$ ) experiment, the ‘signal’ would be the $0\nu\beta\beta$ events, while everything else (radioactive decay, solar neutrinos, $2\nu\beta\beta$ , self destructing dark matter, etc.) would be backgrounds. Once the events have been classified, it is straightforward to turn numbers of events into (relative) rates or probabilities of each event class by taking ratios of the different classes. This higher level information can be be used to constrain (or disprove) theoretical models for how particles interact.

Rule 110 Cellular Automatons and Universality in Minecraft Redstone

Sun, 03 Jan 2021 00:00:00 +0000

Introduction

Home sweet home on the Direwolf20 1.16 server.

I have played a lot of Minecraft and continue to enjoy the game because it is very open ended and every world is unique. For those that don’t know, Minecraft is a world made of blocks, and all the blocks can be moved or changed by the player. It starts off as a procedurally generated “infinite” world for the player to explore and develop however they see fit. There is a lot of content in the vanilla game: monsters to fight, crops to grow, tools to build, etc. Minecraft also supports third party modifications which add new blocks with new functionality to the game. I tend to play on heavily modded minecraft servers (with 100+ mods), and the content decribed here was created on a Direwolf20 1.16 server, which adds a couple of orders of magnitude more complicated blocks to the vanilla game. A lot of these mods add content that turns Minecraft into more of a Logistics/4X game like Rimworld or Factorio (other favorites of mine).

Prioritize network traffic by IP in Linux

Mon, 28 Dec 2020 00:00:00 +0000

I have a server on a residental internet connection with relatively limited upload bandwidth. That server hosts this website along with several services for personal use including:

A Jellyfin media server for streaming my own video content
A Booksonic-Air audiobook streaming server
Automated full-system backups using rclone to Google Drive with borgbackup

If I’m listening to an audio book or streaming some other media to myself, I certainly don’t want to buffer if someone else wants to download a large file or its time to ship regularly scheduled backups off to the Google Panopticon (encrypted, of course). Fortunately, there is built-in functionality in Linux that allows upload packets to be prioritized and reserve some fraction of the available bandwidth. This functionality can also limit the total upload rate from a particular linux machine such that there is always bandwidth left over for other machines on the same network. Much more complicated behavior is possible, but I decided to stick with something simple for now.

Mouse mover program for "working" from home

Sat, 19 Dec 2020 00:00:00 +0000

I was commissioned to solve a critical problem during the Covid-19 pandemic: staying active on Slack / Microsoft Teams / etc while not actually at your computer. Apparently some workplaces monitor your work-from-home habits based entirely on whether your status on these messaging applications is “Active.” This is decently effective, since you have to be moving your mouse and/or typing to remain active, which nominally ensures you are at your work computer. However, you could be browsing Facebook looking at cat pictures instead, or other non-work activities, and if that flies, I think you should probably be allowed to go into the kitchen to make a tasty snack without the corporate panopticon realizing you’re not “Active.”

Reconstructing neutrino interactions with Machine Learning and Likelihood methods

Mon, 14 Dec 2020 00:00:00 +0000

Introduction

A Chroma model of the Theia25 detector with PMTs and LAPPDs as photon detectors.

Neutrino detectors like SNO+ and Theia don’t detect neutrinos directly. Instead they detect optical signals (light/photons) produced by high energy charged particles present after neutrinos interact in the medium. Detectors like these are typically large volumes (1 kt - 100 kt) of scintillating liquid for neutrinos to interact in (“target material”), and are surrounded by very sensitive light detectors to record the optical signals from the interaction. Scintillating liquids are preferred because they produce (relatively) large quantities of photons when charged particles move through them, and more photons means more information about the interaction.

Machine learning from scratch in Python with Numpy

Thu, 10 Dec 2020 00:00:00 +0000

Early in the Covid19 pandemic I decided to take a deep dive into the math and implementation of neural networks (NNs). Instead of treating NNs as a black box and using state-of-the-art packages like Tensorflow and Keras, which make NNs as accessible as LEGOs, I wanted to start from scratch and build the algorithms that Tensorflow (or any NN package) is based on. Historically this hands-on deep-dive learning style has worked quite well for me, and has resulted in some interesting projects like:

DUNE Warm Interface Board (WIB) Software

Mon, 07 Dec 2020 00:00:00 +0000

The DUNE experiment will transfer a massive amount of digitized analog signals from the wire planes, which collect electrons ionized by high energy particles produced in neutrino interactions, to software that decides whether or not the current state of the detector is interesting enough to store for future analysis. Sitting in the middle of this infrastructure is the Warm Interface Board (WIB) which controls and configures the front end electronics (responsible for digitizing the analog signals), aggregates data from a segment of the front end via electrical signals over copper cables, and transfers this data over 40gbps optical links to the upstream data acquisition system (responsible for storing the interesting data).

Simulating optical physics with Chroma

Mon, 07 Dec 2020 00:00:00 +0000

Introduction

Chroma is a simulation package for optical photon raytracing that aims to be physically accurate and very fast. In fact, an instance of Chroma running on a single GPU can propagate photons up to 200x faster than similar methods on a single CPU. It’s built on PyCUDA and contains CUDA kernels for propagating photons in triangular mesh geometries. This allows photons to be propagated in parallel on GPUs, which are increasingly available at high performance compute sites, with their applications to machine learning. The overall idea here is that Chroma can be used to simulate the optical response of neutrino detectors, which ultimately detect flashes of light produced by the high energy particles resulting from neutrino interactions within a detector.

New website is live!

Sun, 06 Dec 2020 00:00:00 +0000

I finally got around to buying an actual domain and benland.us now points to my server. When I discovered the top level domain .land existed, I couldn’t resist, and ben.land is setup identically. Previously my website was a MediaWiki instance, now archived in the Internet Archive, and may contain useful information, but I have switched to using the statically generated site you see here, built with Hugo. The source repository is available on my GitHub.

About Me

Mon, 01 Jan 0001 00:00:00 +0000

I received my Ph.D. in Physics at UC Berkeley in 2019 after receiving a B.S. in Physics from Georgia Tech in 2013, and generally was a nerd before that as well. Going from undergrad to graduate school, I pivoted research interests from atomic molecular and optical physics, with a research group Georgia Tech studying Bose-Einstein condensates), to weakly interacting physics, with a group at UC Berkeley studying neutrinos.

Ultimately my thesis was about using measurements of solar neutrinos to understand fundamental properties of neutrinos, and developing new neutrino detection techniques. During graduate school, I was a member of the SNO, SNO+, and Theia/EOS collaborations.

Contact Info

Mon, 01 Jan 0001 00:00:00 +0000

Connect with me on LinkedIn: linkedin.com/in/benland100.

Contact me via E-mail. I usually have the username benland100, unless otherwise noted, and you can find me @:

GMail (primary/personal) gmail.com
This server (secondary/personal) ben.land
Comcast (professional - benjamin_land@) comcast.com
UC Berkeley (academic) berkeley.edu
Georgia Tech (academic) gatech.edu
UPenn (academic - bland100@) sas.upenn.edu
Fermi National Accelerator Laboratory (academic - bjland@) fnal.gov
SNOLAB (academic - bland@) snolab.ca

Otherwise I’m often on IRC as benland100:

LiberaChat libera.chat
Rizon rizon.net

Resume/CV

Mon, 01 Jan 0001 00:00:00 +0000

Education

PhD Physics, May 2019
University of California, Berkeley, CA
M.A. Physics, May 2015
University of California, Berkeley, CA
B.S. Physics, May 2013 (GPA 4.0/4.0)
Georgia Institute of Technology, Atlanta, GA

Experience

Director - Enterprise Analytics & Data Science (March 2026 - present)
Enterprise Business Intelligence, Comcast
Sr. Manager - Data Science (April 2023 - March 2026)
Enterprise Business Intelligence, Comcast
Lead Data Scientist (September 2021 - April 2023)
Enterprise Business Intelligence, Comcast

Search

Mon, 01 Jan 0001 00:00:00 +0000