def read_control(filename, atoms): f = open(filename) for line in f: if "$grad cartesian gradients" in line: break en = 0 grads = [] first_step = True while(True): line = f.next() if not first_step and '$last' in line or '$actual' in line: f.close() return grads, en if '$end' in line: f.close() return grads, en if 'maximum norm' in line: f.close() return grads, en en = float64(line.split('=')[2].split()[0]) for at, line in zip(atoms, f): pass # if at[3] != line.split()[3]: # print at[3], line.split()[3] grads = [] for at, line in zip(atoms, f): aux = line.replace('D', 'e').replace('d', 'e').split()[0:3] grads += [[float64(g) for g in aux]] first_step = False
def wr_abs_cal_gui_file_to_scipy_array(filename): """ Retrieve the White Rabbit GUI info which is written during Absolute Calibration filename -- source file from which to retrieve data. returns: <type 'numpy.ndarray'> measurements """ data_file = open(filename, "r") # header = data_file.read(5) # read the waveform_header "wrc# " #if header != "wrc# ": #print("Exception: wr_abs_cal_gui_file_to_scipy_array: Not a WR Absolute Calibration GUI file.") #Exception("wr_abs_cal_gui_file_to_scipy_array: Not a WR Absolute Calibration GUI file.") #data_file.close() #return # create an empty gui_data dictionairy gui_data = {} # create an empty lists for t1 and t4 components lst_t1_sec = [] lst_t1 = [] lst_t4_sec = [] lst_t4 = [] while 1: line = data_file.readline() line_lst = line.split(" ") if len(line_lst) < 6: break # Values one one line are: # t1 sec, t1[ns], t1_phase[ps], t4 sec, t4[ns], t4_phase[ps] # to calculate proper t1 and t4 # ns must be scaled 1e-9 and phase scaled with 1e-12 lst_t1_sec.append(line_lst[0]) lst_t1.append(1e-9 * scipy.float64(line_lst[1]) + 1e-12 * scipy.float64(line_lst[2])) lst_t4_sec.append(line_lst[3]) lst_t4.append(1e-9 * scipy.float64(line_lst[4]) + 1e-12 * scipy.float64(line_lst[5])) data_file.close() t1_sec = scipy.array(lst_t1_sec) t1 = scipy.array(lst_t1) t4_sec = scipy.array(lst_t4_sec) t4 = scipy.array(lst_t4) gui_data["t1 seconds"] = (t1_sec) gui_data["t1"] = (t1) gui_data["t4 seconds"] = (t4_sec) gui_data["t4"] = (t4) return gui_data
def glmnetControl(pars=None): import scipy # default options ivals = dict() ivals["fdev"] = scipy.float64(1e-5) ivals["devmax"] = scipy.float64(0.999) ivals["eps"] = scipy.float64(1e-6) ivals["big"] = scipy.float64(9.9e35) ivals["mnlam"] = scipy.float64(5) ivals["pmin"] = scipy.float64(1e-5) ivals["exmx"] = scipy.float64(250) ivals["prec"] = scipy.float64(1e-10) ivals["mxit"] = scipy.float64(100) # quick return if no user opts if pars == None: return ivals # if options are passed in by user, update options with values from opts parsInIvals = set(pars.keys()) - set(ivals.keys()) if len(parsInIvals ) > 0: # assert 'opts' keys are subsets of 'options' keys raise ValueError( 'attempting to set glmnet controls that are not known to glmnetControl' ) else: ivals = {**ivals, **pars} # update values return ivals
def lassotrans(beta, w, y, omega, lam, eta, offset): n = y.shape[0] expterm = np.exp(np.matmul(w, beta)-offset - np.matmul(np.matmul(np.transpose(beta), omega), beta)/2) omegabeta = np.matmul(omega, beta) omegabeta = omegabeta[np.newaxis, :] dLbeta = -(np.matmul(np.transpose(y), w) - np.matmul(np.transpose(expterm), (w - omegabeta)))/n Y = p * np.sqrt(eta/2) * (beta - dLbeta/(eta)) X = p * np.eye(p) * np.sqrt(eta/2) fit = glmnet(x = scipy.float64(X), y = scipy.float64(Y), lambdau = scipy.float64([lam]), intr = False) beta = np.array(glmnetCoef(fit, s= scipy.float64([0])))[1:, 0]#clf.coef_ return beta
def fixed_point(t, M, I, a2): l=7 I = sci.float64(I) M = sci.float64(M) a2 = sci.float64(a2) f = 2*sci.pi**(2*l)*sci.sum(I**l*a2*sci.exp(-I*sci.pi**2*t)) for s in range(l, 1, -1): K0 = sci.prod(range(1, 2*s, 2))/sci.sqrt(2*sci.pi) const = (1 + (1/2)**(s + 1/2))/3 time=(2*const*K0/M/f)**(2/(3+2*s)) f=2*sci.pi**(2*s)*sci.sum(I**s*a2*sci.exp(-I*sci.pi**2*time)) return t-(2*M*sci.sqrt(sci.pi)*f)**(-2/5)
def fixed_point(t, M, I, a2): l = 7 I = scipy.float64(I) M = scipy.float64(M) a2 = scipy.float64(a2) f = 2 * scipy.pi**(2 * l) * scipy.sum(I**l * a2 * scipy.exp(-I * scipy.pi**2 * t)) for s in range(l, 1, -1): K0 = scipy.prod(range(1, 2 * s, 2)) / scipy.sqrt(2 * scipy.pi) const = (1 + (1 / 2)**(s + 1 / 2)) / 3 time = (2 * const * K0 / M / f)**(2 / (3 + 2 * s)) f = 2 * scipy.pi**(2 * s) * scipy.sum(I**s * a2 * scipy.exp(-I * scipy.pi**2 * time)) return t - (2 * M * scipy.sqrt(scipy.pi) * f)**(-2 / 5)
def repeat_EN_csv(data_csv, reps=50, shuffle_mark=False): # repeated_cross_validate(clf_in,X,y,cv_fold=10,rep=50) csv_name, ext = os.path.splitext(data_csv) all_data = pd.read_csv(data_csv) y = np.array((all_data['y'])) fs = np.array(all_data.drop(columns=['y'])) results = repeated_cross_validate(glmnet_wrapper(), scipy.float64(fs), scipy.float64(y), cv_fold=10, rep=reps, shuffle_y=shuffle_mark) return results
def drawMap(self): self.g = geoplotter.GeoPlotter() self.g.clear() self.g.drawWorld() edge_list = [] #edge_list=self.edge_df[["start_lon","start_lat","end_lon","end_lat"]].values.tolist() #pdb.set_trace() # draw the network for edge in self.gd.edges(): start = tuple([scipy.float64(j) for j in edge[0].split(" ")]) end = tuple([scipy.float64(j) for j in edge[1].split(" ")]) edge_list.append([start, end]) self.g.drawLines(edge_list, color='cornflowerblue')
def readMultipleColumnsCSV(delimiter=',', fileName ='.csv',nHeaderLines=1): data=dict() data['name'] = fileName #with open(fileName, newline='', encoding='utf-8','rb') as f: with open(fileName, newline='', encoding='utf-8') as f: #reader=csv.reader(f, delimiter=delimiter) reader=csv.reader(f) dataList=list() nRows=0 nRead=0 # Skip the first nHeaderLines nCols=0 for row in reader: nRead=nRead+1 if nRead== nHeaderLines: break for row in reader: #aa=sc.float64(row) dataList.append(row) print(row) nCols = sc.maximum(nCols,len(row)) nRows=nRows+1 dataList = sc.array(dataList).transpose() dd = list() for c in sc.arange(nCols): x= dataList[c] print(x) rr= 0 for r in sc.arange(nRows): xx=dataList[c][r] if len(xx)>0: rr=rr+1 else: print(xx) dd.append(sc.zeros(rr)) for r in sc.arange(rr): xx=dataList[c][r] if len(xx)>0: print(sc.float64(xx)) dd[c][r]=sc.float64(xx) rr=rr+1 else: print(xx) data['values']= dd data['nRows']= nRows data['nCols']= nCols f.close() return data
def readTestResourceData(self, fileDataPath, testInstanceDict): with open(fileDataPath, "r") as bufferFile: currentData = bufferFile.readline() index = 0 while len(currentData) != 0: currentData = str(currentData).strip() decoyList = currentData.split(sep="\t") if len(decoyList) == 3: instanceKey = int(decoyList[0]) vectorInstance = [] for valueItem in str(decoyList[2]).split(sep=","): vectorInstance.append(float64(valueItem)) self.x_TestInstance.update({index: vectorInstance}) self.y_TestInstance.update({index: instanceKey}) tier1BufferDict = {} if testInstanceDict.__contains__(instanceKey): tier1BufferDict = testInstanceDict.get(instanceKey) tier2BufferDict = {} if tier1BufferDict.__contains__(decoyList[1]): tier2BufferDict.update( {decoyList[1]: tier1BufferDict.get(decoyList[1])}) if len(tier2BufferDict) > 0: self.testInstanceId.update({index: tier2BufferDict}) else: print("resource error in test instance ", decoyList[1]) sys.exit(0) #print(currentData,"\t",index) index = index + 1 currentData = bufferFile.readline() return ()
def get_keff(self, bg2): """Find the eigenvalue in a homogenous material Parameter: ---------- bg2: float, optional; geometric buckling [Default: 0.0] Returns: -------- keff: float; the multiplication factor/eigenvalue """ if not self.is_fissionable: return 0.0 elif self.ngroups == 1: return scipy.float64(self.nu_sigma_f / (self.sigma_a + self.d * bg2)) elif self.ngroups == 2: ratio = self.flux_ratio(bg2) r1 = self.sigma_a[0] + self.sigma_s12 return (self.nu_sigma_f[0] + self.nu_sigma_f[1]/ratio)/ \ (self.d[0]*bg2 + r1) else: errstr = "k_inf calculation is only available for 1 or 2 groups." raise NotImplementedError(errstr)
def full_weighted_cv(X, y, Ds, lambda_gtv=np.linspace(.1, 1, 10), lambda_lasso=None, t=50, auto_cv=True, alpha=.9, k=5): errors = [] X_train, X_test, y_train, y_test = temporal_split(X, y, t) if alpha<1: n = X_train.shape[0] weights = np.array([alpha**(n-t) for t in np.arange(1, n+1)]) X_train = X_train * np.sqrt(weights.reshape(-1,1)) y_train = y_train * np.sqrt(weights) n,p = X_train.shape # test errors for l1 in lambda_gtv: for m in Ds: D = Ds[m] if auto_cv: XD, bigY, invD = augmented_system_lasso(X_train, y_train, D, l1, 0, l1_only=True) fit = cvglmnet(x = XD, y = bigY, family = 'gaussian', ptype = 'mse', nfolds = 5) b = cvglmnetCoef(fit, s = 'lambda_min') l3 = fit['lambda_min'][0] beta = [email protected](b.shape[0])[1:] mset, r2t = compute_errors(y_train, X_train@beta) mse, r2 = compute_errors(y_test, X_test@beta) errors.append([m, l1, l3, mset, r2t, mse, r2]) else: for l3 in lambda_lasso: XD, bigY, invD = augmented_system_lasso(X_train, y_train, D, l1/l3, 0, l1_only=True) #XD, bigY, invD = epsilon_system_lasso(X_train, y_train, D, l1) fit = glmnet(x = XD, y = bigY) b = glmnetCoef(fit, s = scipy.float64([l3]), exact = False) beta = [email protected](b.shape[0])[1:] mset, r2t = compute_errors(y_train, X_train@beta) mse, r2 = compute_errors(y_test, X_test@beta) errors.append([m, l1, l3, mset, r2t, mse, r2]) df = pd.DataFrame(errors, columns=['method', 'lambda_tv', 'lambda_1', 'train_mse', 'train_r2', 'test_mse', 'test_r2']) return df
def _get_spacing(self): # Find Network spacing P12 = self["throat.conns"] C12 = self["pore.coords"][P12] mag = np.linalg.norm(np.diff(C12, axis=1), axis=2) unit_vec = np.around(np.squeeze(np.diff(C12, axis=1)) / mag, decimals=14) spacing = [0, 0, 0] dims = topotools.dimensionality(self) # Ensure vectors point in n-dims unique directions c = {tuple(row): 1 for row in unit_vec} if len(c.keys()) > sum(dims): raise Exception("Spacing is undefined when throats point in " + "more directions than network has dimensions") mag = sp.float64(mag.squeeze()) for ax in [0, 1, 2]: if dims[ax]: inds = np.where(unit_vec[:, ax] == unit_vec[:, ax].max())[0] temp = np.unique(mag[inds]) if not np.allclose(temp, temp[0]): raise Exception( "A unique value of spacing could not be found") else: spacing[ax] = temp[0] return np.array(spacing)
def fit_with_lmfit(self, method='lbfgsb', conf='covar', report=True): try: import lmfit_wrapper as lw except ImportError: print 'Could not import LMfit' return x, data, errs = self.set_fit_data() result = lw.fit_it(self.params, args=(self.x[self.fitrange], self.indata[self.fitrange], self.errs[self.fitrange]), method=method) if report: lw.lf.report_fit(result) output = lw.params_to_grism(result, output_format='df') output['Identifier'] = self.tofit['Identifier'] output.set_value('Contin', 'Identifier', sp.float64('nan')) output['Pos'] -= self.tofit['Line center'] outdict = {} for i in output.index: row = output.ix[i] if i == 'Contin': outdict[i] = [row['Ampl'], row['Ampl_stddev'], row['RedChi2']] else: outdict[i] = [ row['Pos'], row['Sigma'], row['Ampl'], row['Identifier'], row['Pos_stddev'], row['Sigma_stddev'], row['Ampl_stddev'] ] self.Components = outdict self.import_model() self.result = result self.output = output
def read_csv_col(self, phenotype_filepath, colnr, colprefix="", sep='\t'): log.info("reading phenotypes: {}, colnr: {}".format( phenotype_filepath, colnr)) with open(phenotype_filepath, 'r') as phenofile: hcols = phenofile.readline().strip().split(sep) ids = [] vals = [] for l in phenofile: dcols = l.strip().split(sep) try: vals.append(sp.float64(dcols[colnr])) ids.append(dcols[0]) except ValueError: log.warn( "excluding accession {} because of trait value: {}". format(dcols[0], dcols[colnr])) continue tmp_data = pd.DataFrame(vals) tmp_data.index = ids tmp_data.columns = ["_".join([colprefix, hcols[colnr]])] if self.data.size == 0: self.data = tmp_data else: self.data = pd.concat([self.data, tmp_data], join='inner', axis=1) log.info("phenotype intersection is {} accessions.".format( self.data.shape[0])) # self.data.sort_index(inplace=True, key=float); return
def create_image_and_mask(imagefilename, maskfilename): # import a clean input to be corrupted with the mask input = mpimg.imread(imagefilename) if input.ndim == 3: M, N, C = input.shape else: M, N = input.shape C = 1 # import the mask of the inpainting domain # mask = 1 intact part # mask = 0 missing domain mask = scipy.float64((mpimg.imread(maskfilename) == 1)) if (input.ndim == 3) & (mask.ndim < 3): mask = np.repeat(mask[:, :, np.newaxis], C, axis=2) if C == 1: input = scipy.expand_dims(input, axis=2) mask = scipy.expand_dims(mask, axis=2) # create the image with the missin domain: noise = scipy.rand(M, N, C) u = mask * input + (1 - mask) * noise return (u, mask)
def readTrainingResourceData(self, fileDataPath): with open(fileDataPath, "r") as bufferFile: currentData = bufferFile.readline() index = 0 while len(currentData) != 0: currentData = str(currentData).strip() decoyList = currentData.split(sep="\t", maxsplit=1) if len(decoyList) == 2: instanceKey = int(decoyList[0]) vectorInstance = [] for valueItem in str(decoyList[1]).split(sep=","): vectorInstance.append(float64(valueItem)) self.x_instance.update({index: vectorInstance}) self.y_instance.update({index: instanceKey}) if (index == 0): self.instanceSpan = len(vectorInstance) if (len(vectorInstance) < self.instanceSpan): print(index) sys.exit() #print(currentData,"\t",index) index = index + 1 currentData = bufferFile.readline() self.crossValidationSplit() return ()
def readTrainingResourceData(self, fileDataPath): with open(fileDataPath, "r") as bufferFile: currentData = bufferFile.readline() index = 0 while len(currentData) != 0: currentData = str(currentData).strip() decoyList = currentData.split(sep="\t") if len(decoyList) == 3: instanceKey = int(decoyList[0]) vectorList = list( map(lambda valueItem: float64(valueItem), list(str(decoyList[2]).split(sep=",")))) vectorInstance = np.array(vectorList) self.x_instance.update({index: vectorInstance}) self.y_instance.update({index: instanceKey}) if (index == 0): self.instanceSpan = vectorInstance.shape[0] self.featureDimension = self.windowSize if (vectorInstance.shape[0] < self.instanceSpan): print(index) sys.exit() #print(currentData,"\t",index) index = index + 1 currentData = bufferFile.readline() self.crossValidationSplit() return ()
def plot_curr(self): """Plotet anhand der eingebenen Zeilennummer""" ######## plot a 3D Current ######## fig = plt.figure(figsize=plt.figaspect(0.5)) canvas = FigureCanvasTkAgg(fig, master=page3) canvas.get_tk_widget().pack(side='top', fill='both') canvas._tkcanvas.pack(side='top', fill='both', expand=15) toolbar = NavigationToolbar2TkAgg(canvas, page3) canvas.get_tk_widget().grid(row=1,column=1) toolbar.grid(row=50,column=1) ax = fig.add_subplot(1, 2, 1, projection='3d') X = sp.linspace(0,10,10) Y = sp.linspace(0,10,10) X, Y = sp.meshgrid(X, Y) X, Y = X.ravel(), Y.ravel() #R = sp.sqrt(X**2 + Y**2) #Z = sp.sin(R) width = depth = 1 bottom=X*0. #plt.ion() getrow=int(entryrowplot.get()) current_floats=sp.float64(self.data_str['current'][getrow].split(";")).reshape(10,10) maxcurr= np.max(current_floats) #print sp.mean(current_floats) top=current_floats.ravel() top_scaled=(top-sp.amin(top))/(sp.amax(top)-sp.amin(top)) mycolors = cm.jet(top_scaled) ax.bar3d(X, Y, bottom, width, depth, top,color=mycolors, alpha=float(entryTrans.get())) ax.set_title('Partial Currents @ '+self.data_str['sumcurr'][getrow]+' A'+'// @ '+self.data['voltage'][getrow]+' V') ax.set_zlim(0,maxcurr) ax.set_zlabel('Current in A', linespacing=10.4) ax.view_init(elev=int(entryCurrEval.get()), azim=int(entryCurrAngle.get())) #plt.show() fig = plt.figure() #plt.clf() plt.show() plt.gcf().canvas.draw() currplot = ts.strftime("%Y.%m.%d. %H:%M:%S :")+"Current dargestellt" self.displaystate.insert(tk.END, currplot+'\n')
def getSPNetworkx(self, startnode, destnode, find=True): if find: startnode = self.findClosestNode(*startnode) destnode = self.findClosestNode(*destnode) path = networkx.shortest_path(self.gd, startnode, destnode, 'time') path = [tuple([scipy.float64(j) for j in x.split(" ")]) for x in path] return zip(path, path[1:])
def __init__(self, kdim, depth, algo, seed, codes): assert(kdim == 2) self.kdim = kdim self.depth = depth self.algo = algo self.seed = seed self.codes = codes self.indptr = sp.cumsum(sp.bincount(codes + 1, minlength=(self.nr_codes + 1)), dtype=sp.uint64) self.indices = sp.argsort(codes * sp.float64(self.nr_elements) + sp.arange(self.nr_elements))
def findClosestNode(self, lon, lat): min_dist = scipy.inf min_point = [] for i_point in self.gd.nodes(): start = tuple([scipy.float64(j) for j in i_point.split(" ")]) dist = (start[0] - lon)**2 + (start[1] - lat)**2 if dist < min_dist: min_dist = dist min_point = i_point return min_point
def once_csv_pred_test(data_csv): csv_name, ext = os.path.splitext(data_csv) start_time = time.time() all_data = pd.read_csv(data_csv) y = np.array(all_data['y']) fs = np.array(all_data.drop(columns=['y'])) clf = glmnet_wrapper() y_pred = cross_val_predict(clf, scipy.float64(fs), scipy.float64(y), cv=10, n_jobs=-1) r_value, p_value = scipy.stats.pearsonr(y_pred, y) e = int(time.time() - start_time) e_time = '{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60) with open('appending_results.txt', 'a+') as fo: fo.write('\r\n filename---{} r---: {} p---: {} time--: {} \r\n'.format( csv_name, r_value, p_value, e_time)) return r_value, p_value, e_time
def file_to_scipy_array(filename): """ Retrieve the Keysight 53230A Universal Frequency Counter/Timer measurements from file. filename -- source file from which to retrieve data. returns: <type 'numpy.ndarray'> measurements """ data_file = open(filename, "r") line = data_file.readline() if line.strip() != "#MeasurementData:Keysight 53230A": #print("Exception: file_to_scipy_array: Not a Keysight 53230A Measurement Data file.") Exception( "file_to_scipy_array: Not a Keysight 53230A Measurement Data file." ) data_file.close() return line = data_file.readline() version = line.strip().split(":") if not (version[0] == "#version" and version[1] == "0.3"): Exception( "file_to_scipy_array: Keysight 53230A wrong version easurement Data file." ) data_file.close() return lst_measurements = [] while 1: line = data_file.readline() if len(line) == 0: break if line[:len("#date:")] == "#date:": date_in_file = line.split(":")[1].strip() if line[:len("#time:")] == "#time:": time_lst = line.split(":") time_in_file = time_lst[1].strip() + ":" + time_lst[2].strip( ) + ":" + time_lst[3].strip() # All lines starting witout a "#" contain measurements if line[:len("#")] != "#": value = scipy.float64(line.strip()) #print (type(value), value) lst_measurements.append(value) data_file.close() x_data = scipy.arange(0, len(lst_measurements), 1, dtype=scipy.float64) y_data = scipy.array(lst_measurements) measurement_data = scipy.array([x_data, y_data]) return measurement_data
def read_fcon1000_data(csv_fname, data_dir, reg_var_name='Verbal IQ', num_sub=5, reg_var_positive=1, gord=1): """ reads fcon1000 csv and data""" count1 = 0 sub_ids = [] reg_var = [] pbar = tqdm(total=num_sub) with open(csv_fname, newline='') as csvfile: creader = csv.DictReader(csvfile, delimiter=',', quotechar='"') for row in creader: # read the regression variable rvar = row[reg_var_name] if gord == 1: # Read the filtered data by default fname = os.path.join( data_dir, row['ScanDir ID'] + '_rest_bold.32k.GOrd.mat') else: fname = os.path.join( data_dir, row['ScanDir ID'] + '_rest_bold.BOrd.mat') # If the data does not exist for this subject then skip it if not os.path.isfile(fname) or int(row['QC_Rest_1']) != 1: continue if reg_var_positive == 1 and sp.float64(rvar) < 0: continue if count1 == 0: sub_data_files = [] # Truncate the data at a given number of time samples This is needed because # BrainSync needs same number of time sampples sub_data_files.append(fname) sub_ids.append(row['ScanDir ID']) reg_var.append(float(rvar)) count1 += 1 pbar.update(1) # update the progress bar #print('%d,' % count1, end='') if count1 == num_sub: break pbar.close() print('CSV file and the data has been read\nThere are %d subjects' % (len(sub_ids))) return sub_ids, sp.array(reg_var), sub_data_files
def weighted_gtv(X, y, D, l1, l3, alpha=.9): if alpha<1: n = X.shape[0] weights = np.array([alpha**(n-t) for t in np.arange(1, n+1)]) X = X * np.sqrt(weights.reshape(-1,1)) y = y * np.sqrt(weights) XD, bigY, invD = augmented_system_lasso(X, y, D, l1/l3, 0, l1_only=True) fit = glmnet(x = XD, y = bigY) b = glmnetCoef(fit, s = scipy.float64([l3]), exact = False) beta = [email protected](b.shape[0])[1:] return beta
def backward_step(self, a, t): """Return r error value for this output layer a - output of the layer (float), equals to a_(k) t - actual class (+1 or -1) """ a = s.float64(a) t = int(t) assert t in [-1, 1], "Invalid class" t_new = (1 + t) / 2 return s.array([func.sig(a) - t_new])
def glmnetSet(opts = None): import scipy # default options options = { "weights" : scipy.empty([0]), "offset" : scipy.empty([0]), "alpha" : scipy.float64(1.0), "nlambda" : scipy.int32(100), "lambda_min" : scipy.empty([0]), "lambdau" : scipy.empty([0]), "standardize" : True, "intr" : True, "thresh" : scipy.float64(1e-7), "dfmax" : scipy.empty([0]), "pmax" : scipy.empty([0]), "exclude" : scipy.empty([0], dtype = scipy.integer), "penalty_factor" : scipy.empty([0]), "cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]), "maxit" : scipy.int32(1e5), "gtype" : [], "ltype" : 'Newton', "standardize_resp" : False, "mtype" : 'ungrouped' } # quick return if no user opts if opts == None: print('pdco default options:') print(options) return options # if options are passed in by user, update options with values from opts optsInOptions = set(opts.keys()) - set(options.keys()); if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys print(optsInOptions, ' : unknown option for glmnetSet') raise ValueError('attempting to set glmnet options that are not known to glmnetSet') else: options.update(opts) # update values return options
def coo_to_csr(coo): nr_rows, nr_cols, nnz, row, col, val = \ coo.shape[0], coo.shape[1], coo.data.shape[0], coo.row, coo.col, coo.data indptr = sp.cumsum(sp.bincount(row + 1, minlength=(nr_rows + 1)), dtype=sp.uint64) indices = sp.zeros(nnz, dtype=sp.uint32) data = sp.zeros(nnz, dtype=dtype) sorted_idx = sp.argsort(row * sp.float64(nr_cols) + col) indices[:] = col[sorted_idx] data[:] = val[sorted_idx] return indptr, indices, data
def glmnetFit(self, X, y, offsets, numCodons, numGenes, varsNames, lambda_min): """ :param X: :param y: :param offsets: :param numCodons: :param numGenes: :param varsNames: :param lambda_min: :return: """ # fit the model if not lambda_min: fit = cvglmnet(x=X.copy(), y=y.copy(), family='poisson', offset=offsets, alpha=0, parallel=True, lambda_min=np.array([0])) coefs = cvglmnetCoef(fit, s=fit['lambda_min']) # lambda_min lambda_1se else: fit = glmnet(x=X.copy(), y=y.copy(), family='poisson', offset=offsets, alpha=0, lambda_min=np.array([0])) coefs = glmnetCoef(fit, s=scipy.float64([lambda_min])) # parse and scale coefficients intercept = coefs[0][0] geneBetas = pd.DataFrame([[varsNames[i-1].split("_")[1], coefs[i][0]] for i in range(1, numGenes+1)], columns=["gene", "beta"]) geneBetas["log2_TE"] = (geneBetas["beta"] - np.median(geneBetas["beta"])) / np.log(2) geneBetas.drop(["beta"], inplace=True, axis=1) codonBetas = pd.DataFrame([[varsNames[i-1].split("_")[1], coefs[i][0]] for i in range(numGenes+1, numGenes + numCodons + 1)], columns=["codon", "beta"]) codonBetas["log_codon_dwell_time"] = (codonBetas["beta"] - np.median(codonBetas["beta"])) codonBetas["codon_dwell_time"] = np.exp(codonBetas["log_codon_dwell_time"]) codonBetas.drop(["beta", "log_codon_dwell_time"], inplace=True, axis=1) downstreamSLBeta = coefs[numGenes + numCodons + 1][0] # export to local geneBetas.to_csv(path_or_buf=self.output + '/genesTE.csv', sep='\t', header=True, index=False, float_format='%.4f') codonBetas.to_csv(path_or_buf=self.output + '/codons.csv', sep='\t', header=True, index=False, float_format='%.4f') # print results if lambda_min: sys.stderr.write("[results]\tpre-defined lambda: " + str(lambda_min) + "\n") else: sys.stderr.write("[results]\tlambda that gives minimum mean cv error: " + str(fit['lambda_min']) + "\n") sys.stderr.write("[results]\tlambda 1 se away: " + str(fit['lambda_1se']) + "\n") sys.stderr.write("[results]\tintercept: " + str(intercept) + "\n") sys.stderr.write("[results]\tbetas for 2' structure windows: " + str(downstreamSLBeta) + "\n") # plot if not lambda_min: plt.figure() cvglmnetPlot(fit) plt.gcf() plt.savefig(self.output + "/" + "lambda_cv.pdf") plt.clf()
def plot_temp(self): ######## plot 3D Temperature ######## fig2 = plt.figure(figsize=plt.figaspect(0.5)) ax2 = fig2.add_subplot(1, 2, 1, projection='3d') X2 = sp.linspace(0, 5, 5) Y2 = sp.linspace(0, 5, 5) X2, Y2 = sp.meshgrid(X2, Y2) X2, Y2 = X2.ravel(), Y2.ravel() #R = sp.sqrt(X**2 + Y**2) #Z = sp.sin(R) width = depth = 1 bottom = X2 * 0 #plt.ion() p = int(entryrowplot.get()) temp_floats = sp.float64(self.data_str['temp'][p].split(";")).reshape( 5, 5) mintemp = np.min(temp_floats) mintempplot = mintemp mintemptxt = str(round(mintemp, 1)) maxtemp = np.max(temp_floats) maxtempplot = maxtemp maxi = maxtempplot - mintempplot + 0.1 top2 = temp_floats.ravel() - mintemp top_scaled2 = (top2 - sp.amin(top2)) / (sp.amax(top2) - sp.amin(top2)) mycolors = cm.jet(top_scaled2) ax2.bar3d(X2, Y2, bottom, width, depth, top2, color=mycolors, alpha=float(entryTrans.get())) ax2.set_title('Temperature' + '\n' + '@ ' + self.data_str['sumcurr'][p] + ' A' + ' // @ ' + self.data['voltage'][p] + ' V') ax2.set_zlim(0, maxi) ax2.set_zlabel('Temperature +' + mintemptxt + '°C') ax2.view_init(elev=25., azim=60) plt.show() tempplot = ts.strftime( "%Y.%m.%d. %H:%M:%S :") + "Temperature dargestellt" self.displaystate.insert(tk.END, tempplot + '\n')
def read_hess_params(hessian_file=hessian_file): f_in = open(hessian_file) for line_tmp in f_in: if 'N' in line_tmp: line = line_tmp break N = int(line_tmp.split()[1]) line = f_in.next() eps, delta = (float64(x) for x in [line.split()[1, 3]]) line = f_in.next() line = f_in.next() labels = [lab for lab in line.split() if lab!='labels' and lab!='xyz']
def convert_codes_to_csc_matrix(codes, depth): nr_codes = 1 << depth nr_elements = len(codes) indptr = sp.cumsum(sp.bincount(codes + 1, minlength=(nr_codes + 1)), dtype=sp.uint64) indices = sp.argsort(codes * sp.float64(nr_elements) + sp.arange(nr_elements)) C = smat.csc_matrix( (sp.ones_like(indices, dtype=sp.float32), indices, indptr), shape=(nr_elements, nr_codes), ) return C
def save2surfgord(lsurf, rsurf, out_dir, surf_name, bfp_path='.', save_png=True): # if label is zero, black out surface, attribute should be nan num_vert = lsurf.vertices.shape[0] lab = spio.loadmat( os.path.join(bfp_path, 'supp_data/USCBrain_grayordinate_labels.mat')) labs = lab['labels'].squeeze() labs = sp.float64(labs) lsurf.attributes[labs[:num_vert] == 0] = sp.nan rsurf.attributes[labs[num_vert:2 * num_vert] == 0] = sp.nan lsurf.vColor[sp.isnan(lsurf.attributes), :] = 0 rsurf.vColor[sp.isnan(lsurf.attributes), :] = 0 writedfs(out_dir + '/Right_' + surf_name + '.dfs', rsurf) writedfs(out_dir + '/Left_' + surf_name + '.dfs', lsurf) if VTK_INSTALLED == 0: print('VTK is not installed, screenshots will not be saved.') save_png = False if save_png == True: # Visualize left hemisphere view_patch_vtk(lsurf, azimuth=100, elevation=180, roll=90, outfile=out_dir + '/LeftLateral_' + surf_name + '.png', show=0) view_patch_vtk(lsurf, azimuth=-100, elevation=180, roll=-90, outfile=out_dir + '/LeftMedial_' + surf_name + '.png', show=0) # Visualize right hemisphere view_patch_vtk(rsurf, azimuth=-100, elevation=180, roll=-90, outfile=out_dir + '/RightLateral_' + surf_name + '.png', show=0) view_patch_vtk(rsurf, azimuth=100, elevation=180, roll=90, outfile=out_dir + '/RightMedial_' + surf_name + '.png', show=0)
def calcCDFs(sampleList,binEdges): """ Example: dataEKI = getCSVData(csvFiles['EKI']) bMeasures = calcBurstMeasures(dataEKI) cdfs =calcCDFs(sampleList=bMeasures['burstDur'],binEdges=bins['burstDur']) """ nSamples=len(sampleList) nBinPts = len(binEdges) cdfs=list() for n in range(nSamples): nPts=sc.float64(len(sampleList[n])) cdfs.append(sc.zeros(nBinPts)) for m in range(0,nBinPts): samp=sampleList[n] cdfs[n][m] = len(sc.where(samp<=binEdges[m])[0])/nPts return sc.array(cdfs)
print "P_{} = {} a. u.".format(ii/2, Pm[-1]) backup(backup_suf='{}mbackup'.format(ii)) restore() return Pm,dPm,d2Pm/(field**2) def backup(calc_files=calc_files, backup_suf='.backup0'): for filename in calc_files: sp.call("cp -r {0} {0}{1}".format(filename, backup_suf), shell=True) def restore(calc_files=calc_files, backup_suf='.backup0'): for filename in calc_files: sp.call("cp -r {0}{1} {0}".format(filename, backup_suf), shell=True) charge = float64(sys.argv[1]) atom_type = sys.argv[2] grd_obj = Grads(excls, coord_pat, control) de = grd_obj.flatten_grads() print "E0 = {}".format(grd_obj.en) px,dpx,d2px = eval_dipole(charge) f = open(dipole_txt, 'w') f.write('#p\n') sc.savetxt(f, px) for ii,dpi in enumerate(dpx): f.write('#dp {}\n'.format(ii)) sc.savetxt(f, dpi) f.write('#d2p\n') sc.savetxt(f, d2px)
from standard_config import * import subprocess as sp excls = 'zz3 zz4'.split() node_dir_prefix = 'node' srun_command = 'srun -N1 -n1' hessian_file = 'HESS.DAT' omega_file = 'OMEGA.DAT.scipy' eps = 1e-1 ncol = 5 srun_command +=' '# number_of_nodes = int(sys.argv[1]) eps = float64(sys.argv[2]) calc_files = [coord, control, realmos, imagmos, basis, embedding] class Node(object): IDLE, RUN = range(2) def __init__(self,node_dir, calc_files): self.calc_files = calc_files[:] self.node_dir = node_dir sp.call("mkdir {}".format(node_dir), shell=True) for x in calc_files: sp.call("cp {0} {1}/{0}".format(x, node_dir), shell=True) self.process = None self.occupied = None self.status = Node.IDLE
def normalize(self, data): return scipy.float64(data)/255 - 0.5
def set_boundary_conditions(self, bctype='', bcvalue=None, pores=None, throats=None, mode='merge'): r""" Apply boundary conditions to specified pores or throats Parameters ---------- bctype : string Specifies the type or the name of boundary condition to apply. \ The types can be one one of the followings: - 'Dirichlet' : Specify the quantity in each location - 'Neumann' : Specify the flow rate into each location - 'Neumann_group' : Specify the net flow rate into a group of pores/throats component : OpenPNM Phase object The Phase object to which this BC applies bcvalue : array_like The boundary value to apply, such as concentration or rate pores : array_like The pores where the boundary conditions should be applied throats : array_like The throats where the boundary conditions should be applied mode : string, optional Controls how the conditions are applied. Options are: - 'merge': Inserts the specified values, leaving existing values \ elsewhere - 'overwrite': Inserts specified values, clearing all other \ values for that specific bctype - 'remove': Removes boundary conditions from specified locations Notes ----- - It is not possible to have multiple boundary conditions for a specified location in just one algorithm. So when new condition is going to be applied to a specific location, any existing one should be removed or overwritten. - BCs for pores and for throats should be applied independently. """ try: self._existing_BC except AttributeError: self._existing_BC = [] if sp.size(self._phases) != 1: raise Exception('In each use of set_boundary_conditions ' + 'method, one component should be specified ' + 'or attached to the algorithm.') else: component = self._phases[0] if mode not in ['merge', 'overwrite', 'remove']: raise Exception('The mode (' + mode + ') cannot be applied to ' + 'the set_boundary_conditions!') logger.debug('BC method applies to the component: ' + component.name) # Validate bctype if bctype == '': raise Exception('bctype must be specified!') # If mode is 'remove', also bypass checks if mode == 'remove': if pores is None and throats is None: for item in self.labels(): if bctype == item.split('.')[-1]: element = item.split('.')[0] try: del self[element + '.' + 'bcval_' + bctype] except KeyError: pass try: del self[element + '.' + bctype] except KeyError: pass logger.debug('Removing ' + bctype + ' from all locations' + ' for ' + component.name + ' in ' + self.name) self._existing_BC.remove(bctype) else: if pores is not None: prop_label = 'pore.' + 'bcval_' + bctype self[prop_label][pores] = sp.nan info_label = 'pore.' + bctype self[info_label][pores] = False logger.debug('Removing ' + bctype + ' from the ' + 'specified pores for ' + component.name + ' in ' + self.name) if throats is not None: prop_label = 'throat.' + 'bcval_' + bctype self[prop_label][throats] = sp.nan info_label = 'throat.' + bctype self[info_label][throats] = False logger.debug('Removing ' + bctype + ' from the ' + 'specified throats for ' + component.name + ' in ' + self.name) return # Validate pores/throats if pores is None and throats is None: raise Exception('pores/throats must be specified') elif pores is not None and throats is not None: raise Exception('BC for pores and throats must be specified ' + 'independently.') elif throats is None: element = 'pore' loc = sp.array(pores, ndmin=1) all_length = self.Np elif pores is None: element = 'throat' loc = sp.array(throats, ndmin=1) all_length = self.Nt else: raise Exception('Problem with the pore and/or throat list') # Validate bcvalue if bcvalue is not None: # Check bcvalues are compatible with bctypes if bctype == 'Neumann_group': # Only scalars are acceptable if sp.size(bcvalue) != 1: raise Exception('When specifying Neumann_group, bcval ' + 'should be a scalar') else: bcvalue = sp.float64(bcvalue) if 'Neumann_group' not in self._existing_BC: setattr(self, '_' + element + '_Neumann_group_location', []) getattr(self, '_' + element + '_Neumann_group_location').append(loc) else: # Only scalars or Np/Nt-long are acceptable if sp.size(bcvalue) == 1: bcvalue = sp.ones(sp.shape(loc)) * bcvalue elif sp.size(bcvalue) != sp.size(loc): raise Exception('The pore/throat list and bcvalue list ' + 'are different lengths') # Confirm that prop and label arrays exist l_prop = element + '.' + 'bcval_' + bctype if l_prop not in self.props(): self[l_prop] = sp.ones((all_length,), dtype=float) * sp.nan l_label = element + '.' + bctype if l_label not in self.labels(): self[l_label] = sp.zeros((all_length,), dtype=bool) # Check all BC from specified locations, prior to setting new ones for item in self.labels(): bcname = item.split('.')[-1] if bcname in self._existing_BC and item.split('.')[0] == element: if mode in ['merge', 'overwrite']: try: c1 = element c2 = 'bcval_' + bcname c1_label = c1 + c2 self[c1_label][loc] condition1 = sp.isnan(self[c1_label][loc]).all() c2_label = c1 + '_' + bcname condition2 = sp.sum(self[c2_label][loc]) == 0 if not (condition1 and condition2): if mode == 'merge': raise Exception('Because of the existing ' + 'BCs, the method cannot ' + 'apply new BC with the merge' + ' mode to the specified pore' + '/throat.') elif (mode == 'overwrite' and bcname != bctype): raise Exception('Because of the existing ' + 'BCs, the method cannot ' + 'apply new BC with overwrite' + ' mode. This mode only ' + 'overwrites this bctype, ' + 'not the other ones.') except KeyError: pass # Set boundary conditions based on supplied mode if mode == 'merge': if bcvalue is not None: self[l_prop][loc] = bcvalue self[l_label][loc] = True if bctype not in self._existing_BC: self._existing_BC.append(bctype) elif mode == 'overwrite': self[l_prop] = sp.ones((all_length,), dtype=float) * sp.nan if bcvalue is not None: self[l_prop][loc] = bcvalue self[l_label] = sp.zeros((all_length,), dtype=bool) self[l_label][loc] = True if bctype not in self._existing_BC: self._existing_BC.append(bctype)
def _Go_Button_fired(self): # Transform the internal dict holding the model to a Pandas dataframe # that the lmfit wrapper will digest: tofit = pd.DataFrame.from_dict(self.Components).T print tofit print tofit.index tofit.columns = ['Pos', 'Sigma', 'Ampl', 'Identifier'] tofit['Line center'] = self.line_center tofit.set_value('Contin', 'Lock', self.LockConti) for lines in self.Components.keys(): if lines == 'Contin': continue tofit.set_value(lines, 'Lock', self.Locks[lines][:3]) print self.Components print tofit # Make sure no dataarrays belonging to the parent class are altered. x = self.x.copy() data = self.indata.copy() errs = self.errs.copy() # If fitranges set, use them, otherwise use all data. fitrange = [] if len(self.fitrange) == 0: self.fitrange = [(self.line_center - 15, self.line_center + 15)] print 'Fitrange 1: ', fitrange if len(self.fitrange) > 0: for ran in self.fitrange: print 'Ran', ran rmin, rmax = ran[0], ran[1] fitrange += sp.where((self.x > rmin) & (self.x < rmax)) fitrange = sp.hstack(fitrange[:]) fitrange.sort() x = x[fitrange] data = data[fitrange] errs = errs[fitrange] try: import lmfit_wrapper as lw except ImportError: print 'Could not import LMfit' return params = lw.load_params(tofit) result = lw.fit_it( #lw.build_model, params, args=(self.x[fitrange], self.indata[fitrange], self.errs[fitrange])) output = lw.params_to_grism(params, output_format='df') print output print tofit output['Identifier'] = tofit['Identifier'] print output output.set_value('Contin', 'Identifier', sp.float64('nan')) output['Pos'] -= tofit['Line center'] print output outdict = {} for i in output.index: row = output.ix[i] if i == 'Contin': outdict[i] = row['Ampl'] else: outdict[i] = [row['Pos'], row['Sigma'], \ row['Ampl'], row['Identifier']] self.Components = outdict self.import_model() return result
def set_boundary_conditions(self,component=None,bctype='',bcvalue=None,pores=None,throats=None,mode='merge'): r''' Apply boundary conditions to specified pores or throats Parameters ---------- bctype : string Specifies the type or the name of boundary condition to apply. The types can be one one of the followings: - 'Dirichlet' : Specify the quantity in each location - 'Neumann' : Specify the flow rate into each location - 'Neumann_group' : Specify the net flow rate into a group of pores/throats component : OpenPNM Phase object The Phase object to which this BC applies bcvalue : array_like The boundary value to apply, such as concentration or rate pores : array_like The pores where the boundary conditions should be applied throats : array_like The throats where the boundary conditions should be applied mode : string, optional Controls how the conditions are applied. Options are: - 'merge': Inserts the specified values, leaving existing values elsewhere - 'overwrite': Inserts specified values, clearing all other values - 'remove': Removes boundary conditions from specified locations Notes ----- 1. It is not possible to have multiple boundary conditions for a specified location in just one algorithm. So when new condition is going to be applied to a specific location, any existing one should be removed or overwritten. 2- BCs for pores and for throats should be applied independently. ''' try: self._existing_BC except: self._existing_BC = [] if component is None: if sp.size(self._phases)!=1: raise Exception('In each use of set_boundary_conditions method, one component should be specified or attached to the algorithm.' ) else: component = self._phases[0] else: if sp.size(component)!=1: raise Exception('For using set_boundary_conditions method, only one component should be specified.') if mode not in ['merge','overwrite','remove']: raise Exception('The mode ('+mode+') cannot be applied to the set_boundary_conditions!') logger.debug('BC applies to the component: '+component.name) #If mode is 'remove', also bypass checks if mode == 'remove': if pores is None and throats is None: if bctype=='': raise Exception('No bctype/pore/throat is specified') else: for item in self.labels(): if bctype == (item.split('.')[-1]).replace(self._phase.name+'_',"") : element = item.split('.')[0] try: del self[element+'.'+component.name+'_bcval_'+bctype] except: pass try: del self[element+'.'+component.name+'_'+bctype] except: pass logger.debug('Removing '+bctype+' from all locations for '+component.name+' in '+self.name) self._existing_BC.remove(bctype) else: if pores is not None: if bctype!='': self['pore.'+component.name+'_bcval_'+bctype][pores] = sp.nan self['pore.'+component.name+'_'+bctype][pores] = False logger.debug('Removing '+bctype+' from the specified pores for '+component.name+' in '+self.name) else: raise Exception('Cannot remove BC from the pores unless bctype is specified') if throats is not None: if bctype!='': self['throat.'+component.name+'_bcval_'+bctype][throats] = sp.nan self['throat.'+component.name+'_'+bctype][throats] = False logger.debug('Removing '+bctype+' from the specified throats for '+component.name+' in '+self.name) else: raise Exception('Cannot remove BC from the throats unless bctype is specified') return #Validate bctype if bctype == '': raise Exception('bctype must be specified') #Validate pores/throats if pores is None and throats is None: raise Exception('pores/throats must be specified') elif pores is not None and throats is not None: raise Exception('BC for pores and throats must be specified independently') elif throats is None: element ='pore' loc = sp.array(pores,ndmin=1) all_length = self.num_pores() elif pores is None: element ='throat' loc = sp.array(throats,ndmin=1) all_length = self.num_throats() else: raise Exception('Problem with the pore and/or throat list') #Validate bcvalue if bcvalue is not None: #Check bcvalues are compatible with bctypes if bctype == 'Neumann_group': #Only scalars are acceptable if sp.size(bcvalue) != 1: raise Exception('When specifying Neumann_group, bcval should be a scalar') else: bcvalue = sp.float64(bcvalue) if 'Neumann_group' not in self._existing_BC: setattr(self,'_'+element+'_'+component.name+'_Neumann_group_location',[]) getattr(self,'_'+element+'_'+component.name+'_Neumann_group_location').append(loc) else: #Only scalars or Np/Nt-long are acceptable if sp.size(bcvalue) == 1: bcvalue = sp.ones(sp.shape(loc))*bcvalue elif sp.size(bcvalue) != sp.size(loc): raise Exception('The pore/throat list and bcvalue list are different lengths') #Confirm that prop and label arrays exist if element+'.'+component.name+'_bcval_'+bctype not in self.props(): self[element+'.'+component.name+'_bcval_'+bctype] = sp.ones((all_length,),dtype=float)*sp.nan if element+'.'+component.name+'_'+bctype not in self.labels(): self[element+'.'+component.name+'_'+bctype] = sp.zeros((all_length,),dtype=bool) #Check all BC from specified locations, prior to setting new ones for item in self.labels(): bcname = (item.split('.')[-1]).replace(component.name+'_',"") if bcname in self._existing_BC and item.split('.')[0]==element: if mode=='merge': try: self[element+'.'+component.name+'_bcval_'+bcname][loc] if not (sp.isnan(self[element+'.'+component.name+'_bcval_'+bcname][loc]).all() and sp.sum(self[element+'.'+component.name+'_'+bcname][loc])==0): raise Exception('Because of the existing BCs, the method cannot apply new BC with the merge mode to the specified pore/throat.') except KeyError: pass #Set boundary conditions based on supplied mode if mode == 'merge': if bcvalue is not None: self[element+'.'+component.name+'_bcval_'+bctype][loc] = bcvalue self[element+'.'+component.name+'_'+bctype][loc] = True if bctype not in self._existing_BC: self._existing_BC.append(bctype) elif mode == 'overwrite': self[element+'.'+component.name+'_bcval_'+bctype] = sp.ones((all_length,),dtype=float)*sp.nan if bcvalue is not None: self[element+'.'+component.name+'_bcval_'+bctype][loc] = bcvalue self[element+'.'+component.name+'_'+bctype] = sp.zeros((all_length,),dtype=bool) self[element+'.'+component.name+'_'+bctype][loc] = True if bctype not in self._existing_BC: self._existing_BC.append(bctype)