def ubspecdat(h,s,f,df):
"""Calculate ubr and Tbr from measured spectra
The input parameter *f* can be either a scalar or a vector
Parameters
----------
h : float or array-like
Water depth (m)
s : array-like
Spectral densities normalized so that
Hs = 4 * sum(s, 2) * df
*s* is either of length *nf* or (*nt*, *nf*).
f : array-like
Row vector with central frequencies (Hz)
df : float, optional
Scalar or row vector with freq. bandwidths (Hz)
Returns
-------
(ubr, Tbr) :
ubr = representative bottom orbital velocity (m/s)
Tbr = representative bottom wave period (s)
The alternative bottom period, Tbz, is also calculated (see text).
"""
# Chris Sherwood, USGS
# Last revised September 8, 2006
# Recoded in Python by PL Wiberg, Oct 2014
xx = s.shape
nf = xx[1]
nt = xx[0]
w = 2 * np.pi * f
# Determine kh using Soulsby (2006) method
kh = qkhfs(w,h)
w = np.tile(w,(nt,1))
fm = np.tile(f,(nt,1))
kh = np.tile(kh,(nt,1))
h = h * np.ones((nt,nf))
if df:
if np.len(df) == 1:
df = df * np.ones(nt,nf)
elif np.len(df) == nf:
df = np.tile(df,(nt,1))
else:
df = np.diff(f)
df = np.hstack((df,df[-1]))
df = np.tile(df,(nt,1))
Su = ((w ** 2) / (np.sinh(kh) ** 2)) * s
ubr = np.sqrt(2 * np.sum((Su * df)))
fr = np.sum((Su * fm * df)) / (np.sum((Su * df)))
Tbr = 1. / fr
fz = np.sqrt(np.sum((Su * fm ** 2 * df))) / (np.sum((Su * df)))
Tbz = 1. / fz
return ubr, Tbr
def ubspecdat(h, s, f, df):
"""Calculate ubr and Tbr from measured spectra
The input parameter *f* can be either a scalar or a vector
Parameters
----------
h : float or array-like
Water depth (m)
s : array-like
Spectral densities normalized so that
Hs = 4 * sum(s, 2) * df
*s* is either of length *nf* or (*nt*, *nf*).
f : array-like
Row vector with central frequencies (Hz)
df : float, optional
Scalar or row vector with freq. bandwidths (Hz)
Returns
-------
(ubr, Tbr) :
ubr = representative bottom orbital velocity (m/s)
Tbr = representative bottom wave period (s)
The alternative bottom period, Tbz, is also calculated (see text).
"""
# Chris Sherwood, USGS
# Last revised September 8, 2006
# Recoded in Python by PL Wiberg, Oct 2014
xx = s.shape
nf = xx[1]
nt = xx[0]
w = 2 * np.pi * f
# Determine kh using Soulsby (2006) method
kh = qkhfs(w, h)
w = np.tile(w, (nt, 1))
fm = np.tile(f, (nt, 1))
kh = np.tile(kh, (nt, 1))
h = h * np.ones((nt, nf))
if df:
if np.len(df) == 1:
df = df * np.ones(nt, nf)
elif np.len(df) == nf:
df = np.tile(df, (nt, 1))
else:
df = np.diff(f)
df = np.hstack((df, df[-1]))
df = np.tile(df, (nt, 1))
Su = ((w**2) / (np.sinh(kh)**2)) * s
ubr = np.sqrt(2 * np.sum((Su * df)))
fr = np.sum((Su * fm * df)) / (np.sum((Su * df)))
Tbr = 1. / fr
fz = np.sqrt(np.sum((Su * fm**2 * df))) / (np.sum((Su * df)))
Tbz = 1. / fz
return ubr, Tbr
def stackOLA(self,input_ola,window_ola): input_len = np.len(input_ola) new_window_ola_len = np.len(window_ola) step_stack = int(new_window_func*0.5) count_stack = int((input_len-new_window_ola_len)/step_stack) + 1 ola_stack = np.zeros((new_window_ola_len, count_stack)) for i in range(0,count_stack): ola_stack[i]=window_ola*input_ola[1:new_window_ola_len + ((i-1)*step)] #have to correct the array format return ola_stack
def scaledown(x, minval, maxval):
"""
Converts [minval,maxval] to [-1,1] with points always lying inside [-1,1]. Returns scaled down values.
"""
scaled = np.min((
np.max((2 * (x - minval) / (maxval - minval) - 1,
-1 * np.ones(np.len(x)))),
np.ones(np.len(x)),
))
return scaled
def scaleup(x, minval, maxval):
"""
Converts [-1,1] to [minval,maxval] range with points always lying inside new range. Returns scaled up version of values.
"""
scaled = np.min((
np.max((
0.5 * (x + 1) * (maxval - minval) + minval,
minval * np.ones(np.len(x)),
)),
maxval * np.ones(np.len(x)),
))
return scaled
def to_signal(self):
"""
Creates a hyperspy.Signal1D object with the same spectrum
Returns
----------
s : hyperspy.Signal1D
hyperspy object
"""
nf = np.len(self.spec_x_array)
spec_name = 'index'
if self.spec_units in ['nm', 'um']:
spec_name = 'Wavelength'
elif self.spec_units == 'eV':
spec_name = 'E'
dict_f = {
'name': spec_name,
'units': self.spec_units,
'scale': self.spec_x_array[1] - self.spec_x_array[0],
'size': nf,
'offset': self.spec_x_array[0]
}
s = Signal1D(np.squeeze(self.spec_im), axes=[dict_f])
s.change_dtype('float64')
return s
def get_h_char_track(f, f_start, f_end, M, eta, M_chirp, Dl, constants):
# constants = np.arrays([H0, Omega_m, L, f_star, Tobs, NC])
f_star = constants[3]
L = constants[2]
NC = constants[5]
Tobs = constants[4]
A_arr = np.zeros(len(f))
h_c_arr = np.zeros(len(f))
arg_start = np.where(f <= f_start)[0][-1]
if (f_end > 1.): # i.e. off the graph
arg_end = np.len(f) - 1
else:
arg_end = np.where(f >= f_end)[0][0]
for i in range(arg_start, arg_end):
A_arr[i] = get_A(f[i], M, eta, M_chirp, Dl)
h_c_arr[i] = f[i] * A_arr[i] * np.sqrt(16. / 5.)
SNR = 0.
f, Sn = get_Sn(constants)
for i in range(arg_start, arg_end):
freq = 0.5 * (f[i] + f[i - 1])
Sn_est = 0.5 * (1. / Sn[i] + 1. / Sn[i - 1])
SNR += 16. / 5. * freq * get_A(
freq, M, eta, M_chirp,
Dl)**2 * Sn_est * (np.log(f[i]) - np.log(f[i - 1]))
SNR = np.sqrt(SNR)
return h_c_arr, SNR
def trapezoidal(f, a, b, N):
h=(b-a)/N;
x=np.linspace(a,b,N+1);
y = (h/2)*(f(x[0:np.len(x)-1])+f(x[1:len(x)]));
return np.sum(y);
def ssnj_yerror(x, y):
x_sum = np.sum(x) #B
y_sum = np.sum(y) #F
y_ave = y_sum / np.len(y)
x2_sum = np.sum(x * x) #A
delta = np.len(x) * x2_sum - x_sum * x_sum #
Y_ave = np.array([y_ave] * len(x))
Y_var = y - Y_ave # array
σ_obs = Y_var * Y_var
σ_y = np.sqrt(np.sum(σ_obs) / (len(x) - 2))
σ_a = σ_y * np.sqrt(len(x) / delta)
σ_b = σ_y * np.sqrt(x2_sum / delta)
array = [σ_a, σ_b]
return (array)
def get_cohen_d(treatment, control): #For t-test, the effect size is: m_t = np.mean(treatment) m_c = np.mean(control) sd_t = np.std(treatment) sd_c = np.std(control) n_t = np.len(treatment) n_c = np.len(control) sd_pooled = np.sqrt(( ((n_t - 1) * np.pow(sd_t,2)) + ((n_c - 1) * np.pow(sd_c,2)) )) / (n_t+n_c) d = m_t - m_c / sd_pooled
def __init__(self, vN, tilt, p, nx1):
self.nx = np.len(vN)
self.t = np.round(
np.append(np.linspace(-tilt, tilt, nx1 / 2),
np.linspace(tilt, -tilt, nx1 / 2))).astype(int)
self.v = np.zeroes_like(vN)
for j in range(nx):
self.v[j] = np.roll(vN[j], -int(p), axis=0)
for i in range(nx1):
self.v[j, i] = np.roll(self.v[j, i], self.t[i], axis=0)
def find_constant_for_all(self, max_iteration_number=40):
# we need to find F(every E and T) - F(E_min, T_min) = F(every E and T)
# at all steps and summ it for each point (E, T)
E = np.arange(-100, 200, 0.25)
T = np.arange(-30, 40, 0.05)
X, Y = np.meshgrid(E, T)
d1x, d2x = np.shape(X)
d1y, d2y = np.shape(Y)
X_ = X.reshape((d1x * d2x, 1))
Y_ = Y.reshape((d1y * d2y, 1))
t = 1 # start time
# Z_ = self.vector_calc_fuctional(X_, Y_, t)
z_min = np.array((0,))
y_min = np.array((0,))
x_min = np.array((0,))
# np array for quadratic errors of each iteration
error = np.zeros((np.len(E), np.len(T)))
for i in range(0, max_iteration_number):
pass
def integrate(self, loBE = 0., hiBE = 1., model = "linear", integralmethod = "simpson", args = "none"):
"""
Returns a float value that represents the area under specified peaks in XPS data.
The inputs are:
loBE [eV]: Numerical value of the lower bound of the binding energy interval (abscissa) to be analyzed. Default: 0. eV.
hiBE [eV]: Numerical value of the upper bound of the binding energy interval (abscissa) to be analyzed. Default: 1. eV.
model: A string indicating the background type to be removed. Valid inputs are "linear", "shirley", "tougaard", "blended" or "none". Default: "linear".
integralmethod: A string indicating method of integration. Valid inputs are "simpson" and "trapezoid". Default: "simpson".
args: Other arguments affecting the integration method. Default: "none".
"""
# First, we need to determine the indices of the upper and lower bounds of the energy interval of interest.
#Index of starting energy
n1 = 0
while self["BE"][n1] <= loBE:
n1 = n1 + 1
#Index of ending energy
n2 = numpy.len(self["BE"]) - 1
while self["BE"][n2] >= hiBE:
n2 = n2 - 1
# Second, we need to produce a numpy array that represents the XPS background.
if model == "none":
pass
elif model == "linear":
for i in range(n1, n2):
StaibDat.rm_background(self["C1"], loBE = self["BE"][n1], hiBE = self["BE"][n2])
elif model == "shirley":
for i in range(n1, n2):
StaibDat.rm_background(self["C1"], loBE = self["BE"][n1], hiBE = self["BE"][n2], model = "shirley")
elif model == "blended":
for i in range(n1, n2):
StaibDat.rm_background(self["C1"], loBE = self["BE"][n1], hiBE = self["BE"][n2], model = "blended")
elif model == "tougaard":
for i in range(n1, n2):
StaibDat.rm_background(self["C1"], loBE = self["BE"][n1], hiBE = self["BE"][n2], model = "tougaard")
# Finally, we integrate using scipy's integration functions to obtain a float value.
if integralmethod == "simpson":
scipy.integrate.simps(self["C1"][n1:n2] - backgroundvalues(), self["BE"][n1:n2])
elif integrelmethod == "trapezoid":
scipy.integrate.trapz(self["C1"][n1:n2] - backgroundvalues(), self["BE"][n1:n2])
def medianFilt(oi, kernel_size=None):
"""
kernel_size is the half width
"""
if type(oi) == list:
return [medianFilt(o, kernel_size=kernel_size) for o in oi]
if 'OI_FLUX' in oi.keys():
# -- make sure the tellurics are handled properly
if 'TELLURICS' in oi.keys():
t = oi['TELLURICS']
else:
t = np.ones(np.len(oi['WL']))
for k in oi['OI_FLUX'].keys():
for i in range(len(oi['OI_FLUX'][k]['MJD'])):
mask = ~oi['OI_FLUX'][k]['FLAG'][i, :]
oi['OI_FLUX'][k]['FLUX'][i, mask] = scipy.signal.medfilt(
oi['OI_FLUX'][k]['FLUX'][i, mask] / t[mask],
kernel_size=kernel_size) * t[mask]
oi['OI_FLUX'][k]['EFLUX'][i, mask] /= np.sqrt(kernel_size)
if 'OI_VIS' in oi.keys():
for k in oi['OI_VIS'].keys():
for i in range(len(oi['OI_VIS'][k]['MJD'])):
mask = ~oi['OI_VIS'][k]['FLAG'][i, :]
oi['OI_VIS'][k]['|V|'][i, mask] = scipy.signal.medfilt(
oi['OI_VIS'][k]['|V|'][i, mask], kernel_size=kernel_size)
oi['OI_VIS'][k]['E|V|'][i, mask] /= np.sqrt(kernel_size)
oi['OI_VIS'][k]['PHI'][i, mask] = scipy.signal.medfilt(
oi['OI_VIS'][k]['PHI'][i, mask], kernel_size=kernel_size)
oi['OI_VIS'][k]['EPHI'][i, mask] /= np.sqrt(kernel_size)
if 'OI_VIS2' in oi.keys():
for k in oi['OI_VIS2'].keys():
for i in range(len(oi['OI_VIS2'][k]['MJD'])):
mask = ~oi['OI_VIS2'][k]['FLAG'][i, :]
oi['OI_VIS2'][k]['V2'][i, mask] = scipy.signal.medfilt(
oi['OI_VIS2'][k]['V2'][i, mask], kernel_size=kernel_size)
oi['OI_VIS2'][k]['EV2'][i, mask] /= np.sqrt(kernel_size)
if 'OI_T3' in oi.keys():
for k in oi['OI_T3'].keys():
for i in range(len(oi['OI_T3'][k]['MJD'])):
mask = ~oi['OI_T3'][k]['FLAG'][i, :]
oi['OI_T3'][k]['T3PHI'][i, mask] = scipy.signal.medfilt(
oi['OI_T3'][k]['T3PHI'][i, mask], kernel_size=kernel_size)
oi['OI_T3'][k]['ET3PHI'][i, mask] /= np.sqrt(kernel_size)
oi['OI_T3'][k]['T3AMP'][i, mask] = scipy.signal.medfilt(
oi['OI_T3'][k]['T3AMP'][i, mask], kernel_size=kernel_size)
oi['OI_T3'][k]['ET3AMP'][i, mask] /= np.sqrt(kernel_size)
return oi
def minimize(self, coefficients=None, degree=None, initialize=False):
if initialize:
if coefficients is not None:
degree = len(coefficients)
else:
# try a random set of coefficients
if degree is None:
degree = np.len(self.target)
coeff = np.zeros((degree, 6), dtype=np.float64)
coeff[0, 0] = kc
coeff[:, 3] = 1.0
return coeff
# actual optimisation
self.earliercoefficients = np.array(self.coefficients)
def error(*args):
pass
def arm_selection(network,arms,alg=discounted_thompson,gamma = 1, field=[],first_iter=False):
"""
Performs one round when the agents select an arm based on a specified algorithm and assign the allocation
sequence and array of rewards to the corresponding agent.
Inputs:
network - network of social interactions
field - Gaussian random field
alg - which allocation algorithm will be used (default: deterministic)
"""
global K
if alg == deterministic_ucl or alg == block_ucl:
arms = field_to_arms(field)
for i in range(len(network)):
priors = network.node[i]['prior mean']
prior_var = network.node[i]['prior variance']
variance = network.node[i]['variance']
n_arms = np.len(arms)
n_visits = network.node[i]['n']
avg_arms = network.node[i]['m_bar']
time_horizon = 1
a,b,n,m_bar = alg(priors,prior_var,variance,n_arms,time_horizon,arms,n_visits, avg_arms,random_rewards=False)
network.node[i]['alloc_seq'] = np.append(network.node[i]['alloc_seq'],field_to_arms(a,math.sqrt(n_arms)))
network.node[i]['rewards'] = np.append(network.node[i]['rewards'],b)
network.node[i]['prior mean'] = np.mean(network.node[i]['rewards']) #update priors to have them ready for next iteration
network.node[i]['n'] = network.node[i]['n'] + n
network.node[i]['m_bar'] = network.node[i]['m_bar'] + m_bar
elif alg == discounted_thompson or alg == discounted_thompson_general:
for i in range(len(network)):
alpha_0 = beta_0 = 1
S = network.node[i]['S']
F = network.node[i]['F']
T = 1
alloc_seq,reward_seq,S,F = alg(arms,gamma,alpha_0,beta_0,K, T, S,F, first_iter)
network.node[i]['alloc_seq'] = np.append(network.node[i]['alloc_seq'],alloc_seq)
network.node[i]['rewards'] = np.append(network.node[i]['rewards'],reward_seq)
network.node[i]['S'] = S
network.node[i]['F'] = F
else:
print ('ERROR, a mistake in this function')
def prime(z):
alpha = 0.2
# Implementing MAP classifier along with Softmax
if not f:
"""Compute softmax values for each sets of scores in x."""
e_x = np.exp(x - np.max(x))
return e_x / e_x.sum()
scores = [0.0, 1.0, 2.0]
print(Softmax(scores))
q = np.array(3)
q[0] = np.len(x[y==0]) / np.len(x)
q[1] = np.len(x[y==1]) / np.len(x)
q[2]= np.len(x[y==2]) / np.len(x)
for l in range(2):
z = np.argmax(scores[l]*q[l])
z[z < 0] = alpha
z[z > 0] = 1
return z
def basisPursuit_Lorenz96(Vapproximate,D,optEquation,optPolynomial,opts,sigma):
n = Vapproximate.shape[1]
Vtest = Vapproximate[:, optEquation - 1] # optEquation between 1 to n inclusive
soln = np.zeros((D.shape[1],1))
# normalize dictionary and solve the optimization
Dnormalized = np.divide(D, np.tiles(np.sqrt(np.sum(np.square(D), axis = 0)),D.shape[0],1))
c,r,g,d = spgl1(Dnormalized, Vtest, 0, sigma, verbosity = opts.get('verbosity'), iter_lim = opts.get('iterations') )
c = np.divide(c, np.sqrt(np.sum(np.square(D), axis = 0)) # for D normalized
# rescale back to the monomial basis
cRecoverIndex = np.argwhere(c)
if optPolynomail == 'legendre':
for i in range (0, np.len(cRecoverIndex)):
indTmp = cRecoverIndex[i]
if (indTmp == 0):
soln(indTmp) = c[indTmp]
elif (indTmp <= n):
soln(indTmp) = c(indTmp) * math.sqrt(3)
else:
soln(indTmp) = c(indTmp) * 3
else:
soln = c
return soln
def rm_background(self, loBE = 0., hiBE = 1., model = "linear", offset = 0., blend = [], tParam = []):
"""
Return a numpy array corresponding to the background electron count.
XPS data typically consists of the sum of the signal from an XPS event and
some background count from scattered electrons. rm_background calculates
the background electron count over a specified interval and returns an
array with this data. The interval is defined by the loBE and hiBE input
arguments, the default being the lower bound and upper bound of the
object's binding energy data, respectively. The returned array has
elements corresponding to the elements in self["BE"] in the specified
energy interval by default.
Input arguments as well as their units and default values are given as
follows:
loBE [eV]: Numerical value of the lower bound of the binding energy
interval to be analyzed. Default: lower bound of the object's binding
energy.
hiBE [eV]: Numerical value of the upper bound of the binding energy
interval to be analyzed. Default: upper bound of the object's binding
energy.
model: A string indicating the name of background removal algorithm to
use. Valid inputs are "linear", "shirley", "blended" for blended Shirley
type background, or "tougaard".
offset [eV]: A float value of desired energy offset for calculation
of background. Default: 0. eV.
blend: A float value between 0 and 1 for blending linear and Shirley
backgrounds. See notes for blend-type background. Default: [].
tParam = A float value for use in the tougaard removal algorithm.
Default: [].
"""
background_values = list()
#Index of starting energy
n1 = 0
while self["BE"][n1] <= loBE:
n1 = n1 + 1
#Index of ending energy
n2 = numpy.len(self["BE"]) - 1
while self["BE"][n2] >= hiBE:
n2 = n2 - 1
# energyInterval = (self["BE"] > loBE) & (self["BE"] < hiBE)
# For materials with a relatively small step in the background over the
# energy range covered by the peaks, the background in this case may be
# approximated by a linear type background:
#
# L(E) = (I1 * (E2 - E) + I1 * (E - E1)) / (E2 - E1)
#
# where E1 and E2 are two distinct energies and I1 and I2 are the two
# associated intensity values.
if model == "linear":
for i in range(n1, n2):
BG = (self["C1"][n1] * (self["BE"][n2] - self["BE"][i]) + self["C1"][n2] * (self["BE"][i] - self["BE"][n1])) / (self["BE"][n2] - self["BE"][n1])
background_values().append(BG)
return numpy.array(background_values)
# The Shirley algorthim is an iterative determination of the background.
# The formula for computing the Shirley background is:
#
# S(E) = I2 + (I1 - I2) * A2(E) / (A1(E) + A2(E))
#
# where the integrated areas A1(E) and A2(E) represent the area under
# the spectrum to the left and right of the energy value E.
#
# See the original paper at DOI: 10.1103/PhysRevB.5.4709.
elif model == "shirley":
for i in range(n1, n2):
A1[i] = StaibDat.integrate(loBE = self["BE"][0], hiBE = self["BE"][i], model = "shirley", integralmethod = "simpson")
A2[i] = StaibDat.integrate(loBE = self["BE"][i], hiBE = self["BE"][-1], model = "shirley", integralmethod = "simpson")
BG = self["C1"][n2] + (self["C1"][n1] - self["C1"][n2]) * A1[i] / (A1[i] + A2[i])
background_values().append(BG)
return numpy.array(background_values)
# If you find that area intensity ratios of certain peaks are violated
# using pure Shirley or linear backgrounds, use a blended type in order
# to satisfy whatever ratio is dictated by physics (e.g. degeneracy of
# doublet peaks, etc.) to make a "less wrong" background.
#
# The blended type background is calculated from a blend of linear and
# an offset Shirley backgrounds:
#
# OS(E:u,v) = S(E - v) * (1 - u) + u * L(E)
#
# The parameters u and v represent a linear blend between the Shirley
# background (u = 0) and a linear background (u = 1), where the Shirley
# curve is offset by an energy of v eV.
elif model == "blended":
if offset != 0.:
n3 = 0
while self["BE"][n3] <= self["BE"][n1] + offset:
n3 = n3 + 1
if n3 < n1:
for i in range(n3, n2):
linBG = (self["C1"][n1] * (self["BE"][n2] - self["BE"][i]) + self["C1"][n2] * (self["BE"][i] - self["BE"][n1])) / (self["BE"][n2] - self["BE"][n1])
A1[i] = StaibDat.integrate(loBE = self["BE"][0], hiBE = self["BE"][i], model = "shirley", integralmethod = "simpson")
A2[i] = StaibDat.integrate(loBE = self["BE"][i], hiBE = self["BE"][-1], model = "shirley", integralmethod = "simpson")
ShrBG = self["C1"][n2] + (self["C1"][n3] - self["C1"][n2]) * A1[i] / (A1[i] + A2[i])
BG = blend * linBG + ShrBG * (1 - blend)
background_values().append(BG)
return numpy.array(background_values)
elif n3 >= n1:
for i in range(n1, n2):
linBG = (self["C1"][n1] * (self["BE"][n2] - self["BE"][i]) + self["C1"][n2] * (self["BE"][i] - self["BE"][n1])) / (self["BE"][n2] - self["BE"][n1])
A1[i] = StaibDat.integrate(loBE = self["BE"][0], hiBE = self["BE"][i], model = "shirley", integralmethod = "Simpson")
A2[i] = StaibDat.integrate(loBE = self["BE"][i], hiBE = self["BE"][-1], model = "shirley", integralmethod = "Simpson")
shrBG = self["C1"][n2] + (self["C1"][n1] - self["C1"][n2]) * A1[i] / (A1[i] + A2[i])
BG = blend * linBG + shrBG * (1 - blend)
background_values().append(BG)
return numpy.array(background_values)
# The Tougaard background is based on an energy loss cross section F(x)
# representing the probability that an electron at energy offset x undergoes
# a loss event and therefore appears as a contibution to the background.
#
# See: DOI:10.1016/S0039-6028(98)00852-8
elif model == "tougaard":
for i in range(n1, n2):
for j in range(n1, n2):
BG = scipy.integrate.trapz(B * self["C1"][i] * self["C1"][j - i] / (1634 + (self["C1"][j - i])^2)^2)
background_values().append(BG)
else:
raise InputError
counter = 0
for number in range(number):
print(message)
#%%
message = int(input("Enter the total numbers you want to be averaged:"))
A = []
counter =0
for counter in range(message):
counter+=1
A.append(counter)
print(A)
total = int(np.sum(A))
length = int(np.len(A))
average = int(total/length)
print("Average: %s" % average)
#%%%
message = int(input("Enter the total numbers you want to be averaged:"))
for i in range(message):
sum =+ i
values = int(i)
average= int(sum/values)
def __len__(self):
return np.len(self.trace)
import numpy as num
import matplotlib.pyplot as plt
data = np.loadtxt("random_walks.txt")
y = data[:, 0]
x = num.linspace(0, num.len(data), 1)
plt.hist(y, x, (0, 100))
plt.show()
plt.savefig("rand.png")
def vfit_grad( X, Y, V, V_err, nmin=7):
"""
Function to fit a single gradient to a velocity field.
It assumes solid body rotation, and it uses the velocity uncertainty.
X : Off-Set. With appropriate units (e.g. deg)
Y : Off-Set. With appropriate units (e.g. deg)
V : Radial velocity. With appropriate units (e.g. km/s)
V_err : Uncertainty in radial velocity. With appropriate units (e.g. km/s)
param :
nmin : Minimum number of pixels required to carry out the fit. Default is 7,
which is appropriate for single dish data that is Nyquist sampled
OUTPUTS:
Vc: Mean centroid velocity in km/s
Vc_err: Uncertainty of the mean centroid velocity in km/s
Grad: Velocity gradient in km/s/pc
Grad_Err: Uncertainty associated to the velocity gradient (km/s/pc)
PosAng: Position angle of the fitted gradient, in degrees
PAErr: Uncertainty of the position angle (degrees)
ChiSq: Chi^2
"""
# Xold = copy(X)
# Yold = copy(Y)
npts = X.shape
if npts < nmin:
results = result_container()
results.Grad = np.nan
results.Grad_err = np.nan
results.GradPA = np.nan
results.GradPA_err = np.nan
results.Vc = np.nan
results.Vc_err = np.nan
return results #
wt = 1/(V_err**2)
# Obtain total weight, and average (x,y,v) to create new variables (dx,dy,dv)
# which provide a lower uncertainty in the fit.
#
sumWt = np.sum(wt)
x_mean=np.sum(X*wt)/sumWt
y_mean=np.sum(Y*wt)/sumWt
v_mean=np.sum(V*wt)/sumWt
dx = (X-x_mean)#[mask] # remove mean value from inputs
dy = (Y-y_mean)#[mask] # to reduce fit uncertainties
dv = (V-v_mean)#[mask] #
M = [[np.sum(wt), np.sum(dx*wt), np.sum(dy*wt)],
[np.sum(dx*wt), np.sum(dx**2*wt), np.sum(dx*dy*wt)],
[np.sum(dy*wt), np.sum(dx*dy*wt), np.sum(dy**2*wt)]]
#print M
from scipy import linalg
try:
covar = linalg.inv(M)
except IOError:
import sys
sys.exit('Singular matrix: no solution returned')
coeffs = np.dot(covar,[[np.sum(dv*wt)], [np.sum(dx*dv*wt)],[np.sum(dy*dv*wt)]])
#
errx= np.sqrt(covar[1, 1])
erry= np.sqrt(covar[2, 2])
#
gx = coeffs[1][0]
gy = coeffs[2][0]
#
vc = coeffs[0]+v_mean
vp = coeffs[0]+coeffs[1]*dx+coeffs[2]*dy
grad = np.sqrt(coeffs[1]**2+coeffs[2]**2)
posang = np.arctan2(gy, -gx)*180/pi
#print -gx,gy,posang
red_chisq = np.sum( (dv-vp)**2*wt)/(np.len(dv)-3.)
vc_err = 0.
grad_err = np.sqrt((gx*errx)**2+(gy*erry)**2)/grad
#print 'grad_err1', grad_err
grad_err = np.sqrt((gx*errx)**2+(gy*erry)**2+2*gx*gy*covar[2,1])/grad
#print 'grad_err2', grad_err
paerr = 180/pi*sqrt((gx/(gx**2+gy**2))**2*erry**2+
(gy/(gx**2+gy**2))**2*errx**2)
#print 'paerr1',paerr
paerr = 180/pi*sqrt((gx/(gx**2+gy**2))**2*erry**2+
(gy/(gx**2+gy**2))**2*errx**2-2*gx*gy/(gx**2+gy**2)**2*covar[2,1])
#print 'paerr2',paerr
chisq = red_chisq
vp += v_mean
# Restore X and Y
# X=copy(Xold)
# Y=copy(Yold)
results = result_container()
results.Grad = grad
results.Grad_err = grad_err
results.GradPA = posang
results.GradPA_err = paerr
results.Vc = vc
results.Vc_err = vc_err
return results #
def fit_gaussian1D_mask(signal, position, mask_width, center_type="COM"):
"""
Fit a 2D gaussian to a masked image based on
the location of the mask, size of the mask and
the type of the mask
Parameters
----------
signal: ndarray
The 1D signal that will be fitted with the Gaussian
position: float
x center of the mask
mask_width: float
The size of the mask.
center_type: str
Center location for the first pass of the Gaussian.
Default is `COM`, while the other options are `minima`
or `maxima`.
Returns
-------
popt: tuple
Refined X position, Standard deviation, Amplitude
Notes
-----
This code uses the `scipy.optimize.curve_fit` module to fit a 1D
Gaussian peak to masked data. `mask_x` refers to the initial
starting position. Also, this can take in `minima` as a string
for initializing Gaussian peaks.
See also
--------
fit_gaussian2D_mask
initialize_gauss1D
gaussian_1D_function
:Authors:
Debangshu Mukherjee <*****@*****.**>
"""
xV = np.arange(np.len(signal))
sub = np.abs(xV - position) < mask_width
x_pos = np.asarray(xV[sub], dtype=np.float)
masked_signal = np.asarray(signal[sub], dtype=np.float)
mi_min = np.amin(masked_signal)
mi_max = np.amax(masked_signal)
if center_type == "minima":
calc_signal = (masked_signal - mi_max) / (mi_min - mi_max)
initial_guess = initialize_gauss1D(x_pos, calc_signal, "maxima")
else:
calc_image = (masked_image - mi_min) / (mi_max - mi_min)
initial_guess = initialize_gauss1D(x_pos, calc_signal, center_type)
lower_bound = ((initial_guess[0] - mask_width), 0,
((-2.5) * initial_guess[5]))
upper_bound = (
(initial_guess[0] + mask_radius),
(2.5 * mask_radius),
(2.5 * initial_guess[5]),
)
popt, _ = spo.curve_fit(
gaussian_1D_function,
x_pos,
calc_signal,
initial_guess,
bounds=(lower_bound, upper_bound),
ftol=0.01,
xtol=0.01,
)
if center_type == "minima":
popt[-1] = (popt[-1] * (mi_min - mi_max)) + mi_max
popt[-1] = (popt[-1] * (mi_max - mi_min)) + mi_min
return popt
def step(self, a,LoggedSignals,params):
#s = self.state
nSteps=8200;
Constants= params.Constants, Settings=params.Settings, T70=0
oilUptakeDelay=Constants.OIL_UPTAKE_DELAY/Settings.DT;
V=80; Amax=1.21; Amin=0.79;
state1= LoggedSignals.State, T=LoggedSignals.T
mask8=(T%480)>475#% for RT : exeute action of Ag/ammonia only each 8h
if params.RT==0:
mask8=1
S=LoggedSignals.S
if ( params.control=='valid') & LoggedSignals.Start>0:
LoggedSignals.Start=0;T=0;params.RT=0# temp
if T>LoggedSignals.Start:
A=LoggedSignals.A1[T]
SOil=LoggedSignals.SOil
DO=LoggedSignals.DO1[T], X=LoggedSignals.X1[T]
else:
# start
A=LoggedSignals.A
LoggedSignals.isDexLow=0
LoggedSignals.soyBeanFeedMat=np.zeros(np.len(params.oil_feed_time),nSteps)
SOil=0
DO=LoggedSignals.DO
X=LoggedSignals.X/Constants.prop_biomss
#LoggedSignals.S=State(6);
t_se=480;delA=params.delAmat(Action)
if ~mask8:
delA=0
if params.RT==1:
t_se=60
if T==0:
t_se=24*60-1
LoggedSignals.F_s[1440] =0
LoggedSignals.Ag[1440] =285
for i in range(1,t_se):
T=T+1 #;% if T>1; LoggedSignals.F_s[T] =LoggedSignals.F_s(T-1) ;end
if T<24*60:
LoggedSignals.fs_min[T]=0; LoggedSignals.fs_max[T]=0
LoggedSignals.ag_min[T]=Settings.agL(1); LoggedSignals.ag_max[T]=Settings.agH(1);
if T==1:
LoggedSignals.Ag[T] =285
LoggedSignals.F_s[T] =0
A=params.meanA24[T];
elif T>24*60-1 & T<70*60:
A=A+delA
temA=A
A=temA-delA if temA>Amax else A # isApple = True if fruit == 'Apple' else False
A=temA-delA if temA<Amin else A
delA=0
if not( np.where(LoggedSignals.S<2 & LoggedSignals.S>0,1,'first')):#LoggedSignals.S[T]>5
if T==24*60:
LoggedSignals.F_s[T]=100; LoggedSignals.Ag[T] =271;
A=1.19
LoggedSignals.fs_min[T]=Settings.fsL(2); LoggedSignals.fs_max[T]=Settings.fsH(2)
LoggedSignals.ag_min[T]=Settings.agL(2); LoggedSignals.ag_max[T]=Settings.agH(2)
else:
if T== np.where(LoggedSignals.S<2 & LoggedSignals.S>0,1,'first'):
LoggedSignals.T2=T
LoggedSignals.F_s[T] =140
LoggedSignals.fs_min[T]=params.Settings.fsL(3); LoggedSignals.fs_max[T]=params.Settings.fsH(3);
LoggedSignals.ag_min[T]=Settings.agL(2); LoggedSignals.ag_max[T]=Settings.agH(2);
elif T>70*60-1:
A=A+delA
temA=A
A=temA-delA if temA>Amax else A # isApple = True if fruit == 'Apple' else False
A=temA-delA if temA<Amin else A
delA=0
LoggedSignals.fs_min[T]=params.Settings.fsL(4); LoggedSignals.fs_max[T]=params.Settings.fsH(4);
LoggedSignals.ag_min[T]=params.Settings.agL(3); LoggedSignals.ag_max[T]=params.Settings.agH(3);
if T==70*60:
LoggedSignals.F_s[T] =110; LoggedSignals.Ag[T] = LoggedSignals.Ag(T-1);
delFs=params.fsM(Action);
if i>1 or (LoggedSignals.F_s[T] +params.fsM(Action))>LoggedSignals.fs_max[T] or (LoggedSignals.F_s[T] +params.fsM(Action))<LoggedSignals.fs_min[T]:
delFs=0;
LoggedSignals.F_s[T+1] =LoggedSignals.F_s[T] +delFs#;% FS solution
LoggedSignals.F_s[T] =Constants.DEXTROSE_FEEDING_CONCENTRATION*LoggedSignals.F_s[T];
if T<30*60:# % late feeding
LoggedSignals.F_s[T]=0;
delAg=params.agM(Action);
if i==1 and isfield(LoggedSignals,'T2')and T>=LoggedSignals.T2 and T<=(LoggedSignals.T2+24*60):
delAg =np.min(params.agM)
if ~mask8 or i>1 or (LoggedSignals.Ag[T] +delAg)>LoggedSignals.ag_max[T] or (LoggedSignals.Ag[T] +delAg)<LoggedSignals.ag_min[T]:
delAg=0;
# for T>70 , Ag rate is 16h (for t<70 it equal to 8h)
# T70=[T70; T];if T70(end)-T70(end-1)<1.2*t_se; delAg=0; end
LoggedSignals.Ag[T+1] =LoggedSignals.Ag[T] +delAg;
# LoggedSignals.Ag[T] =max(LoggedSignals.Ag[T] ,LoggedSignals.ag_max[T]);
if T==LoggedSignals.Start+1: # %T==1
#%LoggedSignals.Ag=zeros(1,9000);
LoggedSignals.rnd1=1+floor(rand(1)*length(params.impData1));
LoggedSignals.AgOld=280#;%params.impData1{1,LoggedSignals.rnd1}.agitation[T];
LoggedSignals.S[T]=S; LoggedSignals.P1[T]=0;#%params.impData1{1,LoggedSignals.rnd1}.sConcen(1);
if i==1:
# % LoggedSignals.Ag[T]=LoggedSignals.AgOld+params.agM( Action);
LoggedSignals.AgOld=LoggedSignals.Ag[T];
rnd1=LoggedSignals.rnd1;
#% type
"""
if strcmp( params.control,'FsAg'):
i=i
elif params.control=='valid':
LoggedSignals.F_s[T] =params.impData1{1,rnd1}.F_s[T];% LoggedSignals.Ag[T]= LoggedSignals.AgOld; %LoggedSignals.Ag[T]=params.agM( Action);
LoggedSignals.Ag[T]=params.impData1{1,rnd1}.agitation[T];
A=params.impData1{1,rnd1}.A[T];
Constants.airFlowVVM=params.impData1{1,rnd1}.airFlowVVM[T];
if T==1% daynamics verfication
LoggedSignals.S[T]= params.impData1{1,1}.sConcen(1);
X=0.15;
% State(2)=params.impData1{1,1}.biomass(1);
DO=0.007;%=params.impData1{1,1}.DOg2l(1);
A=params.impData1{1,1}.A(1);
"""
#% dymamics
idx=1;
relRows= T>2 and np.transpose(LoggedSignals.isDexLow)==0 and np.transpose(LoggedSignals.S[T])<5;
if relRows:
LoggedSignals.isDexLow=1;
relFeedingIdx=T+np.arange(oilUptakeDelay,T)+oilUptakeDelay+params.oil_feed_time(idx);#%period of soybean oil feeding
# norm_feeding_bell=self.new_bell(relFeedingIdx,length(relFeedingIdx)/0.5,...
#% 0.1,t+oilUptakeDelay+(params.oil_feed_time(idx)/2));% normalized sigmoid value for feeding
c1=T+oilUptakeDelay+params.oil_feed_time(idx)/2
sig=params.oil_feed_time(idx)/4
norm_feeding_bell=exp(-((relFeedingIdx-c1)/sig)^2);
sum_norm_feeding_bell=np.sum(norm_feeding_bell,2);
feeding_bell=norm_feeding_bell*params.InitialCond.SoybeanOil/sum_norm_feeding_bell
LoggedSignals.soyBeanFeedMat[idx,relFeedingIdx(relFeedingIdx<=nSteps)]=feeding_bell(relFeedingIdx<=nSteps)*params.oil_utility(idx);
LoggedSignals.soyBeanFeedMat[idx,relFeedingIdx(relFeedingIdx<=nSteps)]=0;
relDepressionIdx=np.arange(T,T+oilUptakeDelay)
recoveringIdx=T+np.arange(oilUptakeDelay,nSteps)
#% tau=T+oilUptakeDelay;
tau=c1;
LoggedSignals.C[idx,relDepressionIdx]=params.oil_utility(idx);
LoggedSignals.C[idx,recoveringIdx]=1-(1-params.oil_utility(idx))*exp(-((recoveringIdx-(T+oilUptakeDelay))
/(tau-(T+oilUptakeDelay))));
#% DO[idx,t-1]=min(DO(idx,t-1)+0.15*Constants.DO_MAX,Constants.DO_MAX);
# if 0#%strcmp( params.test1,'DO10')
# DO=0.2*Constants.DO_MAX;
rel_mo=params.m_o[1]*LoggedSignals.C[T];
rel_mx=params.m_x(1)*LoggedSignals.C[T];
div=np.sqrt(params.K_I(1)*params.K_ps2(1))/(params.K_I(1)+(sqrt(params.K_I(1)*params.K_ps2(1)))+
(sqrt(params.K_I(1)*params.K_ps2(1)))^2/params.K_ps2(1));
norm_mich_ment=(LoggedSignals.S[T]/(params.K_I(1)+LoggedSignals.S[T]+
(LoggedSignals.S[T]^2./params.K_ps2(1))))/div;
norm_mich_ment_oil=(SOil/(params.K_I(1)+SOil+...
(SOil^2./params.K_ps2(1))))/div;
mu=LoggedSignals.C[T]*params.mu_x(1)*(LoggedSignals.S[T]/(params.K_x(1)+LoggedSignals.S[T]))*(DO/(params.K_ox(1)+DO))*(A/(params.K_xa(1)+A))
alpha1=4e-4; ag05=290;
mu_ag=1/(1+exp(alpha1*ag05*(LoggedSignals.Ag[T]-ag05)))
mu_pp=LoggedSignals.C[T]*params.mu_p(1)*(A/(params.K_p.ravel()+A))*(DO/(DO+params.K_op(1)))*norm_mich_ment;
mu_pp=mu_pp*mu_ag;
mu_pp_oil=LoggedSignals.C[T]*params.mu_p(1)*(A/(params.K_p(1)+A))*(DO/(DO+params.K_op(1)))*norm_mich_ment_oil #;%Dextrose part of Michaelis Menten
mu_pp_oil=mu_pp_oil*mu_ag;
m_xOil=rel_mx*SOil/(LoggedSignals.S[T]+SOil);
m_xDex=rel_mx*LoggedSignals.S[T]/(LoggedSignals.S[T]+SOil);
minusSOil=Settings.DT*X*(mu_pp_oil/params.Y_ps(1)+m_xOil);
plusSOil=SOil+ LoggedSignals.soyBeanFeedMat[T];
isOverDraft=minusSOil>plusSOil;
coefOil=np.ones(length(params.K_x(1)),1);
coefOil[isOverDraft]=plusSOil(isOverDraft)/minusSOil(isOverDraft);
SOil=SOil+ LoggedSignals.soyBeanFeedMat[T]-Settings.DT*X*coefOil*(mu_pp_oil/params.Y_ps(1)+m_xOil);
plusDO=DO+Settings.DT*(params.K_la(1)*
((LoggedSignals.Ag[T]/Constants.AGI_REF_VAL)^2*(Constants.airFlowVVM/Constants.AF_REF_VAL))*(Constants.DO_MAX-DO));
minusDO=Settings.DT*(X*
((mu/params.Y_xo(1))+rel_mo+(mu_pp+mu_pp_oil)/params.Y_po(1)));
DOCoef=(plusDO-(Constants.DO_MAX/25))/minusDO;
plusS=LoggedSignals.S[T]+Settings.DT*(LoggedSignals.F_s[T]/V);
minusS=Settings.DT*(X*
((mu/params.Y_xs(1))+m_xDex+
mu_pp/params.Y_ps(1)));
SCoef=(plusS-0.1)/minusS;
reductionCoef=min(DOCoef,SCoef);
naturalS=LoggedSignals.S[T]+Settings.DT*(-X*((mu/params.Y_xs(1))+m_xDex+mu_pp/params.Y_ps(1))+LoggedSignals.F_s[T]/V);
coefS=LoggedSignals.S[T]+Settings.DT*(-X*reductionCoef*
((mu/params.Y_xs(1))+m_xDex+
mu_pp/params.Y_ps(1))+LoggedSignals.F_s[T]/V);
naturalDO=DO+Settings.DT*(X*...
(-(mu/params.Y_xo(1))-rel_mo-(mu_pp+mu_pp_oil)/params.Y_po(1))+params.K_la(1)*
((LoggedSignals.Ag[T]/Constants.AGI_REF_VAL)^2*
(Constants.airFlowVVM/Constants.AF_REF_VAL))*(Constants.DO_MAX-DO));
coefDO=DO+Settings.DT*(X*reductionCoef*
(-(mu/params.Y_xo(1))-rel_mo-(mu_pp+mu_pp_oil)/params.Y_po(1))+params.K_la(1)*
((LoggedSignals.Ag[T]/Constants.AGI_REF_VAL)^2*
(Constants.airFlowVVM/Constants.AF_REF_VAL))*(Constants.DO_MAX-DO));
isCoef=coefS>naturalS or coefDO>naturalDO;
LoggedSignals.S[T+1]=naturalS;
#%LoggedSignals.S[T](find(isCoef))=coefS(find(isCoef));
if isCoef:
LoggedSignals.S[T+1]=coefS;
DO=naturalDO;
DO[find(isCoef)]=coefDO(find(isCoef));
DO=min(Constants.DO_MAX,DO);
Coef=ones(length(naturalDO),1);
Coef[find(isCoef)]=reductionCoef(find(isCoef));
#%A=1;%;params.impData1{1,rnd1}.A;
X=X+Settings.DT*X*(Coef*mu-params.K_d(1)*A);
LoggedSignals.P1[T+1]=np.max(0,LoggedSignals.P1[T]+Settings.DT*
((Coef*mu_pp+coefOil*mu_pp_oil)*X-params.K(1)*LoggedSignals.P1[T]));#%in [g/l]
LoggedSignals.A1[T]=A; LoggedSignals.DO1[T]=DO; LoggedSignals.X1[T]=X; LoggedSignals.A[T]=A;
for t in range(0, t_end-(dt1+1), Settings['DT']): # start from t=1[minutes]
currModelState[pref['Data variables']] =\
validationData[pref['Data variables']].iloc[t]
# If featuresDist is a modeled parameter, we should not update it from data!!
currModelState[pref['featuresDist']] = validationData[pref['featuresDist']].iloc[t]
for var in pref['Variables']:
delVariableName = var + '_del'
if t % dt1:
modeledVars[var].iloc[t+1] =modeledVars[var].iloc[t]
else:
varT=modeledVars[var].to_numpy()[t]
bestParams = results[var]['bestParams']
relTestData = currModelState[bestParams['features']]#.to_numpy()
allRelTestDataInit = pd.concat([currModelState[bestParams['features']],currModelState[bestParams['featuresDist']]]
, axis=1).dropna()
allRelTestData = allRelTestDataInit.T.drop_duplicates().T # Remove duplications from "allRelTrainDataInit" dataframe
testDistVar = currModelState[bestParams['featuresDist']].to_numpy()
test_dist={}; train_dist={}; distSumSqr = 0
for varForDist in bestParams['featuresDist']:
test_dist[varForDist] = np.repeat(testDistVar.T,
dataDict[var]['trainDistVar'].size, axis=0)
train_dist[varForDist] = np.repeat(dataDict[var]['trainDistVar'],
len(testDistVar),
axis=1)
distVarSqr = (test_dist[varForDist] - train_dist[varForDist]) ** 2
distSumSqr+=distVarSqr
npoints=int(np.ceil(bestParams['frac']*dataDict[var]['trainDistVar'][:,0].size))
dist=np.sqrt(distSumSqr)
w=np.argsort(dist,axis=0)[:npoints]
deltaVar, x ,bias_re,bias_vel= loess_nd_test_point_mat\
(pref,pd.DataFrame(relTestData).T,bestParams['features'],dataDict[var]['relTrainData'], dataDict[var]['trainDistVar'],
dataDict[var]['trainResults'],dist,w,scale_params[var],var,varT, frac=frac1)
for jj in range(1,1*len(pref['Combinations']),1): # in case of bias go to the next config
ii=results[var]['sortedCombinations'][jj]
if bias_vel<0.7 or bias_vel>1.3:
break
if len(pref['Combinations'][ii]['features']) <2:
continue
allRelTrainDataInitB = pd.concat([modelingDataCombined[pref['Combinations'][ii]['features']],
modelingDataCombined[pref['Combinations'][ii]['featuresDist']],
modelingDataCombined[delVariableName]], axis=1).dropna()
allModelingData = allRelTrainDataInitB.T.drop_duplicates().T # Remove duplications from "allRelTrainDataInit" dataframe
#dataDict[var]['relTrainData'] = allModelingData[pref['Combinations'][ii]['features']].to_numpy() # relevant features for linear equation.
relTestData = currModelState[pref['Combinations'][ii]['features']]
deltaVar, x ,bias_re,bias_vel= loess_nd_test_point_mat\
(pref,pd.DataFrame(relTestData).T,pref['Combinations'][ii]['features'],
allModelingData[pref['Combinations'][ii]['features']].to_numpy(), dataDict[var]['trainDistVar'],
dataDict[var]['trainResults'],dist,w,scale_params[var],var,varT, frac=frac1)
demo=2
modeledVars[var].iloc[t+1] = \
modeledVars[var].iloc[t] + dt1*deltaVar/60
modeledVars[var+'_biasVel'].iloc[t+1:t+1+dt1]=list(bias_re*np.ones([1,dt1]).T)
currModelState[var] = modeledVars[var].iloc[t+1]
if T>(nSteps-480):
break
# ODEINT IS TOO SLOW!
# ns_continuous = integrate.odeint(self._dsdt, self.s_continuous, [0, self.dt])
# self.s_continuous = ns_continuous[-1] # We only care about the state
# at the ''final timestep'', self.dt
sh=0;
bellMax=0.65;
lowDexVal=0.1;
highDexVal=4;
if LoggedSignals.S(T)>bellMax:
DexState=(LoggedSignals.S(T)-bellMax)/(highDexVal-bellMax);
else:
DexState=-(LoggedSignals.S(T)-bellMax)/(lowDexVal-bellMax);
LoggedSignals.T=T;
LoggedSignals.State[1]=(mean( LoggedSignals.DO1(np.arange(T+1-120-sh,T-sh)))-0.0005)/0.0005;
#% LoggedSignals.State(2)=Constants.prop_biomss*(mean( LoggedSignals.X1(T+1-120:T))-4)/3;%(LoggedSignals.DO1(T-sh)-LoggedSignals.DO1(T-240-sh))/1e-7;
LoggedSignals.State[2]=0.02*LoggedSignals.F_s(T+1)-2.2;
LoggedSignals.State[3]=(LoggedSignals.A(T-sh)-1.05)/0.3;
LoggedSignals.State[4]=((T-sh)-3500)/4000;
LoggedSignals.State[5]=(LoggedSignals.S(T-sh)-LoggedSignals.S(T-60-sh))/0.3;#%(T/60)*mean( LoggedSignals.F_s(1:T))/V;
LoggedSignals.State[6]=DexState;
LoggedSignals.State[7]=((LoggedSignals.Ag(T-sh)-270)/(280-260));
LoggedSignals.SOil=SOil;
#% state shrvul
NextObs = LoggedSignals.State;
#% Reward upon time
if T>nSteps-480:
IsDone =1;#%NextObs(3)<-100.05; %abs(X) > EnvConstants.XThreshold || abs(Theta) > EnvConstants.ThetaThresholdRadians;
Reward=0;
else:
IsDone =1;#%NextObs(3)<-100.05; %abs(X) > EnvConstants.XThreshold || abs(Theta) > EnvConstants.ThetaThresholdRadians;
Reward=0;
self.state = ns
terminal = self._terminal()
reward = -1. if not terminal else 0.
return (NextObs,reward,IsDone,LoggedSignals, {})
def ustarflag(date,
data,
flags,
isday,
outdir,
min_thresh=0.1,
nboot=100,
ustar_v=2,
plot=False):
'''
Friction velocity flagging for Eddy Covariance data. Assesses the threshold
of friction velocity (ustar) below which a reduction in CO2 flux correlates
with ustar and returns a flag here. Originally coded by Tino Rau.
Definition
----------
ustarflag(date, isday, data, flags, outdir, min_thresh=0.1, nboot=100,
ustar_v=2, plot=False):
Input
-----
date np.array(N), julian date
data np.array(N,3), data array with CO2 flux (Fco2 [mumol/m2s),
friction velocity (ustar [m/s]) and air temperature (T [degC])
inflag np.array(N,3), dtype=int, quality flag of data, 0 where data is
good
isday np.array(N), dtype=bool, True where it is day and False where
it is night
outdir str, path of the output folder
Optional Input
--------------
min_thresh float, minimum ustar threshold, recommendation: 0.1 for
overstorey towers, 0.01 for understorey towers (default: 0.1)
nboot int, number of boot straps (default: 100)
ustar_v int, value which shall be returned when a value is below the
ustar threshold (default: 2)
udef int/float, missing value of data (default: -9999) NaN values are
excluded from computations anyhow.
plot bool, if True data and spikes are plotted (default: False)
Output
------
flag_out np.array(N), flag array where everything is 0 except where
values fall below ustar threshold, there it is ustar_v
Restrictions
------------
- works ONLY for a data set of ONE FULL year
- works ONLY for half hourly time steps
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany.
Copyright (c) 2014 Arndt Piayda
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written, AP, Aug 2014
'''
############################################################################
# fixed parameters
nperiods = 4 # numer of seasons per year
ntclass = 6 # number of temperature classes
corrthresh = 0.3 # correlation coefficient
nuclass = 20 # number of u* classes
upercent = 95. # percentage for average comparison
udef = -9999 # undef of output
############################################################################
# data and flags
Fco2 = data[:, 0]
ustar = data[:, 1]
T = data[:, 2]
flag_Fco2 = flags[:, 0]
flag_ustar = flags[:, 1]
flag_T = flags[:, 2]
years, months, days, hours, mins, sc = dec2date(date, fulldate=True)
nmons = 12 / nperiods
yrmin = np.min(years)
yrmax = np.max(years)
nyears = yrmax - yrmin ######## + 1 works only for one full year of data
if (nyears > 1) | (np.unique(months).size < 12):
raise ValueError(
'ustarflag: only one full year of data can be processed')
flag = (flag_Fco2 == 0) & (~isday) & (flag_T == 0) & (flag_ustar == 0)
############################################################################
# prepare bootstrapping
threshs = np.zeros((nboot, nyears))
seasonal_threshs = np.zeros((nperiods * nboot, nyears))
############################################################################
# calculate thresholds
for y in xrange(yrmin,
yrmax): ######## + 1 works only for one full year of data
#print 'Year ', y
periods = np.unique(months[np.where(years == y)])[0:-1:nmons]
nperiods = len(np.unique(months[np.where(years == y)])) / nmons
out_threshs = np.array([])
nstepsyear = len(np.where(years == y)[0])
#print nstepsyear
########################################################################
# start bootstrapping
for r in xrange(nboot):
range_min = np.min(np.where(years == y)[0])
range_max = np.max(np.where(years == y)[0])
rand = np.random.randint(0, nstepsyear, size=nstepsyear)
T_b = T[range_min + rand]
flag_b = flag[range_min + rand]
years_b = years[range_min + rand]
months_b = months[range_min + rand]
ustar_b = ustar[range_min + rand]
Fco2_b = Fco2[range_min + rand]
# flag the created bootstrap-arrays
T_f = np.extract(flag_b, T_b)
months_f = np.extract(flag_b, months_b)
years_f = np.extract(flag_b, years_b)
ustar_f = np.extract(flag_b, ustar_b)
Fco2_f = np.extract(flag_b, Fco2_b)
# container for thresholds of the seasons of a year
period_threshs = np.array([])
####################################################################
# loop over seasons
for m in periods:
period_flag = (months_f >= m) & (months_f < m + nmons)
# flag data --> just night_time and unflagged data is left
T_m = np.ma.array(T_f, mask=~period_flag, fill_value=udef)
ustar_m = np.ma.array(ustar_f,
mask=~period_flag,
fill_value=udef)
Fco2_m = np.ma.array(Fco2_f,
mask=~period_flag,
fill_value=udef)
# sort the array according to the temperature
ii = np.ma.argsort(T_m)
T_m = T_m[ii]
ustar_m = ustar_m[ii]
Fco2_m = Fco2_m[ii]
# separate into 6 temperature classes with
# equal size according to quantiles
class_width = np.ma.count(T_m) / ntclass
ntlen = T_m.size
# container for the thresholds of this period
class_threshs = np.array([])
################################################################
# loop for every temperature class
for i in xrange(ntclass):
T_temp = T_m[i *
class_width:np.min([(i + 1) *
class_width, ntlen - 1])]
u_temp = ustar_m[i *
class_width:np.min([(i + 1) *
class_width, ntlen -
1])]
Fco2_temp = Fco2_m[i *
class_width:np.min([(i + 1) *
class_width, ntlen -
1])]
# calculate r
#try: #AP
r_abs = np.abs(np.corrcoef(T_temp, u_temp)[0, 1])
#except IndexError: #AP
# print 'IndexError'#AP
# r_abs = 1 #AP
# neglect threshold, if correlation is strong
# online gap tool uses 0.3 as r-threshold,
# original papale paper: 0.4
if r_abs >= corrthresh:
continue
# sort the data of the temperature class according
# to ustar
ii = np.ma.argsort(u_temp)
T_temp = T_temp[ii]
u_temp = u_temp[ii]
Fco2_temp = Fco2_temp[ii]
# set the class width of the ustar classes; class
# with equal size??
u_class_width = np.ma.count(T_temp) / nuclass
nulen = T_temp.size
############################################################
# loop over all ustar classses-1
# threshold = if class average > 99% of average of
# all classes above
# loop over all ustar classes
for u in xrange(nuclass - 1):
T_u = T_temp[u * u_class_width:np.min([(
u + 1) * u_class_width, nulen - 1])]
u_u = u_temp[u * u_class_width:np.min([(
u + 1) * u_class_width, nulen - 1])]
Fco2_u = Fco2_temp[u * u_class_width:np.min([(
u + 1) * u_class_width, nulen - 1])]
rest_Fco2 = Fco2_temp[np.min([(u + 1) *
u_class_width, nulen -
1]):]
rest_avg = np.ma.mean(rest_Fco2)
avg = np.ma.mean(Fco2_u)
if np.abs(avg) >= np.abs(upercent / 100. * rest_avg):
class_threshs = np.append(class_threshs,
np.ma.mean(u_u))
break
# median of thresholds of all temperature classes is
# set as the threshold of the period
if ~np.isnan(np.ma.median(class_threshs)):
#print r
period_threshs = np.append(period_threshs,
np.ma.median(class_threshs))
else:
#print 'All are nans',class_threshs
period_threshs = np.append(period_threshs, udef)
# threshholds of all periods
out_threshs = np.append(out_threshs, period_threshs)
# if there are values in period_thresholds take the maximum,
# else take 90th percentil
if period_threshs == []:
threshs[r, y - yrmin] = np.sort(ustar_f)[np.len(ustar_f) * 9. /
10.]
else:
threshs[r, y - yrmin] = np.max(period_threshs)
seasonal_threshs[0:nperiods * nboot, y - yrmin] = out_threshs
############################################################################
# set the flags
# assign calculated threshold:
# for each year separately,
# for night and day-time data
# take the median of the nboot bootstrapped thresholds for each year
# "out_threshs" used for export and later plotting
flag_out = np.zeros_like(flag_Fco2, dtype=np.int)
for y in range(yrmin,
yrmax): ######## + 1 works only for one full year data
if np.any(threshs[:, y - yrmin] > 10):
print('Hu', y, threshs[:, y - yrmin])
med = np.median(threshs[:, y - yrmin])
if (med < min_thresh):
med = min_thresh
elif np.isnan(med):
print('NaN-WARNING!')
ii = np.argsort(ustar[years == y])
oo = np.where(flag_Fco2[ii] == 0)[0]
flag_out[years==y][ii[oo][::np.int(len(oo)*0.9)]]\
+= ustar_v
else:
ii = (years == y).flatten()
yy = np.where((ustar[ii] < med) & (flag_Fco2[ii] == 0))
uu = np.clip(np.unique(np.concatenate((yy[0], yy[0] + 1))), 0,
len(flag_Fco2[(years == y).flatten()]) - 1)
flag_out[np.where(years == y)[0][uu]] += ustar_v
#print 'Year: %i, u_star thresh: %5.3f'%(y, med)
####################################################################
# plot
if plot:
import matplotlib.pyplot as plt
import matplotlib.backends.backend_pdf as pdf
fig1 = plt.figure(1)
sub1 = fig1.add_subplot(111)
sub1.plot(ustar[np.where(flag & (years==y).flatten())],\
Fco2[np.where(flag & (years==y).flatten())], 'bo')
sub1.axvline(x=med, linewidth=0.75, color='r')
plt.ylabel('F CO2')
plt.xlabel('u_star')
plt.title('u_star thresh: %5.3f' % med)
plt.show()
pp1 = pdf.PdfPages(outdir + '/ustar.pdf')
fig1.savefig(pp1, format='pdf')
pp1.close()
############################################################################
# save output
np.savetxt('%s/u_star_thresh.csv' % outdir,
threshs,
fmt='%4.4f',
delimiter=',')
np.savetxt('%s/u_star_thresh_seasonal.csv' % outdir,
seasonal_threshs,
fmt='%4.4f',
delimiter=',')
return flag_out
import numpy as np
import matplotlib.pylab as plt
from scipy.optimize import leastsq
for i in range(6):
file="/Users/anita/Desktop/new_data_1/500ms_SUN_0000"+str(i)+".txt"
pixel=np.loadtxt(file,usecols=(0,))
intensity=np.loadtxt(file,usecols=(1,))
for j in range(6):
mean=np.sum(pixel)/np.len(pixel)
print mean
ax.plot(trpp_down['x'], trpp_down['y'], 'r')
ax.plot([-1, -1], [max(copss_lost), max(cntrpss_lost)], 'k--')
ax.set_title(r'E={:.2f} keV'.format(Ekev))
ax.set_xlabel(r'P$_\phi$/$\psi_w$')
ax.set_ylabel(r'$\mu\frac{B_0}{E}$')
ax.set_ylim([0, 1.5])
ax.set_xlim([-2, 1.])
ax.grid('on')
## filling bewteen lines
ax.fill_between(boundaries['min']['tr_up']['x'], boundaries['min']['tr_up']['y'],\
boundaries['max']['tr_up']['y'], color='r', alpha=0.6)
ax.fill_between(boundaries['min']['x'], boundaries['min']['cntr'],\
boundaries['max']['cntr'], color='k', alpha=0.6)
f.tight_layout()
ax.set_xlim([-1.2, 0.])
ax.set_ylim([1., 1.5])
f.savefig('boundaries_ripple_{:s}_E{:.2f}.png'.format(run, Ekev),
dpi=800)
return b, B0, R0, boundaries
if np.len(sys.argv) == 4:
fname_a5 = sys.argv[1]
run = sys.argv[2]
Ekev = float(sys.argv[3])
main(fname_a5, run, Ekev, 0, 1)
else:
print('not enough input')
import numpy as np
import matplotlib.pylab as plt
time=np.arange(0,60,0.05)
nt=np.len(time)
theta=np.zeros(nt)
v=np.zeros(nt)
theta[0]=1.0
v[0]=1.0
while i < nt-1:
#theta vs time plot
plt.plot(time,theta)
#energy vs time plot
plt.plot(time,energy)
plt.title('')
plt.xlabel('')
plt.ylabel('')
plt.show()
def record_data(network, data_array) :
"""take single iteration snapshot of the rate of communication"""
for n in network.nodes() :
data_array[n] = np.len(network.node[n]['information shared with'])
