def register_variable(self,varname,units):
if varname == 'b_x':
interpolator=self.bx
if varname == 'b_y':
interpolator=self.by
if varname == 'b_z':
interpolator=self.bz
if varname == 'bvec':
interpolator=self.b
if varname == 'PF':
interpolator=self.pressure_function
self.variables[varname]['interpolator']= interpolator
def interpolate(xvec):
return self.variables[varname]['interpolator'](xvec)
interpolate.__doc__ = "A function that returns {} in [{}].".format(varname,units)
self[varname] = kamodofy(interpolate,
units = units,
citation = self.citation,
data = None)
self[varname + '_ijk'] = kamodofy(gridify(self[varname],
x_i = self.x,
y_j = self.y,
z_k = self.z),
units = units,
citation = self.citation,
data = None)
def test_eval_no_defaults():
kamodo = Kamodo(f='x', verbose=True)
kamodo['g'] = lambda x=3: x
kamodo['h'] = kamodofy(lambda x=[2,3,4]: (kamodofy(lambda x_=np.array([1]): x_**2) for x_ in x))
assert kamodo.evaluate('f', x=3)['x'] == 3
assert kamodo.evaluate('g')['x'] == 3
assert kamodo.evaluate('h')['x_'][-2] == 1.
def test_frequency_composition():
@kamodofy(units='rad/s', arg_units={'B':'T', 'n_e':'1/m**3'})
def omega_uh1(B, n_e):
return np.sqrt(B**2+n_e**2)
kamodo_test = Kamodo(verbose=True)
kamodo_test['B_mag'] = kamodofy(lambda B=np.linspace(0.1,1.,10): B, units='nT', arg_units={'B':'nT'})
kamodo_test['n_e'] = kamodofy(lambda n=np.linspace(4.,13.,10)*10**19:n, units='1/m**3', arg_units={'n':'1/m**3'})
kamodo_test['omega_uh1'] = omega_uh1
print(kamodo_test.unit_registry)
#---------(input)--------
kamodo_test['omega_uh1A'] = 'omega_uh1(B_mag, n_e)'
kamodo_test.omega_uh1A
def test_to_latex():
warnings.simplefilter('error')
kamodo = Kamodo(f='x**2', verbose=True)
assert str(kamodo.to_latex()
) == r'\begin{equation}f{\left(x \right)} = x^{2}\end{equation}'
kamodo = Kamodo(g='x', verbose=True)
assert str(kamodo.to_latex()
) == r'\begin{equation}g{\left(x \right)} = x\end{equation}'
kamodo['f(x[cm])[kg]'] = 'x**2'
kamodo['g'] = kamodofy(lambda x: x**2,
units='kg',
arg_units=dict(x='cm'),
equation='$x^2$')
kamodo['h'] = kamodofy(lambda x: x**2, units='kg', arg_units=dict(x='cm'))
kamodo.to_latex()
def test_to_latex():
warnings.simplefilter('error')
kamodo = Kamodo(f='x**2', verbose=True)
assert str(kamodo.to_latex(mode='inline')) == r'$f{\left(x \right)} = x^{2}$'
kamodo = Kamodo(g='x', verbose=True)
assert str(kamodo.to_latex(mode='inline')) == r'$g{\left(x \right)} = x$'
kamodo['f(x[cm])[kg]'] = 'x**2'
kamodo['g'] = kamodofy(lambda x: x**2, units='kg', arg_units=dict(x='cm'), equation='$x^2$')
kamodo['h'] = kamodofy(lambda x: x**2, units='kg', arg_units=dict(x='cm'))
@kamodofy(units = 'kg/m^3', citation = 'Bob et. al, 2018')
def rho(x = np.array([3,4,5]), y = np.array([1,2,3])):
"""A function that computes density"""
return x+y
kamodo['rho'] = rho
kamodo.to_latex()
def make_interpolators(self):
for variable, metadata in self._metadata['variables'].items():
coords = self.get_coords()
if 'r1' in coords:
cname = 'rvec_1'
else:
cname = coords[0] + 'vec'
units = metadata['units']
exec_str = """def interpolate({cname}):
points = {cname}
if type(points) == np.ndarray:
points = points.tolist()
package = dict(
variable = '{varname}',
points = points)
self._ch.send(package)
results = self._ch.receive()
if type({cname}) == np.ndarray:
return np.array(results)
else:
return results
""".format(varname=variable, cname=cname)
d = {'self': self, 'np': np}
exec(exec_str, d)
interp_func = d['interpolate']
self[variable] = kamodofy(interp_func, units=units)
def test_unit_composition_registration():
server = Kamodo(**{'M': kamodofy(lambda r=3: r, units='kg'),
'V[m^3]': (lambda r: r**3)}, verbose=True)
user = Kamodo(mass=server.M, vol=server.V,
**{'rho(r)[g/cm^3]':'mass/vol'}, verbose=True)
result = (3/3**3)*(1000)*(1/10**6)
assert np.isclose(user.rho(3), result)
def test_compose():
k1 = Kamodo(f='x')
k2 = Kamodo(g='y**2', h = kamodofy(lambda x: x**3))
k3 = compose(m1=k1, m2=k2)
assert k3.f_m1(3) == 3
assert k3.g_m2(3) == 3**2
assert k3.h_m2(3) == 3**3
k3['h(f_m1)'] = 'f_m1'
assert k3.h(3) == 3
def register_variable(self, varname, units):
interpolator = self.get_grid_interpolator(varname)
# store the interpolator
self.variables[varname]['interpolator'] = interpolator
def interpolate(xvec):
return self.variables[varname]['interpolator'](xvec)
# update docstring for this variable
interpolate.__doc__ = "A function that returns {} in [{}].".format(
varname, units)
self[varname] = kamodofy(
interpolate,
units=units,
citation="Pembroke et al 2019, Rastaetter 2020",
data=None)
self[varname + '_ij'] = kamodofy(
gridify(self[varname], x_i=self.x, y_j=self.y),
units=units,
citation="Pembroke et al 2019, Rastaetter 2020",
data=self.variables[varname]['data'])
return
def register_variables(self):
"""register variables as kamodo functions"""
for varname in self._instrument.data.columns:
units = self._instrument.meta[varname].units
if type(units) is not str:
units = ''
docstring = time_interpolator_docstring.format(varname=varname,
units=units)
interpolator = get_interpolator(
time_interpolator, varname, self._instrument.data[varname],
self._instrument.data.index[::self._default_stride], docstring)
self[varname] = kamodofy(interpolator,
units=units,
citation=self._citation)
def register_variable(self, varname, units):
"""register variables into Kamodo for this service, CCMC ROR satellite extractions"""
def interpolate(timestamp):
data = self.variables[varname]['data']
return np.interp(timestamp,self.tsarray,data)
# store the interpolator
self.variables[varname]['interpolator'] = interpolate
# update docstring for this variable
interpolate.__doc__ = "A function that returns {} in [{}].".format(varname,units)
self[varname] = kamodofy(interpolate,
units = units,
citation = "De Zeeuw 2020",
data = None)
def register_variables(self):
for variable_name, df in self.data.items():
dependencies = []
for i in ['TIME'] + list('01234'):
dependency_name = self.meta[variable_name].get(
'DEPEND_{}'.format(i))
if dependency_name is not None:
dependencies.append(dependency_name)
if len(dependencies) == 0:
print('not registering {}: no dependencies'.format(
variable_name))
continue
if not hasattr(df, 'index'):
print('{} has no index, skipping..'.format(variable_name))
continue
regname = self._regnames.get(variable_name, variable_name)
docstring = self.meta[variable_name]['CATDESC']
units = self.meta[variable_name]['UNITS']
citation = self._citation
if isinstance(df.index, pd.MultiIndex):
indices = df.index.levels
data_shape = [len(i) for i in indices]
grid_interpolator = RegularGridInterpolator(
indices, df.values.reshape(data_shape), bounds_error=False)
grid_interpolator.__name__ = variable_name
grid_args = {d: self.get_dependency(d) for d in dependencies}
interpolator = gridify(grid_interpolator, **grid_args)
# catch time dependencies such as Epoch_state and Epoch
elif (len(dependencies) == 1) & ('epoch'
in dependencies[0].lower()):
interpolator = get_interpolator(time_interpolator, regname, df,
df.index, docstring)
else:
print('can not register {}'.format(variable_name))
continue
self[regname] = kamodofy(interpolator,
units=units,
citation=citation)
def register_variable(self, varname, units):
interpolator = self.get_grid_interpolator(varname)
# var_data=pd.DataFrame(data=self.variables[varname]['data'],index=self.seconds_from_20000101(self.Time))
# interpolator=self.time_interpolation(var_data)
# store the interpolator
self.variables[varname]['interpolator'] = interpolator
def interpolate(t):
return self.variables[varname]['interpolator'](t)
# update docstring for this variable
interpolate.__doc__ = "A function that returns {} in [{}].".format(varname,units)
self[varname] = kamodofy(interpolate,
units = units,
citation = "Pembroke et al 2019, Rastaetter 2020 SSCWeb in Kamodo",
data = None)
def register_variable(self, varname, units):
"""register variables into Kamodo for this model, SWMF-GM"""
interpolator = self.get_grid_interpolator(varname)
# store the interpolator
self.variables[varname]['interpolator'] = interpolator
def interpolate(xvec):
# Reduce size of read data block to speed up the interpolation
tmpgrid2 = self.grid[
(self.grid[:, 0] > (np.amin(xvec[:, 0]) - self.tol))
& (self.grid[:, 0] < (np.amax(xvec[:, 0]) + self.tol)) &
(self.grid[:, 1] > (np.amin(xvec[:, 1]) - self.tol)) &
(self.grid[:, 1] < (np.amax(xvec[:, 1]) + self.tol)) &
(self.grid[:, 2] > (np.amin(xvec[:, 2]) - self.tol)) &
(self.grid[:, 2] < (np.amax(xvec[:, 2]) + self.tol))]
data = self.variables[varname]['data']
tmpdata = data[(self.grid[:, 0] > (np.amin(xvec[:, 0]) - self.tol))
& (self.grid[:, 0] <
(np.amax(xvec[:, 0]) + self.tol)) &
(self.grid[:, 1] > (np.amin(xvec[:, 1]) - self.tol))
& (self.grid[:, 1] <
(np.amax(xvec[:, 1]) + self.tol)) &
(self.grid[:, 2] > (np.amin(xvec[:, 2]) - self.tol))
& (self.grid[:, 2] <
(np.amax(xvec[:, 2]) + self.tol))]
# Precompute weights for interpolation to optimize
tmpvtx, tmpwts = self.GMcompute_weights(tmpgrid2, xvec)
return self.GMinterpolate(tmpdata, tmpvtx, tmpwts)
# update docstring for this variable
interpolate.__doc__ = "A function that returns {} in [{}].".format(
varname, units)
self[varname] = kamodofy(interpolate,
units=units,
citation="De Zeeuw 2020",
data=None)
def register_field(self, varname, doc, **kwargs):
'''registers fields'''
columns = kwargs.get('columns', None)
def f(t=self.t):
result = self.interpolators[varname](t).T
try:
return pd.DataFrame(result, index=t, columns=columns)
except:
return result
f.__doc__ = doc.format(**kwargs)
f.__name__ = varname
equation = kwargs.get('equation', None)
if equation is not None:
equation = equation.format(**kwargs)
self[varname] = kamodofy(f,
citation=self.citation,
units=kwargs.get('units', ''),
equation=equation)
