def obtain_t(x, y): """ Compute the Student's t value between two datasets :param x: :param y: :return: (t, df) t = Student's t value df = degrees of freedom """ nx = length(x) ny = length(y) if nx == 0 or ny == 0: raise ValueError('obtain_t: datasets cannot have zero elements') xbar = np.mean(x) ybar = np.mean(y) numerator = np.abs(xbar - ybar) sx = ((np.sum(x**2) / nx) - (xbar**2)) / (nx - 1.0) sy = ((np.sum(y**2) / ny) - (ybar**2)) / (ny - 1.0) if sx < 0: sx = 0 if sy < 0: sy = 0 denominator = np.sqrt(sx + sy) if denominator == 0.0: t = 0 else: t = numerator / denominator df_numerator = (sx + sy)**2 df_denominator = ((sx**2) / (nx - 1.0)) + ((sy**2) / (ny - 1.0)) if df_denominator == 0.0: df = 0.0 else: df = numerator / denominator return t, df
def dp_model_recomp_heating_cooling_trim(fs, q, k, t, th, dT_known, r0, get_gamma4=False): """ Run the DP model, but take into consideration a trimmed curve that can be: (1) heating and cooling (2) cooling only DO NOT use this function for heating only. Use the dp_model_recomp_heating() function below if only the heating curve is passed in. :param fs: as the sampling rate :param q: as the heat input into the soil :param k: as the thermal conductivity :param t: as the time vector :param th: as the threshold time :param dT_known: as the known change in temperature :param r0: as the initial radius :param get_gamma4: True to return gamma4 as well :return: r_t or (r_t, gamma4) """ n = length(t) if length(dT_known) != n: raise ValueError( 'dp_model_recomp_heating_cooling: the length of t must be the same as dT' ) term = -(4 * pi * k) / q dt = 1 / fs if t[0] >= th: # cooling only tvec_heat = [] tvec_cool = t dT_known_heat = [] dT_known_cool = dT_known gamma4_heat = [] else: # heating and cooling nheat = int(np.ceil(fs * (th - t[0]))) tvec_heat = t[:nheat] tvec_cool = t[nheat:] dT_known_heat = dT_known[:nheat] dT_known_cool = dT_known[nheat:] gamma2_heat = term * dT_known_heat gamma3_heat = ei_inv_neg_array(gamma2_heat) * tvec_heat gamma4_heat = -gamma3_heat # COOLING dT_cool_strip = -term * dT_known_cool gamma4_cool = ei_inv_cooling(dT_cool_strip, th, tvec_cool) gamma4 = np.abs(np.concatenate((gamma4_heat, gamma4_cool))) r_t = dp_model_recomp_shared(k, t, q, gamma4, dt, r0) if get_gamma4: return r_t, gamma4 return r_t
def cut_to_zero(x, t): """ Helper function to cut a sequence to zero :param x: as the sequence :param t: as the associated timestep :return: """ n = length(x) if n != length(t): raise ValueError('cut_to_zero: x and t must have the same length') elem = x >= 0 xout = x[elem] tout = t[elem] return xout, tout
def dp_model_recomp_heating_cooling(fs, q, k, t, th, dT_known, r0, get_gamma4=False): """ DP inverse model for heating and cooling. USE THIS FUNCTION ONLY FOR THE FULL CURVE THAT IS NOT TRIMMED. NOTE that the dT_known has to be sufficiently smooth for the derivative operation to not be contaminated by noise :param fs: as the sampling rate :param q: as the heat input into the soil :param k: as the thermal conductivity :param t: as the time vector :param th: as the time of heating :param dT_known: as the change in temperature :param r0: as an assumed change in temperature :param get_gamma4: True to obtain the gamma4 :return: """ n = length(t) if length(dT_known) != n: raise ValueError( 'dp_model_recomp_heating_cooling: the length of t must be the same as dT' ) term = -(4 * pi * k) / q dt = 1 / fs nn = int(np.ceil(fs * th)) tvec_heat = t[:nn] tvec_cool = t[nn:] dT_known_heat = dT_known[:nn] dT_known_cool = dT_known[nn:] # HEATING gamma2_heat = term * dT_known_heat gamma3_heat = ei_inv_neg_array(gamma2_heat) * tvec_heat gamma4_heat = -gamma3_heat # COOLING dT_cool_strip = -term * dT_known_cool gamma4_cool = ei_inv_cooling(dT_cool_strip, th, tvec_cool) gamma4 = np.concatenate((gamma4_heat, gamma4_cool)) r_t = dp_model_recomp_shared(k, t, q, gamma4, dt, r0) if get_gamma4: return r_t, gamma4 return r_t
def safe_div(x, y, replace=None): if replace is None: replace = float('NaN') n = length(x) out = np.zeros(n) if n != length(y): raise ValueError('save_div: cannot divide') for k in range(n): xx = x[k] yy = y[k] if yy == 0: out[k] = replace else: out[k] = xx / yy return out
def run_plot_output(alpha, fs, k, q, r0, run_full, t_heat, t, r): """ Function required to generate the plot outputs for the demonstration :param alpha: :param fs: :param k: :param q: :param r0: :param run_full: :param t_heat: :param t: :param r: :return: """ # Note that Ei(x=0) is not defined, so the time vector must be trimmed # The forward model is not defined at t = 0. tt = np.copy(t) tt = tt[1:] dt = 1 / fs n = length(tt) if run_full: # run the complete algorithm for heating and cooling dT_dual = compute_delta_T_dual_heating_cooling(q, k, alpha, r, tt, t_heat, split=False) dT_dual_fixed = compute_delta_T_dual_heating_cooling(q, k, alpha, r0, tt, t_heat, split=False) r_t_det = dp_model_recomp_heating_cooling(fs, q, k, tt, t_heat, dT_dual, r0, get_gamma4=False) else: # only run the algorithm for heating dT_dual = compute_delta_T_dual_infinite_line_heating(q, k, alpha, r, tt) dT_dual_fixed = compute_delta_T_dual_infinite_line_heating(q, k, alpha, r0, tt) r_t_det = dp_model_recomp_heating(fs, q, k, tt, dT_dual, r0, get_gamma4=False) r_t_det_diff = r - r_t_det r_mm = r / 1.0e-3 r_det_mm = r_t_det / 1.0e-3 return dT_dual, dT_dual_fixed, r_det_mm, r_mm, r_t_det_diff, tt
def inverse_warmup_curve_dp(self, k, dT_dual, q, t, r0, typ, lowpass=False, epsilon=0.0): """ Obtain the inverse of the curve data Note that the inverse solution cannot be used for t = 0 since the solution is undefined at this point The first element is therefore sampled at timestep t = delta_t :param k: as the thermal conductivity determined from the SP model (or assumed) :param dT_dual: dual-probe warmup curve at distance of r(t) (Celcius or K) :param q: inferred heat input (W/m) :param t: vector of regular timestamps (t > 0) for DP :param r0: initial single-probe radius :param typ: 'iterative' to use an iterative solution 'matrix' to use a matrix solution 'regularized' to use Tikhonov regularization :param epsilon: regularization parameter to use in the Tikhanov solution :return: (alpha, r_t) alpha = thermal diffusivity (m^2 / s) r_t = time series showing change in r with respect to time t """ n = length(t) dt = t[1] - t[0] # timestep must be regular gamma2 = -dT_dual * ((4 * pi * k) / q) gamma3 = expi_inv_vect_neg(gamma2) gamma4 = -gamma3 gamma5 = np.sqrt(gamma4 * t) gamma6 = np.log(gamma5) gamma7 = forward_first_derivative(gamma6, dt) log_r = np.log(r0) if typ == 'iterative': gamma8 = inverse_first_derivative(gamma7, dt, log_r) elif typ == 'matrix': self._set_ds(n) gamma8 = self.ds.solve_system_normal(gamma7, dt, log_r) elif typ == 'regularized': self._set_ds(n) gamma8 = self.ds.solve_system_tikreg_sparse( gamma7, dt, log_r, epsilon) else: raise ValueError( 'inverse_warmup_curve: the type of inverse has not been specified' ) gamma9 = np.exp(gamma8) r_t = gamma9 alpha = obtain_alpha(q, k, r_t, t, gamma3) return alpha, r_t
def ei_inv_neg_array(known): """ Take the inverse of Ei(x) with x < 0 :param known: :return: """ n = length(known) out = np.zeros(n) for k in range(n): out[k] = ei_inv_neg(known[k]) return out
def test_small_argument(): from ei import ei from get_alpha import get_alpha_k_C from get_volumetric_heat_capacity import get_volumetric_heat_capacity from gen_time_vec import gen_time_vec q = 50 k = 4 r0 = 5.0e-3 r1 = 50e-3 theta_o = 1.0e-3 theta_w = 0.49 theta_m = 1 - theta_o - theta_w C = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) fs = 120 dt = 1 / fs T = 30 t = gen_time_vec(fs, T) t = t[1:] # cannot start with zero n = length(t) r = np.linspace(r0, r1, n) alpha = get_alpha_k_C(k, C) print('alpha = ', alpha) gamma4 = r**2 / (4 * alpha) gamma5 = np.log(np.sqrt(gamma4)) gamma5_comp = np.log(r) - np.log(2 * np.sqrt(alpha)) gamma5_diff = gamma5 - gamma5_comp # take the average gamma6 = np.average(gamma5) N = length(gamma5) gamma6_comp = (1.0 / N) * np.sum(np.log(r)) - np.log(2 * np.sqrt(alpha)) print('gamma6 = ', gamma6) print('gamma6_comp = ', gamma6_comp) print('diff = ', gamma6 - gamma6_comp) # subtract from original gamma7 = gamma5 - gamma6 gamma7_comp = np.log(r) - (1 / N) * (np.sum(np.log(r))) gamma7_diff = gamma7 - gamma7_comp
def load_r0(self, path): """ Load the radius r0 :return: """ array = np.load(path) q_range = array[QRANGE_IDENT] r0 = array[R0_IDENT] check_same_size(q_range, r0, self.ERR_STR) n = length(q_range) for k in range(n): s = str(q_range[k]) self.lookup[s] = r0[k]
def forward_first_derivative(x, dx): """ Take the first derivative using a two-point stencil :param x: as the vector :param dx: as the step between elements :return: """ n = length(x) nsub1 = n - 1 out = np.zeros(nsub1) cnt = 0 for i in range(1, n): out[cnt] = (x[i] - x[i - 1]) / dx cnt += 1 return out
def normalize_open_interval(x, normalized=False, s=0.5): """ Function to normalize data on the open interval (0,1) INPUTS x = data vector normalized = True if the function has already been normalized s = Bayesian estimator = 0.5 (see paper [3] for details) REFERENCES: [2],[3] """ if (normalized is False): x0 = normalize_regular(x) else: x0 = x N = length(x0) y = (x0 * (N - 1) + s) / N return y
def compute_delta_T_dual_heating_q_H(q, k, H, t): """ Compute the synthetic curve using the heating and cooling with only H :param q: quantity of heat liberated :param k: thermal conductivity :param H: H parameter :param t: time vector :param t_heating: time at which heating ends :return: """ n = length(t) out = np.zeros(n) first = term1(q, k) second = ei(-H / t) out = first * second return out
def inverse_first_derivative(xprime, dt, a0): """ Take the inverse of the first derivative using recursion :param xprime: as the derivative vector :param dt: as the timestep between vectors :param a0: as the known first element (boundary condition) :return: """ n = length(xprime) n1 = n + 1 out = np.zeros(n1) out[0] = a0 cnt = 0 for i in range(1, n1): out[i] = xprime[cnt] * dt + out[cnt] cnt += 1 return out
def expi_inv_vect_neg(known): """ Take the inverse of expi over a vector. Here it is known that x < 0. NOTE that this function cannot be applied if x > 0. :param known: :param neg: :param radius: :return: """ n = length(known) out = np.zeros(n) for k in range(n): out[k] = exp_integral.Eid_inv_negative(known[k]) return out
def ei_inv_cooling(fxy, th, tc): """ Function to compute the inverse of f(x, y) = Ei(-x) - Ei(-y) NOTE that Nelder-Mead function works well, and that an operation can cause underflow. :param fxy: as the function :param th: as the time of heating :param tc: as the cooling time vector :return: """ def _func(x, *args): hh = x[0] known = args[0] th_known = args[1] t_known = args[2] upper = args[3] xx = hh / (t_known - th_known) yy = hh / t_known first = ei(-xx) second = ei(-yy) calc = first - second # this operation can be subject to invalid floating point math if calc < 0: calc = eps elif calc > upper: calc = upper - eps out = known - calc if out < 0: # compute absolute value (do this directly in case multiple precision math is required) out = -out return out nn = length(fxy) recon = np.zeros(nn) hstart = 80 xstart = (hstart, ) th_known = th for k in range(nn): t_known = tc[k] term = t_known - th_known known = fxy[k] z = np.sqrt(term / t_known) upper = term * (((1 + z) / z) * (1 / known))**2 args = (known, th, t_known, upper) res = minimize(_func, xstart, args, method='Nelder-Mead', tol=1.0e-30) # NOTE THE TOLERANCE REQUIRED recon[k] = res.x[0] return recon
def _deriv_3pt_common(x, dx, t, typ): if typ == 'first': f = _first dx2 = 2.0 * dx elif typ == 'second': f = _second dx2 = dx**2 else: raise ValueError('Type of derivative not recognized') n = length(x) nn = n - 2 out = np.zeros(nn) cnt = 0 tt = t[1:-1] for k in range(1, n-1): out[cnt] = f(x, k, dx2) cnt += 1 return tt, out
def test_full_inverse_heating(): q = 50 k = 4 r0 = 5.7e-3 r1 = 15e-3 theta_o = 1.0e-3 theta_w = 0.49 theta_m = 1 - theta_o - theta_w C = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) fs = 12 dt = 1 / fs T = 30 t = gen_time_vec(fs, T) t = t[1:] # cannot start with zero n = length(t) r = np.linspace(r0, r1, n) alpha = get_alpha_k_C(k, C) t_heating = 8 th = t_heating # dT = compute_delta_T_dual_infinite_line_heating(q, k, alpha, r, t) # obtain the forward model # r0_found, r_t = recomp_radius(fs, q, k, t, dT) # print('r0 = ', r0) # print('r0_found = ', r0_found) gamma4 = (r**2) / (4 * alpha) gamma5 = np.sqrt(gamma4) gamma5_comp = r / (2 * np.sqrt(alpha)) gamma6 = np.log(gamma5) gamma7 = forward_first_derivative(gamma6, dt) gamma7_comp = forward_first_derivative(np.log(r), dt) r0_in = r0 gamma8 = np.exp(inverse_first_derivative(gamma7, dt, np.log(r0_in))) gamma8 = gamma8 - gamma8[0] print('delta_r = ', r[2] - r[1]) print('delta_r = ', gamma8[2] - gamma8[1]) plt.figure() plt.plot(gamma8) plt.plot(r) plt.show()
def sp_model_late_time_inv(dT, t, dt, q, entire_heating_time=False, return_all=False): """ Obtain the k value from the late-time inverse :param dT: change in temperature :param t: time vector :param dt: time step :param q: heat input into soil :param entire_heating_time: True to not search for when the curve becomes linear :return: (tlinear, kdet) tlinear = time at which the curve becomes linear kdet = determined k """ TADD = 1.0 # time additional to take when the curve is linear (ensures linearity) log_t = np.log(t) # t cannot be zero since we are taking the logarithm if not entire_heating_time: tt, sd = second_derivative_3pt(dT, dt, log_t) nn = length(sd) kk = 0 for k in range(1, nn): # zero-crossing detector to determine when the curve is linear check = sd[k] # start at the first element if check < 0: kk = k break k2 = kk-2 if k2 < 0: # ensure that the element selected is not less than 0 k2 = 0 tlinear = t[k2] + TADD # time at which the curve becomes linear fs = 1.0/dt # sampling frequency used to compute the cut time tlinear_cut_elem = int(np.ceil(tlinear*fs)) t_tlinear = t[tlinear_cut_elem:] dT_tlinear = dT[tlinear_cut_elem:] else: # bypass cutting the curve t_tlinear = t dT_tlinear = dT tlinear = 0 # take the curve with the late time since this is fit over the late time section of the curve t_tlinear0 = t_tlinear dT_tlinear0 = dT_tlinear kdet, bdet = sp_model_late_time_inv_optim(dT_tlinear0, t_tlinear0, q) if not return_all: return tlinear, kdet return tlinear, kdet, bdet, t_tlinear0, dT_tlinear0
def gen_radius(r0, r1, t, th, sd, heat_cool=False): """ Generate a radius suitable for demonstrating the inverse :param r0: as the starting radius :param r1: as the ending radius :param t: as the total time vector :param th: as the time of heating :param sd: as the standard deviation :param heat_cool: True to generate heating and cooling curves :return: """ n = length(t) # obtain the length of t if heat_cool: # run over the heating and cooling curve a = r1 # height of the peak at the maximum radius b = th # height of the peak time c = sd # standard deviation rout = r0 + gaussian(a, b, c, t) else: rout = np.linspace(r0, r1, n) return rout
def compute_delta_T_dual_heating_cooling(q, k, alpha, r, t, t_heating, split=False): """ Compute the synthetic curve using the heating and cooling :param q: quantity of heat liberated :param k: thermal conductivity :param alpha: thermal diffusivity :param r: probe radius :param t: time vector :param t_heating: time at which heating ends :return: """ n = length(t) out = np.zeros(n) first = term1(q, k) second = -first dt = t[1] - t[0] fs = 1.0 / dt nn = int(np.ceil(fs * t_heating)) tvec_heat = t[:nn] tvec_cool = t[nn:] if is_numpy(r): # variable r rheat = r[:nn] rcool = r[nn:] else: # fixed r rheat = r rcool = r heating = compute_delta_T_dual_infinite_line_heating( q, k, alpha, rheat, tvec_heat) ei_term3 = ei(term3(rcool, alpha, tvec_cool, t_heating)) ei_term2 = ei(term2(rcool, alpha, tvec_cool)) cooling = second * (ei_term3 - ei_term2) out = np.append(heating, cooling) if split: return out, heating, cooling, first, second, tvec_heat, tvec_cool, rheat, rcool, ei_term3, ei_term2 return out
def find_curve_changes(self, x): nx = length(x) n = nx - 2 * self.ws start = 0 end = self.ws mid = int(np.floor(0.5 * (start + end))) out = np.zeros(nx) # output is same size as the initial input for k in range(n): first = x[start:mid] second = x[mid + 1:end] mid += 1 if first.size == 0 or second.size == 0: break test = self.st.run(first, second) if test: out[mid] = CURVE_CHANGE_TRUE_VAL else: out[mid] = CURVE_CHANGE_FALSE_VAL # switch out the endpoints start += 1 end += 1 return out
def compute_delta_T_dual_heating_cooling_q_H(q, k, H, t, t_heating): """ Compute the synthetic curve using the heating and cooling with only H :param q: quantity of heat liberated :param k: thermal conductivity :param H: H parameter :param t: time vector :param t_heating: time at which heating ends :return: """ n = length(t) out = np.zeros(n) first = term1(q, k) for k in range(n): tk = t[k] if tk > t_heating: second = ei(-H / (tk - t_heating)) - ei(-H / tk) second = -second else: second = ei(-H / tk) out[k] = first * second return out
def average_downsample(fsample, fwanted, v): """ Downsample a signal over a series of windows :param fsample: as the actual sampling rate :param fwanted: as the wanted sampling rate :param v: :return: """ n = int(np.ceil(fsample / fwanted)) # number of points in the window nlen = length(v) nwin = int(nlen / n) # number of windows begin = 0 end = n out = np.zeros( nwin) # the output has the same length as the number of windows for k in range(nwin): win = v[begin:end] av = np.average(win) out[k] = av begin = end end += n return out
def data_analysis_for_trials(): """ Perform the data analysis for all trials :return: """ print('Loading data...') experiments = pickle.load(open(DATA_PICKLE_FILE_VEC, "rb")) theta_nom_sand, rho_nom_sand, theta_sig_sand, rho_sig_sand, \ alpha_det_sand, alpha_sig_sand, k_det_sand, kdet_sig_sand, kdet_linear_sand, qav_vec_sand, qknown_vec_sand\ = experiments[SAND_NAME] theta_nom_peat, rho_nom_peat, theta_sig_peat, rho_sig_peat, \ alpha_det_peat, alpha_sig_peat, k_det_peat, kdet_sig_peat, kdet_linear_peat, qav_vec_peat, qknown_vec_peat\ = experiments[PEAT_NAME] print('Done loading data...') ################################################################ # compute the RMSD, MB and PD for sand and peat q (the heat input into the soil) print('Computing q comparisons') rmsd_sand_q = compute_rmse(qknown_vec_sand, qav_vec_sand) rmsd_peat_q = compute_rmse(qknown_vec_peat, qav_vec_peat) mb_sand_q = compute_mb(qknown_vec_sand, qav_vec_sand) mb_peat_q = compute_mb(qknown_vec_peat, qav_vec_peat) pd_sand_q = compute_pd(qknown_vec_sand, qav_vec_sand) pd_peat_q = compute_pd(qknown_vec_peat, qav_vec_peat) comp_list = [('sand', rmsd_sand_q, mb_sand_q, pd_sand_q), ('peat', rmsd_peat_q, mb_peat_q, pd_peat_q)] labels = ['soil', 'rmsd', 'mb', 'pd'] df_q = pd.DataFrame.from_records(comp_list, columns=labels) df_q.to_html(TABLE_PATH + TABLE_NAME_Q_COMP + HTML_EXT) print('DONE saving out HTML comparisons for q') ################################################################ # first sequence of experiments ns = length(theta_nom_sand) xs = np.linspace(1, ns, ns) # second sequence of experiments nnp = length(theta_nom_peat) xp = np.linspace(xs[-1]+1, xs[-1]+nnp, nnp) # break the sequences up for each set so that the stats can be run ######################## # NUMBERS SAND ######################## start_num = 1 end_num = 5 calc_sand_theta_nom_sand_num_1_5 = cut_seq_trial(theta_nom_sand, start_num, end_num) calc_sand_rho_nom_sand_num_1_5 = cut_seq_trial(rho_nom_sand, start_num, end_num) calc_sand_theta_sig_sand_num_1_5 = cut_seq_trial(theta_sig_sand, start_num, end_num) calc_sand_rho_sig_sand_num_1_5 = cut_seq_trial(rho_sig_sand, start_num, end_num) # theta nominal for sand 1-5 rmse__calc_sand_theta_nom_sand_num_1_5 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_1_5) mb__calc_sand_theta_nom_sand_num_1_5 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_1_5) pd__calc_sand_theta_nom_sand_num_1_5 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_1_5) variance__calc_sand_theta_nom_sand_num_1_5 = compute_variance(calc_sand_theta_nom_sand_num_1_5) sd__calc_sand_theta_nom_sand_num_1_5 = compute_sd(calc_sand_theta_nom_sand_num_1_5) # rho nominal for sand 1-5 rmse__calc_sand_rho_nom_sand_num_1_5 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_1_5) mb__calc_sand_rho_nom_sand_num_1_5 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_1_5) pd__calc_sand_rho_nom_sand_num_1_5 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_1_5) variance__calc_rho_theta_nom_sand_num_1_5 = compute_variance(calc_sand_rho_nom_sand_num_1_5) sd__calc_sand_rho_nom_sand_num_1_5 = compute_sd(calc_sand_rho_nom_sand_num_1_5) # theta signal for sand 1-5 rmse__calc_sand_theta_sig_sand_num_1_5 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_1_5) mb__calc_sand_theta_sig_sand_num_1_5 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_1_5) pd__calc_sand_theta_sig_sand_num_1_5 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_1_5) variance__calc_sand_theta_sig_sand_num_1_5 = compute_variance(calc_sand_theta_sig_sand_num_1_5) sd__calc_sand_theta_sig_sand_num_1_5 = compute_sd(calc_sand_theta_sig_sand_num_1_5) # rho signal for sand 1-5 rmse__calc_sand_rho_sig_sand_num_1_5 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_1_5) mb__calc_sand_rho_sig_sand_num_1_5 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_1_5) pd__calc_sand_rho_sig_sand_num_1_5 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_1_5) variance__calc_rho_sig_nom_sand_num_1_5 = compute_variance(calc_sand_rho_sig_sand_num_1_5) sd__calc_sand_rho_sig_sand_num_1_5 = compute_sd(calc_sand_rho_sig_sand_num_1_5) ########################################################################################## start_num = 6 end_num = 10 calc_sand_theta_nom_sand_num_6_10 = cut_seq_trial(theta_nom_sand, start_num, end_num) calc_sand_rho_nom_sand_num_6_10 = cut_seq_trial(rho_nom_sand, start_num, end_num) calc_sand_theta_sig_sand_num_6_10 = cut_seq_trial(theta_sig_sand, start_num, end_num) calc_sand_rho_sig_sand_num_6_10 = cut_seq_trial(rho_sig_sand, start_num, end_num) # theta nominal for sand 6-10 rmse__calc_sand_theta_nom_sand_num_6_10 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_6_10) mb__calc_sand_theta_nom_sand_num_6_10 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_6_10) pd__calc_sand_theta_nom_sand_num_6_10 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_6_10) variance__calc_sand_theta_nom_sand_num_6_10 = compute_variance(calc_sand_theta_nom_sand_num_6_10) sd__calc_sand_theta_nom_sand_num_6_10 = compute_sd(calc_sand_theta_nom_sand_num_6_10) # rho nominal for sand 6-10 rmse__calc_sand_rho_nom_sand_num_6_10 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_6_10) mb__calc_sand_rho_nom_sand_num_6_10 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_6_10) pd__calc_sand_rho_nom_sand_num_6_10 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_6_10) variance__calc_rho_theta_nom_sand_num_6_10 = compute_variance(calc_sand_rho_nom_sand_num_6_10) sd__calc_sand_rho_nom_sand_num_6_10 = compute_sd(calc_sand_rho_nom_sand_num_6_10) # theta signal for sand 6-10 rmse__calc_sand_theta_sig_sand_num_6_10 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_6_10) mb__calc_sand_theta_sig_sand_num_6_10 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_6_10) pd__calc_sand_theta_sig_sand_num_6_10 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_6_10) variance__calc_sand_theta_sig_sand_num_6_10 = compute_variance(calc_sand_theta_sig_sand_num_6_10) sd__calc_sand_theta_sig_sand_num_6_10 = compute_sd(calc_sand_theta_sig_sand_num_6_10) # rho signal for sand 6-10 rmse__calc_sand_rho_sig_sand_num_6_10 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_6_10) mb__calc_sand_rho_sig_sand_num_6_10 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_6_10) pd__calc_sand_rho_sig_sand_num_6_10 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_6_10) variance__calc_rho_sig_nom_sand_num_6_10 = compute_variance(calc_sand_rho_sig_sand_num_6_10) sd__calc_sand_rho_sig_sand_num_6_10 = compute_sd(calc_sand_rho_sig_sand_num_6_10) ########################################################################################## start_num = 11 end_num = 15 calc_sand_theta_nom_sand_num_11_15 = cut_seq_trial(theta_nom_sand, start_num, end_num) calc_sand_rho_nom_sand_num_11_15 = cut_seq_trial(rho_nom_sand, start_num, end_num) calc_sand_theta_sig_sand_num_11_15 = cut_seq_trial(theta_sig_sand, start_num, end_num) calc_sand_rho_sig_sand_num_11_15 = cut_seq_trial(rho_sig_sand, start_num, end_num) # theta nominal for sand 11-15 rmse__calc_sand_theta_nom_sand_num_11_15 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_11_15) mb__calc_sand_theta_nom_sand_num_11_15 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_11_15) pd__calc_sand_theta_nom_sand_num_11_15 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_11_15) variance__calc_sand_theta_nom_sand_num_11_15 = compute_variance(calc_sand_theta_nom_sand_num_11_15) sd__calc_sand_theta_nom_sand_num_11_15 = compute_sd(calc_sand_theta_nom_sand_num_11_15) # rho nominal for sand 11-15 rmse__calc_sand_rho_nom_sand_num_11_15 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_11_15) mb__calc_sand_rho_nom_sand_num_11_15 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_11_15) pd__calc_sand_rho_nom_sand_num_11_15 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_11_15) variance__calc_rho_theta_nom_sand_num_11_15 = compute_variance(calc_sand_rho_nom_sand_num_11_15) sd__calc_sand_rho_nom_sand_num_11_15 = compute_sd(calc_sand_rho_nom_sand_num_11_15) # theta signal for sand 11-15 rmse__calc_sand_theta_sig_sand_num_11_15 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_11_15) mb__calc_sand_theta_sig_sand_num_11_15 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_11_15) pd__calc_sand_theta_sig_sand_num_11_15 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_11_15) variance__calc_sand_theta_sig_sand_num_11_15 = compute_variance(calc_sand_theta_sig_sand_num_11_15) sd__calc_sand_theta_sig_sand_num_11_15 = compute_sd(calc_sand_theta_sig_sand_num_11_15) # rho signal for sand 11-15 rmse__calc_sand_rho_sig_sand_num_11_15 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_11_15) mb__calc_sand_rho_sig_sand_num_11_15 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_11_15) pd__calc_sand_rho_sig_sand_num_11_15 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_11_15) variance__calc_rho_sig_nom_sand_num_11_15 = compute_variance(calc_sand_rho_sig_sand_num_11_15) sd__calc_sand_rho_sig_sand_num_11_15 = compute_sd(calc_sand_rho_sig_sand_num_11_15) ################################################################################################# start_num = 16 end_num = 20 calc_sand_theta_nom_sand_num_16_20 = cut_seq_trial(theta_nom_sand, start_num, end_num) calc_sand_rho_nom_sand_num_16_20 = cut_seq_trial(rho_nom_sand, start_num, end_num) calc_sand_theta_sig_sand_num_16_20 = cut_seq_trial(theta_sig_sand, start_num, end_num) calc_sand_rho_sig_sand_num_16_20 = cut_seq_trial(rho_sig_sand, start_num, end_num) # theta nominal for sand 16-20 rmse__calc_sand_theta_nom_sand_num_16_20 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_16_20) mb__calc_sand_theta_nom_sand_num_16_20 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_16_20) pd__calc_sand_theta_nom_sand_num_16_20 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_num_16_20) variance__calc_sand_theta_nom_sand_num_16_20 = compute_variance(calc_sand_theta_nom_sand_num_16_20) sd__calc_sand_theta_nom_sand_num_16_20 = compute_sd(calc_sand_theta_nom_sand_num_16_20) # rho nominal for sand 16-20 rmse__calc_sand_rho_nom_sand_num_16_20 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_16_20) mb__calc_sand_rho_nom_sand_num_16_20 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_16_20) pd__calc_sand_rho_nom_sand_num_16_20 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_num_16_20) variance__calc_rho_theta_nom_sand_num_16_20 = compute_variance(calc_sand_rho_nom_sand_num_16_20) sd__calc_sand_rho_nom_sand_num_16_20 = compute_sd(calc_sand_rho_nom_sand_num_16_20) # theta signal for sand 16-20 rmse__calc_sand_theta_sig_sand_num_16_20 = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_16_20) mb__calc_sand_theta_sig_sand_num_16_20 = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_16_20) pd__calc_sand_theta_sig_sand_num_16_20 = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_num_16_20) variance__calc_sand_theta_sig_sand_num_16_20 = compute_variance(calc_sand_theta_sig_sand_num_16_20) sd__calc_sand_theta_sig_sand_num_16_20 = compute_sd(calc_sand_theta_sig_sand_num_16_20) # rho signal for sand 16-20 rmse__calc_sand_rho_sig_sand_num_16_20 = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_16_20) mb__calc_sand_rho_sig_sand_num_16_20 = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_16_20) pd__calc_sand_rho_sig_sand_num_16_20 = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_num_16_20) variance__calc_rho_sig_nom_sand_num_16_20 = compute_variance(calc_sand_rho_sig_sand_num_16_20) sd__calc_sand_rho_sig_sand_num_16_20 = compute_sd(calc_sand_rho_sig_sand_num_16_20) ######################## # NUMBERS PEAT ######################## start_num = 1 end_num = 5 calc_peat_theta_nom_peat_num_21_25 = cut_seq_trial(theta_nom_peat, start_num, end_num) calc_peat_rho_nom_peat_num_21_25 = cut_seq_trial(rho_nom_peat, start_num, end_num) calc_peat_theta_sig_peat_num_21_25 = cut_seq_trial(theta_sig_peat, start_num, end_num) calc_peat_rho_sig_peat_num_21_25 = cut_seq_trial(rho_sig_peat, start_num, end_num) # theta nominal for peat 21-25 rmse__calc_peat_theta_nom_peat_num_21_25 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_21_25) mb__calc_peat_theta_nom_peat_num_21_25 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_21_25) pd__calc_peat_theta_nom_peat_num_21_25 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_21_25) variance__calc_peat_theta_nom_peat_num_21_25 = compute_variance(calc_peat_theta_nom_peat_num_21_25) sd__calc_peat_theta_nom_peat_num_21_25 = compute_sd(calc_peat_theta_nom_peat_num_21_25) # rho nominal for peat 21-25 rmse__calc_peat_rho_nom_sand_num_21_25 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_21_25) mb__calc_peat_rho_nom_sand_num_21_25 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_21_25) pd__calc_peat_rho_nom_sand_num_21_25 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_21_25) variance__calc_peat_rho_theta_nom_sand_num_21_25 = compute_variance(calc_peat_rho_nom_peat_num_21_25) sd__calc_peat_rho_nom_sand_num_21_25 = compute_sd(calc_peat_rho_nom_peat_num_21_25) # theta signal for peat 21-25 rmse__calc_peat_theta_sig_sand_num_21_25 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_21_25) mb__calc_peat_theta_sig_sand_num_21_25 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_21_25) pd__calc_peat_theta_sig_sand_num_21_25 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_21_25) variance__calc_peat_theta_sig_sand_num_21_25 = compute_variance(calc_peat_theta_sig_peat_num_21_25) sd__calc_peat_theta_sig_sand_num_21_25 = compute_sd(calc_peat_theta_sig_peat_num_21_25) # rho signal for peat 21-25 rmse__calc_peat_rho_sig_peat_num_21_25 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_21_25) mb__calc_peat_rho_sig_peat_num_21_25 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_21_25) pd__calc_peat_rho_sig_peat_num_21_25 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_21_25) variance__calc_peat_rho_sig_nom_peat_num_21_25 = compute_variance(calc_peat_rho_sig_peat_num_21_25) sd__calc_peat_rho_sig_peat_num_21_25 = compute_sd(calc_peat_rho_sig_peat_num_21_25) ######################################################################################################### start_num = 6 end_num = 10 calc_peat_theta_nom_peat_num_26_30 = cut_seq_trial(theta_nom_peat, start_num, end_num) calc_peat_rho_nom_peat_num_26_30 = cut_seq_trial(rho_nom_peat, start_num, end_num) calc_peat_theta_sig_peat_num_26_30 = cut_seq_trial(theta_sig_peat, start_num, end_num) calc_peat_rho_sig_peat_num_26_30 = cut_seq_trial(rho_sig_peat, start_num, end_num) # theta nominal for peat 26-30 rmse__calc_peat_theta_nom_peat_num_26_30 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_26_30) mb__calc_peat_theta_nom_peat_num_26_30 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_26_30) pd__calc_peat_theta_nom_peat_num_26_30 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_26_30) variance__calc_peat_theta_nom_peat_num_26_30 = compute_variance(calc_peat_theta_nom_peat_num_26_30) sd__calc_peat_theta_nom_peat_num_26_30 = compute_sd(calc_peat_theta_nom_peat_num_26_30) # rho nominal for peat 26-30 rmse__calc_peat_rho_nom_peat_num_26_30 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_26_30) mb__calc_peat_rho_nom_peat_num_26_30 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_26_30) pd__calc_peat_rho_nom_peat_num_26_30 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_26_30) variance__calc_peat_rho_theta_nom_peat_num_26_30 = compute_variance(calc_peat_rho_nom_peat_num_26_30) sd__calc_peat_rho_nom_peat_num_26_30 = compute_sd(calc_peat_rho_nom_peat_num_26_30) # theta signal for peat 26-30 rmse__calc_peat_theta_sig_peat_num_26_30 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_26_30) mb__calc_peat_theta_sig_peat_num_26_30 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_26_30) pd__calc_peat_theta_sig_peat_num_26_30 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_26_30) variance__calc_peat_theta_sig_peat_num_26_30 = compute_variance(calc_peat_theta_sig_peat_num_26_30) sd__calc_peat_theta_sig_peat_num_26_30 = compute_sd(calc_peat_theta_sig_peat_num_26_30) # rho signal for peat 26-30 rmse__calc_peat_rho_sig_peat_num_26_30 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_26_30) mb__calc_peat_rho_sig_peat_num_26_30 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_26_30) pd__calc_peat_rho_sig_peat_num_26_30 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_26_30) variance__calc_peat_rho_sig_nom_peat_num_26_30 = compute_variance(calc_peat_rho_sig_peat_num_26_30) sd__calc_peat_rho_sig_peat_num_26_30 = compute_sd(calc_peat_rho_sig_peat_num_26_30) ######################################################################################################### start_num = 11 end_num = 15 calc_peat_theta_nom_peat_num_31_35 = cut_seq_trial(theta_nom_peat, start_num, end_num) calc_peat_rho_nom_peat_num_31_35 = cut_seq_trial(rho_nom_peat, start_num, end_num) calc_peat_theta_sig_peat_num_31_35 = cut_seq_trial(theta_sig_peat, start_num, end_num) calc_peat_rho_sig_peat_num_31_35 = cut_seq_trial(rho_sig_peat, start_num, end_num) # theta nominal for peat 31-25 rmse__calc_peat_theta_nom_peat_num_31_35 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_31_35) mb__calc_peat_theta_nom_peat_num_31_35 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_31_35) pd__calc_peat_theta_nom_peat_num_31_35 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_num_31_35) variance__calc_peat_theta_nom_peat_num_31_35 = compute_variance(calc_peat_theta_nom_peat_num_31_35) sd__calc_peat_theta_nom_peat_num_31_35 = compute_sd(calc_peat_theta_nom_peat_num_31_35) # rho nominal for peat 31-25 rmse__calc_peat_rho_nom_peat_num_31_35 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_31_35) mb__calc_peat_rho_nom_peat_num_31_35 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_31_35) pd__calc_peat_rho_nom_peat_num_31_35 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_num_31_35) variance__calc_peat_rho_theta_nom_peat_num_31_35 = compute_variance(calc_peat_rho_nom_peat_num_31_35) sd__calc_peat_rho_nom_peat_num_31_35 = compute_sd(calc_peat_rho_nom_peat_num_31_35) # theta signal for peat 31-25 rmse__calc_peat_theta_sig_peat_num_31_35 = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_31_35) mb__calc_peat_theta_sig_peat_num_31_35 = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_31_35) pd__calc_peat_theta_sig_peat_num_31_35 = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_num_31_35) variance__calc_peat_theta_sig_peat_num_31_35 = compute_variance(calc_peat_theta_sig_peat_num_31_35) sd__calc_peat_theta_sig_peat_num_31_35 = compute_sd(calc_peat_theta_sig_peat_num_31_35) # rho signal for peat 31-25 rmse__calc_peat_rho_sig_peat_num_31_35 = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_31_35) mb__calc_peat_rho_sig_peat_num_31_35 = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_31_35) pd__calc_peat_rho_sig_peat_num_31_35 = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_num_31_35) variance__calc__peat_rho_sig_nom_peat_num_31_35 = compute_variance(calc_peat_rho_sig_peat_num_31_35) sd__calc_peat_rho_sig_peat_num_31_35 = compute_sd(calc_peat_rho_sig_peat_num_31_35) ######################################################################################################### ########################### # ALL SAND ########################### calc_sand_theta_nom_sand_all = theta_nom_sand calc_sand_rho_nom_sand_all = rho_nom_sand calc_sand_theta_sig_sand_all = theta_sig_sand calc_sand_rho_sig_sand_all = rho_sig_sand rmse__calc_sand_theta_nom_sand_all = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_all) mb__calc_sand_theta_nom_sand_all = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_all) pd__calc_sand_theta_nom_sand_all = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_nom_sand_all) variance__calc_sand_theta_nom_sand_all = compute_variance(calc_sand_theta_nom_sand_all) sd__calc_sand_theta_nom_sand_trial_all = compute_sd(calc_sand_theta_nom_sand_all) rmse__calc_sand_rho_nom_sand_all = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_all) mb__calc_sand_rho_nom_sand_all = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_all) pd__calc_sand_rho_nom_sand_all = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_nom_sand_all) variance__calc_sand_rho_nom_sand_all = compute_variance(calc_sand_rho_nom_sand_all) sd__calc_sand_rho_nom_sand_all = compute_sd(calc_sand_rho_nom_sand_all) rmse__calc_sand_theta_sig_sand_all = compute_rmse(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_all) mb__calc_sand_theta_sig_sand_all = compute_mb(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_all) pd__calc_sand_theta_sig_sand_all = compute_percentage_diff(THETA_NOMINAL_SAND, calc_sand_theta_sig_sand_all) variance__calc_sand_theta_sig_sand_all = compute_variance(calc_sand_theta_sig_sand_all) sd__calc_sand_theta_sig_sand_all = compute_sd(calc_sand_theta_sig_sand_all) rmse__calc_sand_rho_sig_sand_all = compute_rmse(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_all) mb__calc_sand_rho_sig_sand_all = compute_mb(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_all) pd__calc_sand_rho_sig_sand_all = compute_percentage_diff(DENSITY_NOMINAL_SAND, calc_sand_rho_sig_sand_all) variance__calc_sand_rho_sig_sand_all = compute_variance(calc_sand_rho_sig_sand_all) sd__calc_sand_rho_sig_sand_all = compute_sd(calc_sand_rho_sig_sand_all) ########################### # ALL PEAT ########################### calc_peat_theta_nom_peat_all = theta_nom_peat calc_peat_rho_nom_peat_all = rho_nom_peat calc_peat_theta_sig_peat_all = theta_sig_peat calc_peat_rho_sig_peat_all = rho_sig_peat rmse__calc_peat_theta_nom_peat_all = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_all) mb__calc_peat_theta_nom_peat_all = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_all) pd__calc_peat_theta_nom_peat_all = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_nom_peat_all) variance__calc_peat_theta_nom_peat_all = compute_variance(calc_peat_theta_nom_peat_all) sd__calc_peat_theta_nom_peat_trial_all = compute_sd(calc_peat_theta_nom_peat_all) rmse__calc_peat_rho_nom_peat_all = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_all) mb__calc_peat_rho_nom_peat_all = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_all) pd__calc_peat_rho_nom_peat_all = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_nom_peat_all) variance__calc_peat_rho_nom_peat_all = compute_variance(calc_peat_rho_nom_peat_all) sd__calc_peat_rho_nom_peat_all = compute_sd(calc_peat_rho_nom_peat_all) rmse__calc_peat_theta_sig_peat_all = compute_rmse(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_all) mb__calc_peat_theta_sig_peat_all = compute_mb(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_all) pd__calc_peat_theta_sig_peat_all = compute_percentage_diff(THETA_NOMINAL_PEAT, calc_peat_theta_sig_peat_all) variance__calc_peat_theta_sig_peat_all = compute_variance(calc_peat_theta_sig_peat_all) sd__calc_peat_theta_sig_peat_all = compute_sd(calc_peat_theta_sig_peat_all) rmse__calc_peat_rho_sig_peat_all = compute_rmse(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_all) mb__calc_peat_rho_sig_peat_all = compute_mb(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_all) pd__calc_peat_rho_sig_peat_all = compute_percentage_diff(DENSITY_NOMINAL_PEAT, calc_peat_rho_sig_peat_all) variance__calc_peat_rho_sig_peat_all = compute_variance(calc_peat_rho_sig_peat_all) sd__calc_peat_rho_sig_peat_all = compute_sd(calc_peat_rho_sig_peat_all) # EXPORT ALL OF THE ABOVE IN AN HTML TABLE tabd = PrettyTableWrapper(DEC_PLACES_TAB) # 22 columns (list vertically) tabd.field_names(["Soil Type", "Identifier", "theta_nominal RMSE", "theta_nominal MB", "theta_nominal PD (%)", "theta_nominal Variance", "theta_nominal SD", "rho_nominal RMSE", "rho_nominal MB", "rho_nominal PD (%)", "rho_nominal Variance", "rho_nominal SD", "theta_sig RMSE", "theta_sig MB", "theta_sig PD (%)", "theta_sig Variance", "theta_sig SD", "rho_sig RMSE", "rho_sig MB", "rho_sig PD (%)", "rho_sig Variance", "rho_sig SD" ]) tabd.add_row(['sand', '1-5', rmse__calc_sand_theta_nom_sand_num_1_5, mb__calc_sand_theta_nom_sand_num_1_5, pd__calc_sand_theta_nom_sand_num_1_5, variance__calc_sand_theta_nom_sand_num_1_5, sd__calc_sand_theta_nom_sand_num_1_5, rmse__calc_sand_rho_nom_sand_num_1_5, mb__calc_sand_rho_nom_sand_num_1_5, pd__calc_sand_rho_nom_sand_num_1_5, variance__calc_rho_theta_nom_sand_num_1_5, sd__calc_sand_rho_nom_sand_num_1_5, rmse__calc_sand_theta_sig_sand_num_1_5, mb__calc_sand_theta_sig_sand_num_1_5, pd__calc_sand_theta_sig_sand_num_1_5, variance__calc_sand_theta_sig_sand_num_1_5, sd__calc_sand_theta_sig_sand_num_1_5, rmse__calc_sand_rho_sig_sand_num_1_5, mb__calc_sand_rho_sig_sand_num_1_5, pd__calc_sand_rho_sig_sand_num_1_5, variance__calc_rho_sig_nom_sand_num_1_5, sd__calc_sand_rho_sig_sand_num_1_5 ]) tabd.add_row(['sand', '6-10', rmse__calc_sand_theta_nom_sand_num_6_10, mb__calc_sand_theta_nom_sand_num_6_10, pd__calc_sand_theta_nom_sand_num_6_10, variance__calc_sand_theta_nom_sand_num_6_10, sd__calc_sand_theta_nom_sand_num_6_10, rmse__calc_sand_rho_nom_sand_num_6_10, mb__calc_sand_rho_nom_sand_num_6_10, pd__calc_sand_rho_nom_sand_num_6_10, variance__calc_rho_theta_nom_sand_num_6_10, sd__calc_sand_rho_nom_sand_num_6_10, rmse__calc_sand_theta_sig_sand_num_6_10, mb__calc_sand_theta_sig_sand_num_6_10, pd__calc_sand_theta_sig_sand_num_6_10, variance__calc_sand_theta_sig_sand_num_6_10, sd__calc_sand_theta_sig_sand_num_6_10, rmse__calc_sand_rho_sig_sand_num_6_10, mb__calc_sand_rho_sig_sand_num_6_10, pd__calc_sand_rho_sig_sand_num_6_10, variance__calc_rho_sig_nom_sand_num_6_10, sd__calc_sand_rho_sig_sand_num_6_10 ]) tabd.add_row(['sand', '11-15', rmse__calc_sand_theta_nom_sand_num_11_15, mb__calc_sand_theta_nom_sand_num_11_15, pd__calc_sand_theta_nom_sand_num_11_15, variance__calc_sand_theta_nom_sand_num_11_15, sd__calc_sand_theta_nom_sand_num_11_15, rmse__calc_sand_rho_nom_sand_num_11_15, mb__calc_sand_rho_nom_sand_num_11_15, pd__calc_sand_rho_nom_sand_num_11_15, variance__calc_rho_theta_nom_sand_num_11_15, sd__calc_sand_rho_nom_sand_num_11_15, rmse__calc_sand_theta_sig_sand_num_11_15, mb__calc_sand_theta_sig_sand_num_11_15, pd__calc_sand_theta_sig_sand_num_11_15, variance__calc_sand_theta_sig_sand_num_11_15, sd__calc_sand_theta_sig_sand_num_11_15, rmse__calc_sand_rho_sig_sand_num_11_15, mb__calc_sand_rho_sig_sand_num_11_15, pd__calc_sand_rho_sig_sand_num_11_15, variance__calc_rho_sig_nom_sand_num_11_15, sd__calc_sand_rho_sig_sand_num_11_15 ]) tabd.add_row(['sand', '16-20', rmse__calc_sand_theta_nom_sand_num_16_20, mb__calc_sand_theta_nom_sand_num_16_20, pd__calc_sand_theta_nom_sand_num_16_20, variance__calc_sand_theta_nom_sand_num_16_20, sd__calc_sand_theta_nom_sand_num_16_20, rmse__calc_sand_rho_nom_sand_num_16_20, mb__calc_sand_rho_nom_sand_num_16_20, pd__calc_sand_rho_nom_sand_num_16_20, variance__calc_rho_theta_nom_sand_num_16_20, sd__calc_sand_rho_nom_sand_num_16_20, rmse__calc_sand_theta_sig_sand_num_16_20, mb__calc_sand_theta_sig_sand_num_16_20, pd__calc_sand_theta_sig_sand_num_16_20, variance__calc_sand_theta_sig_sand_num_16_20, sd__calc_sand_theta_sig_sand_num_16_20, rmse__calc_sand_rho_sig_sand_num_16_20, mb__calc_sand_rho_sig_sand_num_16_20, pd__calc_sand_rho_sig_sand_num_16_20, variance__calc_rho_sig_nom_sand_num_16_20, sd__calc_sand_rho_sig_sand_num_16_20 ]) tabd.add_row(['peat', '21-25', rmse__calc_peat_theta_nom_peat_num_21_25, mb__calc_peat_theta_nom_peat_num_21_25, pd__calc_peat_theta_nom_peat_num_21_25, variance__calc_peat_theta_nom_peat_num_21_25, sd__calc_peat_theta_nom_peat_num_21_25, rmse__calc_peat_rho_nom_sand_num_21_25, mb__calc_peat_rho_nom_sand_num_21_25, pd__calc_peat_rho_nom_sand_num_21_25, variance__calc_peat_rho_theta_nom_sand_num_21_25, sd__calc_peat_rho_nom_sand_num_21_25, rmse__calc_peat_theta_sig_sand_num_21_25, mb__calc_peat_theta_sig_sand_num_21_25, pd__calc_peat_theta_sig_sand_num_21_25, variance__calc_peat_theta_sig_sand_num_21_25, sd__calc_peat_theta_sig_sand_num_21_25, rmse__calc_peat_rho_sig_peat_num_21_25, mb__calc_peat_rho_sig_peat_num_21_25, pd__calc_peat_rho_sig_peat_num_21_25, variance__calc_peat_rho_sig_nom_peat_num_21_25, sd__calc_peat_rho_sig_peat_num_21_25, ]) tabd.add_row(['peat', '26-30', rmse__calc_peat_theta_nom_peat_num_26_30, mb__calc_peat_theta_nom_peat_num_26_30, pd__calc_peat_theta_nom_peat_num_26_30, variance__calc_peat_theta_nom_peat_num_26_30, sd__calc_peat_theta_nom_peat_num_26_30, rmse__calc_peat_rho_nom_peat_num_26_30, mb__calc_peat_rho_nom_peat_num_26_30, pd__calc_peat_rho_nom_peat_num_26_30, variance__calc_peat_rho_theta_nom_peat_num_26_30, sd__calc_peat_rho_nom_peat_num_26_30, rmse__calc_peat_theta_sig_peat_num_26_30, mb__calc_peat_theta_sig_peat_num_26_30, pd__calc_peat_theta_sig_peat_num_26_30, variance__calc_peat_theta_sig_peat_num_26_30, sd__calc_peat_theta_sig_peat_num_26_30, rmse__calc_peat_rho_sig_peat_num_26_30, mb__calc_peat_rho_sig_peat_num_26_30, pd__calc_peat_rho_sig_peat_num_26_30, variance__calc_peat_rho_sig_nom_peat_num_26_30, sd__calc_peat_rho_sig_peat_num_26_30 ]) tabd.add_row(['peat', '31-35', rmse__calc_peat_theta_nom_peat_num_31_35, mb__calc_peat_theta_nom_peat_num_31_35, pd__calc_peat_theta_nom_peat_num_31_35, variance__calc_peat_theta_nom_peat_num_31_35, sd__calc_peat_theta_nom_peat_num_31_35, rmse__calc_peat_rho_nom_peat_num_31_35, mb__calc_peat_rho_nom_peat_num_31_35, pd__calc_peat_rho_nom_peat_num_31_35, variance__calc_peat_rho_theta_nom_peat_num_31_35, sd__calc_peat_rho_nom_peat_num_31_35, rmse__calc_peat_theta_sig_peat_num_31_35, mb__calc_peat_theta_sig_peat_num_31_35, pd__calc_peat_theta_sig_peat_num_31_35, variance__calc_peat_theta_sig_peat_num_31_35, sd__calc_peat_theta_sig_peat_num_31_35, rmse__calc_peat_rho_sig_peat_num_31_35, mb__calc_peat_rho_sig_peat_num_31_35, pd__calc_peat_rho_sig_peat_num_31_35, variance__calc__peat_rho_sig_nom_peat_num_31_35, sd__calc_peat_rho_sig_peat_num_31_35 ]) tabd.add_row(['SAND ALL', '', rmse__calc_sand_theta_nom_sand_all, mb__calc_sand_theta_nom_sand_all, pd__calc_sand_theta_nom_sand_all, variance__calc_sand_theta_nom_sand_all, sd__calc_sand_theta_nom_sand_trial_all, rmse__calc_sand_rho_nom_sand_all, mb__calc_sand_rho_nom_sand_all, pd__calc_sand_rho_nom_sand_all, variance__calc_sand_rho_nom_sand_all, sd__calc_sand_rho_nom_sand_all, rmse__calc_sand_theta_sig_sand_all, mb__calc_sand_theta_sig_sand_all, pd__calc_sand_theta_sig_sand_all, variance__calc_sand_theta_sig_sand_all, sd__calc_sand_theta_sig_sand_all, rmse__calc_sand_rho_sig_sand_all, mb__calc_sand_rho_sig_sand_all, pd__calc_sand_rho_sig_sand_all, variance__calc_sand_rho_sig_sand_all, sd__calc_sand_rho_sig_sand_all ]) tabd.add_row(['PEAT ALL', '', rmse__calc_peat_theta_nom_peat_all, mb__calc_peat_theta_nom_peat_all, pd__calc_peat_theta_nom_peat_all, variance__calc_peat_theta_nom_peat_all, sd__calc_peat_theta_nom_peat_trial_all, rmse__calc_peat_rho_nom_peat_all, mb__calc_peat_rho_nom_peat_all, pd__calc_peat_rho_nom_peat_all, variance__calc_peat_rho_nom_peat_all, sd__calc_peat_rho_nom_peat_all, rmse__calc_peat_theta_sig_peat_all, mb__calc_peat_theta_sig_peat_all, pd__calc_peat_theta_sig_peat_all, variance__calc_peat_theta_sig_peat_all, sd__calc_peat_theta_sig_peat_all, rmse__calc_peat_rho_sig_peat_all, mb__calc_peat_rho_sig_peat_all, pd__calc_peat_rho_sig_peat_all, variance__calc_peat_rho_sig_peat_all, sd__calc_peat_rho_sig_peat_all ]) print('Saving stat table...') html = tabd.get_html_string() fn = TABLE_PATH + TABLE_NAME_ALL + HTML_EXT with open(fn, 'w') as f: f.write(html) f.close() print('DONE saving out HTML table') # load in the HTML table text and transpose cols print('Converting to CSV') fn_csv = TABLE_PATH + TABLE_NAME_ALL + CSV_EXT df_list = pd.read_html(fn) for i, df in enumerate(df_list): df.to_csv(fn_csv) print('Done conversion to CSV') # load in the CSV file frame = np.genfromtxt(fn_csv, delimiter=',', dtype=str) frame1 = np.delete(frame, 0, 1) # delete the first column frame2 = np.delete(frame1, 0, 0) # delete the first row c0 = frame2[:, 0] c1 = frame2[:, 1] c2 = frame2[:, 2] c3 = frame2[:, 3] c4 = frame2[:, 4] c5 = frame2[:, 5] c6 = frame2[:, 6] c7 = frame2[:, 7] c8 = frame2[:, 8] c9 = frame2[:, 9] c10 = frame2[:, 10] c11 = frame2[:, 11] c12 = frame2[:, 12] c13 = frame2[:, 13] c14 = frame2[:, 14] c15 = frame2[:, 15] c16 = frame2[:, 16] c17 = frame2[:, 17] c18 = frame2[:, 18] c19 = frame2[:, 19] c20 = frame2[:, 20] c21 = frame2[:, 21] frame_out = np.column_stack((c0, c1, c2, c12, c3, c13, c4, c14, c5, c15, c6, c16, c7, c17, c8, c18, c9, c19, c10, c20, c11, c21)) print('Saving sorted cols out as CSV file...') fn_csv_col_sorted = TABLE_PATH + TABLE_NAME_ALL + "-col-sorted" + CSV_EXT df = pd.DataFrame(frame_out) df.to_csv(fn_csv_col_sorted) fn_csv_col_sorted_html = TABLE_PATH + TABLE_NAME_ALL + "-col-sorted" + HTML_EXT print('Save to HTML file') df.to_html(fn_csv_col_sorted_html) print('DONE')
def run_dp_model_inv_test(show_plot=False, run_full=False): """ Run the SP model inverse test to show an example of the reconstruction :param show_plot: True to show the plot :param run_full: True to run the reconstruction over the heating and cooling curve False to run the reconstruction over only the heating curve :return: """ ################################################ # MAIN ################################################ q = 45 k = 5.2 theta_m = 0.59 theta_o = 9.2e-3 theta_w = 0.40 C = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) alpha = get_alpha_k_C(k, C) r0 = 6e-3 fs = 12 t0 = 0 max_delta_r = 5.0e-3 timestep = 1 / fs t_heat = 8 # 8 seconds for heating (when working with the full curve) if run_full: t1 = 60*3 # 3 minutes for heating and cooling else: t1 = 8 # 8 seconds for heating # create the time vector t = np.arange(t0, t1, timestep) # required since t0 = 0 and this cannot be used since Ei(x=0) is not defined rstep = length(t)-1 ########################################################### # LINEAR CHANGE (INCREASE) ########################################################### print('Computing for linear increase in r(t)...') r = r0 + np.linspace(0, max_delta_r, rstep) dT_dual, dT_dual_fixed, r_det_mm, r_mm, r_t_det_diff, tt = \ run_plot_output(alpha, fs, k, q, r0, run_full, t_heat, t, r) ########################################################### # LINEAR CHANGE (DECREASE) ########################################################### print('Computing for linear decrease in r(t)...') rdec = r[::-1] r0_dec = rdec[0] dT_dual_dec, dT_dual_fixed_dec, r_det_mm_dec, r_mm_dec, r_t_det_diff_dec, tt = \ run_plot_output(alpha, fs, k, q, r0_dec, run_full, t_heat, t, rdec) ########################################################### # RANDOM WALK ########################################################### print('Computing for Brownian random walk in r(t)...') nr = length(r) rb = brownian_noise_norm(nr, r0, r0 + max_delta_r) rb0 = rb[0] dT_dual_bn, dT_dual_fixed_bn, r_det_mm_bn, r_mm_bn, r_t_det_diff_bn, tt = \ run_plot_output(alpha, fs, k, q, rb0, run_full, t_heat, t, rb) ########################################################### # FIGURES ########################################################### print('DONE COMPUTING, RUNNING FIGURES') fig = plt.figure(num=None, figsize=LARGE_SQUARE_FIGSIZE) # INCREASE # (a) ax = fig.add_subplot(3, 3, 1) ax.plot(tt, dT_dual_fixed, label='DP Fixed Radius', color='orange') ax.plot(tt, dT_dual, label='DP Variable Radius', color="cornflowerblue") # ax.set_xlabel('Time (s)') ticklabels_off_x() ax.set_ylabel(create_label('$\Delta T \hspace{1}$', 'K')) ax.legend() ax.set_title('(a)', loc='center') # (b) ax = fig.add_subplot(3, 3, 2) ax.plot(tt, r_mm, color=MODELLED_COLOR, linewidth=4, label='Forward') ax.plot(tt, r_det_mm, color='grey', ls='dashed', label='Inverse') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})$', 'mm')) # ax.set_xlabel('Time (s)') ticklabels_off_x() ax.legend() ax.set_title('(b)', loc='center') # (c) ax = fig.add_subplot(3, 3, 3) ax.plot(tt, r_t_det_diff, color='grey', label='difference') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})\hspace{1}$ Forward -\n Inverse', 'mm')) # ax.set_xlabel('Time (s)') ticklabels_off_x() ax.set_title('(c)', loc='center') # DECREASE # (d) ax = fig.add_subplot(3, 3, 4) ax.plot(tt, dT_dual_fixed_dec, label='DP Fixed Radius', color='orange') ax.plot(tt, dT_dual_dec, label='DP Variable Radius', color="cornflowerblue") ticklabels_off_x() # ax.set_xlabel('Time (s)') ax.set_ylabel(create_label('$\Delta T \hspace{1}$', 'K')) # ax.legend() ax.set_title('(d)', loc='center') # (e) ax = fig.add_subplot(3, 3, 5) ax.plot(tt, r_mm_dec, color=MODELLED_COLOR, linewidth=4, label='Forward') ax.plot(tt, r_det_mm_dec, color='grey', ls='dashed', label='Inverse') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})$', 'mm')) ticklabels_off_x() # ax.set_xlabel('Time (s)') # ax.legend() ax.set_title('(e)', loc='center') # (f) ax = fig.add_subplot(3, 3, 6) ax.plot(tt, r_t_det_diff_dec, color='grey', label='difference') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})\hspace{1}$ Forward -\n Inverse', 'mm')) ticklabels_off_x() # ax.set_xlabel('Time (s)') ax.set_title('(f)', loc='center') # RANDOM WALK # (g) ax = fig.add_subplot(3, 3, 7) ax.plot(tt, dT_dual_fixed_bn, label='DP Fixed Radius', color='orange') ax.plot(tt, dT_dual_bn, label='DP Variable Radius', color="cornflowerblue") ax.set_xlabel('Time (s)') ax.set_ylabel(create_label('$\Delta T \hspace{1}$', 'K')) # ax.legend() ax.set_title('(g)', loc='center') # (h) ax = fig.add_subplot(3, 3, 8) ax.plot(tt, r_mm_bn, color=MODELLED_COLOR, linewidth=4, label='Forward') ax.plot(tt, r_det_mm_bn, color='grey', ls='dashed', label='Inverse') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})$', 'mm')) ax.set_xlabel('Time (s)') ylim = list(ax.get_ylim()) ylim[1] += 0.20*(ylim[1]-ylim[0]) ax.set_ylim(ylim) ax.legend() ax.set_title('(h)', loc='center') # (i) ax = fig.add_subplot(3, 3, 9) ax.plot(tt, r_t_det_diff_bn, color='grey', label='difference') ax.set_ylabel(create_label('$r\hspace{0.3}(\hspace{0.3}t\hspace{0.3})\hspace{1}$ Forward -\n Inverse', 'mm')) ax.set_xlabel('Time (s)') ax.set_title('(i)', loc='center') # SHOW AND SAVE FIGURE plt.tight_layout() plt.savefig(FIG_PATH + DP_SYNTH_FILENAME_EXAMPLE + PLOT_EXTENSION) if show_plot: plt.show()
def test_full_inverse_heating_determine_r(): q = 50 k = 4 r0 = 5.7e-3 r1 = 15e-3 theta_o = 1.0e-3 theta_w = 0.49 theta_m = 1 - theta_o - theta_w C = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) fs = 12 dt = 1 / fs T = 30 t = gen_time_vec(fs, T) t = t[1:] # cannot start with zero n = length(t) r = np.linspace(r0, r1, n) alpha = get_alpha_k_C(k, C) t_heating = 8 th = t_heating # this is the known curve print('Running for different starting r0 values') dT = compute_delta_T_dual_infinite_line_heating(q, k, alpha, r, t) r0v = [4e-3, 5e-3, 5.7e-3, 6e-3] dT_inv_vec = [] for r0_elem in r0v: print('r0_elem = ', r0_elem) r_t_det = dp_model_recomp_heating(fs, q, k, t, dT, r0_elem, get_gamma4=False) dT_inv = compute_delta_T_dual_infinite_line_heating( q, k, alpha, r_t_det, t) dT_inv_vec.append(dT_inv) print('Starting optimization to find the known r') rstart = 1.0e-3 # def _f_obtain_r_from_curve(x, *args): # # UNKNOWN # r0_in = x[0] # # KNOWN # q_in = args[0] # k_in = args[1] # alpha_in = args[2] # t_in = args[3] # fs_in = args[4] # known_in = args[5] # r_t_det = dp_model_recomp_heating(fs, q_in, k_in, t_in, known_in, r0_in, get_gamma4=False) # dT_inv = compute_delta_T_dual_infinite_line_heating(q_in, k_in, alpha_in, r_t_det, t_in) # diff = (known_in - dT_inv)**2 # dsum = np.sum(diff) # return dsum # # use optimization for the starting r # xstart = (rstart,) # args = (q, k, alpha, t, fs, dT) # res = minimize(_f_obtain_r_from_curve, xstart, args, method='Nelder-Mead') # rout = res.x[0] # print('rout = ', rout) # print('r0 = ', r0) # block = True plt.figure() plt.plot(t, dT, linewidth=8) for dT_i in dT_inv_vec: plt.plot(t, dT_i) plt.show(block)
def run_find_hpp_nominal(): """ Do experiment to obtain nominal HPP data :return: """ from calibration_processing import initial_compute_hpp from comparisons import compute_rmse, compute_mb from inverse_model_nominal import obtain_sp_vars_from_curve_min, compute_single_probe_forward_model_min # path = '../hpp-data/hpp-formatted-data/calibration/July-12-2017/' path = '../hpp-data/hpp-formatted-data/sand/July-20-2017/' # path = '../hpp-data/hpp-formatted-data/sand/July-21-2017/' # path = '../hpp-data/hpp-formatted-data/sand/July-26-2017/' # path = '../hpp-data/hpp-formatted-data/peat/July-26-2017/' # path = '../hpp-data/hpp-formatted-data/peat/July-27-2017/' # path = '../hpp-data/hpp-formatted-data/peat/July-30-2017/' # path = '../hpp-data/hpp-formatted-data/peat/July-30-2017/' # path = '../hpp-data/hpp-formatted-data/peat/July-31-2017/' start_string = 'sand-' # start_string = 'cal-' # start_string = 'peat-' downsample = 'dp' filt = 'both' filt_cutoff = 10 # cutoff filter frequency (Hz) fs = 120 # sample rate of device (Hz) fs_down = 12 # downsample frequency (Hz) t_cold = 1 # time of cold sampling at beginning (s) additional_text = '-rep1' r0 = 6e-3 # starting radius (m) # Tikhonov regularization parameter epsilon = 0.0 ############################################################################# q = 45 t_heat = 8 t_total = 3 * SECONDS_IN_MIN # q = 10 # t_heat = 10 * SECONDS_IN_MIN # t_total = 12 * SECONDS_IN_MIN ################################################ # LOAD IN THE COEFFICIENTS USED FOR CALIBRATION AND OBTAIN r_nominal # NOTE that the calibrated r0 is stored in mm, so we need to convert to m to be able to use the data from obtain_load_r0 import SaveLoadR0 sr = SaveLoadR0() sr.load_r0(CONST_PATH + CAL_R0_FILENAME + SAVEZ_EXT) r_nominal = sr.get_r0(q) * 1.0e-3 # r_nominal = 6e-3 # We always use assumed q and use the step detector q use_assumed_q = False use_step_detector_q = True I, Rw, T1, T2, Vout, dV, dac_code, delta_T1, delta_T1_trim, delta_T1_trim_heating, \ delta_T2, delta_T2_trim, num, qav, qprime, step_q_tfirst, step_q_tsecond, t1, t1_trim, \ t1_trim_heating, t2, t2_trim, ypk, t, rmse_q_calc, mb_q_calc, pd_q_calc, t2_trim_heating, \ delta_T2_trim_heating = \ initial_compute_hpp(start_string, additional_text, downsample, filt, filt_cutoff, fs, fs_down, path, q, t_cold, t_heat, t_total, use_assumed_q, use_step_detector_q) dt_sp = t1_trim_heating[1] - t1_trim_heating[0] dt_dp = t2_trim_heating[1] - t2_trim_heating[0] from sp_model_signal import sp_model_signal_inv from curve_time_trim import curve_time_trim from sp_model_signal import sp_model_late_time_inv from inverse_model_nominal import obtain_k_alpha_from_dual_probe from inverse_model_dp_radius import InverseWarmupCurveDP from get_theta_rho import get_theta_rho # heating only for SP t1_trim_heating1, delta_T1_trim_heating1 = curve_time_trim( t1_trim_heating, delta_T1_trim_heating) # heating only for DP t2_trim_heating1, delta_T2_trim_heating1 = curve_time_trim( t2_trim_heating, delta_T2_trim_heating) # heating and cooling for DP t2_trim1, delta_T2_trim1 = curve_time_trim(t2_trim, delta_T2_trim) # SP SIGNAL PROCESSING INVERSE MODEL kdet_sig, bdet = sp_model_signal_inv(delta_T1_trim_heating1, t1_trim_heating1, dt_sp, q, output_model_array=False) # SP inverse model to obtain k via a late-time model tlinear, kout_sp_late_time = sp_model_late_time_inv( delta_T1_trim_heating1, t1_trim_heating1, dt_sp, qav) # Calculate the time at which the heat pulse goes linear relative to the start of the experiment. # This also includes the cold time at the beginning of the experiment (used for graphing). tlinear_from_begin = t_cold + tlinear # SP FORWARD MODELS kd_signal, bd_signal, cd_signal, dd_signal = obtain_sp_vars_from_curve( qav, t1_trim_heating1, delta_T1_trim_heating1, kout_sp_late_time) kd_lt, bd_lt, cd_lt, dd_lt = obtain_sp_vars_from_curve( qav, t1_trim_heating1, delta_T1_trim_heating1, kout_sp_late_time) # SP SYNTHETIC MODELS delta_T_single_synth_signal = compute_single_probe_forward_model( qav, kd_signal, t1_trim_heating1, bd_signal, cd_signal, dd_signal) delta_T_single_synth_late_time = compute_single_probe_forward_model( qav, kd_lt, t1_trim_heating1, bd_lt, cd_lt, dd_lt) # OBTAIN {k, alpha} FROM THE NOMINAL DP MODEL (HEATING AND COOLING) # NOTE THAT THIS REQUIRES AN ESTIMATE OF THE PROBE SPACING RADIUS as r_nominal READ FROM A COEFFICIENT FILE kstart = kd_signal Hstart = 80 k_nom_heat, alpha_nom_heat = obtain_k_alpha_from_dual_probe( q, t2_trim_heating1, t_heat, delta_T2_trim_heating1, kstart, Hstart, r_nominal, full=False) # heat only k_nom_heat_and_cool, alpha_nom_heat_and_cool = obtain_k_alpha_from_dual_probe( qav, t2_trim1, t_heat, delta_T2_trim1, kstart, Hstart, r_nominal, full=True) # heat and cool # OBTAIN {r(t), alpha} FROM THE SIGNAL PROCESSING MODEL # r(t) = r_t_sig as the time-variable radius InvDP = InverseWarmupCurveDP() typ = 'iterative' from scipy.interpolate import spline from scipy.interpolate import UnivariateSpline # s = spline(t2_trim_heating1, delta_T2_trim_heating1, t2_trim_heating1, order=5, kind='smoothest') spl = UnivariateSpline(t2_trim_heating1, delta_T2_trim_heating1) s = spl(t2_trim_heating1) # spline (apply to inverse warmup curve) from deriv_forward_inv import forward_first_derivative sderiv = forward_first_derivative(s, 1 / fs_down) # run a zero crossing detector to determine when sderiv is zero and then cut at that point nn = length(sderiv) ncut = 0 for k in range(nn): if sderiv[k] > 0: ncut = k break ncut += 1 print('ncut = ', ncut) tt_ncut = t2_trim_heating1[ncut + 1:] sderiv_ncut = sderiv[ncut:] tt_cut = tt_ncut[0] # block = True # plt.figure() # # plt.plot(tt_ncut, sderiv_ncut) # plt.plot(t2_trim_heating1[1:], sderiv) # plt.axvline(x=tt_cut) # plt.show(block) scut = s[ncut:] tcut = t2_trim_heating1[ncut:] # scut = s # tcut = t2_trim_heating1 # compute from the inverse warmup curve r0 = 6e-3 alpha_sig, r_t_sig = InvDP.inverse_warmup_curve_dp(kdet_sig, scut, qav, tcut, r_nominal, typ, lowpass=False, epsilon=0.0) # average over r_t_sig from integrate_average import integrate_average r_av = integrate_average(r_t_sig, tcut, 'simpson') # r_av = np.mean(r_t_sig) print('r_av = ', r_av) ############################################################################# # OBTAIN {k, alpha} FROM THE NOMINAL DP MODEL (HEATING AND COOLING) # USE THE r_av FROM SIGNAL PROCESSING kstart = kd_signal Hstart = 80 # r_av = r_nominal print('r_nominal = ', r_nominal) k_sig_heat, alpha_sig_heat = obtain_k_alpha_from_dual_probe( q, t2_trim_heating1, t_heat, delta_T2_trim_heating1, kstart, Hstart, r_av, full=False) # heat only k_sig_heat_and_cool, alpha_sig_heat_and_cool = obtain_k_alpha_from_dual_probe( qav, t2_trim1, t_heat, delta_T2_trim1, kstart, Hstart, r_av, full=True) # heat and cool ############################################################################# # DP SYNTHETICS NOMINAL deltaT_dual_synth_nominal_heat_cool = compute_delta_T_dual_heating_cooling( qav, k_nom_heat, alpha_nom_heat, r_nominal, t2_trim1, t_heat) deltaT_dual_synth_nominal_heating = compute_delta_T_dual_infinite_line_heating( qav, k_nom_heat_and_cool, alpha_nom_heat_and_cool, r_nominal, t2_trim_heating1) # DP SYNTHETIC WITH RADIUS DETERMINED FROM SIGNAL PROCESSING deltaT_dual_syth_variable_radius_heating = compute_delta_T_dual_infinite_line_heating( qav, kdet_sig, alpha_sig, r_av, t2_trim_heating1) # set the organic content theta_o = 9.2e-3 # COMPUTATIONS # {theta_w, rho} for DP (heating) theta_w_heat, rho_heat = get_theta_rho(k_nom_heat, alpha_nom_heat, theta_o) # {theta_w, rho} for DP (heating and cooling) theta_w_heat_cool, rho_heat_cool = get_theta_rho(k_nom_heat_and_cool, alpha_nom_heat_and_cool, theta_o) # SIGNAL PROCESSING (HEAT AND COOL) theta_w_heat_sig, rho_heat_sig = get_theta_rho(kdet_sig, alpha_sig, theta_o) theta_w_heat_cool_sig, rho_heat_cool_sig = get_theta_rho( kdet_sig, alpha_sig, theta_o) # DUAL PROBE # RMSE, MB asnd PD for DP model actual vs synthetic (heating) # RMSE, MB and PD for DP model actual vs synthetic (heating and cooling) # RMSE, MB and PD for DP model actual vs synthetic variable radius (heating only) SIGNAL PROCESSING # SINGLE PROBE # RMSE, MB and PD for SP model actual vs synthetic (late-time) # RMSE, MB and PD for SP model actual vs synthetic (signal processing) # from butterworth_low import butter_lowpass_filter # y = butter_lowpass_filter(delta_T2_trim_heating1, 1, fs, order=5, both=True) # block = False # plt.figure() # plt.plot(t2_trim_heating1, y) # plt.xlabel('Time (s)') # plt.ylabel('delta T2 heating') # plt.legend() # plt.show(block) print('OUTPUTS:') print('kdet_sig (signal processing) = ', kdet_sig) print('tlinear (late-time) = ', tlinear) print('kout_sp_late_time (late-time) = ', kout_sp_late_time) print('') print('k_nom_heat = ', k_nom_heat) print('alpha_nom_heat = ', alpha_nom_heat) print('') print('k_nom_heat_and_cool = ', k_nom_heat_and_cool) print('alpha_nom_heat_and_cool = ', alpha_nom_heat_and_cool) print('') print('alpha_sig (from signal processing with variable radius) = ', alpha_sig) print('THETA AND RHO') print('-----') print('theta_w_heat = ', theta_w_heat) print('rho_heat = ', rho_heat) print('-----') print('theta_w_heat_cool = ', theta_w_heat_cool) print('rho_heat_cool = ', rho_heat_cool) print('----SIGNAL PROCESSING----') print('theta_w_heat_sig = ', theta_w_heat_sig) print('rho_heat_sig = ', rho_heat_sig) print('-----') print('---HEAT AND COOL:---') print('theta_w_heat_cool_sig = ', theta_w_heat_cool_sig) print('rho_heat_cool_sig = ', rho_heat_cool_sig) print('--------------------------') block = False plt.figure() plt.plot(t1_trim_heating1, delta_T1_trim_heating1, label='data') plt.plot(t1_trim_heating1, delta_T_single_synth_signal, label='signal') plt.plot(t1_trim_heating1, delta_T_single_synth_late_time, label='late time') plt.xlabel('Time (s)') plt.ylabel('delta T1 heating SP') plt.legend() plt.show(block) # plt.plot(t2_trim1, delta_T2_trim1, label='data heating and cooling') # plt.plot(t2_trim_heating1, deltaT_dual_synth_nominal_heating, label='heating') # plt.plot(t2_trim1, deltaT_dual_synth_nominal_heat_cool, label='heating and cooling') block = False plt.figure() plt.plot(t2_trim_heating1, delta_T2_trim_heating1, label='data heating') # plt.plot(t2_trim_heating1, deltaT_dual_syth_variable_radius_heating, label='heating (variable radius)') plt.plot(t2_trim_heating1, s, label='heating (variable radius) smooth') plt.legend() plt.xlabel('Time (s)') plt.ylabel('delta T2 heating DP') plt.show(block) block = True plt.figure() plt.plot(tcut, r_t_sig, label='r(t)') plt.legend() plt.xlabel('Time (s)') plt.ylabel('r(t)') plt.show(block)
def check_same_size(a, b, err=''): if length(a) != length(b): raise ValueError(err)
def plot_ei_test(): from ei import ei from get_alpha import get_alpha_k_C from get_volumetric_heat_capacity import get_volumetric_heat_capacity from gen_time_vec import gen_time_vec q = 50 k = 4 r0 = 6.7e-3 r1 = 15e-3 theta_o = 1.0e-3 theta_w = 0.49 theta_m = 1 - theta_o - theta_w C = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) fs = 12 dt = 1 / fs T = 30 t = gen_time_vec(fs, T) t = t[1:] # cannot start with zero n = length(t) r = np.linspace(r0, r1, n) alpha = get_alpha_k_C(k, C) print('alpha = ', alpha) t_heating = 8 th = t_heating dT, heating, cooling, first, second, tvec_heat, tvec_cool, rheat, rcool, ei_term3, ei_term2 = \ compute_delta_T_dual_heating_cooling(q, k, alpha, r, t, t_heating, split=True) # check the recomposition from dp_model_recomp import dp_model_recomp_heating_cooling, dp_model_recomp_heating r_t = dp_model_recomp_heating_cooling(fs, q, k, t, th, dT, r0) r_t_heat = dp_model_recomp_heating(fs, q, k, tvec_heat, heating, r0) block = True plt.figure() plt.plot(t, r_t) plt.plot(t, r) plt.plot(tvec_heat, r_t_heat) plt.show(block) # dT_known = dT # from numpy import pi # from dp_model_recomp import ei_inv_neg_array, ei_inv_cooling # from deriv_forward_inv import forward_first_derivative, inverse_first_derivative # out = np.zeros(n) # term = -(4*pi*k)/q # dt = 1 / fs # nn = int(np.ceil(fs*th)) # tvec_heat = t[:nn] # tvec_cool = t[nn:] # dT_known_heat = dT_known[:nn] # dT_known_cool = dT_known[nn:] # # HEATING # gamma2_heat = term*dT_known_heat # gamma3_heat = ei_inv_neg_array(gamma2_heat) * tvec_heat # gamma4_heat = -gamma3_heat # # COOLING # dT_cool_strip = -term*dT_known_cool # gamma4_cool = ei_inv_cooling(dT_cool_strip, th, tvec_cool) # gamma4 = np.concatenate((gamma4_heat, gamma4_cool)) # AFTER HERE # gamma5 = np.sqrt(gamma4) # gamma6 = np.log(gamma5) # gamma7 = forward_first_derivative(gamma6, dt) # # gamma7_comp = forward_first_derivative(np.log(r), dt) # gamma7_diff = gamma7 - gamma7_comp # # # check the inverse # r0_wanted = 6e-3 # log_r_inv = inverse_first_derivative(gamma7, dt, np.log(r0_wanted)) # r_inv = np.exp(log_r_inv) # # # block = False # plt.figure() # plt.plot(t[1:], gamma7) # plt.plot(t[1:], gamma7_comp) # plt.show(block) # # block = False # plt.figure() # plt.plot(t[1:], gamma7_diff) # plt.show(block) # block = True # plt.figure() # plt.plot(t[1:], linear_test_vec_log_deriv) # plt.plot(t[1:], gamma7) # plt.show(block) # block = True # plt.figure() # plt.plot(t, r_inv) # plt.show(block) from dp_model_recomp import dp_model_recomp_heating_cooling