def col_dens_hc3n_err(Tex, tau, dtex, dtau): """ """ #EJ is EJ/k Ej = 19.6484 R = 1 c = 2.98e10 #cm s-1 pi = 3.141516 k = 1.38 * 1e-16 #erg K-1 h = 6.626 * 1e-27 #erg s nu = 91.199796e9 Tbg = 2.73 Tex = unumpy.uarray(Tex, dtex) tau = unumpy.uarray(tau, dtau) Qrot = ((k * Tex) / (h * 4.5490586e9)) + 1 / 3. gu = 21.0 aul = 58.13e-6 a1 = (8 * pi * nu**3) / ((c**3) * R) a2 = Qrot / (gu * aul) a3 = unumpy.exp(Ej / Tex) / (1 - unumpy.exp(-h * nu / (k * Tex))) a4 = 1 / (jota2(Tex, nu) - jota2(Tbg, nu)) a5 = tau #where tau=integral (tau dv) return a1 * a2 * a3 * a4 * a5
def col_dens_cch_err(Tex, tau, dtex, dtau, optthin=False): """ C2H(1-0) see col_dens_cch """ #EJ is EJ/k Ej = 0.00216 nu = 87.316925e9 R = 5 / 12. c = 2.98e10 #cm s-1 pi = 3.141516 k = 1.38 * 1e-16 #erg K-1 h = 6.626 * 1e-27 #erg s Tbg = 2.73 Tex = unumpy.uarray(Tex, dtex) tau = unumpy.uarray(tau, dtau) Qrot = ((k * Tex) / (h * 43.674518e9)) + 1 / 3. gu = 5.0 aul = 1.52757e-6 a1 = (8 * pi * (nu**3)) / ((c**3) * R) a2 = Qrot / (gu * aul) a3 = unumpy.exp(Ej / Tex) / (1 - unumpy.exp(-h * nu / (k * Tex))) if optthin == True: a4 = tau / ( jota2(Tex, nu) - jota2(Tbg, nu) ) #asuming optically thin, prob best to calculate tau form hyperfine else: a4 = tau #where tau=integral (tau dv) return a1 * a2 * a3 * a4
def unfunc(x, a, b, c): lock_effect = lock * np.heaviside( x - lock_start, 0.5) * (x - lock_start) + amp * (unp.cos( (x - ph) * (1 / 365) * math.pi * 2) - 1) lock_effect += np.exp(-vacc_const * (x**2)) return a * unp.exp((b) * x + lock_effect) + c * unp.exp( (b + mut_effect) * x + lock_effect)
def col_dens_hnco_err(Tex, tau, dtex, dtau): """ Returns the column density (Garden et al 1991) From sanhueza 2012, and references therein Tex: Excitation temperature tau=integral of the opacity (\int tau dv) nu=frequeancy in Hz Asumin R=1 which is diferent only for molecules with hyperfine structure """ #EJ is EJ/k nu = 87.925252e9 Ej = 6.32957 R = 1 c = 2.98e10 #cm s-1 pi = 3.141516 k = 1.38 * 1e-16 #erg K-1 h = 6.626 * 1e-27 #erg s Tbg = 2.73 Tex = unumpy.uarray(Tex, dtex) tau = unumpy.uarray(tau, dtau) Qrot = unumpy.sqrt((pi * ((Tex * k)**3)) / ((h**3) * 918.417805e9 * 11.071010e9 * 10.910577e9)) gu = 9.0 aul = 8.78011e-6 a1 = (8 * pi * (nu**3)) / ((c**3) * R) a2 = Qrot / (gu * aul) a3 = unumpy.exp(Ej / Tex) / (1 - unumpy.exp(-(h * nu) / (k * Tex))) a4 = 1 / (jota2(Tex, nu) - jota2(Tbg, nu)) a5 = tau #where tau=integral (tau dv) return a1 * a2 * a3 * a4 * a5
def countRR(orig_df, mu_df, **kwargs): """ Assumption: One does not measure an isotope after 10 half-lives. Therefore we calculate delta_t and compare it with half-lives. If delta_t < 10HL => select df[Half-life] > 0.1 delta_t """ AVOGADRO = float(6.02214076e+23) orig_df["Half-life [s]"] = orig_df[["Half-life [s]", "sigm_Half-life [s]" ]].apply(uncert_series, axis=1) orig_df["sigm_Area"] = 0.01 * orig_df["Area"] * orig_df["%err"] orig_df["Area"] = orig_df[["Area", "sigm_Area"]].apply(uncert_series, axis=1) orig_df["Ig"] = orig_df[["Ig", "sigm_Ig"]].apply(uncert_series, axis=1) irr_start = pd.to_datetime(kwargs["irradiation_start"], dayfirst=True) t_irr = parse_time_unc(kwargs["irradiation_time"]) acq_started = pd.to_datetime(orig_df["Acquisition Started"][0], dayfirst=True) delta_t = (acq_started - irr_start).total_seconds() - t_irr T_LOW = 0.1 * delta_t T_HIGH = 6e+6 df = orig_df[(orig_df["Half-life [s]"] > T_LOW) & (orig_df["Half-life [s]"] < T_HIGH)] lines_df = orig_df[orig_df["E_tab"].isna()] df_high = orig_df[(orig_df["Half-life [s]"] >= T_HIGH)] mu = get_mu_col(df["Energy"], mu_df) mu = mu.astype(np.float64) rho = ufloat_fromstr(kwargs['foil_material_rho']) d = ufloat_fromstr(kwargs['foil_thickness']) k = (mu * rho * d) / (1 - unp.exp(-mu * rho * d)) lam = np.log(2) / df["Half-life [s]"] mass = ufloat_fromstr(kwargs['foil_mass']) molar_mass = ufloat_fromstr(kwargs['foil_material_molar_mass']) N = mass * AVOGADRO / molar_mass real_time = lines_df['Real Time'][0] live_time = lines_df['Live Time'][0] nom = ((real_time / live_time) * k * lam * df["Area"]) denom = (N * (1 - unp.exp(-lam * t_irr)) * unp.exp(-lam * delta_t) * (1 - unp.exp(-lam * real_time)) * df["eps"] * df["Ig"]) df["RR"] = nom / denom df["RR_fiss_prod"] = (2 / df["fiss_yield"]) * df["RR"] print("Reaction rates counted successfully.") df = df.append(lines_df) df = df.append(df_high) df = df.sort_values(by=["Energy", "Channel", "Ig [%]"], ascending=[True, True, False]) return df
def Gompertz(x, xp): if certain: y_pred = np.exp(-x[2] * xp) * x[1] * -1 y_pred = x[0] * np.exp(y_pred) else: y_pred = unp.exp(-x[2] * xp) * x[1] * -1 y_pred = x[0] * unp.exp(y_pred) return y_pred
def ExtremeValue(param, xp): if certain: y_pred = -np.exp(param[2] + param[1] * xp) y_pred = param[0] * (1 - np.exp(y_pred)) else: y_pred = -unp.exp(param[2] + param[1] * xp) y_pred = param[0] * (1 - unp.exp(y_pred)) return y_pred
def f_unc(x, A1, x01, sig1, A2, x02, sig2, offset): """ similar to the raw function call, but uses unp instead of np for uncertainties calculations. :return: """ return offset + A1 * unp.exp(-(x - x01)**2 / (2 * sig1**2)) + A2 * unp.exp(-(x - x02)**2 / (2 * sig2**2))
def logistic_2(param, xp): if certain: y_pred = -1 + ((1 + param[0]) * np.exp(param[1] * xp)) / ( param[0] + np.exp(param[1] * xp)) else: y_pred = -1 + ((1 + param[0]) * unp.exp(param[1] * xp)) / ( param[0] + unp.exp(param[1] * xp)) return y_pred
def OH_from_TeO3(fluxes, Te=None): ''' Again, translated from Miguel's code. ''' if Te is None: Te = Te_O3(fluxes['OIII4363'], fluxes['OIII4959'], fluxes['OIII5007'], fluxes['Hbeta']) if not 'Te4' in Te.columns: Te['Te4'] = Te['Te'] * 1.e4 Oplus = 7.34e-7 * (fluxes['OII3726'] + fluxes['OII3729'])/fluxes['Hbeta']\ * unp.exp(3.9/Te['Te4']) O2plus = (1.3e-6 / Te['Te4']**0.38) * unp.exp(2.9/Te['Te4'])\ * 4.2 * fluxes['OIII4959']/fluxes['Hbeta'] return 12. + unp.log10(Oplus + O2plus)
def calculate_convoled_population(t): """ Calculates the population at any given time t when a non-flash irradiation schedule is used, generated using irradiation duration a={} seconds """.format(a) vector_uncollapsed = ary([ +unpy.exp( -ary([l * np.clip(t - a, 0, None) for l in decay_constants])), -unpy.exp(-ary([l * np.clip(t, 0, None) for l in decay_constants])) ], dtype=object) vector = np.sum(vector_uncollapsed, axis=0) return premultiplying_factor * (multiplying_factors @ vector)
def col_dens_gralmol_err(Qrot, gu, aul, Ej, Tex, tau, nu, dtex, dtau, R=1, nutb=True): """ Returns the column density of a linear , rigid roto molecule (Garden et al 1991) From sanhueza 2012, and references therein Qrot: Partition function gu: Statistical weight of the upper level aul: Eistein coefficient for spontaneous emission Tex: Excitation temperature R=relative intensity of the brightest hyperfine transition, it is 1 if the moel dont have hyperfine. N2H+=5/9. ; C2H=5/12. tau=integral of the opacity (\int tau dv) nu=frequeancy in Hz nutb=True mean use the case of optically thin assumption . """ #EJ is EJ/k #Ej=0.00216 R = 1 c = 2.98e10 #cm s-1 pi = 3.141516 k = 1.38 * 1e-16 #erg K-1 h = 6.626 * 1e-27 #erg s Tbg = 2.73 Tex = unumpy.uarray(Tex, dtex) tau = unumpy.uarray(tau, dtau) a1 = (8 * pi * nu**3) / ((c**3) * R) a2 = Qrot / (gu * aul) a3 = unumpy.exp(Ej / Tex) / (1 - unumpy.exp(-h * nu / (k * Tex))) if nutb == True: a4 = tau * (1 / (jota2(Tex, nu) - jota2(Tbg, nu)) ) #where tau=integral (tb dv) else: a4 = tau #where tau=integral (tau dv) return a1 * a2 * a3 * a4
def get_oddsratio_file(datanum, iteration): lls, ells = scale_ll(datanum, iteration) lls = unp.uarray(lls, ells) # compute odd ratios numerator, denominator = np.zeros(3), np.zeros(3) median_ratio, sigma_ratio = np.zeros(3), np.zeros(3) for i in range(3): numerator[i], denominator[i] = i + 1, i try: log10_oddsratio = unp.log10(unp.exp(lls[i + 1] - lls[i])) except ValueError: log10_oddsratio = unp.uarray(-np.inf, np.nan) median_ratio[i], sigma_ratio[i] = unp.nominal_values(log10_oddsratio), \ unp.std_devs(log10_oddsratio) # create odds ratio files f = open( 'Cloutier/TimeSeriesCV/oddsratio_%.4d%s.txt' % (datanum, iteration), 'w') g = '# Number of lnL evaluations, planet model denominator, planet model numerator, mode log10(odds ratio), median log10(odds ratio), minus 2 sigma (not used), minus 1 sigma, plus 1 sigma, plus 2 sigma (not used)' for i in range(3): g += '\n1.6E+07,%i,%i,%.6f,%.6f,NaN,%.6f,%.6f,NaN' % ( denominator[i], numerator[i], median_ratio[i], median_ratio[i], sigma_ratio[i], sigma_ratio[i]) g = g.replace('nan', 'NaN') f.write(g) f.close()
def fit_stretched_exp(x, y, yerr, xlong): start = time.time() p0 = (-1.5, 100, 0.15, 2) p, cov = curve_fit(func_stretched_exp, x, y, p0=p0, sigma = yerr, maxfev = 100000) print(p) perr = np.sqrt(np.diag(cov)) yfit = func_stretched_exp(x, p[0], p[1], p[2], p[3]) resid = y-yfit dof = y.size - len(p) chi2 = np.sum((resid/yerr)**2) chi2red = chi2/dof p_val = 1 - stats.chi2.cdf(chi2,dof) yfit = func_stretched_exp(xlong, p[0], p[1], p[2], p[3]) p = unumpy.uarray(p,perr) extrapolate_val = p[0]*unumpy.exp(-(extrapolate_times/p[1])**p[2])+p[3] if p[2]>0: extrap_inf = p[3] elif p[2]<0: extrap_inf = p[0]+p[3] end = time.time() elapsed = end-start return (chi2red, resid, extrapolate_val, extrap_inf, 1, unumpy.nominal_values(p), unumpy.std_devs(p), yfit, elapsed, p_val)
def NegativeExponential(param, xp): if certain: y_pred = param[0] * (1 - np.exp(-param[1] * (-param[2] + xp))) else: y_pred = param[0] * (1 - unp.exp(-param[1] * (-param[2] + xp))) return y_pred
def correct_attentuation(scan_list): """ Correct the attentuation level between a a series of elements in lists. Args: scans (:py:attr:`list` of :py:class:`islatu.refl_data.Scan`): Reflectometry scans. Returns: :py:attr:`list` of :py:class:`islatu.refl_data.Scan`: Reflectometry scans with attenuation corrected. """ for i in range(len(scan_list) - 1): overlap_start = scan_list[i + 1].q[0].n overlap_end = scan_list[i].q[-1].n if overlap_start > overlap_end: warnings.warn('Using extrapolation to correct attenuation between ' 'scans {} and {}. Please double check these ' 'results.'.format(scan_list[i].file_path, scan_list[i + 1].file_path)) overlap_start_index = -2 overlap_end_index = 1 else: overlap_start_index = np.argmin( np.abs(scan_list[i].q - overlap_start)) overlap_end_index = np.argmin( np.abs(scan_list[i + 1].q - overlap_end)) res = linregress( unp.nominal_values(scan_list[i].q[overlap_start_index:]), np.log(unp.nominal_values(scan_list[i].R[overlap_start_index:]))) target_r = unp.exp(scan_list[i + 1].q[:overlap_end_index + 1] * res.slope + res.intercept) vary_r = scan_list[i + 1].R[:overlap_end_index + 1] ratio = target_r.mean() / vary_r.mean() scan_list[i + 1].R *= ratio return scan_list
def evaluate(energy, index, amplitude, reference, ecut): pwl = amplitude * (energy / reference) ** (-index) try: cutoff = np.exp((reference - energy) / ecut) except AttributeError: from uncertainties.unumpy import exp cutoff = exp((reference - energy) / ecut) return pwl * cutoff
def evaluate(energy, index, amplitude, reference, ecut): pwl = amplitude * (energy / reference)**(-index) try: cutoff = np.exp((reference - energy) / ecut) except AttributeError: from uncertainties.unumpy import exp cutoff = exp((reference - energy) / ecut) return pwl * cutoff
def Weibull(param, xp): if certain: y_pred = -param[1] * (xp**param[2]) y_pred = param[0] * (1 - np.exp(y_pred)) else: y_pred = -param[1] * (xp**param[2]) y_pred = param[0] * (1 - unp.exp(y_pred)) return y_pred
def logistic(x, xp): if certain: y_pred = np.exp(-x[1] * (-x[2] + xp)) y_pred = x[0] / (1 + y_pred) else: y_pred = unp.exp(-x[1] * (-x[2] + xp)) y_pred = x[0] / (1 + y_pred) return y_pred
def vonBertalanffy(x, xp): if certain: y_pred = 1 - np.exp(-x[1] * (-x[2] + xp)) y_pred = x[0] * (y_pred**3) else: y_pred = 1 - unp.exp(-x[1] * (-x[2] + xp)) y_pred = x[0] * (y_pred**3) return y_pred
def monomolecular(x, xp): if certain: y_pred = np.exp(-x[1] * xp) y_pred = x[0] * (1 - x[2] * y_pred) else: y_pred = unp.exp(-x[1] * xp) y_pred = x[0] * (1 - x[2] * y_pred) return y_pred
def evaluate(energy, index, amplitude, reference, lambda_): """Evaluate the model (static function).""" pwl = amplitude * (energy / reference)**(-index) try: cutoff = np.exp(-energy * lambda_) except AttributeError: from uncertainties.unumpy import exp cutoff = exp(-energy * lambda_) return pwl * cutoff
def exp_func(x, c): """ An exponential decay function: f(x) = exp(-c*x) """ if isinstance(c, unc.UFloat): return unp.exp(-c * x) else: return np.exp(-c * x)
def calculate_population(t): vector = ( unpy.exp(-ary(decay_constants) * max(0, t)) # -unpy.exp(-ary(decay_constants)*(c-a)) # -unpy.exp(-ary(decay_constants)*b) # +unpy.exp(-ary(decay_constants)*(b-a)) ) return premultiplying_factor * (multiplying_factors @ vector ) # sum across rows
def ChapmanRichards(x, xp): if certain: y_pred = 1 - np.exp(-x[1] * xp) y_pred = x[0] * (y_pred**x[2]) else: y_pred = 1 - unp.exp(-x[1] * xp) y_pred = x[0] * (y_pred**x[2]) return y_pred
def evaluate(energy, index, amplitude, reference, lambda_): """Evaluate the model (static function).""" pwl = amplitude * (energy / reference) ** (-index) try: cutoff = np.exp(-energy * lambda_) except AttributeError: from uncertainties.unumpy import exp cutoff = exp(-energy * lambda_) return pwl * cutoff
def func_err_prop(func, x, p): if func == func_log: # return p[0]*unumpy.log((extrapolate_times + 1 +p[1])) + p[2] return p[0] * unumpy.log(extrapolate_times / p[1] + 1) + p[2] if func == func_power: return p[0] * (extrapolate_times + p[2])**p[1] if func == func_stretched_exp: return p[0] * unumpy.exp(-(extrapolate_times / p[1])**p[2]) + bo else: sys.exit("Error")
def f_unc(x, k, weight): """ similar to the raw function call, but uses unp instead of np for uncertainties calculations. :return: """ term = 1 # calculate the term k^x / x!. Can't do this directly, x! is too large. for n in range(0, int(x)): term *= k / (x - n) * unp.exp(-k / int(x)) return term * weight
def evaluate(energy, amplitude, reference, ecut, index_1, index_2): pwl = amplitude * (energy / reference)**(-index_1) try: cutoff = np.exp((reference / ecut)**(index_2) - (energy / ecut)**(index_2)) except AttributeError: from uncertainties.unumpy import exp cutoff = exp((reference / ecut)**(index_2) - (energy / ecut)**(index_2)) return pwl * cutoff
def disc_arm_number(self, y=1, X=1.5): R_d = self.baryonic_scalelength() a = unp.exp(2 * y) / X d = (y**2 / 2) * ((3 * (I(1, y) * K(0, y)) - 3 * (I(0, y) * K(1, y)) + (I(1, y) * K(2, y)) - (I(2, y) * K(1, y)))) e = (4 * y) * (I(0, y) * K(0, y) - (I(1, y) * K(1, y))) self.m_disc = np.array(a * (d + e)) return self.m_disc
def hernquist_arm_number(self,y=1,X=1.5): M_d = self.M_disc + self.M_hi R_d = self.baryonic_scalelength() M_h = self.M_halo_hernquist() a_h = self.R_halo()[0] a = unp.exp(2*y)/X c = (M_h/M_d) * ((2*y + (3*a_h/R_d)) / (2*y + (a_h/R_d))**3) self.m_hernquist = a * c return self.m_hernquist
def func_err_prop(func, x,p): if func == func_log: # return p[0]*unumpy.log((extrapolate_times + 1 +p[1])) + p[2] return p[0]*unumpy.log(extrapolate_times/p[1] + 1 ) + p[2] if func == func_power: return p[0]*(extrapolate_times+p[2])**p[1] if func == func_stretched_exp: return p[0]*unumpy.exp(-(extrapolate_times/p[1])**p[2]) + bo else: sys.exit("Error")
def bulge_arm_number(self,y=1,X=1.5): M_b = self.M_bulge a_b = self.R_bulge M_d = self.M_disc + self.M_hi R_d = self.baryonic_scalelength() a = unp.exp(2*y)/X b = (M_b/M_d) * ((2*y + (3*a_b/R_d)) / (2*y + (a_b/R_d))**3) self.m_bulge = a * b return self.m_bulge
def func_err_prop(func, x,p): if func == func_log: return p[0]*unumpy.log(extrapolate_times + 1 + p[1]) + p[2] if func == func_2log: return p[0]*unumpy.log(extrapolate_times + 1 + p[1]) +\ p[2]*unumpy.log(extrapolate_times + 1 +p[1]) + p[3] if func == func_stretched_exp: return p[0]*unumpy.exp(-(extrapolate_times/p[1])**p[2])+p[3] if func == func_stretched_exp_assume: return p[0]*unumpy.exp(-(extrapolate_times/p[1])**u)+p[2] if func == func_double_log: return p[0]*unumpy.log(1+unumpy.log(x+1+p[1]))+p[2] if func == func_2stretched_exp: return p[0]*unumpy.exp(-(x/p[1])**p[2])+p[3]*unumpy.exp(-(x/p[4])**p[5]) + p[6] # if func == func_vortex: # return p[0]/((1 + p[1]*p[2]*unumpy.log(x/p[3]+p[4]+1))**(1/p[2])) if func == func_vortex: return (p[0] + p[1]*unumpy.log(x+p[2]+1))**(-1/p[3]) else: sys.exit("Error")
def evaluate(energy, amplitude, reference, ecut, index_1, index_2): """Evaluate the model (static function).""" pwl = amplitude * (energy / reference) ** (-index_1) try: cutoff = np.exp((reference / ecut) ** (index_2) - (energy / ecut) ** (index_2)) except AttributeError: from uncertainties.unumpy import exp cutoff = exp((reference / ecut) ** (index_2) - (energy / ecut) ** (index_2)) return pwl * cutoff
def reaction2Keq(reaction_list): ''' Calculates the equilibrium constants of a reaction, using dG0. Arguments: List of cobra model reaction objects Returns: Array of K-equilibrium values ''' dG0_prime = reaction2dG0(reaction_list) Keq = unumpy.exp( -dG0_prime / (R*default_T) ) return Keq
V_grenz_1 = V_1[0] / np.sqrt(2) V_grenz_2 = V_2[0] / np.sqrt(2) V_grenz_3 = V_3[0] / np.sqrt(2) V_grenz_4 = V_4[0] / np.sqrt(2) V_grenz_1_log = unp.log(V_grenz_1) + 0 V_grenz_2_log = unp.log(V_grenz_2) + 0 V_grenz_3_log = unp.log(V_grenz_3) + 0 V_grenz_4_log = unp.log(V_grenz_4) + 0 nu_grenz_1_log = ( V_grenz_1_log - popt_1[1] ) / popt_1[0] nu_grenz_2_log = ( V_grenz_2_log - popt_2[1] ) / popt_2[0] nu_grenz_3_log = ( V_grenz_3_log - popt_3[1] ) / popt_3[0] nu_grenz_4_log = ( V_grenz_4_log - popt_4[1] ) / popt_4[0] nu_grenz_1 = unp.exp(nu_grenz_1_log) + 0 nu_grenz_2 = unp.exp(nu_grenz_2_log) + 0 nu_grenz_3 = unp.exp(nu_grenz_3_log) + 0 nu_grenz_4 = unp.exp(nu_grenz_4_log) + 0 print("nu1 = " + str(nu_grenz_1)) print("nu2 = " + str(nu_grenz_2)) print("nu3 = " + str(nu_grenz_3)) print("nu4 = " + str(nu_grenz_4)) with open('build/a_nu_1.tex', 'w') as f: f.write(r'\SI{{{:L}}}{{\hertz}}'.format(nu_grenz_1)) with open('build/a_nu_2.tex', 'w') as f: f.write(r'\SI{{{:L}}}{{\kilo\hertz}}'.format(nu_grenz_2 / 1e3 )) with open('build/a_nu_3.tex', 'w') as f: f.write(r'\SI{{{:L}}}{{\kilo\hertz}}'.format(nu_grenz_3 / 1e3 ))
def main(): data = pd.read_csv( 'build/data_corrected.csv', skiprows=(1, 2, 3, 4, 5), ) data = data.query('T > 255') func = lambda x, a, b: linear(x, a, b, x0=data['t'].mean()) params, cov = curve_fit(func, data['t'], data['T']) heating_rate, _ = unc.correlated_values(params, cov) heating_rate *= u.kelvin / u.minute print('Rate = {}'.format(heating_rate)) # fit activaiton energy T_max = data['T'][data['I_corrected'].argmax()] * u.kelvin print('T_max = {} '.format(T_max)) data = data.drop_duplicates(subset=['T']) f = partial(diese_funktion_aus_der_anleitung, data=data, T_star=310) data['activation'] = data.apply(f, axis=1) data = data.replace([np.inf, -np.inf], np.nan).dropna() data['T_inv'] = 1 / data['T'] # data = data.query('(T > 275)') fit_data = data.query('(0.00343 < T_inv < 0.00371)') ignored_data = data[~data.index.isin(fit_data.index)] func = partial(linear, x0=fit_data['T_inv'].mean()) params, cov = curve_fit( func, fit_data['T_inv'], fit_data['activation'], ) a, b = unc.correlated_values(params, cov) print(a, b) W = a * u.kelvin * u.boltzmann_constant print('Activation Energy {} / {}'.format( W.to(u.joule), W.to(u.eV)) ) tau_T_max = ( ((u.boltzmann_constant * T_max**2) / (W * heating_rate)) * unp.exp((- W / (const.k * (u.joule / u.kelvin) * T_max)).to_base_units().magnitude) ) print(tau_T_max.to(u.second)) tau_0 = ( tau_T_max / unp.exp(W.to(u.joule).magnitude / (const.k * T_max.magnitude)) ) print('Tau 0 : {}'.format(tau_0.to(u.second))) with open('build/activation_work_2.tex', 'w') as f: f.write('W = ') f.write(SI(W.to('J').magnitude, r'\joule')) f.write(' = ') f.write(SI(W.to('eV').magnitude, r'\electronvolt')) with open('build/tau.tex', 'w') as f: f.write('\\tau(T_{max}) = ') f.write(SI(tau_T_max.to('s').magnitude, r'\second')) with open('build/tau_0.tex', 'w') as f: f.write('\\tau_0 = ') f.write(SI(tau_0.to('s').magnitude, r'\second')) plt.figure() plt.plot(fit_data['T_inv'], fit_data['activation'], '+', ms=4) plt.plot( ignored_data['T_inv'], ignored_data['activation'], '+', ms=4, color='#626262', ) plt.plot( fit_data['T_inv'], func(fit_data['T_inv'], *params), color='darkgray', ) plt.xlabel(r'$T^{-1} \mathrel{/} \si{\per\kelvin}$') plt.ylabel(r"$\ln{\frac{\int_T^{T'}i(T)\dif{T'}}{i(T)τ_0}}$") plt.tight_layout(pad=0) plt.savefig('build/method2.pdf') plt.figure() T = np.linspace(data['T'].min(), data['T'].max(), 1000) plt.plot(T, tau_0.to('s').magnitude.n * np.exp((W.to('J').magnitude.n / const.k / T))) plt.xlabel(r'$T \mathbin{/} \si{\kelvin}$') plt.ylabel(r'$\tau(T) \mathbin{/} \si{\second}$') plt.tight_layout(pad=1) plt.savefig('build/tau.pdf')
x=np.linspace(20+273.15,65+273.15) print('1/T',1/Temp) print('ln(eha/pas)',unp.log(Kgr*(rhog-1)*T)) print('Geschwindigkeit klein=',Vk,'Zeitmittelwert=',Tk) plt.figure(1) plt.errorbar(noms(1/Temp),noms(unp.log(Kgr*(rhog-1)*T)),xerr=stds(1/Temp),yerr=stds(unp.log(Kgr*(rhog-1)*T)),fmt='rx') plt.plot(noms(1/Temp),noms(unp.log(Kgr*(rhog-1)*T)),'xk',label=r'$Messwerte$') plt.plot(1/x,m*(1/x)+b,'-b',label=r'$Ausgleichsfunktion$') plt.legend(loc='best') plt.grid(True) plt.xlabel(r'$\frac{1}{T}/{K^{-1}}$') plt.ylabel(r'$\ln(\eta / Pa \cdot s)$') plt.savefig('plot.pdf') def Fehlera(x,sa): b=sa*(sum(x**2)/len(x))**(1/2) return b sa1=Fehlera(noms(1/Temp),stdsm) lnA=unp.uarray(b,sa1) Reg=(rhow*Dg)/(ngr*T) Rek=(rhow*Dg)/(n*Tk) A=unp.exp(lnA) print('Reg',Reg) print('Rek',Rek) #print(Temp) #np.savetxt('v.txt',np.column_stack((Temp,T,ngr)),fmt='%r',delimiter=' & ') #print('B',m,stdsm) #print('lnA',lnA) #print('A',A)
print("m3:") print(Start) print(End) m3=fit(wurzel,log(deltaT[Start:End]),log(r2[Start:End])) plt.plot(deltaT[Start-10:End+10],np.exp(m3.n)*(deltaT[Start-10:End+10])**.5,"g--", linewidth=0.6) plt.plot(deltaT[m1Start:m1End],np.exp(m1.n)*(deltaT[m1Start:m1End])**.5,"g-") plt.plot(deltaT[ViertelStart:ViertelEnd],np.exp(m2.n)*(deltaT[ViertelStart:ViertelEnd])**.25,"b-", label=r"$\Delta t^{1/4}$") plt.plot(deltaT[Start:End],np.exp(m3.n)*(deltaT[Start:End])**.5,"g-", label=r"$\Delta t^{1/2}$") plt.plot(deltaT[GeradeStart:GeradeEnd],np.exp(m4.n)*deltaT[GeradeStart:GeradeEnd],"r-", label=r"$\Delta t^{1}$") TauD=(unp.exp(m3-m4))**2 print(TauD) plt.plot([TauD.n,TauD.n],[0.1,1e5],"m--",label=r"$\tau_D="+"{:.1f}".format(TauD.n) +"\pm"+"{:.1f}".format(TauD.s)+"$") TauR=(unp.exp(m2-m3))**4 plt.plot([TauR.n,TauR.n],[0.1,1e5],"y--",label=r"$\tau_R="+"{:.1f}".format(TauR.n) +"\pm"+"{:.1f}".format(TauR.s)+"$") #plt.plot(t,.8*t**.5, label=r"$\Delta T^{ 1/2}$") #plt.plot(t,0.01*(t)**1, label=r"$\Delta T^{ 1}$") #plt.plot(t,3.5*(t)**.25, label=r"$\Delta T^{1/4}$")
Falldauer_unc[0] = t_gr_a # print (Falldauer_unc) rho_Wasser = [998.8, 996.5, 995.3, 994.0, 992.6, 991.0, 989.3, 987.5, 985.7, 983.2] rho_K = rho_gr * np.ones(10) eta_gr_b = K_gr * (rho_K - rho_Wasser) * Falldauer_unc print('eta') print(eta_gr_b) eta_gr_b_log = unp.log(eta_gr_b) params = ucurve_fit(reg.reg_linear, 1/T_2, noms(eta_gr_b_log)) m, b = params write('build/Steigung_b.tex', make_SI(m, r'\kelvin', figures=1)) # Dies ist tatsächlich B ! write('build/Offset_b.tex', make_SI(b, r'', figures=1)) A = unp.exp(b) # print(A) write('build/ParameterA_b.tex', make_SI(A*1e3, r'\kilogram\meter\per\second', 'e-3', figures=1)) # write('build/Tabelle_daten1.tex', make_table([T_2-273, noms(Falldauer_unc), stds(Falldauer_unc), rho_Wasser, 1/T_2*1e3, noms(eta_gr_b)*1e3, stds(eta_gr_b)*1e3, noms(eta_gr_b_log)*(-1), stds(eta_gr_b_log)],[0, 2, 2, 1, 3, 3, 2 , 2, 2])) write('build/Tabelle_daten1.tex', make_table([T_2-273, Falldauer_unc, rho_Wasser, 1/T_2*1e3, eta_gr_b*1e3, (-1)*eta_gr_b_log],[0, 1, 1, 3, 1, 1])) # FULLTABLE write('build/Tabelle_daten1_texformat.tex', make_full_table( 'Messdaten Falldauer in Abhängigkeit der Temperatur.', 'table:daten1', 'build/Tabelle_daten1.tex', [1,4,5], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [r'$T \:/\: \si{\celsius}$', r'$t \:/\: \si{\second}$', r'$T \:/\: \si{\kilo\gram\per\cubic\meter}$',
tau = -1. / popt[0] * const.minute t_H = np.log(2) * tau print papstats.pformat(tau / const.minute, label=u'Dämpfungskonstante tau', unit='min') print papstats.pformat(t_H / const.minute, label=u'Halbwertszeit t_H', unit='min') ##### print u"# 3.3: Präzession" ##### data = np.loadtxt('2.3.txt', skiprows=1) w_1 = unp.uarray(data[:,0], 10) * 2 * const.pi / const.minute T_P = unp.uarray(np.transpose(data[:,1::2]), 2) w_2 = unp.uarray(np.transpose(data[:,2::2]), 10) * 2 * const.pi / const.minute w_2_erw = w_1 * unp.exp(-T_P / tau) diff = w_2 - w_2_erw w_2 = np.mean([w_2, w_2_erw], axis=0) w_F = unp.uarray(unp.nominal_values(w_1 + w_2) / 2., np.sqrt((unp.nominal_values(w_1 - w_2) / 2)**2 + unp.std_devs(w_1 + w_2)**2)) def fit_linear_origin(x, m): return m * x n_m = np.array([1, 1, 2, 2]) d = unp.uarray([15, 20, 15, 20], 0.1) * const.centi mlabels = [str(n_m[i]) + 'm, ' + str(int(d[i].nominal_value/const.centi)) + 'cm' for i in range(len(n_m))] d = d + 1.1 / 2. * const.centi * n_m s = [] plt.clf() plt.suptitle(u'Diagramm 3.2: Präzessionszeit über der Drehfrequenz verschiedener Drehmomente') ax = None
plt.xlim(C2K(26),C2K(65)) plt.xlabel(r'$T / \si{\kelvin}$') plt.ylabel(r'$\eta / \si{\milli\pascal\second}$') plt.legend(loc='best') plt.tight_layout(pad=0) plt.savefig('build/viskosität.pdf') plt.clf() T_r = 1/T T_r_ = 1/T_ lneta = unp.log(eta) slope, intercept, r_value, p_value, std_err = linregress(T_r, unp.nominal_values(lneta)) print(slope, intercept, r_value**2) B = unc.ufloat(slope, std_err) A = unp.exp(unc.ufloat(intercept, std_err * T_r.mean())) print("A = {}, B = {}".format(A, B)) valuesp = (slope + std_err) * T_r_ + intercept + std_err * T_r.mean() valuesm = (slope - std_err) * T_r_ + intercept - std_err * T_r.mean() plt.errorbar(T_r, unp.nominal_values(lneta), yerr=unp.std_devs(lneta), fmt='rx', label='Messdaten', markersize=3) plt.plot(T_r_, slope*T_r_ + intercept, 'b-', label='Lineare Regression') plt.fill_between(T_r_, valuesm, valuesp, facecolor='blue', alpha=0.125, edgecolor='none', label=r'$1\sigma$-Umgebung') plt.xlim(0.00297, 0.00333) plt.xlabel(r'$T^{-1} / \si{\per\kelvin}$') plt.ylabel(r'$\ln(\eta / \si{\milli\pascal\second})$') plt.legend(loc='best') plt.tight_layout(pad=0) plt.savefig('build/viskosität_linear.pdf') plt.clf()
def Eps(ntu,mu): """ cele doua fluide sunt neamestecate """ return 1.-unp.exp(1/mu*unp.pow(ntu,0.22)*(unp.exp(-mu*unp.pow(ntu,0.78))-1))
print(N_ind) N_ind=unp.log(N_ind) def f(t, a, b): return a*t+b params, covariance = curve_fit(f, np.arange(250,(1+len(N_ind))*250,250), nom(N_ind),sigma=std(N_ind)) errors = np.sqrt(np.diag(covariance)) print("Parameter:") a=ufloat(params[0],errors[0]) print("a={}".format(a)) b=ufloat(params[1],errors[1]) print("b={}".format(b)) print("") print('T ={}'.format(np.log(2)/-a)) print('N0 ={}'.format(unp.exp(b)/(1-unp.exp(a*250)))) print("") X = np.linspace(0, 4000) plt.plot(X, f(X, *params), 'b-', label='Ausgleichsgerade') plt.errorbar(np.arange(250,(1+len(N_ind))*250,250),nom(N_ind),yerr=std(N_ind),fmt="x",label="Indium") plt.xlabel(r'Zeit $t$ in s') plt.xticks(np.arange(250,(1+len(N_ind))*250,250),np.arange(250,(1+len(N_ind))*250,250)) plt.grid() plt.ylabel(r'Logarithmierte Zerfallrate $\Delta N$ im Zeitintervall $\Delta t$') plt.legend(loc="best") plt.tight_layout() #plt.yscale("log") plt.savefig("../Bilder/indium.pdf") plt.close() #
def u_decay_with_background(t, N0, lamb, back): return N0 * unp.exp(-lamb*t) + back
plt.ylim(0.5, 30) plt.savefig('Spannung1.png') plt.show() U_regression = np.log(U_0-U) print(U_regression) def f(t, m, b): return m*t+b parameters, popt = curve_fit(f, t, U_regression) m = ufloat(parameters[0], np.sqrt(popt[0,0])) b = ufloat(parameters[1], np.sqrt(popt[1,1])) Zeitkonstante = (-1/m) Ausgangsspannung = unp.exp(b) #Fehlerbalken in y-Richtung ausrechnen: U_err = unp.log(U_0 - U_gesamt) x=np.linspace(0,0.0035) #plt.plot(t, U_regression, 'rx') plt.errorbar(t, U_regression, xerr=t_err, yerr = unp.std_devs(U_err), fmt='r.', label='Datenpunkte mit Messunsicherheit') plt.plot(x, f(x, *parameters), 'b-', label='Lineare Ausgleichsgerade') plt.ylabel('$\log(U_0-U)$') plt.xlabel('Zeit / s') #plt.legend(loc='best') plt.savefig('Spannung2.png') plt.show()
errM = unp.std_devs(M) plt.errorbar(unp.nominal_values(tau), np.log(unp.nominal_values(M)) + errM, fmt='bx', label="T2-Messung") plt.plot(x_plot, g(x_plot, *params), 'r-', label='Linearer Fit') plt.legend(loc="best", numpoints=1) plt.xlim(0,1010) plt.ylim(0, 0.8) plt.xlabel(r'Zeitabstand $\tau$ [$\mu$s]') plt.ylabel(r'ln(Magnetisierung M$_y$/V)') plt.savefig('plotT2.png') errors=np.sqrt(np.diag(covariance)) print('ln(M0) =', params[0], '+/-', errors[0]) print('-(1/T2) =', params[1], '+/-', errors[1]) m0=ufloat(params[0], errors[0]) M0=exp(m0) print('M0 =', unp.nominal_values(M0) , '+/-', unp.std_devs(M0)) #t1/2-Messung t= ufloat(params[1],errors[1]) T2=-(1/t) print('T2=',T2) t12= ufloat(282,4) gG=8.8/(4.4*t12) print(gG) #Diffusionsskonstante data2 = np.genfromtxt('DMessung.txt', unpack='True') tau=unp.uarray(data2[0,:],0)