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)