messthaler-wulff 2025.12.2__tar.gz

messthaler_wulff-2025.12.2/.gitignore

@@ -0,0 +1,6 @@
+.git
+.idea
+.venv
+dist
+test
+__pycache__/

messthaler_wulff-2025.12.2/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 J. Meßthaler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

messthaler_wulff-2025.12.2/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: messthaler-wulff
+Version: 2025.12.2
+Author-email: Guenthner <guenthner.jonathan@gmail.com>
+License-File: LICENSE.txt
+Keywords: Wulff,Wulff Crystals
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: matplotlib
+Requires-Dist: open3d
+Requires-Dist: prettytable
+Requires-Dist: psutil
+Requires-Dist: scipy
+Requires-Dist: sortedcontainers

messthaler_wulff-2025.12.2/makefile

@@ -0,0 +1,24 @@
+py=.venv/bin/python
+user=guenthner
+program-name=messthaler-wulff
+
+set_user:
+	cp ~/.pypirc_$(user) ~/.pypirc
+
+build: clean version
+	$(py) -m build
+
+version:
+	vinc
+
+clean:
+	touch dist/fuck
+	rm dist/*
+
+upload: set_user build
+	$(py) -m twine upload --repository pypi dist/* $(flags)
+
+reload: upload
+	pipx upgrade $(program-name)
+	pipx upgrade $(program-name)
+	$(program-name) --version h

messthaler_wulff-2025.12.2/messthaler_wulff/__init__.py

@@ -0,0 +1,86 @@
+import argparse
+import logging
+import math
+
+import numpy as np
+
+from .data import fcc_transform
+from .terminal_formatting import parse_color
+from .version import program_version
+
+log = logging.getLogger("messthaler_wulff")
+console = logging.StreamHandler()
+log.addHandler(console)
+log.setLevel(logging.DEBUG)
+console.setFormatter(
+    logging.Formatter(parse_color("{asctime} [ℂ3.{levelname:>5}ℂ.] ℂ4.{name}ℂ.: {message}"),
+                      style="{", datefmt="%W %a %I:%M"))
+
+PROGRAM_NAME = "messthaler-wulff"
+DEFAULT_DATE_FORMAT = "%y/%b/%NAME"
+
+
+def command_entry_point():
+    try:
+        main()
+    except KeyboardInterrupt:
+        log.warning("Program was interrupted by user")
+
+
+def parse_lattice(lattice):
+    match lattice.lower():
+        case "fcc":
+            return fcc_transform()
+
+    log.info(f"Unknown lattice name {lattice}, interpreting lattice as python code")
+
+    transform = np.array(eval(lattice, {"sqrt": math.sqrt}))
+
+    log.info(f"Using result as lattice transform:\n{transform}")
+
+    input("Press enter to continue...")
+    return transform
+
+
+def main():
+    parser = argparse.ArgumentParser(prog=PROGRAM_NAME,
+                                     description="Wudduwudduwudduwudduwudduwudduwudduwuddu",
+                                     allow_abbrev=True, add_help=True, exit_on_error=True)
+
+    parser.add_argument('-v', '--verbose', action='store_true', help="Show more output")
+    parser.add_argument("--version", action="store_true", help="Show the current version of the program")
+    parser.add_argument("MODE",
+                        help="What subprogram to execute; Can be 'view' or 'simulate' or 'interactive' or 'explore'")
+    parser.add_argument("--goal", help="The number of atoms to add initially", default="100")
+    parser.add_argument("--dimension", default="3")
+    parser.add_argument("--lattice", default="fcc")
+    parser.add_argument("--axis", action="store_true")
+    parser.add_argument("--orthogonal", action="store_true")
+    parser.add_argument("-w", "--windows", action="store_true")
+
+    args = parser.parse_args()
+
+    log.setLevel(logging.DEBUG if args.verbose else logging.INFO)
+    log.debug("Starting program...")
+
+    if args.version:
+        log.info(f"{PROGRAM_NAME} version {program_version}")
+        return
+
+    match args.MODE.lower():
+        case 'view':
+            from . import mode_view
+            mode_view.run_mode(use_orthogonal_projections=args.orthogonal, show_axes=args.axis)
+        case 'simulate':
+            from . import mode_simulate
+            mode_simulate.run_mode(goal=int(args.goal), lattice=parse_lattice(args.lattice))
+        case 'interactive':
+            from . import mode_interactive
+            mode_interactive.run_mode(goal=int(args.goal), dimension=int(args.dimension),
+                                      lattice=parse_lattice(args.lattice), windows_mode=args.windows)
+        case 'explore':
+            from . import mode_explore
+            mode_explore.run_mode(goal=int(args.goal), lattice=parse_lattice(args.lattice),
+                                  dimension=int(args.dimension))
+        case _:
+            log.error(f"Unknown mode {args.MODE}. Must be one of 'view' or 'simulate'")

messthaler_wulff-2025.12.2/messthaler_wulff/__main__.py

@@ -0,0 +1,3 @@
+import messthaler_wulff
+
+messthaler_wulff.command_entry_point()

messthaler_wulff-2025.12.2/messthaler_wulff/additive_simulation.py

@@ -0,0 +1,456 @@
+import json
+import random
+import shutil
+import time
+from collections import defaultdict
+
+import numpy as np
+
+from .progress import ProgressBar
+
+
+class EnergyTracker:
+    class EnergyLevel:
+        def __init__(self):
+            self.values = []
+            self.indices = {}
+
+        def __len__(self):
+            return len(self.values)
+
+        def __getitem__(self, i):
+            return self.values[i]
+
+        def add(self, atom):
+            if atom in self.indices:
+                return
+
+            self.indices[atom] = len(self.values)
+            self.values.append(atom)
+
+        def remove(self, atom):
+            if len(self.values) == 0:
+                raise ValueError("I am empty")
+
+            index = self.indices[atom]
+            try:
+                if index == len(self.values) - 1:
+                    self.values.pop()
+                else:
+                    self.values[index] = self.values.pop()
+                    self.indices[self.values[index]] = index
+            except IndexError:
+                raise IndexError(f"List index {index} out of range for {self.values}")
+
+            del self.indices[atom]
+
+        def __str__(self):
+            return str(len(self.values))
+
+        def __repr__(self):
+            return str(self)
+
+        def __iter__(self):
+            for i in range(len(self)):
+                yield self[i]
+
+        def json_obj(self):
+            return [str(v) for v in self.values]  # f"{len(self.values)} values"
+
+    def __init__(self):
+        self.min_energy = None
+        self.energy_levels = defaultdict(EnergyTracker.EnergyLevel)
+        self.atom2energy = {}
+
+    def minimum(self, choice=lambda x: 0):
+        level = self.energy_levels[self.min_energy]
+        atom = level[choice(len(level))]
+        return atom, self.min_energy
+
+    def all_minimums(self):
+        level = self.energy_levels[self.min_energy]
+        return list(level)
+
+    def __len__(self):
+        return len(self.atom2energy)
+
+    def __contains__(self, atom):
+        return atom in self.atom2energy
+
+    def get(self, atom):
+        return self.atom2energy[atom]
+
+    def set(self, atom, energy):
+        if self.min_energy is None or energy < self.min_energy:
+            self.min_energy = energy
+
+        if atom in self.atom2energy:
+            old_energy = self.atom2energy[atom]
+            if old_energy != energy:
+                old_level = self.energy_levels[old_energy]
+                old_level.remove(atom)
+                level = self.energy_levels[energy]
+                level.add(atom)
+                self.adjust_min_energy()
+
+            self.atom2energy[atom] = energy
+        else:
+            level = self.energy_levels[energy]
+            level.add(atom)
+            self.atom2energy[atom] = energy
+
+    def unset(self, atom, energy):
+        level = self.energy_levels[energy]
+        level.remove(atom)
+        del self.atom2energy[atom]
+
+        self.adjust_min_energy()
+
+    def adjust_min_energy(self):
+        if len(self) == 0:
+            self.min_energy = None
+        else:
+            while len(self.energy_levels[self.min_energy]) <= 0:
+                self.min_energy += 1
+
+    def atoms(self):
+        return self.atom2energy.keys()
+
+    def __str__(self):
+        return json.dumps({
+            "min_energy": self.min_energy,
+            "atom2energy": {
+                str(k): v for (k, v) in self.atom2energy.items()},
+            "energy_levels": {
+                k: v.json_obj() for (k, v) in self.energy_levels.items()
+            }
+        }, indent=4)
+
+
+class OmniSimulation:
+    BACKWARDS = 0
+    FORWARDS = 1
+
+    def __init__(self, neighborhood, energy_maximum=None, origin=(0, 0, 0, 0)):
+        if energy_maximum is None:
+            energy_maximum = neighborhood.energy_maximum
+
+        self.energy = 0
+        self.atoms = 0
+        self.neighborhood = neighborhood
+        self.energy_maximum = energy_maximum
+
+        self.boundaries = [EnergyTracker(), EnergyTracker()]
+        self.boundaries[self.FORWARDS].set(origin, self.calculate_energy(origin, mode=self.FORWARDS))
+
+    def calculate_energy(self, atom, mode):
+        energy = 0
+
+        for neighbor in self.neighborhood(atom):
+            energy += -1 if neighbor in self.boundaries[1 - mode] else 1
+
+        return energy
+
+    def set_atom(self, atom, energy, mode):
+        mode_boundary = self.boundaries[mode]
+        reverse_boundary = self.boundaries[1 - mode]
+
+        mode_energy = energy
+        self.energy += mode_energy
+        reverse_boundary.set(atom, -mode_energy)
+        if atom in mode_boundary:
+            mode_boundary.unset(atom, mode_energy)
+
+        for neighbor in self.neighborhood(atom):
+            if neighbor in reverse_boundary:
+                neighbor_energy = reverse_boundary.get(neighbor)
+                new_energy = neighbor_energy + 2
+
+                if self.energy_maximum() == new_energy:
+                    reverse_boundary.unset(neighbor, neighbor_energy)
+                else:
+                    reverse_boundary.set(neighbor, new_energy)
+            elif neighbor in mode_boundary:
+                neighbor_energy = mode_boundary.get(neighbor)
+                new_energy = neighbor_energy - 2
+
+                if self.energy_maximum() == new_energy:
+                    mode_boundary.unset(neighbor, neighbor_energy)
+                else:
+                    mode_boundary.set(neighbor, new_energy)
+            else:
+                mode_boundary.set(neighbor, self.calculate_energy(neighbor, mode))
+
+    def next_atom(self, choice, mode):
+        return self.boundaries[mode].minimum(choice)
+
+    def next_atoms(self, mode):
+        return self.boundaries[mode].all_minimums()
+
+    def adjust_atom_count(self, mode):
+        if mode == self.BACKWARDS and self.atoms <= 0:
+            raise ValueError("No atoms left, so can't remove one")
+
+        match mode:
+            case self.FORWARDS:
+                self.atoms += 1
+            case self.BACKWARDS:
+                self.atoms -= 1
+
+    def add_atom(self, choice=lambda l: 0):
+        self.adjust_atom_count(self.FORWARDS)
+
+        atom, energy = self.next_atom(choice, self.FORWARDS)
+        self.set_atom(atom,
+                      energy,
+                      self.FORWARDS)
+
+    def remove_atom(self, choice=lambda l: 0):
+        self.adjust_atom_count(self.BACKWARDS)
+
+        atom, energy = self.next_atom(choice, self.BACKWARDS)
+        self.set_atom(atom,
+                      energy,
+                      self.BACKWARDS)
+
+    def force_set_atom(self, atom, mode=FORWARDS):
+        self.adjust_atom_count(mode)
+
+        atom2energy = self.boundaries[mode].atom2energy
+        if atom in atom2energy:
+            energy = atom2energy[atom]
+        else:
+            energy = self.calculate_energy(atom, mode)
+        self.set_atom(atom, energy, mode)
+
+    def visualise_slice(self, atomiser=lambda x, y: (0, x, y), crosshair=False, view_energies=False, color=True):
+        width, height = shutil.get_terminal_size()
+        margin = 3
+        fg_red = "\x1b[38;2;200;0;0;1m" if color else ""
+        bg_green = "\x1b[48;2;0;70;0;1m" if color else ""
+        unset = "\x1b[m" if color else ""
+
+        def bg():
+            if crosshair and (x == 0 or y == 0):
+                print(end=bg_green + " " + unset)
+            else:
+                print(end=" ")
+
+        for y in range(-(height - margin) // 2, (height - margin) // 2):
+            for x in range(-(width - margin) // 2, (width - margin) // 2):
+                atom = atomiser(x, y)
+                mode = -1
+                energy = None
+
+                for m in range(2):
+                    if atom in self.boundaries[m]:
+                        mode = m
+                        energy = self.boundaries[m].get(atom)
+
+                if view_energies:
+                    if mode == -1:
+                        bg()
+                    elif energy < 0:
+                        print(end=fg_red + str(-energy) + unset)
+                    else:
+                        print(end=str(energy))
+                else:
+                    match mode:
+                        case self.BACKWARDS:
+                            print(end=fg_red + "X" + unset)
+                        case self.FORWARDS:
+                            print(end="O")
+                        case _:
+                            bg()
+            print()
+
+        print()
+
+    def interactive(self, dimension=2, color=True):
+        z = 0
+        view_energies = False
+        crosshair = False
+        atomiser = None
+        match dimension:
+            case 1:
+                atomiser = lambda x, y: (0, x)
+            case 2:
+                atomiser = lambda x, y: (0, x, y)
+            case 3:
+                atomiser = lambda x, y: (0, x, y, z)
+            case _:
+                raise ValueError(f"Unsupported dimension: {dimension}")
+
+        def set_cmd(method):
+            try:
+                if len(args) > 0:
+                    goal = int(args[0])
+                    progress = ProgressBar(goal, lambda: self.energy)
+                    for i in range(goal):
+                        progress(i)
+                        method(lambda l: random.randrange(l))
+                else:
+                    method(lambda l: random.randrange(l))
+            except (ValueError, TypeError):
+                pass
+
+        try:
+            while True:
+                wipe_screen()
+                self.visualise_slice(atomiser, crosshair=crosshair, view_energies=view_energies, color=color)
+                print(f"Total energy: {self.energy}; Z-Layer: {z}")
+
+                try:
+                    cmd, *args = input("Input Command: (add, rm, up, down, exit, ?) ").split()
+                except ValueError:
+                    continue
+
+                match (cmd.lower()):
+                    case "add":
+                        set_cmd(self.add_atom)
+                    case "rm":
+                        set_cmd(self.remove_atom)
+                    case "up":
+                        z += 1
+                    case "down":
+                        z -= 1
+                    case "layer":
+                        if len(args) > 0:
+                            z = int(args[0])
+                    case "energy":
+                        view_energies = not view_energies
+                    case "forwards":
+                        print(self.boundaries[self.FORWARDS])
+                        input("Press Enter to continue")
+                    case "backwards":
+                        print(self.boundaries[self.BACKWARDS])
+                        input("Press Enter to continue")
+                    case "crosshair":
+                        crosshair = not crosshair
+                    case "fill":
+                        self.fill(lambda l: random.randrange(l))
+                    case "exit":
+                        break
+                    case "?":
+                        input("""
+add         - Adds the next atom in the sequence
+rm          - Removes the next atom in the reverse sequence
+up          - Goes up one z-layer (if possible)
+down        - Goes down one z-layer (if possible)
+energy      - Toggle the energy view mode
+forwards    - Display the forwards boundary energy tracker
+backwards   - Display the backwards boundary energy tracker
+crosshair   - Enable a crosshair
+fill        - Adds atoms to the crystal until the energy would increase
+exit        - Exit interactive mode
+?           - Displays this help
+
+Press Enter to continue execution
+""")
+
+        except (ValueError, TypeError):
+            self.interactive(dimension=dimension, color=color)
+        except KeyboardInterrupt:
+            print()
+
+    def points(self):
+        return self.boundaries[self.BACKWARDS].atoms()
+
+    def fill(self, choice=lambda l: 0):
+        while True:
+            atom, energy = self.next_atom(choice, self.FORWARDS)
+            if energy > 0:
+                break
+
+            self.adjust_atom_count(self.FORWARDS)
+
+            self.set_atom(atom,
+                          energy,
+                          self.FORWARDS)
+
+
+def wipe_screen():
+    print(f"\x1b[3J\x1b[H\x1b[J", end="")
+
+
+def move(atom, offset):
+    return tuple((atom[0], *(atom[i + 1] + offset[i] for i in range(len(atom) - 1))))
+
+
+class SimpleNeighborhood:
+    def __init__(self, transform: np.ndarray):
+        start = time.time()
+        shape = transform.shape
+        self.transform = transform
+        self.n = shape[0]
+        if shape[0] != shape[1]:
+            raise ValueError("I need a square matrix")
+
+        self.base_neighborhood = set()
+
+        self.find_neighbors()
+
+        print(f"Calculated in {time.time() - start:.2f} seconds neighbors for:\n{transform}")
+        print(f"Neighbors are: {self.base_neighborhood}")
+        print()
+
+    @staticmethod
+    def points_within_dist(n, dist):
+        if n == 0:
+            yield ()
+            return
+        if n == 1:
+            for i in list(range(-dist, dist + 1)):
+                yield (i,)
+            return
+
+        for i in range(-dist, dist + 1):
+            for p in SimpleNeighborhood.points_within_dist(n - 1, dist):
+                yield [*p, i]
+
+    @staticmethod
+    def points_with_dist(n, dist):
+        if dist == 0:
+            yield [0] * n
+            return
+        if dist == 1:
+            for p in SimpleNeighborhood.points_within_dist(n, dist):
+                if all(x == 0 for x in p): continue
+                yield p
+            return
+
+        for i in range(n):
+            for sign in [-1, 1]:
+                for p in SimpleNeighborhood.points_within_dist(n - 1, dist):
+                    yield *p[:i], sign * dist, *p[i:]
+
+    def find_neighbors(self):
+        for dist in range(1, 10):
+            changed = 0
+
+            for p in SimpleNeighborhood.points_with_dist(self.n, dist):
+                point = np.dot(self.transform, np.array(p))
+                if np.linalg.norm(point) <= 1:
+                    p = tuple(p)
+                    if p not in self.base_neighborhood:
+                        self.base_neighborhood.add(p)
+                        changed += 1
+
+            if changed == 0:
+                return
+
+        raise RuntimeError("Could not find all neighbors")
+
+    def __call__(self, pos):
+        return [move(pos, x) for x in self.base_neighborhood]
+
+    def energy_maximum(self):
+        return len(self.base_neighborhood)
+
+
+def main():
+    OmniSimulation(SimpleNeighborhood(np.identity(2)), None, (0, 0, 0)).interactive(2)
+
+
+if __name__ == "__main__":
+    main()

messthaler_wulff-2025.12.2/messthaler_wulff/common_objects.py

@@ -0,0 +1,67 @@
+from data import *
+
+
+################################################################################
+# The definitions of the fcc, hcp, etc. methods
+
+def fcc(grid_range=range(0, 4), lower_bound=0, upper_bound=1.9, upper_clip_plane=math.inf, add_lines=True):
+    """
+    Generates a subset of fcc
+    :grid_range: The range for the grid which will be range(-3,4) × range(-3,4) × range(-3, 4)
+    """
+    g = grid(grid_range, grid_range, grid_range)
+    g *= fcc_transform()
+    g = g.filter(lambda p: all(lower_bound <= t <= upper_bound for t in p))
+    g = g.filter(lambda p: sum(p[i] for i in range(3)) <= upper_clip_plane)
+    if add_lines:
+        g = auto_lines(g, 1)
+    return g
+
+
+def fcc_wulff(opacity=1, corner_color='red', color='darkred'):
+    """
+    Generates the polygon that is the wulff crystal (with side length 1)
+    """
+    wulff = fcc_wulff_obj()
+    # wulff += pos(0,0,0)  # center the crystal (somewhat)
+    wulff.foreach(Point, setter('color', corner_color))
+    wulff = convex_hull(wulff)
+    wulff.foreach(Triangle, setter('color', color))
+    wulff.foreach(Triangle, setter('opacity', opacity))
+    return wulff
+
+
+def fcc_wulff2(opacity=1, corner_color='red', color='darkred'):
+    """
+    Generates the polygon that is the wulff crystal (with side length 2)
+    """
+    wulff = fcc_wulff2_obj()
+    wulff.foreach(Point, setter('color', corner_color))
+    wulff = convex_hull(wulff)
+    wulff.foreach(Triangle, setter('color', color))
+    wulff.foreach(Triangle, setter('alpha', opacity))
+    return wulff
+
+
+def hcp(grid_range=range(0, 4), lower_bound=0, upper_bound=1.9, upper_clip_plane=math.inf, custom_filter=lambda p: True,
+        add_lines=True):
+    """
+    Generates a subset of hcp
+    """
+
+    g = grid(grid_range, grid_range, grid_range)
+    g *= hcp_transform()
+    g @= g + hcp_vector()
+    g = g.filter(lambda p: all(lower_bound <= t <= upper_bound for t in p))
+    g = g.filter(lambda p: sum(p[i] for i in range(3)) <= upper_clip_plane)
+    g = g.filter(custom_filter)
+    if add_lines:
+        g = auto_lines(g, 1)
+    return g
+
+
+def print_point_set(s):
+    """
+    Given a set s consisting of Point instances, prints their positions
+    """
+    print(f"{len(s)} elements: ", *map(lambda p: p.pos, s))