def test_LeastSquares_bad_input(): with pytest.raises(ValueError): LeastSquares([1, 2], [1], [1], lambda x, a: 0) with pytest.raises(ValueError): LeastSquares([1, 2], [1, 2], [1], lambda x, a: 0) with pytest.raises(ValueError): LeastSquares([1], [1], [1], lambda x, a: 0, loss="foo")
def test_addable_cost_1(): def model1(x, a): return a + x def model2(x, b, a): return a + b * x def model3(x, c): return c lsq1 = LeastSquares(1, 2, 3, model1) assert lsq1.func_code.co_varnames == ("a", ) lsq2 = LeastSquares(1, 3, 4, model2) assert lsq2.func_code.co_varnames == ("b", "a") lsq3 = LeastSquares(1, 1, 1, model3) assert lsq3.func_code.co_varnames == ("c", ) lsq12 = lsq1 + lsq2 assert lsq12._items == [lsq1, lsq2] assert isinstance(lsq12, CostSum) assert isinstance(lsq1, LeastSquares) assert isinstance(lsq2, LeastSquares) assert lsq12.func_code.co_varnames == ("a", "b") assert lsq12.ndata == 2 assert lsq12(1, 2) == lsq1(1) + lsq2(2, 1) m = Minuit(lsq12, a=0, b=0) m.migrad() assert m.parameters == ("a", "b") assert_allclose(m.values, (1, 2)) assert_allclose(m.errors, (3, 5)) assert_allclose(m.covariance, ((9, -9), (-9, 25)), atol=1e-10) lsq121 = lsq12 + lsq1 assert lsq121._items == [lsq1, lsq2, lsq1] assert lsq121.func_code.co_varnames == ("a", "b") assert lsq121.ndata == 3 lsq312 = lsq3 + lsq12 assert lsq312._items == [lsq3, lsq1, lsq2] assert lsq312.func_code.co_varnames == ("c", "a", "b") assert lsq312.ndata == 3 lsq31212 = lsq312 + lsq12 assert lsq31212._items == [lsq3, lsq1, lsq2, lsq1, lsq2] assert lsq31212.func_code.co_varnames == ("c", "a", "b") assert lsq31212.ndata == 5 lsq31212 += lsq1 assert lsq31212._items == [lsq3, lsq1, lsq2, lsq1, lsq2, lsq1] assert lsq31212.func_code.co_varnames == ("c", "a", "b") assert lsq31212.ndata == 6
def test_LeastSquares(loss, verbose): rng = np.random.default_rng(1) x = np.linspace(0, 1, 1000) ye = 0.1 y = rng.normal(2 * x + 1, ye) def model(x, a, b): return a + b * x cost = LeastSquares(x, y, ye, model, loss=loss, verbose=verbose) assert cost.ndata == len(x) m = Minuit(cost, a=0, b=0) m.migrad() assert_allclose(m.values, (1, 2), rtol=0.05) assert cost.loss == loss if loss != "linear": cost.loss = "linear" assert cost.loss != loss m.migrad() assert_allclose(m.values, (1, 2), rtol=0.05) assert m.ndof == len(x) - 2 assert_allclose(m.fmin.reduced_chi2, 1, atol=5e-2)
def test_addable_cost_3(): def line_np(x, par): return par[0] + par[1] * x lsq = LeastSquares([1, 2, 3], [3, 4, 5], 1, line_np) con = NormalConstraint("par", (1, 1), (1, 1)) cs = sum([lsq, con]) assert cs((1, 1)) == pytest.approx(3) cs = 1.5 + lsq + con assert cs((1, 1)) == pytest.approx(4.5)
def fit(self, index, n_bins=100, data_color=None, fit_color=None, box_color=None): data, data_errs, bins = self.get_histogram_by_index(index, n_bins) parameters = { 'mu':0.02, 's':1/250, 'c':0.004, 'N':0.35, } parameters_options = { 'mu' : ([0, 1], 0.01), 's' : ([0,1], 1/25), 'c' : ([0,1], 0.01), 'N' : ([0,1], 0.05), } m = Minuit(LeastSquares(bins, data, data_errs, RegEff.sigFunc), **parameters) for par in m.parameters: m.limits[par], m.errors[par] = parameters_options[par] m.migrad() if not(m.accurate): warnings.warn('Minuit troubles') if self.fit_results is None: columns = [] columns += m.parameters columns += ( tuple(map(lambda x: f'{x}_err', m.parameters)) + ('eff0', 'eff0_err') ) self.fit_results = pd.DataFrame(columns=columns) eff0 = RegEff.sigFunc(0, *m.values) eff0_err = RegEff.sigFunc(0, *(np.array(m.values)+np.array(m.errors))) - eff0 temp_ser = pd.Series(list(m.values) + list(m.errors) + [eff0, eff0_err], index=self.fit_results.columns, name=self.index2energy(index)) if temp_ser.name in self.fit_results.index: self.fit_results.drop(temp_ser.name, axis=0, inplace=True) self.fit_results = self.fit_results.append(temp_ser) fig, ax = plt.subplots() xx = np.linspace(0, np.max(bins), 100) ax.errorbar(bins, data, yerr=data_errs, fmt='.', color=data_color) ax.plot(xx, RegEff.sigFunc(xx, *m.values), color=fit_color) my_style(title=f'Registration eff. vs rad. photon energy ($\sqrt{{s}}$ = {self.index2energy(index)*2e-3:.3f} GeV)', xlim=(0, np.max(bins)), ylim=(0, None), xtitle='$E_{\\gamma}$, GeV', ytitle='$\\varepsilon_{reg}$') values_dict = dict(zip(m.parameters, m.values)) chi2, ndf = m.fval, len(bins)-len(m.parameters)-1 s = f'$\\chi^2$ / ndf = {chi2:.2f} / {ndf}\n' s += f'p-value: {1-stats.chi2.cdf(chi2, ndf):.2f}\n' for var, val, err, fixed in zip(m.parameters, m.values, m.errors, m.fixed): if fixed: s += f'{var} = {val:1.3f}\n' else: s += f'{var} = {val:1.3f}$\\pm${err:.4f}\n' props = dict(boxstyle='square', facecolor=box_color, alpha=0.5) ax.text(0.65, 0.95, s.strip(), transform=ax.transAxes, verticalalignment='top', bbox=props) return
def test_LeastSquares_properties(): def model(x, a): return a c = LeastSquares(1, 2, 3, model) assert_equal(c.x, [1]) assert_equal(c.y, [2]) assert_equal(c.yerror, [3]) assert c.model is model with pytest.raises(AttributeError): c.model = model with pytest.raises(ValueError): c.x = [1, 2] with pytest.raises(ValueError): c.y = [1, 2] with pytest.raises(ValueError): c.yerror = [1, 2]
def test_NormalConstraint_1(): def model(x, a): return a lsq1 = LeastSquares(0, 1, 1, model) lsq2 = lsq1 + NormalConstraint("a", 1, 0.1) assert lsq1.func_code.co_varnames == ("a",) assert lsq2.func_code.co_varnames == ("a",) m = Minuit(lsq1, 0) m.migrad() assert_allclose(m.values, (1,), atol=1e-2) assert_allclose(m.errors, (1,), rtol=1e-2) m = Minuit(lsq2, 0) m.migrad() assert_allclose(m.values, (1,), atol=1e-2) assert_allclose(m.errors, (0.1,), rtol=1e-2)
def test_LeastSquares_mask(): c = LeastSquares([1, 2, 3], [3, np.nan, 4], [1, 1, 1], lambda x, a: x + a) assert c.ndata == 3 assert np.isnan(c(0)) == True m = Minuit(c, 1) assert m.ndof == 2 m.migrad() assert not m.valid c.mask = np.arange(3) != 1 assert np.isnan(c(0)) == False assert c.ndata == 2 assert m.ndof == 1 m.migrad() assert m.valid assert_equal(m.values, [1.5])
def test_LeastSquares(loss, verbose): np.random.seed(1) x = np.random.rand(20) y = 2 * x + 1 ye = 0.1 y += ye * np.random.randn(len(y)) def model(x, a, b): return a + b * x cost = LeastSquares(x, y, ye, model, loss=loss, verbose=verbose) m = Minuit(cost, a=0, b=0) m.migrad() assert_allclose(m.values, (1, 2), rtol=0.03) assert cost.loss == loss if loss != "linear": cost.loss = "linear" assert cost.loss != loss m.migrad() assert_allclose(m.values, (1, 2), rtol=0.02)
TCR2 = 1 / ((1 / TCS2) + (1 / TAUR)) JTOT1 = TCR1 / (1 + numpy.power((freq1 * TCR1), 2)) JTOT2 = TCR2 / (1 + numpy.power((freq2 * TCR2), 2)) RR1 = CMR * ( (3 * JTOT1) + (7 * JTOT2)) + (CMS * TCS2) / (1 + numpy.power(freq2 * TCS2, 2)) T1M = 1 / RR1 # T1m R1rotSS = PROPR * ( (CONC / 55.55) * SOLV) / (T1M + TAUM) #PROPR # Y de R1 # return x # print(R1trans + R1rot) return R1trans + R1rotSS data_yerr = 0.000001 least_squares = LeastSquares(rawdata_x, rawdata_y, data_yerr, line) # pass starting values for a and b # print("coucou1") m = Minuit( least_squares, CONC=float(params["CONC"]["value"]), SOLV=float(params["SOLV"]["value"]), PROPR=float(params["PROPR"]["value"]), SPIN=float(params["SPIN"]["value"]), B=float(params["B"]["value"]), DIF=float(params["DIF"]["value"]), TAUS0=float(params["TAUS0"]["value"]), TAUV=float(params["TAUV"]["value"]), PROPT=float(params["PROPT"]["value"]), gl=float(params["gl"]["value"]), TAUM=float(params["TAUM"]["value"]),
plt.xlabel('$t_{decay}$ (s)') plt.ylabel('Entries') plt.title('Decay time distribution') centers = bins[:-1] + np.diff(bins) / 2 gamma_init = 100. n0_init = n[0] #l = 1./gamma def special_exp(x, n0, gamma): y = n0 * np.exp(-centers / (gamma * piCnst.lifetime())) return y #plt.plot(centers, y, '-', color='b') least_squares = LeastSquares(centers, n, yerror=np.sqrt(n), model=special_exp) m = Minuit(least_squares, n0=n0_init, gamma=gamma_init) m.migrad() print(m.hesse()) plt.plot(centers, special_exp(centers, m.values[0], m.values[1]), color='b', label='fit') #plt.show() plt.savefig('Scratch/nuSTORMTrfLine/nuSTORMTrfLineTst_4_tdec.pdf') plt.close() n, bins, patches = plt.hist(s_dcy_pi, bins=50, color='y') plt.xlabel('s decay (m)') plt.ylabel('Entries') plt.title('Decay point distribution')
print(error) errbar = np.array(error) err = sem(avg) x_data = len y = avg f = plt.figure() f.set_figwidth(10) f.set_figheight(10) def line(x, a, b): return a + b * x least_squares = LeastSquares(x_data, y, error, line) m = Minuit(least_squares, a=0, b=0) m.migrad() # finds minimum of least_squares function m.hesse() plt.plot(np.linspace(0.35, 2.00), line(np.linspace(0.35, 2.00), *m.values), label="fit") plt.errorbar(x_data, y, yerr=error, fmt="o", label="data") print(x_data) print(m.nfit) print(m.fval) length = 7 r = m.fval / (length - m.nfit) fit_info = [
eid_other.append(i[0]) P = pd.DataFrame(eid_p) if not P.empty: P.columns = ['EventID'] P_DFRONT = pd.merge(P,DATA_FRONT, on='EventID') P_DBACK = pd.merge(P,DATA_BACK, on='EventID') P_DDIFF = pd.merge(P,DATA_DIFFERENCE, on='EventID') P_DDIFF = P_DDIFF.dropna() P_DBACK = P_DBACK.dropna() doiList = P_DBACK.gammaxpos.tolist() backCountsList = P_DBACK.Back_Counts.tolist() diffCountsList = P_DDIFF.Difference_Counts.tolist() k = Minuit(LeastSquares(diffCountsList, doiList, 10.0, Line), m = 0.02, b = 0) k.migrad() k.hesse() fig, axs = plt.subplots() crystalLength = 30 nChoices = [5] refractiveIndex = 1.82 for index in range(len(nChoices)): nthPhotonTimes = [] backTriggers = [] frontTriggers = [] doiList = [] doiTruthList = []
variancesOverEnergy.append(varianceOverEnergy) photopeakEnergies = [i for i in eventEnergies if i > 7500] numBins = 50 fig, ax = plt.subplots() hist, xedges = np.histogram(eventEnergies, bins=100) photoPeak = xedges[hist.argmax()] (binCounts, bins, patches) = ax.hist(photopeakEnergies, bins=numBins, range=[photoPeak - 1000, photoPeak + 1000]) binCenters = np.linspace(min(bins), max(bins), numBins) k = Minuit(LeastSquares(binCenters, binCounts, 10.0, gauss), a=100, mu=photoPeak, sigma=100, c=0) k.migrad() k.hesse() energyResolution = k.values[2] / k.values[1] * 100 fitPoints = np.linspace(min(bins), max(bins), 1000) ax.plot(fitPoints, gauss(fitPoints, *k.values[0:4]), color='k') ax.text(0.7, 0.9, "Data Stats:", weight='bold', transform=ax.transAxes) ax.text(0.7, 0.85, "mean: " + format(np.mean(photopeakEnergies), "5.4f"), transform=ax.transAxes)
new_mag = [] for i in range(len(x_chunk)): if np.abs(x_chunk[i] - np.median(x_chunk) ) < 2 * 1.428 * stats.median_absolute_deviation( x_chunk - np.median(x_chunk)): new_chunk.append(x_chunk[i]) newt_chunk.append(t_chunk[i]) new_chunk1.append(ra_chunk[i]) new_chunk2.append(dec_chunk[i]) new_mag.append(mag_chunk[i]) new_chunk3.append(raerr_chunk[i]) new_chunk4.append(decerr_chunk[i]) #Run Minuit on outlier-free ra and dec chunks least_squares = LeastSquares(newt_chunk, new_chunk1, new_chunk3, line) m = Minuit(least_squares, a=0, b=0) m.migrad() m.hesse() least_squares1 = LeastSquares(newt_chunk, new_chunk2, new_chunk4, line) m1 = Minuit(least_squares1, a=0, b=0) m1.migrad() m1.hesse() #Run linear regression with scipy.stats slope, intercept, r_value, p_value, std_err = stats.linregress(
def fit_freezeout(dict_yield,**kwargs): """ Extract freeze out parameters by fitting final heavy ion data (dN/dy) given in dict_yield. Construct ratios of different particles. """ # additional plots of chi^2 (takes time) try: chi2_plot = kwargs['chi2_plot'] except: chi2_plot = False # default # consider decay from unstable particles in the calculation of densities? try: freezeout_decay = kwargs['freezeout_decay'] except: freezeout_decay = True # apply fit to both yields and ratios? try: method = kwargs['method'] except: method = 'all' # consider integration over mass? try: offshell = kwargs['offshell'] except: offshell = False # default # evaluate freeze out parameters for which EoS? full or strangeness neutrality ns0 ? try: EoS = kwargs['EoS'] except: EoS = 'all' # default # we fit the HRG EoS to the ratios of particle yields as list_part1/list_part2 # as in BES STAR paper: PHYSICAL REVIEW C 96, 044904 (2017) list_part1 = ['pi-','K-','p~','Lambda~','Xi~+','K-','p~','Lambda','Xi~+'] list_part2 = ['pi+','K+','p','Lambda','Xi-','pi-','pi-','pi-','pi-'] # unique list of particles (for the yields) list_part = ['pi+','pi-','K+','K-','p','p~','Lambda','Lambda~','Xi-','Xi~+'] # construct yields from input data_yields = [] err_yields = [] final_part = [] for part in list_part: try: # check if the particles are given in dict_yield if(dict_yield[part]!=None and dict_yield[part]>0.): data_yields.append(dict_yield[part]) err_yields.append(dict_yield[part+'_err']) final_part.append(part) except: pass # construct ratios from input yields data_ratios = [] err_ratios = [] final_part1 = [] final_part2 = [] # loop over particles in list_part1 and list_part2 for part1,part2 in zip(list_part1,list_part2): try: # check if the particles are given in dict_yield if(dict_yield[part1]!=None and dict_yield[part1]>0. and dict_yield[part2]!=None and dict_yield[part2]>0.): ratio = dict_yield[part1]/dict_yield[part2] data_ratios.append(ratio) err_ratios.append(abs(ratio)*np.sqrt((dict_yield[part1+'_err']/dict_yield[part1])**2.+(dict_yield[part2+'_err']/dict_yield[part2])**2.)) final_part1.append(part1) final_part2.append(part2) except: pass def f_yields(x,T,muB,muQ,muS,gammaS,dVdy): """ Calculate the particle yields for fixed T,muB,muQ,muS,gammaS,volume x is a dummy argument """ result = np.zeros(len(final_part)) # calculate all densities result_HRG = HRG_freezout(T,muB,muQ,muS,gammaS,EoS='full',**kwargs) # loop over particles for i,part in enumerate(final_part): yval = result_HRG[part] #print('part,yval=',part,yval) # if no decays, then Sigma0 should be added to Lambda # if decays are activated, then Sigma0 decays to Lambda if(not(freezeout_decay)): # include Sigma0 with Lambda if(part=='Lambda'): yval += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part=='Lambda~'): yval += result_HRG['Sigma~0'] # number of particles result[i] = yval*T**3.*dVdy/(0.197**3.) # return the list of yields return result def f_yields_nS0(x,T,muB,gammaS,dVdy): """ Calculate the particle yields for fixed T,muB,gammaS,volume x is a dummy argument """ result = np.zeros(len(final_part)) # calculate all densities result_HRG = HRG_freezout(T,muB,0.,0.,gammaS,EoS='nS0',**kwargs) # loop over particles for i,part in enumerate(final_part): yval = result_HRG[part] #print('part,yval=',part,yval) # if no decays, then Sigma0 should be added to Lambda # if decays are activated, then Sigma0 decays to Lambda if(not(freezeout_decay)): # include Sigma0 with Lambda if(part=='Lambda'): yval += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part=='Lambda~'): yval += result_HRG['Sigma~0'] # number of particles result[i] = yval*T**3.*dVdy/(0.197**3.) # return the list of yields return result def f_ratios(x,T,muB,muQ,muS,gammaS): """ Calculate the ratios of particle yields for fixed T,muB,muQ,muS,gammaS x is a dummy argument """ result = np.zeros(len(data_ratios)) # calculate all densities result_HRG = HRG_freezout(T,muB,muQ,muS,gammaS,EoS='full',**kwargs) # loop over different ratios for i,(part1,part2) in enumerate(zip(final_part1,final_part2)): yval1 = result_HRG[part1] yval2 = result_HRG[part2] #print('part,yval1=',part1,yval1) #print('part,yval2=',part2,yval2) # if no decays, then Sigma0 should be added to Lambda # if decays are activated, then Sigma0 decays to Lambda if(not(freezeout_decay)): # include Sigma0 with Lambda if(part1=='Lambda'): yval1 += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part1=='Lambda~'): yval1 += result_HRG['Sigma~0'] # include Sigma0 with Lambda if(part2=='Lambda'): yval2 += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part2=='Lambda~'): yval2 += result_HRG['Sigma~0'] # ratio of particle1/particle2 result[i] = yval1/yval2 # return the list of ratios return result def f_ratios_nS0(x,T,muB,gammaS): """ Calculate the ratios of particle yields for fixed T,muB,gammaS x is a dummy argument """ result = np.zeros(len(data_ratios)) # calculate all densities result_HRG = HRG_freezout(T,muB,0.,0.,gammaS,EoS='nS0',**kwargs) # loop over different ratios for i,(part1,part2) in enumerate(zip(final_part1,final_part2)): yval1 = result_HRG[part1] yval2 = result_HRG[part2] #print('part,yval1=',part1,yval1) #print('part,yval2=',part2,yval2) # if no decays, then Sigma0 should be added to Lambda # if decays are activated, then Sigma0 decays to Lambda if(not(freezeout_decay)): # include Sigma0 with Lambda if(part1=='Lambda'): yval1 += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part1=='Lambda~'): yval1 += result_HRG['Sigma~0'] # include Sigma0 with Lambda if(part2=='Lambda'): yval2 += result_HRG['Sigma0'] # include Sigma~0 with Lambda~ elif(part2=='Lambda~'): yval2 += result_HRG['Sigma~0'] # ratio of particle1/particle2 result[i] = yval1/yval2 # return the list of ratios return result # initialize the parameters # which parameters to be fixed? fix_T=False fix_muB=False fix_muQ=False fix_muS=False fix_gammaS=False fix_dVdy=False # first guesses for T,muB,muQ,muS,gammaS,dVdy guess = (0.150, 0.05, 0., 0.05, 1., 2000.) # bounds bounds = ((0.100, 0.200), (0, 0.6), (-0.2,0.2), (0,0.2), (0.0,1.2), (100.,10000.)) # fit with yields if((EoS=='all' or EoS=='full') and (method=='all' or method=='yields')): # x-values, just the indexes of ratios [1,2,...,N_particles] xyields = np.arange(len(final_part)) # initialize Minuit least_squares class least_squares = LeastSquares(xyields, data_yields, err_yields, f_yields) m = Minuit(least_squares, T=guess[0], muB=guess[1], muQ=guess[2], muS=guess[3], gammaS=guess[4], dVdy=guess[5], limit_T=bounds[0],limit_muB=bounds[1],limit_muQ=bounds[2],limit_muS=bounds[3],limit_gammaS=bounds[4],limit_dVdy=bounds[5], fix_T=fix_T,fix_muB=fix_muB,fix_muQ=fix_muQ,fix_muS=fix_muS,fix_gammaS=fix_gammaS,fix_dVdy=fix_dVdy) m.migrad() # finds minimum of least_squares function m.hesse() # computes errors #print(m.params) # minuit output # display values and errors popt1 = m.values.values() perr1 = m.errors.values() print('\nfit from yields, full EoS:') fit_string1 = f'$T_{{ch}}={popt1[0]:.4f} \pm {perr1[0]:.4f}\ GeV$\ \n$\mu_{{B}}={popt1[1]:.4f} \pm {perr1[1]:.4f}\ GeV$\ \n$\mu_{{Q}}={popt1[2]:.4f} \pm {perr1[2]:.4f}\ GeV$\ \n$\mu_{{S}}={popt1[3]:.4f} \pm {perr1[3]:.4f}\ GeV$\ \n$\gamma_{{S}}={popt1[4]:.2f} \pm {perr1[4]:.2f}$\ \n$dV/dy={popt1[5]:.1f} \pm {perr1[5]:.1f} \ fm^3$' print(fit_string1) thermo = HRG(popt1[0],popt1[1],popt1[2],popt1[3],gammaS=popt1[4],offshell=offshell) snB1 = thermo['s']/thermo['n_B'] snB1_err = 0. # derivative wrt T thermoT1 = HRG(popt1[0]+perr1[0]/2.,popt1[1],popt1[2],popt1[3],gammaS=popt1[4],offshell=offshell) thermoT2 = HRG(popt1[0]-perr1[0]/2.,popt1[1],popt1[2],popt1[3],gammaS=popt1[4],offshell=offshell) if(thermoT1['n_B']!=0. and thermoT2['n_B']!=0.): snB1_err += (thermoT1['s']/thermoT1['n_B']-thermoT2['s']/thermoT2['n_B'])**2. # derivative wrt mu_B thermomuB1 = HRG(popt1[0],popt1[1]+perr1[1]/2.,popt1[2],popt1[3],gammaS=popt1[4],offshell=offshell) thermomuB2 = HRG(popt1[0],popt1[1]-perr1[1]/2.,popt1[2],popt1[3],gammaS=popt1[4],offshell=offshell) if(thermomuB1['n_B']!=0. and thermomuB2['n_B']!=0.): snB1_err += (thermomuB1['s']/thermomuB1['n_B']-thermomuB2['s']/thermomuB2['n_B'])**2. # derivative wrt mu_Q thermomuQ1 = HRG(popt1[0],popt1[1],popt1[2]+perr1[2]/2.,popt1[3],gammaS=popt1[4],offshell=offshell) thermomuQ2 = HRG(popt1[0],popt1[1],popt1[2]-perr1[2]/2.,popt1[3],gammaS=popt1[4],offshell=offshell) if(thermomuQ1['n_B']!=0. and thermomuQ2['n_B']!=0.): snB1_err += (thermomuQ1['s']/thermomuQ1['n_B']-thermomuQ2['s']/thermomuQ2['n_B'])**2. # derivative wrt mu_S thermomuS1 = HRG(popt1[0],popt1[1],popt1[2],popt1[3]+perr1[3]/2.,gammaS=popt1[4],offshell=offshell) thermomuS2 = HRG(popt1[0],popt1[1],popt1[2],popt1[3]-perr1[3]/2.,gammaS=popt1[4],offshell=offshell) if(thermomuS1['n_B']!=0. and thermomuS2['n_B']!=0.): snB1_err += (thermomuS1['s']/thermomuS1['n_B']-thermomuS2['s']/thermomuS2['n_B'])**2. # derivative wrt gamma_S thermogammaS1 = HRG(popt1[0],popt1[1],popt1[2],popt1[3],gammaS=popt1[4]+perr1[4]/2.,offshell=offshell) thermogammaS2 = HRG(popt1[0],popt1[1],popt1[2],popt1[3],gammaS=popt1[4]-perr1[4]/2.,offshell=offshell) if(thermogammaS1['n_B']!=0. and thermogammaS2['n_B']!=0.): snB1_err += (thermogammaS1['s']/thermogammaS1['n_B']-thermogammaS2['s']/thermogammaS2['n_B'])**2. # error as sqrt((df/dT)**2. dT+(df/dmuB)**2.+...) with f = s/n_B snB1_err = np.sqrt(snB1_err) print(f's/n_B = {snB1} \pm {snB1_err}') # evaluate the chi^2 values for each parameter if(chi2_plot): dT, fT = m.profile('T') dmuB, fmuB = m.profile('muB') dmuQ, fmuQ = m.profile('muQ') dmuS, fmuS = m.profile('muS') dgammaS, fgammaS = m.profile('gammaS') ddVdy, fdVdy = m.profile('dVdy') output_chi21 = [[dT,fT],[dmuB,fmuB],[dmuQ,fmuQ],[dmuS,fmuS],[dgammaS,fgammaS],[ddVdy,fdVdy]] else: output_chi21 = None output_yields = {'fit_yields':np.array(list(zip(popt1,perr1))),\ 'fit_string_yields':fit_string1,\ 'result_yields':f_yields(xyields,*popt1),\ 'data_yields':np.array(list(zip(data_yields,err_yields))),\ 'particle_yields':list(latex(final_part)),\ 'chi2_yields':output_chi21,\ 'snB_yields':np.array([snB1,snB1_err])} else: output_yields = {} # fit with yields # strangeness neutrality if((EoS=='all' or EoS=='nS0') and (method=='all' or method=='yields')): # x-values, just the indexes of ratios [1,2,...,N_particles] xyields = np.arange(len(final_part)) # initialize Minuit least_squares class least_squares = LeastSquares(xyields, data_yields, err_yields, f_yields_nS0) m = Minuit(least_squares, T=guess[0], muB=guess[1], gammaS=guess[4], dVdy=guess[5], limit_T=bounds[0],limit_muB=bounds[1],limit_gammaS=bounds[4],limit_dVdy=bounds[5], fix_T=fix_T,fix_muB=fix_muB,fix_gammaS=fix_gammaS,fix_dVdy=fix_dVdy) m.migrad() # finds minimum of least_squares function m.hesse() # computes errors #print(m.params) # minuit output # display values and errors popt1 = m.values.values() perr1 = m.errors.values() thermo = EoS_nS0(HRG,popt1[0],popt1[1],gammaS=popt1[2],offshell=offshell) print('\nfit from yields, nS0 EoS:') fit_string1 = f'$T_{{ch}}={popt1[0]:.4f} \pm {perr1[0]:.4f}\ GeV$\ \n$\mu_{{B}}={popt1[1]:.4f} \pm {perr1[1]:.4f}\ GeV$\ \n$\gamma_{{S}}={popt1[2]:.2f} \pm {perr1[2]:.2f}$\ \n$dV/dy={popt1[3]:.1f} \pm {perr1[3]:.1f} \ fm^3$\ \n$\mu_{{Q}}={thermo["muQ"]:.4f}\ GeV$\ \n$\mu_{{S}}={thermo["muS"]:.4f}\ GeV$' print(fit_string1) snB1 = thermo['s']/thermo['n_B'] snB1_err = 0. # derivative wrt T thermoT1 = EoS_nS0(HRG,popt1[0]+perr1[0]/2.,popt1[1],gammaS=popt1[2],offshell=offshell) thermoT2 = EoS_nS0(HRG,popt1[0]-perr1[0]/2.,popt1[1],gammaS=popt1[2],offshell=offshell) if(thermoT1['n_B']!=0. and thermoT2['n_B']!=0.): snB1_err += (thermoT1['s']/thermoT1['n_B']-thermoT2['s']/thermoT2['n_B'])**2. # derivative wrt mu_B thermomuB1 = EoS_nS0(HRG,popt1[0],popt1[1]+perr1[1]/2.,gammaS=popt1[2],offshell=offshell) thermomuB2 = EoS_nS0(HRG,popt1[0],popt1[1]-perr1[1]/2.,gammaS=popt1[2],offshell=offshell) if(thermomuB1['n_B']!=0. and thermomuB2['n_B']!=0.): snB1_err += (thermomuB1['s']/thermomuB1['n_B']-thermomuB2['s']/thermomuB2['n_B'])**2. # derivative wrt gamma_S thermogammaS1 = EoS_nS0(HRG,popt1[0],popt1[1],gammaS=popt1[2]+perr1[2]/2.,offshell=offshell) thermogammaS2 = EoS_nS0(HRG,popt1[0],popt1[1],gammaS=popt1[2]-perr1[2]/2.,offshell=offshell) if(thermogammaS1['n_B']!=0. and thermogammaS2['n_B']!=0.): snB1_err += (thermogammaS1['s']/thermogammaS1['n_B']-thermogammaS2['s']/thermogammaS2['n_B'])**2. # error as sqrt((df/dT)**2. dT+(df/dmuB)**2.+...) with f = s/n_B snB1_err = np.sqrt(snB1_err) print(f's/n_B = {snB1} \pm {snB1_err}') # evaluate the chi^2 values for each parameter if(chi2_plot): dT, fT = m.profile('T') dmuB, fmuB = m.profile('muB') dgammaS, fgammaS = m.profile('gammaS') ddVdy, fdVdy = m.profile('dVdy') output_chi21 = [[dT,fT],[dmuB,fmuB],[dgammaS,fgammaS],[ddVdy,fdVdy]] else: output_chi21 = None result_yields_nS0 = f_yields_nS0(xyields,*popt1) Tch,muB,gammaS,dVdy = popt1 Tch_err,muB_err,gammaS_err,dVdy_err = perr1 popt1 = np.array([Tch,muB,thermo['muQ'],thermo['muS'],gammaS,dVdy]) perr1 = np.array([Tch_err,muB_err,0.,0.,gammaS_err,dVdy_err]) output_yields_nS0 = {'fit_yields_nS0':np.array(list(zip(popt1,perr1))),\ 'fit_string_yields_nS0':fit_string1,\ 'result_yields_nS0':result_yields_nS0,\ 'data_yields':np.array(list(zip(data_yields,err_yields))),\ 'particle_yields':list(latex(final_part)),\ 'chi2_yields_nS0':output_chi21,\ 'snB_yields_nS0':np.array([snB1,snB1_err])} else: output_yields_nS0 = {} # fit with ratios if((EoS=='all' or EoS=='full') and (method=='all' or method=='ratios')): # x-values, just the indexes of ratios [1,2,...,N_ratios] xratios = np.arange(len(data_ratios)) # initialize Minuit least_squares class least_squares = LeastSquares(xratios, data_ratios, err_ratios, f_ratios) m = Minuit(least_squares, T=guess[0], muB=guess[1], muQ=guess[2], muS=guess[3], gammaS=guess[4], limit_T=bounds[0],limit_muB=bounds[1],limit_muQ=bounds[2],limit_muS=bounds[3],limit_gammaS=bounds[4], fix_T=fix_T,fix_muB=fix_muB,fix_muQ=fix_muQ,fix_muS=fix_muS,fix_gammaS=fix_gammaS) m.migrad() # finds minimum of least_squares function m.hesse() # computes errors #print(m.params) # minuit output # display values and errors popt2 = m.values.values() perr2 = m.errors.values() print('\nfit from ratios, full EoS:') fit_string2 = f'$T_{{ch}}={popt2[0]:.4f} \pm {perr2[0]:.4f}\ GeV$\ \n$\mu_{{B}}={popt2[1]:.4f} \pm {perr2[1]:.4f}\ GeV$\ \n$\mu_{{Q}}={popt2[2]:.4f} \pm {perr2[2]:.4f}\ GeV$\ \n$\mu_{{S}}={popt2[3]:.4f} \pm {perr2[3]:.4f}\ GeV$\ \n$\gamma_{{S}}={popt2[4]:.2f} \pm {perr2[4]:.2f}$' print(fit_string2) thermo = HRG(popt2[0],popt2[1],popt2[2],popt2[3],gammaS=popt2[4],offshell=offshell) snB2 = thermo['s']/thermo['n_B'] snB2_err = 0. # derivative wrt T thermoT1 = HRG(popt2[0]+perr2[0]/2.,popt2[1],popt2[2],popt2[3],gammaS=popt2[4],offshell=offshell) thermoT2 = HRG(popt2[0]-perr2[0]/2.,popt2[1],popt2[2],popt2[3],gammaS=popt2[4],offshell=offshell) if(thermoT1['n_B']!=0. and thermoT2['n_B']!=0.): snB2_err += (thermoT1['s']/thermoT1['n_B']-thermoT2['s']/thermoT2['n_B'])**2. # derivative wrt mu_B thermomuB1 = HRG(popt2[0],popt2[1]+perr2[1]/2.,popt2[2],popt2[3],gammaS=popt2[4],offshell=offshell) thermomuB2 = HRG(popt2[0],popt2[1]-perr2[1]/2.,popt2[2],popt2[3],gammaS=popt2[4],offshell=offshell) if(thermomuB1['n_B']!=0. and thermomuB2['n_B']!=0.): snB2_err += (thermomuB1['s']/thermomuB1['n_B']-thermomuB2['s']/thermomuB2['n_B'])**2. # derivative wrt mu_Q thermomuQ1 = HRG(popt2[0],popt2[1],popt2[2]+perr2[2]/2.,popt2[3],gammaS=popt2[4],offshell=offshell) thermomuQ2 = HRG(popt2[0],popt2[1],popt2[2]-perr2[2]/2.,popt2[3],gammaS=popt2[4],offshell=offshell) if(thermomuQ1['n_B']!=0. and thermomuQ2['n_B']!=0.): snB2_err += (thermomuQ1['s']/thermomuQ1['n_B']-thermomuQ2['s']/thermomuQ2['n_B'])**2. # derivative wrt mu_S thermomuS1 = HRG(popt2[0],popt2[1],popt2[2],popt2[3]+perr2[3]/2.,gammaS=popt2[4],offshell=offshell) thermomuS2 = HRG(popt2[0],popt2[1],popt2[2],popt2[3]-perr2[3]/2.,gammaS=popt2[4],offshell=offshell) if(thermomuS1['n_B']!=0. and thermomuS2['n_B']!=0.): snB2_err += (thermomuS1['s']/thermomuS1['n_B']-thermomuS2['s']/thermomuS2['n_B'])**2. # derivative wrt gamma_S thermogammaS1 = HRG(popt2[0],popt2[1],popt2[2],popt2[3],gammaS=popt2[4]+perr2[4]/2.,offshell=offshell) thermogammaS2 = HRG(popt2[0],popt2[1],popt2[2],popt2[3],gammaS=popt2[4]-perr2[4]/2.,offshell=offshell) if(thermogammaS1['n_B']!=0. and thermogammaS2['n_B']!=0.): snB2_err += (thermogammaS1['s']/thermogammaS1['n_B']-thermogammaS2['s']/thermogammaS2['n_B'])**2. # error as sqrt((df/dT)**2. dT+(df/dmuB)**2.+...) with f = s/n_B snB2_err = np.sqrt(snB2_err) print(f's/n_B = {snB2} \pm {snB2_err}') # evaluate the chi^2 values for each parameter if(chi2_plot): dT, fT = m.profile('T') dmuB, fmuB = m.profile('muB') dmuQ, fmuQ = m.profile('muQ') dmuS, fmuS = m.profile('muS') dgammaS, fgammaS = m.profile('gammaS') output_chi22 = [[dT,fT],[dmuB,fmuB],[dmuQ,fmuQ],[dmuS,fmuS],[dgammaS,fgammaS]] else: output_chi22 = None output_ratios = {'fit_ratios':np.array(list(zip(popt2,perr2))),\ 'fit_string_ratios':fit_string2,\ 'result_ratios':f_ratios(xratios,*popt2),\ 'data_ratios':np.array(list(zip(data_ratios,err_ratios))),\ 'particle_ratios':list(zip(latex(final_part1),latex(final_part2))),\ 'chi2_ratios':output_chi22,\ 'snB_ratios':np.array([snB2,snB2_err])} else: output_ratios = {} # fit with ratios if((EoS=='all' or EoS=='nS0') and (method=='all' or method=='ratios')): # x-values, just the indexes of ratios [1,2,...,N_ratios] xratios = np.arange(len(data_ratios)) # initialize Minuit least_squares class least_squares = LeastSquares(xratios, data_ratios, err_ratios, f_ratios_nS0) m = Minuit(least_squares, T=guess[0], muB=guess[1], gammaS=guess[4], limit_T=bounds[0],limit_muB=bounds[1],limit_gammaS=bounds[4], fix_T=fix_T,fix_muB=fix_muB,fix_gammaS=fix_gammaS) m.migrad() # finds minimum of least_squares function m.hesse() # computes errors #print(m.params) # minuit output # display values and errors popt2 = m.values.values() perr2 = m.errors.values() thermo = EoS_nS0(HRG,popt2[0],popt2[1],gammaS=popt2[2],offshell=offshell) print('\nfit from ratios, nS0 EoS:') fit_string2 = f'$T_{{ch}}={popt2[0]:.4f} \pm {perr2[0]:.4f}\ GeV$\ \n$\mu_{{B}}={popt2[1]:.4f} \pm {perr2[1]:.4f}\ GeV$\ \n$\gamma_{{S}}={popt2[2]:.2f} \pm {perr2[2]:.2f}$\ \n$\mu_{{Q}}={thermo["muQ"]:.4f}\ GeV$\ \n$\mu_{{S}}={thermo["muS"]:.4f}\ GeV$' print(fit_string2) snB2 = thermo['s']/thermo['n_B'] snB2_err = 0. # derivative wrt T thermoT1 = EoS_nS0(HRG,popt2[0]+perr2[0]/2.,popt2[1],gammaS=popt2[2],offshell=offshell) thermoT2 = EoS_nS0(HRG,popt2[0]-perr2[0]/2.,popt2[1],gammaS=popt2[2],offshell=offshell) if(thermoT1['n_B']!=0. and thermoT2['n_B']!=0.): snB2_err += (thermoT1['s']/thermoT1['n_B']-thermoT2['s']/thermoT2['n_B'])**2. # derivative wrt mu_B thermomuB1 = EoS_nS0(HRG,popt2[0],popt2[1]+perr2[1]/2.,gammaS=popt2[2],offshell=offshell) thermomuB2 = EoS_nS0(HRG,popt2[0],popt2[1]-perr2[1]/2.,gammaS=popt2[2],offshell=offshell) if(thermomuB1['n_B']!=0. and thermomuB2['n_B']!=0.): snB2_err += (thermomuB1['s']/thermomuB1['n_B']-thermomuB2['s']/thermomuB2['n_B'])**2. # derivative wrt gamma_S thermogammaS1 = EoS_nS0(HRG,popt2[0],popt2[1],gammaS=popt2[2]+perr2[2]/2.,offshell=offshell) thermogammaS2 = EoS_nS0(HRG,popt2[0],popt2[1],gammaS=popt2[2]-perr2[2]/2.,offshell=offshell) if(thermogammaS1['n_B']!=0. and thermogammaS2['n_B']!=0.): snB2_err += (thermogammaS1['s']/thermogammaS1['n_B']-thermogammaS2['s']/thermogammaS2['n_B'])**2. # error as sqrt((df/dT)**2. dT+(df/dmuB)**2.+...) with f = s/n_B snB2_err = np.sqrt(snB2_err) print(f's/n_B = {snB2} \pm {snB2_err}') # evaluate the chi^2 values for each parameter if(chi2_plot): dT, fT = m.profile('T') dmuB, fmuB = m.profile('muB') dgammaS, fgammaS = m.profile('gammaS') output_chi22 = [[dT,fT],[dmuB,fmuB],[dgammaS,fgammaS]] else: output_chi22 = None result_ratios_nS0 = f_ratios_nS0(xratios,*popt2) Tch,muB,gammaS = popt2 Tch_err,muB_err,gammaS_err = perr2 popt2 = np.array([Tch,muB,thermo['muQ'],thermo['muS'],gammaS]) perr2 = np.array([Tch_err,muB_err,0.,0.,gammaS_err]) output_ratios_nS0 = {'fit_ratios_nS0':np.array(list(zip(popt2,perr2))),\ 'fit_string_ratios_nS0':fit_string2,\ 'result_ratios_nS0':result_ratios_nS0,\ 'data_ratios':np.array(list(zip(data_ratios,err_ratios))),\ 'particle_ratios':list(zip(latex(final_part1),latex(final_part2))),\ 'chi2_ratios_nS0':output_chi22,\ 'snB_ratios_nS0':np.array([snB2,snB2_err])} else: output_ratios_nS0 = {} output = {} output.update(output_yields) output.update(output_ratios) output.update(output_yields_nS0) output.update(output_ratios_nS0) return output
def test_LeastSquares_mask(): c = LeastSquares([1, 2, 3], [3, np.nan, 4], [1, 1, 1], lambda x, a: x + a) assert np.isnan(c(0)) == True c.mask = np.arange(3) != 1 assert np.isnan(c(0)) == False
cache = [] # initilize model model = Quarks(boundary_type=boundary_type) chi_squared_threshold = 10. N = 100 # number of trials x = np.array([None]) # 2-step optimization process # fit masses then fit full for i in tqdm(range(N)): # Step 1: fitting the masses only params = model.generate_random_inputs(c_min=1., c_max=5.) least_squares = LeastSquares(x, model.output_values[:, :6], model.output_errors[:, :6], model.get_output_masses) optimizer = Minuit(least_squares, params, name=model.input_names) optimizer.limits = model.input_limits optimizer.fixed[:36] = True try: optimizer.migrad() optimizer.hesse() except ValueError: pass # Step 2: fitting all at once # Only run if step 1 is error-free if optimizer.fval: params_2 = np.array(optimizer.values) # feed forward y_2 = model.get_output_full(x, params_2)
dppLg = np.zeros_like(dppHg) pedestalLg = np.zeros_like(pedestalHg) if GUI: fig, ax = plt.subplots() for r in range(row): for c in range(col): channelHgPe = matrixHg[r, c, :] channelLgADC = matrixLg[r, c, :] x = channelHgPe[(channelHgPe > INF) & (channelHgPe < SUP)] y = channelLgADC[(channelHgPe > INF) & (channelHgPe < SUP)] lsq = LeastSquares(x, y, np.ones_like(y), line) fit = Minuit(lsq, m=1, q=60) fit.migrad() fit.hesse() dppLg[r, c] = fit.values["m"] pedestalLg[r, c] = fit.values["q"] print( f"Channel {r} - {c} ADC/pe: {fit.values[0]:.2f} +/- {fit.errors[0]:.2f} Pedestal: {fit.values[1]:.2f} +/- {fit.errors[1]:.2f}" ) if GUI: xFit = np.arange(channelHgPe.min(), channelHgPe.max(), 0.1) yFit = line(xFit, *fit.values) par_b = np.random.multivariate_normal(fit.values, fit.covariance,
# elif whatDetector == 'Back': # ax1 = P_DBACK.plot(kind='scatter', y ='gammaxpos', x='Back_Counts', label = 'phot',color='b') # elif whatDetector == 'Difference': # ax1 = P_DDIFF.plot(kind='scatter', y ='gammaxpos', x='Difference_Counts', label = 'phot',color='b') # elif whatDetector == 'Aug': # ax1 = P_DAUG.plot(kind='scatter', y ='gammaxpos', x='Augmented_Difference_Counts', label = 'phot',color='b') P_DDIFF = P_DDIFF.dropna() doiListPhot = P_DDIFF.gammaxpos.tolist() differenceCountsPhot = P_DDIFF.Difference_Counts.tolist() DATA_DIFFERENCE = DATA_DIFFERENCE.dropna() doiList = DATA_DIFFERENCE.gammaxpos.tolist() differenceCounts = DATA_DIFFERENCE.Difference_Counts.tolist() m = Minuit(LeastSquares(differenceCountsPhot, doiListPhot, 10.0, Line), m=-500, b=3000) m.migrad() m.hesse() # print(m.values) # x = range(int(min(differenceCounts)), int(max(differenceCounts))) # y = [Line(k, *m.values[0:2]) for k in x] # ax1.plot(x, y, color = 'k') # C = pd.DataFrame(eid_c) # if not C.empty: # C.columns = ['EventID'] # C_DFRONT = pd.merge(C,DATA_FRONT, on='EventID') # C_DBACK = pd.merge(C,DATA_BACK, on='EventID') # C_DDIFF = pd.merge(C,DATA_DIFFERENCE, on='EventID') # C_DDIFF = pd.merge(C,DATA_DIFFERENCE, on='EventID')