def calc_bondacf(args): """ calculates persitence length using bond correlation function bondacf: bond correlation function analysis for L_p, when this parameter is provided, then program analyzes first points and fits them, to understand persistance length. C(n) = <u_0 u_n > method: create an array C, loop trajectory: loop residues: loop bonds: analyze angle between first bond vector and i average results plot using save_plots """ psffile = get_path_names.get_filename(args.psffile) u = MDAnalysis.Universe(psffile + '.psf', args.traj) Nbonds = len(u.residues[0]) - 1 Nres = len(u.residues) print "Nres = %r" % Nres print "Nbonds = %r" % Nbonds bonds = np.array((Nbonds, 3)) C = np.zeros(Nbonds) k = 0 for ts in u.trajectory[args.startframe:args.endframe:args.trajskip]: print "time = %r" % ts.frame for res in u.residues: bonds = AnalyzeChain.get_bondlist_coords(res) k += 1 for ui in range(0, Nbonds): C[ui] += np.dot(bonds[0], bonds[ui]) C /= float(k) ui_array = np.arange(Nbonds) save_plots.save_plot(ui_array, C, plotname='bondacf')
def main(args): """ main func """ u = MDAnalysis.Universe(args.psffile, args.traj) psffile = get_path_names.get_filename(args.psffile) SimData(u, args)
def calc_sq(args): """ input: args obtained from read_traj_vmd calculates sq static parameter to analyze trajectories output: """ # psffile = os.path.splitext(args.psffile)[0] u = Universe(args.psffile, args.traj) psffile = get_path_names.get_filename(u.filename) # Ndiv = args.nsub Natoms = len(u.atoms) # Ndiv = int(Natoms**1/3.) Ndiv = 201 # create arrays of positions, get the box dimenstions u.trajectory[args.startframe] u.SYSTEM.packIntoBox() X = u.atoms.positions box = u.trajectory.ts.dimensions[:-3] length_x = box[-1] # be careful here # x = np.arange(-length_x,length_x,dx) x = np.linspace(-length_x, length_x, Ndiv+1, endpoint=True) f, edges = np.histogramdd(X, bins=(Ndiv, Ndiv, Ndiv)) delta = x[1]-x[0] # fast fourier transform, go to reciporal space ftk = (fftshift(fftn(fftshift(f))*delta)) # sk = np.abs(ftk**2) / float(Natoms) sk = np.abs(ftk**2) / float(Natoms) # / float(ndata) probably number of atoms # plt.cla() # basis in reciporal space omega = 2*np.pi*np.arange(Ndiv-1) / (length_x) omega -= omega[int(Ndiv/2)-1] k1, k2, k3 = np.meshgrid(omega, omega, omega) kmax = np.sqrt(3.)*omega[-1] # print "dk =" , dk, " kmax = ", kmax C = norm_sq(sk, k1, k2, k3, Ndiv, kmax) # we are interested in spherically symmetric case, # i.e only the module of [k1,k2,k3] = normk is important # print C[:,1] # plt.plot(C[:,1], C[:,2]) Nfirst = 10 save_plots.save_plot(C[Nfirst:-Nfirst, 1], C[Nfirst:-Nfirst, 2], xlabel='q, 1/sigma', ylabel='sq', title='static structure factor', plotname='sq', name=psffile+'f'+str(args.startframe), ymax=1.0, ymin=0.) return None
def calc_cryst(args): """ Analyzes crystallinity """ u = MDAnalysis.Universe(args.psffile, args.traj) psffile = get_path_names.get_filename(args.psffile) Nres = len(u.residues) frame = [] g2 = [] res_g2 = 0. # key parameter is the parameter used for parsing the files # keyparameter = get_path_names.get_filename(args.traj) keyparameter = args.keyparameter if args.filedumpskip: dumpskip = AnalyzeLog.get_dumpskip(filename='dumpskip.txt', keyparameter="dump" + keyparameter + "skip") timestep = AnalyzeLog.get_timestep(filename='dumpskip.txt', keyparameter="time" + keyparameter + "step") else: print "using given parameters" dumpskip = args.dumpskip timestep = args.timestep for ts in u.trajectory[args.startframe:args.endframe:args.trajskip]: all_g2 = 0. frame.append(ts.frame) for res in u.residues: chords = get_bondlist_coords(res) res_g2 = get_chain_crystallinity(chords, threshold=args.threshold, neigh=args.neigh) all_g2 += res_g2 print('frame {frame} , g2 = {cryst}'.format(frame=ts.frame, cryst=all_g2 / float(Nres))) g2.append(all_g2 / float(Nres)) frame = np.array(frame) g2 = np.array(g2) save_plots.save_plot(frame, g2, plotname='ICC', name=psffile, logplot=args.logplot, dumpskip=dumpskip, timestep=timestep, duplicate=False) # save_plots.save_plot_cryst(frame, g2, psffile, # logplot=args.logplot, # dumpskip=dumpskip, # timestep=timestep) return None
def SimData(u, args): """ input: u, args plot through trajectory and plot frames get chaintype, histogram, chaincounts for current frame then we plot a histogram """ name = get_path_names.get_filename(args.psffile) total_frames, total_crystallinity = [], [] for ts in u.trajectory[args.startframe:args.endframe:args.trajskip]: print " frame = %d " % ts.frame # chaintype, histogram, chaincounts x, y, counts = get_diff_chain_cryst(u, args) total_frames.append(ts.frame) total_crystallinity.append(y) # y = histogram # if it is a histogram how do I calculate total crystallinty plt.axhline(y=y.min(), xmin=x.min(), xmax=x.max(), linewidth=0.8, color='k', ls='--') plt.bar(x, y, width=0.2 * (x.max() - x.min()) / float(len(x)), facecolor='green', alpha=0.7, align='center') yield x, y if args.filedumpskip: dumpskip = AnalyzeLog.get_dumpskip(filename='dumpskip.txt', keyparameter="dump" + args.keyparameter + "skip") timestep = AnalyzeLog.get_timestep(filename='dumpskip.txt', keyparameter="time" + args.keyparameter + "step") else: print "using given parameters" dumpskip = args.dumpskip timestep = args.timestep total_frames = np.asarray(total_frames, dtype='float32') total_crystallinity = np.asarray(total_crystallinity, dtype='float32') factor = 1e6 total_frames *= dumpskip * timestep / float(factor) for j in range(total_crystallinity.shape[1]): np.savez( 'indchainc' + str(x[j]) + 'n' + str(counts[j]) + 'PDI1.0' + 'extra' + name, total_frames, total_crystallinity[:, j])
def SimData(u, args): """ input: u, args plot through trajectory and plot frames get chaintype, histogram, chaincounts for current frame then we plot a histogram """ name = get_path_names.get_filename(args.psffile) total_frames, total_crystallinity, tmp_array = [], [], [] for ts in u.trajectory[args.startframe:args.endframe:args.trajskip]: print " frame = %d " % ts.frame # chaintype, histogram, chaincounts x, y, counts = get_diff_chain_cryst(u, args) total_frames.append(ts.frame) tmp = 0. for i in range(len(y)): tmp += y[i] * counts[i] tmp /= counts.sum() tmp_array.append(tmp) total_crystallinity.append(y) # y = histogram # if it is a histogram how do I calculate total crystallinty print "frame = ", ts.frame, "total cryst = ", tmp if args.filedumpskip: dumpskip = AnalyzeLog.get_dumpskip(filename='dumpskip.txt', keyparameter="dump" + args.keyparameter + "skip") timestep = AnalyzeLog.get_timestep(filename='dumpskip.txt', keyparameter="time" + args.keyparameter + "step") else: print "using given parameters" dumpskip = args.dumpskip timestep = args.timestep total_frames = np.asarray(total_frames, dtype='float32') tmp_array = np.asarray(tmp_array, dtype='float32') total_crystallinity = np.asarray(total_crystallinity, dtype='float32') factor = 1e6 total_frames *= dumpskip * timestep / float(factor) np.savez('inchain_full', total_frames, tmp_array) print "total_crystallinity" print total_crystallinity for j in range(total_crystallinity.shape[1]): np.savez('indchainc' + str(x[j]) + 'n' 'PDI1.0' + 'extra' + name, total_frames, total_crystallinity[:, j]) # total_crystallinity = np.asarray(total_crystallinity) return None
def plot_bars(args): """plots different histgrams""" filenames = [get_path_names.get_filename(x) for x in args.collection] parameters = { 'title': args.titlename, 'xlabel': args.xlabel, 'ylabel': args.ylabel, 'dumpskip': args.dumpskip } if args.logplot: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" plt.ylabel('${0[ylabel]}$'.format(parameters)) plt.xlabel('${0[xlabel]}$'.format(parameters)) plt.title('${0[title]}$'.format(parameters)) widths = [4, 6, 8, 10, 12] colors = ['k', 'y', 'm', 'c', 'b', 'g', 'r', '#aaaaaa'] colorcycler = itertools.cycle(colors) widthscycler = itertools.cycle(widths) for (i, j) in itertools.izip(args.collection, filenames): npz = np.load(i) t = npz[args.name_x] p = npz[args.name_y] clr = next(colorcycler) w = next(widthscycler) plt.bar(t, p, width=w, facecolor=clr, alpha=0.4, label=j, align='center') if args.legend: plt.legend(loc='best') plt.savefig(args.titlename + ".pdf") return None
def main(args): """ main func """ u = MDAnalysis.Universe(args.psffile, args.traj) psffile = get_path_names.get_filename(args.psffile) # Now call the animation package: # (simData is the user function # serving as the argument for simPoints): ani = animation.FuncAnimation(FIG, SimPoints, SimData(u, args), blit=True, interval=150, repeat=True) ani.save('Cryst{filename}.mp4'.format(filename=psffile)) plt.close()
def main(args): """main func""" psffile = get_path_names.get_filename(args.psffile) u = MDAnalysis.Universe(psffile + '.psf', args.traj) bonds = AnalyzeChain.get_bondlist_coords(u.residues[0]) L = 0. # number of lamellae # the skip on the left and on the right, nleft, nright = int(args.neigh) / 2, int(args.neigh) / 2 Nbonds = len(bonds) Nres = len(u.residues) timeframes, L_array = [], [] if args.filedumpskip: dumpskip = AnalyzeLog.get_dumpskip(filename='dumpskip.txt', keyparameter="dump" + args.keyparameter + "skip") timestep = AnalyzeLog.get_timestep(filename='dumpskip.txt', keyparameter="time" + args.keyparameter + "step") else: print "using given parameters" dumpskip = args.dumpskip timestep = args.timestep for ts in u.trajectory[args.startframe:args.endframe:args.trajskip]: print "frame = {frame}, percent of lamellae={num_of_lam}"\ .format(frame=ts.frame, num_of_lam=L/float(Nres)) timeframes.append(ts.frame) L = 0. for myres in u.residues: bonds = AnalyzeChain.get_bondlist_coords(myres) Flag = True # assume we hit the straight segment of the chain atom_indices = [] # indices of atoms in the current lamellae for i in xrange(nleft, Nbonds - nright - 1): if not Flag: # if we ended a straight segment, check the len Nlam = len(atom_indices) if Nlam > 9: L += 1. # print colored( 'lamellae size is %d ' % Nlam, 'green') # start looking for a new lamellae atom_indices = [] Flag = True else: # if we still are hitting straight segments ci = get_seg_cryst(i, bonds, threshold=args.threshold, neigh=args.neigh) if ci > args.threshold: # print "segment = %d, | ci = %4.3f" % (i,ci) Flag = True atom_indices.append(i) elif ci > 0.0: # print "segment = %d, > ci = %4.3f" % (i,ci) Flag = False else: ValueError("crystallinity is negative") L_array.append(L / float(Nres)) timeframes = np.array(timeframes) L_array = np.array(L_array) save_plots.save_plot(timeframes, L_array, plotname='lamellae', name=psffile, logplot=args.logplot, dumpskip=dumpskip, timestep=timestep, ylabel='frac{N_{stems}}{N_{chains}}')
def plot_points(args): """ plots stuff with points #algorithm for induction time. filenames will represent the mol weight, and will be the X axis the flag = False will represent that the crystallization has started the tcryst = will be the time of crystallization, it will be appended to tcryst_array list """ filenames = [get_path_names.get_filename(x) for x in args.collection] parameters = { 'title': args.titlename, 'xlabel': args.xlabel, 'ylabel': args.ylabel, 'dumpskip': args.dumpskip } if args.logplot: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" lines = [ u'D-', u'o-', u'^-', u'>-', u's', u'8', u'<', u'>', u'*', u'H', u'h', u'p', u'v', u'D', u'd', "-", "--", "-.", ":" ] # widths = [4, 6, 8, 10, 12] colors = ['k', 'y', 'm', 'c', 'b', 'g', 'r', '#aaaaaa'] linecycler = itertools.cycle(lines) colorcycler = itertools.cycle(colors) plt.figure() plt.ylabel('${0[ylabel]}$'.format(parameters)) plt.xlabel(r'${0[xlabel]}$'.format(parameters)) # plt.title('${0[title]}$'.format(parameters)) # plt.ylim(0,1) # plt.xlim(10,210) for (i, j) in itertools.izip(args.collection, filenames): # ChainLength = int(re.search('(\d+)n(\d+)', j).group(1)) # NumOfChains = int(re.search('(\d+)n(\d+)', j).group(2)) print j # Extra_string = (re.findall('fit(\S+)', j)) npz = np.load(i) t = npz[args.name_x] p = npz[args.name_y] # p_err = npz[args.name_z] p_err = t * 0. # p = p - p[0] clr = next(colorcycler) # namefile=get_path_names.get_filename(j) # namefile = Extra_string[0] namefile = j plt.errorbar(t, p, yerr=p_err, color=clr, fmt='o-', linewidth=1.4, label=namefile) # plt.plot(t, p, 'go-',color=clr,linewidth=1.4,label=namefile) # plt.plot(t, p, next(linecycler), # color=clr, # linewidth=1.2, # label=namefile) #, # label=r'$M_n = %d,\ N_{chains} = %d$' # % (ChainLength, NumOfChains)) # if args.legend: plt.legend(loc='best') plt.savefig('{0[title]}.pdf'.format(parameters)) return None
matplotlib.use('pgf') matplotlib.rcParams.update(pgf_with_latex) args = read_parameters.read_plot() # def plot_points(args): # """ # plots stuff with points # #algorithm for induction time. # filenames will represent the mol weight, and will be the X axis # the flag = False will represent that the crystallization has started # the tcryst = will be the time of crystallization, it will be appended # to tcryst_array list # """ filenames = [get_path_names.get_filename(x) for x in args.collection] parameters = { 'title': args.titlename, 'xlabel': args.xlabel, 'ylabel': args.ylabel, 'dumpskip': args.dumpskip } if args.logplot: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" lines = [
def main(): args = read_parameters.read_traj_vmd() print args u = MDAnalysis.Universe(args.psffile, args.traj) psffile = get_path_names.get_filename(u.filename) n_atoms_per_box = args.nAtomsPerBox Natoms = u.trajectory.numatoms Nx_atoms = Natoms**(1./3.) # how many atoms in a line Nsub = int(Nx_atoms / float(n_atoms_per_box)) # how many segements of 3 atoms cryst_all = 0.0 # box = u.trajectory.ts.dimensions[:-3] # length_x = box[-1] u.SYSTEM.packIntoBox() a = u.selectAtoms("all") c = a.coordinates() print c length_x = a.bbox().max() grid_1d = np.linspace(0.0, length_x, Nsub+1, endpoint=True) delta = grid_1d[1] - grid_1d[0] frame = [] g2 = [] if args.filedumpskip: dumpskip = AnalyzeLog.get_dumpskip(filename='dumpskip.txt', keyparameter="dump" + args.keyparameter+"skip") # dumpskip = args.dumpskip timestep = AnalyzeLog.get_timestep(filename='dumpskip.txt', keyparameter="time" + args.keyparameter + "step") else: print "using given parameters" dumpskip = args.dumpskip timestep = args.timestep # decide the skipping information if args.auto_traj_skip: trajskip = int(u.trajectory.numframes/120.) if trajskip < 1: trajskip = 1 elif args.auto_traj_skip: trajskip = args.trajskip else: raise ValueError("trajskip needs to be provided") for ts in u.trajectory[args.startframe:args.endframe:trajskip]: # ar_z is a planar selection u.SYSTEM.packIntoBox() for i, z in enumerate(grid_1d[0:-1]): ar_z = u.selectAtoms("prop z >= " + str(z) + " and prop z < " + str(z+delta)) # print " I am in z ", z # print len(ar_z) # ater this step ar_y is a line for j, y in enumerate(grid_1d[0:-1]): ar_y = ar_z.selectAtoms("prop y >= " + str(y) + " and prop y < " + str(y+delta)) # print " I am in y ", y # print len(ar_y) # ater this step ar_x is a dot for k, x in enumerate(grid_1d[0:-1]): ar_x = ar_y.selectAtoms("prop x >= " + str(x) + " and prop x < " + str(x+delta)) # print " I am in x ", x # print len(ar_x) bonds = AnalyzeChain.get_bondlist_coords(ar_x) cryst_all += get_cryst(bonds, get_eigvec(bonds), threshold=args.threshold) frame.append(ts.frame) cryst_all /= float(Nsub**3.0) g2.append(cryst_all) print "frame ", ts.frame, " cryst = ", cryst_all frame = np.array(frame) g2 = np.array(g2) # os.system("convert -delay ") save_plots.save_plot(frame, g2, plotname='YC', name=psffile, logplot=args.logplot, dumpskip=dumpskip, timestep=timestep) return None
def plot_points(args): """ plots stuff with points #algorithm for induction time. filenames will represent the mol weight, and will be the X axis the flag = False will represent that the crystallization has started the tcryst = will be the time of crystallization, it will be appended to tcryst_array list """ def plot_settings(parameters): plt.ylim(parameters['ymin'], parameters['ymax']) if parameters['xlog']: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" if parameters['ylog']: plt.yscale('log') parameters['ylabel'] = ''.join(('log', 'parameters[\'ylabel\']')) print "ylogscale" else: print "regular yscale" plt.ylabel('${0[ylabel]}$'.format(parameters)) plt.xlabel('${0[xlabel]}$'.format(parameters)) # plt.title('{0[title]}'.format(parameters)) # if parameters['plot_style'] is 'lines': # points = ["-", "--", "-.", ":"] # elif parameters['plot_style'] is 'points': # points = [u'D', u'o', u'^', u'>', u's', u'8', # u'<', u'>', u'*', # u'H', u'h', u'p', u'v', u'D', # u'd', "-", "--", "-.", ":"] # # # else: points = [ u'D-', u'o-', u'^-', u'>-', u's-', u'8-', u'<-', u'>-', u'*-', u'H', u'h', u'p', u'v', u'D', u'd', "-", "--", "-.", ":" ] colors = ['k', 'y', 'm', 'c', 'b', 'g', 'r', '#aaaaaa'] lines = ["-", "--", "-.", ":"] return points, lines, colors # read file.param for the plot parameters and put them to parameters parameters = plot_read_file.read_plot_parameters(args) # read file.in, maybe parse the chain info, reutrn the chain_info_parse chain_info_parse = parameters['parse_chain_info'] if chain_info_parse is True: all_files_info_list = plot_read_file.parse_file_info(args.input) elif chain_info_parse is False: all_files_info_list = plot_read_file.simple_parse_file_info(args.input) else: raise ValueError('specify whether you need to parse chain info?') # initialize figure, do the plot parameters, and specify lines, .. plt.figure(figsize=(8, 7)) points, lines, colors = plot_settings(parameters) linecycler = itertools.cycle(lines) pointscycler = itertools.cycle(points) colorcycler = itertools.cycle(colors) chi0_array, kappa_array, n_avrami_array, mw_array = [], [], [], [] chi0_array_error = [] chis_array = [] # loop through files listed and do the plotting for i, file_i in enumerate(all_files_info_list): # print "doing", file_i filename_i = all_files_info_list[i]['npzfile'] npz = np.load(filename_i) t = npz['arr_0'] x = npz['arr_1'] x -= x[0] # t = # normalizing t to be from 0, 0.3 # t /= t.max() # t *= 0.3 print x if parameters['scale_dump'] is True: # then scale the result data # so the final data represents to the 10^6 lj untis values t *= parameters['timestep'] * parameters['dumpskip'] / 1e6 else: print "Using raw data without time scaling" #x = x - x[0] # print p print t clr, llr, plr = next(colorcycler), next(linecycler), next(pointscycler) if parameters['parse_chain_info'] is True: fileNinfo_i = all_files_info_list[i]['chains_info'] extrainfo_i = all_files_info_list[i]['extrastring'] # pdiinfo_i = all_files_info_list[i]['PDI'] result_name = '' for Mn, Nch in fileNinfo_i: result_name += 'M_n = ' result_name += str(Mn) result_name += 'N_{chains} = ' result_name += str(Nch) result_name += ';' # label_i = '${result_name}\ PDI={PDI};{extra}$'.format( # result_name=result_name, PDI=pdiinfo_i, extra=extrainfo_i) label_i = '${result_name}{extra}$'.format(result_name=result_name, extra=extrainfo_i) # label_i = '${result_name}$'.format( # result_name=result_name) else: result_name = all_files_info_list[i]['npzfile'] result_name = get_path_names.get_filename(result_name) label_i = '${result_name}$'.format(result_name=result_name) mw, _ = fileNinfo_i[0] # append M_w info to the list mw_array.append(mw) x0 = x.max() xs = max(get_x0_extrapolation(t[-10:], x[-10:]), x.max()) chi0_array.append(x0) chis_array.append(xs) chi0_array_error.append(abs(xs - x0)) # if parameters['fit'] is True: # # fitting # # deltaf/f <= sqrt(deltachi/chi^2 + chi0^2deltakappa/kappa # # chi0^2deltan/n) # # chi0 < = 1, thererfore i need just module of the whole thing # # this is the estimate of the partial derivatives df/dx # # # print "fitting data" # if parameters['parse_chain_info'] is False: # raise ValueError('specify that\ # you need to parse chain info, to get M_w information') # # # x0 = x.max() # x0 = max(get_x0_extrapolation(t[-10:], x[-10:]),x.max()) # # plt.clf() # x0_err = 0. # x /= x0 # t0 = t[np.where(x>0.01)[0][0]] # print "t0 = ", t0 # # (tfitted, xfitted), fit_params, fit_params_err, fit_chi = fit.fit(fitting_function, t, x, default_pars = [20., 3.]) # (tfitted, xfitted), fit_params, fit_params_err, fit_chi = fit.fit(fitting_function, t[x>0.01], x[x>0.01], default_pars = [10.]) # # # print "total error %f" % fit_chi # # print "errors", np.sqrt(np.diag(pcov_p)) # print "x0 = ", x0, " +- ", x0_err # print "kappa = ", fit_params[0], " +- ", fit_params_err[0] # # print "n_avrami = ", fit_params[1], " +- ", fit_params_err[1] # chi0_array.append(x0) # kappa_array.append(fit_params[0]) # # n_avrami_array.append(fit_params[1]) # mw, _ = fileNinfo_i[0] # append M_w info to the list # mw_array.append(mw) # if parameters['normalize'] is True: # print "normalizing data" # # if parameters['fit'] is True: # # raise ValueError('fit and normalize are non-compatible') # p /= p.max() # if chain_info_parse is True: # plt.plot(t, p, plr, # color=clr, # linewidth=1.8, # alpha=0.9, # label=label_i) # else: # plt.plot(t, p, llr, # color=clr, # linewidth=2.3, # alpha=0.95, # label=label_i) if chain_info_parse is True: plt.plot(t, x, llr, color=clr, linewidth=2.4, markevery=100, alpha=0.99, label="n = " + str(mw)) if parameters['fit'] is True: if parameters['normalize'] is True: raise ValueError('fit and normalize are non-compatible') plt.plot(t, fitting_function(fit_params, t), '-', color=clr, linewidth=4.2) # plt.fill_between(t, # func(t, chi0, kappa, n_avrami)*(1.-tot_fit_err), # func(t, chi0, kappa, n_avrami)*(1.+tot_fit_err), # alpha=0.08, color=clr) if chain_info_parse is True: plt.plot(t, x, plr, color=clr, linewidth=1.8, alpha=0.7, label=label_i) else: plt.plot(t, x, llr, color=clr, linewidth=2.0, alpha=0.95, label=label_i) if parameters['legend'] is True: # plt.legend(loc='best', prop={'size': 12}) plt.legend(loc='best') print parameters if parameters['fit'] is True: chi0_array, kappa_array, n_avrami_array, mw_array =\ np.asarray(chi0_array),\ np.asarray(kappa_array),\ np.asarray(n_avrami_array),\ np.asarray(mw_array) print "chi0", chi0_array print "kappa", kappa_array print "n_avrami", n_avrami_array print "mw", mw_array np.savez('fit_data_chi0', mw_array, chi0_array) np.savez('fit_data_kappa', mw_array, kappa_array) np.savez('fit_data_n', mw_array, n_avrami_array) # np.savetxt('myfile.txt', np.c_[x,y,z]) # np.savetxt('parameters_{0[name]}.txt'.format(parameters), # np.c_[mw_array, chi0_array, kappa_array, n_avrami_array], # delimiter='\t', newline='\n', fmt='%.4f') chi0_array, chis_array, chi0_array_error, mw_array =\ np.asarray(chi0_array),\ np.asarray(chis_array),\ np.asarray(chi0_array_error),\ np.asarray(mw_array) np.savetxt(extrainfo_i + 'fit_data_Mn_chi0_delta.csv', np.c_[mw_array, chi0_array, chis_array, chi0_array_error], delimiter=',') plt.savefig('{0[plotname]}{0[name]}.pdf'.format(parameters)) return None
def plot_points(args): """ plots stuff with points #algorithm for induction time. filenames will represent the mol weight, and will be the X axis the flag = False will represent that the crystallization has started the tcryst = will be the time of crystallization, it will be appended to tcryst_array list """ def plot_settings(parameters): plt.ylim(parameters['ymin'], parameters['ymax']) if parameters['xlog']: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" if parameters['ylog']: plt.yscale('log') parameters['ylabel'] = ''.join(('log', 'parameters[\'ylabel\']')) print "ylogscale" else: print "regular yscale" plt.ylabel('${0[ylabel]}$'.format(parameters)) plt.xlabel('${0[xlabel]}$'.format(parameters)) # plt.title('{0[title]}'.format(parameters)) # if parameters['plot_style'] is 'lines': # points = ["-", "--", "-.", ":"] # elif parameters['plot_style'] is 'points': # points = [u'D', u'o', u'^', u'>', u's', u'8', # u'<', u'>', u'*', # u'H', u'h', u'p', u'v', u'D', # u'd', "-", "--", "-.", ":"] # # # else: points = [ u'D-', u'o-', u'^-', u'>-', u's-', u'8-', u'<-', u'>-', u'*-', u'H', u'h', u'p', u'v', u'D', u'd', "-", "--", "-.", ":" ] colors = ['k', 'y', 'm', 'c', 'b', 'g', 'r', '#aaaaaa'] lines = ["-", "--", "-.", ":"] return points, lines, colors # read file.param for the plot parameters and put them to parameters parameters = read_plot_parameters(args) # read file.in, maybe parse the chain info, reutrn the chain_info_parse chain_info_parse = parameters['parse_chain_info'] if chain_info_parse is True: all_files_info_list = parse_file_info(args.input) elif chain_info_parse is False: all_files_info_list = simple_parse_file_info(args.input) else: raise ValueError('specify whether you need to parse chain info?') # initialize figure, do the plot parameters, and specify lines, .. plt.figure(figsize=(8, 7)) points, lines, colors = plot_settings(parameters) linecycler = itertools.cycle(lines) pointscycler = itertools.cycle(points) colorcycler = itertools.cycle(colors) chi0_array, kappa_array, n_avrami_array, mw_array = [], [], [], [] # loop through files listed and do the plotting for i, file_i in enumerate(all_files_info_list): # print "doing", file_i filename_i = all_files_info_list[i]['npzfile'] # Extra_string = int(re.search('ICC(\s)(\d+)n(\d+)', j).group(1)) npz = np.load(filename_i) t = npz['arr_0'] p = npz['arr_1'] if parameters['scale_dump'] is True: # then scale the result data # so the final data represents to the 10^6 lj untis values t *= parameters['timestep'] * parameters['dumpskip'] / 1e6 else: print "Using raw data without time scaling" p = p - p[0] # print p print t clr, llr, plr = next(colorcycler), next(linecycler), next(pointscycler) if parameters['parse_chain_info'] is True: fileNinfo_i = all_files_info_list[i]['chains_info'] extrainfo_i = all_files_info_list[i]['extrastring'] # pdiinfo_i = all_files_info_list[i]['PDI'] result_name = '' for Mn, Nch in fileNinfo_i: result_name += 'M_n = ' result_name += str(Mn) result_name += 'N_{chains} = ' result_name += str(Nch) result_name += ';' # label_i = '${result_name}\ PDI={PDI};{extra}$'.format( # result_name=result_name, PDI=pdiinfo_i, extra=extrainfo_i) label_i = '${result_name}{extra}$'.format(result_name=result_name, extra=extrainfo_i) # label_i = '${result_name}$'.format( # result_name=result_name) else: result_name = all_files_info_list[i]['npzfile'] result_name = get_path_names.get_filename(result_name) label_i = '${result_name}$'.format(result_name=result_name) if parameters['fit'] is True: # fitting # deltaf/f <= sqrt(deltachi/chi^2 + chi0^2deltakappa/kappa # chi0^2deltan/n) # chi0 < = 1, thererfore i need just module of the whole thing # this is the estimate of the partial derivatives df/dx # print "fitting data" if parameters['parse_chain_info'] is False: raise ValueError('specify that\ you need to parse chain info, to get M_w information') opt_p, pcov_p = scipy.optimize.curve_fit(func, t, p) # calculate error of each parameter using variance == diagonal # elements of covariance matrix chi0_err, kappa_err, n_avrami_err = np.sqrt(np.diag(pcov_p)) tot_fit_err = np.linalg.norm(np.diag(pcov_p) / opt_p) print "total error %f" % tot_fit_err print "errors", np.sqrt(np.diag(pcov_p)) chi0, kappa, n_avrami = opt_p chi0_array.append(chi0) kappa_array.append(kappa) n_avrami_array.append(n_avrami) mw, _ = fileNinfo_i[0] # append M_w info to the list mw_array.append(mw) print "saturation", chi0 print "kappa ", kappa # if parameters['normalize'] is True: # print "normalizing data" # # if parameters['fit'] is True: # # raise ValueError('fit and normalize are non-compatible') # p /= p.max() # if chain_info_parse is True: # plt.plot(t, p, plr, # color=clr, # linewidth=1.8, # alpha=0.9, # label=label_i) # else: # plt.plot(t, p, llr, # color=clr, # linewidth=2.3, # alpha=0.95, # label=label_i) if parameters['fit'] is True: if parameters['normalize'] is True: raise ValueError('fit and normalize are non-compatible') plt.plot(t, func(t, chi0, kappa, n_avrami), '-', color=clr, linewidth=4.2) plt.fill_between( t, func(t, chi0, kappa, n_avrami) * (1. - tot_fit_err), func(t, chi0, kappa, n_avrami) * (1. + tot_fit_err), alpha=0.08, color=clr) if chain_info_parse is True: plt.plot(t, p, plr, color=clr, linewidth=1.8, alpha=0.7, label=label_i) else: plt.plot(t, p, llr, color=clr, linewidth=2.0, alpha=0.95, label=label_i) else: if parameters['normalize'] is True: print "normalizing data" p /= p.max() if chain_info_parse is True: plt.plot(t, p, plr, color=clr, linewidth=1.8, alpha=0.6, label=label_i) else: plt.plot(t, p, plr, color=clr, linewidth=2.8, alpha=0.9, label=label_i) # plt.plot(t, p, llr, # color=clr, # linewidth=2.0, # alpha=0.95, # label=label_i) if parameters['legend'] is True: # plt.legend(loc='best', prop={'size': 12}) plt.legend(loc='best') print parameters if parameters['fit'] is True: chi0_array, kappa_array, n_avrami_array, mw_array =\ np.asarray(chi0_array),\ np.asarray(kappa_array),\ np.asarray(n_avrami_array),\ np.asarray(mw_array) print "chi0", chi0_array print "kappa", kappa_array print "n_avrami", n_avrami_array print "mw", mw_array np.savez('fit_data_chi0', mw_array, chi0_array) np.savez('fit_data_kappa', mw_array, kappa_array) np.savez('fit_data_n', mw_array, n_avrami_array) # np.savetxt('myfile.txt', np.c_[x,y,z]) np.savetxt('parameters_{0[name]}.txt'.format(parameters), np.c_[mw_array, chi0_array, kappa_array, n_avrami_array], delimiter='\t', newline='\n', fmt='%.4f') plt.savefig('{0[plotname]}{0[name]}.pdf'.format(parameters)) return None
def plot_mpl_fig(): """ plots stuff with points #algorithm for induction time. filenames will represent the mol weight, and will be the X axis the flag = False will represent that the crystallization has started the tcryst = will be the time of crystallization, it will be appended to tcryst_array list """ args = read_parameters.read_from_file() def plot_settings(parameters): # read_files('file.txt') # read_files(args) plt.ylim(parameters['ymin'], parameters['ymax']) if parameters['xlog']: plt.xscale('log') parameters['xlabel'] = ''.join(('log', 'parameters[\'xlabel\']')) print "xlogscale" else: print "regular xscale" if parameters['ylog']: plt.yscale('log') parameters['ylabel'] = ''.join(('log', 'parameters[\'ylabel\']')) print "ylogscale" else: print "regular yscale" plt.ylabel('${0[ylabel]}$'.format(parameters)) plt.xlabel('${0[xlabel]}$'.format(parameters)) points = [ u'D-', u'o-', u'^-', u'>-', u's-', u'8-', u'<-', u'>-', u'*-', u'H', u'h', u'p', u'v', u'D', u'd', "-", "--", "-.", ":" ] colors = ['k', 'y', 'm', 'c', 'b', 'g', 'r', '#aaaaaa'] lines = ["-", "--", "-.", ":"] return points, lines, colors # read file.param for the plot parameters and put them to parameters parameters = plot_read_file.read_plot_parameters(args) # read file.in, maybe parse the chain info, reutrn the chain_info_parse chain_info_parse = parameters['parse_chain_info'] if chain_info_parse is True: all_files_info_list = plot_read_file.parse_file_info(args.input) elif chain_info_parse is False: all_files_info_list = plot_read_file.simple_parse_file_info(args.input) else: raise ValueError('specify whether you need to parse chain info?') # initialize figure, do the plot parameters, and specify lines, .. plt.figure(figsize=(8, 7)) points, lines, colors = plot_settings(parameters) linecycler = itertools.cycle(lines) pointscycler = itertools.cycle(points) colorcycler = itertools.cycle(colors) # loop through files listed and do the plotting for i, file_i in enumerate(all_files_info_list): # print "doing", file_i filename_i = all_files_info_list[i]['npzfile'] npz = np.load(filename_i) t = npz['arr_0'] x = npz['arr_1'] is_with_error_bars = True try: error_array = npz['arr_2'] except Exception: print "doing Exception" is_with_error_bars = False pass # t = print x if parameters['scale_dump'] is True: # then scale the result data # so the final data represents to the 10^6 lj untis values t *= parameters['timestep'] * parameters['dumpskip'] / 1e6 else: print "Using raw data without time scaling" # print p print t clr, llr, plr = next(colorcycler), next(linecycler), next(pointscycler) result_name = all_files_info_list[i]['npzfile'] result_name = get_path_names.get_filename(result_name) label_i = '${result_name}$'.format(result_name=result_name) if is_with_error_bars: # plt.errorbar(t, x, # yerr=error_array, # color=clr, # linewidth=1.8, # label=label_i) plt.plot(t, x, color=clr, linewidth=1.8, label=label_i) plt.errorbar(t, error_array, color=clr, linewidth=1.8, label='error' + label_i) else: x = x - x[0] plt.plot(t, x, plr, color=clr, linewidth=1.8, alpha=0.7, label=label_i) print parameters return None