galaga-lab 0.0.1__tar.gz

galaga_lab-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: galaga_lab
+Version: 0.0.1
+Requires-Dist: astropy
+Requires-Dist: numpy
+Requires-Dist: dash
+Requires-Dist: dash_bootstrap_components
+Requires-Dist: Flask
+Requires-Dist: plotly
+Requires-Dist: PyYAML

galaga_lab-0.0.1/README.md

@@ -0,0 +1,42 @@
+# galaga-lab
+Astronomy-themed visual sandbox for education & outreach :-)
+
+## General overview
+Generating a random field of astronomical objects in an approachable, non-technical manner to learn about colors, distances, and objects and interpreting astronomical images in an interactive DASH interface
+
+## Features of an AstroObject
+RA, Dec
+Redshift
+Distance
+Shape (ellipticity)
+Age of Object
+
+Use properties to "bin" to a color/magnitude 
+
+### Object types
+Galaxies
+Stars
+Clusters (later)
+
+### The Random Field
+How are things distributed to match a "real" field survey? 
+- Nubia did this in a project! Woohoo!
+
+## TODOs
+- [ ] Structure of software
+- [ ] Objects & Functionality
+- [ ] Gather Astronomical Features that would be included
+
+## Installation
+From the terminal, run
+```sh
+conda env create -f environment.yml
+```
+This will create a new conda environment called ```galaga-lab``` with all the required dependencies
+
+## Quick Start
+In the root directory, run
+```sh
+python app.py
+```
+The GUI is then available at `http://127.0.0.1:8050/`.

galaga_lab-0.0.1/galaga_lab/Backend/astro_objects.py

@@ -0,0 +1,466 @@
+'''
+File for classes and making the astro objects class and any subclasses/objects for galaxies, etc
+
+Fill out docstrings...
+
+Things to add: 
+1. Ellipticity range dependent on SED type
+2. Exposure-time-dependence so 
+'''
+
+import numpy as np
+from astropy.cosmology import Planck18 as cosmo
+import plotly.graph_objects as go
+from astropy.coordinates import SkyCoord
+from astropy import units as u
+from astropy.wcs import WCS
+
+'''
+SED Template: Spectral Energy Distribution is a galaxy's brightness as wavelength
+Instead of modeling, just an approximated "type" by a dictionary that captures: 
+1. base_color (intrisic g-r color)
+2. mass_to_light (solar masses per solar luminosity)
+ordered from red to blue
+
+Wikipedia: elliptical and lenticular galaxies typically appearing redder due to older stellar populations, 
+while spiral and irregular galaxies are often bluer, indicating ongoing star formation
+
+Just kinda picked at random with minor amounts of logic
+'''
+STARFORMING = {"spiral", "irregular", "starburst"}
+
+SED_TEMPLATES = {"elliptical": (0.80, 3.0), "lenticular": (0.72, 2.5), "spiral": (0.55, 1.8),
+                 "irregular": (0.42, 1.2), "starburst":  (0.30, 0.8)}
+
+GAL_TRIVIA =   {   "elliptical":    [
+                                        "Ellliptical galaxies store all the retired stars. All of them are old and red, with too little gas left to make new ones.",
+                                        "An elliptical galaxy like this likely grew this big by swalloring up smaller galaxies over billions of years in events called mergers."
+                                    ], 
+                    "lenticular":   [
+                                        "Lenticular galaxies have a disk like a spiral, but are like elliptical galaxies in that they have little star-forming gas left.",
+                                        "Lenticular galaxies are like a spiral galaxies that just relaxed and chilled out."
+                                    ], 
+                    "spiral":       [
+                                        "The \"arms\" in the spiral shapes of these galaxies are stellar nurseries: Bright regions where new stars are constantly being born, emitting blue light.",
+                                        "Our own Milky Way is a spiral galaxy like this one, so we're constantly getting new stellar siblings!"
+                                    ],
+                    "irregular":    [
+                                        "Irregular galaxies are often chaotic in shape, due to collisions or gravitational tugs with neighbors.",
+                                        "Most are small and have a ton of star-forming gas, but lack the structure of spiral galaxies."
+                                    ], 
+                    "starburst":    [
+                                        "Starburst galaxies form stars faster than other star-forming galaxies, hence the name!",
+                                        "This galaxy has likely just merged with another, giving it a ton of new gas to make stars with."
+                                    ]
+                }
+
+# name helper functions
+def mass_phrase(mass): 
+    if mass >= 1e12: 
+        return f"{mass/1e12:.0f} trillion"
+    if mass >= 1e9:  
+        return f"{mass/1e9:.0f} billion"
+    return f"{mass/1e6:.0f} million"
+
+def distance_phrase(d_mpc): 
+    mly = d_mpc * 3.262 
+    if mly < 1000: 
+        return f"{mly:,.0f} million light-years"
+    return f"{mly/1000:.1f} billion light-years"
+
+def visibility(mag): 
+    if mag < 20: 
+        return "easy"
+    if mag < 23: 
+        return "moderate"
+    return "hard"
+
+def redshift_note(z):
+    if z < 0.1:  
+        return "It's one of our cosmic neighbors, relatively close by."
+    if z < 0.3:  
+        return "Its light traveled a good chunk of cosmic history to reach us, being slightly stretched to redder light in a process called redshifting."
+    if z < 0.7:  
+        return "We see it as it was billions of years ago, a window into the younger universe, stretched by space itself expanding into redder light."
+    if z < 1.5:  
+        return "Cosmic expansion has noticeably stretched its light toward the red, and we're seeing it when the universe was much younger."
+    return "Its light has been stretched dramatically by the expansion of the universe, carrying an image of the early universe."
+
+def cluster_designation(ra, dec):
+    if dec >= 0:
+        sign = "+"  
+    else: 
+        sign = "-"
+    return f"Cluster J{ra:.1f}{sign}{abs(dec):.1f}"
+
+def sat_sentence(cluster_name, bcg_name): 
+    return (f"It is a member of {cluster_name}, gravitationally bound into a massive cluster "
+            f"and orbiting the cluster's brightest central galaxy, {bcg_name}.")
+
+def bcg_sentence(cluster_name):
+    return (f"It is the Brightest Central Galaxy of {cluster_name}, the giant elliptical at the "
+            f"cluster's heart. BCGs grow enormous over billions of years by merging with infalling "
+            f"galaxies, making them among the oldest and most massive galaxies known.")
+
+# Shared helper function
+def make_wcs():
+        wcs = WCS(naxis=2)
+        wcs.wcs.crpix = [0, 0]
+        wcs.wcs.cdelt = [1.0, 1.0]
+        wcs.wcs.crval = [180, 0]          # center of projection
+        wcs.wcs.ctype = ["RA---AIT", "DEC--AIT"]
+        return wcs
+
+
+class AstroObject: 
+    def __init__(self, ra, dec, z, name=None, exposure_time=1.0):
+        """
+        ra, dec in degrees
+        """
+        self.ra    = ra
+        self.dec   = dec 
+        self.coord = SkyCoord(ra=ra, dec=dec, unit=(u.deg, u.deg))
+        self.z     = z
+        self.name  = name
+        self.d     = cosmo.luminosity_distance(z).to_value("Mpc")
+        self.color = 0
+        self.mag   = 0
+        self.exposure_time = exposure_time
+
+    ## some shared physics/cosmology/coloring/display stuff
+    def distance_modulus(self): 
+        """
+        apparent/absolute with z
+        """
+        return cosmo.distmod(self.z).value
+    
+    def get_hue(self): 
+        '''
+        Map color index (g-r) to an rgb string
+        blue (~0.3) -> red (~0.9)
+
+        Normalize the color over the [0,1] range for easier coloring
+        Interpolate between a blue and a red rgb sequence
+        Makes a direct blue-to-red scale
+        '''
+        c    = np.clip((self.color - 0.3) / 1.2, 0.0, 1.0) #"clips" color to 0, 1; wider range accounts for redshift shift
+        blue = np.array([70, 130, 255])
+        red  = np.array([255, 70, 50])
+
+        r, g, b = (blue + c*(red-blue)).astype(int)
+        return f"rgb({r}, {g}, {b})" #formatted this way for plotly
+    
+    def peak_brightness(self, faint=25.0, bright=15.0, exposure_time=None):
+        '''
+        map magnitude to a peak brightness
+        range it [0.05, 1] to test...
+        Larger mag (fainter) = dimmer
+        Less than 15 mag is the "core" 
+        Greater than 25 (LSST depths) is 0.05, linear between (just for display)
+        '''
+        # easier integration to slider maybe?
+        if exposure_time is None:
+            exposure_time = self.exposure_time
+        
+        '''
+        Could just do 
+        for galaxy in the field: 
+            set self.exposure_time to current slider value
+        '''
+
+        exposure_time = max(exposure_time, 1e-3)   # make slider min > 0
+
+        floor = 0.30
+        ceiling = 1.5 #was 1.0, 2.0 a bit too bright
+        DEPTH_GAIN = 2.0 #for how "sensitive" the slider is/an object is to exposure time; 1.25 is realistic but unresponsive
+
+        m_lim = faint + DEPTH_GAIN * np.log10(exposure_time)
+
+        p = (m_lim - self.mag) / (faint - bright)
+        return float(np.clip(p, floor, ceiling))
+    
+    def finish_visualize(self, fig, title):
+
+        dark = "rgb(10, 10, 30)"   # matching later colorscale I think
+        fig.update_layout(title=title, width=600, height=600,
+            paper_bgcolor="rgba(0,0,0,0)", # transparent around the plot
+            plot_bgcolor=dark, # dark "sky" look
+            xaxis_title="RA [deg]", yaxis_title="dec [deg]")
+        fig.update_xaxes(autorange="reversed", showgrid=False, zeroline=False)
+        fig.update_yaxes(scaleanchor="x", showgrid=False, zeroline=False)
+        fig.show()
+        return fig
+
+class Galaxy(AstroObject): 
+    def __init__(self, ra, dec, z, name, exposure_time=1.0,
+            size    = 7, 
+            type    = "spiral", 
+            q       = 1,
+            mass    = 1e12, 
+            lensed  = False, 
+            sed     = 'None', 
+            agn_lum = 0.0,
+            notes   = None,
+            ):
+        super().__init__(ra, dec, z, name, exposure_time)
+        self.q     = q       # axis ratio
+        self.angle = 0       # eventually add random axis-tilt for display
+        self.mass  = mass    # solar masses
+        #self.lensed = lensed 
+        self.exposure_time = exposure_time
+        self.sed   = sed     # for stellar population type
+        self.agn   = agn_lum # AGN activity
+        self.type  = type    # Galaxy type
+        self.size  = size    # Angular diameter in arcmin
+        self.name   = name
+        self.notes = notes if notes else self.describe()   # string that describes the object
+
+        #setting colors
+        self.color  = self.estimate_color()
+        self.mag    = self.estimate_mag()
+    
+    def get_sed_template(self):
+        return SED_TEMPLATES.get(self.sed, SED_TEMPLATES[self.type])
+    
+    def effective_type(self):
+        return self.sed if self.sed in SED_TEMPLATES else self.type #this is from messy code I don't feel like fixing yet
+    
+    def describe(self):
+        """
+        Layman, educational descriptor built from this galaxy's own physical properties. 
+        Returns a string to be concat'd onto name.
+        """
+        etype = self.effective_type()
+        star_forming = etype in STARFORMING
+
+        lookback = cosmo.lookback_time(self.z).to_value("Gyr")
+        d_com = cosmo.comoving_distance(self.z).to_value("Mpc")
+        wl = ("bluer, shorter-wavelength light from hot, young stars" if star_forming
+              else "redder, longer-wavelength light from old, cool stars")
+
+        base = (f"This is a {etype} galaxy of about {mass_phrase(self.mass)} solar masses, "
+                f"glowing mostly in {wl}. It sits at redshift z = {self.z:.2f}, about "
+                f"{distance_phrase(d_com)} away, so its light left it roughly "
+                f"{lookback:.1f} billion years ago. At magnitude {self.mag:.1f} it would be "
+                f"{visibility(self.mag)} to spot.")
+
+        tidbits = [("It's actively forming new stars." if star_forming
+                   else "It has mostly stopped forming stars ('red and dead').")]
+        
+        if self.agn > 0:
+            tidbits.append("It hosts an active galactic nucleus: a supermassive black hole "
+                           "blazing as it feeds on surrounding gas.")
+            
+        tidbits.append(redshift_note(self.z))
+
+        pool = GAL_TRIVIA.get(etype, [])
+
+        if pool:
+            seed = int(round(self.z, 4) * 1e6 + self.mass) % (2**32)   # deterministic per object
+            tidbits.append(np.random.default_rng(seed).choice(pool))
+
+        return base + " " + " ".join(tidbits)
+
+    def estimate_color(self):
+        #pull template
+        base_color = self.get_sed_template()[0]
+
+        #crude redshift color shift
+        color = base_color + self.z
+        self.color = color
+        return self.color 
+    
+    def estimate_mag(self): 
+        #estimate magnitude based on mass, type, z, d, and m
+        dist_mod = self.distance_modulus() #should just call astropy
+
+        #get luminosity
+        mass_to_light = self.get_sed_template()[1]
+        stellar_lum = self.mass / mass_to_light #should by the solar luminosities
+        lum = stellar_lum + self.agn #adds AGN light
+        
+        M_sun_r = 4.83 # solar absolute magnitude
+
+        #lum to abs mag
+        abs_mag = M_sun_r - 2.5*np.log10(lum)
+
+        #abs mag to app mag
+        self.mag = abs_mag + dist_mod
+
+        return self.mag
+
+
+    def prepare_figure_data(self, display_scale=0.8):
+        '''
+        possible: incorporate ang diameter distance instead of div by 5
+        '''
+        sky_width_deg = self.size * display_scale  # scale actual object size to size on the plot
+
+        wcs = make_wcs()
+
+        # Find pixel position of galaxy center
+        cx, cy = wcs.all_world2pix([[self.ra, self.dec]], 0)[0]
+
+        # Use small offset toward projection center (RA=180) to avoid RA wrap at 0/360
+        delta = -0.1 if self.ra > 180 else 0.1
+        edge_x = wcs.all_world2pix([[self.ra + delta, self.dec]], 0)[0][0]
+        pix_per_deg = abs(edge_x - cx) / abs(delta)
+        pix_width = min(pix_per_deg * sky_width_deg, 15.0)  # cap so no object floods the frame
+
+        n_pix = int(np.clip(pix_width * 20, 20, 200))
+        xs = np.linspace(cx - pix_width, cx + pix_width, n_pix)
+        ys = np.linspace(cy - pix_width, cy + pix_width, n_pix)
+        X, Y = np.meshgrid(xs, ys)
+
+        dx, dy = X - cx, Y - cy
+
+        th = np.radians(self.angle)
+        xr = dx * np.cos(th) + dy * np.sin(th)
+        yr = -dx * np.sin(th) + dy * np.cos(th)
+
+        size = pix_width / 2.0
+        r2 = (xr / size) ** 2 + (yr / (size * self.q)) ** 2
+
+        grid = self.peak_brightness() * np.exp(-0.5 * r2)
+        hue = self.get_hue()
+        # parse rgb values from hue string for faint anchor
+        rgb = hue[4:-1].split(", ")
+        faint_hue = f"rgba({rgb[0]}, {rgb[1]}, {rgb[2]}, 0.08)"
+        cs = [[0.0, "rgba(0,0,0,0)"], [0.15, faint_hue], [1.0, hue]]
+
+        return xs, ys, grid, cs
+
+
+    def visualize(self): 
+        
+        xs, ys, grid, cs = self.prepare_figure_data()
+        fig = go.Figure(go.Heatmap(x=xs, y=ys, z=grid, zmin=0, zmax=1, colorscale=cs, showscale=False))
+
+        return self.finish_visualize(fig, f"Galaxy with z={self.z} and {self.color:.2f}")
+
+'''
+Cluster class
+'''    
+class Cluster(AstroObject):
+    def __init__(self, ra, dec, z, q, n, r, seed=None, exposure_time=1, bcg_scale=1.5):
+        name = cluster_designation(ra, dec)
+        super().__init__(ra, dec, z, name=name, exposure_time=exposure_time)
+        self.q = q # squash factor of cluster from y-axis
+        self.ra = ra #Right Ascention, equatorial positon in sky
+        self.dec = dec #Declination, angular distance from the equator
+        self.z = z #Redshift
+        self.n = n #Number of galaxies in cluster
+        self.r = r #Radius of the cluster
+        self.cluster_size = 0
+        self.bcg_scale = bcg_scale
+        self.bcg_name = f"{self.name} BCG"
+        self.seed = seed
+        self.members = self.generate_members() # initializes the cluster with its members
+
+    def generate_members(self):
+        '''
+        four major arrrays: galaxy types, list of random masses for individual points, 
+        ra and dec of all points
+        '''
+        if self.seed:
+            rng = np.random.default_rng(self.seed)
+        else: 
+            rng = np.random.default_rng(seed=42)
+
+        #Galaxy RAs and Decs
+        r_Mpc = self.r # radius of cluster in Mpc
+        dA_Mpc = cosmo.angular_diameter_distance(self.z).value # distance from observer to cluster in Mpc
+        cluster_size = np.degrees(r_Mpc/dA_Mpc) * 50 # gets angular size of cluster in degrees (from rads) and scales up
+        self.cluster_size = cluster_size #saving this for later
+
+        dx = rng.normal(0, cluster_size, self.n) # returns array of random positions along x axis (RA)
+        dy = self.q * rng.normal(0, cluster_size, self.n) # returns array of random positions along y axis (dec), with a boundary defined by q
+        cluster_ras  = (self.ra + dx) % 360.0                 # RA wraps around the sky
+        cluster_decs = np.clip(self.dec + dy, -90.0, 90.0)    # Dec capped at the poles
+        # orient_angle = rng.uniform(0, np.pi)
+        
+        #Galaxy masses
+        cluster_ms = np.power(10, rng.uniform(9, 11, self.n)) # generates array of standard masses for cluster galaxies
+
+        #Galaxy redshifts
+        cluster_zs = rng.normal(0, 0.005, self.n) + self.z # generates array of cluster galaxy redshift
+
+        #cluster_members = np.zeros(self.n)
+
+        #Galaxy Types
+        gal_types = np.array(["elliptical", "spiral", "irregular"])
+        cl_gal_types = rng.choice(gal_types, self.n, p=np.array([0.7,0.2,0.1]))
+
+        # fix by appending instead of initializing
+        '''
+        cluster_members = np.array([], dtype=Galaxy)
+        for i in range(self.n):
+            gal= Galaxy(cluster_ras[i], cluster_decs[i], cluster_zs[i], cluster_ms[i], sed = cl_gal_types[i])
+            cluster_members = np.append(cluster_members, gal)
+        '''
+
+        # loops over members to properly create Galaxy objects
+        cluster_members = np.array([], dtype=Galaxy)
+
+        # adjust size for jade's code
+        member_size = cluster_size / 5
+
+        '''
+        for i in range(self.n):
+            gal = Galaxy(cluster_ras[i], cluster_decs[i], cluster_zs[i],
+                name=f"member_{i}", size=member_size, mass=cluster_ms[i], sed=cl_gal_types[i], exposure_time=self.exposure_time)
+            cluster_members = np.append(cluster_members, gal)
+
+        # add BCG
+        bcg_name = f"BCG of {self.name}"
+        bcg_size = member_size * self.bcg_scale #before doing this it gave a cool DM halo visualization
+        bcg = Galaxy(self.ra, self.dec, self.z, q=0.7, mass=1e12, sed="elliptical",
+                      name=bcg_name, 
+                      size=bcg_size, exposure_time=self.exposure_time)
+        bcg.angle = np.random.uniform(0, 180)
+        cluster_members = np.insert(cluster_members, 0, bcg)
+        '''
+
+        member_size = 1.0  # fixed size independent of cluster spread
+
+        # BCG
+        bcg = Galaxy(self.ra, self.dec, self.z, name=self.bcg_name,
+                    size=member_size * self.bcg_scale, type="elliptical", sed="elliptical",
+                    mass=5e12, exposure_time=self.exposure_time)
+        bcg.name += " " + bcg_sentence(self.name)
+
+        cluster_members = np.array([], dtype=Galaxy)
+        for i in range(self.n - 1):
+            gal = Galaxy(cluster_ras[i], cluster_decs[i], cluster_zs[i],
+                        name=f"{cl_gal_types[i].capitalize()} gallaxy",
+                        size=member_size, mass=cluster_ms[i], sed=cl_gal_types[i],
+                        exposure_time=self.exposure_time)
+            gal.notes += " " + sat_sentence(self.name, self.bcg_name)
+            cluster_members = np.append(cluster_members, gal)
+
+        cluster_members = np.insert(cluster_members, 0, bcg)
+        return cluster_members
+    
+    def visualize_cluster(self):
+        '''
+        Visualize the cluster independently for testing
+        '''
+        cluster_fig = go.Figure()
+
+        for galaxy in self.members: 
+            xs, ys, grid, cs = galaxy.prepare_figure_data() 
+
+            cluster_fig.add_trace(go.Heatmap(x=xs, y=ys, z=grid, 
+                                zmin=0, zmax=1, colorscale=cs, showscale=False))
+            
+            title = f"Cluster at z={self.z:.3f} with {self.n} members"
+        
+        return self.finish_visualize(cluster_fig, title)
+
+
+
+       
+
+
+
+        

galaga_lab-0.0.1/galaga_lab/Backend/generate_field.py

@@ -0,0 +1,99 @@
+'''
+File for generating the field and functions associated with that
+'''
+import numpy as np
+import plotly.graph_objects as go
+from .astro_objects import AstroObject, Galaxy, Cluster
+from astropy.cosmology import Planck18 as cosmo
+
+# setting arrays
+gal_types = np.array(["elliptical", "lenticular", "spiral", "irregular", "starburst"])
+type_weights = np.array([0.20, 0.15, 0.35, 0.20, 0.10])
+
+# helper function
+def angular_sizes_from_z(zs, rng, z_ref=0.3, size_ref=1.5, scatter=0.25):
+    zs = np.asarray(zs, dtype=float)
+    dA = cosmo.angular_diameter_distance(zs).to_value("Mpc")
+    dA_ref = cosmo.angular_diameter_distance(z_ref).to_value("Mpc")
+
+    sizes  = size_ref * dA_ref / dA
+    sizes *= rng.lognormal(mean=0.0, sigma=scatter, size=zs.shape)
+    return sizes
+
+def generate_field(ra_center=180.0, dec_center=0.0, width=4.0, height=4.0, 
+                   n_gals=200, n_clusters=2, exposure_time=1, seed=None):
+    rng = np.random.default_rng(seed)
+
+    ra_low = ra_center - width/2
+    ra_high = ra_center + width/2
+    dec_low = dec_center - height/2
+    dec_high = dec_center + height/2
+
+    # generate random positions
+    ras = rng.uniform(ra_low, ra_high, n_gals)
+    sin_1 = np.sin(np.radians(dec_low))
+    sin_2 = np.sin(np.radians(dec_high))
+    decs = np.degrees(np.arcsin(np.clip(rng.uniform(sin_1, sin_2, n_gals), -1.0, 1.0)))
+
+    # field making
+    field = np.array([], dtype=AstroObject)
+
+    zs = np.maximum(rng.gamma(shape=2.0, scale=0.25, size=n_gals), 0.05)
+    types = rng.choice(gal_types, size=n_gals, p=type_weights) 
+    masses = np.power(10, rng.uniform(7, 11, n_gals))
+    sizes = angular_sizes_from_z(zs, rng)
+
+    for i in range(n_gals): 
+        g = Galaxy(ras[i], decs[i], zs[i], name=f"{types[i].capitalize()} gallaxy", 
+                   size=sizes[i], sed=types[i], mass=masses[i],
+                   exposure_time = exposure_time)
+        field = np.append(field, g)
+    
+    # generate random positions
+    cl_ras = rng.uniform(ra_low, ra_high, n_clusters)
+    sin_1 = np.sin(np.radians(dec_low))
+    sin_2 = np.sin(np.radians(dec_high))
+    cl_decs = np.degrees(np.arcsin(np.clip(rng.uniform(sin_1, sin_2, n_clusters), -1.0, 1.0)))
+
+    for i in range(n_clusters):
+        c = Cluster(ra=cl_ras[i], dec=cl_decs[i], z=rng.uniform(0.1, 0.6),
+                    q=rng.uniform(0.5, 1.0), n=int(rng.integers(15, 30)),
+                    r=rng.uniform(0.8, 2.0), exposure_time=exposure_time)
+        field = np.append(field, c)
+    
+    return field
+
+def visualize_field(field, title='Random galaxy field'): 
+    fig = go.Figure() 
+
+    #flattening clusters to galaxies
+    gals = np.array([], dtype=Galaxy)
+    for object in field: 
+        members = getattr(object, "members", None)
+
+        # for clusters
+        if members is not None: 
+            gals = np.append(gals, members)
+        else: #its galaxy
+            gals = np.append(gals, object)
+    
+    # loop over for data visual
+    for gal in gals: 
+        xs, ys, grid, cs = gal.prepare_figure_data()
+        fig.add_trace(go.Heatmap(x=xs, y=ys, z=grid, zmin=0, zmax=1,
+                                 colorscale=cs, showscale=False))
+    
+    dark = "rgb(10, 10, 30)"
+    fig.update_layout(title=f"{title} ({len(gals)} objects)",
+                      width=700, height=700,
+                      paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor=dark,
+                      xaxis_title="RA [pix]", yaxis_title="dec [pix]")
+    fig.update_xaxes(autorange="reversed", showgrid=False, zeroline=False)
+    fig.update_yaxes(scaleanchor="x", showgrid=False, zeroline=False)
+    fig.show()
+    return fig
+
+
+
+
+    

galaga_lab-0.0.1/galaga_lab/Frontend/frontend_utils.py

@@ -0,0 +1,226 @@
+'''
+File for the DASH interaction side
+'''
+
+from astropy.coordinates import SkyCoord
+import numpy as np
+import plotly.graph_objects as go
+import yaml
+from astropy import units as u
+from Backend.astro_objects import Galaxy, make_wcs
+from Backend.generate_field import generate_field
+
+
+def add_object(fig, galaxy, xs, ys, grid, cs, usename=True):
+    """On-Sky Object Position Projection
+
+    Takes in go.Figure object from plotly, a Galaxy object from astro_objects.py and returns 
+    a modified graph object for displaying through DASH. 
+
+    Args:
+        fig (go.Figure object): go.Figure object from plotly. Typically displaying a Galaxy object.
+        ra (np.float): float value; degrees. Right Ascension to put on the on-sky projection. 
+        dec (np.float): float value; degrees. Declination to put on the on-sky projection. 
+        name (string): string value. Name of object on the sky. 
+        color (string): Color of the marker on the graph
+        size (int): integer value. Size of object on-sky
+    
+    Returns:
+        fig (go.Figure object): go.Figure object from plotly. Modified graph object for displaying through DASH.
+    """
+
+    wcs = make_wcs()
+    px = wcs.all_world2pix([[galaxy.coord.ra.deg, galaxy.coord.dec.deg]], 0)[0]
+
+    ra_str  = galaxy.coord.ra.to_string(unit=u.hourangle, sep=('\u02b0', '\u1d50', '\u02e2'), pad=True)
+    dec_str = galaxy.coord.dec.to_string(unit=u.deg, sep=('\u00b0', '\u2032', '\u2033'), pad=True, alwayssign=True)
+
+    fig.add_trace(go.Heatmap(
+        x          = xs, 
+        y          = ys, 
+        z          = grid,
+        zmin       = 0,
+        zmax       = 1,
+        colorscale = cs,
+        showscale  = False,
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=[px[0]], y=[px[1]], mode="markers",
+        marker=dict(size=6, color="rgba(0,0,0,0)"),
+        name=galaxy.name,
+        hovertemplate=f"RA: {ra_str}<br>Dec: {dec_str}<extra></extra>",
+        customdata=[[galaxy.name, galaxy.notes]],
+    ))
+    
+    if usename:
+        fig.add_annotation(
+            x=px[0], y=px[1], text=galaxy.name,
+            yshift=10, showarrow=False,
+            font=dict(color="white", size=10),
+        )
+
+    fig.update_layout(
+        hoverlabel=dict(
+            bgcolor="rgba(20, 20, 50, 0.9)",   # background color
+            bordercolor="rgba(255,255,255,0.3)", # border color
+            font=dict(
+                color="white",
+                size=13,
+                family="monospace",
+            ),
+        )
+    )
+
+    return fig
+
+
+def add_catalog_objects(fig, catalog_path, exposure_time):
+    """
+    Loads in the catalog.yaml file and adds all objects to the graph. Calls add_object()
+    """
+    with open(catalog_path, "r") as f:
+        catalog = yaml.safe_load(f)
+
+    for obj in catalog["objects"]:
+
+        coord  = SkyCoord(ra=obj["ra"], dec=obj["dec"], unit=(u.hourangle, u.deg))
+        galaxy = Galaxy(
+                ra            = coord.ra.to(u.deg).value,
+                dec           = coord.dec.to(u.deg).value, 
+                z             = float(obj["redshift"]), 
+                name          = obj["name"],
+                mass          = float(obj["mass_msun"]),
+                q             = float(obj["q"]),
+                type          = obj["type"],
+                size          = float(obj["size_arcmin"]),
+                notes         = obj["notes"],
+                exposure_time = exposure_time,
+            )
+
+        xs, ys, grid, cs = galaxy.prepare_figure_data()
+        fig = add_object(fig, galaxy, xs, ys, grid, cs, usename=True)
+
+    return fig
+
+
+def add_random_field(fig, exposure_time, seed):
+    """
+    Add random galaxy/cluster field instead of calatog objects
+    """
+
+    field = generate_field(ra_center=180.0, dec_center=0.0, width=360.0, height=180.0, 
+                           n_gals=200, n_clusters=5, seed=seed, exposure_time=exposure_time)
+    
+    for object in field:
+
+        if isinstance(object, Galaxy):
+            xs, ys, grid, cs = object.prepare_figure_data()
+            fig = add_object(fig, object, xs, ys, grid, cs, usename=False)
+
+        else:
+            for galaxy in object.members:
+                xs, ys, grid, cs = galaxy.prepare_figure_data()
+                fig = add_object(fig, galaxy, xs, ys, grid, cs, usename=False)
+    
+    return fig
+
+
+
+def init_graph(catalog_path, exposure_time, random_field=False, seed=None):
+    """
+    Build and return the empty sky-chart figure using astropy
+    """
+    wcs        = make_wcs()
+    n_pts      = 400
+    grid_color = "rgba(255,255,255,0.15)"
+    label_color= "rgba(255,255,255,0.55)"
+    traces     = []
+
+    # ── Dec parallels (sweeps through RA) ──────────────────────────
+    ra_sweep = np.linspace(0.5, 359.5, n_pts)
+    for dec in range(-90, 91, 15):
+        sky = np.column_stack([ra_sweep, np.full(n_pts, float(dec))])
+        px  = wcs.all_world2pix(sky, 0)
+        traces.append(go.Scatter(
+            x=px[:, 0], y=px[:, 1],
+            mode="lines",
+            line=dict(color=grid_color, width=0.8),
+            hoverinfo="skip",
+            showlegend=False,
+        ))
+        # Label on the central meridian (RA = 180)
+        lx, ly = wcs.all_world2pix([[180, dec]], 0)[0]
+        traces.append(go.Scatter(
+            x=[lx + 3], y=[ly],
+            mode="text",
+            text=[f"{dec:+d}°"],
+            textfont=dict(color=label_color, size=9),
+            hoverinfo="skip",
+            showlegend=False,
+        ))
+
+    # ── RA meridians (sweeps through Dec) ─────────────────────────
+    dec_sweep = np.linspace(-89.9, 89.9, n_pts)
+    for ra_h in range(0, 24):
+        ra_deg = ra_h * 15.0
+        sky = np.column_stack([np.full(n_pts, ra_deg), dec_sweep])
+        px  = wcs.all_world2pix(sky, 0)
+        traces.append(go.Scatter(
+            x=px[:, 0], y=px[:, 1],
+            mode="lines",
+            line=dict(color=grid_color, width=0.8),
+            hoverinfo="skip",
+            showlegend=False,
+        ))
+        # Label along the equator (Dec = 0)
+        lx, ly = wcs.all_world2pix([[ra_deg, 0]], 0)[0]
+        traces.append(go.Scatter(
+            x=[lx], y=[ly - 6],
+            mode="text",
+            text=[f"{ra_h}h"],
+            textfont=dict(color=label_color, size=9),
+            hoverinfo="skip",
+            showlegend=False,
+        ))
+
+    # ── Outer boundary ellipse ────────────────────────────────────────────────
+    theta = np.linspace(0, 2 * np.pi, 500)
+    # boundary in WCS pixel coords
+    bx = 163.0 * np.cos(theta)
+    by =  82.0 * np.sin(theta)
+    traces.append(go.Scatter(
+        x=bx, y=by,
+        mode="lines",
+        line=dict(color="rgba(255,255,255,0.35)", width=1.2),
+        hoverinfo="skip",
+        showlegend=False,
+    ))
+
+    fig = go.Figure(data=traces)
+    fig.update_layout(
+        paper_bgcolor="#111111",
+        plot_bgcolor="#111111",
+        margin=dict(l=20, r=20, t=20, b=20),
+        xaxis=dict(
+            visible=False,
+            range=[-175, 175],
+            scaleanchor="y",
+            scaleratio=1,
+        ),
+        yaxis=dict(
+            visible=False,
+            range=[-95, 95],
+        ),
+        showlegend=False,
+        dragmode="pan",
+    )
+
+
+    # Now add objects
+    if random_field:
+        fig = add_random_field(fig, exposure_time=exposure_time, seed=seed)
+    else:
+        fig = add_catalog_objects(fig, catalog_path=catalog_path, exposure_time=exposure_time)
+
+    return fig

galaga_lab-0.0.1/galaga_lab/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

galaga_lab-0.0.1/galaga_lab/app.py

@@ -0,0 +1,163 @@
+from dash import (
+    Dash,
+    html,
+    dcc,
+    callback,
+    Output,
+    Input,
+    State,
+    no_update,
+    ctx,
+)
+
+import dash_bootstrap_components as dbc
+import os
+from flask import Flask
+import Frontend.frontend_utils as frontu
+import random
+
+
+# =========== Global variables ==============
+
+CATALOG_PATH = "./catalog.yml"
+
+# ====== Initialize the webserver ============
+
+server = Flask(__name__)
+server.secret_key = os.urandom(24)
+
+app = Dash(__name__, external_stylesheets=[dbc.themes.DARKLY], server=server)
+
+
+app.layout = dbc.Container([
+
+    dbc.Row([
+
+        dbc.Col(
+            html.H1("GALAGA LAB"),
+            width=12, className="text-center"
+        ),
+
+    ], className="my-2"),
+
+    dbc.Row([
+        dbc.Col(
+            dcc.Graph(id="main-graph", style={"width": "100%", "height": "70vh"}),
+            width=12, className="mb-0"
+        ),
+    ], className="mt-0", justify="center", align="center"),
+
+    dbc.Row([
+        dbc.Col([
+            dbc.ButtonGroup([
+                dbc.Button("Random Field", id="btn-random-field", color="primary", outline=False, n_clicks=0),
+                dbc.Button("Catalog", id="btn-catalog", color="primary", outline=True, n_clicks=0),
+            ], id="mode-toggle"),
+        ], width='auto'),
+    ], justify="center", class_name="my-2"),
+
+    dbc.Row([
+        dbc.Col([
+            dcc.Slider(min=0, max=100, marks=None,
+                value=10,
+                id='exposure-slider',
+                updatemode='mouseup',
+            ),
+            html.Label("Exposure Time", htmlFor="exposure-slider",
+                    className="d-block text-center mb-1"),
+        ], width=12),
+    ]),
+
+    dbc.Modal([
+        dbc.ModalHeader(
+            dbc.ModalTitle(id="info-panel-title", style={
+                "position": "absolute",
+                "left": "50%",
+                "transform": "translateX(-50%)",
+            }),
+            className="position-relative",
+        ),
+        dbc.ModalBody(id="info-panel-body", className="text-center"),
+    ], id="info-panel", is_open=False, size="md"),
+
+    # Fires once on page load
+    dcc.Interval(id="init-interval", interval=1, max_intervals=1),
+    # Random seed for the random field
+    dcc.Store(id="field-seed"),
+
+], fluid=True)
+
+
+@callback(
+    Output("main-graph", "figure"),
+    Output("field-seed", "data"),
+    Input("init-interval", "n_intervals"),
+    State("exposure-slider", "value"),
+)
+def initialize_graph(n, exposure_time):
+    seed = random.randrange(2**32)
+    fig = frontu.init_graph(catalog_path=CATALOG_PATH, random_field=True,
+                             exposure_time=exposure_time, seed=seed)
+    
+    return fig, seed
+
+
+@callback(
+    Output("info-panel", "is_open"),
+    Output("info-panel-title", "children"),
+    Output("info-panel-body", "children"),
+    Input("main-graph", "clickData"),
+    prevent_initial_call=True,
+)
+def on_galaxy_click(clickData):
+    if not clickData:
+        return False, "", ""
+
+    point = clickData["points"][0]
+    if "customdata" not in point:
+        return no_update, no_update, no_update
+
+    name, notes = point["customdata"]
+    return True, name, notes
+
+
+@callback(
+    Output("btn-random-field", "outline"),
+    Output("btn-catalog", "outline"),
+    Output("main-graph", "figure", allow_duplicate=True),
+    Input("btn-random-field", "n_clicks"),
+    Input("btn-catalog", "n_clicks"),
+    State("exposure-slider", "value"),
+    State("field-seed", "data"),
+    prevent_initial_call=True
+)
+def toggle_view(rf_clicks, cat_clicks, exposure_time, seed):
+
+    random_field_on = ctx.triggered_id == "btn-random-field"
+
+    # update graph
+    fig = frontu.init_graph(catalog_path=CATALOG_PATH, random_field=random_field_on, exposure_time=exposure_time, seed=seed)
+
+    return (
+        not random_field_on,   # btn-random-field: filled when active
+        random_field_on,       # btn-catalog: filled when active
+        fig,
+    )
+
+
+@callback(
+    Output("main-graph", "figure", allow_duplicate=True),
+    Input("exposure-slider", "value"),
+    State("btn-random-field", "outline"),
+    State("field-seed", "data"),
+    prevent_initial_call=True,
+)
+def update_exposure(exposure_time, rf_outline, seed):
+    # btn-random-field is filled (outline=False) exactly when the random field is showing
+    random_field_on = not rf_outline
+    return frontu.init_graph(catalog_path=CATALOG_PATH, random_field=random_field_on,
+                             exposure_time=exposure_time, seed=seed)
+
+
+if __name__ == "__main__":
+    app.run(debug=True, use_reloader=True)

galaga_lab-0.0.1/galaga_lab.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: galaga_lab
+Version: 0.0.1
+Requires-Dist: astropy
+Requires-Dist: numpy
+Requires-Dist: dash
+Requires-Dist: dash_bootstrap_components
+Requires-Dist: Flask
+Requires-Dist: plotly
+Requires-Dist: PyYAML

galaga_lab-0.0.1/galaga_lab.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+galaga_lab/__init__.py
+galaga_lab/app.py
+galaga_lab.egg-info/PKG-INFO
+galaga_lab.egg-info/SOURCES.txt
+galaga_lab.egg-info/dependency_links.txt
+galaga_lab.egg-info/requires.txt
+galaga_lab.egg-info/top_level.txt
+galaga_lab/Backend/astro_objects.py
+galaga_lab/Backend/generate_field.py
+galaga_lab/Frontend/frontend_utils.py
+tests/test_calculations.py

galaga_lab-0.0.1/galaga_lab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

galaga_lab-0.0.1/galaga_lab.egg-info/requires.txt

@@ -0,0 +1,7 @@
+astropy
+numpy
+dash
+dash_bootstrap_components
+Flask
+plotly
+PyYAML

galaga_lab-0.0.1/galaga_lab.egg-info/top_level.txt

@@ -0,0 +1 @@
+mypkg

galaga_lab-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[tools.setuptools]
+package_dir = {""="src"}
+
+[tool.setuptools.package-dir]
+mypkg = "galaga_lab"
+
+[project]
+name = "galaga_lab"
+version = "0.0.1" 
+dependencies = [
+	"astropy", 
+	"numpy", 
+	"dash", 
+	"dash_bootstrap_components", 
+	"Flask",
+	"plotly",
+	"PyYAML"
+]

galaga_lab-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

galaga_lab-0.0.1/tests/test_calculations.py

@@ -0,0 +1,48 @@
+"""Minimal unit tests for AstroObject calculations. Run: python -m pytest"""
+import os
+import sys
+import math
+import pytest
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from galaga_lab.Backend.astro_objects import AstroObject 
+
+
+def make_obj(z=0.1, color=0.0, mag=0.0, exposure_time=1.0):
+    obj = AstroObject(ra=150.0, dec=2.0, z=z, exposure_time=exposure_time)
+    obj.color = color
+    obj.mag = mag
+    return obj
+
+
+def test_get_hue_anchors_and_clip():
+    assert make_obj(color=0.3).get_hue() == "rgb(150, 180, 255)"   # blue anchor
+    assert make_obj(color=0.9).get_hue() == "rgb(255, 140, 110)"   # red anchor
+    assert make_obj(color=-5).get_hue() == "rgb(150, 180, 255)"    # clipped low
+    assert make_obj(color=5).get_hue() == "rgb(255, 140, 110)"     # clipped high
+
+
+def test_get_hue_midpoint():
+    # color 0.6 -> c=0.5, components truncated to int
+    assert make_obj(color=0.6).get_hue() == "rgb(202, 160, 182)"
+
+
+def test_peak_brightness_midrange():
+    # exposure 1 -> m_lim=25; mag 20 -> (25-20)/10 = 0.5
+    assert make_obj(mag=20.0, exposure_time=1.0).peak_brightness() == pytest.approx(0.5)
+
+
+def test_peak_brightness_clamps():
+    assert make_obj(mag=200.0).peak_brightness() == pytest.approx(0.12)   # floor
+    assert make_obj(mag=-100.0).peak_brightness() == pytest.approx(1.5)   # ceiling
+
+
+def test_peak_brightness_exposure_floored():
+    # exposure 0 clamps to 1e-3 -> m_lim=19; mag 10 -> 0.9
+    assert make_obj(mag=10.0).peak_brightness(exposure_time=0) == pytest.approx(0.9)
+
+
+def test_distance_modulus_matches_luminosity_distance():
+    # identity: mu = 5*log10(d_Mpc) + 25
+    obj = make_obj(z=0.4)
+    assert obj.distance_modulus() == pytest.approx(5 * math.log10(obj.d) + 25)