Removed Update @enumclass. TMIN and TMAX now are merged into ALL. updated...

Removed Update @enumclass. TMIN and TMAX now are merged into ALL. updated fit_scan to reflect the changes

src/fit_scan.jl

 using EnumClasses, Printf
 
 abstract type AbstractUpdate end
-struct TMIN <:AbstractUpdate end
-struct TMAX <:AbstractUpdate end
+struct ALL <:AbstractUpdate end
 struct TMAX_SPAN <:AbstractUpdate end
 struct TMIN_SPAN <:AbstractUpdate end
-
-@enumclass Update tmin tmax tmax_span tmin_span
+struct TMINMAX_SPAN <:AbstractUpdate end
 
 mutable struct Ranges{T<:AbstractUpdate}
     tmin
@@ -14,19 +12,11 @@ mutable struct Ranges{T<:AbstractUpdate}
     is
     ie
     step
-    function Ranges(tmin,tmax,step,update::Update.Type)
-        update == Update.tmin && return new{TMIN}(tmin,tmax,tmin,tmax,step)
-        update == Update.tmax && return new{TMAX}(tmin,tmax,tmin,tmax,step)
-        if update == Update.tmax_span
-            length(tmax) >1 || error("Expected more than one tmax")
-            return new{TMAX_SPAN}(tmin,tmax,tmin,tmax[1],step)
-        end
-        if update == Update.tmin_span
-            length(tmin)>1 || error("Expected more than one tmin")
-            return new{TMIN_SPAN}(tmin,tmax,tmin[1],tmax,step)
-        end
-    end
-    Ranges(tmin,tmax,update::Update.Type) =  Ranges(tmin,tmax,1,update)
+    Ranges(tmin, tmax, step=1) = Ranges(tmin,tmax,step,eltype(tmin),eltype(tmax))
+    Ranges(tmin::T,tmax::U,step,::Type{T},::Type{U}) where {T<:Number,U<:Number} = new{ALL}(tmin,tmax,tmin,tmax,step)
+    Ranges(tmin::T,tmax::U,step,::Type{S},::Type{V}) where {T,U,S<:Number,V<:Number} = new{TMINMAX_SPAN}(tmin,tmax,tmin[1],tmax[1],step)
+    Ranges(tmin::T,tmax::U,step,::Type{T},::Type{V}) where {T<:Number,U,V<:Number}  = new{TMAX_SPAN}(tmin,tmax,tmin,tmax[1],step)
+    Ranges(tmin::T,tmax::U,step,::Type{V},::Type{U}) where {T, U<:Number,V<:Number} = new{TMIN_SPAN}(tmin,tmax,tmin[1],tmax,step)
 end
 
 function Base.iterate(r::Ranges{T}) where T<:AbstractUpdate
@@ -35,8 +25,8 @@ function Base.iterate(r::Ranges{T}) where T<:AbstractUpdate
     return range(r.is, r.ie, step=r.step), 1
 end
 
-function Base.iterate(r::Ranges{TMIN},state)
-    if r.ie-r.is == 1
+function Base.iterate(r::Ranges{ALL},state)
+    if r.ie-r.is <= 1
         r.ie -=1
         r.ie == r.tmin && return nothing
         r.is = r.tmin
@@ -46,19 +36,8 @@ function Base.iterate(r::Ranges{TMIN},state)
     return range(r.is,r.ie,step=r.step), state+1
 end
 
-function Base.iterate(r::Ranges{TMAX},state)
-    if r.ie-r.is == 1
-        r.is +=1
-        r.is == r.tmax && return nothing
-        r.ie = r.tmax
-        return range(r.is,r.ie,step = r.step), state+1
-    end
-    r.ie -=1
-    return range(r.is,r.ie,step=r.step), state+1
-end
-
 function Base.iterate(r::Ranges{TMAX_SPAN},state)
-    if r.ie-r.is ==1
+    if r.ie-r.is <=1
         i = findlast(r.ie.== r.tmax)
         i == lastindex(r.tmax) && return nothing
         r.is = r.tmin
@@ -70,7 +49,7 @@ function Base.iterate(r::Ranges{TMAX_SPAN},state)
 end
 
 function Base.iterate(r::Ranges{TMIN_SPAN},state)
-    if r.ie-r.is ==1
+    if r.ie-r.is <=1
         i = findlast(r.is.== r.tmin)
         i == lastindex(r.tmin) && return nothing
         r.is = r.tmin[i+1]
@@ -81,23 +60,30 @@ function Base.iterate(r::Ranges{TMIN_SPAN},state)
     return range(r.is,r.ie,step=r.step),state+1
 end
 
+function Base.iterate(r::Ranges{TMINMAX_SPAN},state)
+    if r.is == r.tmin[end]
+        r.ie == r.tmax[end] && return nothing
+        i= findlast(r.ie==t for t in r.tmax)
+        r.ie=r.tmax[i+1]
+        r.is=r.tmin[1]
+    else
+        i= findlast(r.is==t for t in r.tmin)
+        r.is = r.tmin[i+1]
+    end
+    return range(r.is,r.ie,step=r.step), state
+end
 
 Base.IteratorSize(::Ranges{T}) where T <:AbstractUpdate = Base.SizeUnknown()
-Base.IteratorSize(::Ranges{TMIN})  = Base.HasLength()
-Base.IteratorSize(::Ranges{TMAX})  = Base.HasLength()
-Base.IteratorSize(::Ranges{TMAX_SPAN}) = Base.HasLength()
 
-function Base.length(r::Ranges{T}) where T<: Union{TMIN,TMAX}
-    L = r.tmax-r.tmin+1
-    return div(L*(L-1),2)
-end
 
-Base.length(r::Ranges{TMAX_SPAN}) =  sum(t-r.tmin for t in r.tmax)
-Base.length(r::Ranges{TMIN_SPAN}) =  sum(r.tmax-t for t in r.tmin)
+@doc raw"""
+    fit_scan(model,xdata,ydata,npar;
+             tmin=1, tmax=lastindex(xdata), kwargs...)
 
+It exectutes all the fit compatible with `tmin`, `tmax`. Return a  `Vector{FitRes}
+"""
 function fit_scan(model,xdata,ydata,npar;
                   tmin = 1, tmax = lastindex(xdata),
-                  update = Update.tmin,
                   W = Float64[],
                   logfile = FitRoutines.NoPrint(),
                   wpm   = Dict{Int64,Vector{Float64}}(),
@@ -110,15 +96,21 @@ function fit_scan(model,xdata,ydata,npar;
     Printf.@printf logfile "Scanning update %s\n" string(update)
 
     vdata = Vector{NamedTuple}()  ## vector of fit results
-    ranges = Ranges(tmin,tmax,update)
+    ranges = Ranges(tmin,tmax)
     fits =Vector{Union{FitRes,Missing}}(missing, length(ranges))
     for (idx,r) in enumerate(ranges)
         length(r)<=npar && continue;
 
         println(logfile, "="^80, "\n")
         Printf.@printf logfile "Fit range  [%.5e, %.5e]\n" xdata[r[1]] xdata[r[end]]
-        fit = fit_routine(model,xdata[r],ydata[r],npar, W=W,C=C,
+        fit = try
+            fit_routine(model,xdata[r],ydata[r],npar, W=W,C=C,
                         guess=guess,logfile=logfile, corr=corr)
+        catch e
+            Printf.@printf logfile "Error during fit routine: %s\n" e.msg
+            @error "Error in fit range [%.5e,%.5e]\n" xdata[r[1]] xdata[r[end]]
+            continue;
+        end
         fits[idx] = FitRes(;fit...,range = (xdata[r[1]],xdata[r[end]]))
     end
     flush(logfile)