not totally hating this

Author: icweaver

src/Spectra.jl

@@ -1,7 +1,7 @@
 module Spectra
 
 # common.jl
-export AbstractSpectrum, spectrum
+export AbstractSpectrum, SingleSpectrum, EchelleSpectrum, spectrum
 # utils.jl
 export blackbody
 # transforms/redden.jl
@@ -12,11 +12,12 @@ using Measurements: Measurements, Measurement
 using Unitful: Unitful, Quantity, @u_str, ustrip, unit, dimension
 using PhysicalConstants.CODATA2018: h, c_0, k_B
 
-# AbstractSpectrum and common functionality
+# AbstractSpectrum, Spectrum, and common functionality
 include("common.jl")
 
 # Spectrum types and basic arithmetic
-include("spectrum.jl")
+include("spectrum_single.jl")
+include("spectrum_echelle.jl")
 
 """
     spectrum(wave, flux; kwds...)
@@ -73,27 +74,27 @@ function spectrum(wave::AbstractVector{<:Real}, flux::AbstractVector{<:Real}; kw
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
-function spectrum(wave::AbstractVector{<:Quantity}, flux::AbstractVector{<:Quantity}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
-    @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
-    Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
-end
+#function spectrum(wave::AbstractVector{<:Quantity}, flux::AbstractVector{<:Quantity}; kwds...)
+#    @assert size(wave) == size(flux) "wave and flux must have equal size"
+#    @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
+#    Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
+#end
 
 function spectrum(wave::AbstractMatrix{<:Real}, flux::AbstractMatrix{<:Real}; kwds...)
     @assert size(wave) == size(flux) "wave and flux must have equal size"
-    EchelleSpectrum(wave, flux, Dict{Symbol,Any}(kwds))
-end
-
-function spectrum(wave::AbstractMatrix{<:Quantity}, flux::AbstractMatrix{<:Quantity}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
-    @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
-    EchelleSpectrum(wave, flux, Dict{Symbol,Any}(kwds))
+    Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
-# tools
-include("utils.jl")
-include("transforms/transforms.jl")
-include("plotting.jl")
-include("fitting/fitting.jl")
+#function spectrum(wave::AbstractMatrix{<:Quantity}, flux::AbstractMatrix{<:Quantity}; kwds...)
+#    @assert size(wave) == size(flux) "wave and flux must have equal size"
+#    @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
+#    EchelleSpectrum(wave, flux, Dict{Symbol,Any}(kwds))
+#end
+#
+## tools
+#include("utils.jl")
+#include("transforms/transforms.jl")
+#include("plotting.jl")
+#include("fitting/fitting.jl")
 
 end # module

src/common.jl

@@ -9,6 +9,19 @@ An abstract holder for astronomical spectra. All types inheriting from this must
 """
 abstract type AbstractSpectrum{W,F} end
 
+"""
+    Spectrum <: AbstractSpectrum
+
+A spectrum or spectra stored as arrays of real numbers. The wavelengths are assumed to be in angstrom.
+"""
+mutable struct Spectrum{W<:Number, F<:Number, N} <: AbstractSpectrum{W, F}
+    wave::AbstractArray{W, N}
+    flux::AbstractArray{F, N}
+    meta::Dict{Symbol,Any}
+end
+
+Spectrum(wave, flux, meta::Dict{Symbol, Any}) = Spectrum(collect(wave), collect(flux), meta)
+
 function Base.getproperty(spec::AbstractSpectrum, nm::Symbol)
     if nm in keys(getfield(spec, :meta))
         return getfield(spec, :meta)[nm]
@@ -19,7 +32,7 @@ end
 
 function Base.propertynames(spec::AbstractSpectrum)
     natural = (:wave, :flux, :meta)
-    meta = keys(spec.meta)
+    meta = keys(meta(spec))
     return (natural..., meta...)
 end
 
@@ -37,32 +50,39 @@ Return the flux of the spectrum.
 """
 flux(spec::AbstractSpectrum) = spec.flux
 
+"""
+    meta(::AbstractSpectrum)
+
+Return the meta of the spectrum.
+"""
+meta(spec::AbstractSpectrum) = spec.meta
+
 # Collection
-Base.eltype(spec::AbstractSpectrum) = eltype(spec.flux)
-Base.size(spec::AbstractSpectrum) = size(spec.flux)
-Base.size(spec::AbstractSpectrum, i) = size(spec.flux, i)
-Base.length(spec::AbstractSpectrum) = length(spec.flux)
-Base.maximum(spec::AbstractSpectrum) = maximum(spec.flux)
-Base.minimum(spec::AbstractSpectrum) = minimum(spec.flux)
-Base.argmax(spec::AbstractSpectrum) = argmax(spec.flux)
-Base.argmin(spec::AbstractSpectrum) = argmin(spec.flux)
-Base.findmax(spec::AbstractSpectrum) = findmax(spec.flux)
-Base.findmin(spec::AbstractSpectrum) = findmin(spec.flux)
+Base.eltype(spec::AbstractSpectrum) = eltype(flux(spec))
+Base.size(spec::AbstractSpectrum) = size(flux(spec))
+Base.size(spec::AbstractSpectrum, i) = size(flux(spec), i)
+Base.length(spec::AbstractSpectrum) = length(flux(spec))
+Base.maximum(spec::AbstractSpectrum) = maximum(flux(spec))
+Base.minimum(spec::AbstractSpectrum) = minimum(flux(spec))
+Base.argmax(spec::AbstractSpectrum) = argmax(flux(spec))
+Base.argmin(spec::AbstractSpectrum) = argmin(flux(spec))
+Base.findmax(spec::AbstractSpectrum) = findmax(flux(spec))
+Base.findmin(spec::AbstractSpectrum) = findmin(flux(spec))
 
 # Arithmetic
-Base.:+(s::T, A) where {T <: AbstractSpectrum} = T(s.wave, s.flux .+ A, s.meta)
-Base.:*(s::T, A::Union{Real, AbstractVector}) where {T <: AbstractSpectrum} = T(s.wave, s.flux .* A, s.meta)
-Base.:/(s::T, A) where {T <: AbstractSpectrum} = T(s.wave, s.flux ./ A, s.meta)
-Base.:-(s::T) where {T <: AbstractSpectrum} = T(s.wave, -s.flux, s.meta)
+Base.:+(s::T, A) where {T <: AbstractSpectrum} = T(wave(s), flux(s) .+ A, meta(s))
+Base.:*(s::T, A::Union{Real, AbstractVector}) where {T <: AbstractSpectrum} = T(wave(s), flux(s) .* A, meta(s))
+Base.:/(s::T, A) where {T <: AbstractSpectrum} = T(wave(s), flux(s) ./ A, meta(s))
+Base.:-(s::T) where {T <: AbstractSpectrum} = T(wave(s), -flux(s), meta(s))
 Base.:-(s::AbstractSpectrum, A) = s + -A
 Base.:-(A, s::AbstractSpectrum) = s - A
 Base.:-(s::AbstractSpectrum, o::AbstractSpectrum) = s - o # Satisfy Aqua
 
 # Multi-Spectrum
-Base.:+(s::T, o::T) where {T <: AbstractSpectrum} = T(s.wave, s.flux .+ o.flux, s.meta)
-Base.:*(s::T, o::T) where {T <: AbstractSpectrum} = T(s.wave, s.flux .* o.flux, s.meta)
-Base.:/(s::T, o::T) where {T <: AbstractSpectrum} = T(s.wave, s.flux ./ o.flux * unit(s)[2], s.meta)
-Base.:-(s::T, o::T) where {T <: AbstractSpectrum} = T(s.wave, s.flux .- o.flux, s.meta)
+Base.:+(s::T, o::T) where {T <: AbstractSpectrum} = T(wave(s), flux(s) .+ flux(s), meta(s))
+Base.:*(s::T, o::T) where {T <: AbstractSpectrum} = T(wave(s), flux(s) .* flux(s), meta(s))
+Base.:/(s::T, o::T) where {T <: AbstractSpectrum} = T(wave(s), flux(s) ./ flux(s) * unit(s)[2], meta(s))
+Base.:-(s::T, o::T) where {T <: AbstractSpectrum} = T(wave(s), flux(s) .- flux(s), meta(s))
 
 """
     Unitful.ustrip(::AbstractSpectrum)
@@ -84,7 +104,7 @@ julia> ustrip(spec)
 Spectrum(Float64, Float64)
 ```
 """
-Unitful.ustrip(spec::AbstractSpectrum) = spectrum(ustrip.(spec.wave), ustrip.(spec.flux); spec.meta...)
+Unitful.ustrip(spec::AbstractSpectrum) = spectrum(ustrip.(wave(spec)), ustrip.(flux(spec)); meta(spec)...)
 
 """
     Unitful.unit(::AbstractSpectrum)
@@ -105,4 +125,4 @@ julia> w_unit, f_unit = unit(spec)
 (Å, W Å^-1 m^-2)
 ```
 """
-Unitful.unit(spec::AbstractSpectrum) = unit(eltype(spec.wave)), unit(eltype(spec.flux))
+Unitful.unit(spec::AbstractSpectrum) = unit(eltype(wave(spec))), unit(eltype(flux(spec)))

src/spectrum.jl

@@ -0,0 +1,24 @@
+const EchelleSpectrum = Spectrum{W, F, 2} where {W, F}
+
+function Base.getindex(spec::EchelleSpectrum, i::Int)
+    w = wave(spec)[i, :]
+    f = flux(spec)[i, :]
+    m = merge(Dict(:Order => i), meta(spec))
+    return Spectrum(w, f, m)
+end
+
+function Base.getindex(spec::EchelleSpectrum, I::AbstractVector)
+    w = wave(spec)[I, :]
+    f = flux(spec)[I, :]
+    m = merge(Dict(:Orders => (first(I), last(I))), meta(spec))
+    return Spectrum(w, f, m)
+end
+
+Base.firstindex(spec::EchelleSpectrum) = firstindex(flux(spec), 1)
+Base.lastindex(spec::EchelleSpectrum) = lastindex(flux(spec), 1)
+
+function Base.show(io::IO, spec::EchelleSpectrum)
+    println(io, "EchelleSpectrum($(eltype(wave(spec))), $(eltype(flux(spec))))")
+    println(io, "  # orders: $(size(spec, 1))")
+    println(io, "meta: ", meta(spec))
+end

src/spectrum_echelle.jl

@@ -0,0 +1,22 @@
+const SingleSpectrum = Spectrum{W, F, 1} where {W, F}
+
+#Base.size(spec::SingleSpectrum) = (length(wave(spec)), )
+#Base.IndexStyle(::Type{<:SingleSpectrum}) = IndexLinear()
+
+function Base.getindex(spec::SingleSpectrum, i::Int)
+    return Spectrum([wave(spec)[i]], [flux(spec)[i]], meta(spec))
+end
+
+function Base.getindex(spec::SingleSpectrum, inds)
+    return Spectrum(wave(spec)[inds], flux(spec)[inds], meta(spec))
+end
+
+Base.firstindex(spec::SingleSpectrum) = firstindex(wave(spec))
+Base.lastindex(spec::SingleSpectrum) = lastindex(wave(spec))
+
+function Base.show(io::IO, spec::SingleSpectrum)
+    println(io, "SingleSpectrum($(eltype(wave(spec))), $(eltype(flux(spec))))")
+    println(io, "wave: ", wave(spec))
+    println(io, "flux: ", flux(spec))
+    println(io, "meta: ", meta(spec))
+end