def salt2mu_aberr(x1=None,x1err=None, c=None,cerr=None, mb=None,mberr=None, cov_x1_c=None,cov_x1_x0=None,cov_c_x0=None, alpha=None,beta=None, alphaerr=None,betaerr=None, M=None,x0=None,sigint=None,z=None,peczerr=0.0005): from uncertainties import ufloat, correlated_values, correlated_values_norm alphatmp,betatmp = alpha,beta alpha,beta = ufloat(alpha,alphaerr),ufloat(beta,betaerr) sf = -2.5/(x0*np.log(10.0)) cov_mb_c = cov_c_x0*sf cov_mb_x1 = cov_x1_x0*sf mu_out,muerr_out = np.array([]),np.array([]) for i in range(len(x1)): covmat = np.array([[mberr[i]**2.,cov_mb_x1[i],cov_mb_c[i]], [cov_mb_x1[i],x1err[i]**2.,cov_x1_c[i]], [cov_mb_c[i],cov_x1_c[i],cerr[i]**2.]]) mb_single,x1_single,c_single = correlated_values([mb[i],x1[i],c[i]],covmat) mu = mb_single + x1_single*alpha - beta*c_single + 19.36 if sigint: mu = mu + ufloat(0,sigint) zerr = peczerr*5.0/np.log(10)*(1.0+z[i])/(z[i]*(1.0+z[i]/2.0)) mu = mu + ufloat(0,np.sqrt(zerr**2. + 0.055**2.*z[i]**2.)) mu_out,muerr_out = np.append(mu_out,mu.n),np.append(muerr_out,mu.std_dev) return(mu_out,muerr_out)
def test_pseudo_inverse(): "Tests of the pseudo-inverse" # Numerical version of the pseudo-inverse: pinv_num = core.wrap_array_func(numpy.linalg.pinv) ########## # Full rank rectangular matrix: m = unumpy.matrix([[ufloat((10, 1)), -3.1], [0, ufloat((3, 0))], [1, -3.1]]) # Numerical and package (analytical) pseudo-inverses: they must be # the same: rcond = 1e-8 # Test of the second argument to pinv() m_pinv_num = pinv_num(m, rcond) m_pinv_package = core._pinv(m, rcond) assert matrices_close(m_pinv_num, m_pinv_package) ########## # Example with a non-full rank rectangular matrix: vector = [ufloat((10, 1)), -3.1, 11] m = unumpy.matrix([vector, vector]) m_pinv_num = pinv_num(m, rcond) m_pinv_package = core._pinv(m, rcond) assert matrices_close(m_pinv_num, m_pinv_package) ########## # Example with a non-full-rank square matrix: m = unumpy.matrix([[ufloat((10, 1)), 0], [3, 0]]) m_pinv_num = pinv_num(m, rcond) m_pinv_package = core._pinv(m, rcond) assert matrices_close(m_pinv_num, m_pinv_package)
def test_wrap_array_func(): ''' Test of numpy.wrap_array_func(), with optional arguments and keyword arguments. ''' # Function that works with numbers with uncertainties in mat (if # mat is an uncertainties.unumpy.matrix): def f_unc(mat, *args, **kwargs): return mat.I + args[0]*kwargs['factor'] # Test with optional arguments and keyword arguments: def f(mat, *args, **kwargs): # This function is wrapped: it should only be called with pure # numbers: assert not any(isinstance(v, uncert_core.UFloat) for v in mat.flat) return f_unc(mat, *args, **kwargs) # Wrapped function: f_wrapped = core.wrap_array_func(f) ########## # Full rank rectangular matrix: m = unumpy.matrix([[ufloat(10, 1), -3.1], [0, ufloat(3, 0)], [1, -3.1]]) # Numerical and package (analytical) pseudo-inverses: they must be # the same: m_f_wrapped = f_wrapped(m, 2, factor=10) m_f_unc = f_unc(m, 2, factor=10) assert arrays_close(m_f_wrapped, m_f_unc)
def getPerformanceOnMC( files, histogramForEstimation="QCDStudy/PFIsolation_WithMETCutAndAsymJetCuts_DR03", bjetBin="", function="expo", fitRange=(0.3, 1.6), additionFitRanges=[(0.2, 1.6), (0.4, 1.6)], ): if bjetBin: histogramForEstimation = histogramForEstimation + "_" + bjetBin hists = [histogramForEstimation] hists = getHistsFromFiles(hists, files) hists = addSampleSum(hists) histogramForComparison = hists["qcd"][histogramForEstimation] histogramForEstimation = hists["allMC"][histogramForEstimation] estimate, absoluteError = getQCDEstimateFor( histogramForEstimation, function, fitRange=fitRange, additionFitRanges=additionFitRanges ) qcdInSignalRegion, qcdError = getIntegral(histogramForComparison, (0, 0.1)) N_est = ufloat((estimate, absoluteError)) N_qcd = ufloat((qcdInSignalRegion, qcdError)) relativeDeviation = N_est / N_qcd result = {} result["performance"] = (relativeDeviation.nominal_value, relativeDeviation.std_dev()) result["estimate"] = (estimate, absoluteError) result["qcdInSignalRegion"] = (qcdInSignalRegion, qcdError) return result
def split_dat(data): """ Takes the row in the form r_n e_r_n ext_n e_ext_n and returns two lists one with the radii and the other with the extinction values both lists are of ufloats Parameters -------- data : list A list of floats of the radii and errors and extinctions and errors. Returns -------- rad : list List of ufloats of the radii. ext : list List of ufloats of the extinctions. """ rad, ext = [], [] for i in range(0, len(data) - 1, 4): vec = [data[i], data[i+1], data[i+2], data[i+3]] if vec[0].strip() != '': radius = ufloat(vec[0], vec[1]) extinct = ufloat(vec[2], vec[3]) rad.append(radius) ext.append(extinct) return ext, rad
def exponential_fit_offset(x, y, amp_guess=1, decay_guess=1, offset_guess=0, errors=True): """ Simple helper function that speeds up single exponetial fit with offset. Uses lmfit Parameters ---------- x, y (float) Sample length x, y arrays of data to be fitted Returns ------- Returns slope and intercept, with uncertainties (use uncertainties package if availabe) !!!!! not tested or working !!!!! """ from lmfit.models import ExpressionModel mod = ExpressionModel("offset + amp * exp(-x/decay)") par = mod.make_params(amp=amp_guess, decay=decay_guess, offset_guess=offset_guess) out = mod.fit(y, params=par, x=x) s = out.params['slope'] i = out.params['intercept'] if errors: try: from uncertainties import ufloat return ufloat(s.value, s.stderr), ufloat(i.value, i.stderr) except: return s.value, s.stderr, i.value, i.stderr else: return s.value, i.value
def get_vhtt_yield(mass): log.warning("Get VHTT yield %s", mass) mmt_yield = results_file.Get('mmt_mumu_final_count/VH%i' % mass).Integral() emt_yield = results_file.Get('emt_emu_final_count/VH%i' % mass).Integral() _, (mmt_passed, mmt_total) = get_stat_error('VH%i' % mass, mmt_yield) _, (emt_passed, emt_total) = get_stat_error('VH%i' % mass, emt_yield) assert(mmt_total == emt_total) mmt_passed = ufloat( (mmt_passed, math.sqrt(mmt_passed) )) emt_passed = ufloat( (emt_passed, math.sqrt(emt_passed) )) total = ufloat( (mmt_total, math.sqrt(mmt_total) )) all_passed = mmt_passed + emt_passed log.warning("total %s", total) log.warning("all %s", all_passed) #multply by fraction of ZH_WH_ttH that is WH wh_xsec = ROOT.HiggsCSandWidth().HiggsCS(3, mass, 7) zh_xsec = ROOT.HiggsCSandWidth().HiggsCS(4, mass, 7) tth_xsec = ROOT.HiggsCSandWidth().HiggsCS(5, mass, 7) wh_fraction = wh_xsec/(wh_xsec + zh_xsec + tth_xsec) log.warning("wh_frac %s", wh_fraction) br_bonus = 1.0/(0.1075+0.1057+0.1125) log.warning("br_bonus %s", br_bonus) return 100*br_bonus*(all_passed/total)/wh_fraction
def regression(f, x_u, y_u, beta0 ): for i, y in enumerate(y_u): if ustd(y) == 0: y_u[i] = ufloat(y_u[i].nominal_value, y_u[i].nominal_value/1e15) if len(x_u.shape) == 2: x_nom = range(len(x_u)) x_error = range(len(x_u)) for i, col in enumerate(x_u): for j, elem in enumerate(col): if ustd(elem) == 0: x_u[i,j] = ufloat(elem.nominal_value, elem.nominal_value/1e15) x_nom[i] = unom(x_u[i]) x_error[i] = ustd(x_u[i]) x_nom = np.array(x_nom) x_error = np.array(x_error) elif np.sum(ustd(x_u)) == 0: x_error = None else: x_error = ustd(x_u) x_nom = unom(x_u) linear = odrpack.Model(f) mydata = odrpack.RealData(x_nom, unom(y_u),sy=ustd(y_u), sx=x_error) myodr = odrpack.ODR(mydata, linear, beta0=beta0) myoutput = myodr.run() #myoutput.pprint() #print "Chi-squared =", np.sum((myoutput.delta**2 + myoutput.eps**2)/(ustd(x_u)**2+ ustd(y_u)**2)) print "Chi-squared =", myoutput.sum_square beta_u = unumpy.uarray(myoutput.beta, myoutput.sd_beta) print "beta = ", beta_u print "reduced chi-square =", myoutput.res_var degrees_of_freedom = myoutput.sum_square/myoutput.res_var p_value = 1-scipy.stats.chi2.cdf(myoutput.sum_square, degrees_of_freedom) print "p-value =", p_value return beta_u
def line_fit(x, y, errors=True): """ Simple helper function that speeds up line fitting. Uses lmfit Parameters ---------- x, y (float) Sample length x, y arrays of data to be fitted Returns ------- Returns slope and intercept, with uncertainties (use uncertainties package if availabe) Also returns fit object out, can be dropped """ from lmfit.models import LinearModel mod = LinearModel() par = mod.guess(y, x=x) out = mod.fit(y, par, x=x) s = out.params['slope'] i = out.params['intercept'] if errors: try: from uncertainties import ufloat return ufloat(s.value, s.stderr), ufloat(i.value, i.stderr), out except: return s.value, s.stderr, i.value, i.stderr, out else: return s.value, i.value, out
def func(ra): u, l = ra.split(':') try: ru = self.signals[u] rl = self.signals[l] except KeyError: return '' if cfb: bu = ufloat(0, 0) bl = ufloat(0, 0) try: bu = self.baselines[u] bl = self.baselines[l] except KeyError: pass try: rr = (ru - bu) / (rl - bl) except ZeroDivisionError: rr = ufloat(0, 0) else: try: rr = ru / rl except ZeroDivisionError: rr = ufloat(0, 0) res = '{}/{}={} '.format(u, l, pad('{:0.4f}'.format(rr.nominal_value))) + \ PLUSMINUS + pad(format('{:0.4f}'.format(rr.std_dev)), n=6) + \ self._get_pee(rr) return res
def fit_single_line_BS(self, x, y, zero_lev, err_continuum, fitting_parameters, bootstrap_iterations = 1000): #Declare parameters and containers for the fit params_dict = fitting_parameters.valuesdict() initial_values = [params_dict['A0'], params_dict['mu0'], params_dict['sigma0']] area_array = empty(bootstrap_iterations) params_array = empty([3, bootstrap_iterations]) n_points = len(x) #Perform the fit for i in range(bootstrap_iterations): y_new = y + np_normal_dist(0, err_continuum, n_points) area_array[i] = simps(y_new, x) - simps(zero_lev, x) best_vals, covar = curve_fit(gaussian_curveBS, (x, zero_lev), y_new, p0=initial_values, maxfev = 1600) params_array[:,i] = best_vals #Compute Bootstrap output mean_area, std_area = mean(area_array), std(area_array) mean_params_array, stdev_params_array = params_array.mean(1), params_array.std(1) #Store the data self.fit_dict['area_intg'], self.fit_dict['area_intg_er'] = mean_area, std_area self.fit_dict['A0_norm'], self.fit_dict['A0_norm_er'] = mean_params_array[0], stdev_params_array[0] self.fit_dict['mu0_norm'], self.fit_dict['mu0_norm_er'] = mean_params_array[1], stdev_params_array[1] self.fit_dict['sigma0_norm'], self.fit_dict['sigma0_norm_er'] = mean_params_array[2], stdev_params_array[2] A = ufloat(mean_params_array[0], stdev_params_array[0]) sigma = ufloat(mean_params_array[2], stdev_params_array[2]) fwhm0_norm = 2.354820045 * sigma areaG0_norm = A * sigma * self.sqrt2pi self.fit_dict['fwhm0_norm'], self.fit_dict['fwhm0_norm_er'] = fwhm0_norm.nominal_value, fwhm0_norm.std_dev self.fit_dict['area_G0_norm'], self.fit_dict['area_G0_norm_er'] = areaG0_norm.nominal_value, areaG0_norm.std_dev return
def get_mean_raw(self, tau=None): vs = [] corrfunc = self._deadtime_correct for r in six.itervalues(self._cp): n = int(r['NShots']) nv = ufloat(float(r['Ar40']), float(r['Ar40err'])) * 6240 dv = ufloat(float(r['Ar36']), float(r['Ar36err'])) * 6240 if tau: dv = corrfunc(dv, tau * 1e-9) vs.append((n, nv / dv)) key = lambda x: x[0] vs = sorted(vs, key=key) mxs = [] mys = [] mes = [] for n, gi in groupby(vs, key=key): mxs.append(n) ys, es = list(zip(*[(nominal_value(xi[1]), std_dev(xi[1])) for xi in gi])) wm, werr = calculate_weighted_mean(ys, es) mys.append(wm) mes.append(werr) return mxs, mys, mes
def combine_complex_df( df1, df2 ): ''' Takes a 2 pandii dataframes of the form: A | B A | B (v,e) | (v,e) (v,e) | (v,e) Returns 1 pandas dataframe of the form A | B (v,e) | (v,e) ''' from uncertainties import ufloat l1=df1.columns.tolist() l2=df2.columns.tolist() if l1 != l2: print "Trying to combine two non compatible dataframes" print l1 print l2 return combined_result = {} for sample in l1: results = [] for entry1, entry2 in zip(df1[sample], df2[sample]): v1 = ufloat(entry1[0], entry1[1]) v2 = ufloat(entry2[0], entry2[1]) s = v1 + v2 results.append( ( s.nominal_value, s.std_dev ) ) combined_result[sample] = results df = dict_to_df(combined_result) return df
def get_data(self) : self.sampdata=collections.OrderedDict() self.data = {} for sname, samp in self.samples.iteritems() : if samp['files'] and samp['fields'] : sdata = self.get_data_from_pickle( samp['files'], samp['fields'] ) self.sampdata[sname] = { 'val' : sdata[0],'err' : samp['err'] } else : self.sampdata[sname] = { 'val' : ufloat(0, 0),'err' : None } if self.datasamp['use_sample_sum'] : ddata = ufloat(0, 0) for sname, samp in self.samples.iteritems() : if samp['isSig'] : continue samp_val = self.sampdata[sname] ddata = ddata + samp_val['val'] self.data = {'val' : ddata } else : ddata = self.get_data_from_pickle( self.datasamp['files'], self.datasamp['fields'] ) self.data = {'val' : ddata[0] } if self.datasamp['generate'] : genval = rand.Poisson( self.data['val'].n ) self.data = {'val' : ufloat( genval, math.sqrt( genval ) ) }
def calculate_latencies(version_dates): linux_latencies = latency(version_dates['linux'], OrderedDict(avo.os_to_kernel)) set_latex_value('linuxMeanUpdateLatency', ufloat(statistics.mean(linux_latencies.values()),statistics.stdev(linux_latencies.values()))) openssl_latencies = latency(version_dates['openssl'], OrderedDict(avo.os_to_project['openssl'])) set_latex_value('opensslMeanUpdateLatency', ufloat(statistics.mean(openssl_latencies.values()),statistics.stdev(openssl_latencies.values()))) bouncycastle_latencies = latency(version_dates['bouncycastle'], OrderedDict(avo.os_to_project['bouncycastle'])) set_latex_value('bouncycastleMeanUpdateLatency',ufloat(statistics.mean(bouncycastle_latencies.values()),statistics.stdev(bouncycastle_latencies.values())))
def Compute_HeliumAbundance(FileFolder, CodeName): OI_HI = pv.GetParameter_ObjLog(CodeName, FileFolder, Parameter='OI_HI_pn', Assumption='float') SI_HI = pv.GetParameter_ObjLog(CodeName, FileFolder, Parameter='SI_HI_ArCorr_pn', Assumption='float') HeIII_HII = pv.GetParameter_ObjLog(CodeName, FileFolder, Parameter='HeIII_HII_pn', Assumption='float') if OI_HI != None: HeII_HII_Inference = ufloat(bp.statistics_dict['He_abud']['mean'], bp.statistics_dict['He_abud']['standard deviation']) #Add the HeIII component if observed if HeIII_HII != None: HeI_HI = HeII_HII_Inference + HeIII_HII else: HeI_HI = HeII_HII_Inference Y_mass_InferenceO = (4 * HeI_HI * (1 - 20 * OI_HI)) / (1 + 4 * HeI_HI) else: Y_mass_InferenceO = None if SI_HI != None: HeII_HII_Inference = ufloat(bp.statistics_dict['He_abud']['mean'], bp.statistics_dict['He_abud']['standard deviation']) #Add the HeIII component if observed if HeIII_HII != None: HeI_HI = HeII_HII_Inference + HeIII_HII else: HeI_HI = HeII_HII_Inference Y_mass_InferenceS = (4 * HeI_HI * (1 - 20 * ch_an.OI_SI * SI_HI)) / (1 + 4 * HeI_HI) else: Y_mass_InferenceS = None return Y_mass_InferenceO, Y_mass_InferenceS
def test_decimal_places(self): cases = [(0, '0'), (-1, '-1'), (0.012, '0.01'), (0.016, '0.02') , (ufloat(0,0), r'$0.0 \pm 0.0$'), (ufloat(10,0), r'$10.0 \pm 0.0$') , (ufloat(0.12, 0.012), r'$0.12 \pm 0.01$'), (ufloat(0.12, 0.016), r'$0.12 \pm 0.02$') , (ufloat(-0.12, 0.016), r'$-0.12 \pm 0.02$')] for test_case, result in cases: self.assertEqual(display_num(test_case, decimal_places=2), result)
def age_equation(j, f, include_decay_error=False, lambda_k=None, scalar=None, arar_constants=None): if isinstance(j, tuple): j = ufloat(*j) elif isinstance(j, str): j = ufloat(j) if isinstance(f, tuple): f = ufloat(*f) elif isinstance(f, str): f = ufloat(f) if not lambda_k: if arar_constants is None: arar_constants = ArArConstants() lambda_k = arar_constants.lambda_k if not scalar: if arar_constants is None: arar_constants = ArArConstants() scalar = float(arar_constants.age_scalar) if not include_decay_error: lambda_k = nominal_value(lambda_k) try: return (lambda_k ** -1 * umath.log(1 + j * f)) / scalar except (ValueError, TypeError): return ufloat(0, 0)
def get_value(self, attr): # print 'get attr', attr, self.isotopes r = ufloat(0, 0, tag=attr) if attr.endswith('bs'): iso = attr[:-2] if iso in self.isotopes: r = self.isotopes[iso].baseline.uvalue elif '/' in attr: non_ic_corr = attr.startswith('u') if non_ic_corr: attr = attr[1:] r = self.get_ratio(attr, non_ic_corr) elif attr == 'icf_40_36': r = self.get_corrected_ratio('Ar40', 'Ar36') elif attr.endswith('ic'): # ex. attr='Ar40ic' isok = attr[:-2] try: r = self.isotopes[isok].ic_factor except KeyError: r = ufloat(0, 0) elif attr in self.computed: r = self.computed[attr] elif attr in self.isotopes: r = self.isotopes[attr].get_intensity() elif hasattr(self, attr): r = getattr(self, attr) # else: # iso = self._get_iso_by_detector(attr) # # iso=next((i for i in self.isotopes if i.detector==attr), None) # if iso: # r = ufloat(iso.ys[-1], tag=attr) return r
def interference_corrections(a39, a37, production_ratios, arar_constants=None, fixed_k3739=False): if production_ratios is None: production_ratios = {} if arar_constants is None: arar_constants = ArArConstants() pr = production_ratios k37 = ufloat(0, 0, tag='k37') if arar_constants.k3739_mode.lower() == 'normal' and not fixed_k3739: # iteratively calculate 37, 39 for _ in range(5): ca37 = a37 - k37 ca39 = pr.get('Ca3937', 0) * ca37 k39 = a39 - ca39 k37 = pr.get('K3739', 0) * k39 else: if not fixed_k3739: fixed_k3739 = arar_constants.fixed_k3739 ca37, ca39, k37, k39 = apply_fixed_k3739(a39, pr, fixed_k3739) k38 = pr.get('K3839', 0) * k39 if not arar_constants.allow_negative_ca_correction: ca37 = max(ufloat(0, 0), ca37) ca36 = pr.get('Ca3637', 0) * ca37 ca38 = pr.get('Ca3837', 0) * ca37 return k37, k38, k39, ca36, ca37, ca38, ca39
def calc_f(pr): k37, k38, k39, ca36, ca37, ca38, ca39 = interference_corrections(a39, a37, pr, arar_constants, fixed_k3739) atm36, cl36, cl38 = calculate_atmospheric(a38, a36, k38, ca38, ca36, decay_time, pr, arar_constants) # calculate radiogenic trapped_4036 = copy(arar_constants.atm4036) trapped_4036.tag = 'trapped_4036' atm40 = atm36 * trapped_4036 k4039 = pr.get('K4039', 0) k40 = k39 * k4039 rad40 = a40 - atm40 - k40 try: ff = rad40 / k39 except ZeroDivisionError: ff = ufloat(1.0, 0) nar = {'k40': k40, 'ca39': ca39, 'k38': k38, 'ca38': ca38, 'cl38': cl38, 'k37': k37, 'ca37': ca37, 'ca36': ca36, 'cl36': cl36} try: rp = rad40 / a40 * 100 except ZeroDivisionError: rp = ufloat(0, 0) comp = {'rad40': rad40, 'a40': a40, 'rad40_percent': rp, 'ca37': ca37, 'ca39': ca39, 'ca36': ca36, 'k39': k39, 'atm40': atm40} ifc = {'Ar40': a40 - k40, 'Ar39': k39, 'Ar38': a38, 'Ar37': a37, 'Ar36': atm36} return ff, nar, comp, ifc
def small_sep13 ( mx , mxErr, lag=0): """ Given a frequency matrix and errors calculates the (scaled) small separation d13 and propagates errors. Notes ----- The parameter lag is the difference between the radial orders of the first modes of l=1 and l=3. """ (Nn, Nl) = np.shape(mx) d13 = np.zeros((1,Nn)) d13Err = np.zeros((1,Nn)) d13.fill(None) # values that can't be calculated remain NaN for n in range(1-lag,Nn): if (mx[n,1] != 0. and mx[n-1+lag,3] != 0.): a = un.ufloat( (mx[n,1], mxErr[n,1]) ) b = un.ufloat( (mx[n-1+lag,3], mxErr[n-1+lag,3]) ) result = (a-b) / 5. d13[0,n-1+lag] = un.nominal_value(result) d13Err[0,n-1+lag] = un.std_dev(result) return d13, d13Err
def calculate_flux(f, age, arar_constants=None): """ #rad40: radiogenic 40Ar #k39: 39Ar from potassium f: F value rad40Ar/39Ar age: age of monitor in years solve age equation for J """ # if isinstance(rad40, (list, tuple)): # rad40 = ufloat(*rad40) # if isinstance(k39, (list, tuple)): # k39 = ufloat(*k39) if isinstance(f, (list, tuple)): f = ufloat(*f) if isinstance(age, (list, tuple)): age = ufloat(*age) # age = (1 / constants.lambdak) * umath.log(1 + JR) try: # r = rad40 / k39 if arar_constants is None: arar_constants = ArArConstants() j = (umath.exp(age * arar_constants.lambda_k.nominal_value) - 1) / f return j.nominal_value, j.std_dev except ZeroDivisionError: return 1, 0
def day3_vacuum(): plt.clf() ux = unp.uarray([800, 1000, 500], ux_error) # V ug_crit = unp.uarray([110, 140, 30], ug_error) # V omega = 2 * math.pi * ufloat(48, 1) # Hz ug_crit = _apply_additional_proportional_error(ug_crit, stability_uncertainty_vacuum) ux *= ux_correction ug_crit *= ug_correction stability(ux, ug_crit, omega, label="Particle V1") plt.title("p = 300 mbar") plt.legend(loc=2) plt.savefig("images/stability_vacuum_1.pdf") plt.clf() ux = unp.uarray([700, 800], ux_error) # V ug_crit = unp.uarray([100, 140], ug_error) # V omega = 2 * math.pi * ufloat(45, 1) # Hz ug_crit = _apply_additional_proportional_error(ug_crit, stability_uncertainty_vacuum) ux *= ux_correction ug_crit *= ug_correction stability(ux, ug_crit, omega, label="Particle V2") plt.title("p = 180 mbar") plt.legend(loc=2) plt.savefig("images/stability_vacuum_2.pdf")
def safe_div(n, d): if n.size == 0: return None if n.shape != d.shape: return None if isinstance(n[0, 0], UFloat) is False: return None z = np.zeros_like(n) z.fill(ufloat(np.nan, np.nan)) it = np.nditer(d, op_flags=["readonly"], flags=["multi_index", "refs_ok"]) while not it.finished: i = it.multi_index[0] j = it.multi_index[1] if abs(d[i, j].n) == 0.0: # z[i,j] = ufloat(0.,0.) z[i, j] = ufloat(np.nan, np.nan) # if abs(n[i,j].n) > 0. : # z[i,j] = ufloat(np.nan,np.nan) # else : # err = np.sqrt( n[i,j].s**2. + d[i,j].s**2. ) # z[i,j] = ufloat(0.,err) # z[i,j] = ufloat(np.nan,np.nan) # z[i,j] = ufloat(np.inf,np.inf) else: z[i, j] = n[i, j] / d[i, j] it.iternext() return z
def get_1d_loose_efficiencies( int_stat, int_syst, lead_reg, lead_ptrange, systematics=None) : eff_stat = {} eff_syst = {} if int_stat['lead']['real']['loose'].n == 0 : eff_stat['eff_R_T_lead'] = ufloat( 1.0, int_stat['lead']['real']['tight'].s/int_stat['lead']['real']['tight'].n ) else : eff_stat['eff_R_T_lead'] = int_stat['lead']['real']['tight'] / (int_stat['lead']['real']['tight']+int_stat['lead']['real']['loose']) eff_stat['eff_F_T_lead'] = int_stat['lead']['fake']['tight'] / (int_stat['lead']['fake']['tight']+int_stat['lead']['fake']['loose']) eff_stat['eff_R_L_lead'] = int_stat['lead']['real']['loose'] / (int_stat['lead']['real']['tight']+int_stat['lead']['real']['loose']) eff_stat['eff_F_L_lead'] = int_stat['lead']['fake']['loose'] / (int_stat['lead']['fake']['tight']+int_stat['lead']['fake']['loose']) eff_syst['eff_R_T_lead'] = int_syst['lead']['real']['tight'] / (int_syst['lead']['real']['tight']+int_syst['lead']['real']['loose']) eff_syst['eff_F_T_lead'] = int_syst['lead']['fake']['tight'] / (int_syst['lead']['fake']['tight']+int_syst['lead']['fake']['loose']) eff_syst['eff_R_L_lead'] = int_syst['lead']['real']['loose'] / (int_syst['lead']['real']['tight']+int_syst['lead']['real']['loose']) eff_syst['eff_F_L_lead'] = int_syst['lead']['fake']['loose'] / (int_syst['lead']['fake']['tight']+int_syst['lead']['fake']['loose']) # Do systematics # the integrals may already have some systematics # that are propagated to the eff_* # therefore, don't overwrite the existing # systematics, but make a ufloat with a # zero value, and non-zero syst eff_syst['eff_R_L_lead'] = eff_syst['eff_R_L_lead'] + ufloat( 0.0, math.fabs(eff_syst['eff_R_L_lead'].n)*get_syst_uncertainty( 'RealTemplateNom', lead_reg, lead_ptrange, 'real', 'loose' ), 'Template_lead_real_loose') eff_syst['eff_F_L_lead'] = eff_syst['eff_F_L_lead'] + ufloat( 0.0, math.fabs(eff_syst['eff_F_L_lead'].n)*get_syst_uncertainty( 'FakeTemplate%s'%systematics, lead_reg, lead_ptrange, 'fake', 'loose' ), 'Template_lead_fake_loose' ) eff_syst['eff_R_T_lead'] = eff_syst['eff_R_T_lead'] + ufloat( 0.0, math.fabs(eff_syst['eff_R_T_lead'].n)*get_syst_uncertainty( 'RealTemplateNom', lead_reg, lead_ptrange, 'real', 'loose' ), 'Template_lead_real_loose') eff_syst['eff_F_T_lead'] = eff_syst['eff_F_T_lead'] + ufloat( 0.0, math.fabs(eff_syst['eff_F_T_lead'].n)*get_syst_uncertainty( 'FakeTemplate%s'%systematics, lead_reg, lead_ptrange, 'fake', 'loose' ), 'Template_lead_fake_loose' ) return eff_stat, eff_syst
def day2_air(): plt.clf() ux = unp.uarray([1000, 860, 800, 760, 1000, 920, 620], ux_error) # V ug_crit_1 = unp.uarray([390, 170, 600, 120, 225, 175, 53], ug_error) # V ug_crit_2 = unp.uarray([390, 170, 600, 120, 160, 145, 67], ug_error) # V ug_crit_3 = unp.uarray([390, 370, 600, 120, 225, 175, 67], ug_error) # V omega = 2 * math.pi * ufloat(28, 1) # Hz ux *= ux_correction for i, ug_crit in enumerate((ug_crit_1, ug_crit_2, ug_crit_3), 1): ug_crit = _apply_additional_proportional_error(ug_crit, stability_uncertainty_air) ug_crit *= ug_correction stability(ux, ug_crit, omega, "Particle A%d" % i) plt.legend(loc=2) plt.savefig("images/stability_air_1.pdf") plt.clf() ux = unp.uarray([550, 740, 870, 1040], ux_error) ug_crit = unp.uarray([39, 84, 133, 147], ug_error) omega = 2 * math.pi * ufloat(32, 1) # Hz ug_crit = _apply_additional_proportional_error(ug_crit, stability_uncertainty_air) ux *= ux_correction ug_crit *= ug_correction stability(ux, ug_crit, omega, label="Particle A4") plt.legend(loc=2) plt.savefig("images/stability_air_2.pdf")
def small_sep02 ( mx , mxErr, lag=0): """ Given a frequency matrix and errors calculates the (scaled) small separation d02 and propagates errors. Notes ----- The parameter lag is the difference between the radial orders of the first modes of l=0 and l=2. """ (Nn, Nl) = np.shape(mx) d02 = np.zeros((1,Nn)) d02Err = np.zeros((1,Nn)) d02.fill(None) # values that can't be calculated are NaN for n in range(1-lag,Nn): if (mx[n,0] != 0. and mx[n-1+lag,2] != 0.): a = un.ufloat( (mx[n,0], mxErr[n,0]) ) b = un.ufloat( (mx[n-1+lag,2], mxErr[n-1+lag,2]) ) result = (a-b) / 3. d02[0,n-1+lag] = un.nominal_value(result) d02Err[0,n-1+lag] = un.std_dev(result) return d02, d02Err
def _set_age_values(self, f, include_decay_error=False): arc = self.arar_constants j = copy(self.j) if j is None: j = ufloat(1e-4, 1e-7) j.tag = 'Position' j.std_dev = self.position_jerr or 0 age = age_equation(j, f, include_decay_error=include_decay_error, arar_constants=arc) self.uage_w_position_err = age j = self.j if j is None: j = ufloat(1e-4, 1e-7, tag='J') age = age_equation(j, f, include_decay_error=include_decay_error, arar_constants=arc) self.uage_w_j_err = age j = copy(self.j) if j is None: j = ufloat(1e-4, 1e-7, tag='J') j.std_dev = 0 age = age_equation(j, f, include_decay_error=include_decay_error, arar_constants=arc) self.uage = age self.age = nominal_value(age) self.age_err = std_dev(age) self.age_err_wo_j = std_dev(age) for iso in self.itervalues(): iso.age_error_component = self.get_error_component(iso.name)
def eval(self, vertex_generator, nevals, nreps=16, ndaq=50): """ Return the negative log likelihood that the detector event set in the constructor or by set_event() was the result of a particle generated by `vertex_generator`. If `nreps` set to > 1, each set of photon vertices will be propagated `nreps` times. """ ntotal = nevals * nreps * ndaq hit_prob, pdf_prob, pdf_prob_uncert = \ self.eval_channel_vbin(vertex_generator, nevals, nreps, ndaq) # NLL calculation: note that negation is at the end # Start with the probabilties of hitting (or not) the channels # Flip probability for channels in event that were not hit hit_prob[~self.event.channels.hit] = 1.0 - hit_prob[~self.event.channels.hit] # Apply a floor so that we don't take the log of zero hit_prob = np.maximum(hit_prob, 0.5 / ntotal) hit_channel_prob = np.log(hit_prob).sum() log_likelihood = ufloat((hit_channel_prob, 0.0)) # Then include the probability densities of the observed # charges and times. log_likelihood += ufloat((np.log(pdf_prob[self.event.channels.hit]).sum(), 0.0)) return -log_likelihood
import numpy as np from uncertainties import ufloat import uncertainties.unumpy as unp Lrund = np.array([60.05, 61.00, 60.00, 60.00, 60.00]) #cm Leckig = np.array([60.30, 60.30, 60.30, 60.30, 60.34]) #cm drund = np.array([10.00, 9.95, 10.00, 10.00, 10.00]) #mm aeckig = np.array([12.00, 12.00, 11.95, 12.00, 12.00]) #mm beckig = np.array([10.00, 9.95, 9.90, 9.95, 10.00]) #mm u_Lrund = ufloat(np.mean(Lrund), np.std(Lrund)) u_Leckig = ufloat(np.mean(Leckig), np.std(Leckig)) u_drund = ufloat(np.mean(drund), np.std(drund)) u_aeckig = ufloat(np.mean(aeckig), np.std(aeckig)) u_beckig = ufloat(np.mean(beckig), np.std(beckig)) print('u_Lrund', u_Lrund) print('u_Leckig', u_Leckig) print('u_drund', u_drund) print('u_aeckig', u_aeckig) print('u_beckig', u_beckig) # ––––––––– # !!! vmtl. falsch ↓ # # Flächenträgheitsmoment: # I = (u_aeckig*u_beckig**3)/12 # print("––––––") # print(f"{I=} mm^4")
def read(self, fileobj): line = self._read_until_line_startswith(fileobj, 'Simulation time') val, = self._read_all_values(line) self.simulation_time_s = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Simulation speed') val, = self._read_all_values(line) self.simulation_speed_1_per_s = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Simulated primary showers') val, = self._read_all_values(line) self.simulated_primary_showers = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Upbound primary particles') val, = self._read_all_values(line) self.upbound_primary_particles = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Downbound primary particles') val, = self._read_all_values(line) self.downbound_primary_particles = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Absorbed primary particles') val, = self._read_all_values(line) self.absorbed_primary_particles = ufloat(val, 0.0) line = self._read_until_line_startswith(fileobj, 'Upbound fraction') val, unc = self._read_all_values(line) self.upbound_fraction = ufloat(val, unc / 3) line = self._read_until_line_startswith(fileobj, 'Downbound fraction') val, unc = self._read_all_values(line) self.downbound_fraction = ufloat(val, unc / 3) line = self._read_until_line_startswith(fileobj, 'Absorption fraction') val, unc = self._read_all_values(line) self.absorbed_fraction = ufloat(val, unc / 3) self._read_until_line_startswith( fileobj, 'Secondary-particle generation probabilities') fileobj.readline() # skip header fileobj.readline() # skip header fileobj.readline() # skip header val_el, val_ph, val_po = self._read_all_values(fileobj.readline()) unc_el, unc_ph, unc_po = self._read_all_values(fileobj.readline()) self.upbound_secondary_electron_generation_probabilities = ufloat( val_el, unc_el / 3) self.upbound_secondary_photon_generation_probabilities = ufloat( val_ph, unc_ph / 3) self.upbound_secondary_positron_generation_probabilities = ufloat( val_po, unc_po / 3) fileobj.readline() # skip header val_el, val_ph, val_po = self._read_all_values(fileobj.readline()) unc_el, unc_ph, unc_po = self._read_all_values(fileobj.readline()) self.downbound_secondary_electron_generation_probabilities = ufloat( val_el, unc_el / 3) self.downbound_secondary_photon_generation_probabilities = ufloat( val_ph, unc_ph / 3) self.downbound_secondary_positron_generation_probabilities = ufloat( val_po, unc_po / 3) fileobj.readline() # skip header val_el, val_ph, val_po = self._read_all_values(fileobj.readline()) unc_el, unc_ph, unc_po = self._read_all_values(fileobj.readline()) self.absorbed_secondary_electron_generation_probabilities = ufloat( val_el, unc_el / 3) self.absorbed_secondary_photon_generation_probabilities = ufloat( val_ph, unc_ph / 3) self.absorbed_secondary_positron_generation_probabilities = ufloat( val_po, unc_po / 3) self.average_deposited_energy_eV.clear() self._read_until_line_startswith( fileobj, 'Average deposited energies (bodies)') line = fileobj.readline().strip() while line.startswith('Body'): body = int(line[5:9]) val, unc, _effic = self._read_all_values(line) self.average_deposited_energy_eV[body] = ufloat(val, unc / 3) line = fileobj.readline().strip() self.average_photon_energy_eV.clear() self._read_until_line_startswith( fileobj, 'Average photon energy at the detectors') line = fileobj.readline().strip() while line.startswith('Detector'): detector = int(line[10:12]) val, unc, _effic = self._read_all_values(line) self.average_photon_energy_eV[detector] = ufloat(val, unc / 3) line = fileobj.readline().strip() line = self._read_until_line_startswith(fileobj, 'Last random seeds') seed1, seed2 = map(int, line.split('=')[1].split(',')) self.last_random_seed1 = ufloat(seed1, 0.0) self.last_random_seed2 = ufloat(seed2, 0.0) try: self._read_until_line_startswith(fileobj, 'Reference line') val, = self._read_all_values(fileobj.readline()) self.reference_line_uncertainty = ufloat(val, 0.0) except IOError: self.reference_line_uncertainty = ufloat(0.0, 0.0)
def __init__(self): super().__init__() self.simulation_time_s = ufloat(0.0, 0.0) self.simulation_speed_1_per_s = ufloat(0.0, 0.0) self.simulated_primary_showers = ufloat(0.0, 0.0) self.upbound_primary_particles = ufloat(0.0, 0.0) self.downbound_primary_particles = ufloat(0.0, 0.0) self.absorbed_primary_particles = ufloat(0.0, 0.0) self.upbound_fraction = ufloat(0.0, 0.0) self.downbound_fraction = ufloat(0.0, 0.0) self.absorbed_fraction = ufloat(0.0, 0.0) self.upbound_secondary_electron_generation_probabilities = ufloat( 0.0, 0.0) self.downbound_secondary_electron_generation_probabilities = ufloat( 0.0, 0.0) self.absorbed_secondary_electron_generation_probabilities = ufloat( 0.0, 0.0) self.upbound_secondary_photon_generation_probabilities = ufloat( 0.0, 0.0) self.downbound_secondary_photon_generation_probabilities = ufloat( 0.0, 0.0) self.absorbed_secondary_photon_generation_probabilities = ufloat( 0.0, 0.0) self.upbound_secondary_positron_generation_probabilities = ufloat( 0.0, 0.0) self.downbound_secondary_positron_generation_probabilities = ufloat( 0.0, 0.0) self.absorbed_secondary_positron_generation_probabilities = ufloat( 0.0, 0.0) self.average_deposited_energy_eV = {} self.average_photon_energy_eV = {} self.last_random_seed1 = ufloat(0.0, 0.0) self.last_random_seed2 = ufloat(0.0, 0.0) self.reference_line_uncertainty = ufloat(0.0, 0.0)
lpos, spos, B = np.genfromtxt("data/linse1.csv",delimiter=",", unpack = True) g=lpos-20 b=spos-lpos V1= B/3 V2= b/g print("Durch Bildgroesse berechneter Massstab V=", V1) print("Durch b und g berechneter Massstab V=", V2) print("b = ", b) print("g = ", g) f= 1 / (1/b + 1/g) print ("Berechnete Brennpunkte:",f) fmitt = ufloat(np.mean(f),sem(f)) print("Gemittelter Brennpunkt mit Fehler:",fmitt) x2=np.linspace(0,15,1000) def f(x,a,c): return a * x + c m= b/(-g) plt.xlim(0,np.max(g)+2) plt.ylim(0,np.max(b)+2) plt.plot(x2, f(x2,m[0],b[0]), 'k--', linewidth=0.5) plt.plot(x2, f(x2,m[1],b[1]), 'k--', linewidth=0.5) plt.plot(x2, f(x2,m[2],b[2]), 'k-', linewidth=0.5) plt.plot(x2, f(x2,m[3],b[3]), 'k-', linewidth=0.5)
def eval_kernel(self, vertex_generator, nevals, nreps=16, ndaq=50, navg=10): """ Return the negative log likelihood that the detector event set in the constructor or by set_event() was the result of a particle generated by `vertex_generator`. If `nreps` set to > 1, each set of photon vertices will be propagated `nreps` times. """ ntotal = nevals * nreps * ndaq mom0 = 0 mom1 = 0.0 mom2 = 0.0 for i in xrange(navg): kernel_generator = islice(vertex_generator, nevals) hitcount, pdf_prob, pdf_prob_uncert = \ self.sim.eval_kernel(self.event.channels, kernel_generator, self.trange, self.qrange, nreps=nreps, ndaq=ndaq, time_only=self.time_only) # Normalize probabilities and put a floor to keep the log finite hit_prob = hitcount.astype(np.float32) / ntotal hit_prob[self.event.channels.hit] = np.maximum( hit_prob[self.event.channels.hit], 0.5 / ntotal) # Set all zero or nan probabilities to limiting PDF value bad_value = (pdf_prob <= 0.0) | np.isnan(pdf_prob) if self.time_only: pdf_floor = 1.0 / (self.trange[1] - self.trange[0]) else: pdf_floor = 1.0 / (self.trange[1] - self.trange[0]) / ( self.qrange[1] - self.qrange[0]) pdf_prob[bad_value] = pdf_floor pdf_prob_uncert[bad_value] = pdf_floor print 'channels with no data:', ( bad_value & self.event.channels.hit).astype(int).sum() # NLL calculation: note that negation is at the end # Start with the probabilties of hitting (or not) the channels log_likelihood = np.log(hit_prob[self.event.channels.hit]).sum( ) + np.log(1.0 - hit_prob[~self.event.channels.hit]).sum() log_likelihood = 0.0 # FIXME: Skipping hit/not-hit probabilities for now # Then include the probability densities of the observed # charges and times. log_likelihood += np.log(pdf_prob[self.event.channels.hit]).sum() print 'll', log_likelihood if np.isfinite(log_likelihood): mom0 += 1 mom1 += log_likelihood mom2 += log_likelihood**2 avg_like = mom1 / mom0 rms_like = (mom2 / mom0 - avg_like**2)**0.5 # Don't forget to return a negative log likelihood return ufloat((-avg_like, rms_like / sqrt(mom0)))
# Entladung des Kondensators Uc, t = np.genfromtxt('data/abfallende_flanke.txt', unpack=True) # Uc in mV, t in ms U0 = 1090 Uc[0] = 1088 params, covariance_matrix = optimize.curve_fit(linfit, t, np.log(Uc / U0)) errors = np.sqrt(np.diag(covariance_matrix)) print('a =', params[0], '+-', errors[0]) print('b =', params[1], '+-', errors[1]) a = ufloat(params[0], errors[0]) b = ufloat(params[1], errors[1]) print('RC =', (-1 / a)) plt.plot(t, np.log(Uc / U0), 'rx', label='Messwerte') plt.plot(t, linfit(t, *params), 'k-', label='Ausgleichsfunktion') plt.xlabel(r'$t/$ms') plt.ylabel(r'$\ln{\left(\frac{U_\mathrm{C}}{U_0}\right)}$') plt.legend() plt.grid() plt.tight_layout() plt.savefig('build/uc.pdf') plt.clf()
comments=['@', '#']) calc_stuff=True else: calc_stuff=False if calc_stuff: composition_data['{0}-{1}_hbnum_mean'.format(first,second)].append( np.mean(num_file[:,1])) composition_data['{0}-{1}_hbnum_std'.format(first,second)].append( np.std(num_file[:,1])) composition_data['{0}-{1}_hblife_mean'.format(first,second)].append( 10*np.sum(life_file[:,2])) # After gathering all raw, sim data, propagate error for first, second in all_hbond_pairs: ufloats = [ufloat(val,std) for val,std in zip(composition_data['{0}-{1}_hbnum_mean'.format(first, second)], composition_data['{0}-{1}_hbnum_std'.format(first, second)])] foo = np.mean(ufloats) composition_data['{0}-{1}_hbnum_mean'.format(first, second)] = foo.n composition_data['{0}-{1}_hbnum_std'.format(first, second)] = foo.s composition_data['{0}-{1}_hblife_std'.format(first, second)] = np.std( composition_data['{0}-{1}_hblife_mean'.format(first, second)]) / len( composition_data['{0}-{1}_hblife_mean'.format(first, second)]) composition_data['{0}-{1}_hblife_mean'.format(first, second)] = np.mean( composition_data['{0}-{1}_hblife_mean'.format(first, second)]) summary_df = summary_df.append(composition_data, ignore_index=True) os.chdir(curr_dir) summary_df.to_csv('specific_hbonds.csv')
print('---' * 25) print("We find standard deviations: ") print("Water - {}".format(std_water)) print("Olive Oil - {}".format(std_oil)) print("---" * 25) lit_water = 7.28e-2 lit_oil = 3.3e-2 print('---' * 25) print("Literature Values: ") print("Water - {} N/m".format(lit_water)) print("Olive Oild - {} N/m".format(lit_oil)) print("---" * 25) """ Calculating with uncertainties """ du = ufloat(0.0045, 0.0005) wat_De_avg = np.average(wat_De) wat_Ds_avg = np.average(wat_Ds) wat_De_std = np.std(wat_De) wat_Ds_std = np.std(wat_Ds) watu_De = ufloat(wat_De_avg, wat_De_std) #with uncertainties watu_Ds = ufloat(wat_Ds_avg, wat_Ds_std) oil_De_avg = np.average(o_De) oil_Ds_avg = np.average(o_Ds) oil_De_std = np.std(o_De) oil_Ds_std = np.std(o_Ds) oilu_De = ufloat(oil_De_avg, oil_De_std) #with uncertainties
def simpleFit(tree, cuts, xmean, xmin=4000, xmax=7000): """ This function fits the "Lb_M" variable of a given TTree with a model formed by a Gaussian and an exponential pdf. All shape parameters are allowed to float in the fit. The initial and range values are hardcoded in the code, except for the initial value of the Gaussian mean and the range of the Lb_M variable to be used. Returns the dataset and the composed model (RooAbsPdf) Definition of the arguments: :tree: type TTree the root TTree that contains the variable to be fitted :cuts: type str optional cuts to apply to the TTree before fitting :mean: type float initial value for the Gaussian mean that will be floated during the fit :xmin: type float, optional minimum value of the Lb_M range to be fitted. Default: 4000 :xmax: type float, optional maximum value of the Lb_M range to be fitted. Default: 7000 """ # define variables and pdfs Lb_M = RooRealVar("Lb_M", "Lb_M", xmin, xmax) mean = RooRealVar("mean", "mean", xmean, xmean - 50, xmean + 50) sigma = RooRealVar("sigma", "sigma", 20, 10, 50) gauss = RooGaussian("gauss", "gauss", Lb_M, mean, sigma) tau = RooRealVar("tau", "tau", -0.005, -0.01, 0.) exp = RooExponential("exp", "exp", Lb_M, tau) # define coefficiencts nsig = RooRealVar("nsig", "nsig", 100, 0, 2000) nbkg = RooRealVar("nbkg", "nbkg", 100, 0, 2000) # build model suma = RooArgList() coeff = RooArgList() suma.add(gauss) suma.add(exp) coeff.add(nsig) coeff.add(nbkg) model = ROOT.RooAddPdf("model", "model", suma, coeff) # define dataset if (cuts != ""): tree = tree.CopyTree(cuts) ds = RooDataSet("data", "dataset with x", tree, RooArgSet(Lb_M)) # fit and save results fitResults = model.fitTo(ds, RooFit.Save(True)) # plot dataset and fit results c = ROOT.TCanvas() massFrame = Lb_M.frame() ds.plotOn(massFrame, RooFit.Name("histo_data")) model.plotOn(massFrame) model.plotOn(massFrame, RooFit.Components("gauss"), RooFit.LineColor(2)) model.plotOn(massFrame, RooFit.Components("exp"), RooFit.LineColor(3)) model.paramOn(massFrame, RooFit.Layout(.55, .95, .93)) massFrame.Draw() c.SaveAs("fit.png") # print results print("{} has been fit to {}".format(model.GetName(), tree.GetName())) print("Total number of entries is: {}".format(ds.numEntries())) print("Number of sig entries is: {:.0f} +- {:.0f}".format( nsig.getValV(), nsig.getError())) print("Number of bkg entries is: {:.0f} +- {:.0f}".format( nbkg.getValV(), nbkg.getError())) # compute S/B with error propagation from uncertainties module nsigu = ufloat(nsig.getValV(), nsig.getError()) nbkgu = ufloat(nbkg.getValV(), nbkg.getError()) signif = nsigu / nbkgu print("S/B = {:.2f} +- {:.2f}".format(signif.nominal_value, signif.std_dev)) return ds, model, c
import uncertainties from uncertainties import ufloat import numpy as np A = ufloat(33.717, 0.9866) #mm⁻¹·s⁻¹ #A = ufloat (34, 0.9866) #mm⁻¹·s⁻¹ rho_1 = 7.82 #g·cm⁻³ rho_2 = 1.2 #g·cm⁻³ g = 9.8 #m·s⁻² #A = 2/9·(rho_1 - rho_2)·g / eta eta = 2 * (rho_1 - rho_2) * g / (9 * A) #Pa·s eta = 1000 * eta #mPa·s print('eta =', eta, 'mPa·s')
def candid_grid( input_data: Union[str, List[str]], step: int = 10, rmin: float = 20, rmax: float = 400, diam: float = 0, obs: Optional[List[str]] = None, extra_error_cp: float = 0, err_scale: float = 1, extra_error_v2: float = 0, instruments=None, doNotFit=None, ncore: int = 1, save: bool = False, outputfile: Optional[str] = None, verbose: bool = False, ): """This function is an user friendly interface between the users of amical pipeline and the CANDID analysis package (https://github.com/amerand/CANDID). Parameters: ----------- `input_data`: oifits file names or list of oifits files,\n `step`: step used to compute the binary grid positions,\n `rmin`, `rmax`: Bounds of the grid [mas],\n `diam`: Stellar diameter of the primary star [mas] (default=0),\n `obs`: List of observables to be fitted (default: ['cp', 'v2']),\n `doNotFit`: Parameters not fitted (default: ['diam*']),\n `verbose`: print some informations {default: False}. Outputs: -------- `res` {dict}: Dictionnary of the results ('best'), uncertainties ('uncer'), reduced chi2 ('chi2') and sigma detection ('nsigma'). """ if obs is None: obs = ["cp", "v2"] if doNotFit is None: doNotFit = ["diam*"] cprint(" | --- Start CANDID fitting --- :", "green") o = candid.Open( input_data, extra_error=extra_error_cp, err_scale=err_scale, extra_error_v2=extra_error_v2, instruments=instruments, ) o.observables = obs o.fitMap( rmax=rmax, rmin=rmin, ncore=ncore, fig=0, step=step, addParam={"diam*": diam}, doNotFit=doNotFit, verbose=verbose, ) if save: if isinstance(input_data, list): first_input = input_data[0] else: first_input = input_data filename = os.path.basename(first_input) + "_detection_map_candid.pdf" if outputfile is not None: filename = outputfile plt.savefig(filename, dpi=300) fit = o.bestFit["best"] e_fit = o.bestFit["uncer"] chi2 = o.bestFit["chi2"] nsigma = o.bestFit["nsigma"] f = fit["f"] / 100.0 e_f = e_fit["f"] / 100.0 if (e_f < 0) or (e_fit["x"] < 0) or (e_fit["y"] < 0): print("Warning: error dm is negative.") e_f = abs(e_f) e_fit["x"] = 0 e_fit["y"] = 0 f_u = ufloat(f, e_f) x, y = fit["x"], fit["y"] x_u = ufloat(x, e_fit["x"]) y_u = ufloat(y, e_fit["y"]) dm = -2.5 * umath.log10(f_u) s = (x_u ** 2 + y_u ** 2) ** 0.5 posang = umath.atan2(x_u, y_u) * 180 / np.pi if posang.nominal_value < 0: posang = 360 + posang cr = 1 / f_u cprint(f"\nResults binary fit (χ2 = {chi2:2.1f}, nσ = {nsigma:2.1f}):", "cyan") cprint("-------------------", "cyan") print(f"Sep = {s.nominal_value:2.1f} +/- {s.std_dev:2.1f} mas") print(f"Theta = {posang.nominal_value:2.1f} +/- {posang.std_dev:2.1f} deg") print(f"CR = {cr.nominal_value:2.1f} +/- {cr.std_dev:2.1f}") print(f"dm = {dm.nominal_value:2.2f} +/- {dm.std_dev:2.2f}") res = { "best": { "model": "binary_res", "dm": dm.nominal_value, "theta": posang.nominal_value, "sep": s.nominal_value, "diam": fit["diam*"], "x0": 0, "y0": 0, }, "uncer": {"dm": dm.std_dev, "theta": posang.std_dev, "sep": s.std_dev}, "chi2": chi2, "nsigma": nsigma, "comp": o.bestFit["best"], } return res
def U2(g, B, Mf, EHy): return g**2 * µB**2 * B**2 * (1 - Mf) / EHy def exp(x, a, b, c): return a * np.exp(b * x) + c def hyp(x, a, b, c): return a + b / (x - c) # Naturkonstanten µ = const.mu_0 me = ufloat(const.physical_constants['electron mass'][0], const.physical_constants['electron mass'][2]) e0 = ufloat(const.physical_constants['elementary charge'][0], const.physical_constants['elementary charge'][2]) µB = ufloat(const.physical_constants['Bohr magneton'][0], const.physical_constants['Bohr magneton'][2]) # Messwerte f = np.array([100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]) Us = np.array([ [4.75, 3.20, 5.50, 2.65, 2.64, 2.05, 0.87, 3.24, 1.22, 2.44], #1.Dip [5.95, 5.60, 9.00, 7.40, 8.55, 9.05, 9.12, 7.16, 6.33, 7.61] ]) #2.Dip Uh = np.array([ [0.00, 0.10, 0.10, 0.22, 0.27, 0.34, 0.42, 0.42, 0.53, 0.55], #1.Dip [0.00, 0.10, 0.10, 0.22, 0.27, 0.34, 0.42, 0.55, 0.65, 0.70] ]) #2.Dip
DATA_PATH = '../results/' for version in ['sequential', 'block', 'cyclic']: print("Working on", version) times = [] fname = '{}_benchmark.out'.format(version) with open(DATA_PATH + fname, 'r') as fstream: lines = fstream.readlines() for line in lines: if line.startswith('Time elapsed'): times.append(float(line[14:23])) times = np.asarray(times)/10000000 if version == 'sequential': tau_s = ufloat(np.mean(times), np.std(times, ddof=1)) tau = tau_s elif version == 'block': tau_b = ufloat(np.mean(times), np.std(times, ddof=1)) tau = tau_b elif version == 'cyclic': tau_c = ufloat(np.mean(times), np.std(times, ddof=1)) tau = tau_c print('Tau for {} is: {}'.format(version, tau)) print('Worst case for sequential:', tau_s*pow(2, 32), 's =', tau_s*pow(2, 32)/3600) km = pow(2, 32) k1 = 13 * km//14
def mittel(x): return ufloat(np.mean(x),np.std(x,ddof=1)/np.sqrt(len(x)))
import numpy as np import uncertainties.unumpy as unp from uncertainties import ufloat from scipy.stats import sem import matplotlib.pyplot as plt from scipy.optimize import curve_fit import scipy.constants as const num = np.arange(1, 11) b1 = ufloat(9.5, 0.8) b2 = ufloat(0.177, 0.09) v3z = ufloat(0.005, 0.001) v3o = ufloat(0.015, 0.002) s1 = ufloat(0.087, 0.011) s2 = ufloat(0.8, 0.1) v4 = ufloat(0.025, 0.005) b4 = ufloat(0.067, 0.004) v1o = ufloat(0.044, 0.004) v1z = ufloat(0.022, 0.002) #b5 Volumen berechnen di = ufloat(10, 0.5) l1 = ufloat(80, 0.5) l2 = ufloat(30, 1) b5 = np.pi * ((di / 2)**2) * l1 + 2 * np.pi * ((di / 2)**2) * l2 b5 = b5 * 1e-6 print("Vol B5 in l:", b5) b5a = ufloat(0.016, 0.002) print("B5 aus Anleitung:", b5a) #b3 Volumen berechnen
#erstelle eine .txt Datei, aus der die Werte fuer die Funktion genommen werden koennen. Das, was in der ersten Spalte steht, sind automaisch die x-Werte, #die zweite die y-Werte. x, y = np.genfromtxt('werte1.txt', unpack=True) #linregress vorbereitung(Fkt definieren m=Steigung, n=y-Schnittpkt) def f(x, m, n): return x * m + n paramsI, covarianceI = curve_fit( f, x, y ) #das muss hier einfach alles hin...kann nicht genau sagen, was es macht. errorsI = np.sqrt(np.diag(covarianceI)) n = ufloat(paramsI[1], errorsI[1]) m = ufloat(paramsI[0], errorsI[0]) print( m, n ) #Dieser Befehl gibt euch in der Kommandozeile als ersten Wert fuer m mit Fehler und den zweiten Wert #fuer n wieder mit Fehler. #with plt.xkcd(): (macht, dass die ganze Sache in comic sans ms optik ausgegeben wird. Sieht sehr fein aus, ist aber vielleicht nicht sooo wichtig) #Plot der Messwerte: L1plot = np.linspace( 0, 0.35) #Grenzen fuer linregr. guckt nach den Grenzwerten fuer die x-Werte. plt.title('Rechteckiger Stab, einseitige Einspannung' ) #Ueberschrift, die ueber dem PLot stehen wird plt.plot(
def Restframe(string, name): dirName = f'{name}' dirName = dirName.split('/')[0] if not os.path.exists(dirName): os.mkdir(dirName) print("Directory ", dirName, " Created ") else: print("Directory ", dirName, " already exists") #Creating a line dict from NIST line_dict = { 'CIV_1548': [1548.202, 0.01, r'C \Rn{4} $\lambda$ 1548'], 'SiIV_1402': [1402.77, 0.1, r'Si \Rn{4} $\lambda$ 1403'], 'Ly_a': [1215.6701, 0.0021, r'Ly-$\alpha$ $\lambda$ 1216'], 'CIII_1897': [1897.57, 0.1, r'C \Rn{3} $\lambda$ 1898'], 'MgII_2796': [2795.528, 0.01, r'Mg \Rn{2} $\lambda$ 2796'], 'MgII_2803': [2802.705, 0.01, r'Mg \Rn{2} $\lambda$ 2803'], 'OIII_5007': [5006.843, 0.01, r'O \Rn{3} $\lambda$ 5007'], 'H_b': [4861.283363, 0.000024, r'H-$\beta$ $\lambda$ 4861'], 'H_a': [6562.85117, 0.00003, r'H-$\alpha$ $\lambda$ 6563'], 'SiII_989': [989.87, 0.1, r'Si \Rn{2} $\lambda$ 989'], 'BeIII_4487': [4487.30, 0.10, r'Be \Rn{3} $\lambda$ 4487'], 'AlII_1670': [1670.7874, 0.001, r'Al \Rn{2} $\lambda$ 1670'], 'NV_1239': [1238.8210, 0.01, r'N \Rn{5} $\lambda$ 1239'], 'CuII_10852': [10852.401, 0.004, r'Cu \Rn{2} $\lambda$ 10852'], 'CuII_5007': [5006.79978, 0.00015, r'Cu \Rn{2} $\lambda$ 5007'], 'TiIII_4971': [4971.194, 0.010, r'Ti \Rn{3} $\lambda$ 4971'], 'ZnII_2026': [2025.4845, 0.001, r'Zn \Rn{2} $\lambda$ 2026'], 'ZnII_2062': [2062.0011, 0.0010, r'Zn \Rn{2} $\lambda$ 2062'], 'ZnII_2064': [2064.2266, 0.0010, r'Zn \Rn{2} $\lambda$ 2064'], 'SiII_1808': [1808.00, 0.10, r'Si \Rn{2} $\lambda$ 1808'], 'FeII_1611': [1610.9229, 0.0005, r'Fe \Rn{2} $\lambda$ 1611'], 'FeII_2249': [2249.05864, 0.00011, r'Fe \Rn{2} $\lambda$ 2249'], 'FeII_2260': [2260.5173, 0.0019, r'Fe \Rn{2} $\lambda$ 2260'], 'SiII_1526': [1526.734, 0.10, r'Si \Rn{2} $\lambda$ 1526'], 'FeI_3021': [3021.0725, 0.0003, r'Fe \Rn{2} $\lambda$ 3021'], 'FeII_2344': [2344.9842, 0.0001, r'Fe \Rn{2} $\lambda$ 2344'], 'FeII_2374': [2374.6530, 0.0001, r'Fe \Rn{2} $\lambda$ 2374'], 'FeII_2382': [2382.0373, 0.0001, r'Fe \Rn{2} $\lambda$ 2382'], 'FeII_2586': [2585.8756, 0.0001, r'Fe \Rn{2} $\lambda$ 2586'], 'CrII_2026': [2025.6186, 0.0001, r'Cr \Rn{2} $\lambda$ 2026'], 'CrII_2062': [2061.57673, 0.00007, r'Cr \Rn{2} $\lambda$ 2062'], 'CrII_2056': [2055.59869, 0.00006, r'Cr \Rn{2} $\lambda$ 2056'], 'CrII_2066': [2065.50389, 0.00007, r'Cr \Rn{2} $\lambda$ 2066'], 'MnII_1162': [1162.0150, 0.0001, r'Mn \Rn{2} $\lambda$ 1162'], 'MnII_1197': [1197.1840, 0.0001, r'Mn \Rn{2} $\lambda$ 1197'], 'MnII_1199': [1199.3910, 0.0001, r'Mn \Rn{2} $\lambda$ 1199'], 'MnII_1201': [1201.1180, 0.0001, r'Mn \Rn{2} $\lambda$ 1201'], 'MnII_2576': [2576.8770, 0.0001, r'Mn \Rn{2} $\lambda$ 2576'], 'MnII_2594': [2594.4990, 0.0001, r'Mn \Rn{2} $\lambda$ 2594'], 'MnII_2606': [2606.4630, 0.0001, r'Mn \Rn{2} $\lambda$ 2606'], 'NiII_1317': [1317.2170, 0.0001, r'Ni \Rn{2} $\lambda$ 1317'], 'NiII_1345': [1345.8780, 0.0001, r'Ni \Rn{2} $\lambda$ 1345'], 'NiII_1370': [1370.1320, 0.0001, r'Ni \Rn{2} $\lambda$ 1370'], 'NiII_1393': [1393.3240, 0.0001, r'Ni \Rn{2} $\lambda$ 1393'], 'NiII_1454': [1454.8420, 0.0001, r'Ni \Rn{2} $\lambda$ 1454'], 'NiII_1502': [1502.1480, 0.0001, r'Ni \Rn{2} $\lambda$ 1502'], 'NiII_1703': [1703.4050, 0.0001, r'Ni \Rn{2} $\lambda$ 1703'], 'NiII_1709': [1709.6000, 0.0001, r'Ni \Rn{2} $\lambda$ 1709'], 'NiII_1741': [1741.5490, 0.0001, r'Ni \Rn{2} $\lambda$ 1741'], 'NiII_1751': [1751.9100, 0.0001, r'Ni \Rn{2} $\lambda$ 1751'], 'NiII_1773': [1773.9490, 0.0001, r'Ni \Rn{2} $\lambda$ 1773'], 'NiII_1804': [1804.4730, 0.0001, r'Ni \Rn{2} $\lambda$ 1804'], 'CrII_1058': [1058.7320, 0.0001, r'Cr \Rn{2} $\lambda$ 1058'], 'CrII_1059': [1059.7320, 0.0001, r'Cr \Rn{2} $\lambda$ 1059'], 'CrII_1064': [1064.1240, 0.0001, r'Cr \Rn{2} $\lambda$ 1064'], 'CrII_1066': [1066.7760, 0.0001, r'Cr \Rn{2} $\lambda$ 1066'], 'SiII_1020': [1020.6989, 0.1, r'Si \Rn{2} $\lambda$ 1020'], 'SiIV_1062': [1062.66, 0.1, r'Si \Rn{4} $\lambda$ 1062'], 'SiII_1190': [1190.4158, 0.1, r'Si \Rn{2} $\lambda$ 1190'], 'SiII_1193': [1193.2897, 0.1, r'Si \Rn{2} $\lambda$ 1193'], 'SiIII_1206': [1206.5000, 0.1, r'Si \Rn{3} $\lambda$ 1206'], 'SiII_1260': [1260.4221, 0.1, r'Si \Rn{2} $\lambda$ 1260'], 'SiII_1304': [1304.3702, 0.1, r'Si \Rn{2} $\lambda$ 1304'], 'SiI_1554': [1554.2960, 0.1, r'Si \Rn{1} $\lambda$ 1554'], 'SiI_1562': [1562.0020, 0.1, r'Si \Rn{1} $\lambda$ 1562'], 'SiI_1625': [1625.7051, 0.1, r'Si \Rn{1} $\lambda$ 1625'], 'SiI_1631': [1631.1705, 0.1, r'Si \Rn{1} $\lambda$ 1631'], 'SiIV_1693': [1693.2935, 0.1, r'Si \Rn{4} $\lambda$ 1693'], 'SiI_2515': [2515.0725, 0.1, r'Si \Rn{1} $\lambda$ 2515'], 'SiI_2208': [2208.6665, 0.1, r'Si \Rn{1} $\lambda$ 2208'], 'SiIII_1892': [1892.0300, 0.1, r'Si \Rn{3} $\lambda$ 1892'], 'SiI_1845': [1845.5202, 0.1, r'Si \Rn{1} $\lambda$ 1845'], 'FeII_935': [935.5175, 0.001, r'Fe \Rn{2} $\lambda$ 935'], 'FeII_937': [937.6520, 0.001, r'Fe \Rn{2} $\lambda$ 937'], 'FeII_1055': [1055.2617, 0.001, r'Fe \Rn{2} $\lambda$ 1055'], 'FeII_1062': [1062.1520, 0.001, r'Fe \Rn{2} $\lambda$ 1062'], 'FeII_1081': [1081.8750, 0.001, r'Fe \Rn{2} $\lambda$ 1081'], 'FeII_1083': [1083.4200, 0.001, r'Fe \Rn{2} $\lambda$ 1083'], 'FeII_1096': [1096.8769, 0.001, r'Fe \Rn{2} $\lambda$ 1096'], 'FeIII_1122': [1122.5360, 0.001, r'Fe \Rn{3} $\lambda$ 1122'], 'FeII_1144': [1144.9379, 0.001, r'Fe \Rn{2} $\lambda$ 1144'], 'FeII_1260': [1260.5330, 0.001, r'Fe \Rn{2} $\lambda$ 1260'], 'FeII_1608': [1608.4511, 0.001, r'Fe \Rn{2} $\lambda$ 1608'], 'FeII_1611': [1611.2005, 0.001, r'Fe \Rn{2} $\lambda$ 1611'], 'FeI_1934': [1934.5351, 0.001, r'Fe \Rn{1} $\lambda$ 1934'], 'FeI_1937': [1937.2682, 0.001, r'Fe \Rn{1} $\lambda$ 1937'], 'FeI_2167': [2167.4531, 0.001, r'Fe \Rn{1} $\lambda$ 2167'], 'FeII_2344': [2344.2140, 0.001, r'Fe \Rn{2} $\lambda$ 2344'], 'FeII_2382': [2382.7650, 0.001, r'Fe \Rn{2} $\lambda$ 2382'], 'FeII_2484': [2484.0211, 0.001, r'Fe \Rn{2} $\lambda$ 2484'], 'FeI_2523': [2523.6083, 0.001, r'Fe \Rn{1} $\lambda$ 2523'], 'FeII_2600': [2600, 0.001, r'Fe \Rn{2} $\lambda$ 2600'], 'FeI_2719': [2719.8331, 0.001, r'Fe \Rn{1} $\lambda$ 2719'], 'FeI_3021': [3021.5189, 0.001, r'Fe \Rn{1} $\lambda$ 3021'], 'AlIII_1854': [1854.7164, 0.1, r'Al \Rn{3} $\lambda$ 1854'], 'AlIII_1862': [1862.7895, 0.1, r'Al \Rn{3} $\lambda$ 1862'], 'MgI_2852': [2852.1370, 0.1, r'Mg \Rn{1} $\lambda$ 2852'], 'MgI_2026': [2026.4768, 0.1, r'Mg \Rn{1} $\lambda$ 2026'], 'PII_1152': [1152.8180, 0.001, r'P \Rn{2} $\lambda$ 1152'], 'CuII_1358': [1358.7730, 0.001, r'Cu \Rn{2} $\lambda$ 1358'] } time_signature = datetime.now().strftime("%m%d-%H%M") name = name.replace('.txt', '') output_name = f'Final_table_{time_signature}_{dirName}.txt' numify = lambda x: float(''.join( char for char in x if char.isdigit() or char == "." or char == "-")) tex_table = string tex_document = r""" \begin{table}[H] \begin{tabular}{cccccccc} Transition & EW$_r$ [Å] & Redshift\\ \hline """ approx_z = float(input('What is the approximate redshift?')) lines = tex_table.split(r"\\")[0:-1] data = [] text = [] # Interactive way of categorising the lines for line in lines: [_, wave, eq, _] = line.strip().split("&") [wave, wave_err] = wave.split(r"\pm") [eq, eq_err] = eq.split(r"\pm") line_exp = unc.ufloat(numify(wave), numify(wave_err)) / (1 + approx_z) ordered_dict = collections.OrderedDict( sorted(line_dict.items(), key=lambda v: v[1])) line_true = input( f'\n What is this line {line_exp}? Please choose from: \n {ordered_dict.keys()}: ' ) data.append([ unc.ufloat(numify(wave), numify(wave_err)), unc.ufloat(numify(eq), numify(eq_err)), unc.ufloat(line_dict[f'{line_true}'][0], line_dict[f'{line_true}'][1]) ]) text.append(line_dict[f'{line_true}'][2]) data = unumpy.matrix(data) z = (data[:, 0] / data[:, 2] - 1) # The errors and their contribution to the weighted redshift avarage z_avg = np.mean(z) var = sum(pow(i - z_avg, 2) for i in z) / len(z) var = var[0, 0] z_avg_std = math.sqrt(var.nominal_value) ew_r = (data[:, 1] / (z_avg + 1)) # Creating a LaTeX table for the results tex_begin = "\\noindent The weighted avarage of the redshift is $z = {:.1uL}$".format( z_avg) for i in range(len(z)): eq_value = ew_r[i, 0] z_value = z[i, 0] tex_document += " {0} & ${1:.1uL}$ & ${2:.1uL}$ \\\\".format( text[i], eq_value, z_value) tex_footer = r""" \hline \end{tabular} \end{table} """ output_name = dirName + "/" + output_name with open(output_name, "w+") as outfile: outfile.write(tex_begin + tex_document + tex_footer) # When the file is saved, it is also printed and inserted in the clip board print(tex_begin + tex_document + tex_footer) copy(tex_begin + tex_document + tex_footer)
import numpy as np import uncertainties.unumpy as unp from uncertainties import ufloat from scipy.stats import sem print('====================') print('Widerstand ANFANG') print('====================') print('Wert 12 ANFANG') ra2 = ufloat(1000, 1000 * 0.002) pot1a = 2.82 pot1b = 10 - pot1a pot1c = pot1a / pot1b pota = ufloat(pot1c, pot1c * 0.005) ra1 = ra2 * pota print('ra1', ra1) rb2 = ufloat(664, 664 * 0.002) pot2a = 3.73 pot2b = 10 - pot2a pot2c = pot2a / pot2b potb = ufloat(pot2c, pot2c * 0.005) rb1 = rb2 * potb print('rb1', rb1) rc2 = ufloat(332, 332 * 0.002) pot3a = 5.42 pot3b = 10 - pot3a pot3c = pot3a / pot3b potc = ufloat(pot3c, pot3c * 0.005) rc1 = rc2 * potc
def __init__(self, identifier, force_download=False, configFile=None, query_dace=True, query_tepcat=True, T0=None, P=None, ecosw=None, esinw=None, depth=None, width=None, K=None, verbose=True): self.identifier = identifier self.T0 = T0 self.P = P self.ecosw = ecosw self.esinw = esinw self.depth = depth self.width = width self.K = K config = load_config(configFile) _cache_path = config['DEFAULT']['data_cache_path'] if query_dace: f = {"obj_id_planet_catname":{"contains":[identifier]}} planet_data = Cheops.query_catalog('planet', filters=f) target = planet_data['obj_id_planet_catname'] if len(target) == 1: if verbose: print('Target ',target[0],' found in DACE-Planets.') T0_val = planet_data['obj_trans_t0_bjd'][0] T0_err = planet_data['obj_trans_t0_bjd_err'][0] P_val = planet_data['obj_trans_period_days'][0] P_err = planet_data['obj_trans_period_days_err'][0] ecosw_val = planet_data['obj_trans_ecosw'][0] ecosw_err = planet_data['obj_trans_ecosw_err'][0] esinw_val = planet_data['obj_trans_esinw'][0] esinw_err = planet_data['obj_trans_esinw_err'][0] depth_val = planet_data['obj_trans_depth_ppm'][0] depth_err = planet_data['obj_trans_depth_ppm_err'][0] width_val = planet_data['obj_trans_duration_days'][0] width_err = planet_data['obj_trans_duration_days_err'][0] # 'obj_rv_k_mps' is in km/s so need to convert to m/s # Note use of np.float to avoid problems with 'NaN' values K_val = np.float(planet_data['obj_rv_k_mps'][0])*1000 K_err = np.float(planet_data['obj_rv_k_mps_err'][0])*1000 # Still need to get errors on these parameters and replace # np.nan with None try: self.T0 = ufloat(float(T0_val),float(T0_err)) self.T0_note = "DACE-Planets" except: self.T0 = None try: self.P = ufloat(float(P_val),float(P_err)) self.P_note = "DACE-Planets" except: self.P = None try: self.ecosw=ufloat(float(ecosw_val),float(ecosw_err)) self.ecosw_note = "DACE-Planets" except: self.ecosw = None try: self.esinw=ufloat(float(esinw_val),float(esinw_err)) self.esinw_note = "DACE-Planets" except: self.esinw = None try: self.depth=ufloat(float(depth_val),float(depth_err)) self.depth_note = "DACE-Planets" except: self.depth = None try: self.width=ufloat(float(width_val),float(width_err)) self.width_note = "DACE-Planets" except: self.width = None try: self.K=ufloat(float(K_val),float(K_err)) self.K_note = "DACE-Planets" except: self.K = None # Tidy up any missing values stored as NaNs in DACE if np.isnan(self.depth.n): self.depth = None if np.isnan(self.width.n): self.width = None if np.isnan(self.ecosw.n): self.ecosw = None if np.isnan(self.esinw.n): self.esinw = None if np.isnan(self.K.n): self.K = None elif len(target) < 1: print('No matching planet in DACE-Planets.') if verbose: print('List of valid planet_id keys:') l = Cheops.query_catalog('planet')['obj_id_planet_catname'] print(l) else: print(r'Target ',identifier,'not defined uniquely: ',target) if query_tepcat: TEPCatObsPath = Path(_cache_path,'observables.csv') download_tepcat = False if force_download: download_tepcat = True elif TEPCatObsPath.is_file(): file_age = mktime(localtime())-os.path.getmtime(TEPCatObsPath) if file_age > int(config['TEPCatObs']['update_interval']): download_tepcat = True else: download_tepcat = False else: download_tepcat = True if download_tepcat: try: url = config['TEPCatObs']['download_url'] except: raise KeyError("TEPCatObs table not found in config file." " Run core.setup_config") try: req=requests.post(url) except: warnings.warn("Failed to update TEPCatObs from server") else: with open(TEPCatObsPath, 'wb') as file: file.write(req.content) if verbose: print('TEPCat data downloaded from \n {}'.format(url)) # Awkward table to deal with because of repeated column names T = Table.read(TEPCatObsPath,format='ascii.no_header') hdr = list(T[0]) targets=np.array(T[T.colnames[hdr.index('System')]][1:], dtype=np.str_) RAh=np.array(T[T.colnames[hdr.index('RAh')]][1:], dtype=np.str_) RAm=np.array(T[T.colnames[hdr.index('RAm')]][1:], dtype=np.str_) RAs=np.array(T[T.colnames[hdr.index('RAs')]][1:], dtype=np.str_) Decd=np.array(T[T.colnames[hdr.index('Decd')]][1:], dtype=np.str_) Decm=np.array(T[T.colnames[hdr.index('Decm')]][1:], dtype=np.str_) Decs=np.array(T[T.colnames[hdr.index('Decs')]][1:], dtype=np.str_) T0_vals=np.array(T[T.colnames[hdr.index('T0(HJDorBJD)')]][1:], dtype=np.float) T0_errs=np.array(T[T.colnames[hdr.index('T0err')]][1:], dtype=np.float) periods=np.array(T[T.colnames[hdr.index('Period(day)')]][1:], dtype=np.float) perrors=np.array(T[T.colnames[hdr.index('Perioderr')]][1:], dtype=np.float) lengths=np.array(T[T.colnames[hdr.index('length')]][1:], dtype=np.float) depths =np.array(T[T.colnames[hdr.index('depth')]][1:], dtype=np.float) ok = [t.startswith(identifier.replace(' ','_')) for t in targets] if sum(ok) > 1: print('Matching planet names: ', *targets[ok]) raise ValueError('More than one planet matches identifier.') elif sum(ok) == 1: T0_val=T0_vals[ok][0] T0_err=T0_errs[ok][0] period=periods[ok][0] perror=perrors[ok][0] length=lengths[ok][0] depth_val=depths[ok][0]*10000 else: try: tar_coords = SkyCoord.from_name(identifier) all_coords = [] for index, i in enumerate(RAh): all_coords.append( RAh[index]+":"+RAm[index]+":"+RAs[index]+" "+ Decd[index]+":"+Decm[index]+":"+Decs[index]) TEPCat_coords = SkyCoord(all_coords, frame="icrs", unit=(u.hourangle, u.deg)) ok = tar_coords.separation(TEPCat_coords) < 5*u.arcsec if sum(ok) > 1: print('Matching planets: ', *targets[ok]) raise ValueError( 'More than one planet matches coordinates.') elif sum(ok)==1: T0_val=T0_vals[ok][0] T0_err=T0_errs[ok][0] period=periods[ok][0] perror=perrors[ok][0] length=lengths[ok][0] depth_val=depths[ok][0]*10000 else: print('No matching planet in TEPCat.') except: print('No coordinate match for planet in TEPCat.') if sum(ok)==1: if self.T0 == None: try: self.T0 = ufloat(float(T0_val),float(T0_err)) self.T0_note = "TEPCat" except: self.T0 = None if self.P == None: try: self.P = ufloat(float(period),float(perror)) self.P_note = "TEPCat" except: self.P = None if self.depth == None: try: self.depth=ufloat(float(depth_val),1e2) self.depth_note = "TEPCat" except: self.depth = None if self.width == None: try: self.width=ufloat(float(length),0.01) self.width_note = "TEPCat" except: self.width = None # User defined values if T0: if isinstance(T0, UFloat): self.T0 = T0 self.T0_note = "User" else: raise ValueError("T0 keyword is not ufloat") if P: if isinstance(P, UFloat): self.P = P self.P_note = "User" else: raise ValueError("P keyword is not ufloat") if ecosw: if isinstance(ecosw, UFloat): self.ecosw = ecosw self.ecosw_note = "User" else: raise ValueError("ecosw keyword is not ufloat") if esinw: if isinstance(esinw, UFloat): self.esinw = esinw self.esinw_note = "User" else: raise ValueError("esinw keyword is not ufloat") if depth: if isinstance(depth, UFloat): self.depth = depth self.depth_note = "User" else: raise ValueError("depth keyword is not ufloat") if width: if isinstance(width, UFloat): self.width = width self.width_note = "User" else: raise ValueError("width keyword is not ufloat") if K: if isinstance(K, UFloat): self.K = K self.K_note = "User" else: raise ValueError("K keyword is not ufloat") # Eccentricity and omega from ecosw and esinw self.ecc = None self.omega = None self.f_s = None self.f_c = None if self.ecosw and self.esinw: ecosw = self.ecosw esinw = self.esinw ecc = usqrt(ecosw*ecosw+esinw*esinw) if ecc.n != 0: omega = uatan2(esinw,ecosw) f_s = usqrt(ecc)*usin(omega) f_c = usqrt(ecc)*ucos(omega) elif ecc.s != 0: # Work-around to avoid NaNs for e=0 with finite error. eps = .0001 ecc = usqrt((ecosw+eps)**2+(esinw+eps)**2)-eps omega = None f_s = ufloat(0,np.sqrt(esinw.s)) f_c = ufloat(0,np.sqrt(ecosw.s)) else: ecc = None omega = None f_s = None f_c = None self.ecc = ecc self.ecc_note = "Derived" self.omega = omega self.omega_note = "Derived" self.f_s = f_s self.f_s_note = "Derived" self.f_c = f_c self.f_c_note = "Derived"
import numpy as np import scipy.constants as const from uncertainties import ufloat from uncertainties import unumpy as unp from scipy.optimize import curve_fit import matplotlib.pyplot as plt import scipy.constants as const import math a = ufloat(-2.64611770, 0.148322358) * (10**(4)) L = ufloat(10.11, 0.03) * (10**(-3)) C = ufloat(2.098, 0.006) * (10**(-9)) R_1 = ufloat(48.1, 0.1) R_2 = ufloat(509.5, 0.5) T_ex = -1 / a R_eff = -2 * L * a print("a", a, "T_ex", T_ex, "R_eff", R_eff)
pylab.ylabel('I_c (mA)') pylab.grid(color="gray") #Fare attenzione che gli errori devono essere sempre sommati con le stesse unita di misura, #quindi nel coeffiente ci cade anche il fattore per passare da una unita di misura all'altra error = pylab.sqrt(dIc**2) init = numpy.array([0.005, 0.005]) par, cov = curve_fit(linear, Vce, Ic, init, error, "true") #trattazione statistica degli errori print(par, cov) #Di nuovo co capisco il chi quadro, non cambia nulla se cambio da true a false a = par[0] b = par[1] a = ufloat(a, cov[0][0]**0.5) b = ufloat(b, cov[1][1]**0.5) print(a, b) print("Early = ", -b / a) chisq = ((Ic - linear(Vce, a, b)) / error)**2 somma = sum(chisq) ndof = len(Vce) - 2 #Tolgo due parametri estratti dal fit p = 1.0 - scipy.stats.chi2.cdf(somma, ndof) print("Chisquare/ndof = %f/%d" % (somma, ndof)) print("p = ", p) #Routine per stampare due rette: div = 1000 bucket = numpy.array([0.0 for i in range(div)])
def gcFit(x, y): """ Perform the glow curve deconvolution for a given glow curve. Parameters ---------- x array-like or string. If array-like, used as x-axis of analysis, should be temperature array from Treco. If string, the call will return a callable to be applied to a data set containing that x column y array-like or string. If array-like, used as y-axis of analysis, typically photon counts of measurement. If string, the call will return a callable to be applied to a data set containing that y column Returns ------- GCio object containing the fitted data. """ if isinstance(x, str): return gcFitWrapper( x, y ) #if isinstance(data, pd.DataFrame) else data.update(gcFitWrapper(data[x], data[y])) # return lambda data: gcFit(data[x], data[y]) if isinstance(data, pd.DataFrame) else data.update(gcFit(data[x], data[y])) results = {} gcTemp = np.array(x) gcPhotons = np.array(y) ################################################################################################ errors_kitis1998 = 0 errors_kitis2006 = 0 errors_red_chi2_greater_10 = 0 # binWidth = 2.5 #gcTemp = np.linspace(T.min(), T.max(), int((T.max()- T.min())/binWidth)) #gcPhotons = utils.rebinHistRescale(T , tPhotons, gcTemp) upperTCut = 580 lowerTCut = 350 indices = np.where([gcTemp > lowerTCut, gcTemp < upperTCut]) indices = np.intersect1d(indices[1][np.where(indices[0] == 0)], indices[1][np.where(indices[0] == 1)]) gcTemp = gcTemp[indices] gcPhotons = gcPhotons[indices] results["gcfit_T"] = gcTemp results["gcfit_nPhotons"] = gcPhotons # initialize start values startT = utils.peakTemps startE = np.array([1.25, 1.55, 1.46, 2.4]) startI = np.array( [100, gcPhotons.max() / 3, gcPhotons.max() / 2, 0.9 * gcPhotons.max()]) startBg = np.array([100, gcTemp.max() + 1, 1e-15, 1e-2]) p0 = np.concatenate((startT, startI, startE, startBg)) bounds = ( [ startT[0] - 10, startT[1] - 10, startT[2] - 10, startT[3] - 10, 0, 0, 0, 0, 0.5, 1, 1, 1, 0, gcTemp.max() + 1, 0, 0.0 ], #minima [ startT[0] + 10, startT[1] + 10, startT[2] + 10, startT[3] + 10, np.inf, np.inf, np.inf, np.inf, 2.3, 3.5, 3.4, 4.5, np.inf, 580, 10, .1 ] #maxima ) # fit marker error = False prefitVals = None # actual fit t0 = time.time() try: params, cov = curve_fit( fitmethod_kitis98, gcTemp, gcPhotons, p0=p0, bounds=bounds, ) prefitVals = params except Exception as e: results["gcfit_prefit_error"] = True Warning('Fit error kitis 98') if isinstance(prefitVals, np.ndarray): p0 = prefitVals try: params, cov = curve_fit( fitmethod_kitis06, gcTemp, gcPhotons, p0=p0, bounds=bounds, ) except Exception as e: Warning('Fit error kitis 06') results["gcfit_error"] = True return results tcpu = round(1000 * (time.time() - t0), 3) fitValues = params fitErrors = np.sqrt(np.diag(cov)) I_pred = fitmethod_kitis06(gcTemp, *params) results["gcfit_gcd"] = I_pred chiSquare = utils.calcRedChisq(gcPhotons, I_pred, np.sqrt(gcPhotons), len(gcPhotons) - len(params)) ####################### data extraction ################# ######################################################### results["gcfit_cpuTime"] = tcpu results["gcfit_redChi2"] = chiSquare Nsig = 0 #unc.ufloat(0,0) for peak in range(4): results["gcfit_Tm%s" % (peak + 2)] = fitValues[peak] results["gcfit_Tm%s_std_dev" % (peak + 2)] = fitErrors[peak] results["gcfit_Im%s" % (peak + 2)] = fitValues[peak + 4] results["gcfit_Im%s_std_dev" % (peak + 2)] = fitErrors[peak + 4] results["gcfit_E%s" % (peak + 2)] = fitValues[peak + 8] results["gcfit_E%s_std_dev" % (peak + 2)] = fitErrors[peak] + 8 peakI = utils.ckitis2006(gcTemp, fitValues[peak], fitValues[peak + 4], fitValues[peak + 8]) results["gcfit_gcd_peak%s" % (peak + 2)] = peakI N_peakI = peakI[1:] * np.diff(gcTemp) results["gcfit_N%s" % (peak + 2)] = np.sum(N_peakI) Nsig += np.sum(N_peakI) results["gcfit_Nsig"] = Nsig uA = unc.ufloat(fitValues[-4], fitErrors[-4]) uB = unc.ufloat(fitValues[-3], fitErrors[-3]) uC = unc.ufloat(fitValues[-2], fitErrors[-2]) uD = unc.ufloat(fitValues[-1], fitErrors[-1]) uIbg = (uA / (uB - gcTemp) + uC * unp.exp((gcTemp - 300) * uD)) uIbg = np.where(unp.nominal_values(uIbg) < 0, 0, uIbg) # uNbg = (uA/(uB-gcTemp[1:])+uC * unp.exp((gcTemp[1:]-300)*uD))*np.diff(gcTemp) # uNbg = np.where(unp.nominal_values(uNbg) < 0,0,uNbg) results["gcfit_gcd_bg"] = unp.nominal_values(uIbg) uNbg = uIbg[1:] * np.diff(gcTemp) results["gcfit_a"] = fitValues[-4] results["gcfit_a_std_dev"] = fitErrors[-4] results["gcfit_b"] = fitValues[-3] results["gcfit_b_std_dev"] = fitErrors[-3] results["gcfit_c"] = fitValues[-2] results["gcfit_c_std_dev"] = fitErrors[-2] results["gcfit_d"] = fitValues[-1] results["gcfit_d_std_dev"] = fitErrors[-1] try: results["gcfit_Nbg"] = np.sum(uNbg).nominal_value results["gcfit_Nbg_std_dev"] = np.sum(uNbg).std_dev results["gcfit_Ntot"] = (Nsig + np.sum(uNbg)).nominal_value results["gcfit_Ntot_std_dev"] = (Nsig + np.sum(uNbg)).std_dev except AttributeError: results["gcfit_Nbg"] = -1 results["gcfit_Nbg_std_dev"] = -1 results["gcfit_Ntot"] = -1 results["gcfit_Ntot_std_dev"] = -1 return results
def wregress(x,y,sy): m1=[[np.sum(x**2/sy**2), np.sum(x/sy**2)],[np.sum(x/sy**2),np.sum(1/sy**2)]] m2=[[np.sum(x*y/sy**2)],[np.sum(y/sy**2)]] [a,b]=linalg.solve(m1,m2) return [a,b] def cerror(x,y,sy): d=np.sum(1/sy**2)*np.sum(x**2/sy**2)-(np.sum(x/sy**2))**2 sa=sa=np.sqrt(1/d*np.sum(1/sy**2)) sb=np.sqrt(1/d*np.sum(x**2/sy**2)) return sa, sb thickness=np.array([0,1,2,3,4,5,6]) Al_width_single=ufloat(10e-3,0.01e-3) Pb_widthlarge=ufloat(10.03e-3,0.02e-3) Pb_widthsmall=ufloat(4.98e-3,0.03e-3) density_Al=ufloat(2.558,0.001) Al_width=Al_width_single*thickness Al_thickness=Al_width*100*density_Al Al_n=unumpy.nominal_values(Al_thickness) Al_e=unumpy.std_devs(Al_thickness) Al_1_n=np.array([0.0, 5.116,7.6739999999999995,10.232,12.79, 15.347999999999999]) Al_1_e=np.array([0, 0.005493037047025989, 0.008239555570538983 , 0.010986074094051978, 0.013732592617564975 , 0.016479111141077966]) print(Al_e[1]) Al_5_n=np.array([0.0, 2.558, 5.116,7.6739999999999995,10.232, 15.347999999999999]) Al_5_e=np.array([0,0.0027465185235129945, 0.005493037047025989, 0.008239555570538983 , 0.010986074094051978 , 0.016479111141077966])
import numpy as np from uncertainties import ufloat from uncertainties.umath import * #Massendurchsätze L = ufloat(18830, 190) T_1 = ufloat(-0.01170, 0.00030) T_2 = ufloat(-0.00949, 0.00030) T_3 = ufloat(-0.00729, 0.00030) T_4 = ufloat(-0.00509, 0.00030) m_1 = (750 + 16720) * T_1 * 120.9 / L m_2 = (750 + 16720) * T_2 * 120.9 / L m_3 = (750 + 16720) * T_3 * 120.9 / L m_4 = (750 + 16720) * T_4 * 120.9 / L #print(m_1, m_2, m_3, m_4) #Kompressorleistung p_a = np.array([440000, 400000, 380000, 370000]) p_b = np.array([860000, 940000, 1080000, 1150000]) m = np.array([m_1, m_2, m_3, m_4]) r = np.array([23100, 21000, 19900, 19400]) k = 1.14 N = 1 / 0.14 * (p_b * (p_a / p_b)**(1 / k) - p_a) * (1 / r) * m print(N)
def curve_fit( func: Callable, xdata: np.ndarray, ydata: np.ndarray, p0: Union[Dict[str, float], np.ndarray], sigma: Optional[np.ndarray] = None, bounds: Optional[Union[Dict[str, Tuple[float, float]], Tuple[np.ndarray, np.ndarray]]] = None, **kwargs, ) -> FitData: r"""Perform a non-linear least squares to fit This solves the optimization problem .. math:: \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i \sigma_i^{-2} (f(x_i, \Theta) - y_i)^2 using :func:`scipy.optimize.curve_fit`. Args: func: a fit function `f(x, *params)`. xdata: a 1D float array of x-data. ydata: a 1D float array of y-data. p0: initial guess for optimization parameters. sigma: Optional, a 1D array of standard deviations in ydata in absolute units. bounds: Optional, lower and upper bounds for optimization parameters. kwargs: additional kwargs for :func:`scipy.optimize.curve_fit`. Returns: result containing ``popt`` the optimal fit parameters, ``popt_err`` the standard error estimates popt, ``pcov`` the covariance matrix for the fit, ``reduced_chisq`` the reduced chi-squared parameter of fit, ``dof`` the degrees of freedom of the fit, ``xrange`` the range of xdata values used for fit. Raises: AnalysisError: When the number of degrees of freedom of the fit is less than 1, or the curve fitting fails. .. note:: ``sigma`` is assumed to be specified in the same units as ``ydata`` (absolute units). If sigma is instead specified in relative units the `absolute_sigma=False` kwarg of scipy :func:`~scipy.optimize.curve_fit` must be used. This affects the returned covariance ``pcov`` and error ``popt_err`` parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq`` ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``. """ # Format p0 parameters if specified as dictionary if isinstance(p0, dict): param_keys = list(p0.keys()) param_p0 = list(p0.values()) # Convert bounds if bounds: lower = [bounds[key][0] for key in param_keys] upper = [bounds[key][1] for key in param_keys] param_bounds = (lower, upper) else: param_bounds = ([-np.inf] * len(param_keys), [np.inf] * len(param_keys)) # Convert fit function def fit_func(x, *params): return func(x, **dict(zip(param_keys, params))) else: param_keys = [f"p{i}" for i in range(len(p0))] param_p0 = p0 if bounds: param_bounds = bounds else: param_bounds = ([-np.inf] * len(p0), [np.inf] * len(p0)) fit_func = func # Check the degrees of freedom is greater than 0 dof = len(ydata) - len(param_p0) if dof < 1: raise AnalysisError( "The number of degrees of freedom of the fit data and model " " (len(ydata) - len(p0)) is less than 1") # Format non-number sigma values if sigma is not None: if np.all(np.isnan(sigma)): sigma = None else: sigma = np.nan_to_num(sigma) if np.count_nonzero(sigma) != len(sigma): # Sigma = 0 causes zero division error sigma = None # Override scipy.curve_fit default for absolute_sigma=True # if sigma is specified. if sigma is not None and "absolute_sigma" not in kwargs: kwargs["absolute_sigma"] = True # Run curve fit try: # pylint: disable = unbalanced-tuple-unpacking popt, pcov = opt.curve_fit(fit_func, xdata, ydata, sigma=sigma, p0=param_p0, bounds=param_bounds, **kwargs) except Exception as ex: raise AnalysisError( "scipy.optimize.curve_fit failed with error: {}".format( str(ex))) from ex if np.isfinite(pcov).all(): # Keep parameter correlations in following analysis steps fit_params = uncertainties.correlated_values(nom_values=popt, covariance_mat=pcov, tags=param_keys) else: # Ignore correlations, add standard error if finite. fit_params = [ uncertainties.ufloat(nominal_value=n, std_dev=s if np.isfinite(s) else np.nan) for n, s in zip(popt, np.sqrt(np.diag(pcov))) ] # Calculate the reduced chi-squared for fit yfits = fit_func(xdata, *popt) residues = (yfits - ydata)**2 if sigma is not None: residues = residues / (sigma**2) reduced_chisq = np.sum(residues) / dof return FitData( popt=list(fit_params), popt_keys=list(param_keys), pcov=pcov, reduced_chisq=reduced_chisq, dof=dof, x_data=xdata, y_data=ydata, )
def test_inverse(): "Tests of the matrix inverse" m = unumpy.matrix([[ufloat(10, 1), -3.1], [0, ufloat(3, 0)]]) m_nominal_values = unumpy.nominal_values(m) # "Regular" inverse matrix, when uncertainties are not taken # into account: m_no_uncert_inv = m_nominal_values.I # The matrix inversion should not yield numbers with uncertainties: assert m_no_uncert_inv.dtype == numpy.dtype(float) # Inverse with uncertainties: m_inv_uncert = m.I # AffineScalarFunc elements # The inverse contains uncertainties: it must support custom # operations on matrices with uncertainties: assert isinstance(m_inv_uncert, unumpy.matrix) assert type(m_inv_uncert[0, 0]) == uncert_core.AffineScalarFunc # Checks of the numerical values: the diagonal elements of the # inverse should be the inverses of the diagonal elements of # m (because we started with a triangular matrix): assert numbers_close(1 / m_nominal_values[0, 0], m_inv_uncert[0, 0].nominal_value), "Wrong value" assert numbers_close(1 / m_nominal_values[1, 1], m_inv_uncert[1, 1].nominal_value), "Wrong value" #################### # Checks of the covariances between elements: x = ufloat(10, 1) m = unumpy.matrix([[x, x], [0, 3 + 2 * x]]) m_inverse = m.I # Check of the properties of the inverse: m_double_inverse = m_inverse.I # The initial matrix should be recovered, including its # derivatives, which define covariances: assert numbers_close(m_double_inverse[0, 0].nominal_value, m[0, 0].nominal_value) assert numbers_close(m_double_inverse[0, 0].std_dev, m[0, 0].std_dev) assert arrays_close(m_double_inverse, m) # Partial test: assert derivatives_close(m_double_inverse[0, 0], m[0, 0]) assert derivatives_close(m_double_inverse[1, 1], m[1, 1]) #################### # Tests of covariances during the inversion: # There are correlations if both the next two derivatives are # not zero: assert m_inverse[0, 0].derivatives[x] assert m_inverse[0, 1].derivatives[x] # Correlations between m and m_inverse should create a perfect # inversion: assert arrays_close(m * m_inverse, numpy.eye(m.shape[0]))
import uncertainties from uncertainties import ufloat import math import numpy import numpy import pylab from scipy.optimize import curve_fit import math import scipy.stats import uncertainties from uncertainties import unumpy INPUT = "datiGuadagno.txt" OUTPUT = "datiGuadagnoEstesi.txt" Vin, dVin, Vout, dVout = pylab.loadtxt(INPUT, unpack=True) f = ufloat(5.00, 5.00 / 100.0) VIN = unumpy.uarray(Vin, dVin) / 1000 VIN3 = unumpy.uarray(Vin, ((dVin)**2 + (0.03 * Vin)**2)**0.5) / 1000 VOUT = unumpy.uarray(Vout, dVout) VOUT3 = unumpy.uarray(Vout, ((dVout)**2 + (0.03 * Vout)**2)**0.5) A = VOUT3 / VIN3 mediaA = A.mean() print(A)
plt.plot(Iq, Uh, 'ro', label='Hall-Spannung bei Variation von Iq') # Achsenbeschriftung plt.xlabel(r'$I_Q \:/\: \si{\ampere}$') plt.ylabel(r'$U_H \:/\: \si{\volt}$') # in matplotlibrc leider (noch) nicht möglich plt.legend() plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) #print("a: ", a) #print("Fehler von a: ", a_err) #print("b: ", b) #print("Fehler von b: ", b_err) a_neu = ufloat(a, a_err) n_neu = ufloat(3.27 * 10**29, 0.09 * 10**29) # 1/meter^3 tau_neu = ufloat(1.72 * 10**-14, 0.05 * 10**-14) vd_neu = ufloat(1.91 * 10**-5, 0.05 * 10**-5) vtotal_neu = ufloat(2.469 * 10**6, 0.023 * 10**6) m_atom = 63.5 * 1.67 * 10**-27 #kilogram rho = 8.96 * 1000 #kilogram pro m^3 print("z1 und z Fehler: ", z(rho, n_neu, m_atom)) #print("n und n error: ", n(B_neu,e_neu,d_neu,a_neu)) #print("Tau und Tau error: ", T(m_neu,L_neu,e_neu,n_neu,R_neu,Q_neu)) #print("Vdrift und Error: ", V(j_neu,e_neu,n_neu)) #print("Mü und Mü Fehler: ", M(e_neu,n_neu,tau_neu,vd_neu,m_neu,j_neu)) #print("Vtotal und Fehler: ", VT(h_neu,m_neu,n_neu)) #print("L und L Fehler: ", L(tau_neu, vtotal_neu))
import numpy as np import matplotlib.pyplot as plt from scipy.optimize import curve_fit from uncertainties import unumpy as unp from uncertainties import ufloat from astropy.io import ascii from uncertainties.unumpy import (nominal_values as noms, std_devs as stds) plt.rcParams['figure.figsize'] = (10, 8) plt.rcParams['font.size'] = 16 plt.rcParams['lines.linewidth'] = 2 N = 80 E = ufloat(210 * 10**9, 0.5 * 10**9) # in Pascal R = 72 * 10**-3 # Spulenradius in m D_KH = 22.5 * 10**-7 # Trägheitsmoment Halterung in kg/m^2 R_k = ufloat(51.03 * 10**-3, 0.020412 * 10**-3) / 2 # Kugelradius in m m_k = ufloat(588.3, 0.23532) * 10**-3 # Kugelmasse in kg L = (61.7 + 4.2) * 10**-2 # Länge des Drahtes in m I = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]) # Strom in A Anzahl1, T = np.genfromtxt('rohdaten/Schubmodul.txt', unpack=True) Anzahl2, d1 = np.genfromtxt('rohdaten/Drahtdurchmesser.txt', unpack=True) Anzahl3, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 = np.genfromtxt( 'rohdaten/MagnetischerMoment.txt', unpack=True) Anzahl4, Te = np.genfromtxt('rohdaten/Erdmagnetfeld.txt', unpack=True) # a) print('A') r = ufloat(np.mean(d1), np.std(d1)) / 2 * 10**-3 print('R = ', r * 10**3, 'in mm') print('RK =', R_k * 10**3, 'in mm')
@uncertainties.wrap def integratehigh(al=None,be=None,ls=None,l=None): if al==None: al=-1.59 if l==None: l=50 if be==None: be=-4.1 if ls==None: ls=43.06 def integrand(X): return np.power(10,((al+1)*np.log10(10**X/10**ls)+be))*np.e**(-10**X/10**ls) integral,abserr=sp.integrate.quad(integrand,42,l) return integral OIINumberDens1=integratelow(al=uncertainties.ufloat(-2.21,0.06),be=uncertainties.ufloat(46.96,2.6))+integratehigh(al=uncertainties.ufloat(-1.59,0.15),be=uncertainties.ufloat(-4.1,0.22),ls=uncertainties.ufloat(43.060,14),l=44) def integ(x,al,bl): return 10**((al+1)*(x-42)+bl) def integ2(x,al,bl): return 10**((al+1)*(x-41.5)+bl) x=[40.9,41.1,41.3,41.5,41.7] y10=np.array([10**-1.97,10**-2.6,10**-2.8]) y06=np.array([10**-2.57,10**-2.88,10**-2.9,10**-2.99,10**-3.35]) y03=np.array([10**-2.6,10**-2.88,10**-2.94,10**-3.1,10**-3.5]) y01=np.array([10**-2.8,10**-2.95,10**-3.2,10**-3.6,10**-3.8]) alph01,beta01=uncertainties.correlated_values(sp.optimize.curve_fit(integ,x,y01,p0=[-2.21,43.6])[0],sp.optimize.curve_fit(integ,x,y01,p0=[-2.21,43.6])[1]) alph03,beta03=uncertainties.correlated_values(sp.optimize.curve_fit(integ,x,y03,p0=[-2.21,43.6])[0],sp.optimize.curve_fit(integ,x,y03,p0=[-2.21,43.6])[1])