;+
; NAME:
;  mk_nuwgt
; PURPOSE: (one line)
;  make a list of inverse cm (and optionally, weights)
; DESCRIPTION:
;  pick nu's appropriate for the temperature
; CATEGORY:
;  Spectra
; CALLING SEQUENCE:
;  nuarr = mk_nuwgt(lnarr, nuwgt)
; INPUTS:
;  lnarr - an array of spectral line structures to be changed
; OPTIONAL INPUT PARAMETERS:
;  none
; KEYWORD INPUT PARAMETERS:
;  none
; KEYWORD OUTPUT PARAMETERS:
;  none
; OUTPUTS:
;  nu - array of wavenumbers (inverse cm)
;  nuwgt - array of wavenumber weights (inverse cm)
; COMMON BLOCKS:
;  None
; SIDE EFFECTS:
; RESTRICTIONS:
;  None
; PROCEDURE:
; MODIFICATION HISTORY:
;  Written 2001 May, by Leslie Young, SwRI
;-

function drop1, a
    return, a[1:n_elements(a)-1]
end

function drop1rev, a
    return, reverse(a[1:n_elements(a)-1])
end

function mk_nuwgt, lnarr, nuwgtarr

    ss = sort(lnarr.nu0)
    nu0arr = lnarr[ss].nu0
    dopwarr = lnarr[ss].dopw
    ss = uniq(nu0arr)
    nu0arr = nu0arr[ss]
    dopwarr = dopwarr[ss]
    
    nx = 10.
    ndopw = 1.
    s = exp(1.)
    ng = 15.
    
                                ; number of lines
    nl = n_elements(nu0arr)
    
                                ; shortward of the first line
    il = 0
    nu0b = nu0arr[il]
    dopwb = dopwarr[il]
    db = 2*(ndopw*dopwb)/nx/s
    nub = nu0b-db*s/2.
    xb = nu0b + [0.]
    for ig = 1, ng do begin
        db = db * s
        xb = [xb, nub - (findgen(nx)+0.5)*db]
        nub = nub - db * nx 
    end
    nuarr = drop1rev(xb)

    ; intermediate
    for il = 1, nl-1 do begin
        nu0a = nu0b
        dopwa = dopwb
        da = 2*(ndopw*dopwa)/nx/s
        nua = nu0a+da*s/2.
        nu0b = nu0arr[il]
        dopwb = dopwarr[il]
        db = 2*(ndopw*dopwb)/nx/s
        nub = nu0b-db*s/2.

        if nua ge nub then begin
            nuarr = [nuarr, nu0a]
        endif else begin
            xa = nu0a + [0., 0.]
            xb = nu0b + [0.]
                    
            continue = 1
;            ig = 1 
;            while continue eq 1 and ig le ng do begin
            while continue eq 1 do begin
                da = da * s
                db = db * s
                nuanext = nua + da * nx
                nubnext = nub - db * nx
                if nuanext lt nubnext then begin 
                    xa = [xa, nua + (findgen(nx)+0.5)*da]
                    xb = [xb, nub - (findgen(nx)+0.5)*db]
                endif else begin 
                    if db lt da then begin
                        na = floor((nubnext-nua)/da-0.5)
                        if na gt 0 then $
                          xa = [xa, nua + (findgen(na)+0.5)*da]
                        nb = floor((nub-(nuanext>nua))/db-0.5)
                        if nb gt 0 then $
                          xb = [xb, nub - (findgen(nb)+0.5)*db]
                    endif else begin
                        na = floor(( (nuanext<nub)-nua)/da-0.5)
                        if na gt 0 then $
                          xa = [xa, nua + (findgen(na)+0.5)*da]
                        nb = floor((nub-nuanext)/db-0.5)
                        if nb gt 0 then $
                          xb = [xb, nub - (findgen(nb)+0.5)*db]
                    endelse
                    continue = 0
                endelse
                nua = nuanext
                nub = nubnext
;                ig = ig + 1
            endwhile
            if n_elements(xb) eq 1 then begin
                if xa[1] le nuarr[n_elements(nuarr)-1] then stop
                nuarr = [nuarr, drop1(xa)]
            endif else begin
                if xa[1] le nuarr[n_elements(nuarr)-1] then stop
                if xb[n_elements(xb)-1] le xa[n_elements(xa)-1] then stop
                nuarr = [nuarr, drop1(xa), drop1rev(xb)]
            endelse
        endelse
    end
    

    ; longward of the last line
    il = nl-1
    nu0a = nu0arr[il]
    dopwa = dopwarr[il]
    da = 2*(ndopw*dopwa)/nx/s
    nua = nu0a+da*s/2.
    xa = nu0a + [0., 0.]
    for ig = 1, ng do begin
        da = da * s
        xa = [xa, nua + (findgen(nx)+0.5)*da]
        nua = nua + da * nx 
    end
    nuarr = [nuarr, drop1(xa)]

    n = n_elements(nuarr)
    nuwgtarr = 0.5*(nuarr[2:n-1]-nuarr[0:n-3])
    nuwgtarr = [nuwgtarr[0],nuwgtarr,nuwgtarr[n-3]]

    return, nuarr

end