def M_halo(self,
alpha=-0.5,
alpha_upper=-0.475,
alpha_lower=-0.575,
beta=0,
logx0=10.4,
gamma=1,
logy0=1.61,
logy0_lower=1.49,
logy0_upper=1.75):
exists = 'halo_mass' in self.__dict__
if exists is False:
stellar_mass = self.M_bulge + self.M_disc
alpha = uf(alpha,
np.max([alpha_upper - alpha, alpha - alpha_lower]))
beta = uf(beta, 0)
x0 = uf(10**logx0, 0)
gamma = uf(gamma, 0)
y0 = uf(
10**logy0,
np.max(
[10**logy0_upper - 10**logy0,
10**logy0 - 10**logy0_lower]))
a = y0 * (stellar_mass / x0)**alpha
b = 1 / 2 + 1 / 2 * ((stellar_mass / x0)**gamma)
c = (beta - alpha) / gamma
y = a * (b**c)
self.halo_mass = y * stellar_mass
return self.halo_mass
def get_salty_Enc(E, salttype, CO2unc=0.0, H2Ounc=0.0):
"""Get a salty, nominal or less-salty enceladus with the activities as ufloats.
"""
QE = deepcopy(E)#nc(name='En', pH=ocean_pH, CO2origin='pH', T=T, workoutID=False)
CO2salt, H2Osalt = Enc.get_CO2_from_HTHeating(QE.env.T, QE.ocean_pH, salts=True)
CO2salt273, H2Osalt273 = Enc.get_CO2_from_HTHeating(273.15, QE.ocean_pH, salts=True)
aCO2, aH20, aH2, aCH4 = 0,0,0,0
if salttype == 'nom':
aCO2 = CO2salt[0]
aH2O = H2Osalt[0]
aH2 = QE.calc_mol_H2(CO2salt273[0])
aCH4 = QE.calc_mol_CH4(CO2salt273[0])
elif salttype =='high':
aCO2 = CO2salt[1]
aH2O = H2Osalt[1]
aH2 = QE.calc_mol_H2(CO2salt273[1])
aCH4 = QE.calc_mol_CH4(CO2salt273[1])
elif salttype == 'low':
aCO2 = CO2salt[2]
aH2O = H2Osalt[2]
aH2 = QE.calc_mol_H2(CO2salt273[2])
aCH4 = QE.calc_mol_CH4(CO2salt273[2])
else:
raise ValueError('Unknown salt type sent to Q_salty')
QE.composition['CO2(aq)'].activity = uf(aCO2, aCO2*CO2unc)
QE.composition['H2(aq)'].activity = aH2
QE.composition['Methane(aq)'].activity = aCH4
QE.composition['H2O(l)'].activity = uf(aH2O, aH2O*H2Ounc)
return QE
def get_CO2_from_HTHeating(T, pH, nominals=False, salts=False, CO2unc=0.):
"""
Return the CO2 activity and H2O activity as ufloats from the carbonate
speciation model, or as a list with upper and lower bounds
(when salts==True)
Attributes
----------
T : float
Temperature of your position in the ocean
pH : float
pH that the ocean would be at 273 K.
salts : boolean, optional
if True, use the carbonate speciation model and return
nominal, upper and lower bounds for both.
"""
aCO2, aH2O = Enceladus.interpo_CO2_H2O(T, pH)
if aCO2<0:
print('WARNING: negative CO2 at pH ', pH, 'Temperature', T, 'setting to 1e10 M')
if nominals:
return 1e-10, aH2O
elif salts:
aCO2_hs, aH2O_hs = Enceladus.interpo_CO2_H2O(T, pH, salt='highsalt')
aCO2_ls, aH2O_ls = Enceladus.interpo_CO2_H2O(T, pH, salt='lowsalt')
return [1e-10, 1e-10, 1e-10], [aH2O, aH2O_hs, aH2O_ls]
else:
return uf(1e-10, 2e-11), uf(aH2O,0)
if nominals:
return aCO2, aH2O
elif salts:
aCO2_hs, aH2O_hs = Enceladus.interpo_CO2_H2O(T, pH, salt='highsalt')
aCO2_ls, aH2O_ls = Enceladus.interpo_CO2_H2O(T, pH, salt='lowsalt')
return [aCO2, aCO2_hs, aCO2_ls], [aH2O, aH2O_hs, aH2O_ls]
else:
return uf(aCO2, CO2unc*aCO2), uf(aH2O,0)
def get_CO2_from_pH(self):
"""
Return the CO2 activity as estimated from the pH in (Waite et al. 2017).
Note only really valid at 273 K.
"""
absCO2 = 10**(-0.1213*(self.pH*self.pH) + (0.9832*self.pH) -3.1741)
unc = 0.2*absCO2
if self.nominals:
return uf(absCO2, unc).n
else:
return uf(absCO2, unc)
def __init__(self, name, pH=8.5, depth=0., T=273.15,
mixingratios={},
CO2origin='pH',
tigerstripeT=uf(197,20),
Pconc=uf(1e-6,0), workoutID=False,
nominals=False,
saltlevel='nom',
**kwargs):
self.depth=depth
self.env.T=T
self.env.P=(1+(99*self.depth))*100000 #100 at bottom, 1 at top, linear in between. Pressure has minimal effect on standard free energies.
self.ocean_pH = pH # the pH of the 'bulk ocean' e.g. at 273 K.
self.pH = pH # the pH at this section of the ocean, not nec. same as above.
self.mixingratios=Waite2017ratios
self.mixingratios.update(mixingratios)
self.tigerstripeT = tigerstripeT
self.nominals=nominals
mol_CO2 = 0.
aH2O=1.
oceanvals=False
if CO2origin=='tigerstripe':
mol_CO2 = self.get_tigerstripe_CO2()
self.initial_conditions(self.pH, mol_CO2, Pconc, H2Oact=aH2O, oceanvals=oceanvals)
elif CO2origin=='pH':
mol_CO2 = self.get_CO2_from_pH()
self.initial_conditions(self.pH, mol_CO2, Pconc, H2Oact=aH2O, oceanvals=oceanvals)
elif CO2origin=='HTHeating':
mol_CO2, aH2O = Enceladus.get_CO2_from_HTHeating(T=self.env.T, pH=self.ocean_pH, nominals=self.nominals)
oceanvals=True
self.initial_conditions(self.pH, mol_CO2, Pconc, H2Oact=aH2O, oceanvals=oceanvals)
elif CO2origin=='HTHeating20':
mol_CO2, aH2O = Enceladus.get_CO2_from_HTHeating(T=self.env.T, pH=self.ocean_pH, nominals=self.nominals, CO2unc=0.2)
oceanvals=True
self.initial_conditions(self.pH, mol_CO2, Pconc, H2Oact=aH2O, oceanvals=oceanvals)
elif CO2origin=='HTHeatingSalts':
mol_CO2lst, aH2Olst = Enceladus.get_CO2_from_HTHeating(T=self.env.T, pH=self.ocean_pH, nominals=self.nominals, CO2unc=0., salts=True)
# mol_CO2, aH2O = mol_CO2lst[0], aH2Olst[0]
oceanvals=True
if saltlevel == 'nom':
self.initial_conditions(self.pH, mol_CO2lst[0], Pconc, H2Oact=aH2Olst[0], oceanvals=oceanvals)
elif saltlevel == 'high':
self.initial_conditions(self.pH, mol_CO2lst[1], Pconc, H2Oact=aH2Olst[1], oceanvals=oceanvals)
elif saltlevel == 'low':
self.initial_conditions(self.pH, mol_CO2lst[2], Pconc, H2Oact=aH2Olst[2], oceanvals=oceanvals)
reactor.__init__(self, name, env=self.env,
reactionlist=self.reactionlist,
composition=self.composition,
workoutID=workoutID, **kwargs)
def hi_scalelength(self,m=0.86,m_error=0.04,c=0.79,c_error=0.02,
k=0.19,k_error=0.03): # Wang+14, Lelli+16
exists = 'R_hi' in self.__dict__
if exists is False:
m_param = uf(m,m_error)
c_param = uf(c,c_error)
k_param = uf(k,k_error)
r_d = self.R_disc
log_r_d = unp.log10(r_d)
logr_hi = m_param * log_r_d + c_param
r_hi = 10**logr_hi
self.R_hi = k_param * r_hi
return self.R_hi
def pitch_angle(self, y=1, halo='hernquist', relation='michikoshi'):
Gamma = self.total_shear(y, halo)
#tanpsi = 1.932 - 5.186*(0.5*Gamma) + 4.704*(0.5*Gamma)**2
if relation == 'michikoshi':
tanpsi = 2 / 7 * unp.sqrt(4 - 2 * Gamma) / Gamma
self.psi = unp.arctan(tanpsi) * 360 / (2 * math.pi)
elif relation == 'fuchs':
tanpsi = 1.932 - 5.186 * (0.5 * Gamma) + 4.704 * (0.5 * Gamma)**2
self.psi = unp.arctan(tanpsi) * 360 / (2 * math.pi)
elif relation == 'seigar':
m = uf(-36.62, 2.77)
c = uf(64.25, 2.87)
self.psi = m * Gamma + c
return self.psi
def runFit(self, Koff, Kon, N, Na0, Nn0, plot=True):
uKoff = uf(Koff, self.Koff_err)
uN = uf(N, self.N_err)
uNa0 = uf(Na0, self.Na0_err)
uNn0 = uf(Nn0, self.Nn0_err)
uKon = uf(Kon, self.Kon_err)
self.lg1 = f"Kon: {uKon:.2uP}, Na: {uNa0:.2uP}, Nn: {uNn0:.2uP}"
self.lg2 = f"Koff: {uKoff:.2uP}, N: {uN:.2uP}"
self.ax0.legend(labels=[self.lg1, self.lg2], title=f"Mass: {self.mass[0]}u, Res: {self.t_res}V, B0: {self.t_b0}ms", fontsize=5, title_fontsize=7)
self.get_depletion_fit(Koff, N, uKoff, uN, Na0, Nn0, Kon, uNa0, uNn0, uKon, plot)
self.get_relative_abundance_fit(plot)
self.ax1.legend(["Fitted", f"A: {self.uA:.3uP}", "Experiment"], fontsize=5, title_fontsize=7)
def runFit(self, Koff, Kon, N, Na0, Nn0, plot=True):
uKoff = uf(Koff, self.Koff_err)
uN = uf(N, self.N_err)
uNa0 = uf(Na0, self.Na0_err)
uNn0 = uf(Nn0, self.Nn0_err)
uKon = uf(Kon, self.Kon_err)
lg1 = f"Kon: {uKon:.2uP}, Na: {uNa0:.2uP}, Nn: {uNn0:.2uP}"
lg2 = f"Koff: {uKoff:.2uP}, N: {uN:.2uP}"
self.get_depletion_fit(Koff, N, uKoff, uN, Na0, Nn0, Kon, uNa0, uNn0, uKon, plot)
self.get_relative_abundance_fit(plot)
self.fig.update_layout(title_text=f"ON: {self.resOnFile.stem}[{self.powerOn}mJ], OFF: {self.resOffFile.stem}[{self.powerOff}mJ];\
A: {self.uA*100:.2uP}%; [Kon: {uKon:.2uP}, Koff: {uKoff:.2uP}]")
def get_relative_abundance_fit(self, plot=True):
self.depletion_fitted = 1 - (self.fitted_counts["resOn"]/self.fitted_counts["resOff"])
depletion_fitted_with_err = 1 - (unp.uarray(self.fitted_counts["resOn"], self.fitted_counts_error["resOn"])/unp.uarray(self.fitted_counts["resOff"], self.fitted_counts_error["resOff"]))
self.depletion_fitted_err = unp.std_devs(depletion_fitted_with_err)
self.depletion_exp = 1 - (self.counts["resOn"]/self.counts["resOff"])
depletion_exp_with_err = 1 - (unp.uarray(self.counts["resOn"], self.error["resOn"])/unp.uarray(self.counts["resOff"], self.error["resOff"]))
self.depletion_exp_err = unp.std_devs(depletion_exp_with_err)
A_init = 0.5
pop_depletion, popc_depletion = curve_fit(
self.Depletion, self.fitX, self.depletion_fitted,
sigma=self.depletion_fitted_err,
absolute_sigma=True,
p0=[A_init],
bounds=[(0), (1)]
)
perr_depletion = np.sqrt(np.diag(popc_depletion))
A = pop_depletion
A_err = perr_depletion
self.uA = uf(A, A_err)
print(f"A: {self.uA:.3uP}")
self.relative_abundance = self.Depletion(self.fitX, A)
if plot:
self.ax1.errorbar(self.power["resOn"], self.depletion_exp, yerr=self.depletion_exp_err, fmt="k.")
self.fit_plot, = self.ax1.plot(self.fitX, self.depletion_fitted)
self.relativeFit_plot, = self.ax1.plot(self.fitX, self.relative_abundance)
def __init__(self, x, y):
# Gaussian model with guessing init. values
model = GaussianModel()
guess = model.guess(y, x=x)
guess_values = guess.valuesdict()
# Fitting gaussian curve with guessed values
fit = model.fit(y,
x=x,
amplitude=guess_values['amplitude'],
center=guess_values['center'],
sigma=guess_values['sigma'])
# Fitted datas: Line freq, sigma and A
fit_data = fit.best_fit
line_freq_fit = fit.best_values['center']
sigma = fit.best_values['sigma']
A = fit.best_values['amplitude']
# FWHM and Amplitude from fitted sigma
fwhm = 2 * sigma * np.sqrt(2 * np.log(2))
amplitude = A / (sigma * np.sqrt(2 * np.pi))
# Gettign error value for sig, freq and A from fit
covar_matrix = fit.covar
varience = np.diag(covar_matrix)
perr = np.sqrt(varience)
sigma_err, line_freq_err, A_err = perr
# Making uncertainties float for sig., A and freq
usigma = uf(sigma, sigma_err)
uA = uf(A, A_err)
uline_freq = uf(line_freq_fit, line_freq_err)
# Calculating FWHM and Amplitude
ufwhm = 2 * usigma * np.sqrt(2 * np.log(2))
uamplitude = uA / (usigma * np.sqrt(2 * np.pi))
# Deriving error from calculated FWHM and Amplitude
amplitude_err = uamplitude.std_dev
fwhm_err = ufwhm.std_dev
self.fit_data, self.uline_freq, self.usigma, self.uamplitude, self.ufwhm = fit_data, uline_freq, usigma, uamplitude, ufwhm
def __init__(self, value=1, error=None):
value = float(value)
if value.is_integer():
value = int(value)
if error == None:
self.value = value
else:
self.value = uf(value, error)
def __init__(self, dT: int, h_len: float, h_max: float, v_len: float,
v_max: int, h_cyc: float, v_cyc: float, displ: float):
"""Setup experiment conditions
---------------------------
dT: temperature difference (K)
h_len: length of height axis (cm)
h_max: maximum value of height axis (m)
v_len: length of pressure axis (cm)
v_max: maximum value of pressure axis (Pa)
h_cyc: measurement of cycle on height axis (cm)
v_cyc: measurement of cycle on pressure axis (cm)
displ: measurement of displacement of piston during B->C (cm)
-----------------------------
self.dT: temperature difference (K)
self.hu: height scale units (m/cm)
self.vu: pressure scale units (Pa/cm)
self.height: height change of cycle (m)
self.volume: volume change of cycle (m^3)
self.pressure: pressure change of cycle (Pa)
self.displ: displacement of piston/mass (m)
self.cyc_work: work done by cycle (Nm)
self.useful_work: useful work done moving mass (Nm)
"""
self.dT = dT
self.hu = h_max / uf(h_len, 0.01)
self.vu = v_max / uf(v_len, 0.01)
self.height = self.hu * uf(h_cyc, 0.01)
self.volume = self.height * area
self.pressure = self.vu * uf(v_cyc, 0.01)
self.displ = self.hu * uf(displ, 0.01)
self.cyc_work = self.volume * self.pressure
self.useful_work = F * self.displ
def eDensity(solvent=(18,10),solute=[],mass_density=(1,0)):
'''
Parameters
----------
solute: list of solvents with each component in the form of tuple containing
molecular weight, electrons per molecule and concentration of that component
e.g. 10e-4 DHDP (546.85,306,1e-4), 0.5M HEH[EHP] (306.4,170,0.5)...
the mixture of DHDP and HEH[EHP]: [(546.85,306,1e-4),(306.4,170,0.5)]
Note: concentration in unit of mole/L
solvent: tuple of the molecular weight and electrons per molecule for the solvent.
e.g. water (18,10), dodecane(170.34,98)
mass_density: mass density of the solution and the uncertainty of the measurement , in g/ml
Notes
-----
Calculation, multi-component solutions likewise
rho_e = (Ne_solute + Ne_solvent)/V # Ne is the number of electrons in the solution
Ne_solute = N_A * Cons * V * ne_solute # ne is the electrons per mlecule
Ne_solvent = N_A * (mdens*V-cons*V*mwght1)/mwght2 * ne_solvent
==> rho_e = N_A*(cons*ne_solute+(mdens-cons*mwght1)/mwght2*ne_solvent)
10e-4 DHDP in dodecane: -> 0.2596 A^-3
eDensity(solvent=(170.34,98),solute=[(546.85,306,1e-4)],mass_density=(0.7495,0))
3M HNO3 in water: -> 0.3618 A^-3
eDensity(solvent=(18,10),solute=[(63,32,3)],mass_density=(1.098,0))
0.5M HEH[EHP] and 10mM Eu in dodecane: -> 0.2672
eDensity(solvent=(170.34,98),solute=[(306.4,170,0.5),(151.96,63,0.01)],mass_density=(0.7774,0))
0.5M citrate in water: -> 0.348
eDensity(solvent=(18,10),solute=[(192.12,100,0.5)],mass_density=(1.047,0))
Return
------
eDensity: electron density of that solution, in A^-3
'''
mdens = uf(mass_density[0]*1e-24,mass_density[1]*1e-24)# convert to g/A^3
# mdens = mass_density * 1e-24 # convert to g/A^3
c_n = sum([k[1]*k[2]*1e-27 for k in solute])
c_m = sum([k[0]*k[2]*1e-27 for k in solute])
rho_e = N_A*(c_n + (mdens-c_m)/solvent[0]*solvent[1])
return rho_e
def get_relative_abundance_fit(self, plot=True):
self.depletion_fitted = 1 - (self.fitted_counts["resOn"]/self.fitted_counts["resOff"])
depletion_fitted_with_err = 1 - (unp.uarray(self.fitted_counts["resOn"], self.fitted_counts_error["resOn"])/unp.uarray(self.fitted_counts["resOff"], self.fitted_counts_error["resOff"]))
self.depletion_fitted_err = unp.std_devs(depletion_fitted_with_err)
self.depletion_exp = 1 - (self.counts["resOn"]/self.counts["resOff"])
depletion_exp_with_err = 1 - (unp.uarray(self.counts["resOn"], self.error["resOn"])/unp.uarray(self.counts["resOff"], self.error["resOff"]))
self.depletion_exp_err = unp.std_devs(depletion_exp_with_err)
A_init = 0.5
pop_depletion, popc_depletion = curve_fit(
self.Depletion, self.fitX, self.depletion_fitted,
sigma=self.depletion_fitted_err,
absolute_sigma=True,
p0=[A_init],
bounds=[(0), (1)]
)
perr_depletion = np.sqrt(np.diag(popc_depletion))
A = pop_depletion
A_err = perr_depletion
self.uA = uf(A, A_err)
print(f"A: {self.uA:.3uP}")
self.relative_abundance = self.Depletion(self.fitX, A)
if plot:
error_data = dict(type="data", array=self.depletion_exp_err, visible=True)
trace1 = go.Scatter(x=self.power["resOn"], y=self.depletion_exp, mode="markers", marker=dict(color=f"black"), name="Exp", error_y=error_data)
trace2 = go.Scatter(x=self.fitX, y=self.depletion_fitted, mode="lines+markers", marker=dict(color=f"rgb{colors[0]}"), name="Fitted")
trace3 = go.Scatter(x=self.fitX, y=self.relative_abundance, mode="lines+markers", marker=dict(color=f"rgb{colors[2]}"), name="Relative")
self.fig.add_trace(trace1, row=1, col=2)
self.fig.add_trace(trace2, row=1, col=2)
self.fig.add_trace(trace3, row=1, col=2)
st.subheader(f"Relative abundance: {self.uA*100:.3uP} %")
def __init__(self,
M_b,
delta_M_b,
M_d,
delta_M_d,
a_b,
delta_a_b,
R_d,
delta_R_d,
M_hi,
delta_M_hi,
scale=1.5,
scale_error=0.2):
self.M_b = M_b.to(u.Msun)
self.delta_M_b = delta_M_b.to(u.Msun)
self.M_d = M_d.to(u.Msun)
self.delta_M_d = delta_M_d.to(u.Msun)
self.a_b = a_b.to(u.kpc)
self.delta_a_b = delta_a_b.to(u.kpc)
self.R_d = R_d.to(u.kpc)
self.delta_R_d = delta_R_d.to(u.kpc)
self.M_hi = M_hi.to(u.Msun)
self.delta_M_hi = delta_M_hi.to(u.Msun)
self.scaler = uf(scale, scale_error)
self.M_bulge = unp.uarray(self.M_b.value, self.delta_M_b.value)
self.M_disc = unp.uarray(self.M_d.value, self.delta_M_d.value)
self.R_bulge = (unp.uarray(self.a_b.value, self.delta_a_b.value) /
self.scaler)
self.R_disc = (unp.uarray(self.R_d.value, self.delta_R_d.value) /
self.scaler)
self.M_hi = unp.uarray(self.M_hi.value, self.delta_M_hi.value)
H0 = 70 * u.km / u.s / u.Mpc
rho_crit = (3 * H0**2) / (8 * math.pi * const.G)
self.rho_crit = (rho_crit.to(u.kg / u.m**3))
def __init__(self,M_b,delta_M_b,M_d,delta_M_d,a_b,delta_a_b,
R_d,delta_R_d,M_hi,delta_M_hi,M_h=None,delta_M_h=None,
R_h=None,delta_R_h=None,scale=1.5,scale_error=0.2,
fix_halo=False):
self.M_b = M_b.to(u.Msun)
self.delta_M_b = delta_M_b.to(u.Msun)
self.M_d = M_d.to(u.Msun)
self.delta_M_d = delta_M_d.to(u.Msun)
self.a_b = a_b.to(u.kpc)
self.delta_a_b = delta_a_b.to(u.kpc)
self.R_d = R_d.to(u.kpc)
self.delta_R_d = delta_R_d.to(u.kpc)
self.M_hi = M_hi.to(u.Msun)
self.delta_M_hi = delta_M_hi.to(u.Msun)
self.M_h = M_h.to(u.Msun) if M_h is not None else None
self.delta_M_h = (delta_M_h.to(u.Msun) if delta_M_h is not None
else None)
self.R_h = R_h.to(u.kpc) if R_h is not None else None
self.delta_R_h = (delta_R_h.to(u.kpc) if delta_R_h is not None
else None)
self.scaler = uf(scale,scale_error)
self.M_bulge = unp.uarray(self.M_b.value,self.delta_M_b.value)
self.M_disc = unp.uarray(self.M_d.value,self.delta_M_d.value)
self.R_bulge = (unp.uarray(self.a_b.value,self.delta_a_b.value)
/ self.scaler)
self.R_disc = (unp.uarray(self.R_d.value,self.delta_R_d.value)
/ self.scaler)
self.M_hi = unp.uarray(self.M_hi.value,self.delta_M_hi.value)
self.fix_halo = fix_halo
H0 = 70 * u.km/u.s/u.Mpc
rho_crit = (3 * H0**2) / (8*math.pi*const.G)
self.rho_crit = (rho_crit.to(u.kg/u.m**3))
# -*- encoding: utf-8 -*
import numpy as np
import matplotlib.pyplot as plt
from uncertainties import ufloat as uf
R = uf(10000, 500)
R1 = uf(50000, 2500)
G = R/R1
print(G)
data = np.genfromtxt("../dati/scope_1.csv", delimiter=",", skip_header=2)
t = data[:,0] * 1000
vout = data[:,1] / 2.0 - 0.1
vin = data[:,2] / 2.0
f = plt.figure(figsize=(8, 5))
ax = f.add_subplot(111)
f.suptitle("Sommatore pesato di tensioni")
v1 = ax.errorbar([-2.5, 2.5], [1, 1], linewidth=2, fmt="-", c="gray")
v2 = ax.errorbar(t, vin, linewidth=2, fmt="--", c="black")
vo = ax.errorbar(t, vout, linewidth=2, fmt="-", c="black")
adc = ax.errorbar([-2.5, 2.5], [-0.2, -0.2], fmt="-", c="black")
ax.set_xlabel("Tempo [ms]")
ax.set_ylabel("Tensione [V]")
ax.set_xlim((-2.5, 2.5))
ax.set_ylim((-0.7, 1.2))
from uncertainties import ufloat as uf
from math import pi
diam = uf(32 / 1000, 1 / 1000)
area = ((diam / 2)**2) * pi
F = 0.1 * 9.81
class Experiment:
def __init__(self, dT: int, h_len: float, h_max: float, v_len: float,
v_max: int, h_cyc: float, v_cyc: float, displ: float):
"""Setup experiment conditions
---------------------------
dT: temperature difference (K)
h_len: length of height axis (cm)
h_max: maximum value of height axis (m)
v_len: length of pressure axis (cm)
v_max: maximum value of pressure axis (Pa)
h_cyc: measurement of cycle on height axis (cm)
v_cyc: measurement of cycle on pressure axis (cm)
displ: measurement of displacement of piston during B->C (cm)
-----------------------------
self.dT: temperature difference (K)
self.hu: height scale units (m/cm)
self.vu: pressure scale units (Pa/cm)
self.height: height change of cycle (m)
self.volume: volume change of cycle (m^3)
self.pressure: pressure change of cycle (Pa)
self.displ: displacement of piston/mass (m)
self.cyc_work: work done by cycle (Nm)
self.useful_work: useful work done moving mass (Nm)
from math import sqrt
from numpy import array, mean
def unc(arr, syst):
stat = arr.std(ddof=1) / sqrt(len(arr))
return sqrt(stat**2 + syst**2)
def out(what, howmuch):
print("{} = {:L}".format(what, howmuch))
print()
# ----- METODA KYVŮ -----
k_m = uf(148, 0.1) / 1000
k_l = uf(234, 3) / 1000
g = 9.81
k_a_10T = array([24.54, 24.52, 24.43, 24.43, 24.45])
k_a_T = k_a_10T / 10
k_10T = uf(mean(k_a_10T), unc(k_a_10T, 0.01))
k_T = uf(mean(k_a_T), unc(k_a_T, 0.001))
out("k_10T", k_10T)
out("k_T", k_T)
k_I = k_m * k_l * ((g * k_T**2) / (4 * pi**2) - k_l)
out("I", k_I)
from uncertainties import ufloat as uf
from math import pi
import numpy as np
# ----- DRÁT -----
r = uf(19.28, 0.01) * 0.001
n_0 = uf(147, 0.5) * 0.001
n = uf(116, 0.5) * 0.001
L = uf(810, 1) * 0.001
l_0 = uf(1156.14, 1.2) * 0.001
m = uf(1.4, 0)
d = uf(0.51, 0.01) * 0.001
delta_l = (r * (n_0 - n)) / (2 * L)
E = (4 * l_0 * m * 9.81) / (delta_l * pi * d**2)
print("delta_l:", delta_l)
print("E:", E)
# ----- TRÁMEK -----
l = uf(412, 1) * 0.001
a_o = uf(11.98, 0.02) * 0.001
b_o = uf(1.95, 0.01) * 0.001
a_m = uf(11.84, 0.03) * 0.001
b_m = uf(1.98, 0.01) * 0.001
y_o = uf(1, 0.05) * 0.001
y_m = uf(1.83, 0.05) * 0.001
m = uf(0.1, 0)
E_o = (m * 9.81 * l**3) / (4 * y_o * a_o * b_o**3)
def initial_conditions(self, pH, mol_CO2, Pconc, H2Oact=1.0, oceanvals=False, mol_CO2_oc=None):
"""
Set up the initial conditions of the ocean in the configuration
defined in the initialisation.
Attributes
----------
pH : float
wider ocean (273 K) pH
mol_CO2 : float
Calculated activity of CO2 at this ocean location.
Pconc : ufloat
Concentration of phosphorus
H2Oact : float, optional
water activity, default 1.0.
oceanvals : boolean, optional
whether computing the wider ocean CO2 activity is needed.
mol_CO2_oc : float, optional
wider ocean CO2 activity. Default is None (then calculated here)
"""
if mol_CO2_oc == None:
mol_CO2_oc = mol_CO2
if oceanvals:
#get wider ocean CO_2
mol_CO2_oc = Enceladus.get_CO2_from_HTHeating(T=273.15, pH=pH)[0]
mol_CH4 = (self.mixingratios['CH4']/self.mixingratios['CO2'])*mol_CO2_oc#2.75*mol_CO2 #0.34*mol_CO2
mol_H2 = (self.mixingratios['H2']/self.mixingratios['CO2'])*mol_CO2_oc#11*mol_CO2 #103*mol_CO2
mol_NH3 = (self.mixingratios['NH3']/self.mixingratios['CO2'])*mol_CO2_oc
mol_H2S = (self.mixingratios['H2S']/self.mixingratios['CO2'])*mol_CO2_oc
# ^ from the ratios in the plumes, hence are upper limits
mol_H=uf(10**(-pH),0)
if self.nominals:
mol_CH4 = mol_CH4.n
mol_H2 = mol_H2.n
mol_NH3 = mol_NH3.n
mol_H2S = mol_H2S.n
mol_H=uf(10**(-pH),0).n
# reagents
CO2 = reaction.reagent('CO2(aq)', self.env, phase='g', conc=mol_CO2,
activity=mol_CO2)
H2aq = reaction.reagent('H2(aq)', self.env, phase='aq', conc=mol_H2,
activity=mol_H2)
CH4aq = reaction.reagent('Methane(aq)', self.env, phase='g', conc=mol_CH4,
activity=mol_CH4)
H2O = reaction.reagent('H2O(l)', self.env, phase='l', conc=uf(55.5, 0), activity=uf(H2Oact,0))
el = reaction.reagent('e-', self.env, charge=-1)
H = reaction.reagent('H+', self.env, charge=1, conc=mol_H,
phase='aq', activity=mol_H)
self.composition = {CO2.name:CO2, H2aq.name:H2aq,
CH4aq.name:CH4aq, H2O.name:H2O, H.name:H}
# overall
r = {self.composition['CO2(aq)']:1, self.composition['H2(aq)']:4}
p = {self.composition['Methane(aq)']:1, self.composition['H2O(l)']:2}
thermaloa = reaction.reaction(r,p,self.env)
# redox
fr = {self.composition['CO2(aq)']:1, self.composition['H+']:8, el:8}
fp = {self.composition['Methane(aq)']:1, self.composition['H2O(l)']:2}
fwd = reaction.redox_half(fr, fp, self.env, 8, -0.244)
rr = {self.composition['H+']:8, el:8}
rp = {self.composition['H2(aq)']:4}
# E ref: Karp, Gerald, Cell and Molecular Biology, 5th Ed., Wiley, 2008
rvs = reaction.redox_half(rr, rp, self.env, 8, -0.421)
# redox cell reaction is thermal overall
rx = reaction.redox(fwd, rvs, thermaloa, 8, self.env)
self.reactionlist = {thermaloa.equation:{type(thermaloa):thermaloa,
type(rx):rx}}
# add in CHNOPS, in elemental form for now
# we already have C in the form of CO2 and CH4
self.composition['NH3(aq)'] = reaction.reagent('NH3(aq)', self.env, phase='aq', conc=mol_NH3,
activity=mol_NH3) # from Glein, Baross, Waite 2015
# P and S we don't actually know.
self.composition['P(aq)'] = reaction.reagent('P(aq)', self.env, phase='aq', conc=Pconc,
activity=Pconc, thermo=False)
self.composition['H2S(aq)'] = reaction.reagent('H2S(aq)', self.env, phase='aq', conc=mol_H2S,
activity=mol_H2S, thermo=False)
dip_indices = signal.find_peaks(-data['Voltage (uV)'], prominence=10)[0]
dips = data.iloc[dip_indices]
# Split dips into P and R bands
# This also resets the indices so we can use them as quantum number L later
p_band = dips[dips['Wavelength (nm)'] <= 3255].reset_index(drop=True)
r_band = dips[dips['Wavelength (nm)'] >= 3350].reset_index(drop=True)
# Find dv values and average, with error
p_diff = p_band.diff().abs()
r_diff = r_band.diff().abs()
p_mean = p_diff['Wavenumber (cm^-1)'].mean()
p_sem = p_diff['Wavenumber (cm^-1)'].sem()
r_mean = r_diff['Wavenumber (cm^-1)'].mean()
r_sem = r_diff['Wavenumber (cm^-1)'].sem()
p_mean = uf(p_mean, p_sem)
r_mean = uf(r_mean, r_sem)
# Find B from 2B=dv estimate
pb = p_mean / 2
rb = r_mean / 2
b_from_dv = (pb + rb) / 2
print('B estimated from dv in P band: {} cm^-1'.format(pb))
print('B estimated from dv in R band: {} cm^-1'.format(rb))
print('Average B estimate from dv: {} cm^-1'.format(b_from_dv))
# Find linear fits for trendlines
p_trend = linregress(p_band.index, p_band['Energy (J)'])
r_trend = linregress(r_band.index, r_band['Energy (J)'])
# Gradient m = +/-2hcB so ZB = +/- m/(2hc)
rt = abs(uf(r_trend.slope, r_trend.stderr) * (10 ** -2) / (2 * const.Planck * const.speed_of_light))
from uncertainties import ufloat as uf
from math import pi, sqrt
# harmonic oscillator with original values
dt = uf(6.30, 0.01)*1e-3
w = 2*pi/dt
print("\nHarmonic oscillator with original values\n")
print("w0 = {}\n".format(w))
# harmonic oscillator with modified inverting gain
dt = uf(4.26, 0.01)*1e-3
w = 2*pi/dt
w_teo = 1e3*sqrt(2)
print("Harmonic oscillator with modified inverting gain")
print("R1 = 10k\t R2 = 22k\t w0 = {}\n".format(w))
print("Expected w = {}\n". format(w_teo))
# harmonic oscillator with different C
dt = uf(617e-6, 0.01e-6)
w = 2*pi/dt
print("w0 = {}\n".format(w))
def main():
# Set up command line switches
parser = argparse.ArgumentParser(
description='Weighted mean and error allowing for external noise',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog = textwrap.dedent(f'''\
This is version {__version__}
Reads a table of values with standard error estimates and calculates
the weighted mean and error, allowing for the possibility that there
is an additional source of uncertainty.
The input table can be any format suitable for reading with the
command astropy.table.Table.read(), e.g., CSV.
By default, the calculation is done using columns 1 and 2 in the
table. Use the flag --val_col and --err_col to specify alternative
column names or numbers.
If --val_col is used and --err-col is not specified, the program will ..
- use the column val_col+1 if val_col is an integer
- look for a column named "e_"+val_col
- look for a column named val_col+"_err"
- give up...
'''))
parser.add_argument('table', nargs='?',
help='Table of values and errors'
)
parser.add_argument('-f', '--format',
help='Table format - passed to Table.read()'
)
parser.add_argument('-v', '--val_col',
default=1,
help='''Column with values
(default: %(default)d)
'''
)
parser.add_argument('-e', '--err_col',
default=None,
help='Column with errors'
)
parser.add_argument('-1', '--one_line',
action='store_const',
dest='one_line',
const=True,
default=False,
help='Output results on one line'
)
parser.add_argument('-p', '--precise',
action='store_const',
dest='precise',
const=True,
default=False,
help='More precise (but slower) calculation'
)
args = parser.parse_args()
if args.table is None:
parser.print_usage()
exit(1)
table = Table.read(args.table, format=args.format)
try:
val_col = int(args.val_col) - 1
name = 'y'
except ValueError:
val_col = str(args.val_col)
name = args.val_col
y = table[val_col][:]
if args.err_col is None:
if isinstance(val_col, int):
yerr = table[val_col+1][:]
else:
try:
err_col = 'e_'+str(args.val_col)
yerr = table[err_col][:]
except KeyError:
err_col = str(args.val_col)+'_err'
yerr = table[err_col][:]
else:
yerr = table[args.err_col][:]
if args.precise:
nw, ns, nb, sf = 128, 1500, 500, 2
else:
nw, ns, nb, sf = 64, 150, 50, 1
mu, e_mu, sig, e_sig, sampler = combine(y, yerr,
walkers=nw, steps=ns, discard=nb)
if not args.one_line:
n = len(y)
print (f'\nRead {n} values from {args.table}')
print (up(uf(y.max(), yerr[np.argmax(y)]),
f'Maximum value of {name}', sf=sf))
print (up(uf(y.min(), yerr[np.argmin(y)]),
f'Minimum value of {name}', sf=sf))
wt = 1/yerr**2
wsum = wt.sum()
wmean = (y*wt).sum()/wsum
chisq = ((y-wmean)**2*wt).sum()
e_int = np.sqrt(1/wsum)
e_ext = np.sqrt(chisq/(n-1)/wsum)
print(f' Weighted mean = {wmean:0.4f}')
print (up(uf(wmean, e_int),f'{name}', sf=sf), '(Internal error)')
print (up(uf(wmean, e_ext),f'{name}', sf=sf), '(External error)')
print(f' Chi-square = {chisq:0.2f}')
p = 1-gammainc(0.5*(n-1),0.5*chisq)
print(f' P(chi-sq. > observed chi-sq. if mean is constant) = {p:0.2}')
print ("--")
print(up(uf(mu,e_mu), name, sf=sf) + '; ' +
up(uf(sig, e_sig),'sigma_ext', sf=sf))
def mean_error(arr):
mean = arr.mean()
std = arr.std(ddof=1)
meandev = std / len(arr)
error = (meandev**2 + 0.1**2)**(1 / 2)
return mean, error
v1_x1_mean, v1_x1_error = mean_error(vrstva1["x1"])
v1_x2_mean, v1_x2_error = mean_error(vrstva1["x2"].dropna())
v2_x1_mean, v2_x1_error = mean_error(vrstva2["x1"])
v2_x2_mean, v2_x2_error = mean_error(vrstva2["x2"].dropna())
from uncertainties import ufloat as uf
t1 = (
uf(v1_x1_mean, v1_x1_error) / uf(v1_x2_mean, v1_x2_error)
) * (
LAMBDA / 2
)
t2 = (
uf(v2_x1_mean, v2_x1_error) / uf(v2_x2_mean, v2_x2_error)
) * (
LAMBDA / 2
)
# ----- ÚKOL 2 ----- #
newton = dataframe_from_csv("../data/newton.csv")
newton = newton * 1e-6
ax.set_xlabel(r"$U_F [\si{V}]$")
ax.set_ylabel(r"$I_F [\si{A}]$")
ax.legend()
fig.tight_layout()
if show:
plt.show()
if save:
plt.savefig("../plot/red.pdf")
return fit.params, fit.errors
param_red_VA, err_red_VA = plot_red_VA_char()
R_d_red = 1 / uf(param_red_VA[0], err_red_VA[0])
U_star_red = uf(param_red_VA[1], err_red_VA[1]) / \
uf(param_red_VA[0], err_red_VA[0])
def plot_blue_VA_char(show=False, save=False):
fig = plt.figure()
ax = fig.add_subplot(111)
lin_start = 60
fit = FitCurve(f_line, blue["U_F"][lin_start:], blue["I_F"][lin_start:])
ax.plot(blue["U_F"],
blue["I_F"],
"k+",
ms=3,
# make a reactor object
rtr = Enceladus('EncT')
# make an organism, for this example, use the preset methanogen.
org = TOM(rtr)
# org.dry_mass=29e-18 # set volume to 1 cubic micron.
TE = nm.apps_theory_estimates(org, rtr)
Tijhuis, TijhuisAerobe, TijhuisAnaerobe = [], [], []
Lever10pc, Lever2pc, Lever1AA = [], [], [] # in-built energy
Lever10pc_ces, Lever2pc_ces, Lever1AA_ces = [], [], [] # constant energy
for i, T in enumerate(Ts):
TE.loc.change_T(T)
TE.org.get_ESynth(AA=True) # update the synthesis energy
td = TE.temperature_defenses(T)
Tijhuis.append(uf(td['Tijhuis'], 0.29 * td['Tijhuis']))
TijhuisAerobe.append(uf(td['TijhuisAerobe'], 0.41 * td['TijhuisAerobe']))
TijhuisAnaerobe.append(
uf(td['TijhuisAnaerobe'], 0.32 * td['TijhuisAnaerobe']))
Lever1AA.append(td['Lever1/250'])
Lever10pc.append(td['Lever10pc'])
Lever2pc.append(td['Lever2pc'])
print(T, TE.org.E_synth / (1000 * org.dry_mass),
1.7e-11 * (org.dry_mass / 29e-18) / (1000 * org.dry_mass))
TE.org.E_synth = 1.7e-11 * (org.dry_mass / 29e-18
) # convert so dry mass matches this organism
td = TE.temperature_defenses(T)
Lever1AA_ces.append(td['Lever1/250'])
Lever10pc_ces.append(td['Lever10pc'])
Lever2pc_ces.append(td['Lever2pc'])
sys.path.append(os.path.dirname(__file__))
import math
from NutMEG.environment import *
from NutMEG.reactor import reactor
import NutMEG.reaction as reaction
from itertools import chain
from uncertainties import ufloat as uf
import uncertainties.umath as umath
import numpy as np
from scipy import interpolate
Waite2017ratios = {'CO2': uf(0.55, 0.25), 'CH4': uf(0.2, 0.1), 'NH3': uf(0.85, 0.45), 'H2': uf(0.9,0.5), 'H2S':uf(0.0021,0.001)}
class Enceladus(reactor):
"""
The chemically active evirionment of the Enceladean ocean.
It has a few unique attributes, and at the moment does not take
kwargs for reactors. This may be added in the future when the
NutMEG is a little more flexible.
This is a saved instance of reactor, which contains the
methanogenesis and environmental data for the moon. Initial composition
can be estimated using mixing ratios from Waite et al. (2017) or
user-specified ones. Concentration of CO2 and pH can be estimated at
elevated temperatures using data from Higgins et al. (2021).
from uncertainties import ufloat as uf
import math
# units
mev = 1.
gev = 1e3 * mev
ev = 1e-6 * mev
s = 1. / ( 6.582119569e-16 * ev )
ps = 1e-12 * s
# constants
GF = uf(1.16673787,0.0000006)*1e-5 / (gev**2) #Fermi's constant
m_t = uf(1776.86,0.12)*mev
m_mu = uf(105.6583745,0.0000024)*mev
m_e = uf(0.5109989461,0.0000000031)*mev
br_tau2mu = uf(0.1739,0.0004)
br_tau2e = uf(0.1782,0.0004)
def BR_P2LNU(m_p, f_p, t_p, vckm, m_l = m_t):
f0 = GF**2 * m_p * m_l**2 / ( 8. * math.pi )
f1 = ( 1. - m_l**2 / m_p**2 )**2 * f_p**2 * vckm**2 * t_p
return f0*f1
# some examples
m_bc = uf(6274.9,0.8)*mev
t_bc = uf(0.510,0.009)*ps
v_cb = uf(0.0412,0.0009)
f_bc = uf(434.,15.)*mev
br_bc2taunu = BR_P2LNU(m_bc, f_bc, t_bc, v_cb)
