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 _fp(x, *args): # UNKNOWN r0 = x[0] # r0 as the unknown starting radius alpha = x[1] # as the unknown alpha # KNOWN dT = args[0] # change in temperature k = args[1] # thermal conductivity t = args[2] # time q = args[3] # q t_heating = args[4] # time of heating gamma7 = args[5] # known gamma7 dt = args[6] # timestep # compute the dT for comparison r = inverse_first_derivative(gamma7, dt, np.log(r0)) # compute the forward model dT_comp = compute_delta_T_dual_heating_cooling(q, k, alpha, r, t, t_heating, split=False) # compute the difference diff = (dT_comp - dT)**2 # we want to minimize the sum of squared errors dsum = np.sum(diff) return dsum
def plot_ineq_check(): """ Check the second part of the inequality :return: """ from forward_model_nominal import compute_delta_T_dual_heating_cooling from get_volumetric_heat_capacity import get_volumetric_heat_capacity from gen_time_vec import gen_time_vec from get_alpha import get_alpha_k_C from numpy import pi from ei_inv_cooling import ei_inv_cooling_array r = 6e-3 q = 50.0 k = 5.0 theta_o = 0.01 theta_w = 0.40 theta_m = 1 - theta_o - theta_w c = get_volumetric_heat_capacity(theta_m, theta_o, theta_w) alpha = get_alpha_k_C(k, c) t_heating = 8 th = t_heating T = 30 fs = 120 t = gen_time_vec(fs, T, tstart=0) t = t[1:] dT_hc = compute_delta_T_dual_heating_cooling(q, k, alpha, r, t, t_heating) nn = int(np.ceil(fs * t_heating)) dT_cool = dT_hc[nn:] t_cool = t[nn:] term = (4 * pi * k) / q dT_cool0 = term * dT_cool # this is the input to find the inverse h = (r**2) / (4 * alpha) x = h / (t_cool - th) y = h / t z = np.sqrt((t_cool - th) / t_cool) high = (t_cool - th) * (((1 + z) / z) * (1.0 / dT_cool0)) print('h = ', h) aout = ei_inv_cooling_array(dT_cool0, t_cool, th) print('done inverse') block = False plt.figure() plt.plot(t, dT_hc) plt.plot(t_cool, dT_cool) plt.axvline(x=t_heating) plt.show(block) block = False plt.figure() plt.plot(t_cool, dT_cool0) plt.plot(t_cool, high) plt.show(block) block = True plt.figure() plt.plot(t_cool, aout) plt.show(block)
def _f_obtain_r_from_curve(x, *args): """ Optimization function to obtain r from the curve. NOTE that both the heating and cooling curves are used to obtain the radius. :param x: (r) :param args: (q, k, alpha, t, known) :return: """ # variable to find r = x[0] # known variables q = args[0] k = args[1] alpha = args[2] t = args[3] t_heating = args[4] known = args[5] # compute synthetic deltaT = compute_delta_T_dual_heating_cooling(q, k, alpha, r, t, t_heating) diff = (known - deltaT)**2 dsum = np.sum(diff) return dsum
def run_find_hpp_nominal_test_sig(): """ 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-31-2017/' start_string = 'sand-' # start_string = 'cal-' # start_string = 'sand-' # 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 # sand theta_o = 9.2e-3 # organic content theta_m = 0.59 # mineral content # Cm_set = 1.1e6 # Co_set = 1.0e6 Cm_set = None Co_set = None # peat # theta_o = 0.49 # theta_m = 0.01 ############################################################################# q = 45 t_heat = 8 t_total = 3 * SECONDS_IN_MIN # q = 45 # t_heat = 11 # t_total = 3 * SECONDS_IN_MIN # q = 55 # t_heat = 20 # t_total = 3 * SECONDS_IN_MIN # q = 55 # t_heat = 89 # t_total = 3 * SECONDS_IN_MIN # q = 10 # t_heat = 10 * SECONDS_IN_MIN # t_total = 12 * SECONDS_IN_MIN # q = 20 # t_heat = 89 # t_total = 3 * 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 # We always use the assumed q and 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) th = t_heat kstart = 5 Hstart = 80 k_det, alpha_det = obtain_k_alpha_from_dual_probe(qav, t2_trim1, th, delta_T2_trim1, kstart, Hstart, r_nominal, full=True) dT_synth = compute_delta_T_dual_heating_cooling(qav, k_det, alpha_det, r_nominal, t2_trim1, th, split=False) # from lmfit.models import SkewedGaussianModel # model = SkewedGaussianModel() # params = model.make_params(amplitude=10, center=0, sigma=1, gamma=0) # result = model.fit(delta_T2_trim1, params, x=t2_trim1) # y = result.best_fit from get_max import get_max, get_min idx, m = get_max(dT_synth) print('dt_dp = ', dt_dp) idx_time = dt_dp * idx print('idx = ', idx) print('idx_time = ', idx_time) from deriv_forward_inv import forward_first_derivative dT_deriv = forward_first_derivative(dT_synth, dt_dp) from numerical_derivative import second_derivative_3pt tt, dT_deriv2 = second_derivative_3pt(dT_synth, dt_dp, t2_trim1) # from find_plateau_curvature import obtain_curvature_1d # cc = obtain_curvature_1d(dT_synth, 5, 3, dt_dp) idx_peak, md_peak = get_max(dT_synth) idxd, md = get_min(dT_deriv2) # if idxd > idx_peak: # idxd_found = idxd idxd_found = idx_peak idxd_time = dt_dp * idxd_found # print('idxd_time = ', idxd_time) # print('idxd_time_heat = ', idxd_time + th) # set the trim time at the end # end_trim_time = 40 # only for 21 July end_trim_time = 0 end_cut_num = int(np.floor(fs_down * end_trim_time)) # Cut the sequence at the beginning # cut_time = idxd_time # cut_time = idxd_time cut_time = idxd_time print('cut_time = ', cut_time) cut_num = int(np.floor(fs_down * cut_time)) if end_cut_num > 0: t2_trim1_cut = t2_trim1[cut_num:-end_cut_num] delta_T2_trim1_cut = delta_T2_trim1[cut_num:-end_cut_num] else: t2_trim1_cut = t2_trim1[cut_num:] delta_T2_trim1_cut = delta_T2_trim1[cut_num:] block = False plt.figure() plt.plot(t2_trim1, delta_T2_trim1) plt.plot(t2_trim1, dT_synth) # plt.plot(t2_trim1, y) plt.plot(t2_trim1[1:], dT_deriv) plt.plot(tt, dT_deriv2) # plt.plot(t2_trim1, cc) plt.axvline(cut_time) plt.title('DP heating and cooling') plt.show(block) # obtain the radius from dp_model_recomp import dp_model_recomp_heating, dp_model_recomp_heating_cooling, \ dp_model_recomp_heating_cooling_trim # r_t_heating = dp_model_recomp_heating(fs_down, q, kdet_sig, t2_trim_heating1_cut, delta_T2_trim_heating1_cut, # r_nominal) r_t_heating_cooling, gamma4 = dp_model_recomp_heating_cooling_trim( fs_down, qav, kdet_sig, t2_trim1_cut, th, delta_T2_trim1_cut, r_nominal, get_gamma4=True) # tcut_heat = 7.0 # cut_num_heat = int(np.floor(fs_down * tcut_heat)) # r_t_heating, gamma4_heating = dp_model_recomp_heating(fs_down, qav, kdet_sig, t2_trim_heating1[1:], # delta_T2_trim_heating1[1:], r_nominal, get_gamma4=True) # compute alpha alpha = (r_t_heating_cooling**2) / (4.0 * gamma4) alpha_sig = np.mean(alpha) print('k_det = ', k_det) print('alpha_det = ', alpha_det) print('kdet_sig = ', kdet_sig) print('alpha_sig = ', alpha_sig) print('alpha = ', alpha_sig) theta_w_var, rho_nom_var = get_theta_rho(k_det, alpha_det, theta_o, theta_m, Cm_set, Co_set) theta_w_sig, rho_w_sig = get_theta_rho(kdet_sig, alpha_sig, theta_o, theta_m, Cm_set, Co_set) print('------------------------------') print('theta_w_var = ', theta_w_var) print('rho_nom_var = ', rho_nom_var) print('------------------------------') print('theta_w_sig = ', theta_w_sig) print('rho_w_sig = ', rho_w_sig) print('------------------------------') # TEST THE INVERSE print('testing the inverse') from recomp_theta_rho import recomp_theta_rho_additional theta_w_var, rho_nom_var, theta_w_sig, rho_w_sig, \ t2_trim1, delta_T2_trim1, dT_synth_nom, dT_synth_sig, \ cut_time, t2_trim1_cut, r_t_heating_cooling, \ alpha_det, alpha_sig, k_det, kdet_sig, \ t1_trim_heating1, delta_T1_trim_heating1, dT_synth_sp, \ delta_T1_trim, t1_trim, qav = \ recomp_theta_rho_additional(path, start_string, additional_text, q, t_heat, t_total, end_trim_time) print('done testing') print('------------------------------') print('theta_w_var = ', theta_w_var) print('rho_nom_var = ', rho_nom_var) print('------------------------------') print('theta_w_sig = ', theta_w_sig) print('rho_w_sig = ', rho_w_sig) print('------------------------------')
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
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 recomp_theta_rho_additional(path, start_string, additional_text, q, t_heat, t_total, end_trim_time, trim_sp_begin=0, r_nominal=None, theta_o=None, theta_m=None, add_time_after_max=None): """ Open a file and recompose theta, rho and other inputs :param path: as the path where to do the processing :param start_string: as the starting string of the file :param additional_text: as the additional text at the end :param q: as the heat input into the soil :param t_heat: as the time of heating :param t_total: as the total time :param end_trim_time: as the time to trim at the beginning of the sequence :param trim_sp_begin: as the number of points to trim at the beginning of the SP sequence for inverse model :param r_nominal: as the nominal radius (to override the calibrated radius) :param theta_o: fraction of organic content in the soil :param theta_m: fraction of mineral content in the soil :param: add_time_after_max: time to cut the curve after the maximum :return: """ downsample = 'dp' filt = 'both' filt_cutoff = DP_LOWPASS_FILTER_CUT fs = FS_SAMPLE fs_down = FS_DOWN_DP t_cold = T_COLD_BEGIN if add_time_after_max is None: add_time_after_max = NOM_TIME_ADD_AFTER_MAX sr = SaveLoadR0() sr.load_r0(CONST_PATH + CAL_R0_FILENAME + SAVEZ_EXT) if r_nominal is None: r_nominal = sr.get_r0(q) * 1.0e-3 # set whether we are dealing with sand or peat if 'sand' in start_string: Cm_set = None Co_set = None if theta_o is None: theta_o = theta_o_sand if theta_m is None: theta_m = theta_m_sand elif 'peat' in start_string: Cm_set = Cm_peat Co_set = Co_peat if theta_o is None: theta_o = theta_o_peat if theta_m is None: theta_m = theta_m_peat else: raise ValueError( 'recomp_theta_rho_additional: start_string must contain sand or peat' ) 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, return_q_full=False) dt_sp = t1_trim_heating[1] - t1_trim_heating[0] dt_dp = t2_trim_heating[1] - t2_trim_heating[0] t1_trim_heating1, delta_T1_trim_heating1 = curve_time_trim( t1_trim_heating, delta_T1_trim_heating) t2_trim_heating1, delta_T2_trim_heating1 = curve_time_trim( t2_trim_heating, delta_T2_trim_heating) t2_trim1, delta_T2_trim1 = curve_time_trim(t2_trim, delta_T2_trim) kdet_sig, _bdet = sp_model_signal_inv( delta_T1_trim_heating1[trim_sp_begin:], t1_trim_heating1[trim_sp_begin:], dt_sp, qav, output_model_array=False) tlinear, kdet_linear = sp_model_late_time_inv(delta_T1_trim_heating1, t1_trim_heating1, dt_sp, qav, entire_heating_time=False, return_all=False) th = t_heat kstart = 5 Hstart = 80 k_det, alpha_det = obtain_k_alpha_from_dual_probe(qav, t2_trim1, th, delta_T2_trim1, kstart, Hstart, r_nominal, full=True) dT_synth_nom = compute_delta_T_dual_heating_cooling(qav, k_det, alpha_det, r_nominal, t2_trim1, th, split=False) k_out_sp, b_out_sp, c_out_sp, d_out_sp = obtain_sp_vars_from_curve( qav, t1_trim_heating1, delta_T1_trim_heating1, kdet_sig) dT_synth_sp = compute_single_probe_forward_model(qav, k_out_sp, t1_trim_heating1, b_out_sp, c_out_sp, d_out_sp, constrain=True) idx_peak, md_peak = get_max(dT_synth_nom) idxd_found = idx_peak idxd_time = dt_dp * idxd_found end_cut_num = int(np.floor(fs_down * end_trim_time)) cut_time = idxd_time + add_time_after_max # time when the curve needs to be cut (can also be negative) cut_num = int(np.floor(fs_down * cut_time)) if end_cut_num > 0: t2_trim1_cut = t2_trim1[cut_num:-end_cut_num] delta_T2_trim1_cut = delta_T2_trim1[cut_num:-end_cut_num] else: t2_trim1_cut = t2_trim1[cut_num:] delta_T2_trim1_cut = delta_T2_trim1[cut_num:] r_t_heating_cooling, gamma4 = dp_model_recomp_heating_cooling_trim( fs_down, qav, kdet_sig, t2_trim1_cut, th, delta_T2_trim1_cut, r_nominal, get_gamma4=True) alpha_vec = (r_t_heating_cooling**2) / (4.0 * gamma4) alpha_sig = np.mean(np.abs(alpha_vec)) theta_w_nom, rho_nom = get_theta_rho(k_det, alpha_det, theta_o, theta_m, Cm_set, Co_set) theta_w_sig, rho_sig = get_theta_rho(kdet_sig, alpha_sig, theta_o, theta_m, Cm_set, Co_set) dT_synth_sig = compute_delta_T_dual_heating_cooling(qav, kdet_sig, alpha_sig, r_nominal, t2_trim1, th, split=False) """ theta_w_nom water content from nominal heating and cooling curve-fitting rho_nom density from nominal heating and cooling curve-fitting theta_w_sig water content from signal processing rho_w_sig density from signal processing t2_trim1 time vector for DP experiment delta_T2_trim1 temperature difference vector for DP experiment dT_synth_nom synthetic curve for DP using nominal method dT_synth_sig synthetic curve for DP using signal processing cut_time time when sequence is cut t2_trim1_cut cut time sequence for heating and cooling r_t_heating_cooling r(t) for heating and cooling determined over cut time alpha_det alpha from DP curve-fitting alpha_sig alpha from signal processing k_det thermal conductivity from curve-fitting kdet_sig thermal conductivity from signal processing t1_trim_heating1 trimmed SP time vector delta_T1_trim_heating1 trimmed SP time heating vector dT_synth_sp synthetic model from single probe delta_T1_trim change in temperature of SP t1_trim time vector associated with SP tlinear time at which curve becomes linear kdet_linear k detected using linear algorithm """ return theta_w_nom, rho_nom, theta_w_sig, rho_sig, \ t2_trim1, delta_T2_trim1, dT_synth_nom, dT_synth_sig, \ cut_time, t2_trim1_cut, r_t_heating_cooling, \ alpha_det, alpha_sig, k_det, kdet_sig, \ t1_trim_heating1, delta_T1_trim_heating1, dT_synth_sp, \ delta_T1_trim, t1_trim, \ tlinear, kdet_linear, qav