Updated juobs_uwreal_const to use Ref{uwreal}

constants/juobs_uwreal_const.jl

 import ADerrors
-const b_values = [3.40, 3.46, 3.55, 3.70, 3.85]
+const beta_to_idx = Dict{Float64,Int64}(3.40 =>1, 3.46=>2, 3.55=>3, 3.70=>4, 3.85=>5)
 
-const M = let C = zeros(8, 8)
-#PDG
+let 
+  C = zeros(8, 8)
   M_values = [1869.65, 2010.26, 1968.34, 2112.2, 2980.3, 3096.916, 5279.65, 5366.3] #MD, MD*, MDs, MDs*, \eta_c, J/\psi , MB, MBs(MeV)
   M_error = [0.05, 0.05, 0.07, 0.4, 1.2, 0.011, 0.12, 0.6]
+  M = Ref{Vector{uwreal}}()
   for i = 1:8
     C[i, i] = M_error[i] ^ 2
   end
-  ADerrors.cobs(M_values, C, "charmed meson masses")
+  global function M()
+    if !isassigned(M) 
+      M.x = ADerrors.cobs(M_values, C, "charmed meson masses")
+    end
+    return M.x;
+  end
 end
 
-#1802.05243 taking into account correlations in zm_tm
-let C = [[0.375369e-6, 0.429197e-6, -0.186896e-5] [0.429197e-6, 0.268393e-4, 0.686776e-4] [-0.186896e-5, 0.686776e-4, 0.212386e-3]]
-
-  z =  ADerrors.cobs([0.348629, 0.020921, 0.070613], C, "z")
+let 
+  #1802.05243 taking into account correlations in zm_tm
+  C = [0.375369e-6, 0.429197e-6, -0.186896e-5; 0.429197e-6, 0.268393e-4, 0.686776e-4; -0.186896e-5, 0.686776e-4, 0.212386e-3]
+  z = Ref{Vector{uwreal}}();
+  global function ZP(beta::Float64)
+    if !isassigned(z)
+      z.x =  ADerrors.cobs([0.348629, 0.020921, 0.070613], C, "z")
+    end
+    return z.x[1] + z.x[2] *(beta-3.79) + z.x[3]*(beta-3.79)^2
+  end
+  CC = [0.164635e-4, 0.215658e-4, -0.754203e-4; 0.215658e-4, 0.121072e-2, 0.308890e-2; -0.754203e-4, 0.308890e-2, 0.953843e-2]
+  zm = Ref{Vector{uwreal}}()
+  Mrat_ = Ref{uwreal}()
 
-  global ZP(b) = z[1] + z[2] * (b - 3.79) + z[3] * (b - 3.79)^2
-  CC = [[0.164635e-4, 0.215658e-4, -0.754203e-4] [0.215658e-4, 0.121072e-2, 0.308890e-2] [-0.754203e-4, 0.308890e-2, 0.953843e-2]]
-  zz = ADerrors.cobs([2.270073, 0.121644, -0.464575], CC, "zm")
+  global function Mrat_()
+    if !isassigned(Mrat_)
+      Mrat_.x =ADerrors.uwreal([.9148, 0.0088], "M/mhad")
+    end
+    return Mrat_.x
+  end
 
-  # same for zm wilson
-  Mrat = ADerrors.uwreal([.9148, 0.0088], "M/mhad")
+  global function z_covar(beta::Float64)
+    if !isassigned(zz)
+      zm.x = ADerrors.cobs([2.270073, 0.121644, -0.464575], CC, "zm")
+    end
+    return Mrat().mean*(zz.x[1] + zz.x[2]*(beta-3.79)+zz.x[3]*(b-3.79)^2)
+  end
   
-  global z_covar(b) = Mrat.mean*(zz[1] + zz[2]*(b-3.79) + zz[3]*(b-3.79)^2)
-  global zm_tm_covar(b) = Mrat / ZP(b)
+  global  zm_tm_covar(beta::Float64) = Mrat() / ZP(beta)
 end
 
 ## taking into account correlations in r_m
@@ -40,8 +61,13 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = ZM_error[i] ^ 2
   end
-  ZM = ADerrors.cobs(ZM_data, C, "ZM values")
-  global zm(beta::Float64)         = ZM[b_values .== beta][1]
+  ZM = Ref{Vector{uwreal}}()
+  global function zm(beta::Float64)
+    if !isassigned(ZM)
+      ZM.x =  ADerrors.cobs(ZM_data, C, "ZM values")
+    end
+    return ZM[beta_to_idx[beta]]
+  end
 end
 
 let C = zeros(5, 5)
@@ -51,8 +77,14 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = ZM_tm_error[i] ^ 2
   end
-  ZM_tm = ADerrors.cobs(ZM_tm_data, C, "ZM_tm values")
-  global zm_tm(beta::Float64)      = ZM_tm[b_values .== beta][1]
+  ZM_tm = Ref{Vector{uwreal}}()
+  
+  global function zm_tm(beta::Float64)
+    if !isassigned(ZM_tm)
+      ZM_tm.x = ADerrors.cobs(ZM_tm_data, C, "ZM_tm values")
+    end
+    return ZM_tm.x[beta_to_idx[beta]]
+  end
 end
 
 let C = zeros(5, 5)
@@ -60,20 +92,32 @@ let C = zeros(5, 5)
   t0_data = [2.846, 3.634, 5.140, 8.564, 14.064]
   t0_error = [8, 13, 21, 24, 63] .* 1e-3
 
-
   for i in 1:5
     C[i, i] = t0_error[i] ^ 2
   end
   
-  t0_ = ADerrors.cobs(t0_data, C, "t0")
-  global t0(beta::Float64)         = t0_[b_values .== beta][1]
+  t0_ = Ref{Vector{uwreal}}()
+  global function t0(beta::Float64)
+    if !isassigned(beta)
+      t0_.x = ADerrors.cobs(t0_data, C, "t0")
+    end
+    return t0_.x[beta_to_idx[beta]];
+  end
+
+  t0_ph_ = Ref{uwreal}()
+  global function t0_ph()
+    if !isassigned(t0_ph)
+      t0_ph_.x = ADerrors.uwreal([0.4118,0.25e-4],"sqrt(8 t0) (fm)") 
+    end
+    return t0_ph_.x
+  end
 
-  # from AS analysis
-  t0_ph =ADerrors.uwreal([0.4118,0.25e-4],"sqrt(8 t0) (fm)") 
-  a_ = [t0_ph] ./ sqrt.(8 .* t0_)
-  global a(beta::Float64)          = a_[b_values .== beta][1]
+  global function a(beta::Float64)
+    return t0_ph() / sqrt(8*t0_.x[beta_to_idx[beta]]);
+  end
 end
 
+
 let C = zeros(5, 5)
   #1808.09236
   ZA_data = [0.75642, 0.76169, 0.76979, 0.78378, 0.79667]
@@ -82,9 +126,14 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = ZA_err[i] ^ 2
   end
+  Za = Ref{Vector{uwreal}}()
 
-  Za = ADerrors.cobs(ZA_data, C, "ZA")
-  global za(beta::Float64)         = Za[b_values .== beta][1]
+  global function za(beta::Float64)
+    if !isassigned(Za)
+      Za.x = ADerrors.cobs(ZA_data, C, "ZA")
+    end
+    return za.x[beta_to_idx[beta]];
+  end
 end
 
 let C = zeros(5, 5)
@@ -95,8 +144,15 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = ZV_err[i] ^ 2 
   end
-  Zv = ADerrors.cobs(ZV_data, C, "ZV")
-  global zv(beta::Float64) = Zv[b_values .== beta][1]
+  Zv = Ref{Vector{uwreal}}()
+
+  global function zv(beta::Float64)
+    if !isassigned(Zv)
+      Zv.x = ADerrors.cobs(ZV_data, C, "ZV")
+    end
+    return zv.x[beta_to_idx[beta]];
+  end
+
 end
 
 let C = zeros(5, 5)
@@ -108,8 +164,13 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = ZS_over_ZP_err[i] ^ 2
   end
-  ZS_over_ZP = ADerrors.cobs(ZS_over_ZP_data, C, "ZS/ZP")
-  global zs_over_zp(beta::Float64) = ZS_over_ZP[b_values .== beta][1]
+  ZS_over_ZP = Ref{Vector{uwreal}}()
+  global function zs_over_zp(beta::Float64)
+    if !isassigned(ZS_over_ZP_data)
+      ZS_over_ZP.x = ADerrors.cobs(ZS_over_ZP_data, C, "ZS/ZP")
+    end
+    return ZS_over_ZP.x[beta_to_idx[beta]];
+  end 
 end
 
 let C = zeros(5, 5)
@@ -120,10 +181,16 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i, i] = RM_err[i] ^2 
   end
-  RM = ADerrors.cobs(RM_data, C, "rm")
-  global rm(beta::Float64)         = RM[b_values .== beta][1]
+  RM  = Ref{Vector{uwreal}}()
+  global function rm(beta::Float64)
+    if !isassigned(rm)
+      RM.x = ADerrors.cobs(RM_data, C, "rm")
+    end
+    return rm.x[beta_to_idx[beta]];
+  end  
 end
 
+
 let C = zeros(5, 5)
   #1906.03445 LCP1 for heavy quarks
   BA_MINUS_BP_data = [-0.324, -0.265, -0.196, -0.119, -0.073]
@@ -132,9 +199,13 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i,i]  = BA_MINUS_BP_err[i] ^2
   end
-
-  BA_BP = ADerrors.cobs(BA_MINUS_BP_data, C, "ba-bp")
-  global ba_bp(beta::Float64)      = BA_BP[b_values .== beta][1]
+  BA_BP = Ref{Vector{uwreal}}()
+  global function ba_bp(beta::Float64)
+    if !isassigned(BA_BP)
+      BA_BP.x =  ADerrors.cobs(BA_MINUS_BP_data, C, "ba-bp")
+    end
+    return  BA_BP.x[beta_to_idx[beta]];
+  end
 end
 
 let C = zeros(5, 5)
@@ -144,7 +215,11 @@ let C = zeros(5, 5)
   for i in 1:5
     C[i,i]  = ZERR[i] ^2
   end
-  ZZ = ADerrors.cobs(ZDATA, C, "Z")
-  global Z(beta::Float64)          = ZZ[b_values .== beta][1]
+  ZZ = Ref{Vector{uwreal}}();
+  global function Z(beta::Float64)
+    if !isassinged(ZZ)
+      ZZ.x =ADerrors.cobs(ZDATA, C, "Z")
+    end
+    return ZZ[beta_to_idx[beta]];
+  end
 end
-