def read_datalines(self, NSTEPS=0, start_step=-1, select_ckeys=None, max_vector_dim=None, even_NSTEPS=True): """Read NSTEPS steps of file, starting from start_step, and store only the selected ckeys. INPUT: NSTEPS -> number of steps to read (default: 0 -> reads all the file) start_step = -1 -> continue from current step (default) 0 -> go to start step N -> go to N-th step select_ckeys -> an array with the column keys you want to read (see all_ckeys for a list) max_vector_dim -> when reading vectors read only this number of components (None = read all components) even_NSTEPS -> round the number of steps to an even number (default: True) OUTPUT: data -> a dictionary with the selected-column steps """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() if (NSTEPS == 0): NSTEPS = self.MAX_NSTEPS self._set_ckey(select_ckeys, max_vector_dim) # set the ckeys to read self._initialize_dic(NSTEPS) # allocate dictionary self.gotostep(start_step) # jump to the starting step # read NSTEPS of the file progbar_step = max(100000, int(0.005*NSTEPS)) for step in range(NSTEPS): line = self.file.readline() if len(line) == 0: # EOF print "Warning: reached EOF." break values = np.array(line.split()) for key, idx in self.ckey.iteritems(): # save the selected columns self.data[key][step,:] = np.array(map(float, values[idx])) if ( (step+1)%progbar_step == 0 ): if self._GUI: progbar.value = float(step+1)/NSTEPS*100.; progbar.description = "{:6.2f}%".format(progbar.value) else: print " step = {:9d} - {:6.2f}% completed".format(step+1, float(step+1)/NSTEPS*100.) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < self.NSTEPS): if (step == 0): print "WARNING: no step read." return else: print "Warning: less steps read." self.NSTEPS = step + 1 if even_NSTEPS: if (NSTEPS%2 == 1): NSTEPS = NSTEPS - 1 for key, idx in self.ckey.iteritems(): # free memory not used self.data[key] = self.data[key][:NSTEPS,:] print " ( %d ) steps read." % (NSTEPS) self.NSTEPS = NSTEPS print "DONE. Elapsed time: ", time()-start_time, "seconds" return self.data
def get_gaussian_labels_probabilities(digits, hidden_markov_models, n_observation_classes, n_hidden_states, n_iter, tol, display_progress, use_pickle, filename): labels_probabilities = [] directory = settings.LABELS_PROBABILITIES_DIRECTORY + "centroids_" + str(n_observation_classes - 3) directory += "/hidden_states_" + str(n_hidden_states) + "/n_iter_" + str(n_iter) + "/tol_" + str(tol) path = directory + "/" + filename if use_pickle and os.path.isfile(path): labels_probabilities = pickle.load(open(path, 'rb')) else: f = FloatProgress(min=0, max=100) if display_progress: display(f) i = 0 for dig in digits: probabilites = get_gaussian_label_probabilites(dig, hidden_markov_models) labels_probabilities.append(probabilites) f.value = (float(i) * 100.0) / float(len(digits)) i += 1 f.close() if use_pickle: if not os.path.exists(directory): os.makedirs(directory) with open(path,'wb') as f: pickle.dump(labels_probabilities,f) return labels_probabilities
def plot_digit_samples(samples, display_progress = False): f = FloatProgress(min=0, max=100) if display_progress: display(f) plt.clf(); _, axarr = plt.subplots(2, 5); for i in range(0, 2): for j in range(0, 5): n = 5*i + j n -= 1 if n < 0: n = 9 x_points = [] y_points = [] for curve in samples[n][0].curves: for point in curve: x_points.append(point[0]) y_points.append(point[1]) axarr[i, j].plot(x_points, y_points, linewidth = 2.0) #axarr[i, j].axis([settings.IMAGE_PLOT_X_MIN, settings.IMAGE_PLOT_X_MAX, settings.IMAGE_PLOT_Y_MIN, settings.IMAGE_PLOT_Y_MAX]); f.value += 10 f.close() plt.show();
class IPyBackend(ProgressBar): def __init__(self, iterable=None, length=None, *, label=None, show_eta=True, show_percent=None, show_pos=False, item_show_func=None, info_sep=' '): from traitlets import TraitError try: from ipywidgets import FloatProgress except ImportError: from IPython.html.widgets.widget_float import FloatProgress try: self.backend = FloatProgress(value=0, min=0, step=1) # max and description are set via properties except TraitError: raise RuntimeError('IPython notebook needs to be running') super().__init__(iterable, length, label=label, show_eta=show_eta, show_percent=show_percent, show_pos=show_pos, item_show_func=item_show_func, info_sep=info_sep) self.is_hidden = False def __enter__(self): from IPython.display import display display(self.backend) return super().__enter__() def render_finish(self): self.backend.close() def render_progress(self): info_bits = [] if self.show_pos: info_bits.append(self.format_pos()) if self.show_percent or (self.show_percent is None and not self.show_pos): info_bits.append(self.format_pct()) if self.show_eta and self.eta_known and not self.finished: info_bits.append(self.format_eta()) if self.item_show_func is not None: item_info = self.item_show_func(self.current_item) if item_info is not None: info_bits.append(item_info) self.backend.description = '{} {}'.format( self.label or '', self.info_sep.join(info_bits)) self.backend.max = self.length self.backend.value = self.pos
def plot_digit(digit, display_progress = False): fig=plt.figure() ax=fig.add_subplot(111) f = FloatProgress(min=0, max=100) if display_progress: display(f) n_points = 0 for curve in digit.curves: n_points += len(curve) i = 0 for curve in digit.curves: x_points = [] y_points = [] for point in curve: x_points.append(point[0]) y_points.append(point[1]) f.value = 100.0*(float(i) / float(n_points)) i += 1 plt.plot(x_points, y_points, linewidth = 2.0) f.close() plt.axis([settings.IMAGE_PLOT_X_MIN, settings.IMAGE_PLOT_X_MAX, settings.IMAGE_PLOT_Y_MIN, settings.IMAGE_PLOT_Y_MAX]) plt.show()
def _compute_current_density(bvs, gvx, gvy, gvz, cmatr, cmati, occvec, verbose=True): """Compute the current density in each cartesian direction.""" nbas, npts = bvs.shape curx = np.zeros(npts, dtype=np.float64) cury = np.zeros(npts, dtype=np.float64) curz = np.zeros(npts, dtype=np.float64) cval = np.zeros(nbas, dtype=np.float64) if verbose: fp = FloatProgress(description='Computing:') display(fp) for mu in range(nbas): if verbose: fp.value = mu / nbas * 100 crmu = cmatr[mu] cimu = cmati[mu] bvmu = bvs[mu] gvxmu = gvx[mu] gvymu = gvy[mu] gvzmu = gvz[mu] for nu in range(nbas): crnu = cmatr[nu] cinu = cmati[nu] bvnu = bvs[nu] gvxnu = gvx[nu] gvynu = gvy[nu] gvznu = gvz[nu] cval = evaluate('-0.5 * (occvec * (crmu * cinu - cimu * crnu))', out=cval) csum = cval.sum() evaluate('curx + csum * (bvmu * gvxnu - gvxmu * bvnu)', out=curx) evaluate('cury + csum * (bvmu * gvynu - gvymu * bvnu)', out=cury) evaluate('curz + csum * (bvmu * gvznu - gvzmu * bvnu)', out=curz) if verbose: fp.close() return curx, cury, curz
def butter_filter(self, lowcut, highcut=0, order=2, fs=20000.): nyq = 0.5 * fs if highcut != 0: low = lowcut / nyq high = highcut / nyq b, a = butter(order, [low, high], btype='band', analog=False) else: low = lowcut / nyq b, a = butter(order, low, btype='high', analog=False) if isinstance(self.metadata, list): progr = FloatProgress(min=0, max=len(self.metadata), description='Filtering...', bar_style='success') display(progr) cut_data_butter = [None] * len(self.raw_data) for i, k in enumerate(self.raw_data): cut_data_butter[i] = np.empty(k.shape) for j, z in enumerate(self.raw_data[i]): cut_data_butter[i][j] = filtfilt(b, a, z) progr.value += 1 self.butter_data = cut_data_butter progr.close() if isinstance(self.metadata, dict): cut_data_butter = [None] * len(self.raw_data) for i, k in enumerate(self.raw_data): cut_data_butter[i] = filtfilt(b, a, k) self.butter_data = np.asarray(cut_data_butter)
def plot_digits_heatmap(digits, display_progress = False): f = FloatProgress(min=0, max=100) if display_progress: display(f) plt.clf(); _, axarr = plt.subplots(2, 5); for i in range(0, 2): for j in range(0, 5): n = 5*i + j x_points = [] y_points = [] for digit in digits: if digit.label == n: for curve in digit.curves: for point in curve: x_points.append(point[0]) y_points.append(point[1]) heatmap, xedges, yedges = np.histogram2d(x_points, y_points, bins=50); extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]; axarr[i, j].imshow(np.rot90(heatmap), extent=extent); axarr[i, j].axis([settings.IMAGE_PLOT_X_MIN, settings.IMAGE_PLOT_X_MAX, settings.IMAGE_PLOT_Y_MIN, settings.IMAGE_PLOT_Y_MAX]); f.value += 10 f.close() plt.show();
def cepstral_analysis(self, aic_type='aic', Kmin_corrfactor=1.0, bayes_p=False, density_grid=None): """Perform the Cepstral Analysis on all blocks.""" if self.GUI: progbar = FloatProgress(min=0, max=100) progbar.description = "0 %" display(progbar) self.BLOCK_NFREQS = self.BLOCK_SIZE / 2 + 1 if self.MULTI_COMPONENT: print ' N_COMPONENTS = {:10d}'.format(self.N_COMPONENTS) self.ck_THEORY_var, self.psd_THEORY_mean = multicomp_cepstral_parameters( self.BLOCK_NFREQS, self.N_COMPONENTS) self.bayes_p = bayes_p if (self.N_BLOCKS == 1): raise NotImplemented('One block.') for L in range(self.N_BLOCKS): if self.MULTI_COMPONENT: self.block[L].compute_psd(DT=self.TSKIP, DT_FS=self.DT_FS, average_components=True) self.block[L].dct = ta.CosFilter(self.block[L].logpsd, \ ck_theory_var=self.ck_THEORY_var, psd_theory_mean=self.psd_THEORY_mean, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor, normalization=self.BLOCK_SIZE) else: self.block[L].compute_psd(DT=self.TSKIP, DT_FS=self.DT_FS) self.block[L].dct = ta.CosFilter( self.block[L].logpsd, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor, normalization=self.BLOCK_SIZE) # theory_var=None self.block[L].dct.scan_filter_tau() if self.bayes_p: self.block[L].dct.compute_p_aic(method='ba') if density_grid is not None: self.density_grid = density_grid self.block[L].dct.compute_logtau_density( method='ba', only_stats=False, density_grid=density_grid) else: self.block[L].dct.compute_logtau_density(method='ba', only_stats=True) if self.GUI: progbar.value = float(L + 1) / self.N_BLOCKS * 100. progbar.description = "%5.2f %%" % progbar.value if self.GUI: progbar.close() self.freqs = self.block[0].freqs return
def radial_pcf_out_of_core(hdftwo, hdfout, u, pairs, **kwargs): """ Out of core radial pair correlation calculation. Atomic two body data is expected to have been computed (see :func:`~exatomic.core.two.compute_atom_two_out_of_core`) An example is given below. Note the importance of the definition of pairs and the presence of additional arguments. .. code:: Python radial_pcf_out_of_core("in.hdf", "out.hdf", uni, {"O_H": ([0], "H")}, length="Angstrom", dr=0.01) Args: hdftwo (str): HDF filepath containing atomic two body data hdfout (str): HDF filepath to which radial PCF data will be written (see Note) u (:class:`~exatomic.core.universe.Universe`): Universe pairs (dict): Dictionary of string name keys, values of ``a``, ``b`` arguments (see Note) kwargs: Additional keyword arguments to be passed (see Note) Note: Results will be stored in the hdfout HDF file. Keys are of the form ``radial_pcf_key``. The keys of ``pairs`` are used to store the output while the values are used to perform the pair correlation itself. """ f = u.atom['frame'].unique() n = len(f) fp = FloatProgress(description="Computing:") display(fp) fdx = f[0] twokey = "frame_" + str(fdx) + "/atom_two" atom = u.atom[u.atom['frame'] == fdx].copy() uu = Universe(atom=atom, frame=u.frame.loc[[fdx]], atom_two=pd.read_hdf(hdftwo, twokey)) pcfs = {} for key, ab in pairs.items(): pcfs[key] = radial_pair_correlation(uu, ab[0], ab[1], **kwargs).reset_index() fp.value = 1 / n * 100 for i, fdx in enumerate(f[1:]): twokey = "frame_" + str(fdx) + "/atom_two" atom = u.atom[u.atom['frame'] == fdx].copy() uu = Universe(atom=atom, frame=u.frame.loc[[fdx]], atom_two=pd.read_hdf(hdftwo, twokey)) for key, ab in pairs.items(): pcfs[key] += radial_pair_correlation(uu, ab[0], ab[1], **kwargs).reset_index() fp.value = (i + 1) / n * 100 store = pd.HDFStore(hdfout) for key in pairs.keys(): pcfs[key] /= n store.put("radial_pcf_" + key, pcfs[key]) store.close() fp.close()
def read_timesteps(self, selection, start_step=-1, select_ckeys=None, fast_check=True): """ Read selected keys of file, within the provided range. Examples: read_timesteps(10, start_step=0, select_ckeys=['id,xu,yu,vu']) -->> Read first 10 timesteps, only the specified columns read_timesteps(10, select_ckeys=['id,xu,yu,vu']) -->> Read the next 10 timesteps, only the specified columns (DELTA_TIMESTEP is assumed) read_timesteps((10,30)) -->> Read from TIMESTEP 10 to 30 read_timesteps((10,30,2)) -->> Read every 2 steps from TIMESTEP 10 to 30 """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() self._set_ckey(select_ckeys) # set the ckeys to read --> ckey self._set_timesteps(selection, start_step) # set the timesteps to read --> timestep self._initialize_dic() # allocate dictionary --> data # extract the steps from the file progbar_step = max(1000, int(0.005 * self.nsteps)) atomid_col = self.all_ckeys['id'][0] for istep, step in enumerate(self.timestep): self._gototimestep(step, fast_check) # jump to the desired step, self.data[istep]['TIMESTEP'] = step for nat in range(self.NATOMS): # read data (may be unsorted) line = self.file.readline() if len(line) == 0: # EOF raise EOFError('Warning: reached EOF.') values = np.array(line.split()) for key, idx in self.ckey.items(): # save the selected columns atomid = int(values[atomid_col]) - 1 # current atom index (in LAMMPS it starts from 1) if (key == 'element'): # this should be improved self.data[istep][key][atomid, :] = np.array(list(map(str, values[idx]))) else: self.data[istep][key][atomid, :] = np.array(list(map(float, values[idx]))) if ((istep + 1) % progbar_step == 0): if self._GUI: progbar.value = float(istep + 1) / self.nsteps * 100. progbar.description = '%g %%' % progbar.value else: log.write_log(' step = {:9d} - {:6.2f}% completed'.format(istep + 1, float(istep + 1) / self.nsteps * 100.)) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (istep + 1 < self.nsteps): # (should never happen) if (istep == 0): log.write_log('WARNING: no step read.') return else: log.write_log('Warning: less steps read.') self.nsteps = istep + 1 if not self._quiet: log.write_log(' ( %d ) steps read.' % (self.nsteps)) log.write_log('DONE. Elapsed time: ', time() - start_time, 'seconds') self._compute_current_step = False # next time do not compute the current_step return self.data
def direct_read(self, path, start, stop, modified): # Generate an array with the length of the clean indices and broadcast the data directly into array. #-> The slicing is very time consuming for many datapoints (>100000) if isinstance(self.dict, File): electrode_info = np.asarray(self.dict['mapping']['channel', 'electrode']) mask = electrode_info['electrode'] != -1 clean_rel_inds = electrode_info['channel'][mask] traces = np.empty((len(clean_rel_inds), stop - start)) self.metadata['DAC'] = np.empty([stop - start]) self.dict['sig'].read_direct(traces[:, :], source_sel=np.s_[clean_rel_inds, start:stop]) self.dict['sig'].read_direct(self.metadata['DAC'][:], source_sel=np.s_[1024, start:stop]) print self.metadata['DAC'].shape self.metadata['time'] = np.arange(0, (stop - start) / 20000., 1 / 20000.) if isinstance(self.dict, list): electrode_info = [ np.asarray(i['mapping']['channel', 'electrode']) for i in self.dict ] mask = [i['electrode'] != -1 for i in electrode_info] clean_rel_inds = [ i[0]['channel'][i[1]] for i in zip(electrode_info, mask) ] traces = [ np.empty((len(i), stop - start)) for i in clean_rel_inds ] progr = FloatProgress(min=0, max=len(self.dict), description='Importing...', bar_style='success') display(progr) for i, v in enumerate(zip(traces, clean_rel_inds)): self.dict[i]['sig'].read_direct( v[0], source_sel=np.s_[v[1], start:stop]) self.metadata[i]['DAC'] = np.empty([stop - start]) self.dict[i]['sig'].read_direct( self.metadata[i]['DAC'][:], source_sel=np.s_[1024, start:stop]) self.metadata[i]['time'] = np.arange( 0, (stop - start) / 20000., 1 / 20000.) progr.value += 1 progr.close() return traces
def compute_atom_two_out_of_core(hdfname, uni, a, **kwargs): """ Perform an out of core periodic two body calculation for a simple cubic unit cell with dimension a. All data will be saved to and HDF5 file with the given filename. Key structure is per frame, i.e. ``frame_fdx/atom_two``. Args: hdfname (str): HDF file name uni (:class:`~exatomic.core.universe.Universe`): Universe a (float): Simple cubic unit cell dimension kwargs: Keyword arguments for bond computation (i.e. covalent radii) See Also: :func:`~exatomic.core.two._compute_bonds` """ store = pd.HDFStore(hdfname, mode="a") unit_atom = uni.atom[['symbol', 'x', 'y', 'z', 'frame']].copy() unit_atom['symbol'] = unit_atom['symbol'].astype(str) unit_atom['frame'] = unit_atom['frame'].astype(int) unit_atom.update(uni.unit_atom) grps = unit_atom.groupby("frame") n = len(grps) fp = FloatProgress(description="AtomTwo to HDF:") display(fp) for i, (fdx, atom) in enumerate(grps): v = pdist_ortho(atom['x'].values, atom['y'].values, atom['z'].values, a, a, a, atom.index.values, a) tdf = pd.DataFrame.from_dict({ 'frame': np.array([fdx] * len(v[0]), dtype=int), 'dx': v[0], 'dy': v[1], 'dz': v[2], 'dr': v[3], 'atom0': v[4], 'atom1': v[5], 'projection': v[6] }) _compute_bonds(uni.atom[uni.atom['frame'] == fdx], tdf, **kwargs) store.put("frame_" + str(fdx) + "/atom_two", tdf) fp.value = i / n * 100 store.close() fp.close()
def torus_dat(kp, kq, refine=300, segm=40, tR=1.6, tr=0.6): spt, spp, spq, spr, spR = sp.symbols("t p q r R", real=True) c = sp.Matrix([(spR+spr*sp.cos(2*sp.pi*spq*spt))*sp.cos(2*sp.pi*spp*spt),\ (spR+spr*sp.cos(2*sp.pi*spq*spt))*sp.sin(2*sp.pi*spp*spt),\ spr*sp.sin(2*sp.pi*spq*spt)]) dc = sp.Matrix([sp.diff(x,spt) for x in c]) # derivative ldc = sp.sqrt(sum( [ x**2 for x in dc ] )).simplify() # speed udc = dc/ldc ## 2nd order kc = sp.Matrix([sp.diff(x,spt) for x in udc]) # curvature vector ks = sp.sqrt(sum( [ x**2 for x in kc])) # curvature scalar ukc = kc/ks # unit curvature vector ## bi-normal bnc = udc.cross(ukc) # cross of unit tangent and unit curvature. ## the parametrization of the boundary of the width w tubular neighbourhood spw, spu = sp.symbols("w, u", real=True) ## width of torus knot, and meridional parameter tSurf = c + spw*sp.cos(2*sp.pi*(spu+kp*kq*spt))*ukc + spw*sp.sin(2*sp.pi*(spu+kp*kq*spt))*bnc ## (b) ufuncify from sympy.utilities.autowrap import ufuncify knotSuf = [ufuncify([spt, spp, spq, spr, spR, spw, spu], tSurf[i]) for i in range(3)] knotSnp = sp.lambdify((spt, spp, spq, spr, spR, spw, spu), tSurf, "numpy" ) kt = (np.pi*tr) / (4*kp) # knot radial thickness 2*pi*tr is circumf, and kp strands pass through so this ## should be around 2*pi*tr would be 2*kp*kt for the knot to fill the surface, i.e kt = pi*tr / 4*kp ## make bigger or smaller depending on how much empty space one wants to see. seg = kp*refine ## segments along length of pq torus knot. kp*120 gives a fairly smooth image. def surf(i,j): ## lambdify return np.array(knotSnp(float(i)/seg, kp, kq, tr, tR, kt, float(j)/segm)).ravel() fp = FloatProgress(min=0, max=100, description="Knot data"); display(fp); ## progrss indicator xyz = np.ndarray( (seg+1, segm+1, 3) ) for i,j in it.product( range(seg+1), range(segm+1) ): ## put the affine reparametrization here. xyz[i,j] = surf(i,j) fp.value = int(100*i/(seg+1)) fp.close() return(xyz)
class IPyBackend(ProgressBar): def __init__(self, iterable=None, length=None, *, label=None, show_eta=True, show_percent=None, show_pos=False, item_show_func=None, info_sep=' '): from IPython import get_ipython try: from ipywidgets import FloatProgress except ImportError: from IPython.html.widgets.widget_float import FloatProgress ipython = get_ipython() if not ipython or ipython.__class__.__name__ != 'ZMQInteractiveShell': raise RuntimeError('IPython notebook needs to be running') self.backend = FloatProgress(value=0, min=0, step=1) # max and description are set via properties super().__init__(iterable, length, label=label, show_eta=show_eta, show_percent=show_percent, show_pos=show_pos, item_show_func=item_show_func, info_sep=info_sep) self.is_hidden = False def __enter__(self): from IPython.display import display display(self.backend) return super().__enter__() def render_finish(self): self.backend.close() def render_progress(self): info_bits = [] if self.show_pos: info_bits.append(self.format_pos()) if self.show_percent or (self.show_percent is None and not self.show_pos): info_bits.append(self.format_pct()) if self.show_eta and self.eta_known and not self.finished: info_bits.append(self.format_eta()) if self.item_show_func is not None: item_info = self.item_show_func(self.current_item) if item_info is not None: info_bits.append(item_info) self.backend.description = '{} {}'.format(self.label or '', self.info_sep.join(info_bits)) self.backend.max = self.length self.backend.value = self.pos
def make_video(fname, show=True, figsize=(12,8), vmax=None, cmap='inferno', s=9, maxframes=None): with h5py.File('{0}.h5'.format(fname), 'r') as f: time = f['time'][:] n = time.shape[0] if maxframes is None or maxframes > n: stride = 1 frames = n else: stride = round(n / maxframes) frames = n // stride if vmax is None: vmax = norm(f['step-0/vel'][:],axis=1).max() bar = FloatProgress(min=0, max=n-1, description='frames: {0}'.format(n)) display(bar) def make_frame(step): coo = f['step-{0}/coo'.format(step * stride)][:] vel = f['step-{0}/vel'.format(step * stride)][:] L,H = amax(coo, axis=0) gcf().clear() dots = scatter(coo[:,0], coo[:,1], s=s, c=norm(vel,axis=1), vmax=vmax, linewidth=0, cmap=cmap) m = L * 0.01 xlim([-m, L+m]) ylim([-m, H+m]) colorbar() gca().set_aspect('equal') bar.value = step * stride bar.description = '{0}/{1}'.format(step * stride, n) return dots fig = figure(figsize=figsize); anim = animation.FuncAnimation(fig, make_frame, frames=frames, interval=30) anim.save('{0}.mp4'.format(fname), bitrate=3200, extra_args=['-vcodec', 'libx264']) close() bar.close() if show: return show_video(fname)
def plot_digit_observations(digit, centroids, n_observation_classes, display_progress = False): pen_down_label = n_observation_classes - settings.PEN_DOWN_LABEL_DELTA pen_up_label = n_observation_classes - settings.PEN_UP_LABEL_DELTA stop_label = n_observation_classes - settings.STOP_LABEL_DELTA fig=plt.figure() ax=fig.add_subplot(111) f = FloatProgress(min=0, max=100) if display_progress: display(f) curves = [] current_curve = [] for observation in digit.observations: if observation < pen_down_label: point = centroids[observation] current_curve.append(point) elif observation == pen_up_label: if len(current_curve) > 0: curves.append(current_curve) current_curve = [] n_points = 0 for curve in curves: n_points += len(curve) i = 0 for curve in curves: x_points = [] y_points = [] for point in curve: x_points.append(point[0]) y_points.append(point[1]) f.value = 100.0*(float(i) / float(n_points)) i += 1 plt.plot(x_points, y_points, linewidth = 2.0) f.close() plt.axis([settings.IMAGE_PLOT_X_MIN, settings.IMAGE_PLOT_X_MAX, settings.IMAGE_PLOT_Y_MIN, settings.IMAGE_PLOT_Y_MAX]) plt.show()
def cepstral_analysis_kappa(self,other, aic_type='aic', Kmin_corrfactor=1.0, bayes_p=False, density_grid=None): #need also "other", a class with the charge current! """Perform the Cepstral Analysis on all blocks.""" if self.GUI: progbar = FloatProgress(min=0, max=100) progbar.description = "0 %" display(progbar) self.BLOCK_NFREQS = self.BLOCK_SIZE/2 + 1 if self.MULTI_COMPONENT: print ' N_COMPONENTS = {:10d}'.format(self.N_COMPONENTS) self.ck_THEORY_var, self.psd_THEORY_mean = tc.md.cepstral.multicomp_cepstral_parameters(self.BLOCK_NFREQS, self.N_COMPONENTS-1) #different number of degrees of freedom! self.bayes_p = bayes_p if (self.N_BLOCKS == 1): raise NotImplementedError('One block.') for L in range(self.N_BLOCKS): if self.MULTI_COMPONENT: self.block[L].compute_kappa(other=other.block[L],DT=self.TSKIP, DT_FS=self.DT_FS, average_components=True) #different method call! self.block[L].dct = tc.md.CosFilter(self.block[L].logpsd, \ ck_theory_var=self.ck_THEORY_var, psd_theory_mean=self.psd_THEORY_mean, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor)#, normalization=self.BLOCK_SIZE) #removed (personal comunication with Loris) else: self.block[L].compute_kappa(other=other.block[L],DT=self.TSKIP, DT_FS=self.DT_FS) #different method call! self.block[L].dct = tc.md.CosFilter(self.block[L].logpsd, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor)#, normalization=self.BLOCK_SIZE) # theory_var=None self.block[L].dct.scan_filter_tau() if self.bayes_p: self.block[L].dct.compute_p_aic(method='ba') if density_grid is not None: self.density_grid = density_grid self.block[L].dct.compute_logtau_density(method='ba', only_stats=False, density_grid=density_grid) else: self.block[L].dct.compute_logtau_density(method='ba', only_stats=True) if self.GUI: progbar.value = float(L+1)/self.N_BLOCKS*100.; progbar.description = "%5.2f %%" % progbar.value if self.GUI: progbar.close() self.freqs = self.block[0].freqs return
def _compute_current_density(bvs, gvx, gvy, gvz, cmatr, cmati, occvec, verbose=True): """Compute the current density in each cartesian direction.""" nbas, npts = bvs.shape curx = np.zeros(npts, dtype=np.float64) cury = np.zeros(npts, dtype=np.float64) curz = np.zeros(npts, dtype=np.float64) cval = np.zeros(nbas, dtype=np.float64) if verbose: fp = FloatProgress(description='Computing:') display(fp) for mu in range(nbas): if verbose: fp.value = mu / nbas * 100 crmu = cmatr[mu] cimu = cmati[mu] bvmu = bvs[mu] gvxmu = gvx[mu] gvymu = gvy[mu] gvzmu = gvz[mu] for nu in range(nbas): crnu = cmatr[nu] cinu = cmati[nu] bvnu = bvs[nu] gvxnu = gvx[nu] gvynu = gvy[nu] gvznu = gvz[nu] cval = evaluate('-0.5 * (occvec * (crmu * cinu - cimu * crnu))', out=cval) csum = cval.sum() evaluate('curx + csum * (bvmu * gvxnu - gvxmu * bvnu)', out=curx) evaluate('cury + csum * (bvmu * gvynu - gvymu * bvnu)', out=cury) evaluate('curz + csum * (bvmu * gvznu - gvzmu * bvnu)', out=curz) if verbose: fp.close() return curx, cury, curz
class ProgressBarJupyter(Progress): """Simple Jupyter progress bar Writes a progress bar to an ipython widget """ def __init__(self, total): super(ProgressBarJupyter, self).__init__() from ipywidgets import FloatProgress from IPython.display import display self.progress = FloatProgress(min=0, max=total) display(self.progress) def update(self, step=1): self.progress.value += step def done(self): """Close the widget """ self.progress.close()
class ProgressBarJupyter(Progress): """Simple Jupyter progress bar Writes a progress bar to an ipython widget """ def __init__(self, total): super(ProgressBarJupyter, self).__init__() from ipywidgets import FloatProgress from IPython.display import display self.progress = FloatProgress(min=0, max=total) display(self.progress) def update(self, step=1): self.progress.value += step def done(self): """Close the widget """ self.progress.close()
def compute_angles_out_of_core(hdfname, uni, bond=True): """ Given an HDF of atom two body properties, compute angles. Atomic two body data is expected to have been computed (see :func:`~exatomic.core.two.compute_atom_two_out_of_core`) Args: hdfname (str): Path to HDF file containing two body data uni (:class:`~exatomic.core.universe.Universe`): Universe bond (bool): Restrict to bond angles (default True) Warning: If bond is set to False, this process may take a very long time. """ store = pd.HDFStore(hdfname, mode="a") f = u.atom['frame'].unique() n = len(f) fp = FloatProgress(description="Computing:") display(fp) for i, fdx in enumerate(f): tdf = store.get("frame_" + str(fdx) + "/atom_two") indexes = [] radians = [] for atom0, group in tdf[tdf['bond'] == True].groupby("atom0"): dx = group['dx'].values.astype(float) dy = group['dy'].values.astype(float) dz = group['dz'].values.astype(float) dr = group['dr'].values.astype(float) atom1 = group['atom1'].values.astype(int) rad, adx = angles(dx, dy, dz, dr, atom0, atom1) indexes.append(adx) radians.append(rad) indexes = np.concatenate(indexes) radians = np.concatenate(radians) adf = pd.DataFrame(indexes, columns=("atom0", "atom1", "atom2")) adf['angle'] = radians store.put("frame_" + str(fdx) + "/atom_angle", adf) fp.value = i / n * 100 store.close() fp.close()
def read_datalines(filedata, ckey, even_NSTEPS=True, GUI=False): if GUI: progbar = FloatProgress(min=0, max=100) display(progbar) NSTEPS = len(filedata) - 1 data = initialize_dic(NSTEPS, ckey) progbar_step = max(100000, int(0.005*NSTEPS)) for step, line in enumerate(filedata[1:]): if len(line) == 0: # EOF print "Warning: reached EOF." break values = np.array(line.split()) for key, idx in ckey.iteritems(): # save the selected columns data[key][step,:] = np.array(map(float, values[idx])) if ( (step+1)%progbar_step == 0 ): if GUI: progbar.value = float(step+1)/NSTEPS*100.; progbar.description = "{:6.2f}%".format(progbar.value) else: print " step = {:9d} - {:6.2f}% completed".format(step+1, float(step+1)/NSTEPS*100.) if GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < NSTEPS): if (step == 0): print "WARNING: no step read." return else: print "Warning: less steps read." NSTEPS = step + 1 if even_NSTEPS: if (NSTEPS%2 == 1): NSTEPS = NSTEPS - 1 for key, idx in ckey.iteritems(): # free memory not used data[key] = data[key][:NSTEPS,:] print " ( %d ) steps read." % (NSTEPS) return data
class AbuProgress(object): """单进程(主进程)进度显示控制类""" # 过滤DeprecationWarning: Widget._keys_default is deprecated in traitlets 4.1: use @default decorator instead. @warnings_filter def __init__(self, total, a_progress, label=None): """ 外部使用eg: progess = AbuProgress(stock_df.shape[0], 0, 'merging {}'.format(m)) for i, symbol in enumerate(stock_df['symbol']): progess.show(i + 1) :param total: 总任务数量 :param a_progress: 初始进度 :param label: 进度显示label """ self._total = total self._progress = a_progress self._label = label self.f = sys.stdout self.progress_widget = None def __enter__(self): """创建子进程做进度显示""" return self def __exit__(self, exc_type, exc_val, exc_tb): self.f.write('\r') if self.progress_widget is not None: self.progress_widget.close() @property def progress(self): """property获取self._progress""" return self._progress @progress.setter def progress(self, a_progress): """rogress.setter设置progress""" if a_progress > self._total: self._progress = self._total elif a_progress < 0: self._progress = 0 else: self._progress = a_progress def show(self, a_progress=None, ext='', p_format="{}:{}:{}%"): """ 进行进度控制显示主方法 :param ext: 可以添加额外的显示文字,str,默认空字符串 :param a_progress: 默认None, 即使用类内部计算的迭代次数进行进度显示 :param p_format: 进度显示格式,默认{}: {}%,即'self._label:round(self._progress / self._total * 100, 2))%' """ self.progress = a_progress if a_progress is not None else self.progress + 1 ps = round(self._progress / self._total * 100, 2) if self._label is not None: # 如果初始化label没有就只显示ui进度 self.f.write('\r') self.f.write(p_format.format(self._label, ext, ps)) if ABuEnv.g_is_ipython: if self.progress_widget is None: self.progress_widget = FloatProgress(value=0, min=0, max=100) display(self.progress_widget) self.progress_widget.value = ps # 这样会出现余数结束的情况,还是尽量使用上下文管理器控制结束 if self._progress == self._total: self.f.write('\r') if self.progress_widget is not None: self.progress_widget.close()
def periodic_nearest_neighbors_by_atom(uni, source, a, sizes, **kwargs): """ Determine nearest neighbor molecules to a given source (or sources) and return the data as a dataframe. Warning: For universes with more than about 250 atoms, consider using the slower but more memory efficient :func:`~exatomic.algorithms.neighbors.periodic_nearest_neighbors_by_atom_large`. For a simple cubic periodic system with unit cell dimension ``a``, clusters can be generated as follows. In the example below, additional keyword arguments have been included as they are almost always required in order to correctly identify molecular units semi-empirically. .. code-block:: python periodic_nearest_neighbors_by_atom(u, [0], 40.0, [0, 5, 10, 50], dmax=40.0, C=1.6, O=1.6) Argument descriptions can be found below. The additional keyword arguments, ``dmax``, ``C``, ``O``, are passed directly to the two body computation used to determine (semi-empirically) molecular units. Note that although molecules are computed, neighboring molecular units are determine by an atom to atom criteria. Args: uni (:class:`~exatomic.core.universe.Universe`): Universe source (int, str, list): Integer label or string symbol of source atom a (float): Cubic unit cell dimension sizes (list): List of slices to create kwargs: Additional keyword arguments to be passed to atom two body calculation Returns: dct (dict): Dictionary of sliced universes and nearest neighbor table See Also: Sliced universe construction can be facilitated by :func:`~exatomic.algorithms.neighbors.construct`. """ def sorter(group, source_atom_idxs): s = group[['atom0', 'atom1']].stack() return s[~s.isin(source_atom_idxs)].reset_index() if "label" not in uni.atom.columns: uni.atom['label'] = uni.atom.get_atom_labels() dct = defaultdict(list) grps = uni.atom.groupby("frame") ntot = len(grps) fp = FloatProgress(description="Slicing:") display(fp) for i, (fdx, atom) in enumerate(grps): if len(atom) > 0: uu = _create_super_universe(Universe(atom=atom.copy()), a) uu.compute_atom_two(**kwargs) uu.compute_molecule() if isinstance(source, (int, np.int32, np.int64)): source_atom_idxs = uu.atom[(uu.atom.index.isin([source])) & (uu.atom['prj'] == 13)].index.values elif isinstance(source, (list, tuple)): source_atom_idxs = uu.atom[uu.atom['label'].isin(source) & (uu.atom['prj'] == 13)].index.values else: source_atom_idxs = uu.atom[(uu.atom['symbol'] == source) & (uu.atom['prj'] == 13)].index.values source_molecule_idxs = uu.atom.loc[source_atom_idxs, 'molecule'].unique().astype(int) uu.atom_two['frame'] = uu.atom_two['atom0'].map(uu.atom['frame']) nearest_atoms = uu.atom_two[ (uu.atom_two['atom0'].isin(source_atom_idxs)) | (uu.atom_two['atom1'].isin(source_atom_idxs))].sort_values( "dr")[['frame', 'atom0', 'atom1']] nearest = nearest_atoms.groupby("frame").apply( sorter, source_atom_idxs=source_atom_idxs) del nearest['level_1'] nearest.index.names = ['frame', 'idx'] nearest.columns = ['two', 'atom'] nearest['molecule'] = nearest['atom'].map(uu.atom['molecule']) nearest = nearest[~nearest['molecule'].isin(source_molecule_idxs)] nearest = nearest.drop_duplicates('molecule', keep='first') nearest.reset_index(inplace=True) nearest['frame'] = nearest['frame'].astype(int) nearest['molecule'] = nearest['molecule'].astype(int) dct['nearest'].append(nearest) for nn in sizes: atm = [] for j, fdx in enumerate(nearest['frame'].unique()): mdxs = nearest.loc[nearest['frame'] == fdx, 'molecule'].tolist()[:nn] mdxs.append(source_molecule_idxs[j]) atm.append(uu.atom[uu.atom['molecule'].isin(mdxs)][[ 'symbol', 'x', 'y', 'z', 'frame' ]].copy()) dct[nn].append(pd.concat(atm, ignore_index=True)) fp.value = i / ntot * 100 dct['nearest'] = pd.concat(dct['nearest'], ignore_index=True) for nn in sizes: dct[nn] = Universe(atom=pd.concat(dct[nn], ignore_index=True)) fp.close() return dct
class AbuProgress(object): """单进程(主进程)进度显示控制类""" # 过滤DeprecationWarning: Widget._keys_default is deprecated in traitlets 4.1: use @default decorator instead. @warnings_filter def __init__(self, total, a_progress, label=None): """ 外部使用eg: progess = AbuProgress(stock_df.shape[0], 0, 'merging {}'.format(m)) for i, symbol in enumerate(stock_df['symbol']): progess.show(i + 1) :param total: 总任务数量 :param a_progress: 初始进度 :param label: 进度显示label """ self._total = total self._progress = a_progress self._label = label self.f = sys.stdout self.progress_widget = None def __enter__(self): """创建子进程做进度显示""" return self def __exit__(self, exc_type, exc_val, exc_tb): self.f.write('\r') if self.progress_widget is not None: self.progress_widget.close() @property def progress(self): """property获取self._progress""" return self._progress @progress.setter def progress(self, a_progress): """rogress.setter设置progress""" if a_progress > self._total: self._progress = self._total elif a_progress < 0: self._progress = 0 else: self._progress = a_progress def show(self, a_progress=None, ext='', p_format="{}:{}:{}%"): """ 进行进度控制显示主方法 :param ext: 可以添加额外的显示文字,str,默认空字符串 :param a_progress: 默认None, 即使用类内部计算的迭代次数进行进度显示 :param p_format: 进度显示格式,默认{}: {}%,即'self._label:round(self._progress / self._total * 100, 2))%' """ self.progress = a_progress if a_progress is not None else self.progress + 1 ps = round(self._progress / self._total * 100, 2) if self._label is not None: # 如果初始化label没有就只显示ui进度 self.f.write('\r') self.f.write(p_format.format(self._label, ext, ps)) if ABuEnv.g_is_ipython: if self.progress_widget is None: self.progress_widget = FloatProgress(value=0, min=0, max=100) display(self.progress_widget) self.progress_widget.value = ps # 这样会出现余数结束的情况,还是尽量使用上下文管理器控制结束 if self._progress == self._total: self.f.write('\r') if self.progress_widget is not None: self.progress_widget.close()
def periodic_nearest_neighbors_by_atom_large(uni, source, a, sizes, **kwargs): """ Determine nearest neighbor molecules to a given source (or sources) and return the data as a dataframe. Tip: This function performs the same operation as :func:`~exatomic.algorithms.neighbors.periodic_nearest_neighbors_by_atom`, but is meant for universes containing more than about 250 atoms per frame (the referenced function will be faster for smaller universes). For a simple cubic periodic system with unit cell dimension ``a``, clusters can be generated as follows. In the example below, additional keyword arguments have been included as they are almost always required in order to correctly identify molecular units semi-empirically. .. code-block:: python periodic_nearest_neighbors_by_atom_ooc(u, [0], 40.0, [0, 5, 10, 50], dmax=40.0, C=1.6, O=1.6) Argument descriptions can be found below. The additional keyword arguments, ``dmax``, ``C``, ``O``, are passed directly to the two body computation used to determine (semi-empirically) molecular units. Note that although molecules are computed, neighboring molecular units are determine by an atom to atom criteria. Args: uni (:class:`~exatomic.core.universe.Universe`): Universe source (int, str, list): Integer label or string symbol of source atom a (float): Cubic unit cell dimension sizes (iterable): List of slices to create kwargs: Additional keyword arguments to be passed to atom two body calculation Returns: dct (dict): Dictionary of sliced universes and nearest neighbor table See Also: Sliced universe construction can be facilitated by :func:`~exatomic.algorithms.neighbors.construct`. """ if "label" not in uni.atom.columns: uni.atom['label'] = uni.atom.get_atom_labels() if not isinstance(sizes, list): raise TypeError("Argument sizes must be iterable of ints.") dct = defaultdict(list) grps = uni.atom.groupby("frame") ntot = len(grps) fp = FloatProgress(description="Slicing:") display(fp) for i, (fdx, atom) in enumerate(grps): if len(atom) > 0: uu = Universe(atom=atom.copy()) uu.frame = uni.frame.loc[[fdx], :] uu.compute_atom_two(**kwargs) uu.compute_molecule() if isinstance(source, (int, np.int32, np.int64)): source_atom_idxs = [source] elif isinstance(source, np.ndarray): source_atom_idxs = source.tolist() elif isinstance(source, (list, tuple)): source_atom_idxs = uu.atom[uu.atom['label'].isin(source) | uu.atom['symbol']. isin(source)].index.astype( int).tolist() else: source_atom_idxs = uu.atom[uu.atom['symbol'] == source].index.astype(int).tolist() source_molecule_idxs = uu.atom.loc[ source_atom_idxs, 'molecule'].unique().astype(int).tolist() # Identify the nearest molecules nearest_atoms = uu.atom_two[ uu.atom_two['atom0'].isin(source_atom_idxs) | uu.atom_two['atom1'].isin(source_atom_idxs)].sort_values( 'dr')[['atom0', 'atom1']].copy() nearest_atoms['molecule0'] = nearest_atoms['atom0'].map( uu.atom['molecule']) nearest_atoms['molecule1'] = nearest_atoms['atom1'].map( uu.atom['molecule']) nearest_molecules = nearest_atoms[['molecule0', 'molecule1']].stack() nearest_molecules = nearest_molecules[ ~nearest_molecules.isin(source_molecule_idxs)].drop_duplicates( keep='first') # Build the appropriate universes for nn in sizes: atom1 = uu.atom.loc[uu.atom['molecule']. isin(nearest_molecules.iloc[:nn].tolist() + source_molecule_idxs), ['symbol', 'x', 'y', 'z']] adxs, x, y, z, prj = _worker(atom1.index.values.astype(int), atom1['x'].values.astype(float), atom1['y'].values.astype(float), atom1['z'].values.astype(float), a) patom = pd.DataFrame.from_dict({ 'atom': adxs, 'x': x, 'y': y, 'z': z, 'prj': prj }) patom['frame'] = patom['atom'].map(uu.atom['frame']) patom['symbol'] = patom['atom'].map(uu.atom['symbol']) sliced_u = Universe(atom=patom) sliced_u.compute_atom_two(dmax=a) sliced_u.compute_molecule() source_adxs1 = sliced_u.atom[ (sliced_u.atom['prj'] == 13) & sliced_u.atom['atom'].isin(source_atom_idxs)].index source_mdxs1 = sliced_u.atom.loc[source_adxs1, 'molecule'].unique().tolist() nearest_atoms1 = sliced_u.atom_two[ sliced_u.atom_two['atom0'].isin(source_adxs1) | sliced_u. atom_two['atom1'].isin(source_adxs1)].sort_values('dr')[[ 'atom0', 'atom1' ]].copy() nearest_atoms1['molecule0'] = nearest_atoms1['atom0'].map( sliced_u.atom['molecule']) nearest_atoms1['molecule1'] = nearest_atoms1['atom1'].map( sliced_u.atom['molecule']) nearest_molecules1 = nearest_atoms1[['molecule0', 'molecule1']].stack() nearest_molecules1 = nearest_molecules1[ ~nearest_molecules1.isin(source_mdxs1)].drop_duplicates( keep='first') # Its fine to overwrite atom1 above since the uu.atom slice is not necessarily clustered atom1 = sliced_u.atom.loc[sliced_u.atom['molecule'].isin( nearest_molecules1.iloc[:nn].tolist() + source_mdxs1)].copy() dct[nn].append(atom1) index = nearest_molecules.index.get_level_values(0) nearest_molecules = nearest_molecules.to_frame() nearest_molecules.columns = ['molecule'] nearest_molecules['frame'] = fdx nearest_molecules['atom0'] = nearest_atoms.loc[index, 'atom0'].values nearest_molecules['atom1'] = nearest_atoms.loc[index, 'atom1'].values dct['nearest'].append(nearest_molecules) fp.value = i / ntot * 100 dct['nearest'] = pd.concat(dct['nearest'], ignore_index=True) for nn in sizes: dct[nn] = Universe(atom=pd.concat(dct[nn], ignore_index=True)) fp.close() return dct
def read_datalines(self, NSTEPS=0, start_step=-1, select_ckeys=None, max_vector_dim=None, even_NSTEPS=True): """ Read NSTEPS steps of file, starting from start_step, and store only the selected ckeys. INPUT: NSTEPS -> number of steps to read (default: 0 -> reads all the file) start_step = -1 -> continue from current step (default) 0 -> go to start step N -> go to N-th step select_ckeys -> an array with the column keys you want to read (see all_ckeys for a list) max_vector_dim -> when reading vectors read only this number of components (None = read all components) even_NSTEPS -> round the number of steps to an even number (default: True) OUTPUT: data -> a dictionary with the selected-column steps """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() if (NSTEPS == 0): NSTEPS = self.MAX_NSTEPS self._set_ckey(select_ckeys, max_vector_dim) # set the ckeys to read self._initialize_dic(NSTEPS) # allocate dictionary self.gotostep(start_step) # jump to the starting step # read NSTEPS of the file progbar_step = max(100000, int(0.005 * NSTEPS)) for step in range(NSTEPS): line = self.file.readline() if (len(line) == 0): # EOF log.write_log('Warning: reached EOF.') break if self.endrun_keyword in line: # end-of-run keyword log.write_log(' endrun_keyword found.') step -= 1 break values = np.array(line.split()) if (values.size != self.NALLCKEYS): log.write_log( 'Warning: line with wrong number of columns found. Stopping here...' ) log.write_log(line) break for key, idx in self.ckey.items(): # save the selected columns self.data[key][step, :] = np.array( list(map(float, values[idx]))) if ((step + 1) % progbar_step == 0): if self._GUI: progbar.value = float(step + 1) / NSTEPS * 100. progbar.description = '{:6.2f}%'.format(progbar.value) else: log.write_log( ' step = {:9d} - {:6.2f}% completed'.format( step + 1, float(step + 1) / NSTEPS * 100.)) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < NSTEPS): if (step == 0): log.write_log('WARNING: no step read.') return else: if (NSTEPS != self.MAX_NSTEPS): # if NSTEPS was specified log.write_log('Warning: less steps read.') NSTEPS = step + 1 # the correct number of read steps # even the number of steps if even_NSTEPS: if (NSTEPS % 2 == 1): NSTEPS = NSTEPS - 1 log.write_log( ' Retaining an even number of steps (even_NSTEPS=True).') for key, idx in self.ckey.items(): # free the memory not used self.data[key] = self.data[key][:NSTEPS, :] log.write_log(' ( %d ) steps read.' % (NSTEPS)) self.NSTEPS = NSTEPS log.write_log('DONE. Elapsed time: ', time() - start_time, 'seconds') return self.data
def periodic_nearest_neighbors_by_atom(uni, source, a, sizes, **kwargs): """ Determine nearest neighbor molecules to a given source (or sources) and return the data as a dataframe. For a simple cubic periodic system with unit cell dimension ``a``, clusters can be generated as follows. In the example below, additional keyword arguments have been included as they are almost always required in order to correctly identify molecular units semi-empirically. .. code-block:: python periodic_nearest_neighbors_by_atom(u, [0], 40.0, [0, 5, 10, 50], dmax=40.0, C=1.6, O=1.6) Argument descriptions can be found below. The additional keyword arguments, ``dmax``, ``C``, ``O``, are passed directly to the two body computation used to determine (semi-empirically) molecular units. Note that although molecules are computed, neighboring molecular units are determine by an atom to atom criteria. Args: uni (:class:`~exatomic.core.universe.Universe`): Universe source (int, str, list): Integer label or string symbol of source atom a (float): Cubic unit cell dimension sizes (list): List of slices to create kwargs: Additional keyword arguments to be passed to atom two body calculation Returns: dct (dict): Dictionary of sliced universes and nearest neighbor table See Also: Sliced universe construction can be facilitated by :func:`~exatomic.algorithms.neighbors.construct`. """ def sorter(group, source_atom_idxs): s = group[['atom0', 'atom1']].stack() return s[~s.isin(source_atom_idxs)].reset_index() if "label" not in uni.atom.columns: uni.atom['label'] = uni.atom.get_atom_labels() dct = defaultdict(list) grps = uni.atom.groupby("frame") ntot = len(grps) fp = FloatProgress(description="Slicing:") display(fp) for i, (fdx, atom) in enumerate(grps): if len(atom) > 0: uu = _create_super_universe(Universe(atom=atom.copy()), a) uu.compute_atom_two(**kwargs) uu.compute_molecule() if isinstance(source, (int, np.int32, np.int64)): source_atom_idxs = uu.atom[(uu.atom.index.isin([source])) & (uu.atom['prj'] == 13)].index.values elif isinstance(source, (list, tuple)): source_atom_idxs = uu.atom[uu.atom['label'].isin(source) & (uu.atom['prj'] == 13)].index.values else: source_atom_idxs = uu.atom[(uu.atom['symbol'] == source) & (uu.atom['prj'] == 13)].index.values source_molecule_idxs = uu.atom.loc[source_atom_idxs, 'molecule'].unique().astype(int) uu.atom_two['frame'] = uu.atom_two['atom0'].map(uu.atom['frame']) nearest_atoms = uu.atom_two[(uu.atom_two['atom0'].isin(source_atom_idxs)) | (uu.atom_two['atom1'].isin(source_atom_idxs))].sort_values("dr")[['frame', 'atom0', 'atom1']] nearest = nearest_atoms.groupby("frame").apply(sorter, source_atom_idxs=source_atom_idxs) del nearest['level_1'] nearest.index.names = ['frame', 'idx'] nearest.columns = ['two', 'atom'] nearest['molecule'] = nearest['atom'].map(uu.atom['molecule']) nearest = nearest[~nearest['molecule'].isin(source_molecule_idxs)] nearest = nearest.drop_duplicates('molecule', keep='first') nearest.reset_index(inplace=True) nearest['frame'] = nearest['frame'].astype(int) nearest['molecule'] = nearest['molecule'].astype(int) dct['nearest'].append(nearest) for nn in sizes: atm = [] for j, fdx in enumerate(nearest['frame'].unique()): mdxs = nearest.loc[nearest['frame'] == fdx, 'molecule'].tolist()[:nn] mdxs.append(source_molecule_idxs[j]) atm.append(uu.atom[uu.atom['molecule'].isin(mdxs)][['symbol', 'x', 'y', 'z', 'frame']].copy()) dct[nn].append(pd.concat(atm, ignore_index=True)) fp.value = i/ntot*100 dct['nearest'] = pd.concat(dct['nearest'], ignore_index=True) for nn in sizes: dct[nn] = Universe(atom=pd.concat(dct[nn], ignore_index=True)) fp.close() return dct
def flowLines(F, Ipb, LAT, flow): f = F[0] ## sympy function, matrix valued. k = len(F[1]) ## number of parameters to f. F[1] is the variable names. ## F[2] is the integration bounds. Df = sp.zeros(3, k) for i in range(k): Df[:, i] = sp.diff(f, F[1][i]) Cf = sp.sqrt((Df.transpose() * Df).det()).simplify() ## Cf is the length/area/volume distortion of f. x, y, z = sp.symbols('x y z') P = sp.Matrix([x, y, z]) ## we have to push I through Df to get the current vector field. I = Df * Ipb den = sp.Matrix(f - P) ITG = I.cross(den) den = den.dot(den)**(3 / 2) ITG = (ITG / den) ## let's make an entire routine that does Euler's method callable? ## this is possibly something to experiment with, the level of abstraction. ## we could also just make the integration command callable. ITGc = [ufuncify(F[1] + [x, y, z], ITG[i, 0]) for i in range(3)] ## compile the curve as well, as we need to check distances C = [ufuncify(F[1], F[0][i, 0]) for i in range(3)] ## loop running through the lattice [X,Y,Z]=LAT computing flowlines at those ## coordinates. retval = [] fp = FloatProgress(min=0, max=100, description="Flowlines") display(fp) ## progrss indicator count = 0 totc = LAT[0].shape[0] * LAT[0].shape[1] * LAT[0].shape[2] for i, j, k in it.product(range(LAT[0].shape[0]), range(LAT[0].shape[1]), range(LAT[0].shape[2])): # TODO: let's throw in a basic check to see if this starting coordinate # is too close to the curve. errFlag = False flowline = [[LAT[0][i, j, k]], [LAT[1][i, j, k]], [LAT[2][i, j, k]]] for s in range(flow[1]): dp = [ INT.nquad(ITGc[l], F[2], args=(flowline[0][-1], flowline[1][-1], flowline[2][-1]), opts=[{ 'epsrel': 0 }, { 'epsabs': 1e-3 }])[0] for l in range(3) ] ## here is a primitive check to see if our lattice point is too close to ## the curve. Should be replaced with something more sophisticated... later. ldp = np.sqrt(sum([crd**2 for crd in dp])) if (ldp > 1e+8): errFlag = True break ## assemble our flowline for l in range(3): flowline[l].append(flowline[l][-1] + flow[0] * dp[l] / ldp) count += 1 fp.value = int(100 * count / totc) ## let's not build the flow line if ldp is too large. if errFlag == False: retval.append(flowline) fp.close() return retval, C
def array_slice(self, path, start, stop, modified): #Convert the (whole!) h5 dataset to an numpy array and slice immediately. #Check if input is only one h5 file or multiple if isinstance(self.dict, File): electrode_info = np.asarray(self.dict['mapping']['channel', 'electrode']) mask = electrode_info['electrode'] != -1 clean_rel_inds = electrode_info['channel'][mask] if modified == True: stop = 'end' self.metadata['modified'] = True else: self.metadata['modified'] = False if stop == 'end': if modified == False: traces = np.asarray(self.dict['sig']) self.metadata['DAC'] = traces[1024, start:] traces = traces[clean_rel_inds, start:] #crop the traces self.metadata['time'] = np.arange( 0, (self.dict['sig'].shape[1] - start) / 20000., 1 / 20000.) else: traces = np.asarray(self.dict['sig'])[:, start:] self.metadata['time'] = self.dict['time'][:] else: traces = np.asarray(self.dict['sig']) self.metadata['DAC'] = traces[1024, start:stop] traces = traces[clean_rel_inds, start:stop] self.metadata['time'] = np.arange(0, (stop - start) / 20000., 1 / 20000.) if isinstance(self.dict, list): electrode_info = [ np.asarray(i['mapping']['channel', 'electrode']) for i in self.dict ] mask = [i['electrode'] != -1 for i in electrode_info] clean_rel_inds = [ i[0]['channel'][i[1]] for i in zip(electrode_info, mask) ] traces = [] progr = FloatProgress(min=0, max=len(self.dict), description='Importing...', bar_style='success') display(progr) if modified == True: stop = 'end' for i in range(len(clean_rel_inds)): self.metadata[i]['modified'] = True else: for i in range(len(clean_rel_inds)): self.metadata[i]['modified'] = False if stop == 'end': for i, v in enumerate(clean_rel_inds): if modified == False: raw_trace = np.asarray(self.dict[i]['sig']) self.metadata[i]['DAC'] = raw_trace[1024, start:] traces.append(raw_trace[v, start:]) self.metadata[i]['time'] = np.arange( 0, (self.dict[i]['sig'].shape[1] - start) / 20000., 1 / 20000.) else: traces.append( np.asarray(self.dict[i]['sig'])[:, start:]) self.metadata[i]['time'] = self.dict[i]['time'][:] progr.value += 1 else: for i, v in enumerate(clean_rel_inds): raw_trace = np.asarray(self.dict[i]['sig']) self.metadata[i]['DAC'] = raw_trace[1024, start:] traces.append(raw_trace[v, start:stop]) self.metadata[i]['time'] = np.arange( 0, (stop - start) / 20000., 1 / 20000.) progr.value += 1 progr.close() return traces