more faffing

Author: chris-simpson

gempy/library/wavecal.py

@@ -803,28 +803,38 @@ def find_solution(init_models, config, peaks=None, peak_weights=None,
                                             min_lines_per_fit=min_lines_per_fit,
                                             k=k, bounds_setter=bounds_setter)
 
+            wavemin, wavemax = sorted(model(model.domain))
+            nlines_expected = sum(wavemin <= wline <= wavemax for wline in arc_lines)
+
             # We perform a regular least-squares fit to all the matches
             # we've made. This allows a high polynomial order to be
             # used without the risk of it going off the rails
             matched = np.where(matches > -1)[0]
             fit_it = fitting.LinearLSQFitter()
-            if len(matched) > 1:  # need at least 2 lines, right?
-                m_init = models.Chebyshev1D(degree=min(config["order"], len(matched)-1),
-                                            domain=domain)
+
+            # We allow this continue if we only matched 1 line but only 1 line is
+            # expected
+            if len(matched) > 1: # or (len(matched) * nlines_expected == 1 and len(peaks) <= 2):
+                m_init = models.Chebyshev1D(
+                    degree=min(config["order"], (len(matched) + 1) // 2),
+                    domain=domain)
                 for p, v in zip(model.param_names, model.parameters):
                     if p in m_init.param_names:
                         setattr(m_init, p, v)
                 model_bounds = bounds_setter(m_init)
+                if len(matched) == 1:
+                    m_init.c1.fixed = True
                 #for i in range(len(matched), m_init.degree + 1):
                 #    m_init.fixed[f"c{i}"] = True
                 matched_peaks = peaks[matched]
                 matched_arc_lines = arc_lines[matches[matched]]
                 m_final = fit_it(m_init, matched_peaks, matched_arc_lines)
+                print(repr(m_final))
                 #for p, l in zip(matched_peaks, matched_arc_lines):
                 #    print(f"{p:.2f} => {l:.2f}")
 
                 # We're close to the correct solution, perform a KDFit
-                m_init = models.Chebyshev1D(degree=config["order"], domain=domain)
+                m_init = models.Chebyshev1D(m_final.degree, domain=domain)
                 for p, v in zip(m_final.param_names, m_final.parameters):
                     setattr(m_init, p, v)
                 dw = abs(np.diff(m_final(m_final.domain))[0] / np.diff(m_final.domain)[0])
@@ -865,12 +875,12 @@ def find_solution(init_models, config, peaks=None, peak_weights=None,
                                       np.array([-0.5, 0.5]) * np.diff(bounds)[0])
                         assert new_bounds[0] <= v <= new_bounds[1]
                 except AssertionError:
-                    # for p, v in zip(fit1d.model.param_names, fit1d.model.parameters):
-                    #     bounds = model_bounds.get(p, (-np.inf, np.inf))
-                    #     new_bounds = (np.asarray(bounds) +
-                    #                   np.array([-0.5, 0.5]) * np.diff(bounds)[0])
-                    #     print(p, v, new_bounds)
-                    # print("*** REJECTED ***")
+                    for p, v in zip(fit1d.model.param_names, fit1d.model.parameters):
+                        bounds = model_bounds.get(p, (-np.inf, np.inf))
+                        new_bounds = (np.asarray(bounds) +
+                                      np.array([-0.5, 0.5]) * np.diff(bounds)[0])
+                        print(p, v, new_bounds)
+                    print("*** REJECTED ***")
                     continue
 
                 # Wavelength solution models need to be monotonic. Make that check.
@@ -1013,7 +1023,7 @@ def perform_piecewise_fit(model, peaks, arc_lines, pixel_start, kdsigma,
                     # automatically removes old (bad) match
                     matches[i] = m
                     found_new_matches = True
-                    #print(f"Pixel {p} => was {m_init(p):.4f} now {m_this(p):.4f} {arc_lines[m]}")
+                    print(f"Pixel {p} => was {m_init(p):.4f} now {m_this(p):.4f} {arc_lines[m]}")
         try:
             p_lo = peaks[matches > -1].min()
         except ValueError: