@synsci/cli-darwin-arm64 1.1.76 → 1.1.78

package/bin/skills/astropy/references/coordinates.md

@@ -0,0 +1,273 @@
+# Astronomical Coordinates (astropy.coordinates)
+
+The `astropy.coordinates` package provides tools for representing celestial coordinates and transforming between different coordinate systems.
+
+## Creating Coordinates with SkyCoord
+
+The high-level `SkyCoord` class is the recommended interface:
+
+```python
+from astropy import units as u
+from astropy.coordinates import SkyCoord
+
+# Decimal degrees
+c = SkyCoord(ra=10.625*u.degree, dec=41.2*u.degree, frame='icrs')
+
+# Sexagesimal strings
+c = SkyCoord(ra='00h42m30s', dec='+41d12m00s', frame='icrs')
+
+# Mixed formats
+c = SkyCoord('00h42.5m +41d12m', unit=(u.hourangle, u.deg))
+
+# Galactic coordinates
+c = SkyCoord(l=120.5*u.degree, b=-23.4*u.degree, frame='galactic')
+```
+
+## Array Coordinates
+
+Process multiple coordinates efficiently using arrays:
+
+```python
+# Create array of coordinates
+coords = SkyCoord(ra=[10, 11, 12]*u.degree,
+                  dec=[41, -5, 42]*u.degree)
+
+# Access individual elements
+coords[0]
+coords[1:3]
+
+# Array operations
+coords.shape
+len(coords)
+```
+
+## Accessing Components
+
+```python
+c = SkyCoord(ra=10.68*u.degree, dec=41.27*u.degree, frame='icrs')
+
+# Access coordinates
+c.ra        # <Longitude 10.68 deg>
+c.dec       # <Latitude 41.27 deg>
+c.ra.hour   # Convert to hours
+c.ra.hms    # Hours, minutes, seconds tuple
+c.dec.dms   # Degrees, arcminutes, arcseconds tuple
+```
+
+## String Formatting
+
+```python
+c.to_string('decimal')      # '10.68 41.27'
+c.to_string('dms')          # '10d40m48s 41d16m12s'
+c.to_string('hmsdms')       # '00h42m43.2s +41d16m12s'
+
+# Custom formatting
+c.ra.to_string(unit=u.hour, sep=':', precision=2)
+```
+
+## Coordinate Transformations
+
+Transform between reference frames:
+
+```python
+c_icrs = SkyCoord(ra=10.68*u.degree, dec=41.27*u.degree, frame='icrs')
+
+# Simple transformations (as attributes)
+c_galactic = c_icrs.galactic
+c_fk5 = c_icrs.fk5
+c_fk4 = c_icrs.fk4
+
+# Explicit transformations
+c_icrs.transform_to('galactic')
+c_icrs.transform_to(FK5(equinox='J1975'))  # Custom frame parameters
+```
+
+## Common Coordinate Frames
+
+### Celestial Frames
+- **ICRS**: International Celestial Reference System (default, most common)
+- **FK5**: Fifth Fundamental Catalogue (equinox J2000.0 by default)
+- **FK4**: Fourth Fundamental Catalogue (older, requires equinox specification)
+- **GCRS**: Geocentric Celestial Reference System
+- **CIRS**: Celestial Intermediate Reference System
+
+### Galactic Frames
+- **Galactic**: IAU 1958 galactic coordinates
+- **Supergalactic**: De Vaucouleurs supergalactic coordinates
+- **Galactocentric**: Galactic center-based 3D coordinates
+
+### Horizontal Frames
+- **AltAz**: Altitude-azimuth (observer-dependent)
+- **HADec**: Hour angle-declination
+
+### Ecliptic Frames
+- **GeocentricMeanEcliptic**: Geocentric mean ecliptic
+- **BarycentricMeanEcliptic**: Barycentric mean ecliptic
+- **HeliocentricMeanEcliptic**: Heliocentric mean ecliptic
+
+## Observer-Dependent Transformations
+
+For altitude-azimuth coordinates, specify observation time and location:
+
+```python
+from astropy.time import Time
+from astropy.coordinates import EarthLocation, AltAz
+
+# Define observer location
+observing_location = EarthLocation(lat=40.8*u.deg, lon=-121.5*u.deg, height=1060*u.m)
+# Or use named observatory
+observing_location = EarthLocation.of_site('Apache Point Observatory')
+
+# Define observation time
+observing_time = Time('2023-01-15 23:00:00')
+
+# Transform to alt-az
+aa_frame = AltAz(obstime=observing_time, location=observing_location)
+aa = c_icrs.transform_to(aa_frame)
+
+print(f"Altitude: {aa.alt}")
+print(f"Azimuth: {aa.az}")
+```
+
+## Working with Distances
+
+Add distance information for 3D coordinates:
+
+```python
+# With distance
+c = SkyCoord(ra=10*u.degree, dec=9*u.degree, distance=770*u.kpc, frame='icrs')
+
+# Access 3D Cartesian coordinates
+c.cartesian.x
+c.cartesian.y
+c.cartesian.z
+
+# Distance from origin
+c.distance
+
+# 3D separation
+c1 = SkyCoord(ra=10*u.degree, dec=9*u.degree, distance=10*u.pc)
+c2 = SkyCoord(ra=11*u.degree, dec=10*u.degree, distance=11.5*u.pc)
+sep_3d = c1.separation_3d(c2)  # 3D distance
+```
+
+## Angular Separation
+
+Calculate on-sky separations:
+
+```python
+c1 = SkyCoord(ra=10*u.degree, dec=9*u.degree, frame='icrs')
+c2 = SkyCoord(ra=11*u.degree, dec=10*u.degree, frame='fk5')
+
+# Angular separation (handles frame conversion automatically)
+sep = c1.separation(c2)
+print(f"Separation: {sep.arcsec} arcsec")
+
+# Position angle
+pa = c1.position_angle(c2)
+```
+
+## Catalog Matching
+
+Match coordinates to catalog sources:
+
+```python
+# Single target matching
+catalog = SkyCoord(ra=ra_array*u.degree, dec=dec_array*u.degree)
+target = SkyCoord(ra=10.5*u.degree, dec=41.2*u.degree)
+
+# Find closest match
+idx, sep2d, dist3d = target.match_to_catalog_sky(catalog)
+matched_coord = catalog[idx]
+
+# Match with maximum separation constraint
+matches = target.separation(catalog) < 1*u.arcsec
+```
+
+## Named Objects
+
+Retrieve coordinates from online catalogs:
+
+```python
+# Query by name (requires internet)
+m31 = SkyCoord.from_name("M31")
+crab = SkyCoord.from_name("Crab Nebula")
+psr = SkyCoord.from_name("PSR J1012+5307")
+```
+
+## Earth Locations
+
+Define observer locations:
+
+```python
+# By coordinates
+location = EarthLocation(lat=40*u.deg, lon=-120*u.deg, height=1000*u.m)
+
+# By named observatory
+keck = EarthLocation.of_site('Keck Observatory')
+vlt = EarthLocation.of_site('Paranal Observatory')
+
+# By address (requires internet)
+location = EarthLocation.of_address('1002 Holy Grail Court, St. Louis, MO')
+
+# List available observatories
+EarthLocation.get_site_names()
+```
+
+## Velocity Information
+
+Include proper motion and radial velocity:
+
+```python
+# Proper motion
+c = SkyCoord(ra=10*u.degree, dec=41*u.degree,
+             pm_ra_cosdec=15*u.mas/u.yr,
+             pm_dec=5*u.mas/u.yr,
+             distance=150*u.pc)
+
+# Radial velocity
+c = SkyCoord(ra=10*u.degree, dec=41*u.degree,
+             radial_velocity=20*u.km/u.s)
+
+# Both
+c = SkyCoord(ra=10*u.degree, dec=41*u.degree, distance=150*u.pc,
+             pm_ra_cosdec=15*u.mas/u.yr, pm_dec=5*u.mas/u.yr,
+             radial_velocity=20*u.km/u.s)
+```
+
+## Representation Types
+
+Switch between coordinate representations:
+
+```python
+# Cartesian representation
+c = SkyCoord(x=1*u.kpc, y=2*u.kpc, z=3*u.kpc,
+             representation_type='cartesian', frame='icrs')
+
+# Change representation
+c.representation_type = 'cylindrical'
+c.rho  # Cylindrical radius
+c.phi  # Azimuthal angle
+c.z    # Height
+
+# Spherical (default for most frames)
+c.representation_type = 'spherical'
+```
+
+## Performance Tips
+
+1. **Use arrays, not loops**: Process multiple coordinates as single array
+2. **Pre-compute frames**: Reuse frame objects for multiple transformations
+3. **Use broadcasting**: Efficiently transform many positions across many times
+4. **Enable interpolation**: For dense time sampling, use ErfaAstromInterpolator
+
+```python
+# Fast approach
+coords = SkyCoord(ra=ra_array*u.degree, dec=dec_array*u.degree)
+coords_transformed = coords.transform_to('galactic')
+
+# Slow approach (avoid)
+for ra, dec in zip(ra_array, dec_array):
+    c = SkyCoord(ra=ra*u.degree, dec=dec*u.degree)
+    c_transformed = c.transform_to('galactic')
+```

package/bin/skills/astropy/references/cosmology.md

@@ -0,0 +1,307 @@
+# Cosmological Calculations (astropy.cosmology)
+
+The `astropy.cosmology` subpackage provides tools for cosmological calculations based on various cosmological models.
+
+## Using Built-in Cosmologies
+
+Preloaded cosmologies based on WMAP and Planck observations:
+
+```python
+from astropy.cosmology import Planck18, Planck15, Planck13
+from astropy.cosmology import WMAP9, WMAP7, WMAP5
+from astropy import units as u
+
+# Use Planck 2018 cosmology
+cosmo = Planck18
+
+# Calculate distance to z=4
+d = cosmo.luminosity_distance(4)
+print(f"Luminosity distance at z=4: {d}")
+
+# Age of universe at z=0
+age = cosmo.age(0)
+print(f"Current age of universe: {age.to(u.Gyr)}")
+```
+
+## Creating Custom Cosmologies
+
+### FlatLambdaCDM (Most Common)
+
+Flat universe with cosmological constant:
+
+```python
+from astropy.cosmology import FlatLambdaCDM
+
+# Define cosmology
+cosmo = FlatLambdaCDM(
+    H0=70 * u.km / u.s / u.Mpc,  # Hubble constant at z=0
+    Om0=0.3,                      # Matter density parameter at z=0
+    Tcmb0=2.725 * u.K             # CMB temperature (optional)
+)
+```
+
+### LambdaCDM (Non-Flat)
+
+Non-flat universe with cosmological constant:
+
+```python
+from astropy.cosmology import LambdaCDM
+
+cosmo = LambdaCDM(
+    H0=70 * u.km / u.s / u.Mpc,
+    Om0=0.3,
+    Ode0=0.7  # Dark energy density parameter
+)
+```
+
+### wCDM and w0wzCDM
+
+Dark energy with equation of state parameter:
+
+```python
+from astropy.cosmology import FlatwCDM, w0wzCDM
+
+# Constant w
+cosmo_w = FlatwCDM(H0=70 * u.km/u.s/u.Mpc, Om0=0.3, w0=-0.9)
+
+# Evolving w(z) = w0 + wz * z
+cosmo_wz = w0wzCDM(H0=70 * u.km/u.s/u.Mpc, Om0=0.3, Ode0=0.7,
+                   w0=-1.0, wz=0.1)
+```
+
+## Distance Calculations
+
+### Comoving Distance
+
+Line-of-sight comoving distance:
+
+```python
+d_c = cosmo.comoving_distance(z)
+```
+
+### Luminosity Distance
+
+Distance for calculating luminosity from observed flux:
+
+```python
+d_L = cosmo.luminosity_distance(z)
+
+# Calculate absolute magnitude from apparent magnitude
+M = m - 5*np.log10(d_L.to(u.pc).value) + 5
+```
+
+### Angular Diameter Distance
+
+Distance for calculating physical size from angular size:
+
+```python
+d_A = cosmo.angular_diameter_distance(z)
+
+# Calculate physical size from angular size
+theta = 10 * u.arcsec  # Angular size
+physical_size = d_A * theta.to(u.radian).value
+```
+
+### Comoving Transverse Distance
+
+Transverse comoving distance (equals comoving distance in flat universe):
+
+```python
+d_M = cosmo.comoving_transverse_distance(z)
+```
+
+### Distance Modulus
+
+```python
+dm = cosmo.distmod(z)
+# Relates apparent and absolute magnitudes: m - M = dm
+```
+
+## Scale Calculations
+
+### kpc per Arcminute
+
+Physical scale at a given redshift:
+
+```python
+scale = cosmo.kpc_proper_per_arcmin(z)
+# e.g., "50 kpc per arcminute at z=1"
+```
+
+### Comoving Volume
+
+Volume element for survey volume calculations:
+
+```python
+vol = cosmo.comoving_volume(z)  # Total volume to redshift z
+vol_element = cosmo.differential_comoving_volume(z)  # dV/dz
+```
+
+## Time Calculations
+
+### Age of Universe
+
+Age at a given redshift:
+
+```python
+age = cosmo.age(z)
+age_now = cosmo.age(0)  # Current age
+age_at_z1 = cosmo.age(1)  # Age at z=1
+```
+
+### Lookback Time
+
+Time since photons were emitted:
+
+```python
+t_lookback = cosmo.lookback_time(z)
+# Time between z and z=0
+```
+
+## Hubble Parameter
+
+Hubble parameter as function of redshift:
+
+```python
+H_z = cosmo.H(z)  # H(z) in km/s/Mpc
+E_z = cosmo.efunc(z)  # E(z) = H(z)/H0
+```
+
+## Density Parameters
+
+Evolution of density parameters with redshift:
+
+```python
+Om_z = cosmo.Om(z)        # Matter density at z
+Ode_z = cosmo.Ode(z)      # Dark energy density at z
+Ok_z = cosmo.Ok(z)        # Curvature density at z
+Ogamma_z = cosmo.Ogamma(z)  # Photon density at z
+Onu_z = cosmo.Onu(z)      # Neutrino density at z
+```
+
+## Critical and Characteristic Densities
+
+```python
+rho_c = cosmo.critical_density(z)  # Critical density at z
+rho_m = cosmo.critical_density(z) * cosmo.Om(z)  # Matter density
+```
+
+## Inverse Calculations
+
+Find redshift corresponding to a specific value:
+
+```python
+from astropy.cosmology import z_at_value
+
+# Find z at specific lookback time
+z = z_at_value(cosmo.lookback_time, 10*u.Gyr)
+
+# Find z at specific luminosity distance
+z = z_at_value(cosmo.luminosity_distance, 1000*u.Mpc)
+
+# Find z at specific age
+z = z_at_value(cosmo.age, 1*u.Gyr)
+```
+
+## Array Operations
+
+All methods accept array inputs:
+
+```python
+import numpy as np
+
+z_array = np.linspace(0, 5, 100)
+d_L_array = cosmo.luminosity_distance(z_array)
+H_array = cosmo.H(z_array)
+age_array = cosmo.age(z_array)
+```
+
+## Neutrino Effects
+
+Include massive neutrinos:
+
+```python
+from astropy.cosmology import FlatLambdaCDM
+
+# With massive neutrinos
+cosmo = FlatLambdaCDM(
+    H0=70 * u.km/u.s/u.Mpc,
+    Om0=0.3,
+    Tcmb0=2.725 * u.K,
+    Neff=3.04,  # Effective number of neutrino species
+    m_nu=[0., 0., 0.06] * u.eV  # Neutrino masses
+)
+```
+
+Note: Massive neutrinos reduce performance by 3-4x but provide more accurate results.
+
+## Cloning and Modifying Cosmologies
+
+Cosmology objects are immutable. Create modified copies:
+
+```python
+# Clone with different H0
+cosmo_new = cosmo.clone(H0=72 * u.km/u.s/u.Mpc)
+
+# Clone with modified name
+cosmo_named = cosmo.clone(name="My Custom Cosmology")
+```
+
+## Common Use Cases
+
+### Calculating Absolute Magnitude
+
+```python
+# From apparent magnitude and redshift
+z = 1.5
+m_app = 24.5  # Apparent magnitude
+d_L = cosmo.luminosity_distance(z)
+M_abs = m_app - cosmo.distmod(z).value
+```
+
+### Survey Volume Calculations
+
+```python
+# Volume between two redshifts
+z_min, z_max = 0.5, 1.5
+volume = cosmo.comoving_volume(z_max) - cosmo.comoving_volume(z_min)
+
+# Convert to Gpc^3
+volume_gpc3 = volume.to(u.Gpc**3)
+```
+
+### Physical Size from Angular Size
+
+```python
+theta = 1 * u.arcsec  # Angular size
+z = 2.0
+d_A = cosmo.angular_diameter_distance(z)
+size_kpc = (d_A * theta.to(u.radian)).to(u.kpc)
+```
+
+### Time Since Big Bang
+
+```python
+# Age at specific redshift
+z_formation = 6
+age_at_formation = cosmo.age(z_formation)
+time_since_formation = cosmo.age(0) - age_at_formation
+```
+
+## Comparison of Cosmologies
+
+```python
+# Compare different models
+from astropy.cosmology import Planck18, WMAP9
+
+z = 1.0
+print(f"Planck18 d_L: {Planck18.luminosity_distance(z)}")
+print(f"WMAP9 d_L: {WMAP9.luminosity_distance(z)}")
+```
+
+## Performance Considerations
+
+- Calculations are fast for most purposes
+- Massive neutrinos reduce speed significantly
+- Array operations are vectorized and efficient
+- Results valid for z < 5000-6000 (depends on model)