GalCubeCraft is a high-fidelity, easy-to-read pipeline for synthesising IFU-style spectral cubes (velocity × y × x). It is designed for method development: fast generation of controllable, reproducible cubes for denoising, deconvolution, kinematic tests, and ML pretraining. The code emphasises clarity (well-named small functions), sensible defaults, and modularity so you can replace morphology, kinematics or instrument modules with minimal changes.

What it does

• Constructs a 3D flux field per galaxy component using a radial Sérsic-like surface profile (disk plane) combined with an exponential vertical profile.
• Builds a compact analytic rotation-curve model to assign tangential velocities to voxels; supports multiple components (primary + satellites) and simple velocity dispersion models.
• Rotates the 3D flux & velocity fields to an arbitrary viewing geometry (inclination + position angle) and projects emission into line-of-sight velocity bins to form a spectral cube.
• Applies optional instrument effects: per-channel 2D beam convolution (elliptical Gaussian), channel binning / spectral smoothing, and additive noise models. Cubes are saved with accompanying metadata for reproducibility.

Design & architecture

• Core pipeline: small, single-responsibility functions in src/GalCubeCraft/core.py orchestrate grid creation, component stacking, kinematics and I/O.
• Helpers: utils.py contains beam kernels, convolution helpers and spatial transforms; io.py wraps saving/loading with consistent folder layouts.
• Visualisation: visualise.py exposes moment map and spectrum helpers used by both scripts and the GUI.
• GUI: a compact Tkinter-based GUI (see below) designed for interactive exploration without blocking the UI thread.

Quick install & API example

pip install GalCubeCraft

import GalCubeCraft
# create and run quickly from script
g = GalCubeCraft(n_cubes=1, grid_size=125, n_spectral_slices=40, seed=42)
results = g.generate_cubes()
cube, params = results[0]
print('cube shape =', cube.shape)
g.visualise(results, idx=0, save=False)

Files & integration (expanded)

• src/GalCubeCraft/core.py — orchestrates grid creation, stacking components and kinematics.
• src/GalCubeCraft/utils.py — beam kernels, convolution helpers and small numeric utilities.
• src/GalCubeCraft/visualise.py — moment maps and spectrum plotting helpers used by the GUI and scripts.
• src/GalCubeCraft/gui.py — the compact Tkinter GUI; see the pseudocode excerpt above for its threading pattern.

GUI - Interactive Usage

• Generates one spectral cube at a time from the parameters you set. This is sufficient for interactive experimentation and previewing the effects of different choices.
• Runs the heavy generation step in a background thread and displays logs in a small Log window so you can follow progress and any printed diagnostics.
• Provides convenience buttons to visualise results using the plotting helpers: Moment-0 (integrated intensity), Moment-1 (intensity-weighted velocity), and the integrated line-of-sight spectrum. These open interactive Matplotlib figures so you can pan/zoom as needed.
• Allows saving the generated spectral cube along with a parameters/metadata dictionary to disk. Both NumPy .npz archives and Python .pkl pickles are supported by the GUI save dialog.

Controls and parameters

The GUI exposes the following user-adjustable parameters (each control is directly reflected in the generator instance shown in gui.py):

• Number of galaxies (primary + satellites)
• Satellite offset (distance from primary centre, pixels)
• Beam information: minor axis (bmin, px), major axis (bmaj, px), position angle (BPA, degrees)
• Resolution parameter r (controls Re relative to beam size)
• Sérsic index n (profile concentration)
• Scale height h_z (vertical exponential scale, px)
• Central effective flux density S_e (intrinsic scaling)
• Line-of-sight velocity dispersion σ_v,z (km/s)
• Grid size (nx = ny, pixels)
• Number of spectral channels (n_s)
• Inclination angle (rotation about X, degrees)
• Azimuthal / position angle (rotation about Y, degrees)

Launch

# from package (recommended)
python -m GalCubeCraft.gui

# or from the source tree
cd src/GalCubeCraft
python gui.py

Behaviour and UX notes

• Generation is started with the "Generate" button. While a cube is being produced the GUI disables the interactive sliders (to indicate a running state) and the Log window is shown so you can follow output.
• When generation finishes the visualisation buttons (Moment0, Moment1, Spectra) and the Save button become enabled. The "New" button clears the current generator state and re-enables controls so you can start a fresh instance.
• The GUI attempts to render LaTeX-style labels for parameter names (using Matplotlib mathtext). If rendering fails for a label it falls back to a readable plain-text label so controls remain understandable.

Visualisation

• Moment-0: integrated intensity map produced by summing the cube along the spectral axis and optionally saving the figure.
• Moment-1: intensity-weighted velocity map computed from the spectral channels and visualised with an overlaid beam marker.
• Spectrum: integrated flux vs velocity (line-of-sight spectrum).

All visualisation helpers are implemented as small functions in src/GalCubeCraft/visualise.py and are called by the GUI to produce Matplotlib figures. These figures are interactive; you can pan/zoom and save them using Matplotlib's GUI controls.

Saving

The GUI Save flow prefers to save already-generated results (so it does not re-run the expensive generation step). You can save as a compressed NumPy archive (.npz) or as a pickled Python object (.pkl). Saved contents include the spectral cube array and a parameter dictionary with metadata (beam info, pixel scale, average velocities, etc.).

Future features

Planned enhancements for future releases include:

• Artificial noise injection and configurable S/N controls
• Batch generation of multiple cubes and export of training-ready datasets
• More advanced kinematic models and multi-component morphologies
• Small GUI refinements (progress bar for generation, better layout on HiDPI displays)

Authors

• Arnab Lahiry (alahiry@ics.forth.gr)

AstroLore is an open-source Python package designed to bridge the gap between rigorous astronomical data and the imaginative worlds of science fiction. Hosted on GitHub and available for distribution via PyPI, this tool allows astronomers, hobbyists, and sci-fi enthusiasts to contextualize real-world celestial objects within the "lore" of popular culture.

By leveraging Astropy for coordinate transformation and the SIMBAD astronomical database for object resolution, Astrolore calculates angular separations to identify connections between actual astrophysical targets and a custom-curated dataset of locations referenced in science fiction literature, television, and film.

Key Capabilities

The package offers a graphical user interface (GUI) that streamlines the user experience through the following core functionalities:

• Flexible Input Methods: Users can define a target using two distinct methods:
  • Object Name: Query by common astronomical names (e.g., "Betelgeuse", "M31"). The tool automatically resolves these names to coordinates using SIMBAD.
  • Celestial Coordinates: Input specific Right Ascension (RA) and Declination (Dec) values for precise targeting of arbitrary points in the sky.





• Nearest Source Identification: The algorithm computes the great-circle distance between the user's input and every entry in the custom "Lore" dataset to identify the closest sci-fi reference. It returns the name of the fictional location and the work of fiction it originates from.




• Aladin Sky Atlas Integration: Users can launch an interactive view of the identified nearest sci-fi source directly within the application. This utilizes the Aladin Lite API to render a high-quality optical view of the region surrounding the target.




• Sky Separation Plotting: The tool generates a static Matplotlib sky plot that visually represents the angular separation and relative positions of the user's input object versus the matched sci-fi source, providing spatial context to the result.

Installation & Usage

Astrolore manages dependencies such as pandas, numpy, and pywebview to ensure a seamless installation process.

pip install astrolore

Once installed, the GUI can be initialized with just two lines of Python code:

from astrolore import gui
# Initialize and launch the main interface
gui.main_gui().start_gui()

Authors

• Arnab Lahiry (alahiry@ics.forth.gr)
• Isabele Souza Vitorio (ivitorio@umich.edu)
• Joe Adamo (jadamo@arizona.edu)
• Kayvon Sharifi (ksharifi1@gsu.edu)

This is a small, self-contained JavaScript game also availabled as an easter egg depending on the decisions made in the home page....re-used here so visitors can play it directly. It demonstrates compact animation, adaptive input handling, and a tiny game loop that balances predictable motion with occasional randomized darts to keep the target lively.

Key capabilities

• The game is initialized via window.launchSnitch()
• Clean teardown API (window.teardownSnitch()) to stop timers/RAF and remove injected DOM safely when the modal closes.
• Responsive: runs inside a page-scoped slot or a modal viewport without requiring a framework.
• Small footprint: vanilla JS (no external dependencies) and simple CSS for the runner, progress UI, and victory box.

How it works

The implementation follows a straightforward architecture:

1. Initialization: the page creates or re-uses a #snitch-slot container and calls launchSnitch(). That entry-point renders the runner image, progress UI and wires event handlers.
2. Motion loop: the runner normally performs smooth, low-amplitude drifting using CSS transforms and requestAnimationFrame. In addition, the implementation schedules intermittent "darts" — short, faster movements that make the runner jump to a new location. Darts are randomized in timing but parameterized by tunable values such as dartDistance and dartSpeed, so you can control how far and how quickly the runner darts across the viewport. Darts are scheduled with randomized timeouts (e.g. rand(dartIntervalMin, dartIntervalMax)) and executed with eased transforms so motion remains visually smooth.
3. Interaction modes: the game continuously listens for pointer position (mouse or touch). If the pointer comes within a proximity radius the runner will attempt an evasive manoeuvre: it computes a flee vector away from the pointer and executes a directional dart in that vector (often with a small angular jitter). This makes the runner sensitive to the player's attempts to trap it — it doesn't simply move randomly, it actively avoids the pointer.
4. Player capture flow: the user must repeatedly chase the runner and keep it in a slow/near state to fill the on-screen progress bar. Progress accumulates while the pointer is close (or while the runner is cornered) and decays when the pointer moves away; when the progress reaches 100% the game enters a capture window that allows a click/tap to succeed. If the capture attempt fails or the runner escapes, progress begins to decay and the chase resumes.
5. Teardown: teardownSnitch() cancels outstanding RAFs/timeouts and removes all DOM elements inserted by the game, preventing leaks when the slot is moved or the modal closes.

Configurable motion parameters (example)

// Example tuning constants exposed inside the snitch module
const SNITCH_CONFIG = {
  dartDistance: 120,      // pixels the runner moves during a dart (tunable)
  dartSpeed: 360,         // ms duration for a dart movement (tunable)
  dartIntervalMin: 360,   // minimum ms between scheduled darts
  dartIntervalMax: 1600,  // maximum ms between scheduled darts
  fleeMultiplier: 1.4,    // multiplier when fleeing from pointer (increases dartDistance)
  proximityRadius: 140    // px radius in which the runner treats the pointer as 'near'
};
                                

Fleeing behaviour (concept)

The runner computes a unit vector away from the pointer and applies a dart in that direction. The flee distance uses dartDistance * fleeMultiplier and the dart uses dartSpeed for a quick escape. This produces intuitive avoidance: approaching the runner from different angles makes it dart in the opposite direction instead of just randomly teleporting.

function fleeFromPointer(runnerX, runnerY, pointerX, pointerY){
  const dx = runnerX - pointerX;
  const dy = runnerY - pointerY;
  const len = Math.hypot(dx, dy) || 1;
  const nx = dx / len, ny = dy / len; // normalized flee direction
  const distance = SNITCH_CONFIG.dartDistance * SNITCH_CONFIG.fleeMultiplier;
  const targetX = runnerX + nx * distance;
  const targetY = runnerY + ny * distance;
  smoothMoveTo(runnerElement, targetX, targetY, { duration: SNITCH_CONFIG.dartSpeed });
}
                                

Progress & capture loop

Progress increases while the pointer remains within the proximity radius and the runner's velocity is low (i.e., it's not in an active dart). The progress visually fills the .snitch-progress-bar. When it reaches 100% the UI allows a capture by clicking/tapping the runner; otherwise, progress decays slowly if the player stops trying. This encourages repeated, skillful attempts rather than a single lucky click.

Representative code snippets

Start the game (programmatic):

// Start the snitch game (exposed from scripts/home/home-snitch.js)
if (typeof window.launchSnitch === 'function') {
  window.launchSnitch();
} else {
  // loader fallback: dynamically load the script then start
  var s = document.createElement('script');
  s.src = 'scripts/home/home-snitch.js';
  s.onload = function(){ window.launchSnitch && window.launchSnitch(); };
  document.body.appendChild(s);
}
                                

Stop / cleanup the game (used by the modal on close):

// Stop the game and remove injected UI
if (typeof window.teardownSnitch === 'function') {
  window.teardownSnitch();
}
                                

Core algorithm (motion & scheduling)

At a high level the runner's behaviour is implemented as follows (simplified):

function scheduleRandomDart() {
  // choose a new target position within bounds
  var target = pickRandomOnViewport();
  // smoothly move toward the target using easing
  smoothMoveTo(runnerElement, target.x, target.y, { duration: 280 });
  // occasionally perform a quick dart (flee) when the pointer is nearby
  setTimeout(scheduleRandomDart, rand(360, 1600));
}

function smoothMoveTo(node, x, y, opts){
  // apply CSS transform transitions to animate position changes
  node.style.transition = 'transform ' + (opts.duration||240) + 'ms cubic-bezier(.2,.9,.2,1)';
  node.style.transform = 'translate(' + x + 'px, ' + y + 'px)';
}
                                

Files and integration points

• snitch.js — full game logic, exposes launchSnitch and teardownSnitch.
• css/style.css and css/software_style.css — snitch visuals, runner sizing, progress bar, and the victory box styles (copied locally for page-scoped usage).
• software.html — includes a #snitch-slot container and a play button wired to open the modal and call the snitch initializer.

Play & Controls

• Pointer: move the mouse to chase the runner; clicking (or tapping) performs capture attempts when the progress bar is full.

Authors

• Arnab Lahiry